diffpy.structure 3.2.0__py3-none-any.whl

diffpy/structure/parsers/p_xyz.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.structure  by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2007 trustees of the Michigan State University.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+
+"""Parser for XYZ file format, where
+
+    * First line gives number of atoms.
+    * Second line has optional title.
+    * Remaining lines contain element, `x, y, z`.
+"""
+
+import sys
+
+from diffpy.structure import Structure
+from diffpy.structure.parsers import StructureParser
+from diffpy.structure.structureerrors import StructureFormatError
+
+
+class P_xyz(StructureParser):
+    """Parser for standard XYZ structure format.
+
+    Attributes
+    ----------
+    format : str
+        Format name, default "xyz".
+    """
+
+    def __init__(self):
+        StructureParser.__init__(self)
+        self.format = "xyz"
+        return
+
+    def parseLines(self, lines):
+        """Parse list of lines in XYZ format.
+
+        Parameters
+        ----------
+        lines : list of str
+            List of lines in XYZ format.
+
+        Returns
+        -------
+        Structure
+            Parsed structure instance.
+
+        Raises
+        ------
+        StructureFormatError
+            Invalid XYZ format.
+        """
+        linefields = [line.split() for line in lines]
+        # prepare output structure
+        stru = Structure()
+        # find first valid record
+        start = 0
+        for field in linefields:
+            if len(field) == 0 or field[0] == "#":
+                start += 1
+            else:
+                break
+        # first valid line gives number of atoms
+        try:
+            lfs = linefields[start]
+            w1 = linefields[start][0]
+            if len(lfs) == 1 and str(int(w1)) == w1:
+                p_natoms = int(w1)
+                stru.title = lines[start + 1].strip()
+                start += 2
+            else:
+                emsg = "%d: invalid XYZ format, missing number of atoms" % (start + 1)
+                raise StructureFormatError(emsg)
+        except (IndexError, ValueError):
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            emsg = "%d: invalid XYZ format, missing number of atoms" % (start + 1)
+            e = StructureFormatError(emsg)
+            raise e.with_traceback(exc_traceback)
+        # find the last valid record
+        stop = len(lines)
+        while stop > start and len(linefields[stop - 1]) == 0:
+            stop -= 1
+        # get out for empty structure
+        if p_natoms == 0 or start >= stop:
+            return stru
+        # here we have at least one valid record line
+        nfields = len(linefields[start])
+        if nfields != 4:
+            emsg = "%d: invalid XYZ format, expected 4 columns" % (start + 1)
+            raise StructureFormatError(emsg)
+        # now try to read all record lines
+        try:
+            p_nl = start
+            for fields in linefields[start:]:
+                p_nl += 1
+                if fields == []:
+                    continue
+                elif len(fields) != nfields:
+                    emsg = ("%d: all lines must have " + "the same number of columns") % p_nl
+                    raise StructureFormatError(emsg)
+                element = fields[0]
+                element = element[0].upper() + element[1:].lower()
+                xyz = [float(f) for f in fields[1:4]]
+                stru.addNewAtom(element, xyz=xyz)
+        except ValueError:
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            emsg = "%d: invalid number format" % p_nl
+            e = StructureFormatError(emsg)
+            raise e.with_traceback(exc_traceback)
+        # finally check if all the atoms have been read
+        if p_natoms is not None and len(stru) != p_natoms:
+            emsg = "expected %d atoms, read %d" % (p_natoms, len(stru))
+            raise StructureFormatError(emsg)
+        return stru
+
+    def toLines(self, stru):
+        """Convert Structure stru to a list of lines in XYZ format.
+
+        Parameters
+        ----------
+        stru : Structure
+            Structure to be converted.
+
+        Returns
+        -------
+        list of str
+            List of lines in XYZ format.
+        """
+        lines = []
+        lines.append(str(len(stru)))
+        lines.append(stru.title)
+        for a in stru:
+            rc = a.xyz_cartn
+            s = "%-3s %g %g %g" % (a.element, rc[0], rc[1], rc[2])
+            lines.append(s)
+        return lines
+
+
+# End of class P_xyz
+
+# Routines -------------------------------------------------------------------
+
+
+def getParser():
+    """Return new `parser` object for XYZ format.
+
+    Returns
+    -------
+    P_xcfg
+        Instance of `P_xyz`.
+    """
+    return P_xyz()

diffpy/structure/parsers/parser_index_mod.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.structure  by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2007 trustees of the Michigan State University.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+
+"""Index of recognized structure formats, their IO capabilities and
+associated modules where they are defined.
+
+Attributes
+----------
+parser_index : dict
+    Dictionary of recognized structure formats. The keys are format names
+    and the values are dictionaries with the following keys:
+
+    module : str
+        Name of the module that defines the parser class.
+    file_extension : str
+        File extension for the format, including the leading dot.
+    file_pattern : str
+        File pattern for the format, using '|' as separator for multiple
+        patterns.
+    has_input : bool
+        ``True`` if the parser can read the format.
+    has_output : bool
+        ``True`` if the parser can write the format.
+
+Note
+----
+Plugins for new structure formats need to be added to the parser_index
+dictionary in this module.
+"""
+
+parser_index = {
+    # automatic format detection - tries all parsers one by one
+    "auto": {
+        "module": "p_auto",
+        "file_extension": "",
+        "file_pattern": "*.*",
+        "has_input": True,
+        "has_output": False,
+    },
+    # CIF format
+    "cif": {
+        "module": "p_cif",
+        "file_extension": ".cif",
+        "file_pattern": "*.cif",
+        "has_input": True,
+        "has_output": True,
+    },
+    # PDB format
+    "pdb": {
+        "module": "p_pdb",
+        "file_extension": ".pdb",
+        "file_pattern": "*.pdb",
+        "has_input": True,
+        "has_output": True,
+    },
+    # Discus structure format
+    "discus": {
+        "module": "p_discus",
+        "file_extension": ".stru",
+        "file_pattern": "*.stru|*.rstr",
+        "has_input": True,
+        "has_output": True,
+    },
+    # PDFfit structure format
+    "pdffit": {
+        "module": "p_pdffit",
+        "file_extension": ".stru",
+        "file_pattern": "*.stru|*.rstr",
+        "has_input": True,
+        "has_output": True,
+    },
+    # standard xyz file
+    "xyz": {
+        "module": "p_xyz",
+        "file_extension": ".xyz",
+        "file_pattern": "*.xyz",
+        "has_input": True,
+        "has_output": True,
+    },
+    # raw xyz file (element labels optional)
+    "rawxyz": {
+        "module": "p_rawxyz",
+        "file_extension": ".xyz",
+        "file_pattern": "*.xyz",
+        "has_input": True,
+        "has_output": True,
+    },
+    # AtomEye extended configuration format
+    "xcfg": {
+        "module": "p_xcfg",
+        "file_extension": "",
+        "file_pattern": "*.xcfg|*.eye|*.cfg",
+        "has_input": True,
+        "has_output": True,
+    },
+}

diffpy/structure/parsers/structureparser.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.structure  by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2008 trustees of the Michigan State University.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+
+"""Definition of StructureParser, a base class for specific parsers.
+"""
+
+
+class StructureParser(object):
+    """Base class for all structure parsers.
+
+    Attributes
+    ----------
+    format : str
+        Format name of particular parser.
+    filename : str
+        Path to structure file that is read or written.
+    """
+
+    def __init__(self):
+        self.format = None
+        self.filename = None
+        return
+
+    def parseLines(self, lines):
+        """Create Structure instance from a list of lines.
+
+        Return Structure object or raise StructureFormatError exception.
+
+        Note
+        ----
+        This method has to be overloaded in derived class.
+        """
+        raise NotImplementedError("parseLines not defined for '%s' format" % self.format)
+        return
+
+    def toLines(self, stru):
+        """Convert Structure stru to a list of lines.
+
+        Return list of strings.
+
+        Note
+        ----
+        This method has to be overloaded in derived class.
+        """
+        raise NotImplementedError("toLines not defined for '%s' format" % self.format)
+
+    def parse(self, s):
+        """Create `Structure` instance from a string."""
+        lines = s.rstrip("\r\n").split("\n")
+        stru = self.parseLines(lines)
+        return stru
+
+    def tostring(self, stru):
+        """Convert `Structure` instance to a string."""
+        lines = self.toLines(stru)
+        s = "\n".join(lines) + "\n"
+        return s
+
+    def parseFile(self, filename):
+        """Create Structure instance from an existing file."""
+        self.filename = filename
+        with open(filename) as fp:
+            s = fp.read()
+        stru = self.parse(s)
+        return stru
+
+
+# End of class StructureParser

diffpy/structure/pdffitstructure.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# diffpy.structure  by DANSE Diffraction group
+#                   Simon J. L. Billinge
+#                   (c) 2006 trustees of the Michigan State University.
+#                   All rights reserved.
+#
+# File coded by:    Pavol Juhas
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE_DANSE.txt for license information.
+#
+##############################################################################
+
+"""Definition of PDFFitStructure class derived from Structure
+"""
+
+
+from diffpy.structure.structure import Structure
+
+# ----------------------------------------------------------------------------
+
+
+class PDFFitStructure(Structure):
+    """PDFFitStructure --> Structure with extra pdffit member.
+
+    Parameters
+    ----------
+    *args, **kwargs :
+        See `Structure` class constructor.
+
+    Attributes
+    ----------
+    pdffit : dict
+        Dictionary for storing following extra parameters from
+        PDFFit structure files:
+            `'scale', 'delta1', 'delta2', 'sratio',
+            'rcut', 'spcgr', 'dcell', 'ncell'`
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.pdffit = {
+            "scale": 1.0,
+            "delta1": 0.0,
+            "delta2": 0.0,
+            "sratio": 1.0,
+            "rcut": 0.0,
+            "spcgr": "P1",
+            "spdiameter": 0.0,
+            "stepcut": 0.0,
+            "dcell": 6 * [0.0],
+            "ncell": [1, 1, 1, 0],
+        }
+        Structure.__init__(self, *args, **kwargs)
+        return
+
+    def read(self, filename, format="auto"):
+        """Same as `Structure.read`, but update `spcgr` value in
+        `self.pdffit` when parser can get spacegroup.
+
+        See `Structure.read()` for more info.
+
+        Parameters
+        ----------
+        filename : str
+            File to be loaded.
+        format : str, Optional
+            All structure formats are defined in parsers submodule,
+            when ``format == 'auto'`` all parsers are tried one by one.
+
+        Return
+        ------
+        StructureParser
+            Instance of StructureParser used to load the data.
+        """
+        p = Structure.read(self, filename, format)
+        sg = getattr(p, "spacegroup", None)
+        if sg:
+            self.pdffit["spcgr"] = sg.short_name
+        return p
+
+    def readStr(self, s, format="auto"):
+        """Same as `Structure.readStr`, but update `spcgr` value in
+        `self.pdffit` when parser can get spacegroup.
+
+        See `Structure.readStr()` for more info.
+
+        Parameters
+        ----------
+        s : str
+            String with structure definition.
+        format : str, Optional
+            All structure formats are defined in parsers submodule. When ``format == 'auto'``,
+            all parsers are tried one by one.
+
+        Return
+        ------
+        StructureParser
+            Instance of `StructureParser` used to load the data.
+        """
+        p = Structure.readStr(self, s, format)
+        sg = getattr(p, "spacegroup", None)
+        if sg:
+            self.pdffit["spcgr"] = sg.short_name
+        return p
+
+
+# End of class PDFFitStructure