synth-dynamics 0.1.0__py3-none-any.whl

synth_dynamics/__init__.py

@@ -0,0 +1,6 @@
+from .system import System
+from .forcefield import ANMForceField
+from .integrator import LangevinIntegrator
+from .simulation import Simulation
+
+__all__ = ["System", "ANMForceField", "LangevinIntegrator", "Simulation"]

synth_dynamics/forcefield.py

@@ -0,0 +1,57 @@
+import numpy as np
+from scipy.spatial.distance import pdist, squareform
+
+class ANMForceField:
+    def __init__(self, equilibrium_coords, cutoff=15.0, spring_constant=1.0):
+        """
+        Anisotropic Network Model Force Field.
+        
+        Args:
+            equilibrium_coords: (N, 3) array of C-alpha equilibrium positions.
+            cutoff: Distance cutoff for interactions in Angstroms.
+            spring_constant: Uniform spring constant k.
+        """
+        self.x0 = equilibrium_coords
+        self.cutoff = cutoff
+        self.k = spring_constant
+        self.n_atoms = len(equilibrium_coords)
+        
+        # Precompute equilibrium distances and adjacency matrix
+        dist_matrix = squareform(pdist(self.x0))
+        self.adj = (dist_matrix < cutoff) & (dist_matrix > 0)
+        self.r0 = dist_matrix
+
+    def compute_forces(self, current_coords):
+        """
+        Computes the harmonic forces on each atom.
+        
+        Args:
+            current_coords: (N, 3) array of current positions.
+        Returns:
+            forces: (N, 3) array of forces.
+        """
+        # Calculate current distances and difference vectors
+        # diff[i, j] = r_i - r_j
+        diff = current_coords[:, np.newaxis, :] - current_coords[np.newaxis, :, :]
+        dist = np.linalg.norm(diff, axis=2)
+        
+        # Avoid division by zero
+        dist_inv = np.zeros_like(dist)
+        mask = dist > 0
+        dist_inv[mask] = 1.0 / dist[mask]
+        
+        # Force magnitude matrix: F_ij = -k * (r_ij - r0_ij)
+        # We only care about pairs in the adjacency matrix
+        force_mag = -self.k * (dist - self.r0)
+        
+        # Full force vector matrix: F_vec_ij = F_ij * (diff_ij / dist_ij)
+        # Shape: (N, N, 3)
+        force_vecs = (force_mag * dist_inv)[:, :, np.newaxis] * diff
+        
+        # Zero out inactive interactions
+        force_vecs[~self.adj] = 0.0
+        
+        # Total force on atom i is sum over j
+        forces = np.sum(force_vecs, axis=1)
+                
+        return forces

synth_dynamics/integrator.py

@@ -0,0 +1,39 @@
+import numpy as np
+
+class LangevinIntegrator:
+    def __init__(self, dt=0.1, temperature=300.0, friction=1.0):
+        """
+        Overdamped Langevin (Brownian) Integrator.
+        
+        Args:
+            dt: Time step.
+            temperature: Temperature in Kelvin.
+            friction: Friction coefficient (gamma).
+        """
+        self.dt = dt
+        self.T = temperature
+        self.gamma = friction
+        self.kb = 0.0019872041  # Boltzmann constant in kcal/(mol*K)
+        
+    def step(self, positions, forces):
+        """
+        Performs a single integration step.
+        
+        x(t+dt) = x(t) + (dt/gamma) * F + sqrt(2 * kb * T * dt / gamma) * R
+        
+        Args:
+            positions: (N, 3) array of current positions.
+            forces: (N, 3) array of current forces.
+        Returns:
+            new_positions: (N, 3) array of updated positions.
+        """
+        n_atoms = positions.shape[0]
+        
+        # Deterministic term
+        drift = (self.dt / self.gamma) * forces
+        
+        # Stochastic term
+        sigma = np.sqrt(2.0 * self.kb * self.T * self.dt / self.gamma)
+        random_force = sigma * np.random.normal(size=(n_atoms, 3))
+        
+        return positions + drift + random_force

synth_dynamics/simulation.py

@@ -0,0 +1,40 @@
+import MDAnalysis as mda
+from .system import System
+from .forcefield import ANMForceField
+from .integrator import LangevinIntegrator
+
+class Simulation:
+    def __init__(self, system, forcefield, integrator):
+        """
+        Orchestrates the Langevin dynamics simulation.
+        
+        Args:
+            system: System instance.
+            forcefield: ForceField instance.
+            integrator: Integrator instance.
+        """
+        self.system = system
+        self.ff = forcefield
+        self.integrator = integrator
+        
+    def run(self, n_steps, output_path, stride=10):
+        """
+        Runs the simulation and saves the trajectory.
+        
+        Args:
+            n_steps: Total number of integration steps.
+            output_path: Path to save the trajectory (e.g., .dcd or .pdb).
+            stride: Frequency of saving frames.
+        """
+        writer = mda.Writer(output_path, self.system.n_atoms)
+        
+        for i in range(n_steps):
+            forces = self.ff.compute_forces(self.system.positions)
+            new_positions = self.integrator.step(self.system.positions, forces)
+            self.system.positions = new_positions
+            
+            if i % stride == 0:
+                writer.write(self.system.ca_atoms)
+                
+        writer.close()
+        print(f"Simulation complete. Trajectory saved to {output_path}")

synth_dynamics/system.py

@@ -0,0 +1,28 @@
+import MDAnalysis as mda
+import numpy as np
+
+class System:
+    def __init__(self, pdb_path: str):
+        """
+        Initializes the system by loading a PDB file and extracting C-alpha atoms.
+        
+        Args:
+            pdb_path: Path to the input PDB file.
+        """
+        self.universe = mda.Universe(pdb_path)
+        self.ca_atoms = self.universe.select_atoms("name CA")
+        
+        if len(self.ca_atoms) == 0:
+            raise ValueError(f"No C-alpha atoms found in {pdb_path}")
+            
+        # Store equilibrium coordinates (reference state)
+        self.equilibrium_coords = self.ca_atoms.positions.copy()
+        self.n_atoms = len(self.ca_atoms)
+        
+    @property
+    def positions(self):
+        return self.ca_atoms.positions
+
+    @positions.setter
+    def positions(self, new_positions):
+        self.ca_atoms.positions = new_positions

synth_dynamics-0.1.0.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: synth-dynamics
+Version: 0.1.0
+Summary: Time-Resolved Ensemble Generator using Coarse-Grained ENM Langevin Dynamics
+Author: George Elkins
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/georgeelkins/synth-dynamics
+Project-URL: Repository, https://github.com/georgeelkins/synth-dynamics
+Project-URL: Documentation, https://synth-dynamics.readthedocs.io/
+Project-URL: Bug Tracker, https://github.com/georgeelkins/synth-dynamics/issues
+Keywords: molecular-dynamics,protein-dynamics,ANM,Langevin,ensemble-generation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: MDAnalysis
+Requires-Dist: scipy
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx_rtd_theme; extra == "docs"
+Dynamic: license-file
+
+# synth-dynamics: Time-Resolved Ensemble Generator
+
+`synth-dynamics` is a fast, lightweight molecular dynamics engine designed to generate meaningful conformational ensembles of proteins. Unlike full-atom simulations (like GROMACS or Amber), `synth-dynamics` uses a **Coarse-Grained Anisotropic Network Model (ANM)** and **Langevin dynamics** to capture the essential global motions of proteins with minimal computational overhead.
+
+This tool is designed to bridge the gap between static structures and time-averaged experimental observables, such as NMR relaxation parameters, SAXS Kratky plots, or FRET efficiency distributions.
+
+## Key Features
+
+- **Coarse-Grained Simulation**: Models proteins using C-alpha atoms and harmonic "spring" networks.
+- **Fast Langevin Engine**: Propagates coordinates using a stable, overdamped Langevin integrator.
+- **Experimental Integration**: Perfect for generating the structural ensembles needed for `synth-nmr` or `synth-saxs`.
+- **Easy to Use**: Simple API for loading PDBs, configuring forcefields, and running simulations.
+- **Extensively Tested**: 100% test coverage ensuring reliability and correctness.
+
+## Installation
+
+`synth-dynamics` requires Python 3.10+ and the following dependencies:
+
+```bash
+pip install numpy MDAnalysis scipy
+```
+
+To install the documentation theme:
+```bash
+pip install sphinx_rtd_theme
+```
+
+## Quick Start
+
+Running a simulation is straightforward:
+
+```python
+from synth_dynamics import System, ANMForceField, LangevinIntegrator, Simulation
+
+# 1. Load the system (automatically filters for C-alpha atoms)
+system = System("protein.pdb")
+
+# 2. Define the Anisotropic Network Model forcefield
+# Cutoff (15A) and spring constant determine the flexibility
+ff = ANMForceField(system.equilibrium_coords, cutoff=15.0, spring_constant=1.0)
+
+# 3. Initialize the Langevin integrator (dt in fs, T in Kelvin)
+integrator = LangevinIntegrator(dt=0.1, temperature=300.0, friction=1.0)
+
+# 4. Run and save the trajectory
+sim = Simulation(system, ff, integrator)
+sim.run(n_steps=1000, output_path="trajectory.dcd", stride=10)
+```
+
+## Documentation
+
+Full API documentation and usage guides are available in the `docs/` directory. You can build the HTML documentation locally:
+
+```bash
+cd docs
+sphinx-build -b html . _build/html
+```
+
+## Testing
+
+To run the test suite and verify coverage:
+
+```bash
+PYTHONPATH=. pytest --cov=synth_dynamics tests/
+```
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details (if applicable).

synth_dynamics-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+synth_dynamics/__init__.py,sha256=o_OJWCEU3hUTQY0y9NhT_UikVJZEv8HWAEJj5DrPAcI,218
+synth_dynamics/forcefield.py,sha256=ZXJ9soNd52pYUnO4oLxR-CKESNHcdgtlzm2iQFrYLXE,2044
+synth_dynamics/integrator.py,sha256=TiVLtxgAARtLEUKoTJnb5DS7DOJWpf74acS0qRe1etU,1251
+synth_dynamics/simulation.py,sha256=h0x6QT4s5DrsL0Zhbx0yZwH84GI62XNhc0gN3AVSLys,1383
+synth_dynamics/system.py,sha256=xwzOwXf7_wFUSE27A5_Ndd58bMSaPW3H7EqyEHcgGJE,878
+synth_dynamics-0.1.0.dist-info/licenses/LICENSE,sha256=vhOY8MmX_KvSe6pbSfjbPEoceqNPv_Hoaz6BXrKS6rI,1070
+synth_dynamics-0.1.0.dist-info/METADATA,sha256=h1H5Wmyqf1TrmndGlCCOzHHDsDoQufYUu_jObELE1FE,3817
+synth_dynamics-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+synth_dynamics-0.1.0.dist-info/top_level.txt,sha256=Hg-LJU210eYBuiyW4HYA3g82mAgNmZYcUBksa4Gii3I,15
+synth_dynamics-0.1.0.dist-info/RECORD,,

synth_dynamics-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

synth_dynamics-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 George Elkins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

synth_dynamics-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+synth_dynamics