ipi 2.6.0__py3-none-any.whl

ipi/__init__.py

@@ -0,0 +1,7 @@
+"""
+The i-PI package.
+"""
+
+__all__ = ["clients", "engine", "inputs", "interfaces", "utils", "ipi_global_settings"]
+
+ipi_global_settings = {"floatformat": "%16.8e"}

ipi/_driver/driver.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+import socket
+import argparse
+import numpy as np
+
+try:
+    from pes import *
+except ImportError:
+    # when in an installed i-PI package
+    from ipi._driver.pes import *
+
+description = """
+Minimal example of a Python driver connecting to i-PI and exchanging energy, forces, etc.
+"""
+
+
+def recv_data(sock, data):
+    """Fetches binary data from i-PI socket."""
+    blen = data.itemsize * data.size
+    buf = np.zeros(blen, np.byte)
+
+    bpos = 0
+    while bpos < blen:
+        timeout = False
+        try:
+            bpart = 1
+            bpart = sock.recv_into(buf[bpos:], blen - bpos)
+        except socket.timeout:
+            print(" @SOCKET:   Timeout in status recvall, trying again!")
+            timeout = True
+            pass
+        if not timeout and bpart == 0:
+            raise RuntimeError("Socket disconnected!")
+        bpos += bpart
+    if np.isscalar(data):
+        return np.frombuffer(buf[0:blen], data.dtype)[0]
+    else:
+        return np.frombuffer(buf[0:blen], data.dtype).reshape(data.shape)
+
+
+def send_data(sock, data):
+    """Sends binary data to i-PI socket."""
+
+    if np.isscalar(data):
+        data = np.array([data], data.dtype)
+    buf = data.tobytes()
+    sock.send(buf)
+
+
+HDRLEN = 12  # number of characters of the default message strings
+
+
+def Message(mystr):
+    """Returns a header of standard length HDRLEN."""
+
+    # convert to bytestream since we'll be sending this over a socket
+    return str.ljust(str.upper(mystr), HDRLEN).encode()
+
+
+def run_driver(unix=False, address="", port=12345, driver=Dummy_driver()):
+    """Minimal socket client for i-PI."""
+
+    # Opens a socket to i-PI
+    if unix:
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.connect("/tmp/ipi_" + address)
+    else:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.connect((address, port))
+
+    f_init = False
+    f_data = False
+    f_verbose = False
+
+    # initializes structure arrays
+    cell = np.zeros((3, 3), float)
+    icell = np.zeros((3, 3), float)
+    pos = np.zeros(0, float)
+
+    # initializes return arrays
+    pot = 0.0
+    force = np.zeros(0, float)
+    vir = np.zeros((3, 3), float)
+    while True:  # ah the infinite loop!
+        header = sock.recv(HDRLEN)
+
+        if header == Message("STATUS"):
+            # responds to a status request
+            if not f_init:
+                sock.sendall(Message("NEEDINIT"))
+            elif f_data:
+                sock.sendall(Message("HAVEDATA"))
+            else:
+                sock.sendall(Message("READY"))
+        elif header == Message("INIT"):
+            # initialization
+            rid = recv_data(sock, np.int32())
+            initlen = recv_data(sock, np.int32())
+            initstr = recv_data(sock, np.chararray(initlen))
+            if f_verbose:
+                print(rid, initstr)
+            f_init = True  # we are initialized now
+        elif header == Message("POSDATA"):
+            # receives structural information
+            cell = recv_data(sock, cell)
+            icell = recv_data(
+                sock, icell
+            )  # inverse of the cell. mostly useless legacy stuff
+            nat = recv_data(sock, np.int32())
+            if len(pos) == 0:
+                # shapes up the position array
+                pos.resize((nat, 3))
+                force.resize((nat, 3))
+            else:
+                if len(pos) != nat:
+                    raise RuntimeError("Atom number changed during i-PI run")
+            pos = recv_data(sock, pos)
+
+            ##### THIS IS THE TIME TO DO SOMETHING WITH THE POSITIONS!
+            pot, force, vir, extras = driver(cell, pos)
+            f_data = True
+        elif header == Message("GETFORCE"):
+            sock.sendall(Message("FORCEREADY"))
+
+            # sanity check in the returned values (catches bugs and inconsistencies in the implementation)
+            if not isinstance(force, np.ndarray) and force.dtype == np.float64:
+                raise ValueError(
+                    "driver returned forces with the wrong type: we need a "
+                    "numpy.ndarray containing 64-bit floating points values"
+                )
+
+            if not isinstance(vir, np.ndarray) and vir.dtype == np.float64:
+                raise ValueError(
+                    "driver returned virial with the wrong type: we need a "
+                    "numpy.ndarray containing 64-bit floating points values"
+                )
+
+            if len(force.flatten()) != len(pos.flatten()):
+                raise ValueError(
+                    "driver returned forces with the wrong size: number of "
+                    "atoms and dimensions must match positions"
+                )
+
+            if len(vir.flatten()) != 9:
+                raise ValueError(
+                    "driver returned a virial tensor which does not have 9 components"
+                )
+
+            send_data(sock, np.float64(pot))
+            send_data(sock, np.int32(nat))
+            send_data(sock, force)
+            send_data(sock, vir)
+            send_data(sock, np.int32(len(extras)))
+            sock.sendall(extras.encode("utf-8"))
+
+            f_data = False
+        elif header == Message("EXIT"):
+            print("Received exit message from i-PI. Bye bye!")
+            return
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=description)
+
+    parser.add_argument(
+        "-u",
+        "--unix",
+        action="store_true",
+        default=False,
+        help="Use a UNIX domain socket.",
+    )
+    parser.add_argument(
+        "-a",
+        "--address",
+        type=str,
+        default="localhost",
+        help="Host name (for INET sockets) or name of the UNIX domain socket to connect to.",
+    )
+    parser.add_argument(
+        "-p",
+        "--port",
+        type=int,
+        default=12345,
+        help="TCP/IP port number. Ignored when using UNIX domain sockets.",
+    )
+    parser.add_argument(
+        "-m",
+        "--mode",
+        type=str,
+        default="dummy",
+        help="""Type of potential to be used to compute the potential and its derivatives.
+                Currently implemented: [dummy, harmonic]
+        """,
+    )
+    parser.add_argument(
+        "-o",
+        "--param",
+        type=str,
+        default="",
+        help="""Parameters required to run the driver. Comma-separated list of values
+        """,
+    )
+
+    args = parser.parse_args()
+
+    if args.mode in __drivers__:
+        d_f = __drivers__[args.mode](args.param)
+    elif args.mode == "dummy":
+        d_f = Dummy_driver(args.param)
+    else:
+        raise ValueError("Unsupported driver mode ", args.mode)
+
+    run_driver(
+        unix=args.unix,
+        address=args.address,
+        port=args.port,
+        driver=d_f,
+    )

ipi/_driver/pes/__init__.py

@@ -0,0 +1,14 @@
+""" Small functions/classes providing access to driver PES to be called from driver.py """
+
+from .dummy import Dummy_driver
+from .harmonic import Harmonic_driver
+from .rascal import Rascal_driver
+
+__all__ = ["__drivers__", "Dummy_driver", "Harmonic_driver", "Rascal_driver"]
+
+# dictionary linking strings
+__drivers__ = {
+    "dummy": Dummy_driver,
+    "harmonic": Harmonic_driver,
+    "rascal": Rascal_driver,
+}

ipi/_driver/pes/dummy.py

@@ -0,0 +1,17 @@
+class Dummy_driver(object):
+    def __init__(self, args=None):
+        """Initialized dummy drivers"""
+        self.args = args
+        self.check_arguments()
+
+    def check_arguments(self):
+        """Dummy function that checks the arguments required to run the driver"""
+        pass
+
+    def __call__(self, cell, pos):
+        """Does nothing, but returns properties that can be used by the driver loop."""
+        pot = 0.0
+        force = pos * 0.0  # makes a zero force with same shape as pos
+        vir = cell * 0.0  # makes a zero virial with same shape as cell
+        extras = "nada"
+        return pot, force, vir, extras

ipi/_driver/pes/harmonic.py

@@ -0,0 +1,30 @@
+""" Harmonic potential """
+
+import sys
+from .dummy import Dummy_driver
+
+
+class Harmonic_driver(Dummy_driver):
+    def __init__(self, args=None):
+        self.error_msg = """\nHarmonic driver requires specification of force constant.\nExample: python driver.py -m harmonic -u -o 1.3\n"""
+        super(Harmonic_driver, self).__init__(args)
+
+    def check_arguments(self):
+        """Function that checks the arguments required to run the driver"""
+        try:
+            k = list(map(float, self.args.split(",")))
+        except ValueError:
+            sys.exit(self.error_msg)
+
+        if len(k) == 1:
+            self.k = k[0]
+        else:
+            sys.exit(self.error_msg)
+
+    def __call__(self, cell, pos):
+        """Silly harmonic potential"""
+        pot = 0.5 * self.k * (pos**2).sum()
+        force = -self.k * pos  # makes a zero force with same shape as pos
+        vir = cell * 0.0  # makes a zero virial with same shape as cell
+        extras = "nada"
+        return pot, force, vir, extras

ipi/_driver/pes/rascal.py

@@ -0,0 +1,57 @@
+"""Interface with librascal to run machine learning potentials"""
+
+import sys
+from .dummy import Dummy_driver
+
+from ipi.utils.mathtools import det_ut3x3
+from ipi.utils.units import unit_to_internal, unit_to_user
+
+try:
+    from rascal.models.genericmd import GenericMDCalculator as RascalCalc
+except:
+    RascalCalc = None
+
+
+class Rascal_driver(Dummy_driver):
+    def __init__(self, args=None):
+        self.error_msg = """Rascal driver requires specification of a .json model file fitted with librascal, 
+                            and a template file that describes the chemical makeup of the structure. 
+                            Example: python driver.py -m rascal -u -o model.json,template.xyz"""
+
+        super().__init__(args)
+
+        if RascalCalc is None:
+            raise ImportError("Couldn't load librascal bindings")
+
+    def check_arguments(self):
+        """Check the arguments required to run the driver
+
+        This loads the potential and atoms template in librascal
+        """
+        try:
+            arglist = self.args.split(",")
+        except ValueError:
+            sys.exit(self.error_msg)
+
+        if len(arglist) == 2:
+            self.model = arglist[0]
+            self.template = arglist[1]
+        else:
+            sys.exit(self.error_msg)
+
+        self.rascal_calc = RascalCalc(self.model, True, self.template)
+
+    def __call__(self, cell, pos):
+        """Get energies, forces, and stresses from the librascal model"""
+        pos_rascal = unit_to_user("length", "angstrom", pos)
+        # librascal expects ASE-format, cell-vectors-as-rows
+        cell_rascal = unit_to_user("length", "angstrom", cell.T)
+        # Do the actual calculation
+        pot, force, stress = self.rascal_calc.calculate(pos_rascal, cell_rascal)
+        pot_ipi = unit_to_internal("energy", "electronvolt", pot)
+        force_ipi = unit_to_internal("force", "ev/ang", force)
+        # The rascal stress is normalized by the cell volume (in rascal units)
+        vir_rascal = -1 * stress * det_ut3x3(cell_rascal)
+        vir_ipi = unit_to_internal("energy", "electronvolt", vir_rascal.T)
+        extras = ""
+        return pot_ipi, force_ipi, vir_ipi, extras

ipi/engine/__init__.py

@@ -0,0 +1,25 @@
+"""
+Modules used to run simulations.
+"""
+
+# This file is part of i-PI.
+# i-PI Copyright (C) 2014-2015 i-PI developers
+# See the "licenses" directory for full license information.
+
+
+__all__ = [
+    "atoms",
+    "cell",
+    "simulation",
+    "forces",
+    "ensembles",
+    "properties",
+    "thermostats",
+    "barostats",
+    "beads",
+    "outputs",
+    "normalmodes",
+    "initializer",
+    "system",
+    "paratemp",
+]

ipi/engine/atoms.py

@@ -0,0 +1,273 @@
+"""Classes which deal with classical atoms.
+
+Used for holding information about the atoms, including their positions, masses
+momenta and kinetic energy. Has separate classes for accessing the global
+arrays of atoms and for individual atoms.
+"""
+
+# This file is part of i-PI.
+# i-PI Copyright (C) 2014-2015 i-PI developers
+# See the "licenses" directory for full license information.
+
+
+import numpy as np
+
+from ipi.utils.depend import *
+
+
+__all__ = ["Atoms", "Atom"]
+
+
+class Atom(dobject):
+
+    """Represent an atom, with position, velocity, mass and related properties.
+
+    This is actually only an interface to the Atoms class, i.e. only stores
+    views of the large arrays which contain all the coordinates.
+
+    Attributes:
+       kin: The kinetic energy of the atom.
+       kstress: The contribution of the atom to the kinetic stress tensor.
+
+    Depend objects:
+       p: The three components of the momentum of the atom.
+       q: The three components of the position of the atom.
+       m: The mass of the atom.
+       name: The name of the atom.
+       m3: An array of 3 elements with each element being the mass of the atom.
+          Used when each degree of freedom needs to be divided by the mass.
+    """
+
+    def __init__(self, system, index):
+        """Initialises Atom.
+
+        Args:
+           system: An Atoms object containing the required atom.
+           index: An integer giving the index of the required atom in the atoms
+              list. Note that indices start from 0.
+        """
+        dself = dd(self)  # direct access
+
+        dself.p = system.p[3 * index : 3 * index + 3]
+        dself.q = system.q[3 * index : 3 * index + 3]
+        dself.m = system.m[index : index + 1]
+        dself.name = system.names[index : index + 1]
+        dself.m3 = system.m3[3 * index : 3 * index + 3]
+
+    @property
+    def kin(self):
+        """Calculates the contribution of the atom to the kinetic energy."""
+
+        return np.dot(self.p, self.p) / (2.0 * self.m)
+
+    @property
+    def kstress(self):
+        """Calculates the contribution of the atom to the kinetic stress
+        tensor.
+        """
+
+        p = dstrip(self.p)
+        ks = np.zeros((3, 3), float)
+        for i in range(3):
+            for j in range(i, 3):
+                ks[i, j] = p[i] * p[j]
+        return ks / self.m
+
+
+class Atoms(dobject):
+
+    """Storage for the atoms' positions, masses and velocities.
+
+    Everything is stored as 3*n sized contiguous arrays,
+    and a convenience-access is provided through a list of Atom objects.
+
+    Attributes:
+       natoms: The number of atoms.
+
+    Depend objects:
+       p: An array giving the components of the atom positions.
+       q: An array giving the components of the atom momenta.
+       m: An array giving the atom masses.
+       names: An array giving the atom names.
+       m3: An array of 3*n elements where each element of m has been copied
+          three times. Used when each degree of freedom needs to be divided
+          by the mass.
+       M: The total mass of all the atoms.
+       kin: The total kinetic energy of the atoms. Depends on p and m3.
+       kstress: The contribution of the atoms to the kinetic stress tensor.
+          Depends on px, py, pz and m.
+       qx: An array giving the x components of the positions.
+       qy: An array giving the y components of the positions.
+       qz: An array giving the z components of the positions.
+       px: An array giving the x components of the momenta.
+       py: An array giving the y components of the momenta.
+       pz: An array giving the z components of the momenta.
+    """
+
+    def __init__(self, natoms, _prebind=None):
+        """Initialises Atoms.
+
+        Each replica and the centroid coordinate are all held as Atoms objects,
+        and so slices of the global position and momentum arrays must be used in
+        the initialisation so that they always agree with each other.
+
+        Args:
+           natoms: An integer giving the number of atoms.
+           _prebind: An optional tuple of four elements; a depend_array of length
+              3*natoms for the positions, another for the momenta, a depend_array
+              of length natoms for the masses and another for the names.
+        """
+
+        self.natoms = natoms
+
+        dself = dd(self)  # direct access
+
+        if _prebind is None:
+            dself.q = depend_array(name="q", value=np.zeros(3 * natoms, float))
+            dself.p = depend_array(name="p", value=np.zeros(3 * natoms, float))
+            dself.m = depend_array(name="m", value=np.zeros(natoms, float))
+            dself.names = depend_array(
+                name="names", value=np.zeros(natoms, np.dtype("|U6"))
+            )
+        else:
+            dself.q = _prebind[0]
+            dself.p = _prebind[1]
+            dself.m = _prebind[2]
+            dself.names = _prebind[3]
+
+        dself.m3 = depend_array(
+            name="m3",
+            value=np.zeros(3 * natoms, float),
+            func=self.mtom3,
+            dependencies=[dself.m],
+        )
+
+        dself.M = depend_value(name="M", func=self.get_msum, dependencies=[dself.m])
+        dself.kin = depend_value(
+            name="kin", func=self.get_kin, dependencies=[dself.p, dself.m3]
+        )
+        dself.kstress = depend_value(
+            name="kstress", func=self.get_kstress, dependencies=[dself.p, dself.m]
+        )
+
+    def copy(self):
+        """Creates a new Atoms object.
+
+        Returns:
+           An Atoms object with the same q, p, m and names arrays as the original.
+        """
+
+        newat = Atoms(self.natoms)
+        newat.q[:] = self.q
+        newat.p[:] = self.p
+        newat.m[:] = self.m
+        newat.names[:] = self.names
+        return newat
+
+    def __len__(self):
+        """Length function.
+
+        This is called whenever the standard function len(atoms) is used.
+
+        Returns:
+           The number of atoms.
+        """
+
+        return self.natoms
+
+    def __iter__(self):
+        """Iterator.
+
+        This is called whenever one iterates over an Atoms object.
+
+        Returns:
+           Itertor over all atoms in this Atoms object.
+        """
+
+        for index in range(len(self)):
+            yield Atom(self, index)
+
+    def __getitem__(self, index):
+        """Overwrites standard getting function.
+
+        This is called whenever the standard function atoms[index] is used.
+        Returns an Atom object with the appropriate position and momenta arrays.
+        Note that they are dynamically generated each time an Atom needs to be
+        accessed, as this reduces the number of depend objects that need to be
+        held at any one time.
+
+        Args:
+           index: The index of the atom to be accessed.
+
+        Returns:
+           The atom given by the index.
+        """
+
+        return Atom(self, index)
+
+    def __setitem__(self, index, value):
+        """Overwrites standard setting function.
+
+        This is called whenever the standard function atoms[index]=value is used.
+        Changes the position and momenta of the appropriate slice of the global
+        position and momentum arrays to those given by value.
+        Note that they are dynamically generated each time an Atom needs to be
+        accessed, as this reduces the number of depend objects that need to be
+        held at any one time.
+
+        Args:
+           index: The atom to be changed.
+           value: The Atom object that holds the new values.
+        """
+
+        pat = Atom(self, index)
+        pat.p = value.p
+        pat.q = value.q
+        pat.m = value.m
+        pat.name = value.name
+
+    def get_msum(self):
+        """Calculates the total mass."""
+
+        return self.m.sum()
+
+    def mtom3(self):
+        """Returns a 3*n mass array.
+
+        Returns:
+           An array of 3*n elements where each element of m has been copied
+           three times. Used when each degree of freedom needs to be divided
+           by the mass.
+        """
+
+        m3 = np.zeros(3 * self.natoms, float)
+        m3[0 : 3 * self.natoms : 3] = self.m
+        m3[1 : 3 * self.natoms : 3] = m3[0 : 3 * self.natoms : 3]
+        m3[2 : 3 * self.natoms : 3] = m3[0 : 3 * self.natoms : 3]
+        return m3
+
+    def get_kin(self):
+        """Calculates the total kinetic energy of the system."""
+
+        p = dstrip(self.p)
+        return 0.5 * np.dot(p, p / dstrip(self.m3))
+
+    def get_kstress(self):
+        """Calculates the total contribution of the atoms to the kinetic stress
+        tensor -- not volume-scaled
+        """
+
+        p = dstrip(self.p)
+        m = dstrip(self.m)
+        px = p[0::3]
+        py = p[1::3]
+        pz = p[2::3]
+
+        ks = np.zeros((3, 3), float)
+        ks[0, 0] = np.dot(px, px / m)
+        ks[1, 1] = np.dot(py, py / m)
+        ks[2, 2] = np.dot(pz, pz / m)
+        ks[0, 1] = np.dot(px, py / m)
+        ks[0, 2] = np.dot(px, pz / m)
+        ks[1, 2] = np.dot(py, pz / m)
+        return ks