From 3ec04301cea3774e12678fb703af7643c9397ff5 Mon Sep 17 00:00:00 2001 From: frostedoyster Date: Thu, 19 Jun 2025 13:59:15 +0200 Subject: [PATCH 01/10] Symplectic integrator --- src/flashmd/ipi_symplectic.py | 514 ++++++++++++++++++++++++++++++++++ 1 file changed, 514 insertions(+) create mode 100644 src/flashmd/ipi_symplectic.py diff --git a/src/flashmd/ipi_symplectic.py b/src/flashmd/ipi_symplectic.py new file mode 100644 index 0000000..5f08381 --- /dev/null +++ b/src/flashmd/ipi_symplectic.py @@ -0,0 +1,514 @@ +from ipi.utils.depend import dstrip +from ipi.utils.units import Constants +from ipi.utils.messages import verbosity, info +from ipi.utils.mathtools import random_rotation as random_rotation_matrix +from ipi.engine.motion.dynamics import NVEIntegrator, NVTIntegrator, NPTIntegrator + +from flashmd.stepper import FlashMDStepper +import ase.units +import torch +import numpy as np +import ase.data + +from metatomic.torch import System +from metatensor.torch import Labels, TensorBlock, TensorMap + + +def get_standard_vv_step( + sim, model=None, device=None, rescale_energy=True, random_rotation=False +): + """ + Returns a velocity Verlet stepper function for i-PI simulations. + + Parameters: + - sim: The i-PI simulation object. + - rescale_energy: If True, rescales the kinetic energy after the step + to maintain energy conservation. + + Returns: + - A function that performs a velocity Verlet step. + """ + + def vv_step(motion): + if random_rotation: + raise NotImplementedError( + "Random rotation is not implemented in the standard VV stepper." + ) + + if rescale_energy: + info("@flashmd: Old energy", verbosity.debug) + old_energy = sim.properties("potential") + sim.properties("kinetic_md") + + print(motion.integrator.pdt, motion.integrator.qdt) + motion.integrator.pstep(level=0) + motion.integrator.pconstraints() + motion.integrator.qcstep() # does two steps because qdt is halved in the i-PI integrator + motion.integrator.qcstep() + motion.integrator.pstep(level=0) + motion.integrator.pconstraints() + + if rescale_energy: + info("@flashmd: Energy rescale", verbosity.debug) + new_energy = sim.properties("potential") + sim.properties("kinetic_md") + kinetic_energy = sim.properties("kinetic_md") + alpha = np.sqrt(1.0 - (new_energy - old_energy) / kinetic_energy) + motion.beads.p[:] = alpha * dstrip(motion.beads.p) + + return vv_step + + +def get_flashmd_vv_step(sim, symplectic_model, model, device, rescale_energy=True, random_rotation=False, accuracy_threshold=1e-3, alpha=0.5): + capabilities = model.capabilities() + + base_timestep = float(model.module.base_time_step) * ase.units.fs + + dt = sim.syslist[0].motion.dt * 2.4188843e-17 * ase.units.s + + n_time_steps = int( + [k for k in capabilities.outputs.keys() if "mtt::delta_" in k][0].split("_")[1] + ) + if not np.allclose(dt, n_time_steps * base_timestep): + raise ValueError( + f"Mismatch between timestep ({dt}) and model timestep ({base_timestep})." + ) + + device = torch.device(device) + dtype = getattr(torch, capabilities.dtype) + stepper = Stepper(symplectic_model, [model], n_time_steps, device, accuracy_threshold=accuracy_threshold, alpha=alpha) + + def flashmd_vv(motion): + info("@flashmd: Starting VV", verbosity.debug) + if rescale_energy: + info("@flashmd: Old energy", verbosity.debug) + old_energy = sim.properties("potential") + sim.properties("kinetic_md") + + info("@flashmd: Stepper", verbosity.debug) + system = ipi_to_system(motion, device, dtype) + + if random_rotation: + # generate a random rotation matrix + R = torch.tensor( + random_rotation_matrix(motion.prng, improper=True), + device=system.positions.device, + dtype=system.positions.dtype, + ) + # applies the random rotation + system.cell = system.cell @ R.T + system.positions = system.positions @ R.T + momenta = system.get_data("momenta").block(0).values.squeeze() + momenta[:] = momenta @ R.T # does the change in place + + new_system = stepper.step(system) + + if random_rotation: + # revert q,p to the original reference frame (`system_to_ipi` ignores the cell) + new_system.positions = new_system.positions @ R + momenta = new_system.get_data("momenta").block(0).values.squeeze() + momenta[:] = momenta @ R + + info("@flashmd: System to ipi", verbosity.debug) + system_to_ipi(motion, new_system) + info("@flashmd: VV P constraints", verbosity.debug) + motion.integrator.pconstraints() + + if rescale_energy: + info("@flashmd: Energy rescale", verbosity.debug) + new_energy = sim.properties("potential") + sim.properties("kinetic_md") + kinetic_energy = sim.properties("kinetic_md") + alpha = np.sqrt(1.0 - (new_energy - old_energy) / kinetic_energy) + motion.beads.p[:] = alpha * dstrip(motion.beads.p) + motion.integrator.pconstraints() + info("@flashmd: End of VV step", verbosity.debug) + + return flashmd_vv + + +def get_nve_stepper( + sim, + symplectic_model, + model, + device, + rescale_energy=True, + random_rotation=False, + use_standard_vv=False, + accuracy_threshold=1e-3, + alpha=0.5, +): + motion = sim.syslist[0].motion + if type(motion.integrator) is not NVEIntegrator: + raise TypeError( + f"Base i-PI integrator is of type {motion.integrator.__class__.__name__}, use a NVE setup." + ) + + if use_standard_vv: + # use the standard velocity Verlet integrator + vv_step = get_standard_vv_step( + sim, model, device, rescale_energy, random_rotation + ) + else: + # defaults to the FlashMD VV stepper + vv_step = get_flashmd_vv_step( + sim, symplectic_model, model, device, rescale_energy, random_rotation, accuracy_threshold=accuracy_threshold, alpha=alpha + ) + + def nve_stepper(motion, *_, **__): + vv_step(motion) + motion.ensemble.time += motion.dt + + return nve_stepper + + +def get_nvt_stepper( + sim, + symplectic_model, + model, + device, + rescale_energy=True, + random_rotation=False, + use_standard_vv=False, + accuracy_threshold=1e-3, + alpha=0.5, +): + motion = sim.syslist[0].motion + if type(motion.integrator) is not NVTIntegrator: + raise TypeError( + f"Base i-PI integrator is of type {motion.integrator.__class__.__name__}, use a NVT setup." + ) + + if use_standard_vv: + # use the standard velocity Verlet integrator + vv_step = get_standard_vv_step( + sim, model, device, rescale_energy, random_rotation + ) + else: + # defaults to the FlashMD VV stepper + vv_step = get_flashmd_vv_step( + sim, symplectic_model, model, device, rescale_energy, random_rotation, accuracy_threshold=accuracy_threshold, alpha=alpha + ) + + def nvt_stepper(motion, *_, **__): + # OBABO splitting of a NVT propagator + motion.thermostat.step() + motion.integrator.pconstraints() + vv_step(motion) + motion.thermostat.step() + motion.integrator.pconstraints() + motion.ensemble.time += motion.dt + + return nvt_stepper + + +def _qbaro(baro): + """Propagation step for the cell volume (adjusting atomic positions and momenta).""" + + v = baro.p[0] / baro.m[0] + halfdt = ( + baro.qdt + ) # this is set to half the inner loop in all integrators that use a barostat + expq, expp = (np.exp(v * halfdt), np.exp(-v * halfdt)) + + baro.nm.qnm[0, :] *= expq + baro.nm.pnm[0, :] *= expp + baro.cell.h *= expq + + +def _pbaro(baro): + """Propagation step for the cell momentum (adjusting atomic positions and momenta).""" + + # we are assuming then that p the coupling between p^2 and dp/dt only involves the fast force + dt = baro.pdt[0] + + # computes the pressure associated with the forces at the outer level MTS level. + press = np.trace(baro.stress_mts(0)) / 3.0 + # integerates the kinetic part of the pressure with the force at the inner-most level. + nbeads = baro.beads.nbeads + baro.p += ( + 3.0 + * dt + * (baro.cell.V * (press - nbeads * baro.pext) + Constants.kb * baro.temp) + ) + + +def get_npt_stepper( + sim, + symplectic_model, + model, + device, + rescale_energy=True, + random_rotation=False, + use_standard_vv=False, + accuracy_threshold=1e-3, + alpha=0.5, +): + motion = sim.syslist[0].motion + if type(motion.integrator) is not NPTIntegrator: + raise TypeError( + f"Base i-PI integrator is of type {motion.integrator.__class__.__name__}, use a NPT setup." + ) + + if use_standard_vv: + # use the standard velocity Verlet integrator + vv_step = get_standard_vv_step( + sim, model, device, rescale_energy, random_rotation + ) + else: + # defaults to the FlashMD VV stepper + vv_step = get_flashmd_vv_step( + sim, symplectic_model, model, device, rescale_energy, random_rotation, accuracy_threshold=accuracy_threshold, alpha=alpha + ) + + # The barostat here needs a simpler splitting than for BZP, something as + # OAbBbBABbAbPO where Bp and Ap are the cell momentum and volume steps + def npt_stepper(motion, *_, **__): + info("@flashmd: Starting NPT step", verbosity.debug) + info("@flashmd: Particle thermo", verbosity.debug) + motion.thermostat.step() + info("@flashmd: P constraints", verbosity.debug) + motion.integrator.pconstraints() + info("@flashmd: Barostat thermo", verbosity.debug) + motion.barostat.thermostat.step() + info("@flashmd: Barostat q", verbosity.debug) + _qbaro(motion.barostat) + info("@flashmd: Barostat p", verbosity.debug) + _pbaro(motion.barostat) + info("@flashmd: FlashVV", verbosity.debug) + vv_step(motion) + info("@flashmd: Barostat p", verbosity.debug) + _pbaro(motion.barostat) + info("@flashmd: Barostat q", verbosity.debug) + _qbaro(motion.barostat) + info("@flashmd: Barostat thermo", verbosity.debug) + motion.barostat.thermostat.step() + info("@flashmd: Particle thermo", verbosity.debug) + motion.thermostat.step() + info("@flashmd: P constraints", verbosity.debug) + motion.integrator.pconstraints() + motion.ensemble.time += motion.dt + info("@flashmd: NPT Step finished", verbosity.debug) + + return npt_stepper + + +def ipi_to_system(motion, device, dtype): + positions = ( + dstrip(motion.beads.q).reshape(-1, 3) * ase.units.Bohr / ase.units.Angstrom + ) + positions_torch = torch.tensor(positions, device=device, dtype=dtype) + cell = dstrip(motion.cell.h).T * ase.units.Bohr / ase.units.Angstrom + cell_torch = torch.tensor(cell, device=device, dtype=dtype) + pbc_torch = torch.tensor([True, True, True], device=device, dtype=torch.bool) + momenta = ( + dstrip(motion.beads.p).reshape(-1, 3) + * (9.1093819e-31 * ase.units.kg) + * (ase.units.Bohr / ase.units.Angstrom) + / (2.4188843e-17 * ase.units.s) + ) + momenta_torch = torch.tensor(momenta, device=device, dtype=dtype) + masses = dstrip(motion.beads.m) * 9.1093819e-31 * ase.units.kg + masses_torch = torch.tensor(masses, device=device, dtype=dtype) + types_torch = torch.tensor( + [ase.data.atomic_numbers[name] for name in motion.beads.names], + device=device, + dtype=torch.int32, + ) + system = System(types_torch, positions_torch, cell_torch, pbc_torch) + system.add_data( + "momenta", + TensorMap( + keys=Labels.single().to(device), + blocks=[ + TensorBlock( + values=momenta_torch.unsqueeze(-1), + samples=Labels( + names=["system", "atom"], + values=torch.tensor( + [[0, j] for j in range(len(momenta_torch))], device=device + ), + ), + components=[ + Labels( + names="xyz", + values=torch.tensor([[0], [1], [2]], device=device), + ) + ], + properties=Labels.single().to(device), + ) + ], + ), + ) + system.add_data( + "masses", + TensorMap( + keys=Labels.single().to(device), + blocks=[ + TensorBlock( + values=masses_torch.unsqueeze(-1), + samples=Labels( + names=["system", "atom"], + values=torch.tensor( + [[0, j] for j in range(len(masses_torch))], device=device + ), + ), + components=[], + properties=Labels.single().to(device), + ) + ], + ), + ) + return system + + +def system_to_ipi(motion, system): + # only needs to convert positions and momenta, it's assumed that the cell won't be changed + motion.beads.q[:] = ( + system.positions.cpu().numpy().flatten() * ase.units.Angstrom / ase.units.Bohr + ) + motion.beads.p[:] = system.get_data("momenta").block().values.squeeze( + -1 + ).cpu().numpy().flatten() / ( + (9.1093819e-31 * ase.units.kg) + * (ase.units.Bohr / ase.units.Angstrom) + / (2.4188843e-17 * ase.units.s) + ) + + +from metatomic.torch import ModelEvaluationOptions, ModelOutput +from metatensor.torch import Labels, TensorBlock, TensorMap +import torch +from metatomic.torch import System +from metatrain.utils.neighbor_lists import get_system_with_neighbor_lists +from typing import List +from metatomic.torch import AtomisticModel +from flashmd.stepper import FlashMDStepper + + +class Stepper(FlashMDStepper): + def __init__( + self, + model: AtomisticModel, + models: List[AtomisticModel], + n_time_steps: int, + device: torch.device, + accuracy_threshold: float = 1e-3, + alpha: float = 0.5, + ): + super().__init__(models, n_time_steps, device) + self.model = model + self.evaluation_options_implicit = ModelEvaluationOptions( + length_unit="Angstrom", + outputs={ + f"mtt::delta_{self.n_time_steps}_q": ModelOutput(per_atom=True), + f"mtt::delta_{self.n_time_steps}_p": ModelOutput(per_atom=True), + }, + ) + self.accuracy_threshold = accuracy_threshold + self.alpha = alpha + + def step(self, system: System): + new_system = super().step(system) + # new_system = system + + cooldown = 300 + accuracy = np.inf + accuracies = [np.inf] + accuracy_threshold = self.accuracy_threshold + alpha = self.alpha + niterations = 0 + old_positions = new_system.positions + old_momenta = new_system.get_data("momenta").block().values + while accuracy > accuracy_threshold: + print("Iteration:", niterations, "Accuracy:", accuracy) + old_positions = new_system.positions * alpha + old_positions * (1 - alpha) + old_momenta = new_system.get_data("momenta").block().values * alpha + old_momenta * (1 - alpha) + midpoint_system = get_system( + (system.positions + old_positions) / 2.0, + system.types, + system.cell, + system.pbc, + (system.get_data("momenta").block().values + old_momenta) / 2.0, + system.get_data("masses").block().values, + ) + midpoint_system = get_system_with_neighbor_lists( + midpoint_system, self.model.requested_neighbor_lists() + ) + outputs = self.model([midpoint_system], self.evaluation_options_implicit, check_consistency=False) + delta_q = outputs[f"mtt::delta_{self.n_time_steps}_q"].block().values.squeeze(-1) + delta_p = outputs[f"mtt::delta_{self.n_time_steps}_p"].block().values + new_system = get_system( + system.positions + delta_q, + system.types, + system.cell, + system.pbc, + system.get_data("momenta").block().values + delta_p, + system.get_data("masses").block().values, + ) + accuracy = torch.abs(new_system.positions - old_positions).max().item() + torch.abs(new_system.get_data("momenta").block().values - old_momenta).max().item() + # print(torch.abs(new_system.positions - old_positions).max().item(), torch.abs(new_system.get_data("momenta").block().values - old_momenta).max().item()) + accuracies.append(accuracy) + if len(accuracies) > 100: + if accuracy > accuracies[-100] and cooldown <= 0: + print("Reducing alpha") + alpha *= 0.5 + cooldown = 300 + niterations += 1 + cooldown -= 1 + print("Number of iterations:", niterations, "accuracy threshold:", accuracy_threshold) + return new_system + + +def get_system(positions, types, cell, pbc, momenta, masses): + device = positions.device + system = System( + positions=positions, + types=types, + cell=cell, + pbc=pbc, + ) + system.add_data( + "momenta", + TensorMap( + keys=Labels.single().to(device), + blocks=[ + TensorBlock( + values=momenta, + samples=Labels( + names=["system", "atom"], + values=torch.tensor( + [[0, j] for j in range(len(system))], + device=device, + ), + ), + components=[ + Labels( + names="xyz", + values=torch.tensor( + [[0], [1], [2]], device=device + ), + ) + ], + properties=Labels.single().to(device), + ) + ], + ), + ) + system.add_data( + "masses", + TensorMap( + keys=Labels.single().to(device), + blocks=[ + TensorBlock( + values=masses, + samples=Labels( + names=["system", "atom"], + values=torch.tensor( + [[0, j] for j in range(len(system))], + device=device, + ), + ), + components=[], + properties=Labels.single().to(device), + ) + ], + ), + ) + return system From eaf7534717d3d19c62677a3fa14aab727ec35029 Mon Sep 17 00:00:00 2001 From: Johannes Spies <13813209+johannes-spies@users.noreply.github.com> Date: Tue, 20 Jan 2026 09:36:10 +0000 Subject: [PATCH 02/10] Make compatible with current metatrain --- src/flashmd/ipi_symplectic.py | 40 +++++++++++++++++++++-------------- 1 file changed, 24 insertions(+), 16 deletions(-) diff --git a/src/flashmd/ipi_symplectic.py b/src/flashmd/ipi_symplectic.py index 5f08381..d28db20 100644 --- a/src/flashmd/ipi_symplectic.py +++ b/src/flashmd/ipi_symplectic.py @@ -1,3 +1,4 @@ +from attr import has from ipi.utils.depend import dstrip from ipi.utils.units import Constants from ipi.utils.messages import verbosity, info @@ -60,21 +61,29 @@ def vv_step(motion): def get_flashmd_vv_step(sim, symplectic_model, model, device, rescale_energy=True, random_rotation=False, accuracy_threshold=1e-3, alpha=0.5): capabilities = model.capabilities() - base_timestep = float(model.module.base_time_step) * ase.units.fs + if hasattr(model.module, "base_time_step"): + base_timestep = float(model.module.base_time_step) * ase.units.fs + n_time_steps = int( + [k for k in capabilities.outputs.keys() if "mtt::delta_" in k][0].split("_")[1] + ) + timestep = base_timestep * n_time_steps + elif hasattr(model.module, "timestep"): + timestep = float(model.module.timestep) * ase.units.fs + else: + raise ValueError( + "The model does not specify a base timestep (attribute 'base_time_step' or 'timestep')." + ) dt = sim.syslist[0].motion.dt * 2.4188843e-17 * ase.units.s - n_time_steps = int( - [k for k in capabilities.outputs.keys() if "mtt::delta_" in k][0].split("_")[1] - ) - if not np.allclose(dt, n_time_steps * base_timestep): + if not np.allclose(dt, timestep): raise ValueError( - f"Mismatch between timestep ({dt}) and model timestep ({base_timestep})." + f"Mismatch between timestep ({dt}) and model timestep ({timestep})." ) device = torch.device(device) dtype = getattr(torch, capabilities.dtype) - stepper = Stepper(symplectic_model, [model], n_time_steps, device, accuracy_threshold=accuracy_threshold, alpha=alpha) + stepper = Stepper(symplectic_model, model, device, accuracy_threshold=accuracy_threshold, alpha=alpha) def flashmd_vv(motion): info("@flashmd: Starting VV", verbosity.debug) @@ -361,9 +370,9 @@ def ipi_to_system(motion, device, dtype): def system_to_ipi(motion, system): # only needs to convert positions and momenta, it's assumed that the cell won't be changed motion.beads.q[:] = ( - system.positions.cpu().numpy().flatten() * ase.units.Angstrom / ase.units.Bohr + system.positions.detach().cpu().numpy().flatten() * ase.units.Angstrom / ase.units.Bohr ) - motion.beads.p[:] = system.get_data("momenta").block().values.squeeze( + motion.beads.p[:] = system.get_data("momenta").block().values.detach().squeeze( -1 ).cpu().numpy().flatten() / ( (9.1093819e-31 * ase.units.kg) @@ -386,19 +395,18 @@ class Stepper(FlashMDStepper): def __init__( self, model: AtomisticModel, - models: List[AtomisticModel], - n_time_steps: int, + flashmd: AtomisticModel, device: torch.device, accuracy_threshold: float = 1e-3, alpha: float = 0.5, ): - super().__init__(models, n_time_steps, device) + super().__init__(flashmd, device) self.model = model self.evaluation_options_implicit = ModelEvaluationOptions( length_unit="Angstrom", outputs={ - f"mtt::delta_{self.n_time_steps}_q": ModelOutput(per_atom=True), - f"mtt::delta_{self.n_time_steps}_p": ModelOutput(per_atom=True), + "positions": ModelOutput(per_atom=True), + "momenta": ModelOutput(per_atom=True), }, ) self.accuracy_threshold = accuracy_threshold @@ -432,8 +440,8 @@ def step(self, system: System): midpoint_system, self.model.requested_neighbor_lists() ) outputs = self.model([midpoint_system], self.evaluation_options_implicit, check_consistency=False) - delta_q = outputs[f"mtt::delta_{self.n_time_steps}_q"].block().values.squeeze(-1) - delta_p = outputs[f"mtt::delta_{self.n_time_steps}_p"].block().values + delta_q = outputs[f"positions"].block().values.squeeze(-1) + delta_p = outputs[f"momenta"].block().values new_system = get_system( system.positions + delta_q, system.types, From f25ecff9d24a8cec6b2010e420fb2f0f6205438f Mon Sep 17 00:00:00 2001 From: Johannes Spies <13813209+johannes-spies@users.noreply.github.com> Date: Tue, 20 Jan 2026 09:36:44 +0000 Subject: [PATCH 03/10] Add dummy Al example --- examples/al/.gitignore | 9 + examples/al/compare.ipynb | 187 ++++++++++++++++++ examples/al/create-datasets.py | 67 +++++++ examples/al/input.xml | 33 ++++ examples/al/options-flashmd-symplectic.yaml | 55 ++++++ examples/al/options-flashmd.yaml | 50 +++++ examples/al/simulation-baseline/baseline.xml | 33 ++++ examples/al/simulation-baseline/run.sh | 1 + examples/al/simulation-flashmd-omatpes/run.py | 13 ++ examples/al/simulation-flashmd-symplectic.py | 0 .../al/simulation-flashmd-symplectic/run.py | 16 ++ examples/al/simulation-flashmd/run.py | 14 ++ 12 files changed, 478 insertions(+) create mode 100644 examples/al/.gitignore create mode 100644 examples/al/compare.ipynb create mode 100644 examples/al/create-datasets.py create mode 100644 examples/al/input.xml create mode 100644 examples/al/options-flashmd-symplectic.yaml create mode 100644 examples/al/options-flashmd.yaml create mode 100644 examples/al/simulation-baseline/baseline.xml create mode 100644 examples/al/simulation-baseline/run.sh create mode 100644 examples/al/simulation-flashmd-omatpes/run.py create mode 100644 examples/al/simulation-flashmd-symplectic.py create mode 100644 examples/al/simulation-flashmd-symplectic/run.py create mode 100644 examples/al/simulation-flashmd/run.py diff --git a/examples/al/.gitignore b/examples/al/.gitignore new file mode 100644 index 0000000..3659241 --- /dev/null +++ b/examples/al/.gitignore @@ -0,0 +1,9 @@ +*.xyz* +*.extxyz* +*.out* +*RESTART* +outputs +*.pt +wandb +*.ckpt +RESTART \ No newline at end of file diff --git a/examples/al/compare.ipynb b/examples/al/compare.ipynb new file mode 100644 index 0000000..a319c7c --- /dev/null +++ b/examples/al/compare.ipynb @@ -0,0 +1,187 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f1bdd1c2", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "156c05e2", + "metadata": {}, + "outputs": [], + "source": [ + "simulations = [\n", + " \"simulation-baseline\",\n", + " \"simulation-flashmd\",\n", + " \"simulation-flashmd-symplectic\",\n", + " \"simulation-flashmd-omatpes\",\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b50538b0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timeconservedtemperature
step
00.000-7.795911281.497480
10.001-7.795911341.251899
20.002-7.795912265.825062
30.003-7.795913299.073033
40.004-7.795913346.877868
\n", + "
" + ], + "text/plain": [ + " time conserved temperature\n", + "step \n", + "0 0.000 -7.795911 281.497480\n", + "1 0.001 -7.795911 341.251899\n", + "2 0.002 -7.795912 265.825062\n", + "3 0.003 -7.795913 299.073033\n", + "4 0.004 -7.795913 346.877868" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "out_files = {name: np.loadtxt(name + \"/md.out\") for name in simulations}\n", + "dfs = {name: pd.DataFrame(frame, columns=[\"step\", \"time\", \"conserved\", \"temperature\"]).astype({\"step\": int}).set_index(\"step\") for name, frame in out_files.items()}\n", + "dfs[\"simulation-baseline\"].head()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "67a53c45", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(figsize=(8, 6), nrows=2, sharex=True)\n", + "fig.suptitle(\"Simulation Statistics Comparison\")\n", + "ax_conserved, ax_temperature = axs\n", + "for ax in axs:\n", + " ax.grid()\n", + "ax_conserved.set(ylabel=\"energy\", title=\"conserved\")\n", + "ax_conserved.set_ylim(-8, -6.5)\n", + "ax_temperature.set(xlabel=\"time in ps\", ylabel=\"temperature in K\", title=\"kinetic\")\n", + "for name, df in dfs.items():\n", + " ax_conserved.plot(df[\"time\"], df[\"conserved\"], label=name, lw=2)\n", + " ax_temperature.plot(df[\"time\"], df[\"temperature\"], label=name, lw=2)\n", + "ax_conserved.legend()\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4e4acf2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "default", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/al/create-datasets.py b/examples/al/create-datasets.py new file mode 100644 index 0000000..f847e0d --- /dev/null +++ b/examples/al/create-datasets.py @@ -0,0 +1,67 @@ +import copy + +import ase +import ase.build +import ase.io +import ase.units +from ase.calculators.emt import EMT +from ase.md import VelocityVerlet +from ase.md.langevin import Langevin +from ase.md.velocitydistribution import MaxwellBoltzmannDistribution + + +# We start by creating a simple system (a small box of aluminum). +atoms = ase.build.bulk("Al", "fcc", cubic=True) * (2, 2, 2) + +# We first equilibrate the system at 300K using a Langevin thermostat. +MaxwellBoltzmannDistribution(atoms, temperature_K=300) +atoms.calc = EMT() +dyn = Langevin( + atoms, 2 * ase.units.fs, temperature_K=300, friction=1 / (100 * ase.units.fs) +) +dyn.run(1000) # 2 ps equilibration (around 10 ps is better in practice) + +# Then, we run a production simulation in the NVE ensemble. +trajectory = [] + + +def store_trajectory(): + trajectory.append(copy.deepcopy(atoms)) + + +dyn = VelocityVerlet(atoms, 1 * ase.units.fs) +dyn.attach(store_trajectory, interval=1) +dyn.run(2000) # 2 ps NVE run + +time_lag = 32 +spacing = 200 + +def get_structure_for_dataset_m2d(frame_now, frame_ahead): + s = copy.deepcopy(frame_now) + s.arrays["delta_positions"] = ( + frame_ahead.get_positions() - frame_now.get_positions() + ) + s.arrays["delta_momenta"] = frame_ahead.get_momenta() - frame_now.get_momenta() + s.set_positions(0.5 * (frame_now.get_positions() + frame_ahead.get_positions())) + s.set_momenta(0.5 * (frame_now.get_momenta() + frame_ahead.get_momenta())) + return s + +def get_structure_for_dataset_s2e(frame_now, frame_ahead): + s = copy.deepcopy(frame_now) + s.arrays["future_positions"] = frame_ahead.get_positions() + s.arrays["future_momenta"] = frame_ahead.get_momenta() + return s + + +structures_for_dataset_m2d = [] +structures_for_dataset_s2e = [] +for i in range(0, len(trajectory) - time_lag, spacing): + frame_now = trajectory[i] + frame_ahead = trajectory[i + time_lag] + s_m2d = get_structure_for_dataset_m2d(frame_now, frame_ahead) + s_s2e = get_structure_for_dataset_s2e(frame_now, frame_ahead) + structures_for_dataset_m2d.append(s_m2d) + structures_for_dataset_s2e.append(s_s2e) + +ase.io.write("data/midpoint-to-delta.xyz", structures_for_dataset_m2d) +ase.io.write("data/start-to-end.xyz", structures_for_dataset_s2e) diff --git a/examples/al/input.xml b/examples/al/input.xml new file mode 100644 index 0000000..b00cfb1 --- /dev/null +++ b/examples/al/input.xml @@ -0,0 +1,33 @@ + + 100 + + positions + velocities + [ step, time{picosecond}, conserved, temperature{kelvin} ] + + + 32123 + + + metatomic + {model: ../models/mlip_pet-omatpes-v2.pt, template: ../data/equilibrated.xyz, device: cuda} + + + + + + + ../data/equilibrated.xyz + 300 + + + 300 + + + + 32 + 2 + + + + \ No newline at end of file diff --git a/examples/al/options-flashmd-symplectic.yaml b/examples/al/options-flashmd-symplectic.yaml new file mode 100644 index 0000000..a6fb918 --- /dev/null +++ b/examples/al/options-flashmd-symplectic.yaml @@ -0,0 +1,55 @@ +seed: 42 +base_precision: 32 + +architecture: + name: experimental.flashmd_symplectic + training: + timestep: 32 # in this case 30 (time lag) * 1 fs (timestep of reference MD) + batch_size: 8 # to be increased in a production scenario + num_epochs: 100 # to be increased (at least 1000-10000) in a production scenario + log_interval: 1 + learning_rate: 3e-4 + fixed_scaling_weights: + positions: 1.0 + momenta: 1.0 + loss: + positions: + type: mse + weight: 1.0 + reduction: mean + momenta: + type: mse + weight: 1.0 + reduction: mean + +training_set: + systems: + read_from: data/midpoint-to-delta.xyz + length_unit: A + targets: + positions: + key: delta_positions + quantity: length + unit: A + type: + cartesian: + rank: 1 + per_atom: true + momenta: + key: delta_momenta + quantity: momentum + unit: (eV*u)^(1/2) + type: + cartesian: + rank: 1 + per_atom: true + +validation_set: 0.1 +test_set: 0.0 + +wandb: + project: flashmd-variants + name: symplectic-flashmd + tags: + - al + - symplectic-flashmd diff --git a/examples/al/options-flashmd.yaml b/examples/al/options-flashmd.yaml new file mode 100644 index 0000000..ab54371 --- /dev/null +++ b/examples/al/options-flashmd.yaml @@ -0,0 +1,50 @@ +seed: 42 + +architecture: + name: experimental.flashmd + training: + timestep: 32 # in this case 32 (time lag) * 1 fs (timestep of reference MD) + batch_size: 8 # to be increased in a production scenario + num_epochs: 100 # to be increased (at least 1000-10000) in a production scenario + log_interval: 1 + loss: + positions: + type: mse + weight: 1.0 + reduction: mean + momenta: + type: mse + weight: 1.0 + reduction: mean + +training_set: + systems: + read_from: data/start-to-end.xyz + length_unit: A + targets: + positions: + key: future_positions + quantity: length + unit: A + type: + cartesian: + rank: 1 + per_atom: true + momenta: + key: future_momenta + quantity: momentum + unit: (eV*u)^(1/2) + type: + cartesian: + rank: 1 + per_atom: true + +validation_set: 0.1 +test_set: 0.1 + +wandb: + project: flashmd-variants + name: flashmd-baseline + tags: + - al + - flashmd diff --git a/examples/al/simulation-baseline/baseline.xml b/examples/al/simulation-baseline/baseline.xml new file mode 100644 index 0000000..3a69456 --- /dev/null +++ b/examples/al/simulation-baseline/baseline.xml @@ -0,0 +1,33 @@ + + 3200 + + positions + velocities + [ step, time{picosecond}, conserved, temperature{kelvin} ] + + + 32123 + + + metatomic + {model: ../models/mlip_pet-omatpes-v2.pt, template: ../data/equilibrated.xyz, device: cuda} + + + + + + + ../data/equilibrated.xyz + 300 + + + 300 + + + + 1 + 2 + + + + \ No newline at end of file diff --git a/examples/al/simulation-baseline/run.sh b/examples/al/simulation-baseline/run.sh new file mode 100644 index 0000000..a7121d6 --- /dev/null +++ b/examples/al/simulation-baseline/run.sh @@ -0,0 +1 @@ +pixi run i-pi baseline.xml \ No newline at end of file diff --git a/examples/al/simulation-flashmd-omatpes/run.py b/examples/al/simulation-flashmd-omatpes/run.py new file mode 100644 index 0000000..2fa42ab --- /dev/null +++ b/examples/al/simulation-flashmd-omatpes/run.py @@ -0,0 +1,13 @@ +from ipi.utils.scripting import InteractiveSimulation +from flashmd import get_pretrained +from flashmd.ipi import get_nvt_stepper + +with open("../input.xml", "r") as input_xml: + sim = InteractiveSimulation(input_xml) + +# replace the motion step with a FlashMD stepper +_, flashmd_model_32 = get_pretrained("pet-omatpes", 32) +step_fn = get_nvt_stepper(sim, flashmd_model_32, "cuda") +sim.set_motion_step(step_fn) + +sim.run(100) diff --git a/examples/al/simulation-flashmd-symplectic.py b/examples/al/simulation-flashmd-symplectic.py new file mode 100644 index 0000000..e69de29 diff --git a/examples/al/simulation-flashmd-symplectic/run.py b/examples/al/simulation-flashmd-symplectic/run.py new file mode 100644 index 0000000..c3939a2 --- /dev/null +++ b/examples/al/simulation-flashmd-symplectic/run.py @@ -0,0 +1,16 @@ +from metatomic.torch import load_atomistic_model +from ipi.utils.scripting import InteractiveSimulation +from flashmd.ipi_symplectic import get_nvt_stepper + +with open("../input.xml", "r") as input_xml: + sim = InteractiveSimulation(input_xml) + +# replace the motion step with a FlashMD stepper +flashmd_model_32 = load_atomistic_model("../models/flashmd.pt") +flashmd_model_32.to("cuda") +flashmd_symplectic_model_32 = load_atomistic_model("../models/flashmd-symplectic.pt") +flashmd_symplectic_model_32.to("cuda") +step_fn = get_nvt_stepper(sim, flashmd_symplectic_model_32, flashmd_model_32, "cuda", rescale_energy=False) +sim.set_motion_step(step_fn) + +sim.run(100) diff --git a/examples/al/simulation-flashmd/run.py b/examples/al/simulation-flashmd/run.py new file mode 100644 index 0000000..614af2c --- /dev/null +++ b/examples/al/simulation-flashmd/run.py @@ -0,0 +1,14 @@ +from metatomic.torch import load_atomistic_model +from ipi.utils.scripting import InteractiveSimulation +from flashmd.ipi import get_nvt_stepper + +with open("../input.xml", "r") as input_xml: + sim = InteractiveSimulation(input_xml) + +# replace the motion step with a FlashMD stepper +flashmd_model_32 = load_atomistic_model("../models/flashmd.pt") +flashmd_model_32.to("cuda") +step_fn = get_nvt_stepper(sim, flashmd_model_32, "cuda") +sim.set_motion_step(step_fn) + +sim.run(100) From 35834b23611fcfa4a4276006ad62bb39dfb3c365 Mon Sep 17 00:00:00 2001 From: Johannes Spies <13813209+johannes-spies@users.noreply.github.com> Date: Tue, 20 Jan 2026 13:27:41 +0000 Subject: [PATCH 04/10] Rethink steppers --- examples/al/simulation-flashmd-omatpes/run.py | 11 +- .../al/simulation-flashmd-symplectic/run.py | 23 +- examples/al/simulation-flashmd/run.py | 17 +- src/flashmd/ipi_symplectic.py | 522 ------------------ src/flashmd/stepper.py | 8 +- src/flashmd/steppers/__init__.py | 5 + src/flashmd/steppers/core.py | 24 + src/flashmd/steppers/symplectic.py | 166 ++++++ src/flashmd/vv.py | 231 ++++++++ src/flashmd/wrappers/__init__.py | 6 + src/flashmd/wrappers/npt.py | 83 +++ src/flashmd/wrappers/nve.py | 22 + src/flashmd/wrappers/nvt.py | 26 + 13 files changed, 608 insertions(+), 536 deletions(-) delete mode 100644 src/flashmd/ipi_symplectic.py create mode 100644 src/flashmd/steppers/__init__.py create mode 100644 src/flashmd/steppers/core.py create mode 100644 src/flashmd/steppers/symplectic.py create mode 100644 src/flashmd/vv.py create mode 100644 src/flashmd/wrappers/__init__.py create mode 100644 src/flashmd/wrappers/npt.py create mode 100644 src/flashmd/wrappers/nve.py create mode 100644 src/flashmd/wrappers/nvt.py diff --git a/examples/al/simulation-flashmd-omatpes/run.py b/examples/al/simulation-flashmd-omatpes/run.py index 2fa42ab..a379d52 100644 --- a/examples/al/simulation-flashmd-omatpes/run.py +++ b/examples/al/simulation-flashmd-omatpes/run.py @@ -1,13 +1,20 @@ +import torch from ipi.utils.scripting import InteractiveSimulation from flashmd import get_pretrained -from flashmd.ipi import get_nvt_stepper +from flashmd.stepper import FlashMDStepper +from flashmd.wrappers import wrap_nvt +from flashmd.vv import flashmd_vv + +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") with open("../input.xml", "r") as input_xml: sim = InteractiveSimulation(input_xml) # replace the motion step with a FlashMD stepper _, flashmd_model_32 = get_pretrained("pet-omatpes", 32) -step_fn = get_nvt_stepper(sim, flashmd_model_32, "cuda") +stepper = FlashMDStepper(flashmd_model_32, device=device) +step_fn = flashmd_vv(sim, stepper, device=device, dtype=torch.float32, rescale_energy=False) +step_fn = wrap_nvt(sim, step_fn) sim.set_motion_step(step_fn) sim.run(100) diff --git a/examples/al/simulation-flashmd-symplectic/run.py b/examples/al/simulation-flashmd-symplectic/run.py index c3939a2..5244098 100644 --- a/examples/al/simulation-flashmd-symplectic/run.py +++ b/examples/al/simulation-flashmd-symplectic/run.py @@ -1,16 +1,29 @@ +import torch from metatomic.torch import load_atomistic_model from ipi.utils.scripting import InteractiveSimulation -from flashmd.ipi_symplectic import get_nvt_stepper +from flashmd.steppers import SymplecticStepper +from flashmd.stepper import FlashMDStepper +from flashmd.vv import flashmd_vv +from flashmd.wrappers import wrap_nvt + +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") with open("../input.xml", "r") as input_xml: sim = InteractiveSimulation(input_xml) -# replace the motion step with a FlashMD stepper +# load FlashMD model for initial guess flashmd_model_32 = load_atomistic_model("../models/flashmd.pt") -flashmd_model_32.to("cuda") +flashmd_model_32.to(device) +initial_guess = FlashMDStepper(flashmd_model_32, device=device) + +# load FlashMD symplectic model for corrector flashmd_symplectic_model_32 = load_atomistic_model("../models/flashmd-symplectic.pt") -flashmd_symplectic_model_32.to("cuda") -step_fn = get_nvt_stepper(sim, flashmd_symplectic_model_32, flashmd_model_32, "cuda", rescale_energy=False) +flashmd_symplectic_model_32.to(device) + +# replace the motion step with a FlashMD stepper +stepper = SymplecticStepper(initial_guess, flashmd_symplectic_model_32, None) +step_fn = flashmd_vv(sim, stepper, device=device, dtype=torch.float32, rescale_energy=False, random_rotation=False) +step_fn = wrap_nvt(sim, step_fn) sim.set_motion_step(step_fn) sim.run(100) diff --git a/examples/al/simulation-flashmd/run.py b/examples/al/simulation-flashmd/run.py index 614af2c..7195282 100644 --- a/examples/al/simulation-flashmd/run.py +++ b/examples/al/simulation-flashmd/run.py @@ -1,14 +1,23 @@ +import torch from metatomic.torch import load_atomistic_model from ipi.utils.scripting import InteractiveSimulation -from flashmd.ipi import get_nvt_stepper +from flashmd.stepper import FlashMDStepper +from flashmd.vv import flashmd_vv +from flashmd.wrappers.nvt import wrap_nvt + +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") with open("../input.xml", "r") as input_xml: sim = InteractiveSimulation(input_xml) -# replace the motion step with a FlashMD stepper +# load FlashMD model flashmd_model_32 = load_atomistic_model("../models/flashmd.pt") -flashmd_model_32.to("cuda") -step_fn = get_nvt_stepper(sim, flashmd_model_32, "cuda") +flashmd_model_32.to(device) + +# replace the motion step with a FlashMD stepper +stepper = FlashMDStepper(flashmd_model_32, device=device) +step_fn = flashmd_vv(sim, stepper, device=device, dtype=torch.float32, rescale_energy=False) +step_fn = wrap_nvt(sim, step_fn) sim.set_motion_step(step_fn) sim.run(100) diff --git a/src/flashmd/ipi_symplectic.py b/src/flashmd/ipi_symplectic.py deleted file mode 100644 index d28db20..0000000 --- a/src/flashmd/ipi_symplectic.py +++ /dev/null @@ -1,522 +0,0 @@ -from attr import has -from ipi.utils.depend import dstrip -from ipi.utils.units import Constants -from ipi.utils.messages import verbosity, info -from ipi.utils.mathtools import random_rotation as random_rotation_matrix -from ipi.engine.motion.dynamics import NVEIntegrator, NVTIntegrator, NPTIntegrator - -from flashmd.stepper import FlashMDStepper -import ase.units -import torch -import numpy as np -import ase.data - -from metatomic.torch import System -from metatensor.torch import Labels, TensorBlock, TensorMap - - -def get_standard_vv_step( - sim, model=None, device=None, rescale_energy=True, random_rotation=False -): - """ - Returns a velocity Verlet stepper function for i-PI simulations. - - Parameters: - - sim: The i-PI simulation object. - - rescale_energy: If True, rescales the kinetic energy after the step - to maintain energy conservation. - - Returns: - - A function that performs a velocity Verlet step. - """ - - def vv_step(motion): - if random_rotation: - raise NotImplementedError( - "Random rotation is not implemented in the standard VV stepper." - ) - - if rescale_energy: - info("@flashmd: Old energy", verbosity.debug) - old_energy = sim.properties("potential") + sim.properties("kinetic_md") - - print(motion.integrator.pdt, motion.integrator.qdt) - motion.integrator.pstep(level=0) - motion.integrator.pconstraints() - motion.integrator.qcstep() # does two steps because qdt is halved in the i-PI integrator - motion.integrator.qcstep() - motion.integrator.pstep(level=0) - motion.integrator.pconstraints() - - if rescale_energy: - info("@flashmd: Energy rescale", verbosity.debug) - new_energy = sim.properties("potential") + sim.properties("kinetic_md") - kinetic_energy = sim.properties("kinetic_md") - alpha = np.sqrt(1.0 - (new_energy - old_energy) / kinetic_energy) - motion.beads.p[:] = alpha * dstrip(motion.beads.p) - - return vv_step - - -def get_flashmd_vv_step(sim, symplectic_model, model, device, rescale_energy=True, random_rotation=False, accuracy_threshold=1e-3, alpha=0.5): - capabilities = model.capabilities() - - if hasattr(model.module, "base_time_step"): - base_timestep = float(model.module.base_time_step) * ase.units.fs - n_time_steps = int( - [k for k in capabilities.outputs.keys() if "mtt::delta_" in k][0].split("_")[1] - ) - timestep = base_timestep * n_time_steps - elif hasattr(model.module, "timestep"): - timestep = float(model.module.timestep) * ase.units.fs - else: - raise ValueError( - "The model does not specify a base timestep (attribute 'base_time_step' or 'timestep')." - ) - - dt = sim.syslist[0].motion.dt * 2.4188843e-17 * ase.units.s - - if not np.allclose(dt, timestep): - raise ValueError( - f"Mismatch between timestep ({dt}) and model timestep ({timestep})." - ) - - device = torch.device(device) - dtype = getattr(torch, capabilities.dtype) - stepper = Stepper(symplectic_model, model, device, accuracy_threshold=accuracy_threshold, alpha=alpha) - - def flashmd_vv(motion): - info("@flashmd: Starting VV", verbosity.debug) - if rescale_energy: - info("@flashmd: Old energy", verbosity.debug) - old_energy = sim.properties("potential") + sim.properties("kinetic_md") - - info("@flashmd: Stepper", verbosity.debug) - system = ipi_to_system(motion, device, dtype) - - if random_rotation: - # generate a random rotation matrix - R = torch.tensor( - random_rotation_matrix(motion.prng, improper=True), - device=system.positions.device, - dtype=system.positions.dtype, - ) - # applies the random rotation - system.cell = system.cell @ R.T - system.positions = system.positions @ R.T - momenta = system.get_data("momenta").block(0).values.squeeze() - momenta[:] = momenta @ R.T # does the change in place - - new_system = stepper.step(system) - - if random_rotation: - # revert q,p to the original reference frame (`system_to_ipi` ignores the cell) - new_system.positions = new_system.positions @ R - momenta = new_system.get_data("momenta").block(0).values.squeeze() - momenta[:] = momenta @ R - - info("@flashmd: System to ipi", verbosity.debug) - system_to_ipi(motion, new_system) - info("@flashmd: VV P constraints", verbosity.debug) - motion.integrator.pconstraints() - - if rescale_energy: - info("@flashmd: Energy rescale", verbosity.debug) - new_energy = sim.properties("potential") + sim.properties("kinetic_md") - kinetic_energy = sim.properties("kinetic_md") - alpha = np.sqrt(1.0 - (new_energy - old_energy) / kinetic_energy) - motion.beads.p[:] = alpha * dstrip(motion.beads.p) - motion.integrator.pconstraints() - info("@flashmd: End of VV step", verbosity.debug) - - return flashmd_vv - - -def get_nve_stepper( - sim, - symplectic_model, - model, - device, - rescale_energy=True, - random_rotation=False, - use_standard_vv=False, - accuracy_threshold=1e-3, - alpha=0.5, -): - motion = sim.syslist[0].motion - if type(motion.integrator) is not NVEIntegrator: - raise TypeError( - f"Base i-PI integrator is of type {motion.integrator.__class__.__name__}, use a NVE setup." - ) - - if use_standard_vv: - # use the standard velocity Verlet integrator - vv_step = get_standard_vv_step( - sim, model, device, rescale_energy, random_rotation - ) - else: - # defaults to the FlashMD VV stepper - vv_step = get_flashmd_vv_step( - sim, symplectic_model, model, device, rescale_energy, random_rotation, accuracy_threshold=accuracy_threshold, alpha=alpha - ) - - def nve_stepper(motion, *_, **__): - vv_step(motion) - motion.ensemble.time += motion.dt - - return nve_stepper - - -def get_nvt_stepper( - sim, - symplectic_model, - model, - device, - rescale_energy=True, - random_rotation=False, - use_standard_vv=False, - accuracy_threshold=1e-3, - alpha=0.5, -): - motion = sim.syslist[0].motion - if type(motion.integrator) is not NVTIntegrator: - raise TypeError( - f"Base i-PI integrator is of type {motion.integrator.__class__.__name__}, use a NVT setup." - ) - - if use_standard_vv: - # use the standard velocity Verlet integrator - vv_step = get_standard_vv_step( - sim, model, device, rescale_energy, random_rotation - ) - else: - # defaults to the FlashMD VV stepper - vv_step = get_flashmd_vv_step( - sim, symplectic_model, model, device, rescale_energy, random_rotation, accuracy_threshold=accuracy_threshold, alpha=alpha - ) - - def nvt_stepper(motion, *_, **__): - # OBABO splitting of a NVT propagator - motion.thermostat.step() - motion.integrator.pconstraints() - vv_step(motion) - motion.thermostat.step() - motion.integrator.pconstraints() - motion.ensemble.time += motion.dt - - return nvt_stepper - - -def _qbaro(baro): - """Propagation step for the cell volume (adjusting atomic positions and momenta).""" - - v = baro.p[0] / baro.m[0] - halfdt = ( - baro.qdt - ) # this is set to half the inner loop in all integrators that use a barostat - expq, expp = (np.exp(v * halfdt), np.exp(-v * halfdt)) - - baro.nm.qnm[0, :] *= expq - baro.nm.pnm[0, :] *= expp - baro.cell.h *= expq - - -def _pbaro(baro): - """Propagation step for the cell momentum (adjusting atomic positions and momenta).""" - - # we are assuming then that p the coupling between p^2 and dp/dt only involves the fast force - dt = baro.pdt[0] - - # computes the pressure associated with the forces at the outer level MTS level. - press = np.trace(baro.stress_mts(0)) / 3.0 - # integerates the kinetic part of the pressure with the force at the inner-most level. - nbeads = baro.beads.nbeads - baro.p += ( - 3.0 - * dt - * (baro.cell.V * (press - nbeads * baro.pext) + Constants.kb * baro.temp) - ) - - -def get_npt_stepper( - sim, - symplectic_model, - model, - device, - rescale_energy=True, - random_rotation=False, - use_standard_vv=False, - accuracy_threshold=1e-3, - alpha=0.5, -): - motion = sim.syslist[0].motion - if type(motion.integrator) is not NPTIntegrator: - raise TypeError( - f"Base i-PI integrator is of type {motion.integrator.__class__.__name__}, use a NPT setup." - ) - - if use_standard_vv: - # use the standard velocity Verlet integrator - vv_step = get_standard_vv_step( - sim, model, device, rescale_energy, random_rotation - ) - else: - # defaults to the FlashMD VV stepper - vv_step = get_flashmd_vv_step( - sim, symplectic_model, model, device, rescale_energy, random_rotation, accuracy_threshold=accuracy_threshold, alpha=alpha - ) - - # The barostat here needs a simpler splitting than for BZP, something as - # OAbBbBABbAbPO where Bp and Ap are the cell momentum and volume steps - def npt_stepper(motion, *_, **__): - info("@flashmd: Starting NPT step", verbosity.debug) - info("@flashmd: Particle thermo", verbosity.debug) - motion.thermostat.step() - info("@flashmd: P constraints", verbosity.debug) - motion.integrator.pconstraints() - info("@flashmd: Barostat thermo", verbosity.debug) - motion.barostat.thermostat.step() - info("@flashmd: Barostat q", verbosity.debug) - _qbaro(motion.barostat) - info("@flashmd: Barostat p", verbosity.debug) - _pbaro(motion.barostat) - info("@flashmd: FlashVV", verbosity.debug) - vv_step(motion) - info("@flashmd: Barostat p", verbosity.debug) - _pbaro(motion.barostat) - info("@flashmd: Barostat q", verbosity.debug) - _qbaro(motion.barostat) - info("@flashmd: Barostat thermo", verbosity.debug) - motion.barostat.thermostat.step() - info("@flashmd: Particle thermo", verbosity.debug) - motion.thermostat.step() - info("@flashmd: P constraints", verbosity.debug) - motion.integrator.pconstraints() - motion.ensemble.time += motion.dt - info("@flashmd: NPT Step finished", verbosity.debug) - - return npt_stepper - - -def ipi_to_system(motion, device, dtype): - positions = ( - dstrip(motion.beads.q).reshape(-1, 3) * ase.units.Bohr / ase.units.Angstrom - ) - positions_torch = torch.tensor(positions, device=device, dtype=dtype) - cell = dstrip(motion.cell.h).T * ase.units.Bohr / ase.units.Angstrom - cell_torch = torch.tensor(cell, device=device, dtype=dtype) - pbc_torch = torch.tensor([True, True, True], device=device, dtype=torch.bool) - momenta = ( - dstrip(motion.beads.p).reshape(-1, 3) - * (9.1093819e-31 * ase.units.kg) - * (ase.units.Bohr / ase.units.Angstrom) - / (2.4188843e-17 * ase.units.s) - ) - momenta_torch = torch.tensor(momenta, device=device, dtype=dtype) - masses = dstrip(motion.beads.m) * 9.1093819e-31 * ase.units.kg - masses_torch = torch.tensor(masses, device=device, dtype=dtype) - types_torch = torch.tensor( - [ase.data.atomic_numbers[name] for name in motion.beads.names], - device=device, - dtype=torch.int32, - ) - system = System(types_torch, positions_torch, cell_torch, pbc_torch) - system.add_data( - "momenta", - TensorMap( - keys=Labels.single().to(device), - blocks=[ - TensorBlock( - values=momenta_torch.unsqueeze(-1), - samples=Labels( - names=["system", "atom"], - values=torch.tensor( - [[0, j] for j in range(len(momenta_torch))], device=device - ), - ), - components=[ - Labels( - names="xyz", - values=torch.tensor([[0], [1], [2]], device=device), - ) - ], - properties=Labels.single().to(device), - ) - ], - ), - ) - system.add_data( - "masses", - TensorMap( - keys=Labels.single().to(device), - blocks=[ - TensorBlock( - values=masses_torch.unsqueeze(-1), - samples=Labels( - names=["system", "atom"], - values=torch.tensor( - [[0, j] for j in range(len(masses_torch))], device=device - ), - ), - components=[], - properties=Labels.single().to(device), - ) - ], - ), - ) - return system - - -def system_to_ipi(motion, system): - # only needs to convert positions and momenta, it's assumed that the cell won't be changed - motion.beads.q[:] = ( - system.positions.detach().cpu().numpy().flatten() * ase.units.Angstrom / ase.units.Bohr - ) - motion.beads.p[:] = system.get_data("momenta").block().values.detach().squeeze( - -1 - ).cpu().numpy().flatten() / ( - (9.1093819e-31 * ase.units.kg) - * (ase.units.Bohr / ase.units.Angstrom) - / (2.4188843e-17 * ase.units.s) - ) - - -from metatomic.torch import ModelEvaluationOptions, ModelOutput -from metatensor.torch import Labels, TensorBlock, TensorMap -import torch -from metatomic.torch import System -from metatrain.utils.neighbor_lists import get_system_with_neighbor_lists -from typing import List -from metatomic.torch import AtomisticModel -from flashmd.stepper import FlashMDStepper - - -class Stepper(FlashMDStepper): - def __init__( - self, - model: AtomisticModel, - flashmd: AtomisticModel, - device: torch.device, - accuracy_threshold: float = 1e-3, - alpha: float = 0.5, - ): - super().__init__(flashmd, device) - self.model = model - self.evaluation_options_implicit = ModelEvaluationOptions( - length_unit="Angstrom", - outputs={ - "positions": ModelOutput(per_atom=True), - "momenta": ModelOutput(per_atom=True), - }, - ) - self.accuracy_threshold = accuracy_threshold - self.alpha = alpha - - def step(self, system: System): - new_system = super().step(system) - # new_system = system - - cooldown = 300 - accuracy = np.inf - accuracies = [np.inf] - accuracy_threshold = self.accuracy_threshold - alpha = self.alpha - niterations = 0 - old_positions = new_system.positions - old_momenta = new_system.get_data("momenta").block().values - while accuracy > accuracy_threshold: - print("Iteration:", niterations, "Accuracy:", accuracy) - old_positions = new_system.positions * alpha + old_positions * (1 - alpha) - old_momenta = new_system.get_data("momenta").block().values * alpha + old_momenta * (1 - alpha) - midpoint_system = get_system( - (system.positions + old_positions) / 2.0, - system.types, - system.cell, - system.pbc, - (system.get_data("momenta").block().values + old_momenta) / 2.0, - system.get_data("masses").block().values, - ) - midpoint_system = get_system_with_neighbor_lists( - midpoint_system, self.model.requested_neighbor_lists() - ) - outputs = self.model([midpoint_system], self.evaluation_options_implicit, check_consistency=False) - delta_q = outputs[f"positions"].block().values.squeeze(-1) - delta_p = outputs[f"momenta"].block().values - new_system = get_system( - system.positions + delta_q, - system.types, - system.cell, - system.pbc, - system.get_data("momenta").block().values + delta_p, - system.get_data("masses").block().values, - ) - accuracy = torch.abs(new_system.positions - old_positions).max().item() + torch.abs(new_system.get_data("momenta").block().values - old_momenta).max().item() - # print(torch.abs(new_system.positions - old_positions).max().item(), torch.abs(new_system.get_data("momenta").block().values - old_momenta).max().item()) - accuracies.append(accuracy) - if len(accuracies) > 100: - if accuracy > accuracies[-100] and cooldown <= 0: - print("Reducing alpha") - alpha *= 0.5 - cooldown = 300 - niterations += 1 - cooldown -= 1 - print("Number of iterations:", niterations, "accuracy threshold:", accuracy_threshold) - return new_system - - -def get_system(positions, types, cell, pbc, momenta, masses): - device = positions.device - system = System( - positions=positions, - types=types, - cell=cell, - pbc=pbc, - ) - system.add_data( - "momenta", - TensorMap( - keys=Labels.single().to(device), - blocks=[ - TensorBlock( - values=momenta, - samples=Labels( - names=["system", "atom"], - values=torch.tensor( - [[0, j] for j in range(len(system))], - device=device, - ), - ), - components=[ - Labels( - names="xyz", - values=torch.tensor( - [[0], [1], [2]], device=device - ), - ) - ], - properties=Labels.single().to(device), - ) - ], - ), - ) - system.add_data( - "masses", - TensorMap( - keys=Labels.single().to(device), - blocks=[ - TensorBlock( - values=masses, - samples=Labels( - names=["system", "atom"], - values=torch.tensor( - [[0, j] for j in range(len(system))], - device=device, - ), - ), - components=[], - properties=Labels.single().to(device), - ) - ], - ), - ) - return system diff --git a/src/flashmd/stepper.py b/src/flashmd/stepper.py index a8e46b9..3e9956d 100644 --- a/src/flashmd/stepper.py +++ b/src/flashmd/stepper.py @@ -1,4 +1,3 @@ -# from ..utils.pretrained import load_pretrained_models import ase.units import torch from metatensor.torch import Labels, TensorBlock, TensorMap @@ -6,9 +5,10 @@ from metatrain.utils.neighbor_lists import get_system_with_neighbor_lists from .constraints import enforce_physical_constraints +from .steppers import AtomisticStepper -class FlashMDStepper: +class FlashMDStepper(AtomisticStepper): def __init__( self, model: AtomisticModel, @@ -17,7 +17,6 @@ def __init__( self.model = model.to(device) self.time_step = float(model.module.timestep) * ase.units.fs - # one of these for each model: self.evaluation_options = ModelEvaluationOptions( length_unit="Angstrom", outputs={ @@ -29,6 +28,9 @@ def __init__( self.dtype = getattr(torch, self.model.capabilities().dtype) self.device = device + def get_timestep(self) -> float: + return self.time_step + def step(self, system: System): if system.device.type != self.device.type: raise ValueError("System device does not match stepper device.") diff --git a/src/flashmd/steppers/__init__.py b/src/flashmd/steppers/__init__.py new file mode 100644 index 0000000..1d7e326 --- /dev/null +++ b/src/flashmd/steppers/__init__.py @@ -0,0 +1,5 @@ +from .core import AtomisticStepper +from .symplectic import SymplecticStepper + + +__all__ = ["AtomisticStepper", "SymplecticStepper"] diff --git a/src/flashmd/steppers/core.py b/src/flashmd/steppers/core.py new file mode 100644 index 0000000..7cfafe5 --- /dev/null +++ b/src/flashmd/steppers/core.py @@ -0,0 +1,24 @@ +from abc import ABC, abstractmethod + +from metatomic.torch import System + + +class AtomisticStepper(ABC): + @abstractmethod + def get_timestep(self) -> float: + """Get the time step of the stepper in femtoseconds. + + Returns: + float: The time step in femtoseconds. + """ + + @abstractmethod + def step(self, system: System) -> System: # type: ignore + """Perform a single MD step on the given system. + + Args: + system (System): The input system containing positions, momenta, etc. + + Returns: + System: The updated system after one MD step. + """ diff --git a/src/flashmd/steppers/symplectic.py b/src/flashmd/steppers/symplectic.py new file mode 100644 index 0000000..8fe7987 --- /dev/null +++ b/src/flashmd/steppers/symplectic.py @@ -0,0 +1,166 @@ +from typing import Callable + +import ase.units +import numpy as np +import torch +from metatensor.torch import Labels, TensorBlock, TensorMap +from metatomic.torch import AtomisticModel, ModelEvaluationOptions, ModelOutput, System +from metatrain.utils.neighbor_lists import get_system_with_neighbor_lists + +from flashmd.steppers import AtomisticStepper + + +class SymplecticStepper(AtomisticStepper): + def __init__( + self, + initial_guess: AtomisticStepper, + midpoint_to_delta_model: AtomisticModel, + fixed_point_solver: Callable[ + [Callable[[torch.Tensor], torch.Tensor], torch.Tensor], torch.Tensor + ], + # device: torch.device, + # accuracy_threshold: float = 1e-3, + # alpha: float = 0.5, + ): + # super().__init__(flashmd, device) + self.initial_guess = initial_guess + self.midpoint_to_delta_model = midpoint_to_delta_model + self.fixed_point_solver = fixed_point_solver + + # self.model = model + self.evaluation_options_implicit = ModelEvaluationOptions( + length_unit="Angstrom", + outputs={ + "positions": ModelOutput(per_atom=True), + "momenta": ModelOutput(per_atom=True), + }, + ) + self.accuracy_threshold = 1e-3 + self.alpha = 0.5 + + def get_timestep(self) -> float: + timestep: float = self.midpoint_to_delta_model.module.timestep.item() # type: ignore + return timestep * ase.units.fs + + def step(self, system: System) -> System: # type: ignore + new_system = self.initial_guess.step(system) + # new_system = system + + cooldown = 300 + accuracy = np.inf + accuracies = [np.inf] + accuracy_threshold = self.accuracy_threshold + alpha = self.alpha + niterations = 0 + old_positions = new_system.positions + old_momenta = new_system.get_data("momenta").block().values + while accuracy > accuracy_threshold: + print("Iteration:", niterations, "Accuracy:", accuracy) + old_positions = new_system.positions * alpha + old_positions * (1 - alpha) + old_momenta = new_system.get_data( + "momenta" + ).block().values * alpha + old_momenta * (1 - alpha) + midpoint_system = get_system( + (system.positions + old_positions) / 2.0, + system.types, + system.cell, + system.pbc, + (system.get_data("momenta").block().values + old_momenta) / 2.0, + system.get_data("masses").block().values, + ) + midpoint_system = get_system_with_neighbor_lists( + midpoint_system, self.midpoint_to_delta_model.requested_neighbor_lists() + ) + outputs = self.midpoint_to_delta_model( + [midpoint_system], + self.evaluation_options_implicit, + check_consistency=False, + ) + delta_q = outputs["positions"].block().values.squeeze(-1) + delta_p = outputs["momenta"].block().values + new_system = get_system( + system.positions + delta_q, + system.types, + system.cell, + system.pbc, + system.get_data("momenta").block().values + delta_p, + system.get_data("masses").block().values, + ) + accuracy = ( + torch.abs(new_system.positions - old_positions).max().item() + + torch.abs(new_system.get_data("momenta").block().values - old_momenta) + .max() + .item() + ) + # print(torch.abs(new_system.positions - old_positions).max().item(), torch.abs(new_system.get_data("momenta").block().values - old_momenta).max().item()) + accuracies.append(accuracy) + if len(accuracies) > 100: + if accuracy > accuracies[-100] and cooldown <= 0: + print("Reducing alpha") + alpha *= 0.5 + cooldown = 300 + niterations += 1 + cooldown -= 1 + print( + "Number of iterations:", + niterations, + "accuracy threshold:", + accuracy_threshold, + ) + return new_system + + +def get_system(positions, types, cell, pbc, momenta, masses): + device = positions.device + system = System( + positions=positions, + types=types, + cell=cell, + pbc=pbc, + ) + system.add_data( + "momenta", + TensorMap( + keys=Labels.single().to(device), + blocks=[ + TensorBlock( + values=momenta, + samples=Labels( + names=["system", "atom"], + values=torch.tensor( + [[0, j] for j in range(len(system))], + device=device, + ), + ), + components=[ + Labels( + names="xyz", + values=torch.tensor([[0], [1], [2]], device=device), + ) + ], + properties=Labels.single().to(device), + ) + ], + ), + ) + system.add_data( + "masses", + TensorMap( + keys=Labels.single().to(device), + blocks=[ + TensorBlock( + values=masses, + samples=Labels( + names=["system", "atom"], + values=torch.tensor( + [[0, j] for j in range(len(system))], + device=device, + ), + ), + components=[], + properties=Labels.single().to(device), + ) + ], + ), + ) + return system diff --git a/src/flashmd/vv.py b/src/flashmd/vv.py new file mode 100644 index 0000000..fe47205 --- /dev/null +++ b/src/flashmd/vv.py @@ -0,0 +1,231 @@ +import ase.data +import ase.units +import numpy as np +import torch +from ipi.utils.depend import dstrip +from ipi.utils.mathtools import random_rotation as random_rotation_matrix +from ipi.utils.messages import info, verbosity +from metatensor.torch import Labels, TensorBlock, TensorMap +from metatomic.torch import System + +from .stepper import AtomisticStepper + + +def standard_vv(sim, rescale_energy: bool = False): + """ + Returns a velocity Verlet stepper function for i-PI simulations. + + Parameters: + sim: The i-PI simulation object. + rescale_energy: If True, rescales the kinetic energy after the step + to maintain energy conservation. + + Returns: + A function that performs a velocity Verlet step. + """ + + def vv_step(motion): + old_energy = None + if rescale_energy: + info("@flashmd: Old energy", verbosity.debug) + old_energy = sim.properties("potential") + sim.properties("kinetic_md") + + print(motion.integrator.pdt, motion.integrator.qdt) + motion.integrator.pstep(level=0) + motion.integrator.pconstraints() + motion.integrator.qcstep() # does two steps because qdt is halved in the i-PI integrator + motion.integrator.qcstep() + motion.integrator.pstep(level=0) + motion.integrator.pconstraints() + + if rescale_energy: + info("@flashmd: Energy rescale", verbosity.debug) + new_energy = sim.properties("potential") + sim.properties("kinetic_md") + kinetic_energy = sim.properties("kinetic_md") + alpha = np.sqrt(1.0 - (new_energy - old_energy) / kinetic_energy) + motion.beads.p[:] = alpha * dstrip(motion.beads.p) + + return vv_step + + +def flashmd_vv( + sim, + stepper: AtomisticStepper, + device: torch.device, + dtype: torch.dtype, + # symplectic_model, + # model, + # device, + rescale_energy=True, + random_rotation=False, + # accuracy_threshold=1e-3, + # alpha=0.5, +): + # capabilities = model.capabilities() + + # if hasattr(model.module, "base_time_step"): + # base_timestep = float(model.module.base_time_step) * ase.units.fs + # n_time_steps = int( + # [k for k in capabilities.outputs.keys() if "mtt::delta_" in k][0].split( + # "_" + # )[1] + # ) + # timestep = base_timestep * n_time_steps + # elif hasattr(model.module, "timestep"): + # timestep = float(model.module.timestep) * ase.units.fs + # else: + # raise ValueError( + # "The model does not specify a base timestep (attribute 'base_time_step' or 'timestep')." + # ) + + # compare the model's internal timestep with the i-PI one -- they need to match + dt = sim.syslist[0].motion.dt * 2.4188843e-17 * ase.units.s + timestep = stepper.get_timestep() + if not np.allclose(dt, timestep): + raise ValueError( + f"Mismatch between timestep ({dt}) and model timestep ({timestep})." + ) + + # device = torch.device(device) + # dtype = getattr(torch, capabilities.dtype) + # stepper = Stepper( + # symplectic_model, + # model, + # device, + # accuracy_threshold=accuracy_threshold, + # alpha=alpha, + # ) + + def flashmd_vv(motion): + info("@flashmd: Starting VV", verbosity.debug) + old_energy = None + if rescale_energy: + info("@flashmd: Old energy", verbosity.debug) + old_energy = sim.properties("potential") + sim.properties("kinetic_md") + + info("@flashmd: Stepper", verbosity.debug) + system = ipi_to_system(motion, device, dtype) + + R = None + if random_rotation: + # generate a random rotation matrix + R = torch.tensor( + random_rotation_matrix(motion.prng, improper=True), + device=system.positions.device, + dtype=system.positions.dtype, + ) + # applies the random rotation + system.cell = system.cell @ R.T + system.positions = system.positions @ R.T + momenta = system.get_data("momenta").block(0).values.squeeze() + momenta[:] = momenta @ R.T # does the change in place + + print(system) + new_system = stepper.step(system) + + if random_rotation: + # revert q,p to the original reference frame (`system_to_ipi` ignores the cell) + new_system.positions = new_system.positions @ R + momenta = new_system.get_data("momenta").block(0).values.squeeze() + momenta[:] = momenta @ R + + info("@flashmd: System to ipi", verbosity.debug) + system_to_ipi(motion, new_system) + info("@flashmd: VV P constraints", verbosity.debug) + motion.integrator.pconstraints() + + if rescale_energy: + info("@flashmd: Energy rescale", verbosity.debug) + new_energy = sim.properties("potential") + sim.properties("kinetic_md") + kinetic_energy = sim.properties("kinetic_md") + alpha = np.sqrt(1.0 - (new_energy - old_energy) / kinetic_energy) + motion.beads.p[:] = alpha * dstrip(motion.beads.p) + motion.integrator.pconstraints() + info("@flashmd: End of VV step", verbosity.debug) + + return flashmd_vv + + +def ipi_to_system(motion, device, dtype): + positions = ( + dstrip(motion.beads.q).reshape(-1, 3) * ase.units.Bohr / ase.units.Angstrom + ) + positions_torch = torch.tensor(positions, device=device, dtype=dtype) + cell = dstrip(motion.cell.h).T * ase.units.Bohr / ase.units.Angstrom + cell_torch = torch.tensor(cell, device=device, dtype=dtype) + pbc_torch = torch.tensor([True, True, True], device=device, dtype=torch.bool) + momenta = ( + dstrip(motion.beads.p).reshape(-1, 3) + * (9.1093819e-31 * ase.units.kg) + * (ase.units.Bohr / ase.units.Angstrom) + / (2.4188843e-17 * ase.units.s) + ) + momenta_torch = torch.tensor(momenta, device=device, dtype=dtype) + masses = dstrip(motion.beads.m) * 9.1093819e-31 * ase.units.kg + masses_torch = torch.tensor(masses, device=device, dtype=dtype) + types_torch = torch.tensor( + [ase.data.atomic_numbers[name] for name in motion.beads.names], + device=device, + dtype=torch.int32, + ) + system = System(types_torch, positions_torch, cell_torch, pbc_torch) + system.add_data( + "momenta", + TensorMap( + keys=Labels.single().to(device), + blocks=[ + TensorBlock( + values=momenta_torch.unsqueeze(-1), + samples=Labels( + names=["system", "atom"], + values=torch.tensor( + [[0, j] for j in range(len(momenta_torch))], device=device + ), + ), + components=[ + Labels( + names="xyz", + values=torch.tensor([[0], [1], [2]], device=device), + ) + ], + properties=Labels.single().to(device), + ) + ], + ), + ) + system.add_data( + "masses", + TensorMap( + keys=Labels.single().to(device), + blocks=[ + TensorBlock( + values=masses_torch.unsqueeze(-1), + samples=Labels( + names=["system", "atom"], + values=torch.tensor( + [[0, j] for j in range(len(masses_torch))], device=device + ), + ), + components=[], + properties=Labels.single().to(device), + ) + ], + ), + ) + return system + + +def system_to_ipi(motion, system): + # only needs to convert positions and momenta, it's assumed that the cell won't be changed + motion.beads.q[:] = ( + system.positions.detach().cpu().numpy().flatten() + * ase.units.Angstrom + / ase.units.Bohr + ) + motion.beads.p[:] = system.get_data("momenta").block().values.detach().squeeze( + -1 + ).cpu().numpy().flatten() / ( + (9.1093819e-31 * ase.units.kg) + * (ase.units.Bohr / ase.units.Angstrom) + / (2.4188843e-17 * ase.units.s) + ) diff --git a/src/flashmd/wrappers/__init__.py b/src/flashmd/wrappers/__init__.py new file mode 100644 index 0000000..48861b8 --- /dev/null +++ b/src/flashmd/wrappers/__init__.py @@ -0,0 +1,6 @@ +from .npt import wrap_npt +from .nve import wrap_nve +from .nvt import wrap_nvt + + +__all__ = ["wrap_npt", "wrap_nve", "wrap_nvt"] diff --git a/src/flashmd/wrappers/npt.py b/src/flashmd/wrappers/npt.py new file mode 100644 index 0000000..5e09300 --- /dev/null +++ b/src/flashmd/wrappers/npt.py @@ -0,0 +1,83 @@ +from typing import Callable + +import numpy as np +from ipi.engine.motion import Motion +from ipi.engine.motion.dynamics import NPTIntegrator +from ipi.engine.simulation import Simulation +from ipi.utils.messages import info, verbosity +from ipi.utils.units import Constants + + +def _qbaro(baro): + """Propagation step for the cell volume (adjusting atomic positions and momenta).""" + + v = baro.p[0] / baro.m[0] + halfdt = ( + baro.qdt + ) # this is set to half the inner loop in all integrators that use a barostat + expq, expp = (np.exp(v * halfdt), np.exp(-v * halfdt)) + + baro.nm.qnm[0, :] *= expq + baro.nm.pnm[0, :] *= expp + baro.cell.h *= expq + + +def _pbaro(baro): + """Propagation step for the cell momentum (adjusting atomic positions and momenta).""" + + # we are assuming then that p the coupling between p^2 and dp/dt only involves the fast force + dt = baro.pdt[0] + + # computes the pressure associated with the forces at the outer level MTS level. + press = np.trace(baro.stress_mts(0)) / 3.0 + # integerates the kinetic part of the pressure with the force at the inner-most level. + nbeads = baro.beads.nbeads + baro.p += ( + 3.0 + * dt + * (baro.cell.V * (press - nbeads * baro.pext) + Constants.kb * baro.temp) + ) + + +def wrap_npt( + sim: Simulation, + vv_step: Callable[[Motion], None], +) -> Callable[[Motion], None]: + """Wrap a velocity-Verlet stepper into an NPT stepper for i-PI.""" + + motion = sim.syslist[0].motion + if type(motion.integrator) is not NPTIntegrator: + raise TypeError( + f"Base i-PI integrator is of type {motion.integrator.__class__.__name__}, use a NPT setup." + ) + + # The barostat here needs a simpler splitting than for BZP, something as + # OAbBbBABbAbPO where Bp and Ap are the cell momentum and volume steps + def npt_stepper(motion, *_, **__): + info("@flashmd: Starting NPT step", verbosity.debug) + info("@flashmd: Particle thermo", verbosity.debug) + motion.thermostat.step() + info("@flashmd: P constraints", verbosity.debug) + motion.integrator.pconstraints() + info("@flashmd: Barostat thermo", verbosity.debug) + motion.barostat.thermostat.step() + info("@flashmd: Barostat q", verbosity.debug) + _qbaro(motion.barostat) + info("@flashmd: Barostat p", verbosity.debug) + _pbaro(motion.barostat) + info("@flashmd: FlashVV", verbosity.debug) + vv_step(motion) + info("@flashmd: Barostat p", verbosity.debug) + _pbaro(motion.barostat) + info("@flashmd: Barostat q", verbosity.debug) + _qbaro(motion.barostat) + info("@flashmd: Barostat thermo", verbosity.debug) + motion.barostat.thermostat.step() + info("@flashmd: Particle thermo", verbosity.debug) + motion.thermostat.step() + info("@flashmd: P constraints", verbosity.debug) + motion.integrator.pconstraints() + motion.ensemble.time += motion.dt + info("@flashmd: NPT Step finished", verbosity.debug) + + return npt_stepper diff --git a/src/flashmd/wrappers/nve.py b/src/flashmd/wrappers/nve.py new file mode 100644 index 0000000..e9d4d94 --- /dev/null +++ b/src/flashmd/wrappers/nve.py @@ -0,0 +1,22 @@ +from typing import Callable + +from ipi.engine.motion import Motion +from ipi.engine.motion.dynamics import NVEIntegrator +from ipi.engine.simulation import Simulation + + +def wrap_nve( + sim: Simulation, + vv_step: Callable[[Motion], None], +) -> Callable[[Motion], None]: + motion = sim.syslist[0].motion + if type(motion.integrator) is not NVEIntegrator: + raise TypeError( + f"Base i-PI integrator is of type {motion.integrator.__class__.__name__}, use a NVE setup." + ) + + def nve_stepper(motion, *_, **__): + vv_step(motion) + motion.ensemble.time += motion.dt + + return nve_stepper diff --git a/src/flashmd/wrappers/nvt.py b/src/flashmd/wrappers/nvt.py new file mode 100644 index 0000000..27670aa --- /dev/null +++ b/src/flashmd/wrappers/nvt.py @@ -0,0 +1,26 @@ +from typing import Callable + +from ipi.engine.motion import Motion +from ipi.engine.motion.dynamics import NVTIntegrator + + +def wrap_nvt( + sim, + vv_step: Callable[[Motion], None], +) -> Callable[[Motion], None]: + motion = sim.syslist[0].motion + if type(motion.integrator) is not NVTIntegrator: + raise TypeError( + f"Base i-PI integrator is of type {motion.integrator.__class__.__name__}, use a NVT setup." + ) + + def nvt_stepper(motion, *_, **__): + # OBABO splitting of a NVT propagator + motion.thermostat.step() + motion.integrator.pconstraints() + vv_step(motion) + motion.thermostat.step() + motion.integrator.pconstraints() + motion.ensemble.time += motion.dt + + return nvt_stepper From 88c7d287a1261acb586dd8f7ab6bf49b2bd89285 Mon Sep 17 00:00:00 2001 From: Johannes Spies <13813209+johannes-spies@users.noreply.github.com> Date: Tue, 20 Jan 2026 13:31:20 +0000 Subject: [PATCH 05/10] Draft advanced FPI solver --- src/flashmd/fpi.py | 85 ++++++++++++++++++++++++++++++++++++++++++++++ tests/test_fpi.py | 19 +++++++++++ 2 files changed, 104 insertions(+) create mode 100644 src/flashmd/fpi.py create mode 100644 tests/test_fpi.py diff --git a/src/flashmd/fpi.py b/src/flashmd/fpi.py new file mode 100644 index 0000000..a869ced --- /dev/null +++ b/src/flashmd/fpi.py @@ -0,0 +1,85 @@ +from typing import Callable + +import torch + + +def anderson_solver( + f: Callable[[torch.Tensor], torch.Tensor], + x0: torch.Tensor, + m: int = 5, + max_iter: int = 50, + tol: float = 1e-5, + beta: float = 1.0, + lambda_reg: float = 1e-4, + return_residual_norms: bool = False, +) -> torch.Tensor | tuple[torch.Tensor, list[float]]: + """ + Solve fixed-point problem x = f(x) using Anderson acceleration. + + Args: + f: Fixed-point mapping. + x0: Initial guess. + m: Number of previous iterates to use for acceleration. + max_iter: Maximum number of iterations. + tol: Convergence tolerance based on residual norm. + beta: Mixing parameter for the fixed-point step. + lambda_reg: Regularization parameter for least-squares solve. + return_residual_norms: If True, also return list of residual norms. + + Returns: + Approximate solution x, and optionally list of residual norms. + """ + # history buffers + delta_xs, delta_gs = [], [] + residual_norms = [] + + # run fixed-pointer iteration + x = x0 + fx = f(x) + g = fx - x + x_prev, g_prev = None, None + for k in range(max_iter): + # evaluate residual and compute convergence + res_norm = torch.norm(g).item() + residual_norms.append(res_norm) + if res_norm < tol: + break + + # update history + if k > 0: + assert x_prev is not None and g_prev is not None + delta_xs.append(x - x_prev) + delta_gs.append(g - g_prev) + + # truncate history to hold at most m elements + if len(delta_xs) > m: + delta_xs.pop(0) + delta_gs.pop(0) + x_prev, g_prev = x, g + + # compute Anderson acceleration step + if len(delta_xs) > 0: + # create matrices from history of shape (features, history_length) + X = torch.stack(delta_xs, dim=1) # (n, k) + G = torch.stack(delta_gs, dim=1) # (n, k) + + # solve regularized least-squares problem + A = G.T @ G + lambda_reg * torch.eye(G.shape[1], device=G.device) + b = G.T @ g + try: + coeffs = torch.linalg.solve(A, b) + # update iterate with momentum + Anderson step + x = x + beta * g - (X + beta * G) @ coeffs + except RuntimeError: + x = x + beta * g # fallback to fixed-point step if matrix is singular + else: + x = x + beta * g # fixed-point step if there is no history + + # update iterate and residual + fx = f(x) + g = fx - x + + if return_residual_norms: + return x, residual_norms + else: + return x diff --git a/tests/test_fpi.py b/tests/test_fpi.py new file mode 100644 index 0000000..c05e6b2 --- /dev/null +++ b/tests/test_fpi.py @@ -0,0 +1,19 @@ +import torch + +from flashmd.fpi import anderson_solver + + +def test_anderson_solver_convergence(): + """Test that the Anderson solver converges on a simple fixed-point problem.""" + + def f(x): + return 0.5 * x + 1.0 + + x0 = torch.tensor([0.0]) + x_sol, residuals = anderson_solver( + f, x0, m=3, max_iter=100, tol=1e-6, return_residual_norms=True + ) + x_exact = torch.tensor([2.0]) + + assert torch.allclose(x_sol, x_exact, atol=1e-5) + assert all(earlier >= later for earlier, later in zip(residuals, residuals[1:])) From c1a76f387c1242ca9b34c3853d6ea8227bc6a04c Mon Sep 17 00:00:00 2001 From: Johannes Spies <13813209+johannes-spies@users.noreply.github.com> Date: Tue, 20 Jan 2026 15:59:35 +0000 Subject: [PATCH 06/10] Add another solver --- examples/al/compare.ipynb | 2 +- .../al/simulation-flashmd-symplectic/run.py | 16 +- src/flashmd/fpi.py | 3 +- src/flashmd/steppers/symplectic.py | 243 +++++++++--------- 4 files changed, 135 insertions(+), 129 deletions(-) diff --git a/examples/al/compare.ipynb b/examples/al/compare.ipynb index a319c7c..3dd0e63 100644 --- a/examples/al/compare.ipynb +++ b/examples/al/compare.ipynb @@ -129,7 +129,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/examples/al/simulation-flashmd-symplectic/run.py b/examples/al/simulation-flashmd-symplectic/run.py index 5244098..dc78aa5 100644 --- a/examples/al/simulation-flashmd-symplectic/run.py +++ b/examples/al/simulation-flashmd-symplectic/run.py @@ -1,3 +1,4 @@ +from typing import Callable import torch from metatomic.torch import load_atomistic_model from ipi.utils.scripting import InteractiveSimulation @@ -5,6 +6,7 @@ from flashmd.stepper import FlashMDStepper from flashmd.vv import flashmd_vv from flashmd.wrappers import wrap_nvt +from flashmd.fpi import anderson_solver device = torch.device("cuda" if torch.cuda.is_available() else "cpu") @@ -20,8 +22,20 @@ flashmd_symplectic_model_32 = load_atomistic_model("../models/flashmd-symplectic.pt") flashmd_symplectic_model_32.to(device) +# create a fixed-point solver and attach a logger to see the convergence behavior +solver_kwargs = dict(m=0, max_iter=100, tol=1e-3, beta=0.5) +def solver_with_log( + g: Callable[[torch.Tensor], torch.Tensor], + x0: torch.Tensor, +) -> torch.Tensor: + x_star, norms = anderson_solver(g, x0, return_residual_norms=True, **solver_kwargs) # type: ignore + print("l2 accuracies (converged in %d steps):" % len(norms)) + for i, n in enumerate(norms): + print("iteration", i, "residual norm:", n) + return x_star + # replace the motion step with a FlashMD stepper -stepper = SymplecticStepper(initial_guess, flashmd_symplectic_model_32, None) +stepper = SymplecticStepper(initial_guess, flashmd_symplectic_model_32, solver_with_log) step_fn = flashmd_vv(sim, stepper, device=device, dtype=torch.float32, rescale_energy=False, random_rotation=False) step_fn = wrap_nvt(sim, step_fn) sim.set_motion_step(step_fn) diff --git a/src/flashmd/fpi.py b/src/flashmd/fpi.py index a869ced..15a7242 100644 --- a/src/flashmd/fpi.py +++ b/src/flashmd/fpi.py @@ -30,7 +30,8 @@ def anderson_solver( Approximate solution x, and optionally list of residual norms. """ # history buffers - delta_xs, delta_gs = [], [] + delta_xs: list[torch.Tensor] = [] + delta_gs: list[torch.Tensor] = [] residual_norms = [] # run fixed-pointer iteration diff --git a/src/flashmd/steppers/symplectic.py b/src/flashmd/steppers/symplectic.py index 8fe7987..fdc4406 100644 --- a/src/flashmd/steppers/symplectic.py +++ b/src/flashmd/steppers/symplectic.py @@ -1,7 +1,7 @@ +from functools import partial from typing import Callable import ase.units -import numpy as np import torch from metatensor.torch import Labels, TensorBlock, TensorMap from metatomic.torch import AtomisticModel, ModelEvaluationOptions, ModelOutput, System @@ -10,6 +10,51 @@ from flashmd.steppers import AtomisticStepper +def system_to_phase_space(system) -> torch.Tensor: + # extract positions and momenta from system + positions = system.positions + momenta = system.get_data("momenta")[0].values + # flatten and concatenate + return torch.cat([positions.view(-1), momenta.view(-1)], dim=0) + + +def phase_space_to_system(system, x: torch.Tensor): + # extract positions and momenta from concatenated tensor and reshape into original shapes + positions, momenta = torch.chunk(x, 2) + positions = positions.view_as(system.positions) + momenta = momenta.view_as(system.get_data("momenta")[0].values) + + # take the types, masses and cell from the original system + new_system = System( + types=system.types, + positions=positions, + cell=system.cell, + pbc=system.pbc, + ) + + # copy masses + new_system.add_data("masses", system.get_data("masses")) + + # attach momenta + device = positions.device + new_system.add_data( + "momenta", + TensorMap( + keys=Labels.single().to(device), + blocks=[ + TensorBlock( + values=momenta, + samples=Labels.range("atom", len(system)).to(device), + components=[Labels.range("xyz", 3).to(device)], + properties=Labels.single().to(device), + ) + ], + ), + ) + + return new_system + + class SymplecticStepper(AtomisticStepper): def __init__( self, @@ -18,9 +63,6 @@ def __init__( fixed_point_solver: Callable[ [Callable[[torch.Tensor], torch.Tensor], torch.Tensor], torch.Tensor ], - # device: torch.device, - # accuracy_threshold: float = 1e-3, - # alpha: float = 0.5, ): # super().__init__(flashmd, device) self.initial_guess = initial_guess @@ -28,139 +70,88 @@ def __init__( self.fixed_point_solver = fixed_point_solver # self.model = model - self.evaluation_options_implicit = ModelEvaluationOptions( + self.evaluation_options = ModelEvaluationOptions( length_unit="Angstrom", outputs={ "positions": ModelOutput(per_atom=True), "momenta": ModelOutput(per_atom=True), }, ) - self.accuracy_threshold = 1e-3 - self.alpha = 0.5 + self.fixed_point_solver = fixed_point_solver def get_timestep(self) -> float: timestep: float = self.midpoint_to_delta_model.module.timestep.item() # type: ignore return timestep * ase.units.fs - def step(self, system: System) -> System: # type: ignore - new_system = self.initial_guess.step(system) - # new_system = system - - cooldown = 300 - accuracy = np.inf - accuracies = [np.inf] - accuracy_threshold = self.accuracy_threshold - alpha = self.alpha - niterations = 0 - old_positions = new_system.positions - old_momenta = new_system.get_data("momenta").block().values - while accuracy > accuracy_threshold: - print("Iteration:", niterations, "Accuracy:", accuracy) - old_positions = new_system.positions * alpha + old_positions * (1 - alpha) - old_momenta = new_system.get_data( - "momenta" - ).block().values * alpha + old_momenta * (1 - alpha) - midpoint_system = get_system( - (system.positions + old_positions) / 2.0, - system.types, - system.cell, - system.pbc, - (system.get_data("momenta").block().values + old_momenta) / 2.0, - system.get_data("masses").block().values, - ) - midpoint_system = get_system_with_neighbor_lists( - midpoint_system, self.midpoint_to_delta_model.requested_neighbor_lists() - ) - outputs = self.midpoint_to_delta_model( - [midpoint_system], - self.evaluation_options_implicit, - check_consistency=False, - ) - delta_q = outputs["positions"].block().values.squeeze(-1) - delta_p = outputs["momenta"].block().values - new_system = get_system( - system.positions + delta_q, - system.types, - system.cell, - system.pbc, - system.get_data("momenta").block().values + delta_p, - system.get_data("masses").block().values, - ) - accuracy = ( - torch.abs(new_system.positions - old_positions).max().item() - + torch.abs(new_system.get_data("momenta").block().values - old_momenta) - .max() - .item() - ) - # print(torch.abs(new_system.positions - old_positions).max().item(), torch.abs(new_system.get_data("momenta").block().values - old_momenta).max().item()) - accuracies.append(accuracy) - if len(accuracies) > 100: - if accuracy > accuracies[-100] and cooldown <= 0: - print("Reducing alpha") - alpha *= 0.5 - cooldown = 300 - niterations += 1 - cooldown -= 1 - print( - "Number of iterations:", - niterations, - "accuracy threshold:", - accuracy_threshold, + def _fixed_point_step( + self, system, x_init: torch.Tensor, x_bar: torch.Tensor + ) -> torch.Tensor: + """ + Take the current estimate of the midpoint in phase-space representation, update and + return it. + + NOTE: The function takes a system as the first argument to allow constructing a + metatomic-compatible System object, which unfortunately is required for model + evaluation. + + Args: + system: The initial system before the step. + x_init: The initial system in phase-space representation. For the fixed-point + iterations, it has to be of shape (B, D) where B is the batch size (1 here) and + D is the dimension of the phase space. + x_bar: The current estimate of the midpoint in phase-space representation. Note + that this also has to be of shape (B, D). + + Returns: + The updated midpoint in phase-space representation. + """ + # flatten the batch dimension + x_bar = x_bar.squeeze(0) + + # convert to system representation + midpoint_system = phase_space_to_system(system, x_bar) + + # attach neighbor lists based on the model's requests + midpoint_system = get_system_with_neighbor_lists( + midpoint_system, self.midpoint_to_delta_model.requested_neighbor_lists() ) - return new_system + # run the model to get the deltas + evaluation_options = self.evaluation_options + outputs = self.midpoint_to_delta_model( + [midpoint_system], evaluation_options, check_consistency=False + ) -def get_system(positions, types, cell, pbc, momenta, masses): - device = positions.device - system = System( - positions=positions, - types=types, - cell=cell, - pbc=pbc, - ) - system.add_data( - "momenta", - TensorMap( - keys=Labels.single().to(device), - blocks=[ - TensorBlock( - values=momenta, - samples=Labels( - names=["system", "atom"], - values=torch.tensor( - [[0, j] for j in range(len(system))], - device=device, - ), - ), - components=[ - Labels( - names="xyz", - values=torch.tensor([[0], [1], [2]], device=device), - ) - ], - properties=Labels.single().to(device), - ) - ], - ), - ) - system.add_data( - "masses", - TensorMap( - keys=Labels.single().to(device), - blocks=[ - TensorBlock( - values=masses, - samples=Labels( - names=["system", "atom"], - values=torch.tensor( - [[0, j] for j in range(len(system))], - device=device, - ), - ), - components=[], - properties=Labels.single().to(device), - ) - ], - ), - ) - return system + # depending on the model, extract deltas + delta_q = outputs["positions"].block().values.squeeze(-1) + delta_p = outputs["momenta"].block().values + + # compute new midpoint in phase space + delta_x = torch.cat([delta_q.view(-1), delta_p.view(-1)], dim=0) + + # compute new midpoint + x_bar_new = x_init + 0.5 * delta_x + return x_bar_new + + def step(self, system: System) -> System: # type: ignore + # convert system to phase space representation + x_init = system_to_phase_space(system) + + # get initial guess from FlashMD + initial_guess = self.initial_guess.step(system) + x_prime_init = system_to_phase_space(initial_guess) + + # compute initial midpoint from starting point and initial guess + x_bar_init = 0.5 * (x_init + x_prime_init) + + # attach the system to the fixed-point function and call solver + f = partial(self._fixed_point_step, system, x_init) + x_bar_star = self.fixed_point_solver(f, x_bar_init) + + # compute final updated phase space point + x_star = 2 * x_bar_star - x_init + + # convert back to system representation + x_prime = phase_space_to_system(system, x_star) + + return x_prime From 5f29be45bf0e30f120f0fa5b83f3a7847122c59e Mon Sep 17 00:00:00 2001 From: Johannes Spies <13813209+johannes-spies@users.noreply.github.com> Date: Tue, 20 Jan 2026 16:04:31 +0000 Subject: [PATCH 07/10] Remove unnecessary squeeze --- src/flashmd/steppers/symplectic.py | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/flashmd/steppers/symplectic.py b/src/flashmd/steppers/symplectic.py index fdc4406..161b1ad 100644 --- a/src/flashmd/steppers/symplectic.py +++ b/src/flashmd/steppers/symplectic.py @@ -105,9 +105,6 @@ def _fixed_point_step( Returns: The updated midpoint in phase-space representation. """ - # flatten the batch dimension - x_bar = x_bar.squeeze(0) - # convert to system representation midpoint_system = phase_space_to_system(system, x_bar) @@ -117,9 +114,8 @@ def _fixed_point_step( ) # run the model to get the deltas - evaluation_options = self.evaluation_options outputs = self.midpoint_to_delta_model( - [midpoint_system], evaluation_options, check_consistency=False + [midpoint_system], self.evaluation_options, check_consistency=False ) # depending on the model, extract deltas From ce4326763368eb39ce6597ae3892dd41fc699153 Mon Sep 17 00:00:00 2001 From: Johannes Spies <13813209+johannes-spies@users.noreply.github.com> Date: Tue, 20 Jan 2026 16:14:26 +0000 Subject: [PATCH 08/10] Refactor FlashMD stepper --- examples/al/simulation-flashmd-omatpes/run.py | 2 +- .../al/simulation-flashmd-symplectic/run.py | 3 +- examples/al/simulation-flashmd/run.py | 2 +- src/flashmd/ase/velocity_verlet.py | 2 +- src/flashmd/ipi.py | 2 +- src/flashmd/steppers/__init__.py | 3 +- .../{stepper.py => steppers/flashmd.py} | 4 +-- src/flashmd/vv.py | 36 ++----------------- 8 files changed, 11 insertions(+), 43 deletions(-) rename src/flashmd/{stepper.py => steppers/flashmd.py} (97%) diff --git a/examples/al/simulation-flashmd-omatpes/run.py b/examples/al/simulation-flashmd-omatpes/run.py index a379d52..5fffc1d 100644 --- a/examples/al/simulation-flashmd-omatpes/run.py +++ b/examples/al/simulation-flashmd-omatpes/run.py @@ -1,7 +1,7 @@ import torch from ipi.utils.scripting import InteractiveSimulation from flashmd import get_pretrained -from flashmd.stepper import FlashMDStepper +from flashmd.steppers import FlashMDStepper from flashmd.wrappers import wrap_nvt from flashmd.vv import flashmd_vv diff --git a/examples/al/simulation-flashmd-symplectic/run.py b/examples/al/simulation-flashmd-symplectic/run.py index dc78aa5..a287c1f 100644 --- a/examples/al/simulation-flashmd-symplectic/run.py +++ b/examples/al/simulation-flashmd-symplectic/run.py @@ -2,8 +2,7 @@ import torch from metatomic.torch import load_atomistic_model from ipi.utils.scripting import InteractiveSimulation -from flashmd.steppers import SymplecticStepper -from flashmd.stepper import FlashMDStepper +from flashmd.steppers import SymplecticStepper, FlashMDStepper from flashmd.vv import flashmd_vv from flashmd.wrappers import wrap_nvt from flashmd.fpi import anderson_solver diff --git a/examples/al/simulation-flashmd/run.py b/examples/al/simulation-flashmd/run.py index 7195282..c839227 100644 --- a/examples/al/simulation-flashmd/run.py +++ b/examples/al/simulation-flashmd/run.py @@ -1,7 +1,7 @@ import torch from metatomic.torch import load_atomistic_model from ipi.utils.scripting import InteractiveSimulation -from flashmd.stepper import FlashMDStepper +from flashmd.steppers import FlashMDStepper from flashmd.vv import flashmd_vv from flashmd.wrappers.nvt import wrap_nvt diff --git a/src/flashmd/ase/velocity_verlet.py b/src/flashmd/ase/velocity_verlet.py index 087a382..60411d0 100644 --- a/src/flashmd/ase/velocity_verlet.py +++ b/src/flashmd/ase/velocity_verlet.py @@ -8,7 +8,7 @@ from metatomic.torch.ase_calculator import _ase_to_torch_data from scipy.spatial.transform import Rotation -from ..stepper import FlashMDStepper +from ..steppers.flashmd import FlashMDStepper class VelocityVerlet(MolecularDynamics): diff --git a/src/flashmd/ipi.py b/src/flashmd/ipi.py index 1ba00f6..51817f8 100644 --- a/src/flashmd/ipi.py +++ b/src/flashmd/ipi.py @@ -10,7 +10,7 @@ from metatensor.torch import Labels, TensorBlock, TensorMap from metatomic.torch import System -from flashmd.stepper import FlashMDStepper +from flashmd.steppers.flashmd import FlashMDStepper def get_standard_vv_step( diff --git a/src/flashmd/steppers/__init__.py b/src/flashmd/steppers/__init__.py index 1d7e326..ad1b573 100644 --- a/src/flashmd/steppers/__init__.py +++ b/src/flashmd/steppers/__init__.py @@ -1,5 +1,6 @@ from .core import AtomisticStepper from .symplectic import SymplecticStepper +from .flashmd import FlashMDStepper -__all__ = ["AtomisticStepper", "SymplecticStepper"] +__all__ = ["AtomisticStepper", "FlashMDStepper", "SymplecticStepper"] diff --git a/src/flashmd/stepper.py b/src/flashmd/steppers/flashmd.py similarity index 97% rename from src/flashmd/stepper.py rename to src/flashmd/steppers/flashmd.py index 3e9956d..45a08a6 100644 --- a/src/flashmd/stepper.py +++ b/src/flashmd/steppers/flashmd.py @@ -4,8 +4,8 @@ from metatomic.torch import AtomisticModel, ModelEvaluationOptions, ModelOutput, System from metatrain.utils.neighbor_lists import get_system_with_neighbor_lists -from .constraints import enforce_physical_constraints -from .steppers import AtomisticStepper +from ..constraints import enforce_physical_constraints +from . import AtomisticStepper class FlashMDStepper(AtomisticStepper): diff --git a/src/flashmd/vv.py b/src/flashmd/vv.py index fe47205..3368b6d 100644 --- a/src/flashmd/vv.py +++ b/src/flashmd/vv.py @@ -8,7 +8,7 @@ from metatensor.torch import Labels, TensorBlock, TensorMap from metatomic.torch import System -from .stepper import AtomisticStepper +from .steppers.flashmd import AtomisticStepper def standard_vv(sim, rescale_energy: bool = False): @@ -53,31 +53,9 @@ def flashmd_vv( stepper: AtomisticStepper, device: torch.device, dtype: torch.dtype, - # symplectic_model, - # model, - # device, rescale_energy=True, random_rotation=False, - # accuracy_threshold=1e-3, - # alpha=0.5, ): - # capabilities = model.capabilities() - - # if hasattr(model.module, "base_time_step"): - # base_timestep = float(model.module.base_time_step) * ase.units.fs - # n_time_steps = int( - # [k for k in capabilities.outputs.keys() if "mtt::delta_" in k][0].split( - # "_" - # )[1] - # ) - # timestep = base_timestep * n_time_steps - # elif hasattr(model.module, "timestep"): - # timestep = float(model.module.timestep) * ase.units.fs - # else: - # raise ValueError( - # "The model does not specify a base timestep (attribute 'base_time_step' or 'timestep')." - # ) - # compare the model's internal timestep with the i-PI one -- they need to match dt = sim.syslist[0].motion.dt * 2.4188843e-17 * ase.units.s timestep = stepper.get_timestep() @@ -85,17 +63,7 @@ def flashmd_vv( raise ValueError( f"Mismatch between timestep ({dt}) and model timestep ({timestep})." ) - - # device = torch.device(device) - # dtype = getattr(torch, capabilities.dtype) - # stepper = Stepper( - # symplectic_model, - # model, - # device, - # accuracy_threshold=accuracy_threshold, - # alpha=alpha, - # ) - + def flashmd_vv(motion): info("@flashmd: Starting VV", verbosity.debug) old_energy = None From 853c3404d8e4e02c7340a9f10627bc7d9b679626 Mon Sep 17 00:00:00 2001 From: Johannes Spies <13813209+johannes-spies@users.noreply.github.com> Date: Tue, 20 Jan 2026 16:16:16 +0000 Subject: [PATCH 09/10] Reformat --- src/flashmd/steppers/__init__.py | 2 +- src/flashmd/vv.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/flashmd/steppers/__init__.py b/src/flashmd/steppers/__init__.py index ad1b573..357c04a 100644 --- a/src/flashmd/steppers/__init__.py +++ b/src/flashmd/steppers/__init__.py @@ -1,6 +1,6 @@ from .core import AtomisticStepper -from .symplectic import SymplecticStepper from .flashmd import FlashMDStepper +from .symplectic import SymplecticStepper __all__ = ["AtomisticStepper", "FlashMDStepper", "SymplecticStepper"] diff --git a/src/flashmd/vv.py b/src/flashmd/vv.py index 3368b6d..e07545f 100644 --- a/src/flashmd/vv.py +++ b/src/flashmd/vv.py @@ -63,7 +63,7 @@ def flashmd_vv( raise ValueError( f"Mismatch between timestep ({dt}) and model timestep ({timestep})." ) - + def flashmd_vv(motion): info("@flashmd: Starting VV", verbosity.debug) old_energy = None From 21e086510c88adc3e346b6ed64eed9c405a1b43f Mon Sep 17 00:00:00 2001 From: Johannes Spies <13813209+johannes-spies@users.noreply.github.com> Date: Fri, 23 Jan 2026 15:19:29 +0000 Subject: [PATCH 10/10] Remove spurious print --- src/flashmd/vv.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/flashmd/vv.py b/src/flashmd/vv.py index e07545f..4310cf6 100644 --- a/src/flashmd/vv.py +++ b/src/flashmd/vv.py @@ -88,7 +88,6 @@ def flashmd_vv(motion): momenta = system.get_data("momenta").block(0).values.squeeze() momenta[:] = momenta @ R.T # does the change in place - print(system) new_system = stepper.step(system) if random_rotation: