diffpy.srfit 3.1.0__py3-none-any.whl

diffpy/srfit/sas/prcalculator.py

@@ -0,0 +1,139 @@
+#!/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.
+#
+##############################################################################
+"""Nanoparticle form factor P(r) calculator.
+
+The PrCalculator class wraps a sas.pr.invertor.Invertor object as a
+Calculator. This is not wrapped as a ProfileGenerator because it will be
+used to share information between SAS I(Q) to PDF G(r), but it does not
+use the same profile as the PDF, which is where the calculator will be
+applied.
+"""
+
+__all__ = ["PrCalculator", "CFCalculator"]
+
+from functools import partial
+
+import numpy
+
+from diffpy.srfit.fitbase import Calculator
+
+Invertor = None
+
+
+class PrCalculator(Calculator):
+    """A class for calculating P(r) from data.
+
+    This is provided so that SAS data can be used to calculate a nanoparticle
+    form factor (characteristic function) for nanoparticle PDF refinements. For
+    a crystal-like nanoparticle:
+    Gnano(r) = f(r)Gcrystal(r),
+    where f(r) is the nanoparticle form factor.
+    This is obtained from P(r) as
+    P(r) = 4 pi r**2 f(r).
+
+    Attributes:
+    _invertor   --  sas.pr.invertor.Invertor object. This object is internal,
+                    but can be configured by the user after initialization.
+                    Note that the 'x', 'y' and 'err' attributes get overwritten
+                    every time the invertor is used.
+
+    Managed Parameters:
+    scale       --  The scale factor (default 1).
+    q           --  The q-values of the I(q) signal
+    iq          --  The I(q) signal
+    diq         --  The uncertainty in I(q)
+    """
+
+    def __init__(self, name):
+        """Initialize the generator.
+
+        name        --  A name for the PrCalculator
+        """
+        Calculator.__init__(self, name)
+
+        # delayed import of Invertor
+        global Invertor
+        if Invertor is None:
+            from diffpy.srfit.sas.sasimport import sasimport
+
+            Invertor = sasimport("sas.pr.invertor").Invertor
+
+        self._invertor = Invertor()
+
+        self._newParameter("scale", 1)
+        self._newParameter("q", None)
+        self._newParameter("iq", None)
+        self._newParameter("diq", None)
+        return
+
+    def __call__(self, r):
+        """Calculate P(r) from the data or calculated signal."""
+        q = self.q.value
+        iq = self.iq.value
+        diq = self.diq.value
+        if diq is None:
+            diq = numpy.ones_like(q)
+        self._invertor.d_max = max(r) + 5.0
+        # Assume profile doesn't include 0. It's up to the user to make this
+        # happen.
+        self._invertor.x = q
+        self._invertor.y = iq
+        self._invertor.err = diq
+        c, c_cov = self._invertor.invert_optimize()
+        _inverted_w_c = partial(self._inverted, c=c)
+        pr = map(_inverted_w_c, r)
+
+        pr = numpy.array(pr)
+        return self.scale.value * pr
+
+    def _inverted(self, x, c):
+        self._invertor.pr(c, x)
+
+
+# End class PrCalculator
+
+
+class CFCalculator(PrCalculator):
+    """A class for calculating the characteristic function (CF) from data.
+
+    This calculator produces
+    f(r) = P(r) / 4 pi r**2
+    which is the nanoparticle form factor scaled by density.
+
+    Attributes:
+    _invertor   --  sas.pr.invertor.Invertor object. This object is internal,
+                    but can be configured by the user after initialization.
+                    Note that the 'x', 'y' and 'err' attributes get overwritten
+                    every time the invertor is used.
+
+    Managed Parameters:
+    scale       --  The scale factor (default 1).
+    q           --  The q-values of the I(q) signal
+    iq          --  The I(q) signal
+    diq         --  The uncertainty in I(q)
+    """
+
+    def __call__(self, r):
+        """Calculate P(r) from the data or calculated signal."""
+        fr = PrCalculator.__call__(self, r)
+        fr /= 4 * numpy.pi * r**2
+        if r[0] == 0:
+            # Assume the scale makes fr properly normalized. We don't have much
+            # other choice.
+            fr[0] = 1
+        return fr
+
+
+# End class CFCalculator

diffpy/srfit/sas/sasgenerator.py

@@ -0,0 +1,70 @@
+#!/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.
+#
+##############################################################################
+"""SAS profile generator.
+
+The SASGenerator class wraps a sas.models.BaseModel object as a
+ProfileGenerator.
+"""
+
+__all__ = ["SASGenerator"]
+
+from diffpy.srfit.fitbase import ProfileGenerator
+from diffpy.srfit.sas.sasparameter import SASParameter
+
+
+class SASGenerator(ProfileGenerator):
+    """A class for calculating I(Q) from a scattering type.
+
+    Attributes:
+    _model      --  BaseModel object this adapts.
+
+    Managed Parameters:
+    These depend on the parameters of the BaseModel object held by _model. They
+    are created from the 'params' attribute of the BaseModel. If a dispersion
+    is set for the BaseModel, the dispersion "width" will be accessible under
+    "<parname>_width", where <parname> is the name a parameter adjusted by
+    dispersion.
+    """
+
+    def __init__(self, name, model):
+        """Initialize the generator.
+
+        name    --  A name for the SASGenerator
+        model   --  SASModel object this adapts.
+        """
+        ProfileGenerator.__init__(self, name)
+
+        self._model = model
+
+        # Wrap normal parameters
+        for parname in model.params:
+            par = SASParameter(parname, model)
+            self.addParameter(par)
+
+        # Wrap dispersion parameters
+        for parname in model.dispersion:
+            name = parname + "_width"
+            parname += ".width"
+            par = SASParameter(name, model, parname)
+            self.addParameter(par)
+
+        return
+
+    def __call__(self, q):
+        """Calculate I(Q) for the BaseModel."""
+        return self._model.evalDistribution(q)
+
+
+# End class SASGenerator

diffpy/srfit/sas/sasimport.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.srfit      Complex Modeling Initiative
+#                   (c) 2015 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.
+#
+##############################################################################
+"""Universal import functions for volatile SasView/SansViews API-s."""
+
+
+def sasimport(modname):
+    """Import specified module from the SasView sas package.
+
+    modname  -- absolute module name contained in the sas package.
+
+    When specified import does not work directly, try older API-s and raise
+    DeprecationWarning.  Raise ImportError if nothing works.
+    """
+    if not modname.startswith("sas."):
+        emsg = 'Module name must start with "sas."'
+        raise ValueError(emsg)
+    mobj = None
+    # standard import
+    try:
+        exec("import %s as mobj" % modname)
+    except ImportError:
+        pass
+    else:
+        return mobj
+    # revert to the old sans namespace, sas --> sans
+    modsans = "sans" + modname[3:]
+    import warnings
+
+    wfmt = (
+        "Using obsolete package %r instead of %r.  Please install "
+        "SasView 3.1 or the srfit-sasview package from Anaconda."
+    )
+    wmsg = wfmt % (modsans, modname)
+    try:
+        exec("import %s as mobj" % modsans)
+        warnings.warn(wmsg, DeprecationWarning)
+    except ImportError:
+        pass
+    else:
+        return mobj
+    # finally check the oldest DataLoader API for sas.dataloader
+    if modname.startswith("sas.dataloader"):
+        modloader = "DataLoader" + modname[14:]
+        wmsg = wfmt % (modloader, modname)
+        try:
+            exec("import %s as mobj" % modloader)
+            warnings.warn(wmsg, DeprecationWarning)
+        except ImportError:
+            pass
+        else:
+            return mobj
+    # Obsolete API-s failed here.  Import again and let it raise ImportError.
+    exec("import %s as mobj" % modname)
+    raise AssertionError("The import above was supposed to fail.")

diffpy/srfit/sas/sasparameter.py

@@ -0,0 +1,70 @@
+#!/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.
+#
+##############################################################################
+"""SAS profile generator.
+
+The SASGenerator class wraps a sas.models.BaseModel object as a
+ProfileGenerator.
+"""
+
+__all__ = ["SASParameter"]
+
+from diffpy.srfit.fitbase.parameter import Parameter
+
+
+class SASParameter(Parameter):
+    """Class adapting a sasmodel parameter to srfit Parameter.
+
+    Attributes
+    name    --  A name for this Parameter.
+    const   --  A flag indicating whether this is considered a constant.
+    _value  --  The value of the Parameter. Modified with 'setValue'.
+    value   --  Property for 'getValue' and 'setValue'.
+    constrained --  A flag indicating if the Parameter is constrained
+                (default False).
+    bounds  --  A 2-list defining the bounds on the Parameter. This can be
+                used by some optimizers when the Parameter is varied. These
+                bounds are unrelated to restraints on a Parameter.
+    _model  --  The BaseModel to which the underlying parameter belongs.
+    _parname    --  The name of the underlying BaseModel parameter.
+    """
+
+    def __init__(self, name, model, parname=None):
+        """Create the Parameter.
+
+        name    --  Name of the Parameter
+        model   --  The BaseModel to which the underlying parameter belongs
+        parname --  Name of parameter used by the model. If this is None
+                    (default), then name is used.
+        """
+        self._parname = parname or name
+        val = model.getParam(self._parname)
+        self._model = model
+        Parameter.__init__(self, name, val)
+        return
+
+    def getValue(self):
+        """Get the value of the Parameter."""
+        value = self._model.getParam(self._parname)
+        return value
+
+    def setValue(self, value):
+        """Set the value of the Parameter."""
+        if value != self.getValue():
+            self._model.setParam(self._parname, value)
+            self.notify()
+        return self
+
+
+# End of class SASParameter

diffpy/srfit/sas/sasparser.py

@@ -0,0 +1,133 @@
+#!/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.
+#
+##############################################################################
+"""This module contains parsers for SAS data.
+
+SASParser uses the sas DataLoader class to load data.
+"""
+
+__all__ = ["SASParser"]
+
+
+from diffpy.srfit.exceptions import ParseError
+from diffpy.srfit.fitbase.profileparser import ProfileParser
+from diffpy.srfit.sas.sasimport import sasimport
+
+
+class SASParser(ProfileParser):
+    """Class for parsing a sas profile.
+
+    This uses a sas DataLoader to load the data. The DataInfo object it returns
+    is held in the metadata under the name "datainfo".
+
+    Attributes
+
+    _format     --  Name of the data format that this parses (string, default
+                    ""). The format string is a unique identifier for the data
+                    format handled by the parser.
+    _banks      --  The data from each bank. Each bank contains a
+                    (x, y, dx, dy) tuple:
+                    x       --  A numpy array containing the independent
+                                variable read from the file.
+                    y       --  A numpy array containing the profile
+                                from the file.
+                    dx      --  A numpy array containing the uncertainty in x
+                                read from the file. This is 0 if the
+                                uncertainty cannot be read.
+                    dy      --  A numpy array containing the uncertainty read
+                                from the file. This is 0 if the uncertainty
+                                cannot be read.
+    _x          --  Independent variable from the chosen bank
+    _y          --  Profile from the chosen bank
+    _dx         --  Uncertainty in independent variable from the chosen bank
+    _dy         --  Uncertainty in profile from the chosen bank
+    _meta       --  A dictionary containing metadata read from the file.
+
+    General Metadata
+
+    filename    --  The name of the file from which data was parsed. This key
+                    will not exist if data was not read from file.
+    nbanks      --  The number of banks parsed.
+    bank        --  The chosen bank number.
+
+    Metadata - These may appear in the metadata dictionary
+
+    datainfo    --  The DataInfo object used to do the data parsing.
+    """
+
+    _format = "SAS"
+
+    def parseFile(self, filename):
+        """Parse a file and set the _x, _y, _dx, _dy and _meta variables.
+
+        This wipes out the currently loaded data and selected bank number.
+
+        Arguments
+        filename    --  The name of the file to parse
+
+        Raises IOError if the file cannot be read
+        Raises ParseError if the file cannot be parsed
+        """
+
+        Loader = sasimport("sas.dataloader.loader").Loader
+        loader = Loader()
+
+        try:
+            data = loader.load(filename)
+        except RuntimeError as e:
+            raise ParseError(e)
+        except ValueError as e:
+            raise ParseError(e)
+
+        self._banks = []
+        self._meta = {}
+        self._meta["filename"] = filename
+        self._meta["datainfo"] = data
+
+        self._banks.append([data.x, data.y, data.dx, data.dy])
+        self.selectBank(0)
+        return
+
+    def parseString(self, patstring):
+        """Parse a string and set the _x, _y, _dx, _dy and _meta variables.
+
+        When _dx or _dy cannot be obtained in the data format it is set to 0.
+
+        This wipes out the currently loaded data and selected bank number.
+
+        Arguments
+        patstring   --  A string containing the pattern
+
+        Raises ParseError if the string cannot be parsed
+        """
+        # This calls on parseFile, as that is how the sas data loader works.
+        import tempfile
+
+        fh, fn = tempfile.mkstemp()
+        outfile = open(fn, "w")
+        fn.write(patstring)
+        outfile.close()
+        self.parseFile(fn)
+
+        del self._metadata["filename"]
+
+        # Close the temporary file and delete it
+        import os
+
+        os.close(fh)
+        os.remove(fn)
+        return
+
+
+# End of class SASParser

diffpy/srfit/sas/sasprofile.py

@@ -0,0 +1,94 @@
+#!/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.
+#
+##############################################################################
+"""Class for adapting a sas DataInfo objects to the Profile interface."""
+
+__all__ = ["SASProfile"]
+
+from numpy import ones_like
+
+from diffpy.srfit.fitbase.profile import Profile
+
+
+class SASProfile(Profile):
+    """Observed and calculated profile container for SAS data.
+
+    This wraps a sas DataInfo object as a Profile object. Use this when you
+    want to use and manipulate a DataProfile before using it with SrFit.
+    Otherwise, use the SASParser class and load the data into a base Profile
+    object.
+
+    Attributes
+
+    _xobs   --  A numpy array of the observed independent variable (default
+                None)
+    xobs    --  Read-only property of _xobs.
+    _yobs   --  A numpy array of the observed signal (default None)
+    yobs    --  Read-only property of _yobs.
+    _dyobs  --  A numpy array of the uncertainty of the observed signal
+                (default None, optional).
+    dyobs   --  Read-only property of _dyobs.
+    x       --  A numpy array of the calculated independent variable (default
+                None, property for xpar accessors).
+    y       --  The profile over the calculation range (default None, property
+                for ypar accessors).
+    dy      --  The uncertainty in the profile over the calculation range
+                (default None, property for dypar accessors).
+    ycalc   --  A numpy array of the calculated signal (default None).
+    xpar    --  A ProfileParameter that stores x (named "x").
+    ypar    --  A ProfileParameter that stores y (named "y").
+    dypar   --  A ProfileParameter that stores dy (named "dy").
+    meta    --  A dictionary of metadata. This is only set if provided by a
+                parser.
+
+    _datainfo   --  The DataInfo object this wraps.
+    """
+
+    def __init__(self, datainfo):
+        """Initialize the attributes.
+
+        datainfo   --  The DataInfo object this wraps.
+        """
+        self._datainfo = datainfo
+        Profile.__init__(self)
+
+        self._xobs = self._datainfo.x
+        self._yobs = self._datainfo.y
+        if self._datainfo.dy is None or 0 == len(self._datainfo.dy):
+            self._dyobs = ones_like(self.xobs)
+        else:
+            self._dyobs = self._datainfo.dy
+        return
+
+    def setObservedProfile(self, xobs, yobs, dyobs=None):
+        """Set the observed profile.
+
+        This is overloaded to change the value within the datainfo object.
+
+        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)
+        """
+        Profile.setObservedProfile(self, xobs, yobs, dyobs)
+        # Copy the arrays to the _datainfo attribute.
+        self._datainfo.x = self._xobs
+        self._datainfo.y = self._yobs
+        self._datainfo.dy = self._dyobs
+        return

diffpy/srfit/structure/__init__.py

@@ -0,0 +1,60 @@
+#!/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.
+#
+##############################################################################
+"""Modules and classes that adapt structure representations to the ParameterSet
+interface and automatic structure constraint generation from space group
+information."""
+
+from diffpy.srfit.structure.sgconstraints import constrainAsSpaceGroup
+
+
+def struToParameterSet(name, stru):
+    """Creates a ParameterSet from an structure.
+
+    This returns a ParameterSet adapted for the structure depending on its
+    type.
+
+    stru    --  a structure object known by this module
+    name    --  A name to give the structure.
+
+    Raises TypeError if stru cannot be adapted
+    """
+    from diffpy.srfit.structure.diffpyparset import DiffpyStructureParSet
+
+    if DiffpyStructureParSet.canAdapt(stru):
+        return DiffpyStructureParSet(name, stru)
+
+    from diffpy.srfit.structure.objcrystparset import ObjCrystCrystalParSet
+
+    if ObjCrystCrystalParSet.canAdapt(stru):
+        return ObjCrystCrystalParSet(name, stru)
+
+    from diffpy.srfit.structure.objcrystparset import ObjCrystMoleculeParSet
+
+    if ObjCrystMoleculeParSet.canAdapt(stru):
+        return ObjCrystMoleculeParSet(name, stru)
+
+    from diffpy.srfit.structure.cctbxparset import CCTBXCrystalParSet
+
+    if CCTBXCrystalParSet.canAdapt(stru):
+        return CCTBXCrystalParSet(name, stru)
+
+    raise TypeError("Unadaptable structure format")
+
+
+# silence pyflakes checker
+assert constrainAsSpaceGroup
+
+
+# End of file

diffpy/srfit/structure/basestructureparset.py

@@ -0,0 +1,62 @@
+#!/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.
+#
+##############################################################################
+"""Base class for adapting structures to a ParameterSet interface.
+
+The BaseStructureParSet is a ParameterSet with functionality required by
+all structure adapters.
+"""
+
+__all__ = ["BaseStructureParSet"]
+
+from diffpy.srfit.fitbase.parameterset import ParameterSet
+
+
+class BaseStructureParSet(ParameterSet):
+    """Base class for structure adapters.
+
+    BaseStructureParSet derives from ParameterSet and provides methods that
+    help interface the ParameterSet with the space group constraint methods in
+    the sgconstraints module and to ProfileGenerators.
+
+    Attributes:
+    stru    --  The adapted object
+    """
+
+    @classmethod
+    def canAdapt(self, stru):
+        """Return whether the structure can be adapted by this class."""
+        return False
+
+    def getLattice(self):
+        """Get a ParameterSet containing the lattice Parameters.
+
+        The returned ParameterSet may contain other Parameters than the
+        lattice Parameters. It is assumed that the lattice parameters
+        are named "a", "b", "c", "alpha", "beta", "gamma".
+
+        Lattice must also have the "angunits" attribute, which is either
+        "deg" or "rad", to signify degrees or radians.
+        """
+        raise NotImplementedError("The must be overloaded")
+
+    def getScatterers(self):
+        """Get a list of ParameterSets that represents the scatterers.
+
+        The site positions must be accessible from the list entries via
+        the names "x", "y", and "z". The ADPs must be accessible as
+        well, but the name and nature of the ADPs (U-factors, B-factors,
+        isotropic, anisotropic) depends on the adapted structure.
+        """
+        raise NotImplementedError("The must be overloaded")