diffpy.srfit 3.1.0__py3-none-any.whl

diffpy/srfit/structure/srrealparset.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2009 The Trustees of Columbia University
+#                   in the City of New York.  All rights reserved.
+#
+# File coded by:    Chris Farrow
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+"""Structure wrapper class for structures compatible with SrReal."""
+
+__all__ = ["SrRealParSet"]
+
+from diffpy.srfit.structure.basestructureparset import BaseStructureParSet
+from diffpy.srfit.structure.bvsrestraint import BVSRestraint
+
+
+class SrRealParSet(BaseStructureParSet):
+    """Base class for SrReal-compatible structure adapters.
+
+    This derives from BaseStructureParSet and provides some extended
+    functionality provided by SrReal.
+
+    Attributes:
+    stru            --  The adapted object
+    _usesymmetry    --  A flag indicating if SrReal calculators that operate on
+                        this object should use symmetry. By default this is
+                        True.
+    """
+
+    def __init__(self, *args, **kw):
+        BaseStructureParSet.__init__(self, *args, **kw)
+        self._usesymmetry = True
+        self.stru = None
+        return
+
+    def restrainBVS(self, sig=1, scaled=False):
+        """Restrain the bond-valence sum to zero.
+
+        This adds a penalty to the cost function equal to
+        bvmsdiff / sig**2
+        where bvmsdiff is the mean-squared difference between the calculated
+        and expected bond valence sums for the structure. If scaled is True,
+        this is also scaled by the current point-averaged chi^2 value so the
+        restraint is roughly equally weighted in the fit.
+
+        sig     --  The uncertainty on the BVS (default 1).
+        scaled  --  A flag indicating if the restraint is scaled
+                    (multiplied) by the unrestrained point-average chi^2
+                    (chi^2/numpoints) (default False).
+
+        Returns the BVSRestraint object for use with the 'unrestrain' method.
+        """
+
+        # Create the Restraint object
+        res = BVSRestraint(self, sig, scaled)
+        # Add it to the _restraints set
+        self._restraints.add(res)
+        # Our configuration changed. Notify observers.
+        self._updateConfiguration()
+        # Return the Restraint object
+        return res
+
+    def useSymmetry(self, use=True):
+        """Set this structure to use symmetry.
+
+        This determines how the structure is treated by SrReal
+        calculators.
+        """
+        self._usesymmetry = bool(use)
+        return
+
+    def usingSymmetry(self):
+        """Check if symmetry is being used."""
+        return self._usesymmetry
+
+    def _getSrRealStructure(self):
+        """Get the structure object for use with SrReal calculators.
+
+        If this is periodic, then return the structure, otherwise, pass
+        it inside of a nosymmetry wrapper.
+        """
+        from diffpy.srreal.structureadapter import nosymmetry
+
+        if self._usesymmetry:
+            return self.stru
+        return nosymmetry(self.stru)

diffpy/srfit/util/__init__.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2008 The Trustees of Columbia University
+#                   in the City of New York.  All rights reserved.
+#
+# File coded by:    Chris Farrow
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+"""Utilities and constants used throughout SrFit."""
+
+_DASHEDLINE = 78 * "-"
+
+
+def sortKeyForNumericString(s):
+    """Compute key for sorting strings according to their integer numeric
+    value.
+
+    Each string gets split to string and integer segments to create keys
+    for comparison.  Signs, decimal points and exponents are ignored.
+    This function is intended as the ``key`` argument for the ``sorted``
+    or ``list.sort`` function.
+
+    Parameters
+    ----------
+    s : str
+        String which may have numeric components, e.g., "a12b".
+
+    Returns
+    -------
+    tuple
+        Tuple of non-numeric segments intermixed with integer values.
+    """
+    if sortKeyForNumericString._rx is None:
+        import re
+
+        sortKeyForNumericString._rx = re.compile(r"(\d+)")
+    rx = sortKeyForNumericString._rx
+    rv = tuple((int(w) if i % 2 else w) for i, w in enumerate(rx.split(s)))
+    return rv
+
+
+sortKeyForNumericString._rx = None
+
+# End of file

diffpy/srfit/util/argbinders.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      Complex Modeling Initiative
+#                   (c) 2014 Brookhaven Science Associates,
+#                   Brookhaven National Laboratory.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE.txt for license information.
+#
+##############################################################################
+"""Functions for binding arguments of callable objects."""
+
+
+class bind2nd(object):
+    """Freeze second argument of a callable object to a given constant."""
+
+    def __init__(self, func, arg1):
+        """Freeze the second argument of function func to arg1."""
+        self.func = func
+        self.arg1 = arg1
+        return
+
+    def __call__(self, *args, **kwargs):
+        boundargs = (args[0], self.arg1) + args[1:]
+        return self.func(*boundargs, **kwargs)

diffpy/srfit/util/inpututils.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2010 The Trustees of Columbia University
+#                   in the City of New York.  All rights reserved.
+#
+# File coded by:    Chris Farrow
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+"""Input utilities."""
+
+__all__ = ["inputToString"]
+
+import os.path
+
+
+def inputToString(input):
+    """Convert input from various modes to a string.
+
+    This is useful when you want a method to accept a string, open file object
+    or file name.
+
+    input    --  An open file-like object, name of a file
+                or a string containing the input.
+
+    Returns the input in a string
+    Raises IOError if the input is supected to be a file name, but the file
+    cannot be found.
+    """
+    # Get the input into a string
+    inptstr = ""
+    if hasattr(input, "read"):
+        inptstr = input.read()
+    # TODO remove handling of string input accept only file or filename
+    # FIXME check for typos in the file name
+    elif os.path.exists(input) or (len(input) < 80 and input.count("\n") == 0):
+        with open(input, "r") as infile:
+            inptstr = infile.read()
+    else:
+        inptstr = input
+
+    return inptstr
+
+
+# End of file

diffpy/srfit/util/nameutils.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2008 The Trustees of Columbia University
+#                   in the City of New York.  All rights reserved.
+#
+# File coded by:    Chris Farrow
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+"""Name utilities."""
+
+__all__ = ["isIdentifier", "validateName"]
+
+import re
+
+reident = re.compile(r"^[a-zA-Z_]\w*$")
+
+
+def isIdentifier(s):
+    """Check to see if a python string is a valid identifier.
+
+    From http://code.activestate.com/recipes/413487/
+    """
+    if reident.match(s) is None:
+        return False
+    return True
+
+
+def validateName(name):
+    """Validate that a name is a valid identifier.
+
+    Raises ValueError if the name is invalid.
+    """
+    # Check that the name is valid
+    if not isIdentifier(name):
+        raise ValueError(f"Name {name} is not a valid identifier")
+    return
+
+
+# End of file

diffpy/srfit/util/observable.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+#
+#                             michael a.g. aïvázis
+#                                  orthologue
+#                      (c) 1998-2009  all rights reserved
+#
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Derived from pyre-1.0/packages/pyre/patterns/Observable.py
+# See pyre-1.0 for full copyright and license information
+
+__all__ = ["Observable"]
+
+
+from diffpy.srfit.util.weakrefcallable import weak_ref
+
+
+class Observable(object):
+    """Provide notification support for classes that maintain dynamic
+    associations with multiple clients.
+
+    Observers, i.e. clients of the observable, register event handlers
+    that will be invoked to notify them whenever something interesting
+    happens to the observable. The nature of what is being observed is
+    defined by Observable descendants and their managers. For example,
+    instances of pyre.calc.Node are observable by other nodes whose
+    value depends on them so that the dependents can be notified about
+    value changes and forced to recompute their own value.
+
+    The event handlers are callables that take the observable instance
+    as their single argument.
+
+    interface:
+      addObserver: registers its callable argument with the list of
+      handlers to invoke removeObserver: remove an event handler from
+      the list of handlers to invoke notify: invoke the registered
+      handlers in the order in which they were registered
+    """
+
+    def notify(self, other=()):
+        """Notify all observers."""
+        # build a list before notification, just in case the observer's
+        # callback behavior involves removing itself from our callback set
+        semaphores = (self,) + other
+        for callable in tuple(self._observers):
+            callable(semaphores)
+        return
+
+    # callback management
+
+    def addObserver(self, callable):
+        """Add callable to the set of observers."""
+        f = weak_ref(callable, fallback=_fbRemoveObserver)
+        self._observers.add(f)
+        return
+
+    def removeObserver(self, callable):
+        """Remove callable from the set of observers."""
+        f = weak_ref(callable)
+        self._observers.remove(f)
+        return
+
+    def hasObserver(self, callable):
+        """True if `callable` is present in the set of observers."""
+        f = weak_ref(callable)
+        rv = f in self._observers
+        return rv
+
+    # meta methods
+
+    def __init__(self, **kwds):
+        super(Observable, self).__init__(**kwds)
+        self._observers = set()
+        return
+
+
+# end of class Observable
+
+# Local helpers --------------------------------------------------------------
+
+
+def _fbRemoveObserver(fobs, semaphores):
+    # Remove WeakBoundMethod `fobs` from the observers of notifying object.
+    # This is called from Observable.notify when the WeakBoundMethod
+    # associated object dies.
+    observable = semaphores[0]
+    observable.removeObserver(fobs)
+    return
+
+
+# end of file

diffpy/srfit/util/tagmanager.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2008 The Trustees of Columbia University
+#                   in the City of New York.  All rights reserved.
+#
+# File coded by:    Chris Farrow
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+"""TagManager class.
+
+The TagManager class takes hashable objects and assigns tags to them.
+Objects can then be easily referenced via their assigned tags.
+"""
+
+__all__ = ["TagManager"]
+
+import functools
+
+
+class TagManager(object):
+    """TagManager class.
+
+    Manage tags on hashable objects. Tags are strings that carry metadata.
+
+    silent          --  Flag indicating whether to silently pass by when a tag
+                        cannot be found (bool, True). If this is False, then a
+                        KeyError will be thrown when a tag cannot be found.
+    _tagdict        --  A dictionary of tags to sets of tagged objects.
+    """
+
+    def __init__(self):
+        """Initialization."""
+        self._tagdict = {}
+        self.silent = True
+        return
+
+    def alltags(self):
+        """Get all tags managed by the TagManager."""
+        return self._tagdict.keys()
+
+    def tag(self, obj, *tags):
+        """Tag an object.
+
+        Tags are stored as strings.
+
+        obj     --  Any hashable object to be untagged.
+        *tags   --  Tags to apply to obj.
+
+        Raises TypeError if obj is not hashable.
+        """
+        for tag in tags:
+            oset = self._tagdict.setdefault(str(tag), set())
+            oset.add(obj)
+        return
+
+    def untag(self, obj, *tags):
+        """Remove tags from an object.
+
+        obj     --  Any hashable object to be untagged.
+        *tags   --  Tags to remove from obj. If this is empty, then all
+                    tags will be removed from obj.
+
+        Raises KeyError if a passed tag does not apply to obj and self.silent
+        is False
+        """
+        if not tags:
+            tags = self.tags(obj)
+
+        for tag in tags:
+            oset = self.__getObjectSet(tag)
+            if obj not in oset and not self.silent:
+                raise KeyError("Tag '%s' does not apply" % tag)
+            oset.discard(obj)
+
+        return
+
+    def tags(self, obj):
+        """Get all tags on an object.
+
+        Returns list
+        """
+        tags = [k for (k, v) in self._tagdict.items() if obj in v]
+        return tags
+
+    def hasTags(self, obj, *tags):
+        """Determine if an object has all passed tags.
+
+        Returns bool
+        """
+        setgen = (self.__getObjectSet(t) for t in tags)
+        result = all(obj in s for s in setgen)
+        return result
+
+    def union(self, *tags):
+        """Get all objects that have any of the passed tags.
+
+        Returns set
+        """
+        if not tags:
+            return set()
+        setgen = (self.__getObjectSet(t) for t in tags)
+        objs = functools.reduce(set.union, setgen)
+        return objs
+
+    def intersection(self, *tags):
+        """Get all objects that have all of the passed tags.
+
+        Returns set
+        """
+        if not tags:
+            return set()
+        setgen = (self.__getObjectSet(t) for t in tags)
+        objs = functools.reduce(set.intersection, setgen)
+        return objs
+
+    def verifyTags(self, *tags):
+        """Check that tags are all extant.
+
+        Raises KeyError if a passed tag does not exist. This ignores
+        self.silent.
+        """
+        keys = self._tagdict.keys()
+        for tag in tags:
+            if tag not in keys:
+                raise KeyError("Tag '%s' does not exist" % tag)
+        return True
+
+    def __getObjectSet(self, tag):
+        """Helper function for getting an object set with given tag.
+
+        Raises KeyError if a passed tag does not exist and self.silent
+        is False
+        """
+        oset = self._tagdict.get(str(tag))
+        if oset is None:
+            if not self.silent:
+                raise KeyError("Tag '%s' does not exist" % tag)
+            oset = set()
+        return oset
+
+
+# End class TagManager
+
+# End of file

diffpy/srfit/util/weakrefcallable.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      Complex Modeling Initiative
+#                   (c) 2016 Brookhaven Science Associates,
+#                   Brookhaven National Laboratory.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE.txt for license information.
+#
+##############################################################################
+"""Picklable storage of callable objects using weak references."""
+
+
+import types
+import weakref
+
+import six
+
+
+class WeakBoundMethod(object):
+    """Callable wrapper to a bound method stored as a weak reference.
+
+    Support storage of bound methods without keeping the associated objects
+    alive forever.  Provide facility for a fallback function to be used
+    when method-related object is deleted.
+
+    Attributes
+    ----------
+    function : MethodType
+        the unbound function extracted from the wrapped bound method.
+    fallback : FunctionType, optional
+        plain function to be called when object holding the bound method
+        gets deallocated.  The fallback function is called with this
+        object as the first argument followed by any positional and
+        keyword arguments passed for the bound method.  The fallback
+        function can be used to deregister this wrapper.
+    _wref : weakref
+        weak reference to the object the wrapped method is bound to.
+    _class : type
+        the type of the object to which the method is bound.
+        This is only used for pickling.
+    """
+
+    __slots__ = ("function", "fallback", "_wref", "_class")
+
+    def __init__(self, f, fallback=None):
+        """Create a weak reference wrapper to bound method.
+
+        Parameters
+        ----------
+        f : bound MethodType
+            instance-bound method to be wrapped.
+        fallback : FunctionType, optional
+            plain function to be called instead of the bound method when
+            the method associated object gets deallocated.
+        """
+        # This does not handle builtin methods, but that can be added
+        # if necessary.
+        self.function = f.__func__
+        if six.PY2:
+            self.function = f.__func__.__get__(None, f.im_class)
+        self.fallback = fallback
+        self._class = type(f.__self__)
+        self._wref = weakref.ref(f.__self__)
+        return
+
+    def __call__(self, *args, **kwargs):
+        """Call the wrapped method if the weak-referenced object is alive.
+
+        If that object does not exist and the fallback function is defined,
+        call the fallback function instead.
+
+        Parameters
+        ----------
+        *args, **kwargs
+            same arguments as for the wrapped bound method.
+
+        Raises
+        ------
+        ReferenceError
+            when the method-bound object does not exist and the fallback
+            function is not defined.
+        """
+        mobj = self._wref()
+        if mobj is not None:
+            return self.function(mobj, *args, **kwargs)
+        if self.fallback is not None:
+            return self.fallback(self, *args, **kwargs)
+        emsg = "Object bound to {} does not exist.".format(self.function)
+        raise ReferenceError(emsg)
+
+    # support use of this class in hashed collections
+
+    def __hash__(self):
+        return hash((self.function, self._wref))
+
+    def __eq__(self, other):
+        rv = self.function == other.function and (
+            self._wref == other._wref or None is self._wref() is other._wref()
+        )
+        return rv
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    # support pickling of this type
+
+    def __getstate__(self):
+        """Return state with a resolved weak reference."""
+        mobj = self._wref()
+        nm = self.function.__name__
+        amsg = "Unable to pickle this unbound function by name."
+        if six.PY2:
+            assert self.function == getattr(self._class, nm), amsg
+        if six.PY3:
+            assert self.function is getattr(self._class, nm), amsg
+        state = (self._class, nm, self.fallback, mobj)
+        return state
+
+    def __setstate__(self, state):
+        """Restore the weak reference in this wrapper upon unpickling."""
+        (self._class, nm, self.fallback, mobj) = state
+        self.function = getattr(self._class, nm)
+        if mobj is None:
+            # use a fake weak reference that mimics deallocated object.
+            self._wref = self.__mimic_empty_ref
+            return
+        # Here the referred object exists.
+        self._wref = weakref.ref(mobj)
+        return
+
+    @staticmethod
+    def __mimic_empty_ref():
+        return None
+
+
+# end of class WeakBoundMethod
+
+
+def weak_ref(f, fallback=None):
+    """Create weak-reference wrapper to a bound method.
+
+    Parameters
+    ----------
+    f : callable
+        object-bound method or a plain function.
+    fallback : FunctionType, optional
+        plain function to be called when object holding ``f`` gets
+        deallocated.  The fallback function is called with the
+        wrapper object as the first argument followed by positional
+        and keyword arguments passed for the bound method.  The
+        fallback function can be used to deregister the wrapper.
+
+    Returns
+    -------
+    WeakBoundMethod
+        when `f` is a bound method.  If `f` is a plain function or
+        already of WeakBoundMethod type, return `f` and ignore the
+        `fallback` argument.
+    """
+    # NOTE Weak referencing plain functions is probably not needed,
+    # because they are already bound to the defining modules.
+    rv = f
+    if isinstance(f, (types.MethodType, types.BuiltinMethodType)):
+        rv = WeakBoundMethod(f, fallback=fallback)
+    return rv