diffpy.srfit 3.1.0__py3-none-any.whl

diffpy/srfit/structure/bvsrestraint.py

@@ -0,0 +1,101 @@
+#!/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.
+#
+##############################################################################
+"""Bond-valence sum calculator from SrReal wrapped as a Restraint.
+
+This can be used as an addition to a cost function during a structure
+refinement to keep the bond-valence sum within tolerable limits.
+"""
+
+__all__ = ["BVSRestraint"]
+
+from diffpy.srfit.exceptions import SrFitError
+from diffpy.srfit.fitbase.restraint import Restraint
+
+
+class BVSRestraint(Restraint):
+    """Wrapping of BVSCalculator.bvmsdiff as a Restraint.
+
+    The restraint penalty is the root-mean-square deviation of the theoretical
+    and calculated bond-valence sum of a structure.
+
+    Attributes:
+    _calc   --  The SrReal BVSCalculator instance.
+    _parset --  The SrRealParSet that created this BVSRestraint.
+    sig     --  The uncertainty on the BVS (default 1).
+    scaled  --  A flag indicating if the restraint is scaled (multiplied)
+                by the unrestrained point-average chi^2 (chi^2/numpoints)
+                (default False).
+    """
+
+    def __init__(self, parset, sig=1, scaled=False):
+        """Initialize the Restraint.
+
+        parset  --  SrRealParSet that creates this BVSRestraint.
+        sig     --  The uncertainty on the BVS (default 1).
+        scaled  --  A flag indicating if the restraint is scaled
+                    (multiplied) by the unrestrained point-average chi^2
+                    (chi^2/numpoints) (bool, default False).
+        """
+        from diffpy.srreal.bvscalculator import BVSCalculator
+
+        self._calc = BVSCalculator()
+        self._parset = parset
+        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 (float, default 1.0).
+        """
+        # Get the bvms from the BVSCalculator
+        stru = self._parset._getSrRealStructure()
+        self._calc.eval(stru)
+        penalty = self._calc.bvmsdiff
+
+        # Scale by the prefactor
+        penalty /= self.sig**2
+
+        # Optionally scale by w
+        if self.scaled:
+            penalty *= w
+
+        return penalty
+
+    def _validate(self):
+        """This evaluates the calculator.
+
+        Raises SrFitError if validation fails.
+        """
+        from numpy import nan
+
+        p = self.penalty()
+        if p is None or p is nan:
+            raise SrFitError("Cannot evaluate penalty")
+        v = self._calc.value
+        if len(v) > 1 and not v.any():
+            emsg = (
+                "Bond valence sums are all zero.  Check atom symbols in "
+                "the structure or define custom bond-valence parameters."
+            )
+            raise SrFitError(emsg)
+        return
+
+    # End of class BVSRestraint
+
+
+# End of file

diffpy/srfit/structure/cctbxparset.py

@@ -0,0 +1,292 @@
+#!/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.
+#
+##############################################################################
+"""Wrappers for interfacing cctbx crystal with SrFit.
+
+This wraps a cctbx.crystal as a ParameterSet with a similar hierarchy, which
+can then be used within a FitRecipe. Note that all manipulations to the
+cctbx.crystal should be done before wrapping. Changes made to the cctbx.crystal
+object after wrapping may not be reflected within the wrapper, which can have
+unpredictable results during a structure refinement.
+
+Classes:
+
+CCTBXCrystalParSet  --  Wrapper for cctbx.crystal
+CCTBXUnitCellParSet --  Wrapper for the unit cell of cctbx.crystal
+CCTBXScattererParSet --  Wrapper for cctbx.xray.scatterer
+"""
+
+from diffpy.srfit.fitbase.parameter import ParameterAdapter
+from diffpy.srfit.fitbase.parameterset import ParameterSet
+from diffpy.srfit.structure.basestructureparset import BaseStructureParSet
+
+__all__ = ["CCTBXScattererParSet", "CCTBXUnitCellParSet", "CCTBXCrystalParSet"]
+
+
+class CCTBXScattererParSet(ParameterSet):
+    """A wrapper for cctbx.xray.scatterer.
+
+    This class derives from ParameterSet.
+
+    Attributes:
+    name        --  Name of the scatterer. The name is always of the form
+                    "%s%i" % (element, number), where the number is the running
+                    index of that element type (starting at 0).
+    x (y, z)    --  Atom position in crystal coordinates (ParameterAdapter)
+    occupancy   --  Occupancy of the atom on its crystal location
+                    (ParameterAdapter)
+    Uiso        --  Isotropic scattering factor (ParameterAdapter).
+    """
+
+    def __init__(self, name, strups, idx):
+        """Initialize.
+
+        name    --  The name of this scatterer.
+        strups  --  The CCTBXCrystalParSet that contains the cctbx structure
+        idx     --  The index of the scatterer in the structure.
+        """
+        ParameterSet.__init__(self, name)
+        self.strups = strups
+        self.idx = idx
+
+        # x, y, z, occupancy
+        self.addParameter(
+            ParameterAdapter("x", None, self._xyzgetter(0), self._xyzsetter(0))
+        )
+        self.addParameter(
+            ParameterAdapter("y", None, self._xyzgetter(1), self._xyzsetter(1))
+        )
+        self.addParameter(
+            ParameterAdapter("z", None, self._xyzgetter(2), self._xyzsetter(2))
+        )
+        self.addParameter(
+            ParameterAdapter("occupancy", None, self._getocc, self._setocc)
+        )
+        self.addParameter(
+            ParameterAdapter("Uiso", None, self._getuiso, self._setuiso)
+        )
+        return
+
+    # Getters and setters
+
+    def _xyzgetter(self, i):
+
+        def f(dummy):
+            return self.strups.stru.scatterers()[self.idx].site[i]
+
+        return f
+
+    def _xyzsetter(self, i):
+
+        def f(dummy, value):
+            xyz = list(self.strups.stru.scatterers()[self.idx].site)
+            xyz[i] = value
+            self.strups.stru.scatterers()[self.idx].site = tuple(xyz)
+            return
+
+        return f
+
+    def _getocc(self, dummy):
+        return self.strups.stru.scatterers()[self.idx].occupancy
+
+    def _setocc(self, dummy, value):
+        self.strups.stru.scatterers()[self.idx].occupancy = value
+        return
+
+    def _getuiso(self, dummy):
+        return self.strups.stru.scatterers()[self.idx].u_iso
+
+    def _setuiso(self, dummy, value):
+        self.strups.stru.scatterers()[self.idx].u_iso = value
+        return
+
+    def _getElem(self):
+        return self.stru.element_symbol()
+
+    element = property(_getElem)
+
+
+# End class CCTBXScattererParSet
+
+
+class CCTBXUnitCellParSet(ParameterSet):
+    """A wrapper for cctbx unit_cell object.
+
+    Attributes:
+    name    --  Always "unitcell".
+    a, b, c, alpha, beta, gamma --  Unit cell parameters (ParameterAdapter).
+    """
+
+    def __init__(self, strups):
+        """Initialize.
+
+        strups  --  The CCTBXCrystalParSet that contains the cctbx structure
+                    and the unit cell we're wrapper.
+        """
+        ParameterSet.__init__(self, "unitcell")
+        self.strups = strups
+        self._latpars = list(self.strups.stru.unit_cell().parameters())
+
+        self.addParameter(
+            ParameterAdapter("a", None, self._latgetter(0), self._latsetter(0))
+        )
+        self.addParameter(
+            ParameterAdapter("b", None, self._latgetter(1), self._latsetter(1))
+        )
+        self.addParameter(
+            ParameterAdapter("c", None, self._latgetter(2), self._latsetter(2))
+        )
+        self.addParameter(
+            ParameterAdapter(
+                "alpha", None, self._latgetter(3), self._latsetter(3)
+            )
+        )
+        self.addParameter(
+            ParameterAdapter(
+                "beta", None, self._latgetter(4), self._latsetter(4)
+            )
+        )
+        self.addParameter(
+            ParameterAdapter(
+                "gamma", None, self._latgetter(5), self._latsetter(5)
+            )
+        )
+
+        return
+
+    def _latgetter(self, i):
+
+        def f(dummy):
+            return self._latpars[i]
+
+        return f
+
+    def _latsetter(self, i):
+
+        def f(dummy, value):
+            self._latpars[i] = value
+            self.strups._update = True
+            return
+
+        return f
+
+
+# End class CCTBXUnitCellParSet
+
+# FIXME - Special positions should be constant.
+
+
+class CCTBXCrystalParSet(BaseStructureParSet):
+    """A wrapper for CCTBX structure.
+
+    Attributes:
+    stru        --  The adapted cctbx structure object.
+    scatterers  --  The list of ScattererParSets.
+    unitcell    --  The CCTBXUnitCellParSet for the structure.
+    """
+
+    def __init__(self, name, stru):
+        """Initialize.
+
+        name    --  A name for this
+        stru    --  A CCTBX structure instance.
+        """
+        ParameterSet.__init__(self, name)
+        self.stru = stru
+        self.addParameterSet(CCTBXUnitCellParSet(self))
+        self.scatterers = []
+
+        self._update = False
+
+        cdict = {}
+        for s in stru.scatterers():
+            el = s.element_symbol()
+            i = cdict.get(el, 0)
+            sname = "%s%i" % (el, i)
+            cdict[el] = i + 1
+            scatterer = CCTBXScattererParSet(sname, self, i)
+            self.addParameterSet(scatterer)
+            self.scatterers.append(scatterer)
+
+        # Constrain the lattice
+        from diffpy.srfit.structure.sgconstraints import _constrainSpaceGroup
+
+        symbol = self.getSpaceGroup()
+        _constrainSpaceGroup(self, symbol)
+
+        return
+
+    def update(self):
+        """Update the unit_cell to a change in lattice parameters.
+
+        This remakes the unit cell according to a change in the lattice
+        parameters. Call this function before using the
+        CCTBXCrystalParSet. The unit_cell will only be remade if
+        necessary.
+        """
+        if not self._update:
+            return
+
+        self._update = False
+        stru = self.stru
+        sgn = stru.space_group().match_tabulated_settings().number()
+
+        # Create the symmetry object
+        from cctbx.crystal import symmetry
+
+        symm = symmetry(
+            unit_cell=self.unitcell._latpars, space_group_symbol=sgn
+        )
+
+        # Now the new structure
+        newstru = stru.__class__(
+            crystal_symmetry=symm, scatterers=stru.scatterers()
+        )
+
+        self.unitcell._latpars = list(newstru.unit_cell().parameters())
+
+        self.stru = newstru
+        return
+
+    @classmethod
+    def canAdapt(self, stru):
+        """Return whether the structure can be adapted by this class."""
+        try:
+            from cctbx.crystal import special_position_settings
+        except ImportError:
+            return False
+        return isinstance(stru, special_position_settings)
+
+    def getLattice(self):
+        """Get the ParameterSet containing the lattice Parameters."""
+        return self.unitcell
+
+    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.
+        """
+        return self.scatterers
+
+    def getSpaceGroup(self):
+        """Get the HM space group symbol for the structure."""
+        sg = self.stru.space_group()
+        t = sg.type()
+        return t.lookup_symbol()
+
+
+# End class CCTBXCrystalParSet

diffpy/srfit/structure/diffpyparset.py

@@ -0,0 +1,303 @@
+#!/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.
+#
+##############################################################################
+"""Adapters for interfacing a diffpy.structure.Structure with SrFit.
+
+A diffpy.structure.Structure object is meant to be passed to a
+DiffpyStructureParSet object from this module, which can then be used as a
+ParameterSet. (It has other methods for interfacing with SrReal calculator
+adapters.) Any change to the lattice or existing atoms will be registered with
+the Structure. Changes in the number of atoms will not be recognized.  Thus,
+the diffpy.structure.Structure object should be fully configured before passing
+it to DiffpyStructureParSet.
+
+DiffpyStructureParSet --  Adapter for diffpy.structure.Structure
+DiffpyLatticeParSet   --  Adapter for diffpy.structure.Lattice
+DiffpyAtomParSet      --  Adapter for diffpy.structure.Atom
+"""
+
+__all__ = ["DiffpyStructureParSet"]
+
+from diffpy.srfit.fitbase.parameter import ParameterAdapter, ParameterProxy
+from diffpy.srfit.fitbase.parameterset import ParameterSet
+from diffpy.srfit.structure.srrealparset import SrRealParSet
+from diffpy.srfit.util.argbinders import bind2nd
+
+
+# Accessor for xyz of atoms
+class _xyzgetter(object):
+
+    def __init__(self, i):
+        self.i = i
+
+    def __call__(self, atom):
+        return atom.xyz[self.i]
+
+
+class _xyzsetter(object):
+
+    def __init__(self, i):
+        self.i = i
+
+    def __call__(self, atom, value):
+        atom.xyz[self.i] = value
+
+
+class DiffpyAtomParSet(ParameterSet):
+    """A wrapper for diffpy.structure.Atom.
+
+    This class derives from diffpy.srfit.fitbase.parameterset.ParameterSet. See
+    this class for base attributes.
+
+    Attributes:
+    atom        --  The diffpy.structure.Atom this is adapting
+    element     --  The element name (property).
+
+    Managed Parameters:
+    x (y, z)    --  Atom position in crystal coordinates (ParameterAdapter)
+    occupancy   --  Occupancy of the atom on its crystal location
+                    (ParameterAdapter)
+    occ         --  Proxy for occupancy (ParameterProxy).
+    U11, U22, U33, U12, U21, U23, U32, U13, U31
+                --  Anisotropic displacement factor for atom (ParameterAdapter
+                    or ParameterProxy). Note that the Uij and Uji parameters
+                    are the same.
+    Uiso        --  Isotropic ADP (ParameterAdapter).
+    B11, B22, B33, B12, B21, B23, B32, B13, B31
+                --  Anisotropic displacement factor for atom (ParameterAdapter
+                    or ParameterProxy). Note that the Bij and Bji parameters
+                    are the same. (Bij = 8*pi**2*Uij)
+    Biso        --  Isotropic ADP (ParameterAdapter).
+    """
+
+    def __init__(self, name, atom):
+        """Initialize.
+
+        atom    --  A diffpy.structure.Atom instance
+        """
+        ParameterSet.__init__(self, name)
+        self.atom = atom
+        a = atom
+        # x, y, z, occupancy
+        self.addParameter(
+            ParameterAdapter("x", a, _xyzgetter(0), _xyzsetter(0))
+        )
+        self.addParameter(
+            ParameterAdapter("y", a, _xyzgetter(1), _xyzsetter(1))
+        )
+        self.addParameter(
+            ParameterAdapter("z", a, _xyzgetter(2), _xyzsetter(2))
+        )
+        occupancy = ParameterAdapter("occupancy", a, attr="occupancy")
+        self.addParameter(occupancy)
+        self.addParameter(ParameterProxy("occ", occupancy))
+        # U
+        self.addParameter(ParameterAdapter("U11", a, attr="U11"))
+        self.addParameter(ParameterAdapter("U22", a, attr="U22"))
+        self.addParameter(ParameterAdapter("U33", a, attr="U33"))
+        U12 = ParameterAdapter("U12", a, attr="U12")
+        U21 = ParameterProxy("U21", U12)
+        U13 = ParameterAdapter("U13", a, attr="U13")
+        U31 = ParameterProxy("U31", U13)
+        U23 = ParameterAdapter("U23", a, attr="U23")
+        U32 = ParameterProxy("U32", U23)
+        self.addParameter(U12)
+        self.addParameter(U21)
+        self.addParameter(U13)
+        self.addParameter(U31)
+        self.addParameter(U23)
+        self.addParameter(U32)
+        self.addParameter(ParameterAdapter("Uiso", a, attr="Uisoequiv"))
+        # B
+        self.addParameter(ParameterAdapter("B11", a, attr="B11"))
+        self.addParameter(ParameterAdapter("B22", a, attr="B22"))
+        self.addParameter(ParameterAdapter("B33", a, attr="B33"))
+        B12 = ParameterAdapter("B12", a, attr="B12")
+        B21 = ParameterProxy("B21", B12)
+        B13 = ParameterAdapter("B13", a, attr="B13")
+        B31 = ParameterProxy("B31", B13)
+        B23 = ParameterAdapter("B23", a, attr="B23")
+        B32 = ParameterProxy("B32", B23)
+        self.addParameter(B12)
+        self.addParameter(B21)
+        self.addParameter(B13)
+        self.addParameter(B31)
+        self.addParameter(B23)
+        self.addParameter(B32)
+        self.addParameter(ParameterAdapter("Biso", a, attr="Bisoequiv"))
+        return
+
+    def __repr__(self):
+        return repr(self.atom)
+
+    def _getElem(self):
+        return self.atom.element
+
+    def _setElem(self, el):
+        self.atom.element = el
+
+    element = property(_getElem, _setElem, "type of atom")
+
+
+# End class DiffpyAtomParSet
+
+
+def _latgetter(par):
+    return bind2nd(getattr, par)
+
+
+def _latsetter(par):
+    return bind2nd(setattr, par)
+
+
+class DiffpyLatticeParSet(ParameterSet):
+    """A wrapper for diffpy.structure.Lattice.
+
+    This class derives from diffpy.srfit.fitbase.parameterset.ParameterSet. See
+    this class for base attributes.
+
+    Attributes
+    lattice     --  The diffpy.structure.Lattice this is adapting
+    name        --  Always "lattice"
+    angunits    --  "deg", the units of angle
+
+    Managed Parameters:
+    a, b, c, alpha, beta, gamma --  The lattice parameters (ParameterAdapter).
+    """
+
+    def __init__(self, lattice):
+        """Initialize.
+
+        lattice --  A diffpy.structure.Lattice instance
+        """
+        ParameterSet.__init__(self, "lattice")
+        self.angunits = "deg"
+        self.lattice = lattice
+        lat = lattice
+        self.addParameter(
+            ParameterAdapter("a", lat, _latgetter("a"), _latsetter("a"))
+        )
+        self.addParameter(
+            ParameterAdapter("b", lat, _latgetter("b"), _latsetter("b"))
+        )
+        self.addParameter(
+            ParameterAdapter("c", lat, _latgetter("c"), _latsetter("c"))
+        )
+        self.addParameter(
+            ParameterAdapter(
+                "alpha", lat, _latgetter("alpha"), _latsetter("alpha")
+            )
+        )
+        self.addParameter(
+            ParameterAdapter(
+                "beta", lat, _latgetter("beta"), _latsetter("beta")
+            )
+        )
+        self.addParameter(
+            ParameterAdapter(
+                "gamma", lat, _latgetter("gamma"), _latsetter("gamma")
+            )
+        )
+        return
+
+    def __repr__(self):
+        return repr(self.lattice)
+
+
+# End class DiffpyLatticeParSet
+
+
+class DiffpyStructureParSet(SrRealParSet):
+    """A wrapper for diffpy.structure.Structure.
+
+    This class derives from diffpy.srfit.fitbase.parameterset.ParameterSet. See
+    this class for base attributes.
+
+    Attributes:
+    atoms   --  The list of DiffpyAtomParSets, provided for convenience.
+    stru    --  The diffpy.structure.Structure this is adapting
+
+    Managed ParameterSets:
+    lattice     --  The managed DiffpyLatticeParSet
+    <el><idx>   --  A managed DiffpyAtomParSets. <el> is the atomic element and
+                    <idx> is the index of that element in the structure,
+                    starting from zero. Thus, for nickel in P1 symmetry, the
+                    managed DiffpyAtomParSets will be named "Ni0", "Ni1", "Ni2"
+                    and "Ni3".
+    """
+
+    def __init__(self, name, stru):
+        """Initialize.
+
+        name    --  A name for the structure
+        stru    --  A diffpy.structure.Structure instance
+        """
+        SrRealParSet.__init__(self, name)
+        self.stru = stru
+        self.addParameterSet(DiffpyLatticeParSet(stru.lattice))
+        self.atoms = []
+
+        cdict = {}
+        for a in stru:
+            el = a.element.title()
+            # Try to sanitize the name.
+            el = el.replace("+", "p")
+            el = el.replace("-", "m")
+            i = cdict.get(el, 0)
+            aname = "%s%i" % (el, i)
+            cdict[el] = i + 1
+            atom = DiffpyAtomParSet(aname, a)
+            self.addParameterSet(atom)
+            self.atoms.append(atom)
+
+        return
+
+    def __repr__(self):
+        return repr(self.stru)
+
+    def getLattice(self):
+        """Get the ParameterSet containing the lattice Parameters."""
+        return self.lattice
+
+    @classmethod
+    def canAdapt(self, stru):
+        """Return whether the structure can be adapted by this class."""
+        from diffpy.structure import Structure
+
+        return isinstance(stru, Structure)
+
+    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.
+        """
+        return self.atoms
+
+    def _getSrRealStructure(self):
+        """Get the structure object for use with SrReal calculators.
+
+        If this is periodic, then return the structure, otherwise, pass
+        it inside of a nosymmetry wrapper. This takes the extra step of
+        wrapping the structure in a nometa wrapper.
+        """
+        from diffpy.srreal.structureadapter import nometa
+
+        stru = SrRealParSet._getSrRealStructure(self)
+        return nometa(stru)
+
+
+# End class DiffpyStructureParSet