diffpy.srfit 3.1.0__py3-none-any.whl

diffpy/srfit/pdf/pdfcontribution.py

@@ -0,0 +1,311 @@
+#!/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.
+#
+##############################################################################
+"""PDFContribution class.
+
+This is a custom FitContribution that simplifies the creation of PDF
+fits.
+"""
+
+__all__ = ["PDFContribution"]
+
+from diffpy.srfit.fitbase import FitContribution, Profile
+
+
+class PDFContribution(FitContribution):
+    """PDFContribution class.
+
+    PDFContribution is a FitContribution that is customized for PDF fits. Data
+    and phases can be added directly to the PDFContribution. Setup of
+    constraints and restraints requires direct interaction with the generator
+    attributes (see setPhase).
+
+    Attributes
+    name            --  A name for this FitContribution.
+    profile         --  A Profile that holds the measured (and calculated)
+                        signal.
+    _meta           --  Metadata dictionary. This is specific to this object,
+                        and not shared with the profile. This is used to record
+                        configuration options, like qmax.
+    _calculators    --  A managed dictionary of Calculators, indexed by name.
+    _constraints    --  A set of constrained Parameters. Constraints can be
+                        added using the 'constrain' methods.
+    _generators     --  A managed dictionary of ProfileGenerators.
+    _parameters     --  A managed OrderedDict of parameters.
+    _restraints     --  A set of Restraints. Restraints can be added using the
+                        'restrain' or 'confine' methods.
+    _parsets        --  A managed dictionary of ParameterSets.
+    _eqfactory      --  A diffpy.srfit.equation.builder.EquationFactory
+                        instance that is used to create constraints and
+                        restraints from string
+    _eq             --  The FitContribution equation that will be optimized.
+    _reseq          --  The residual equation.
+    _xname          --  Name of the x-variable
+    _yname          --  Name of the y-variable
+    _dyname         --  Name of the dy-variable
+
+    Managed Parameters:
+    scale   --  Scale factor
+    qbroad  --  Resolution peak broadening term
+    qdamp   --  Resolution peak dampening term
+    """
+
+    def __init__(self, name):
+        """Create the PDFContribution.
+
+        name        --  The name of the contribution.
+        """
+        FitContribution.__init__(self, name)
+        self._meta = {}
+        # Add the profile
+        profile = Profile()
+        self.setProfile(profile, xname="r")
+
+        # Need a parameter for the overall scale, in the case that this is a
+        # multi-phase fit.
+        self.newParameter("scale", 1.0)
+        # Profile-related parameters that will be shared between the generators
+        self.newParameter("qdamp", 0)
+        self.newParameter("qbroad", 0)
+        return
+
+    # Data methods
+
+    def loadData(self, data):
+        """Load the data in various formats.
+
+        This uses the PDFParser to load the data and then passes it to the
+        built-in profile with loadParsedData.
+
+        data    --  An open file-like object, name of a file that contains data
+                    or a string containing the data.
+        """
+        # Get the data into a string
+        from diffpy.srfit.util.inpututils import inputToString
+
+        datstr = inputToString(data)
+
+        # Load data with a PDFParser
+        from diffpy.srfit.pdf.pdfparser import PDFParser
+
+        parser = PDFParser()
+        parser.parseString(datstr)
+
+        # Pass it to the profile
+        self.profile.loadParsedData(parser)
+        return
+
+    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 savetxt(self, fname, **kwargs):
+        """Call numpy.savetxt with x, ycalc, y, dy.
+
+        This calls on the built-in Profile.
+
+        Arguments are passed to numpy.savetxt.
+        """
+        return self.profile.savetxt(fname, **kwargs)
+
+    # Phase methods
+
+    def addStructure(self, name, stru, periodic=True):
+        """Add a phase that goes into the PDF calculation.
+
+        name    --  A name to give the generator that will manage the PDF
+                    calculation from the passed structure. The adapted
+                    structure will be accessible via the name "phase" as an
+                    attribute of the generator, e.g.
+                    contribution.name.phase, where 'contribution' is this
+                    contribution and 'name' is passed name.
+                    (default), then the name will be set as "phase".
+        stru    --  diffpy.structure.Structure, pyobjcryst.crystal.Crystal or
+                    pyobjcryst.molecule.Molecule instance.  Default None.
+        periodic -- The structure should be treated as periodic.  If this is
+                    True (default), then a PDFGenerator will be used to
+                    calculate the PDF from the phase. Otherwise, a
+                    DebyePDFGenerator will be used. Note that some structures
+                    do not support periodicity, in which case this may be
+                    ignored.
+
+        Returns the new phase (ParameterSet appropriate for what was passed in
+        stru.)
+        """
+        # Based on periodic, create the proper generator.
+        if periodic:
+            from diffpy.srfit.pdf.pdfgenerator import PDFGenerator
+
+            gen = PDFGenerator(name)
+        else:
+            from diffpy.srfit.pdf.debyepdfgenerator import DebyePDFGenerator
+
+            gen = DebyePDFGenerator(name)
+
+        # Set up the generator
+        gen.setStructure(stru, "phase", periodic)
+        self._setupGenerator(gen)
+
+        return gen.phase
+
+    def addPhase(self, name, parset, periodic=True):
+        """Add a phase that goes into the PDF calculation.
+
+        name    --  A name to give the generator that will manage the PDF
+                    calculation from the passed parameter phase. The parset
+                    will be accessible via the name "phase" as an attribute
+                    of the generator, e.g., contribution.name.phase, where
+                    'contribution' is this contribution and 'name' is passed
+                    name.
+        parset  --  A SrRealParSet that holds the structural information.
+                    This can be used to share the phase between multiple
+                    BasePDFGenerators, and have the changes in one reflect in
+                    another.
+        periodic -- The structure should be treated as periodic.  If this is
+                    True (default), then a PDFGenerator will be used to
+                    calculate the PDF from the phase. Otherwise, a
+                    DebyePDFGenerator will be used. Note that some structures
+                    do not support periodicity, in which case this may be
+                    ignored.
+
+        Returns the new phase (ParameterSet appropriate for what was passed in
+        stru.)
+        """
+        # Based on periodic, create the proper generator.
+        if periodic:
+            from diffpy.srfit.pdf.pdfgenerator import PDFGenerator
+
+            gen = PDFGenerator(name)
+        else:
+            from diffpy.srfit.pdf.debyepdfgenerator import DebyePDFGenerator
+
+            gen = DebyePDFGenerator(name)
+
+        # Set up the generator
+        gen.setPhase(parset, periodic)
+        self._setupGenerator(gen)
+
+        return gen.phase
+
+    def _setupGenerator(self, gen):
+        """Setup a generator.
+
+        The generator must already have a managed SrRealParSet, added
+        with setStructure or setPhase.
+        """
+        # Add the generator to this FitContribution
+        self.addProfileGenerator(gen)
+
+        # Set the proper equation for the fit, depending on the number of
+        # phases we have.
+        gnames = self._generators.keys()
+        eqstr = " + ".join(gnames)
+        eqstr = "scale * (%s)" % eqstr
+        self.setEquation(eqstr)
+
+        # Update with our metadata
+        gen.meta.update(self._meta)
+        gen.processMetaData()
+
+        # Constrain the shared parameters
+        self.constrain(gen.qdamp, self.qdamp)
+        self.constrain(gen.qbroad, self.qbroad)
+        return
+
+    # Calculation setup methods
+
+    def _getMetaValue(self, kwd):
+        """Get metadata according to object hierarchy."""
+        # Check self, then generators then profile
+        if kwd in self._meta:
+            return self._meta[kwd]
+        for gen in self._generators.values():
+            if kwd in gen.meta:
+                return gen.meta[kwd]
+        val = self.profile.meta.get(kwd)
+        return val
+
+    def setScatteringType(self, type="X"):
+        """Set the scattering type.
+
+        type    --   "X" for x-ray or "N" for neutron
+
+        Raises ValueError if type is not "X" or "N"
+        """
+        self._meta["stype"] = type
+        for gen in self._generators.values():
+            gen.setScatteringType(type)
+        return
+
+    def getScatteringType(self):
+        """Get the scattering type.
+
+        See 'setScatteringType'.
+        """
+        return self._getMetaValue("stype")
+
+    def setQmax(self, qmax):
+        """Set the qmax value."""
+        self._meta["qmax"] = qmax
+        for gen in self._generators.values():
+            gen.setQmax(qmax)
+        return
+
+    def getQmax(self):
+        """Get the qmax value."""
+        return self._getMetaValue("qmax")
+
+    def setQmin(self, qmin):
+        """Set the qmin value."""
+        self._meta["qmin"] = qmin
+        for gen in self._generators.values():
+            gen.setQmin(qmin)
+        return
+
+    def getQmin(self):
+        """Get the qmin value."""
+        return self._getMetaValue("qmin")
+
+
+# End of file

diffpy/srfit/pdf/pdfgenerator.py

@@ -0,0 +1,77 @@
+#!/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 profile generator.
+
+The PDFGenerator class can take a diffpy.structure,
+pyobjcryst.crystal.Crystal or pyobjcryst.molecule.Molecule object and
+calculate the crystal PDF from it. The passed structure object is
+wrapped in a StructureParameter set, which makes its attributes
+refinable. See the class definition for more details and the examples
+for its use.
+"""
+
+__all__ = ["PDFGenerator"]
+
+from diffpy.srfit.pdf.basepdfgenerator import BasePDFGenerator
+
+
+class PDFGenerator(BasePDFGenerator):
+    """A class for calculating the PDF from a single crystal structure.
+
+    This works with diffpy.structure.Structure, pyobjcryst.crystal.Crystal and
+    pyobjcryst.molecule.Molecule instances. Note that the managed Parameters
+    are not created until the structure is added.
+
+    Attributes:
+    _calc   --  PDFCalculator instance for calculating the PDF
+    _phase  --  The structure ParameterSet used to calculate the profile.
+    _lastr  --  The last value of r over which the PDF was calculated. This is
+                used to configure the calculator when r changes.
+
+    Managed Parameters:
+    scale   --  Scale factor
+    delta1  --  Linear peak broadening term
+    delta2  --  Quadratic peak broadening term
+    qbroad  --  Resolution peak broadening term
+    qdamp   --  Resolution peak dampening term
+
+    Managed ParameterSets:
+    The structure ParameterSet (SrRealStructure instance) used to calculate the
+    profile is named by the user.
+
+    Usable Metadata:
+    stype   --  The scattering type "X" for x-ray, "N" for neutron (see
+                'setScatteringType').
+    qmax    --  The maximum scattering vector used to generate the PDF (see
+                setQmax).
+    qmin    --  The minimum scattering vector used to generate the PDF (see
+                setQmin).
+    scale   --  See Managed Parameters.
+    delta1  --  See Managed Parameters.
+    delta2  --  See Managed Parameters.
+    qbroad  --  See Managed Parameters.
+    qdamp   --  See Managed Parameters.
+    """
+
+    def __init__(self, name="pdf"):
+        """Initialize the generator."""
+        from diffpy.srreal.pdfcalculator import PDFCalculator
+
+        BasePDFGenerator.__init__(self, name)
+        self._setCalculator(PDFCalculator())
+        return
+
+
+# End class PDFGenerator

diffpy/srfit/pdf/pdfparser.py

@@ -0,0 +1,226 @@
+#!/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 PDF data.
+
+PDFParser is suitable for parsing data generated from PDFGetN and
+PDFGetX.
+
+See the class documentation for more information.
+"""
+
+__all__ = ["PDFParser"]
+
+import re
+
+import numpy
+
+from diffpy.srfit.exceptions import ParseError
+from diffpy.srfit.fitbase.profileparser import ProfileParser
+
+
+class PDFParser(ProfileParser):
+    """Class for holding a diffraction pattern.
+
+    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
+
+    stype       --  The scattering type ("X", "N")
+    qmin        --  Minimum scattering vector (float)
+    qmax        --  Maximum scattering vector (float)
+    qdamp       --  Resolution damping factor (float)
+    qbroad      --  Resolution broadening factor (float)
+    spdiameter  --  Nanoparticle diameter (float)
+    scale       --  Data scale (float)
+    temperature --  Temperature (float)
+    doping      --  Doping (float)
+    """
+
+    _format = "PDF"
+
+    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
+        """
+        # useful regex patterns:
+        rx = {"f": r"[-+]?(\d+(\.\d*)?|\d*\.\d+)([eE][-+]?\d+)?"}
+        # find where does the data start
+        res = re.search(r"^#+ start data\s*(?:#.*\s+)*", patstring, re.M)
+        # start_data is position where the first data line starts
+        if res:
+            start_data = res.end()
+        else:
+            # find line that starts with a floating point number
+            regexp = r"^\s*%(f)s" % rx
+            res = re.search(regexp, patstring, re.M)
+            if res:
+                start_data = res.start()
+            else:
+                start_data = 0
+        header = patstring[:start_data]
+        databody = patstring[start_data:].strip()
+
+        # find where the metadata starts
+        metadata = ""
+        res = re.search(r"^#+\ +metadata\b\n", header, re.M)
+        if res:
+            metadata = header[res.end() :]
+            header = header[: res.start()]
+
+        # parse header
+        meta = self._meta
+        # stype
+        if re.search("(x-?ray|PDFgetX)", header, re.I):
+            meta["stype"] = "X"
+        elif re.search("(neutron|PDFgetN)", header, re.I):
+            meta["stype"] = "N"
+        # qmin
+        regexp = r"\bqmin *= *(%(f)s)\b" % rx
+        res = re.search(regexp, header, re.I)
+        if res:
+            meta["qmin"] = float(res.groups()[0])
+        # qmax
+        regexp = r"\bqmax *= *(%(f)s)\b" % rx
+        res = re.search(regexp, header, re.I)
+        if res:
+            meta["qmax"] = float(res.groups()[0])
+        # qdamp
+        regexp = r"\b(?:qdamp|qsig) *= *(%(f)s)\b" % rx
+        res = re.search(regexp, header, re.I)
+        if res:
+            meta["qdamp"] = float(res.groups()[0])
+        # qbroad
+        regexp = r"\b(?:qbroad|qalp) *= *(%(f)s)\b" % rx
+        res = re.search(regexp, header, re.I)
+        if res:
+            meta["qbroad"] = float(res.groups()[0])
+        # spdiameter
+        regexp = r"\bspdiameter *= *(%(f)s)\b" % rx
+        res = re.search(regexp, header, re.I)
+        if res:
+            meta["spdiameter"] = float(res.groups()[0])
+        # dscale
+        regexp = r"\bdscale *= *(%(f)s)\b" % rx
+        res = re.search(regexp, header, re.I)
+        if res:
+            meta["scale"] = float(res.groups()[0])
+        # temperature
+        regexp = r"\b(?:temp|temperature|T)\ *=\ *(%(f)s)\b" % rx
+        res = re.search(regexp, header)
+        if res:
+            meta["temperature"] = float(res.groups()[0])
+        # doping
+        regexp = r"\b(?:x|doping)\ *=\ *(%(f)s)\b" % rx
+        res = re.search(regexp, header)
+        if res:
+            meta["doping"] = float(res.groups()[0])
+
+        # parsing general metadata
+        if metadata:
+            regexp = r"\b(\w+)\ *=\ *(%(f)s)\b" % rx
+            while True:
+                res = re.search(regexp, metadata, re.M)
+                if res:
+                    meta[res.groups()[0]] = float(res.groups()[1])
+                    metadata = metadata[res.end() :]
+                else:
+                    break
+
+        # read actual data - robs, Gobs, drobs, dGobs
+        inf_or_nan = re.compile("(?i)^[+-]?(NaN|Inf)\\b")
+        has_drobs = True
+        has_dGobs = True
+        # raise ParseError if something goes wrong
+        robs = []
+        Gobs = []
+        drobs = []
+        dGobs = []
+        try:
+            for line in databody.split("\n"):
+                v = line.split()
+                # there should be at least 2 value in the line
+                robs.append(float(v[0]))
+                Gobs.append(float(v[1]))
+                # drobs is valid if all values are defined and positive
+                has_drobs = (
+                    has_drobs and len(v) > 2 and not inf_or_nan.match(v[2])
+                )
+                if has_drobs:
+                    v2 = float(v[2])
+                    has_drobs = v2 > 0.0
+                    drobs.append(v2)
+                # dGobs is valid if all values are defined and positive
+                has_dGobs = (
+                    has_dGobs and len(v) > 3 and not inf_or_nan.match(v[3])
+                )
+                if has_dGobs:
+                    v3 = float(v[3])
+                    has_dGobs = v3 > 0.0
+                    dGobs.append(v3)
+        except (ValueError, IndexError) as err:
+            raise ParseError(err)
+        if has_drobs:
+            drobs = numpy.asarray(drobs)
+        else:
+            drobs = None
+        if has_dGobs:
+            dGobs = numpy.asarray(dGobs)
+        else:
+            dGobs = None
+
+        robs = numpy.asarray(robs)
+        Gobs = numpy.asarray(Gobs)
+
+        self._banks.append([robs, Gobs, drobs, dGobs])
+        return
+
+
+# End of PDFParser

diffpy/srfit/sas/__init__.py

@@ -0,0 +1,30 @@
+#!/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 calculation tools."""
+
+__all__ = [
+    "SASGenerator",
+    "SASParser",
+    "SASProfile",
+    "PrCalculator",
+    "CFCalculator",
+]
+
+from .prcalculator import CFCalculator, PrCalculator
+from .sasgenerator import SASGenerator
+from .sasparser import SASParser
+from .sasprofile import SASProfile
+
+# End of file