imdclient 0.1.3__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,9 +52,13 @@ 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``]
+        If True, the client will attempt to change the simulation engine's waiting behavior to
+        non-blocking after the client disconnects. If False, the client will attempt to change it
+        to blocking. If None, the client will not attempt to change the simulation engine's behavior.
     **kwargs : dict (optional)
         Additional keyword arguments to pass to the :class:`BaseIMDProducer` and :class:`IMDFrameBuffer`
     """
@@ -57,6 +70,7 @@ class IMDClient:
         n_atoms,
         socket_bufsize=None,
         multithreaded=True,
+        continue_after_disconnect=None,
         **kwargs,
     ):
 
@@ -64,6 +78,7 @@ class IMDClient:
         self._conn = self._connect_to_server(host, port, socket_bufsize)
         self._imdsinfo = self._await_IMD_handshake()
         self._multithreaded = multithreaded
+        self._continue_after_disconnect = continue_after_disconnect
 
         if self._multithreaded:
             self._buf = IMDFrameBuffer(
@@ -132,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")
@@ -292,6 +308,17 @@ class IMDClient:
         self._conn.sendall(go)
         logger.debug("IMDClient: Sent go packet to server")
 
+        if self._continue_after_disconnect is not None:
+            wait_behavior = (int)(not self._continue_after_disconnect)
+            wait_packet = create_header_bytes(
+                IMDHeaderType.IMD_WAIT, wait_behavior
+            )
+            self._conn.sendall(wait_packet)
+            logger.debug(
+                "IMDClient: Attempted to change wait behavior to %s",
+                not self._continue_after_disconnect,
+            )
+
     def _disconnect(self):
         # MUST disconnect before stopping execution
         # if simulation already ended, this method will do nothing
@@ -499,7 +526,14 @@ class BaseIMDProducer(threading.Thread):
 
 class IMDProducerV2(BaseIMDProducer):
     def __init__(
-        self, conn, buffer, sinfo, n_atoms, multithreaded, error_queue, **kwargs
+        self,
+        conn,
+        buffer,
+        sinfo,
+        n_atoms,
+        multithreaded,
+        error_queue,
+        **kwargs,
     ):
         super(IMDProducerV2, self).__init__(
             conn, buffer, sinfo, n_atoms, multithreaded, error_queue, **kwargs
@@ -713,9 +747,6 @@ class IMDProducerV3(BaseIMDProducer):
                 ).reshape((self._n_atoms, 3)),
             )
 
-    def __del__(self):
-        logger.debug("IMDProducer: I am being deleted")
-
 
 class IMDFrameBuffer:
     """

imdclient/IMDProtocol.py

@@ -34,6 +34,7 @@ class IMDHeaderType(Enum):
     IMD_BOX = 13
     IMD_VELOCITIES = 14
     IMD_FORCES = 15
+    IMD_WAIT = 16
 
 
 def parse_energy_bytes(data, endianness):

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/gromacs/md/gromacs_v3_nst1.mdp

@@ -1,5 +1,5 @@
 title                   = PRODUCTION IN NPT
-ld-seed                 = 1
+ld-seed			= 1
 ; Run parameters
 integrator              = md        ; leap-frog integrator
 nsteps                  = 100    ; 1 * 1000 = 1 ps
@@ -7,9 +7,9 @@ dt                      = 0.001     ; 1 fs
 ; Output control
 nstxout                 = 1      ; save coordinates every 1 fs
 nstvout                 = 1      ; save velocities every 1 fs
-nstfout                 = 1
+nstfout                 = 1      ; save forces every 1 fs
 nstenergy               = 1      ; save energies every 1 fs
-nstlog                  = 10      ; update log file every 1 ps
+nstlog                  = 10     
 ; Center of mass (COM) motion
 nstcomm                 = 10        ; remove COM motion every 10 steps
 comm-mode               = Linear    ; remove only COM translation (liquids in PBC) 

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,72 +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,
+            )
+
+            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_compare_imd_to_true_traj(
-        self, imd_u, true_u, first_frame, comp_time, comp_dt, comp_step
+    def test_continue_after_disconnect(
+        self, docker_client, topol, tmp_path, port
     ):
-        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,
-                )
+        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.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):
+            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):
+        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.close()
+        # Give the simulation engine
+        # enough time to finish running (though it shouldn't)
+        time.sleep(45)
+
+        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/conftest.py

@@ -1,42 +1,3 @@
 """
 Global pytest fixtures
 """
-
-
-# Command line arguments for 'test_manual.py'
-def pytest_addoption(parser):
-    parser.addoption(
-        "--topol_path_arg",
-        action="store",
-        default=None,
-    )
-    parser.addoption(
-        "--traj_path_arg",
-        action="store",
-        default=None,
-    )
-    parser.addoption(
-        "--first_frame_arg", action="store", type=int, default=None
-    )
-
-
-def pytest_generate_tests(metafunc):
-    # This is called for every test. Only get/set command line arguments
-    # if the argument is specified in the list of test "fixturenames".
-    topol = metafunc.config.option.topol_path_arg
-    traj = metafunc.config.option.traj_path_arg
-    first_frame = metafunc.config.option.first_frame_arg
-
-    if all(
-        arg in metafunc.fixturenames
-        for arg in ["topol_path_arg", "traj_path_arg", "first_frame_arg"]
-    ):
-        if topol is None or traj is None or first_frame is None:
-            raise ValueError(
-                "Must pass all three of '--topol_path_arg <path/to/topology>', "
-                + "'--traj_path_arg <path/to/trajectory>', "
-                + "'--first_frame_arg <first traj frame to compare to IMD>"
-            )
-        metafunc.parametrize("topol_path_arg", [topol])
-        metafunc.parametrize("traj_path_arg", [traj])
-        metafunc.parametrize("first_frame_arg", [first_frame])

imdclient/tests/datafiles.py

@@ -8,7 +8,22 @@ Use as ::
 
 """
 
-__all__ = ["LAMMPS_IN", "LAMMPS_TOPOL", "GROMACS_TRAJ", "GROMACS_MDP"]
+__all__ = [
+    "LAMMPS_TOPOL",
+    "LAMMPS_IN_NST_1",
+    "LAMMPS_IN_NST_8",
+    "GROMACS_TRAJ",
+    "GROMACS_MDP",
+    "GROMACS_TOP",
+    "GROMACS_GRO",
+    "GROMACS_MDP_NST_1",
+    "GROMACS_MDP_NST_8",
+    "NAMD_TOPOL",
+    "NAMD_CONF_NST_1",
+    "NAMD_CONF_NST_8",
+    "NAMD_PARAMS",
+    "NAMD_PSF",
+]
 
 from importlib import resources
 from pathlib import Path

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/gromacs/README.md

@@ -0,0 +1,112 @@
+# Manual validation of different compiler options for GROMACS using ASU's SOL
+
+### Running tests
+
+To validate all IMDv3 output (time, integration step, dt, box, positions, velocities, and forces)
+against TRR output with a simple sample simulation, first ensure you're using a 
+python environment which has the testing requirements of IMDClient installed.
+
+If not already installed, do:
+```bash
+conda env create -n imdclient-test -f devtools/conda-envs/test_env.yaml -y
+conda activate imdclient-test
+```
+
+Equivalently, on ASU's Sol, do:
+```bash
+module load mamba
+# Only needed for MPI builds
+module load openmpi/4.1.5
+conda env create -n imdclient-test -f devtools/conda-envs/test_env.yaml -y
+source activate imdclient-test
+```
+
+Then, to run the tests, do:
+```bash
+cd imdclient/tests/hpc_testing/gromacs
+chmod +x validate_gmx.sh
+
+./validate_gmx.sh \
+    --gmx_binary /path/to/gmx
+```
+
+Or, for MPI builds,
+```bash
+./validate_gmx.sh \
+    --gmx_binary /path/to/gmx \
+    --mpi
+```
+
+To validate against your own simulation files, see `validate_gmx.sh` for 
+command line arguments.
+
+### Compiling on ASU's Sol supercomputer
+
+Allocate a GPU node on SOL and clone in https://gitlab.com/ljwoods2/gromacs.git
+
+After cloning, do:
+```bash
+git checkout imd-v3
+module load cmake/3.30.2
+module load gcc-12.1.0-gcc-11.2.0
+moudle load cuda-12.6.1-gcc-12.1.0
+module load openmpi/4.1.5
+
+mkdir -p build_gpu
+cd build_gpu
+
+cmake .. -DGMX_BUILD_OWN_FFTW=ON -DGMX_GPU=CUDA -DGMX_MPI=ON
+make -j 4
+make install
+source /your/installation/prefix/here/bin/GMXRC
+```
+<!-- 
+After GROMACS has been built, change into the directory containing this file.
+
+To test on one node, run this in the shell (assuming there are 4 cores available):
+```bash
+/home/ljwoods2/workspace/gromacs/build_mpi/bin/gmx grompp \
+    -f gmx_gpu_test.mdp \
+    -c struct.gro \
+    -p gmx_gpu_test.top \
+    -imd struct_imd.gro \
+    -o gmx_gpu_test.tpr \
+    -maxwarn 1
+
+/home/ljwoods2/workspace/gromacs/build_mpi/bin/gmx mdrun \
+    -s gmx_gpu_test.tpr \
+    -o gmx_gpu_test.trr \
+    -imdwait \
+    -ntmpi 2 \
+    -ntomp 2
+```
+To test on multiple nodes, run this in the shell (assuming there are 4 nodes and 16 cores available, with 1 GPU on each node):
+
+```bash
+module load openmpi/4.1.5
+
+/home/ljwoods2/workspace/gromacs/build_mpi/bin/mpirun \
+    -np 4 \
+    gmx_mpi mdrun \
+    -s gmx_gpu_test.tpr \
+    -o gmx_gpu_test.trr \
+    -imdwait \
+    -ntomp 4 \
+    -gpu_id 0
+```
+
+And in a different shell (from the same directory), run the following commands:
+
+```bash
+module load mamba
+# Environment containing IMDClient
+source activate imdclient-test
+
+mkdir tmp_test
+
+python imdclient/tests/test_manual.py \
+    --topol_arg imdclient/tests/hpc_testing/gromacs/struct.gro \
+    --traj_arg imdclient/tests/hpc_testing/gromacs/gmx_gpu_test.trr \
+    --first_frame_arg 0 \
+    --tmp_path tmp_test
+``` -->

imdclient/tests/hpc_testing/gromacs/gmx_gpu_test.mdp

@@ -0,0 +1,58 @@
+title                   = PRODUCTION IN NPT
+ld-seed			= 1
+; Run parameters
+integrator              = md        ; leap-frog integrator
+nsteps                  = 1000    ; 1 * 1000 = 1 ps
+dt                      = 0.001     ; 1 fs
+; Output control
+nstxout                 = 10      ; save coordinates every 10 fs
+nstvout                 = 10      ; save velocities every 10 fs
+nstfout                 = 10
+nstenergy               = 10      ; save energies every 10 fs
+nstlog                  = 10      ; update log file every 10 fs
+; Center of mass (COM) motion
+nstcomm                 = 10        ; remove COM motion every 10 steps
+comm-mode               = Linear    ; remove only COM translation (liquids in PBC) 
+; Bond parameters
+continuation            = yes       ; first dynamics run
+constraint_algorithm    = lincs     ; holonomic constraints
+constraints             = all-bonds ; all bonds lengths are constrained
+lincs_iter              = 1         ; accuracy of LINCS
+lincs_order             = 4         ; also related to accuracy
+; Nonbonded settings
+cutoff-scheme           = Verlet    ; Buffered neighbor searching
+ns_type                 = grid      ; search neighboring grid cells
+nstlist                 = 10        ; 10 fs, largely irrelevant with Verlet
+rcoulomb                = 1.0       ; short-range electrostatic cutoff (in nm)
+rvdw                    = 1.0       ; short-range van der Waals cutoff (in nm)
+DispCorr                = EnerPres  ; account for cut-off vdW scheme
+; Electrostatics
+coulombtype             = PME       ; Particle Mesh Ewald for long-range electrostatics
+pme_order               = 4         ; cubic interpolation
+fourierspacing          = 0.12      ; grid spacing for FFT
+; Temperature coupling is on
+tcoupl                  = Nose-Hoover       ; good for production, after equilibration
+; we define separate thermostats for the solute and solvent (need to adapt)
+; see default groups defined by Gromacs for your system or define your own (make_ndx)
+tc-grps                 = Protein  SOL      ; the separate groups for the thermostats
+tau-t                   = 1.0      1.0      ; time constants for thermostats (ps)
+ref-t                   = 300      300      ; reference temperature for thermostats (K)
+; Pressure coupling is off
+pcoupl                  = Parrinello-Rahman ; good for production, after equilibration
+tau-p                   = 2.0               ; time constant for barostat (ps)
+compressibility         = 4.5e-5            ; compressibility (1/bar) set to water at ~300K
+ref-p                   = 1.0               ; reference pressure for barostat (bar)
+; Periodic boundary conditions
+pbc                     = xyz       ; 3-D PBC
+; Velocity generation
+gen_vel                 = no
+IMD-group               = System
+IMD-nst                 = 10
+IMD-version             = 3
+IMD-time                = yes
+IMD-box                 = yes
+IMD-coords              = yes
+IMD-unwrap              = no
+IMD-vels                = yes
+IMD-forces              = yes
+IMD-energies            = yes