imdclient 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

imdclient/tests/base.py

@@ -1,4 +1,5 @@
 from imdclient.IMDClient import IMDClient
+from imdclient.IMD import IMDReader
 import pytest
 from pathlib import Path
 import os
@@ -9,8 +10,11 @@ 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
 
 logger = logging.getLogger("imdclient.IMDClient")
 
@@ -61,62 +65,192 @@ def assert_allclose_with_logging(a, b, rtol=1e-07, atol=0, equal_nan=False):
 class IMDv3IntegrationTest:
 
     @pytest.fixture()
-    def run_sim_and_wait(self, tmp_path, command, match_string):
-        old_cwd = Path.cwd()
-        os.chdir(tmp_path)
-        p = subprocess.Popen(
-            command,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            shell=True,
-            text=True,
-            bufsize=0,
-            preexec_fn=os.setsid,
+    def setup_command(self):
+        return None
+
+    @pytest.fixture()
+    def port(self):
+        yield get_free_port()
+
+    @pytest.fixture()
+    def docker_client(
+        self,
+        tmp_path,
+        input_files,
+        setup_command,
+        simulation_command,
+        port,
+    ):
+        # 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"
+        )
+        # Copy input files into tmp_path
+        for inp in input_files:
+            shutil.copy(inp, tmp_path)
+
+        cmdstring = "cd '/tmp'"
+        # Run the setup command, if any
+        if setup_command is not None:
+            # This should be blocking
+            cmdstring += " && " + setup_command
+
+        cmdstring += " && " + simulation_command
+
+        # Start the container, mount tmp_path, run simulation
+        container = docker_client.containers.run(
+            img,
+            f"/bin/sh -c '{cmdstring}'",
+            detach=True,
+            volumes={tmp_path.as_posix(): {"bind": "/tmp", "mode": "rw"}},
+            ports={"8888/tcp": port},
+            name="sim",
+            remove=True,
         )
-        t = time.time()
 
-        for stdout_line in iter(p.stdout.readline, ""):
-            logger.debug(f"stdout: {stdout_line}")
-            if match_string in stdout_line:
+        # For now, just wait 30 seconds
+        # life is too short to figure out how to redirect all stdout from inside
+        # a container
+        time.sleep(30)
 
-                break
-            if time.time() - t > 10:
-                raise TimeoutError("Timeout waiting for match string")
+        yield
+        try:
+            container.stop()
+        except docker.errors.NotFound:
+            pass
 
-        logger.debug("Match string found")
-        yield p
-        os.chdir(old_cwd)
-        os.killpg(os.getpgid(p.pid), signal.SIGTERM)
+    @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"))
+
+    @pytest.fixture()
+    def true_u(self, topol, traj, imd_u, tmp_path):
+        u = mda.Universe(
+            (tmp_path / topol),
+            (tmp_path / traj),
+        )
+        yield u
+
+    @pytest.fixture()
+    def comp_time(self):
+        return True
+
+    @pytest.fixture()
+    def comp_dt(self):
+        return True
 
     @pytest.fixture()
-    def client(self, run_sim_and_wait, universe):
-        client = IMDClient("localhost", 8888, universe.trajectory.n_atoms)
-        yield client
-        client.stop()
-
-    def test_compare_imd_to_true_traj(self, universe, client, first_frame):
-        imdsinfo = client.get_imdsessioninfo()
-
-        for ts in universe.trajectory[first_frame:]:
-            imdf = client.get_imdframe()
-            if imdsinfo.time:
-                assert_allclose(imdf.time, ts.time, atol=1e-03)
-                assert_allclose(imdf.step, ts.data["step"])
-            if imdsinfo.box:
+    def comp_step(self):
+        return True
+
+    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(
-                    imdf.box,
-                    ts.triclinic_dimensions,
+                    true_u.trajectory[i].dimensions,
+                    imd_u.trajectory[i - first_frame].dimensions,
                     atol=1e-03,
                 )
-            if imdsinfo.positions:
+            if (
+                true_u.trajectory[i].has_positions
+                and imd_u.trajectory[i - first_frame].has_positions
+            ):
                 assert_allclose_with_logging(
-                    imdf.positions, ts.positions, atol=1e-03
+                    true_u.trajectory[i].positions,
+                    imd_u.trajectory[i - first_frame].positions,
+                    atol=1e-03,
                 )
-            if imdsinfo.velocities:
+            if (
+                true_u.trajectory[i].has_velocities
+                and imd_u.trajectory[i - first_frame].has_velocities
+            ):
                 assert_allclose_with_logging(
-                    imdf.velocities, ts.velocities, atol=1e-03
+                    true_u.trajectory[i].velocities,
+                    imd_u.trajectory[i - first_frame].velocities,
+                    atol=1e-03,
                 )
-            if imdsinfo.forces:
+            if (
+                true_u.trajectory[i].has_forces
+                and imd_u.trajectory[i - first_frame].has_forces
+            ):
                 assert_allclose_with_logging(
-                    imdf.forces, ts.forces, atol=1e-03
+                    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,
+            # Make sure LAMMPS topol can be read
+            # Does nothing if not LAMMPS
+            atom_style="id type x y z",
+        )
+        # Though we disconnect here, the simulation should continue
+        u.trajectory.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}",
+                atom_style="id type x y z",
+            )
+
+    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,
+            # Make sure LAMMPS topol can be read
+            # Does nothing if not LAMMPS
+            atom_style="id type x y z",
+        )
+        u.trajectory.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}",
+            atom_style="id type x y z",
+        )

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" "LAMMPS_IN_NST_1",
+    "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
@@ -16,18 +31,26 @@ from pathlib import Path
 _data_ref = resources.files("imdclient.data")
 
 LAMMPS_TOPOL = (_data_ref / "lammps" / "md" / "lammps_topol.data").as_posix()
-LAMMPS_IN = (_data_ref / "lammps" / "md" / "lammps_v3.in").as_posix()
-LAMMPS_TRAJ = (_data_ref / "lammps" / "md" / "lammps_trj.h5md").as_posix()
-GROMACS_TRAJ = (
-    _data_ref / "gromacs" / "md" / "gromacs_v3_nst1.trr"
+LAMMPS_IN_NST_1 = (
+    _data_ref / "lammps" / "md" / "lammps_v3_nst_1.in"
 ).as_posix()
-GROMACS_TOPOL = (
-    _data_ref / "gromacs" / "md" / "gromacs_struct.gro"
+LAMMPS_IN_NST_8 = (
+    _data_ref / "lammps" / "md" / "lammps_v3_nst_8.in"
 ).as_posix()
-GROMACS_TPR = (_data_ref / "gromacs" / "md" / "gromacs_v3_nst1.tpr").as_posix()
+
+
+GROMACS_GRO = (_data_ref / "gromacs" / "md" / "gromacs_struct.gro").as_posix()
+GROMACS_MDP_NST_1 = (
+    _data_ref / "gromacs" / "md" / "gromacs_v3_nst1.mdp"
+).as_posix()
+GROMACS_MDP_NST_8 = (
+    _data_ref / "gromacs" / "md" / "gromacs_v3_nst8.mdp"
+).as_posix()
+GROMACS_TOP = (_data_ref / "gromacs" / "md" / "gromacs_v3.top").as_posix()
+
 NAMD_TOPOL = (_data_ref / "namd" / "md" / "alanin.pdb").as_posix()
-NAMD_CONF = (_data_ref / "namd" / "md" / "namd_v3.namd").as_posix()
-NAMD_TRAJ = (_data_ref / "namd" / "md" / "alanin.dcd").as_posix()
+NAMD_CONF_NST_1 = (_data_ref / "namd" / "md" / "namd_v3_nst_1.namd").as_posix()
+NAMD_CONF_NST_8 = (_data_ref / "namd" / "md" / "namd_v3_nst_8.namd").as_posix()
 NAMD_PARAMS = (_data_ref / "namd" / "md" / "alanin.params").as_posix()
 NAMD_PSF = (_data_ref / "namd" / "md" / "alanin.psf").as_posix()
 

imdclient/tests/docker_testing/docker.md

@@ -0,0 +1,25 @@
+# Running simulation engines compiled for GPU acceleration from a container
+
+Ensure [docker](https://www.docker.com/) and the [NVIDIA container toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) are installed.
+
+
+To run the container:
+```bash
+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
+```
+
+To run each simulation engine with repository simulation configurations:
+```bash
+cd /home/conda/namd/md
+namd3 +devices 0 namd_v3.namd
+
+cd /home/conda/gromacs/md
+gmx grompp -f gromacs_v3_nst1.mdp -c gromacs_struct.gro -p gromacs_v3.top
+gmx mdrun -s topol.tpr -nb gpu
+
+cd /home/conda/lammps/md
+lmp -sf gpu < lammps_v3_nst_1.in
+```

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