diffpy.srfit 3.1.0__py3-none-any.whl

diffpy/srfit/equation/visitors/swapper.py

@@ -0,0 +1,142 @@
+#!/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.
+#
+##############################################################################
+"""Swapper for replacing a Literal in an equation with another Literals."""
+
+__all__ = ["Swapper"]
+
+from diffpy.srfit.equation.visitors.visitor import Visitor
+
+
+class Swapper(Visitor):
+    """Swapper for swapping out one literal for another in a literal tree.
+
+    Note that this cannot swap out a root node of a literal tree. This case
+    must be tested for explicitly.
+
+    Attributes:
+    newlit  --  The literal to be placed into the literal tree.
+    oldlit  --  The literal to be replaced.
+    """
+
+    def __init__(self, oldlit, newlit):
+        """Initialize.
+
+        oldlit  --  The literal to be replaced.
+        newlit  --  The literal to be placed into the literal tree. See the
+                    class for how the replacement takes place.
+        """
+
+        self.newlit = newlit
+        self.oldlit = oldlit
+
+        self._swap = False
+
+        return
+
+    def onArgument(self, arg):
+        """Process an Argument node.
+
+        Tell the parent to swap the old Argument with the replacement
+        Literal.
+        """
+
+        if arg is self.oldlit:
+            self._swap = True
+
+        return
+
+    def onOperator(self, op):
+        """Process an Operator node.
+
+        Tell the parent to swap the old Operator with the replacement
+        Literal.
+        """
+
+        # Check to see if we need to swap out this Operator. If so, then we
+        # don't need to traverse into its arguments.
+        if op is self.oldlit:
+            self._swap = True
+            return
+
+        # Now traverse into the arguments.
+        for literal in op.args:
+            literal.identify(self)
+
+        # If we've been told to swap out a literal, then we must do it in-place
+        # because the order of op.args matters.
+        if self._swap:
+
+            oldlit = self.oldlit
+            newlit = self.newlit
+
+            while oldlit in op.args:
+
+                # Record the index
+                idx = op.args.index(oldlit)
+                # Remove the literal
+                del op.args[idx]
+                # Remove op as an observer. A KeyError will be raised if we
+                # attempt to remove the same observer more than once, which
+                # might happen if the oldlit appears multiple times in op.args.
+                try:
+                    oldlit.removeObserver(op._flush)
+                except KeyError:
+                    pass
+
+                # Validate the new literal. If it fails, we need to restore the
+                # old one
+                try:
+                    op._loopCheck(newlit)
+                except ValueError:
+                    # Restore the old literal
+                    op.args.insert(idx, oldlit)
+                    oldlit.addObserver(op._flush)
+                    raise
+
+                # If we got here, then go on with replacing the literal
+                op.args.insert(idx, newlit)
+                newlit.addObserver(op._flush)
+                op._flush(other=())
+
+            self._swap = False
+
+        return
+
+    def onEquation(self, eq):
+        """Process an Equation node.
+
+        This looks at the equation itself as well as the root.
+        """
+        if eq is self.oldlit:
+            self._swap = True
+            return
+
+        # If the newlit is the root, then swap that out and move on.
+        if eq.root is self.oldlit:
+            eq.setRoot(self.newlit)
+            return
+
+        # Now move into the equation. We have to do a _loopCheck to make sure
+        # that we won't have any loops in the equation.
+        eq._loopCheck(self.newlit)
+        eq.root.identify(self)
+
+        # Reset the root in case anything changed underneath.
+        eq.setRoot(eq.root)
+
+        return
+
+
+# End of file

diffpy/srfit/equation/visitors/validator.py

@@ -0,0 +1,113 @@
+#!/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.
+#
+##############################################################################
+"""Validator visitor for validating a tree of Literals.
+
+The Validator walks an equation tree composed of Literals and checks the
+validity of each equation as much as possible without evaluating it. It
+collects errors in a list.
+
+The Validator checks that the input count of each Operator is equal to
+the output count of its arguments. It also checks that each object has
+the proper interface.
+"""
+
+__all__ = ["Validator"]
+
+from diffpy.srfit.equation.literals.abcs import ArgumentABC, OperatorABC
+from diffpy.srfit.equation.visitors.visitor import Visitor
+
+msg = "'%s' does not have the interface required by '%s'"
+
+
+class Validator(Visitor):
+    """Validator error for checking validity of an equation tree.
+
+    Attributes:
+    errors  --  List of strings describing errors.
+    _nin    --  Variable for counting the number input arguments for an
+                operator.
+    """
+
+    def __init__(self):
+        """Initialize."""
+        self.reset()
+        return
+
+    def reset(self):
+        """Click the clicker and reset non-public data."""
+        self.errors = []
+        self._nin = 0
+        return
+
+    def onArgument(self, arg):
+        """Process an Argument node.
+
+        The Argument must be an instance of ArgumentABC from
+        diffpy.srfit.equation.literals.abcs
+        """
+        if not isinstance(arg, ArgumentABC):
+            m = msg % (arg, ArgumentABC.__name__)
+            self.errors.append(m)
+        self._nin = 1
+        return self.errors
+
+    def onOperator(self, op):
+        """Process an Operator node.
+
+        The Operator must be an instance of OperatorABC from
+        diffpy.srfit.equation.literals.abcs
+        """
+
+        if not isinstance(op, OperatorABC):
+            m = msg % (op, OperatorABC.__name__)
+            self.errors.append(m)
+
+        # Can only process single-valued functions
+        if op.nout != 1:
+            m = "'%s' is not single-valued (nout != 1)" % op
+            self.errors.append(m)
+        # Check name
+        if op.name is None:
+            m = "'%s' does not have a name" % op
+            self.errors.append(m)
+        # Check symbol
+        if op.symbol is None:
+            m = "'%s' does not have a symbol" % op
+            self.errors.append(m)
+        # Check operation without evaluating it
+        if op.operation is None:
+            m = "'%s' does not define and operation" % op
+            self.errors.append(m)
+
+        localnin = 0
+        for literal in op.args:
+            literal.identify(self)
+            # Count the nout of the arguments.
+            localnin += self._nin
+
+        # Check the input/output balance
+        if op.nin >= 0 and localnin != op.nin:
+            m = "'%s' requires %i inputs but receives %i" % (
+                op,
+                op.nin,
+                localnin,
+            )
+            self.errors.append(m)
+
+        self._nin = op.nout
+        return self.errors
+
+
+# End of file

diffpy/srfit/equation/visitors/visitor.py

@@ -0,0 +1,62 @@
+#!/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.
+#
+##############################################################################
+"""Base visitor class.
+
+Visitors work with Literal trees to perform a specified action. They are
+designed according to the visitor pattern (
+http://en.wikipedia.org/wiki/Visitor_pattern).
+
+Visitors work with the following Literal classes
+(diffpy.srfit.equation.literals):
+Argument
+Operator
+
+See the Visitor class for the required methods that each Visitor must overload.
+"""
+
+__all__ = ["Visitor"]
+
+
+class Visitor(object):
+    """Abstract class for all visitors to a Literal tree.
+
+    See implemented visitors for examples of use.
+    """
+
+    def onArgument(self, arg):
+        """Process an Argument node."""
+        return self._abstract("onArgument")
+
+    def onOperator(self, op):
+        """Process an Operator node."""
+        return self._abstract("onOperator")
+
+    def onEquation(self, eq):
+        """Process an Equation node.
+
+        Equations are specialized Operators. They don't need to be
+        specifically supported by a Visitor.
+        """
+        return self.onOperator(eq)
+
+    # throw an exception
+    def _abstract(self, method):
+        raise NotImplementedError(
+            "class '%s' should override method '%s'"
+            % (self.__class__.__name__, method)
+        )
+
+
+# End of file

diffpy/srfit/exceptions.py

@@ -0,0 +1,29 @@
+#!/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.
+#
+##############################################################################
+"""
+Exceptions used for SrFit - specific errors.
+"""
+
+
+class SrFitError(Exception):
+    """Generic error in SrFit expressions or recipe."""
+
+    pass
+
+
+class ParseError(Exception):
+    """Exception used by ProfileParsers."""
+
+    pass

diffpy/srfit/fitbase/__init__.py

@@ -0,0 +1,53 @@
+#!/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.
+#
+##############################################################################
+"""The base fitting classes for diffpy.srfit.
+
+This package contains modules and subpackages that are used to define a
+fit problem in SrFit. Unaltered, these classes will help set up a fit
+problem that can be optimized within a fitting framework or with a
+standalone optimizer. They provide the basic framework for defining a
+forward calculator, and from that defining a fit problem with data,
+constraints and restraints. The classes involved in this collaboration
+can be tied to a fitting framework at various levels through
+inheritance. One can create a fitting problem using the FitContribution,
+Profile and FitRecipe classes.
+
+Various code and design taken from Paul Kienzle's PARK package.
+http://www.reflectometry.org/danse/park.html
+"""
+
+__all__ = [
+    "Calculator",
+    "FitContribution",
+    "FitHook",
+    "FitRecipe",
+    "FitResults",
+    "initializeRecipe",
+    "PlotFitHook",
+    "Profile",
+    "ProfileGenerator",
+    "SimpleRecipe",
+]
+
+from diffpy.srfit.fitbase.calculator import Calculator
+from diffpy.srfit.fitbase.fitcontribution import FitContribution
+from diffpy.srfit.fitbase.fithook import FitHook, PlotFitHook
+from diffpy.srfit.fitbase.fitrecipe import FitRecipe
+from diffpy.srfit.fitbase.fitresults import FitResults, initializeRecipe
+from diffpy.srfit.fitbase.profile import Profile
+from diffpy.srfit.fitbase.profilegenerator import ProfileGenerator
+from diffpy.srfit.fitbase.simplerecipe import SimpleRecipe
+
+# End of file

diffpy/srfit/fitbase/calculator.py

@@ -0,0 +1,110 @@
+#!/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.
+#
+##############################################################################
+"""The Calculator for Parameter-aware functions.
+
+Calculator is a functor class for producing a signal from embedded
+Parameters. Calculators can store Parameters and ParameterSets,
+Constraints and Restraints. Also, the __call__ function can be
+overloaded to accept external arguments. Calculators are used to wrap
+registered functions so that the function's Parameters are contained in
+an object specific to the function.  A custom Calculator can be added to
+another RecipeOrganizer with the 'registerCalculator' method.
+"""
+
+__all__ = ["Calculator"]
+
+from diffpy.srfit.equation.literals.operators import Operator
+from diffpy.srfit.fitbase.parameterset import ParameterSet
+
+
+class Calculator(Operator, ParameterSet):
+    """Base class for calculators.
+
+    A Calculator organizes Parameters and has a __call__ method that can
+    calculate a generic signal.
+
+    Attributes
+    name            --  A name for this organizer.
+    meta            --  A dictionary of metadata needed by the calculator.
+    _calculators    --  A managed dictionary of Calculators, indexed by name.
+    _constraints    --  A set of constrained Parameters. Constraints can be
+                        added using the 'constrain' methods.
+    _parameters     --  A managed OrderedDict of contained Parameters.
+    _parsets        --  A managed dictionary of ParameterSets.
+    _restraints     --  A set of Restraints. Restraints can be added using the
+                        'restrain' or 'confine' methods.
+    _eqfactory      --  A diffpy.srfit.equation.builder.EquationFactory
+                        instance that is used create Equations from string.
+
+    Operator Attributes
+    args    --  List of Literal arguments
+    nin     --  Number of inputs (<1 means this is variable)
+    nout    --  Number of outputs (1)
+    operation   --  Function that performs the operation, self.__call__
+    symbol  --  Same as name
+    _value  --  The value of the Operator.
+    value   --  Property for 'getValue'.
+
+    Properties
+    names           --  Variable names (read only). See getNames.
+    values          --  Variable values (read only). See getValues.
+    """
+
+    # define abstract attributes from the Operator base.
+
+    nin = -1
+    nout = 1
+
+    def __init__(self, name):
+        ParameterSet.__init__(self, name)
+        self.meta = {}
+
+        # Initialize Operator attributes
+        Operator.__init__(self, name)
+        return
+
+    @property
+    def symbol(self):
+        return self.name
+
+    # Overload me!
+    def __call__(self, *args):
+        """Calculate something.
+
+        This method must be overloaded. When overloading, you should
+        specify the arguments explicitly, otherwise the parameters must
+        be specified when adding the Calculator to a RecipeOrganizer.
+        """
+        return 0
+
+    def operation(self, *args):
+        self._value = self.__call__(*args)
+        return self._value
+
+    def _validate(self):
+        """Validate my state.
+
+        This performs ParameterSet validations. This does not validate
+        the operation, since this could be costly. The operation should
+        be validated with a containing equation.
+
+        Raises AttributeError if validation fails.
+        """
+        ParameterSet._validate(self)
+
+        return
+
+
+# End class Calculator

diffpy/srfit/fitbase/configurable.py

@@ -0,0 +1,57 @@
+#!/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.
+#
+##############################################################################
+"""Configurable class.
+
+A Configurable has state of which a FitRecipe must be aware.
+"""
+
+__all__ = ["Configurable"]
+
+
+class Configurable(object):
+    """Configurable class.
+
+    A Configurable has state of which a FitRecipe must be aware.
+
+    Attributes
+    _configobjs     --  Set of Configureables in a hierarchy or instances.
+                        Messages get passed up the hierarchy to a FitReciple
+                        via these objects.
+    """
+
+    def __init__(self):
+        self._configobjs = set()
+        return
+
+    def _updateConfiguration(self):
+        """Notify Configurables in hierarchy of configuration change."""
+        for obj in self._configobjs:
+            obj._updateConfiguration()
+        return
+
+    def _storeConfigurable(self, obj):
+        """Store a Configurable.
+
+        The passed obj is only stored if it is a a Configurable,
+        otherwise this method quietly exits.
+        """
+        if isinstance(obj, Configurable):
+            self._configobjs.add(obj)
+        return
+
+
+# End class Configurable
+
+# End of file

diffpy/srfit/fitbase/constraint.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.
+#
+##############################################################################
+"""Constraint class.
+
+Constraints are used by a FitRecipe (and other RecipeOrganizers) to
+organize constraint equations. They store a Parameter object and an
+Equation object that is used to compute its value. The
+Constraint.constrain method is used to create this association.
+"""
+
+__all__ = ["Constraint"]
+
+from diffpy.srfit.exceptions import SrFitError
+from diffpy.srfit.fitbase.validatable import Validatable
+
+
+class Constraint(Validatable):
+    """Constraint class.
+
+    Constraints are designed to be stored in only one place. (The holder of the
+    constraint owns it).
+
+    Attributes
+    par     --  A Parameter that is the subject of the constraint.
+    eq      --  An equation whose evaluation is used to set the value of the
+                constraint.
+    """
+
+    def __init__(self):
+        """Initialization."""
+        self.par = None
+        self.eq = None
+        return
+
+    def constrain(self, par, eq):
+        """Constrain a Parameter according to an Equation.
+
+        The parameter will be set constant once it is constrained. This
+        will keep it from being constrained multiple times.
+
+        Raises a ValueError if par is const.
+        """
+
+        if par.const:
+            raise ValueError("The parameter '%s' is constant" % par)
+
+        if par.constrained:
+            raise ValueError("The parameter '%s' is already constrained" % par)
+
+        par.constrained = True
+
+        self.par = par
+        self.eq = eq
+        self.update()
+        return
+
+    def unconstrain(self):
+        """Clear the constraint."""
+        self.par.constrained = False
+        self.par = None
+        self.eq = None
+        return
+
+    def update(self):
+        """Update the parameter according to the equation."""
+        # This will be evaluated quickly thanks to the Equation class.
+        val = self.eq()
+        # This will only change the Parameter if val is different from the
+        # currently stored value.
+        self.par.setValue(val)
+        return
+
+    def _validate(self):
+        """Validate my state.
+
+        This validates that par is not None. This validates eq.
+
+        Raises SrFitError if validation fails.
+        """
+        if self.par is None:
+            raise SrFitError("par is None")
+        if self.eq is None:
+            raise SrFitError("eq is None")
+        self.par._validate()
+        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()
+            self.par.setValue(val)
+        except TypeError:
+            raise SrFitError("eq cannot be evaluated")
+        finally:
+            if val is None:
+                raise SrFitError("eq evaluates to None")
+
+        return
+
+
+# End of file