imdclient 0.1.4__py3-none-any.whl → 0.2.0b0__py3-none-any.whl

imdclient/IMDClient.py

@@ -1,18 +1,27 @@
 """
-
-IMDClient
-^^^^^^^^^
+IMDClient module
+================
 
 .. autoclass:: IMDClient
    :members:
 
+.. autoclass:: BaseIMDProducer
+   :members:
+   :inherited-members:
+
+.. autoclass:: IMDProducerV2
+   :members:
+   :inherited-members:
+
 .. autoclass:: IMDProducerV3
    :members:
    :inherited-members:
 
 .. autoclass:: IMDFrameBuffer
    :members:
-   
+
+.. autoclass:: IMDFrame
+   :members:
 """
 
 import socket
@@ -43,7 +52,7 @@ class IMDClient:
     socket_bufsize : int, (optional)
         Size of the socket buffer in bytes. Default is to use the system default
     buffer_size : int (optional)
-        IMDFramebuffer will be filled with as many :class:`IMDFrame` fit in `buffer_size` bytes [``10MB``]
+        :class:`IMDFrameBuffer` will be filled with as many :class:`IMDFrame` fit in `buffer_size` bytes [``10MB``]
     timeout : int, optional
         Timeout for the socket in seconds [``5``]
     continue_after_disconnect : bool, optional [``None``]
@@ -138,10 +147,11 @@ class IMDClient:
 
             self._producer.start()
 
-    def signal_handler(self, sig, frame):
-        """Catch SIGINT to allow clean shutdown on CTRL+C
+    def signal_handler(self):
+        """Catch SIGINT to allow clean shutdown on CTRL+C.
+
         This also ensures that main thread execution doesn't get stuck
-        waiting in buf.pop_full_imdframe()"""
+        waiting in ``buf.pop_full_imdframe()``"""
         logger.debug("Intercepted signal")
         self.stop()
         logger.debug("Shutdown success")
@@ -207,9 +217,7 @@ class IMDClient:
             # /proc/sys/net/core/rmem_default
             # Max (linux):
             # /proc/sys/net/core/rmem_max
-            conn.setsockopt(
-                socket.SOL_SOCKET, socket.SO_RCVBUF, socket_bufsize
-            )
+            conn.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, socket_bufsize)
         try:
             logger.debug(f"IMDClient: Connecting to {host}:{port}")
             conn.connect((host, port))
@@ -307,8 +315,8 @@ class IMDClient:
             )
             self._conn.sendall(wait_packet)
             logger.debug(
-                "IMDClient: Attempted to change wait behavior to %s", 
-                not self._continue_after_disconnect 
+                "IMDClient: Attempted to change wait behavior to %s",
+                not self._continue_after_disconnect,
             )
 
     def _disconnect(self):
@@ -785,9 +793,7 @@ class IMDFrameBuffer:
             raise ValueError("pause_empty_proportion must be between 0 and 1")
         self._pause_empty_proportion = pause_empty_proportion
         if unpause_empty_proportion < 0 or unpause_empty_proportion > 1:
-            raise ValueError(
-                "unpause_empty_proportion must be between 0 and 1"
-            )
+            raise ValueError("unpause_empty_proportion must be between 0 and 1")
         self._unpause_empty_proportion = unpause_empty_proportion
 
         if buffer_size <= 0:
@@ -854,9 +860,7 @@ class IMDFrameBuffer:
                 logger.debug("IMDProducer: Noticing consumer finished")
                 raise EOFError
         except Exception as e:
-            logger.debug(
-                f"IMDProducer: Error waiting for space in buffer: {e}"
-            )
+            logger.debug(f"IMDProducer: Error waiting for space in buffer: {e}")
 
     def pop_empty_imdframe(self):
         logger.debug("IMDProducer: Getting empty frame")
@@ -902,9 +906,7 @@ class IMDFrameBuffer:
             imdf = self._full_q.get()
         else:
             with self._full_imdf_avail:
-                while (
-                    self._full_q.qsize() == 0 and not self._producer_finished
-                ):
+                while self._full_q.qsize() == 0 and not self._producer_finished:
                     self._full_imdf_avail.wait()
 
             if self._producer_finished and self._full_q.qsize() == 0:

imdclient/__init__.py

@@ -6,9 +6,4 @@ IMDClient
 from .IMDClient import IMDClient
 from importlib.metadata import version
 
-from .streamanalysis import AnalysisBase, StackableAnalysis
-from MDAnalysis.analysis import base
-
-base.AnalysisBase = AnalysisBase
-
 __version__ = version("imdclient")

imdclient/data/namd/md/namd_v3_nst_1.namd

@@ -1,7 +1,7 @@
 # This is a test namd configuration file
 
 timestep	0.5
-numsteps	10
+numsteps	100
 structure	alanin.psf
 parameters	alanin.params
 coordinates	alanin.pdb

imdclient/tests/base.py

@@ -1,20 +1,17 @@
-from imdclient.IMDClient import IMDClient
-from imdclient.IMD import IMDReader
-import pytest
-from pathlib import Path
-import os
-import signal
-import subprocess
 import time
+import logging
+import shutil
+
+import pytest
+import numpy as np
 from numpy.testing import (
     assert_allclose,
 )
-import numpy as np
 import docker
-import logging
-import shutil
 import MDAnalysis as mda
+
 from .utils import get_free_port
+from .minimalreader import MinimalReader
 
 logger = logging.getLogger("imdclient.IMDClient")
 
@@ -64,6 +61,10 @@ def assert_allclose_with_logging(a, b, rtol=1e-07, atol=0, equal_nan=False):
 
 class IMDv3IntegrationTest:
 
+    @pytest.fixture()
+    def container_name(self):
+        return "ghcr.io/becksteinlab/streaming-md-docker:main-common-cpu"
+
     @pytest.fixture()
     def setup_command(self):
         return None
@@ -80,12 +81,13 @@ class IMDv3IntegrationTest:
         setup_command,
         simulation_command,
         port,
+        container_name,
     ):
         # In CI, container process needs access to tmp_path
         tmp_path.chmod(0o777)
         docker_client = docker.from_env()
         img = docker_client.images.pull(
-            "ghcr.io/becksteinlab/streaming-md-docker:main-Common-CPU"
+            container_name,
         )
         # Copy input files into tmp_path
         for inp in input_files:
@@ -123,13 +125,11 @@ class IMDv3IntegrationTest:
 
     @pytest.fixture()
     def imd_u(self, docker_client, topol, tmp_path, port):
-        u = mda.Universe((tmp_path / topol), f"imd://localhost:{port}")
-        with mda.Writer(
-            (tmp_path / "imd.trr").as_posix(), u.trajectory.n_atoms
-        ) as w:
-            for ts in u.trajectory:
-                w.write(u.atoms)
-        yield mda.Universe((tmp_path / topol), (tmp_path / "imd.trr"))
+        n_atoms = mda.Universe(tmp_path / topol).atoms.n_atoms
+        u = MinimalReader(
+            f"imd://localhost:{port}", n_atoms=n_atoms, process_stream=True
+        )
+        yield u
 
     @pytest.fixture()
     def true_u(self, topol, traj, imd_u, tmp_path):
@@ -139,118 +139,97 @@ class IMDv3IntegrationTest:
         )
         yield u
 
-    @pytest.fixture()
-    def comp_time(self):
-        return True
+    def test_compare_imd_to_true_traj(self, imd_u, true_u, first_frame, dt):
+        for i in range(first_frame, len(true_u.trajectory)):
 
-    @pytest.fixture()
-    def comp_dt(self):
-        return True
+            assert_allclose(
+                true_u.trajectory[i].time,
+                imd_u.trajectory[i - first_frame].time,
+                atol=1e-03,
+            )
 
-    @pytest.fixture()
-    def comp_step(self):
-        return True
+            assert_allclose(
+                dt,
+                imd_u.trajectory[i - first_frame].dt,
+                atol=1e-03,
+            )
 
-    def test_compare_imd_to_true_traj(
-        self, imd_u, true_u, first_frame, comp_time, comp_dt, comp_step
-    ):
-        for i in range(first_frame, len(true_u.trajectory)):
-            if comp_time:
-                assert_allclose(
-                    true_u.trajectory[i].time,
-                    imd_u.trajectory[i - first_frame].time,
-                    atol=1e-03,
-                )
-            if comp_dt:
-                assert_allclose(
-                    true_u.trajectory[i].dt,
-                    imd_u.trajectory[i - first_frame].dt,
-                    atol=1e-03,
-                )
-            if comp_step:
-                assert_allclose(
-                    true_u.trajectory[i].data["step"],
-                    imd_u.trajectory[i - first_frame].data["step"],
-                )
-            if (
-                true_u.trajectory[i].dimensions is not None
-                and imd_u.trajectory[i - first_frame].dimensions is not None
-            ):
-                assert_allclose_with_logging(
-                    true_u.trajectory[i].dimensions,
-                    imd_u.trajectory[i - first_frame].dimensions,
-                    atol=1e-03,
-                )
-            if (
-                true_u.trajectory[i].has_positions
-                and imd_u.trajectory[i - first_frame].has_positions
-            ):
-                assert_allclose_with_logging(
-                    true_u.trajectory[i].positions,
-                    imd_u.trajectory[i - first_frame].positions,
-                    atol=1e-03,
-                )
-            if (
-                true_u.trajectory[i].has_velocities
-                and imd_u.trajectory[i - first_frame].has_velocities
-            ):
-                assert_allclose_with_logging(
-                    true_u.trajectory[i].velocities,
-                    imd_u.trajectory[i - first_frame].velocities,
-                    atol=1e-03,
-                )
-            if (
-                true_u.trajectory[i].has_forces
-                and imd_u.trajectory[i - first_frame].has_forces
-            ):
-                assert_allclose_with_logging(
-                    true_u.trajectory[i].forces,
-                    imd_u.trajectory[i - first_frame].forces,
-                    atol=1e-03,
-                )
+            assert_allclose(
+                true_u.trajectory[i].data["step"],
+                imd_u.trajectory[i - first_frame].step,
+            )
+
+            assert_allclose_with_logging(
+                true_u.trajectory[i].dimensions,
+                imd_u.trajectory[i - first_frame].dimensions,
+                atol=1e-03,
+            )
+
+            assert_allclose_with_logging(
+                true_u.trajectory[i].positions,
+                imd_u.trajectory[i - first_frame].positions,
+                atol=1e-03,
+            )
+
+            assert_allclose_with_logging(
+                true_u.trajectory[i].velocities,
+                imd_u.trajectory[i - first_frame].velocities,
+                atol=1e-03,
+            )
+
+            assert_allclose_with_logging(
+                true_u.trajectory[i].forces,
+                imd_u.trajectory[i - first_frame].forces,
+                atol=1e-03,
+            )
 
     def test_continue_after_disconnect(
         self, docker_client, topol, tmp_path, port
     ):
-        u = mda.Universe(
-            (tmp_path / topol),
-            f"imd://localhost:{port}",
-            continue_after_disconnect=True,
+        n_atoms = mda.Universe(
+            tmp_path / topol,
             # Make sure LAMMPS topol can be read
             # Does nothing if not LAMMPS
             atom_style="id type x y z",
+        ).atoms.n_atoms
+        u = MinimalReader(
+            f"imd://localhost:{port}",
+            n_atoms=n_atoms,
+            continue_after_disconnect=True,
         )
         # Though we disconnect here, the simulation should continue
-        u.trajectory.close()
+        u.close()
         # Wait for the simulation to finish running
         time.sleep(45)
 
         # Now, attempt to reconnect- should fail,
         # since the simulation should have continued
         with pytest.raises(IOError):
-            u = mda.Universe(
-                (tmp_path / topol),
-                f"imd://localhost:{port}",
+            n_atoms = mda.Universe(
+                tmp_path / topol,
                 atom_style="id type x y z",
-            )
+            ).atoms.n_atoms
+            u = MinimalReader(f"imd://localhost:{port}", n_atoms=n_atoms)
 
     def test_wait_after_disconnect(self, docker_client, topol, tmp_path, port):
-        u = mda.Universe(
-            (tmp_path / topol),
-            f"imd://localhost:{port}",
-            # Could also use None here- just being explicit
-            continue_after_disconnect=False,
+        n_atoms = mda.Universe(
+            tmp_path / topol,
             # Make sure LAMMPS topol can be read
             # Does nothing if not LAMMPS
             atom_style="id type x y z",
+        ).atoms.n_atoms
+        u = MinimalReader(
+            f"imd://localhost:{port}",
+            n_atoms=n_atoms,
+            continue_after_disconnect=False,
         )
-        u.trajectory.close()
+        u.close()
         # Give the simulation engine
         # enough time to finish running (though it shouldn't)
         time.sleep(45)
 
-        u = mda.Universe(
-            (tmp_path / topol),
-            f"imd://localhost:{port}",
+        n_atoms = mda.Universe(
+            tmp_path / topol,
             atom_style="id type x y z",
-        )
+        ).atoms.n_atoms
+        u = MinimalReader(f"imd://localhost:{port}", n_atoms=n_atoms)

imdclient/tests/datafiles.py

@@ -14,7 +14,7 @@ __all__ = [
     "LAMMPS_IN_NST_8",
     "GROMACS_TRAJ",
     "GROMACS_MDP",
-    "GROMACS_TOP" "LAMMPS_IN_NST_1",
+    "GROMACS_TOP",
     "GROMACS_GRO",
     "GROMACS_MDP_NST_1",
     "GROMACS_MDP_NST_8",

imdclient/tests/docker_testing/docker.md

@@ -5,7 +5,7 @@ Ensure [docker](https://www.docker.com/) and the [NVIDIA container toolkit](http
 
 To run the container:
 ```bash
-docker pull ghcr.io/becksteinlab/streaming-md-docker:main-Common-GPU
+docker pull ghcr.io/becksteinlab/streaming-md-docker:main-common-gpu
 
 docker run -v $PWD/imdclient/data:/home/conda:rw -it --runtime=nvidia --gpus=all \
     ghcr.io/becksteinlab/streaming-md-docker:main-Common-GPU

imdclient/tests/hpc_testing/lammps/README.md

@@ -40,7 +40,7 @@ Or, for MPI builds,
 To validate against your own simulation files, see `validate_lmp.sh` for 
 command line arguments.
 
-### Compiling on ASU's Sol supercomputer
+### Compiling on ASU's Sol supercomputer with MPI and GPU support
 
 Allocate a GPU node on SOL and clone in https://github.com/ljwoods2/lammps/tree/imd-v3
 
@@ -57,6 +57,6 @@ module load openmpi/4.1.5
 mkdir -p build_gpu
 cd build_gpu
 
-cmake ../cmake/ -D PKG_MISC=yes -D PKG_GPU=on -D GPU_API=cuda -D PKG_H5MD=yes -D BUILD_MPI=yes -D LAMMPS_ASYNC_IMD=yes
+cmake ../cmake/ -D PKG_MISC=yes -D PKG_GPU=on -D GPU_API=cuda -D PKG_H5MD=yes -D BUILD_MPI=yes -DCMAKE_CXX_FLAGS="-DLAMMPS_ASYNC_IMD"
 make -j 4
 ```

imdclient/tests/hpc_testing/namd/README.md

@@ -35,39 +35,113 @@ command line arguments.
 
 ### Compiling on ASU's Sol supercomputer
 
-Allocate a GPU node on SOL and clone in https://gitlab.com/tcbgUIUC/namd.git
+Allocate requisite resources (CPU cores, nodes, GPUs) on SOL and clone in https://gitlab.com/tcbgUIUC/namd.git
 
-After cloning, do:
+After cloning and `cd`-ing to `namd` folder if you're not already there, do:
 
 ```bash
 git checkout feature_imdv3
-module load cmake-3.21.4-gcc-11.2.0
-module load gcc-10.3.0-gcc-11.2.0
-module load cuda-11.7.0-gcc-11.2.0
-module load openmpi/4.1.5
+```
 
-wget http://www.ks.uiuc.edu/Research/namd/libraries/fftw-linux-x86_64.tar.gz
-tar xzf fftw-linux-x86_64.tar.gz
-mv linux-x86_64 fftw
-wget http://www.ks.uiuc.edu/Research/namd/libraries/tcl8.6.13-linux-x86_64.tar.gz
-wget http://www.ks.uiuc.edu/Research/namd/libraries/tcl8.6.13-linux-x86_64-threaded.tar.gz
-tar xzf tcl8.6.13-linux-x86_64.tar.gz
-tar xzf tcl8.6.13-linux-x86_64-threaded.tar.gz
-mv tcl8.6.13-linux-x86_64 tcl
-mv tcl8.6.13-linux-x86_64-threaded tcl-threaded
+Download and install TCL and FFTW libraries:
+```bash
+    wget http://www.ks.uiuc.edu/Research/namd/libraries/fftw-linux-x86_64.tar.gz
+    tar xzf fftw-linux-x86_64.tar.gz
+    mv linux-x86_64 fftw
+    wget http://www.ks.uiuc.edu/Research/namd/libraries/tcl8.6.13-linux-x86_64.tar.gz
+    wget http://www.ks.uiuc.edu/Research/namd/libraries/tcl8.6.13-linux-x86_64-threaded.tar.gz
+    tar xzf tcl8.6.13-linux-x86_64.tar.gz
+    tar xzf tcl8.6.13-linux-x86_64-threaded.tar.gz
+    mv tcl8.6.13-linux-x86_64 tcl
+    mv tcl8.6.13-linux-x86_64-threaded tcl-threaded
+```
 
+Once can then download and unpack the Charm++ source code:
+
+```bash
 wget https://github.com/charmplusplus/charm/archive/refs/tags/v8.0.0.tar.gz
 tar xf v8.0.0.tar.gz
+```
+
+Then, NAMD can be built with the following options:
+
+#### Muticore version
+
+```bash
+module load gcc-11.2.0-gcc-11.2.0
 
 cd charm-8.0.0
 ./build charm++ multicore-linux-x86_64 --with-production
-cd multicore-linux-x86_64/tests/charm++/megatest
-make -j 4
-./megatest +p4 
 cd ../../../../..
 
 ./config Linux-x86_64-g++ --charm-arch multicore-linux-x86_64
 
 cd Linux-x86_64-g++
-make -j 4
+make
+```
+
+#### InfiniBand UCX OpenMPI PMIx version
+
+```bash
+module load gcc-11.2.0-gcc-11.2.0
+module load openmpi/4.1.5
+module load pmix/4.1.3-slurm
+
+export CPATH="/packages/apps/pmix/4.1.3-slurm/include:$CPATH"
+export LIBRARY_PATH="/packages/apps/pmix/4.1.3-slurm/lib:$LIBRARY_PATH"
+
+cd charm-8.0.0
+./build charm++ ucx-linux-x86_64 ompipmix --with-production
+cd ../../../../..
+
+./config Linux-x86_64-g++ --charm-arch ucx-linux-x86_64-ompipmix
+
+cd Linux-x86_64-g++
+make
+```
+
+#### MPI version
+
+```bash
+module load gcc-11.2.0-gcc-11.2.0
+module load mpich/4.2.2
+
+env MPICXX=mpicxx ./build charm++ mpi-linux-x86_64 --with-production
+cd ../../../../..
+
+./config Linux-x86_64-g++ --charm-arch mpi-linux-x86_64
+
+cd Linux-x86_64-g++
+make
 ```
+
+#### GPU-resident CUDA multicore version
+
+```bash
+module load gcc-11.2.0-gcc-11.2.0
+module load mpich/4.2.2
+module load cuda-11.8.0-gcc-11.2.0
+module load gsl-2.7.1-gcc-11.2.0
+
+cd charm-8.0.0
+./build charm++ multicore-linux-x86_64 --with-production
+cd ../../../../..
+
+./config Linux-x86_64-g++ --charm-arch multicore-linux-x86_64 --with-single-node-cuda
+
+cd Linux-x86_64-g++
+make
+```
+
+#### GPU-resident CUDA MPI version
+
+```bash
+cd charm-8.0.0
+env MPICXX=mpicxx ./build charm++ mpi-linux-x86_64-smp --with-production
+cd 
+
+./config Linux-x86_64-g++ --charm-arch mpi-linux-x86_64-smp --with-single-node-cuda
+
+cd Linux-x86_64-g++
+make
+```

imdclient/tests/minimalreader.py

@@ -0,0 +1,86 @@
+import logging
+import copy
+
+from MDAnalysis.coordinates import core
+
+from imdclient.IMDClient import IMDClient
+from imdclient.utils import parse_host_port
+
+logger = logging.getLogger("imdclient.IMDClient")
+
+
+class MinimalReader:
+    """
+    Minimal reader for testing purposes
+
+    Parameters
+    ----------
+    filename : str
+        a string of the form "host:port" where host is the hostname
+        or IP address of the listening MD engine server and port
+        is the port number.
+    n_atoms : int
+        number of atoms in the system. defaults to number of atoms
+        in the topology. don't set this unless you know what you're doing
+    process_stream : bool (optional)
+        if True, the reader will process the stream of frames and
+        store them in the `trajectory` attribute. defaults to False.
+    kwargs : dict (optional)
+        keyword arguments passed to the constructed :class:`IMDClient`
+    """
+
+    def __init__(self, filename, n_atoms, process_stream=False, **kwargs):
+
+        self.imd_frame = None
+
+        # a trajectory of imd frames
+        self.trajectory = []
+
+        self.n_atoms = n_atoms
+
+        host, port = parse_host_port(filename)
+
+        # This starts the simulation
+        self._imdclient = IMDClient(host, port, n_atoms, **kwargs)
+
+        self._frame = -1
+
+        if process_stream:
+            self._process_stream()
+
+    def _read_next_frame(self):
+        try:
+            imd_frame = self._imdclient.get_imdframe()
+        except EOFError:
+            raise
+
+        self._frame += 1
+        self.imd_frame = imd_frame
+
+        # Modify the box dimensions to be triclinic
+        self._modify_box_dimesions()
+
+        logger.debug(f"MinimalReader: Loaded frame {self._frame}")
+
+        return self.imd_frame
+
+    def _modify_box_dimesions(self):
+        self.imd_frame.dimensions = core.triclinic_box(*self.imd_frame.box)
+
+    def _process_stream(self):
+        # Process the stream of frames
+        while True:
+            try:
+                self.trajectory.append(copy.deepcopy(self._read_next_frame()))
+                # `.copy()` might not be required but adding it to cover any edge cases where a refernce gets passed
+                logger.debug(
+                    f"MinimalReader: Added frame {self._frame} to trajectory"
+                )
+            except EOFError:
+                break
+
+    def close(self):
+        """Gracefully shut down the reader. Stops the producer thread."""
+        logger.debug("MinimalReader: close() called")
+        if self._imdclient is not None:
+            self._imdclient.stop()

imdclient/tests/server.py

@@ -1,15 +1,16 @@
 import socket
 import struct
-import numpy as np
 import threading
-import time
+import logging
+
+import numpy as np
+
 from imdclient.IMDProtocol import (
     IMDHeaderType,
     create_header_bytes,
     create_energy_bytes,
     IMDHEADERSIZE,
 )
-import logging
 from imdclient.IMDClient import sock_contains_data, read_into_buf, IMDHeader
 
 logger = logging.getLogger("imdclient.IMDClient")