diffpy.srfit 3.1.0__py3-none-any.whl

diffpy/srfit/fitbase/restraint.py

@@ -0,0 +1,117 @@
+#!/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.
+#
+##############################################################################
+"""Restraints class.
+
+Restraints are used by RecipeOrganizers to organize restraint equations.
+Restraints store an Equation, bounds on its value, and the form of the
+penalty function for breaking a restraint. This penalty is added to the
+residual equation calculated by a FitRecipe.
+"""
+
+__all__ = ["Restraint"]
+
+from numpy import inf
+
+from diffpy.srfit.exceptions import SrFitError
+from diffpy.srfit.fitbase.validatable import Validatable
+
+
+class Restraint(Validatable):
+    """Restraint class.
+
+    Attributes
+    eq      --  An equation whose evaluation is compared against the restraint
+                bounds.
+    lb      --  The lower bound on the restraint evaluation (default -inf).
+    ub      --  The lower bound on the restraint evaluation (default inf).
+    sig     --  The uncertainty on the bounds (default 1).
+    scaled  --  A flag indicating if the restraint is scaled (multiplied) by
+                the unrestrained point-average chi^2 (chi^2/numpoints)
+                (default False).
+
+    The penalty is calculated as
+    (max(0, lb - val, val - ub)/sig)**2
+    and val is the value of the calculated equation.  This is multiplied by the
+    average chi^2 if scaled is True.
+    """
+
+    def __init__(self, eq, lb=-inf, ub=inf, sig=1, scaled=False):
+        """Restrain an equation to specified bounds.
+
+        eq      --  An equation whose evaluation is compared against the
+                    restraint bounds.
+        lb      --  The lower bound on the restraint evaluation (float, default
+                    -inf).
+        ub      --  The lower bound on the restraint evaluation (float, default
+                    inf).
+        sig     --  The uncertainty on the bounds (default 1).
+        scaled  --  A flag indicating if the restraint is scaled (multiplied)
+                    by the unrestrained point-average chi^2 (chi^2/numpoints)
+                    (bool, default False).
+        """
+        self.eq = eq
+        self.lb = float(lb)
+        self.ub = float(ub)
+        self.sig = float(sig)
+        self.scaled = bool(scaled)
+        return
+
+    def penalty(self, w=1.0):
+        """Calculate the penalty of the restraint.
+
+        w   --  The point-average chi^2 which is optionally used to scale the
+                penalty (default 1.0).
+
+        Returns the penalty as a float
+        """
+        val = self.eq()
+        penalty = (max(0, self.lb - val, val - self.ub) / self.sig) ** 2
+
+        if self.scaled:
+            penalty *= w
+
+        return penalty
+
+    def _validate(self):
+        """Validate my state.
+
+        This validates eq.
+
+        Raises SrFitError if validation fails.
+        """
+        if self.eq is None:
+            raise SrFitError("eq is None")
+        from diffpy.srfit.equation.visitors import validate
+
+        try:
+            validate(self.eq)
+        except ValueError as e:
+            raise SrFitError(e)
+
+        # Try to get the value of eq.
+        try:
+            val = self.eq()
+        except TypeError:
+            raise SrFitError("eq cannot be evaluated")
+        finally:
+            if val is None:
+                raise SrFitError("eq evaluates to None")
+
+        return
+
+
+# End class Restraint
+
+# End of file

diffpy/srfit/fitbase/simplerecipe.py

@@ -0,0 +1,230 @@
+#!/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.
+#
+##############################################################################
+"""Simple FitRecipe class that includes a FitContribution and Profile."""
+
+from diffpy.srfit.fitbase.fitcontribution import FitContribution
+from diffpy.srfit.fitbase.fitrecipe import FitRecipe
+from diffpy.srfit.fitbase.fitresults import FitResults
+from diffpy.srfit.fitbase.profile import Profile
+
+
+class SimpleRecipe(FitRecipe):
+    """SimpleRecipe class.
+
+    This is a FitRecipe with a built-in Profile (the 'profile' attribute) and
+    FitContribution (the 'contribution' attribute). Unique methods from each of
+    these are exposed through this class to facilitate the creation of a simple
+    fit recipe.
+
+    Attributes
+    profile         --  The built-in Profile object.
+    contribution    --  The built-in FitContribution object.
+    results         --  The built-in FitResults object.
+    name            --  A name for this FitRecipe.
+    fithook         --  An object to be called whenever within the residual
+                        (default FitHook()) that can pass information out of
+                        the system during a refinement.
+    _constraints    --  A dictionary of Constraints, indexed by the constrained
+                        Parameter. Constraints can be added using the
+                        'constrain' method.
+    _oconstraints   --  An ordered list of the constraints from this and all
+                        sub-components.
+    _calculators    --  A managed dictionary of Calculators.
+    _contributions  --  A managed OrderedDict of FitContributions.
+    _parameters     --  A managed OrderedDict of parameters (in this case the
+                        parameters are varied).
+    _parsets        --  A managed dictionary of ParameterSets.
+    _eqfactory      --  A diffpy.srfit.equation.builder.EquationFactory
+                        instance that is used to create constraints and
+                        restraints from string
+    _fixed          --  A set of parameters that are not actually varied.
+    _restraintlist  --  A list of restraints from this and all sub-components.
+    _restraints     --  A set of Restraints. Restraints can be added using the
+                        'restrain' or 'confine' methods.
+    _ready          --  A flag indicating if all attributes are ready for the
+                        calculation.
+    _tagdict        --  A dictionary of tags to variables.
+    _weights        --  List of weighing factors for each FitContribution. The
+                        weights are multiplied by the residual of the
+                        FitContribution when determining the overall residual.
+
+    Properties
+    names           --  Variable names (read only). See getNames.
+    values          --  Variable values (read only). See getValues.
+    """
+
+    def __init__(self, name="fit", conclass=FitContribution):
+        """Initialization."""
+        FitRecipe.__init__(self, name)
+        self.fithooks[0].verbose = 3
+        contribution = conclass("contribution")
+        self.profile = Profile()
+        contribution.setProfile(self.profile)
+        self.addContribution(contribution)
+        self.results = FitResults(self, update=False)
+
+        # Adopt all the FitContribution methods
+        public = [
+            aname
+            for aname in dir(contribution)
+            if aname not in dir(self) and not aname.startswith("_")
+        ]
+        for mname in public:
+            method = getattr(contribution, mname)
+            setattr(self, mname, method)
+        return
+
+    # Profile methods
+    def loadParsedData(self, parser):
+        """Load parsed data from a ProfileParser.
+
+        This sets the xobs, yobs, dyobs arrays as well as the metadata.
+        """
+        return self.profile.loadParsedData(parser)
+
+    def setObservedProfile(self, xobs, yobs, dyobs=None):
+        """Set the observed profile.
+
+        Arguments
+        xobs    --  Numpy array of the independent variable
+        yobs    --  Numpy array of the observed signal.
+        dyobs   --  Numpy array of the uncertainty in the observed signal. If
+                    dyobs is None (default), it will be set to 1 at each
+                    observed xobs.
+
+        Raises ValueError if len(yobs) != len(xobs)
+        Raises ValueError if dyobs != None and len(dyobs) != len(xobs)
+        """
+        return self.profile.setObservedProfile(xobs, yobs, dyobs)
+
+    def setCalculationRange(self, xmin=None, xmax=None, dx=None):
+        """Set epsilon-inclusive calculation range.
+
+        Adhere to the observed ``xobs`` points when ``dx`` is the same
+        as in the data.  ``xmin`` and ``xmax`` are clipped at the bounds
+        of the observed data.
+
+        Parameters
+        ----------
+
+        xmin : float or "obs", optional
+            The minimum value of the independent variable.  Keep the
+            current minimum when not specified.  If specified as "obs"
+            reset to the minimum observed value.
+        xmax : float or "obs", optional
+            The maximum value of the independent variable.  Keep the
+            current maximum when not specified.  If specified as "obs"
+            reset to the maximum observed value.
+        dx : float or "obs", optional
+            The sample spacing in the independent variable.  When different
+            from the data, resample the ``x`` as anchored at ``xmin``.
+
+        Note that xmin is always inclusive (unless clipped). xmax is inclusive
+        if it is within the bounds of the observed data.
+
+        Raises
+        ------
+        AttributeError
+            If there is no observed data.
+        ValueError
+            When xmin > xmax or if dx <= 0.  Also if dx > xmax - xmin.
+        """
+        return self.profile.setCalculationRange(xmin, xmax, dx)
+
+    def setCalculationPoints(self, x):
+        """Set the calculation points.
+
+        Arguments
+        x   --  A non-empty numpy array containing the calculation points. If
+                xobs exists, the bounds of x will be limited to its bounds.
+
+        This will create y and dy on the specified grid if xobs, yobs and
+        dyobs exist.
+        """
+        return self.profile.setCalculationPoints(x)
+
+    def loadtxt(self, *args, **kw):
+        """Use numpy.loadtxt to load data.
+
+        Arguments are passed to numpy.loadtxt. unpack = True is
+        enforced. The first two arrays returned by numpy.loadtxt are
+        assumed to be x and y. If there is a third array, it is assumed
+        to by dy. Any other arrays are ignored. These are passed to
+        setObservedProfile.
+
+        Raises ValueError if the call to numpy.loadtxt returns fewer
+        than 2 arrays.
+
+        Returns the x, y and dy arrays loaded from the file
+        """
+        return self.profile.loadtxt(*args, **kw)
+
+    # FitContribution
+    def setEquation(self, eqstr, ns={}):
+        """Set the profile equation for the FitContribution.
+
+        This sets the equation that will be used when generating the residual.
+        The equation will be usable within setResidualEquation as "eq", and it
+        takes no arguments.
+
+        eqstr   --  A string representation of the equation. Variables will be
+                    extracted from this equation and be given an initial value
+                    of 0.
+        ns      --  A dictionary of Parameters, indexed by name, that are used
+                    in the eqstr, but not registered (default {}).
+
+        Raises ValueError if ns uses a name that is already used for a
+        variable.
+        """
+        self.contribution.setEquation(eqstr, ns={})
+        # Extract variables
+        for par in self.contribution:
+            # Skip Profile  Parameters
+            if par.name in ("x", "y", "dy"):
+                continue
+            if par.value is None:
+                par.value = 0
+            if par.name not in self._parameters:
+                self.addVar(par)
+        return
+
+    def __call__(self):
+        """Evaluate the contribution equation."""
+        return self.contribution.evaluate()
+
+    # FitResults methods
+
+    def printResults(self, header="", footer=""):
+        """Format and print the results.
+
+        header  --  A header to add to the output (default "")
+        footer  --  A footer to add to the output (default "")
+        """
+        self.results.printResults(header, footer, True)
+        return
+
+    def saveResults(self, filename, header="", footer=""):
+        """Format and save the results.
+
+        filename -  Name of the save file.
+        header  --  A header to add to the output (default "")
+        footer  --  A footer to add to the output (default "")
+        """
+        self.results.saveResults(filename, header, footer, True)
+
+
+# End class SimpleRecipe
+
+# End of file

diffpy/srfit/fitbase/validatable.py

@@ -0,0 +1,59 @@
+#!/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.
+#
+##############################################################################
+"""Validatable class.
+
+A Validatable has state that must be validated before a FitRecipe can
+first calculate the residual.
+"""
+
+__all__ = ["Validatable"]
+
+
+class Validatable(object):
+    """Validatable class.
+
+    A Validatable has state that must be validated by a FitRecipe.
+    """
+
+    def _validateOthers(self, iterable):
+        """Method to validate configuration of Validatables in iterable.
+
+        This is provided as a convenience for derived classes.  No need
+        to overload this. Call this method from overloaded _validate
+        with an iterable of other Validatables.
+        """
+        for obj in iterable:
+            if obj is self:
+                continue
+            if isinstance(obj, Validatable):
+                obj._validate()
+
+        return
+
+    def _validate(self):
+        """Validate self and Validatables.
+
+        Overload this in a derived class.
+
+        Raises AttributeError if validation fails.
+        """
+        # Validate self here.
+        # Then validate others.
+        return
+
+
+# End class Validatable
+
+# End of file

diffpy/srfit/interface/__init__.py

@@ -0,0 +1,33 @@
+#!/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.
+#
+##############################################################################
+"""Usability interface for SrFit.
+
+The classes and functions in this package are designed to unobtrusively
+mix with base SrFit objects and provide them with interface enhancements
+for scripting.
+"""
+
+
+from diffpy.srfit.interface.interface import (
+    FitRecipeInterface,
+    ParameterInterface,
+    RecipeOrganizerInterface,
+)
+
+_parameter_interface = ParameterInterface
+_recipeorganizer_interface = RecipeOrganizerInterface
+_fitrecipe_interface = FitRecipeInterface
+
+# End of file

diffpy/srfit/interface/interface.py

@@ -0,0 +1,180 @@
+#!/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.
+#
+##############################################################################
+"""Interface enhancements for Parameter-type classes.
+
+Most interface additions can thought of by considering the classes in
+SrFit to be sets of parameters. "+=" adds a new parameter, when that
+makes sense. "|=" is the 'union' of these sets, and in general is used
+to combine different objects. See individual interface classes for
+specifics.
+"""
+
+__all__ = [
+    "ParameterInterface",
+    "FitRecipeInterface",
+    "RecipeOrganizerInterface",
+]
+
+import six
+
+from diffpy.srfit.equation.literals.abcs import ArgumentABC
+
+
+class ParameterInterface(object):
+    """Mix-in class for enhancing the Parameter interface."""
+
+    def __lshift__(self, v):
+        """SetValue with <<
+
+        Think of '<<' as injecting a value
+
+        v   --  value or Argument derivative
+        """
+        if isinstance(v, ArgumentABC):
+            self.value = v.value
+        else:
+            self.value = v
+        return self
+
+
+# End class ParameterInterface
+
+# ----------------------------------------------------------------------------
+
+
+class RecipeOrganizerInterface(object):
+    """Mix-in class for enhancing the RecipeOrganizer interface."""
+
+    def __imul__(self, args):
+        """Constrain with *=
+
+        Think of '*' as a push-pin.
+
+        This accepts arguments for a single constraint.
+        """
+        _applyargs(args, self.constrain)
+        return self
+
+    def __imod__(self, args):
+        """Restrain with %=
+
+        This of '%' as a loose rope.
+
+        This accepts arguments for a single restraint.
+        """
+        _applyargs(args, self.restrain)
+        return self
+
+    def __iadd__(self, args):
+        """_newParameter or _addParameter with +=
+
+        Think of "+" as addition of a Parameter.
+
+        This accepts arguments for a single function call.
+        """
+
+        # Want to detect _addParameter or _newParameter
+        def f(*args):
+            if isinstance(args[0], six.string_types):
+                self._newParameter(*args)
+            else:
+                self._addParameter(*args)
+            return
+
+        _applyargs(args, f)
+        return self
+
+
+# End class RecipeOrganizerInterface
+
+# ----------------------------------------------------------------------------
+
+
+class FitRecipeInterface(object):
+    """Mix-in class for enhancing the FitRecipe interface."""
+
+    def __ior__(self, args):
+        """AddContribution with |=
+
+        Think of "|" as the union of components.
+
+        This accepts a single argument.
+        """
+        self.addContribution(args)
+        return self
+
+    def __iadd__(self, args):
+        """AddVar or newVar with +=
+
+        Think of "+" as addition of a variable.
+
+        This accepts a single argument or an iterable of single
+        arguments or argument tuples.
+        """
+
+        # Want to detect addVar or newVar
+        def f(*args):
+            if isinstance(args[0], six.string_types):
+                self.newVar(*args)
+            else:
+                self.addVar(*args)
+            return
+
+        _applymanyargs(args, f)
+        return self
+
+
+# End class FitRecipeInterface
+
+# Local helper functions -----------------------------------------------------
+
+
+def _applymanyargs(args, f):
+    """Apply arguments to a function.
+
+    Args can be any of the following.
+    arg
+    (arg1, arg2, ...)
+    ((arg1a, arg1b, ...), ...)
+    """
+    if not hasattr(args, "__iter__"):
+        f(args)
+        return
+
+    for arg in args:
+        if hasattr(arg, "__iter__"):
+            f(*arg)
+        else:
+            f(arg)
+
+    return
+
+
+def _applyargs(args, f):
+    """Apply arguments to a function.
+
+    Args can be any of the following.
+    arg
+    (arg1, arg2, ...)
+    ((arg1a, arg1b, ...), ...)
+    """
+    if not hasattr(args, "__iter__"):
+        f(args)
+    else:
+        f(*args)
+    return
+
+
+# End of file

diffpy/srfit/pdf/__init__.py

@@ -0,0 +1,24 @@
+#!/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.
+#
+##############################################################################
+"""PDF calculation tools."""
+
+__all__ = ["PDFGenerator", "DebyePDFGenerator", "PDFContribution", "PDFParser"]
+
+from diffpy.srfit.pdf.debyepdfgenerator import DebyePDFGenerator
+from diffpy.srfit.pdf.pdfcontribution import PDFContribution
+from diffpy.srfit.pdf.pdfgenerator import PDFGenerator
+from diffpy.srfit.pdf.pdfparser import PDFParser
+
+# End of file