pack-mm 0.0.15__tar.gz → 0.0.19__tar.gz

{pack_mm-0.0.15 → pack_mm-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pack-mm
-Version: 0.0.15
+Version: 0.0.19
 Summary: packing materials and molecules in boxes using for machine learnt interatomic potentials
 Author: Alin M. Elena
 Classifier: Programming Language :: Python

{pack_mm-0.0.15 → pack_mm-0.0.19}/pack_mm/cli/packmm.py

@@ -52,30 +52,28 @@ def packmm(
     ),
     centre: str | None = typer.Option(
         None,
-        help="""Centre of the insertion zone in fractional coordinates,
-        e.g., '0.12,0.4,0.5'.""",
+        help="""Centre of the insertion zone, coordinates in Å,
+        e.g., '5.0, 5.0, 5.0'.""",
     ),
     radius: float | None = typer.Option(
         None,
         help="""Radius of the sphere or cylinder in Å,
         depending on the insertion volume.""",
     ),
-    height: float | None = typer.Option(
-        None, help="Height of the cylinder in fractional coordinates."
-    ),
+    height: float | None = typer.Option(None, help="Height of the cylinder in Å."),
     a: float | None = typer.Option(
         None,
-        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        help="""Side of the box or semi-axis of the ellipsoid, in Å,
         depends on the insertion method.""",
     ),
     b: float | None = typer.Option(
         None,
-        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        help="""Side of the box or semi-axis of the ellipsoid, in Å,
         depends on the insertion method.""",
     ),
     c: float | None = typer.Option(
         None,
-        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        help="""Side of the box or semi-axis of the ellipsoid, in Å,
         depends on the insertion method.""",
     ),
     device: str = typer.Option(
@@ -86,15 +84,22 @@ def packmm(
     temperature: float = typer.Option(
         300.0, help="Temperature for the Monte Carlo acceptance rule."
     ),
-    cell_a: float = typer.Option(20.0, help="Side of the empty box along the x-axis."),
-    cell_b: float = typer.Option(20.0, help="Side of the empty box along the y-axis."),
-    cell_c: float = typer.Option(20.0, help="Side of the empty box along the z-axis."),
+    cell_a: float = typer.Option(
+        20.0, help="Side of the empty box along the x-axis in Å."
+    ),
+    cell_b: float = typer.Option(
+        20.0, help="Side of the empty box along the y-axis in Å."
+    ),
+    cell_c: float = typer.Option(
+        20.0, help="Side of the empty box along the z-axis in Å."
+    ),
     fmax: float = typer.Option(
         0.1, help="force tollerance for optimisation if needed."
     ),
     geometry: bool = typer.Option(
         True, help="Perform geometry optimization at the end."
     ),
+    out_path: str = typer.Option(".", help="path to save various outputs."),
 ):
     """Pack molecules into a system based on the specified parameters."""
     print("Script called with following input")
@@ -119,6 +124,7 @@ def packmm(
     print(f"{temperature=}")
     print(f"{fmax=}")
     print(f"{geometry=}")
+    print(f"{out_path=}")
     if nmols == -1:
         print("nothing to do, no molecule to insert")
         raise typer.Exit(0)
@@ -151,9 +157,10 @@ def packmm(
         ntries=ntries,
         fmax=fmax,
         geometry=geometry,
-        ca=cell_a,
-        cb=cell_b,
-        cc=cell_c,
+        cell_a=cell_a,
+        cell_b=cell_b,
+        cell_c=cell_c,
+        out_path=out_path,
     )
 
 

{pack_mm-0.0.15 → pack_mm-0.0.19}/pack_mm/core/core.py

@@ -138,28 +138,29 @@ def validate_value(label, x):
 
 
 def pack_molecules(
-    system: str | None,
-    molecule: str,
-    nmols: int,
-    arch: str,
-    model: str,
-    device: str,
-    where: str,
-    center: tuple[float, float, float] | None,
-    radius: float | None,
-    height: float | None,
-    a: float | None,
-    b: float | None,
-    c: float | None,
-    seed: int,
-    temperature: float,
-    ntries: int,
-    geometry: bool,
-    fmax: float,
-    ca: float,
-    cb: float,
-    cc: float,
-) -> None:
+    system: str = None,
+    molecule: str = "H2O",
+    nmols: int = -1,
+    arch: str = "cpu",
+    model: str = "mace_mp",
+    device: str = "medium-omat-0",
+    where: str = "anywhere",
+    center: tuple[float, float, float] = None,
+    radius: float = None,
+    height: float = None,
+    a: float = None,
+    b: float = None,
+    c: float = None,
+    seed: int = 2025,
+    temperature: float = 300.0,
+    ntries: int = 50,
+    geometry: bool = False,
+    fmax: float = 0.1,
+    cell_a: float = None,
+    cell_b: float = None,
+    cell_c: float = None,
+    out_path: str = ".",
+) -> float:
     """
     Pack molecules into a system based on the specified parameters.
 
@@ -181,7 +182,8 @@ def pack_molecules(
         temperature (float): Temperature in Kelvin for acceptance probability.
         ntries (int): Maximum number of attempts to insert each molecule.
         geometry (bool): Whether to perform geometry optimization after insertion.
-        ca, cb, cc (float): Cell dimensions if system is empty.
+        cell_a, cell_b, cell_c (float): Cell dimensions if system is empty.
+        out_path (str): path to save various outputs
     """
     kbt = temperature * 8.6173303e-5  # Boltzmann constant in eV/K
     validate_value("temperature", temperature)
@@ -193,10 +195,10 @@ def pack_molecules(
     validate_value("box b", b)
     validate_value("box c", c)
     validate_value("ntries", ntries)
-    validate_value("cell box a", ca)
-    validate_value("cell box b", cb)
+    validate_value("cell box cell a", cell_a)
+    validate_value("cell box cell b", cell_b)
     validate_value("nmols", nmols)
-    validate_value("cell box c", cc)
+    validate_value("cell box cell c", cell_c)
 
     random.seed(seed)
 
@@ -204,25 +206,21 @@ def pack_molecules(
         sys = read(system)
         sysname = Path(system).stem
     except Exception:
-        sys = Atoms(cell=[ca, cb, cc], pbc=[True, True, True])
+        sys = Atoms(cell=[cell_a, cell_b, cell_c], pbc=[True, True, True])
         sysname = "empty"
 
     cell = sys.cell.lengths()
 
-    # Print initial information
+    # Print summary
     print(f"Inserting {nmols} {molecule} molecules in {sysname}.")
     print(f"Using {arch} model {model} on {device}.")
     print(f"Insert in {where}.")
 
-    # Set center of insertion region
     if center is None:
         center = (cell[0] * 0.5, cell[1] * 0.5, cell[2] * 0.5)
-    else:
-        center = tuple(ci * cell[i] for i, ci in enumerate(center))
 
-    # Set parameters based on insertion region
     if where == "anywhere":
-        a, b, c = 1, 1, 1
+        a, b, c = cell[0], cell[1], cell[2]
     elif where == "sphere":
         if radius is None:
             radius = min(cell) * 0.5
@@ -230,20 +228,22 @@ def pack_molecules(
         if radius is None:
             if where == "cylinderZ":
                 radius = min(cell[0], cell[1]) * 0.5
+                if height is None:
+                    height = 0.5 * cell[2]
             elif where == "cylinderY":
                 radius = min(cell[0], cell[2]) * 0.5
+                if height is None:
+                    height = 0.5 * cell[1]
             elif where == "cylinderX":
                 radius = min(cell[2], cell[1]) * 0.5
-        if height is None:
-            height = 0.5
+                if height is None:
+                    height = 0.5 * cell[0]
     elif where == "box":
-        a, b, c = a or 1, b or 1, c or 1
+        a, b, c = a or cell[0], b or cell[1], c or cell[2]
     elif where == "ellipsoid":
-        a, b, c = a or 0.5, b or 0.5, c or 0.5
+        a, b, c = a or cell[0], b or cell[1], c or cell[2]
 
-    calc = choose_calculator(
-        arch=arch, model_path=model, device=device, default_dtype="float64"
-    )
+    calc = choose_calculator(arch=arch, model_path=model, device=device)
     sys.calc = calc
 
     e = sys.get_potential_energy() if len(sys) > 0 else 0.0
@@ -253,7 +253,7 @@ def pack_molecules(
         accept = False
         for _itry in range(ntries):
             mol = load_molecule(molecule)
-            tv = get_insertion_position(where, center, cell, a, b, c, radius, height)
+            tv = get_insertion_position(where, center, a, b, c, radius, height)
             mol = rotate_molecule(mol)
             mol.translate(tv)
 
@@ -274,18 +274,31 @@ def pack_molecules(
             csys = tsys.copy()
             e = en
             print(f"Inserted particle {i + 1}")
-            write(f"{sysname}+{i + 1}{Path(molecule).stem}.cif", csys)
+            write(Path(out_path) / f"{sysname}+{i + 1}{Path(molecule).stem}.cif", csys)
         else:
+            # Things are bad, maybe geomatry optimisation saves us
             print(f"Failed to insert particle {i + 1} after {ntries} tries")
-            optimize_geometry(
-                f"{sysname}+{i + 1}{Path(molecule).stem}.cif", device, arch, model, fmax
+            _ = optimize_geometry(
+                f"{sysname}+{i + 1}{Path(molecule).stem}.cif",
+                device,
+                arch,
+                model,
+                fmax,
+                out_path,
             )
+    energy_final = e
 
     # Perform final geometry optimization if requested
     if geometry:
-        optimize_geometry(
-            f"{sysname}+{nmols}{Path(molecule).stem}.cif", device, arch, model, fmax
+        energy_final = optimize_geometry(
+            f"{sysname}+{nmols}{Path(molecule).stem}.cif",
+            device,
+            arch,
+            model,
+            fmax,
+            out_path,
         )
+    return energy_final
 
 
 def load_molecule(molecule: str):
@@ -299,25 +312,24 @@ def load_molecule(molecule: str):
 def get_insertion_position(
     where: str,
     center: tuple[float, float, float],
-    cell: list[float],
-    a: float,
-    b: float,
-    c: float,
-    radius: float | None,
-    height: float | None,
+    a: float = None,
+    b: float = None,
+    c: float = None,
+    radius: float = None,
+    height: float = None,
 ) -> tuple[float, float, float]:
     """Get a random insertion position based on the region."""
     if where == "sphere":
         return random_point_in_sphere(center, radius)
     if where == "box":
-        return random_point_in_box(center, cell[0] * a, cell[1] * b, cell[2] * c)
+        return random_point_in_box(center, a, b, c)
     if where == "ellipsoid":
-        return random_point_in_ellipsoid(center, cell[0] * a, cell[1] * b, cell[2] * c)
+        return random_point_in_ellipsoid(center, a, b, c)
     if where in ["cylinderZ", "cylinderY", "cylinderX"]:
         axis = where[-1].lower()
-        return random_point_in_cylinder(center, radius, cell[2] * height, axis)
+        return random_point_in_cylinder(center, radius, height, axis)
     # now is anywhere
-    return random.random(3) * [a, b, c] * cell
+    return random.random(3) * [a, b, c]
 
 
 def rotate_molecule(mol):
@@ -330,16 +342,21 @@ def rotate_molecule(mol):
 
 
 def optimize_geometry(
-    struct_path: str, device: str, arch: str, model: str, fmax: float
+    struct_path: str,
+    device: str,
+    arch: str,
+    model: str,
+    fmax: float,
+    out_path: str = ".",
 ) -> float:
     """Optimize the geometry of a structure."""
     geo = GeomOpt(
         struct_path=struct_path,
         device=device,
         fmax=fmax,
-        calc_kwargs={"model_paths": model, "default_dtype": "float64"},
+        calc_kwargs={"model_paths": model},
         filter_kwargs={"hydrostatic_strain": True},
     )
     geo.run()
-    write(f"{struct_path}-opt.cif", geo.struct)
+    write(Path(out_path) / f"{struct_path}-opt.cif", geo.struct)
     return geo.struct.get_potential_energy()

{pack_mm-0.0.15 → pack_mm-0.0.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pack-mm"
-version = "0.0.15"
+version = "0.0.19"
 description = "packing materials and molecules in boxes using for machine learnt interatomic potentials"
 authors = [
     { name = "Alin M. Elena" },
@@ -44,6 +44,7 @@ docs = [
     "furo<2025.0.0,>=2024.1.29",
     "jupyter>=1.1.1",
     "markupsafe<2.1",
+    "sphinx-immaterial",
     "nbsphinx>=0.9.6",
     "numpydoc<2.0.0,>=1.6.0",
     "sphinx<9.0.0,>=8.0.2",
@@ -136,3 +137,7 @@ default-groups = [
     "docs",
     "pre-commit",
 ]
+
+[tool.uv.sources.sphinx-immaterial]
+git = "https://github.com/jbms/sphinx-immaterial.git"
+rev = "main"

pack_mm-0.0.19/tests/test_core.py

@@ -0,0 +1,178 @@
+"""Test cli for core."""
+
+# -*- coding: utf-8 -*-
+# Author; alin m elena, alin@elena.re
+# Contribs;
+# Date: 22-02-2025
+# ©alin m elena,
+from __future__ import annotations
+
+from ase import Atoms
+from ase.build import molecule as build_molecule
+from ase.io import write
+import numpy as np
+from numpy import random
+import pytest
+
+from pack_mm.core.core import (
+    get_insertion_position,
+    load_molecule,
+    optimize_geometry,
+    pack_molecules,
+    random_point_in_box,
+    random_point_in_cylinder,
+    random_point_in_ellipsoid,
+    random_point_in_sphere,
+    rotate_molecule,
+    validate_value,
+)
+
+
+# Set a fixed seed for reproducibility in tests
+@pytest.fixture(autouse=True)
+def set_random_seed():
+    """Set random seed."""
+    random.seed(2042)
+
+
+def test_random_point_in_sphere():
+    """Test point in sphere."""
+    center = (0, 0, 0)
+    radius = 10.0
+    point = random_point_in_sphere(center, radius)
+    assert len(point) == 3
+    distance = np.linalg.norm(np.array(point) - np.array(center))
+    assert distance <= radius
+
+
+def test_random_point_in_ellipsoid():
+    """Test point in ellipsoid."""
+    center = (0, 0, 0)
+    a, b, c = 1.0, 2.0, 3.0
+    point = random_point_in_ellipsoid(center, a, b, c)
+    assert len(point) == 3
+    x, y, z = point
+    assert (x**2 / a**2) + (y**2 / b**2) + (z**2 / c**2) <= 1.0
+
+
+def test_random_point_in_box():
+    """Test point in box."""
+    center = (0, 0, 0)
+    a, b, c = 1.0, 2.0, 3.0
+    point = random_point_in_box(center, a, b, c)
+    assert len(point) == 3
+    x, y, z = point
+    assert center[0] - a * 0.5 <= x <= center[0] + a * 0.5
+    assert center[1] - b * 0.5 <= y <= center[1] + b * 0.5
+    assert center[2] - c * 0.5 <= z <= center[2] + c * 0.5
+
+
+def test_random_point_in_cylinder():
+    """Test point in cylinder."""
+    center = (0, 0, 0)
+    radius = 1.0
+    height = 2.0
+    direction = "z"
+    point = random_point_in_cylinder(center, radius, height, direction)
+    assert len(point) == 3
+    x, y, z = point
+    assert x**2 + y**2 <= radius**2
+    assert center[2] - height * 0.5 <= z <= center[2] + height * 0.5
+
+
+def test_validate_value_positive():
+    """Test point in test value."""
+    validate_value("test_value", 1.0)  # Should not raise an exception
+
+
+def test_validate_value_negative():
+    """Test point in test value."""
+    with pytest.raises(Exception, match="Invalid test_value, needs to be positive"):
+        validate_value("test_value", -1.0)
+
+
+def test_load_molecule_from_file(tmp_path):
+    """Test point in load molecule."""
+    molecule = build_molecule("H2O")
+    molecule_file = tmp_path / "water.xyz"
+    molecule.write(molecule_file)
+    loaded_molecule = load_molecule(str(molecule_file))
+    assert isinstance(loaded_molecule, Atoms)
+    assert len(loaded_molecule) == 3  # H2O has 3 atoms
+
+
+def test_load_molecule_from_name():
+    """Test point in load molecule."""
+    molecule = load_molecule("H2O")
+    assert isinstance(molecule, Atoms)
+    assert len(molecule) == 3  # H2O has 3 atoms
+
+
+def test_get_insertion_position_sphere():
+    """Test point in sphere."""
+    center = (0, 0, 0)
+    radius = 10.0
+    point = get_insertion_position("sphere", center, radius=radius)
+    assert len(point) == 3
+    distance = np.linalg.norm(np.array(point) - np.array(center))
+    assert distance <= radius
+
+
+def test_rotate_molecule():
+    """Test rotate molecule."""
+    molecule = build_molecule("H2O")
+    rotated_molecule = rotate_molecule(molecule)
+    assert isinstance(rotated_molecule, Atoms)
+    assert len(rotated_molecule) == 3  # H2O has 3 atoms
+
+
+def test_optimize_geometry(tmp_path):
+    """Test go."""
+    # Create a temporary structure file
+    molecule = build_molecule("H2O")
+    molecule.set_cell([10, 10, 10])
+    molecule.set_pbc([True, True, True])
+    structure_file = tmp_path / "water.cif"
+    write(structure_file, molecule)
+    optimized_energy = optimize_geometry(
+        str(structure_file),
+        device="cpu",
+        arch="mace_mp",
+        model="medium-omat-0",
+        fmax=0.01,
+    )
+    assert optimized_energy == pytest.approx(-13.759273983276572, abs=1.0e-8)
+
+
+# Test pack_molecules with a simple case
+def test_pack_molecules(tmp_path):
+    """Test pack molecule."""
+    # Create a temporary system file
+    system = Atoms(
+        "Ca", positions=[(5.0, 5.0, 5.0)], cell=[10, 10, 10], pbc=[True, True, True]
+    )
+    system_file = tmp_path / "system.cif"
+    write(system_file, system)
+
+    # Test packing molecules
+    e = pack_molecules(
+        system=str(system_file),
+        molecule="H2O",
+        nmols=2,
+        arch="mace_mp",
+        model="medium-omat-0",
+        device="cpu",
+        where="sphere",
+        center=(5.0, 5.0, 5.0),
+        radius=5.0,
+        seed=2042,
+        temperature=300,
+        ntries=10,
+        geometry=False,
+        fmax=0.1,
+        out_path=tmp_path,
+    )
+
+    assert (tmp_path / "system+1H2O.cif").exists()
+    assert (tmp_path / "system+2H2O.cif").exists()
+    assert e == pytest.approx(-28.251229837533085, abs=1.0e-6)

{pack_mm-0.0.15 → pack_mm-0.0.19}/tests/test_packmm.py

@@ -3,7 +3,7 @@
 # Author; alin m elena, alin@elena.re
 # Contribs;
 # Date: 22-02-2025
-# ©alin m elena, GPL v3 https://www.gnu.org/licenses/gpl-3.0.en.html
+# ©alin m elena,
 from __future__ import annotations
 
 from typer.testing import CliRunner
@@ -88,6 +88,13 @@ def test_packmm_mlip():
     assert "device='cuda'" in strip_ansi_codes(result.output)
 
 
+def test_packmm_out_path():
+    """Check out_path."""
+    result = runner.invoke(app, ["--out-path", "out"])
+    assert result.exit_code == 0
+    assert "out_path='out'" in strip_ansi_codes(result.output)
+
+
 def test_packmm_custom_box_dimensions():
     """Check box."""
     result = runner.invoke(app, ["--a", "30.0", "--b", "30.0", "--c", "30.0"])