pack-mm 0.0.14__py3-none-any.whl

pack_mm/__init__.py

@@ -0,0 +1,7 @@
+"""Pack molecules in various shapes."""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+__version__ = version("pack-mm")

pack_mm/cli/packmm.py

@@ -0,0 +1,161 @@
+"""Command line for packmm."""
+
+# Author; alin m elena, alin@elena.re
+# Contribs;
+# Date: 22-02-2025
+# ©alin m elena,
+from __future__ import annotations
+
+from enum import Enum
+
+import typer
+
+from pack_mm.core.core import pack_molecules
+
+
+class InsertionMethod(str, Enum):
+    """Insertion options."""
+
+    ANYWHERE = "anywhere"
+    SPHERE = "sphere"
+    BOX = "box"
+    CYLINDER_Z = "cylinderZ"
+    CYLINDER_Y = "cylinderY"
+    CYLINDER_X = "cylinderX"
+    ELLIPSOID = "ellipsoid"
+
+
+app = typer.Typer(no_args_is_help=True)
+
+
+@app.command()
+def packmm(
+    system: str | None = typer.Option(
+        None,
+        help="""The original box in which you want to add particles.
+        If not provided, an empty box will be created.""",
+    ),
+    molecule: str = typer.Option(
+        "H2O",
+        help="""Name of the molecule to be processed, ASE-recognizable or
+        ASE-readable file.""",
+    ),
+    nmols: int = typer.Option(-1, help="Target number of molecules to insert."),
+    ntries: int = typer.Option(
+        50, help="Maximum number of attempts to insert each molecule."
+    ),
+    seed: int = typer.Option(2025, help="Random seed for reproducibility."),
+    where: InsertionMethod = typer.Option(
+        InsertionMethod.ANYWHERE,
+        help="""Where to insert the molecule. Choices: 'anywhere', 'sphere',
+        'box', 'cylinderZ', 'cylinderY', 'cylinderX', 'ellipsoid'.""",
+    ),
+    centre: str | None = typer.Option(
+        None,
+        help="""Centre of the insertion zone in fractional coordinates,
+        e.g., '0.12,0.4,0.5'.""",
+    ),
+    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."
+    ),
+    a: float | None = typer.Option(
+        None,
+        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        depends on the insertion method.""",
+    ),
+    b: float | None = typer.Option(
+        None,
+        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        depends on the insertion method.""",
+    ),
+    c: float | None = typer.Option(
+        None,
+        help="""Side of the box or semi-axis of the ellipsoid, fractional,
+        depends on the insertion method.""",
+    ),
+    device: str = typer.Option(
+        "cpu", help="Device to run calculations on (e.g., 'cpu' or 'cuda')."
+    ),
+    model: str = typer.Option("medium-omat-0", help="ML model to use."),
+    arch: str = typer.Option("mace_mp", help="MLIP architecture to use."),
+    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."),
+    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."
+    ),
+):
+    """Pack molecules into a system based on the specified parameters."""
+    print("Script called with following input")
+    print(f"{system=}")
+    print(f"{nmols=}")
+    print(f"{molecule=}")
+    print(f"{ntries=}")
+    print(f"{seed=}")
+    print(f"where={where.value}")
+    print(f"{centre=}")
+    print(f"{radius=}")
+    print(f"{height=}")
+    print(f"{a=}")
+    print(f"{b=}")
+    print(f"{c=}")
+    print(f"{cell_a=}")
+    print(f"{cell_b=}")
+    print(f"{cell_c=}")
+    print(f"{arch=}")
+    print(f"{model=}")
+    print(f"{device=}")
+    print(f"{temperature=}")
+    print(f"{fmax=}")
+    print(f"{geometry=}")
+    if nmols == -1:
+        print("nothing to do, no molecule to insert")
+        raise typer.Exit(0)
+
+    center = centre
+    if centre:
+        center = tuple(map(float, centre.split(",")))
+        lc = [x < 0.0 for x in center]
+        if len(center) != 3 or any(lc):
+            err = "Invalid centre 3 coordinates expected!"
+            print(f"{err}")
+            raise Exception("Invalid centre 3 coordinates expected!")
+
+    pack_molecules(
+        system=system,
+        molecule=molecule,
+        nmols=nmols,
+        arch=arch,
+        model=model,
+        device=device,
+        where=where,
+        center=center,
+        radius=radius,
+        height=height,
+        a=a,
+        b=b,
+        c=c,
+        seed=seed,
+        temperature=temperature,
+        ntries=ntries,
+        fmax=fmax,
+        geometry=geometry,
+        ca=cell_a,
+        cb=cell_b,
+        cc=cell_c,
+    )
+
+
+if __name__ == "__main__":
+    app()

pack_mm/core/core.py

@@ -0,0 +1,345 @@
+# Author; alin m elena, alin@elena.re
+# Contribs;
+# Date: 16-11-2024
+# ©alin m elena,
+"""pack molecules inside various shapes."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ase import Atoms
+from ase.build import molecule as build_molecule
+from ase.io import read, write
+from janus_core.calculations.geom_opt import GeomOpt
+from janus_core.helpers.mlip_calculators import choose_calculator
+from numpy import cos, exp, pi, random, sin, sqrt
+
+
+def random_point_in_sphere(c: (float, float, float), r: float) -> (float, float, float):
+    """
+    Generate a random point inside a sphere of radius r, centered at c.
+
+    Parameters
+    ----------
+        c (tuple): The center of the sphere as (x, y, z).
+        r (float): The radius of the sphere.
+
+    Returns
+    -------
+        tuple: A point (x, y, z) inside the sphere.
+    """
+    rad = r * random.rand() ** (1 / 3)
+
+    theta = random.uniform(0, 2 * pi)
+    phi = random.uniform(0, pi)
+
+    x = c[0] + rad * sin(phi) * cos(theta)
+    y = c[1] + rad * sin(phi) * sin(theta)
+    z = c[2] + rad * cos(phi)
+
+    return (x, y, z)
+
+
+def random_point_in_ellipsoid(
+    d: (float, float, float), a: float, b: float, c: float
+) -> (float, float, float):
+    """
+    Generate a random point inside an ellipsoid with axes a, b, c, centered at d.
+
+    Parameters
+    ----------
+        d (tuple): The center of the ellipsoid as (x, y, z).
+        a (float): The semi-axis length of the ellipsoid along the x-axis.
+        b (float): The semi-axis length of the ellipsoid along the y-axis.
+        c (float): The semi-axis length of the ellipsoid along the z-axis.
+
+    Returns
+    -------
+        tuple: A point (x, y, z) inside the ellipsoid.
+    """
+    theta = random.uniform(0, 2 * pi)
+    phi = random.uniform(0, pi)
+    rad = random.rand() ** (1 / 3)
+
+    x = d[0] + a * rad * sin(phi) * cos(theta)
+    y = d[1] + b * rad * sin(phi) * sin(theta)
+    z = d[2] + c * rad * cos(phi)
+
+    return (x, y, z)
+
+
+def random_point_in_box(
+    d: (float, float, float), a: float, b: float, c: float
+) -> (float, float, float):
+    """
+    Generate a random point inside a box with sides a, b, c, centered at d.
+
+    Parameters
+    ----------
+        d (tuple): The center of the box as (x, y, z).
+        a (float): The length of the box along the x-axis.
+        b (float): The length of the box along the y-axis.
+        c (float): The length of the box along the z-axis.
+
+    Returns
+    -------
+        tuple: A point (x, y, z) inside the box.
+    """
+    x = d[0] + random.uniform(-a * 0.5, a * 0.5)
+    y = d[1] + random.uniform(-b * 0.5, b * 0.5)
+    z = d[2] + random.uniform(-c * 0.5, c * 0.5)
+
+    return (x, y, z)
+
+
+def random_point_in_cylinder(
+    c: (float, float, float), r: float, h: float, d: str
+) -> (float, float, float):
+    """
+    Generate a random point inside a cylinder with radius r and height h, centered at c.
+
+    Parameters
+    ----------
+        c (tuple): The center of the cylinder as (x, y, z).
+        r (float): The radius of the cylinder's base.
+        h (float): The height of the cylinder.
+        direction (str): direction along which cylinger is oriented
+
+    Returns
+    -------
+        tuple: A point (x, y, z) inside the cylinder.
+    """
+    theta = random.uniform(0, 2 * pi)
+    rad = r * sqrt(random.rand())
+
+    if d == "z":
+        z = c[2] + random.uniform(-h * 0.5, h * 0.5)
+        x = c[0] + rad * cos(theta)
+        y = c[1] + rad * sin(theta)
+    elif d == "y":
+        y = c[1] + random.uniform(-h * 0.5, h * 0.5)
+        x = c[0] + rad * cos(theta)
+        z = c[2] + rad * sin(theta)
+    elif d == "x":
+        x = c[0] + random.uniform(-h * 0.5, h * 0.5)
+        y = c[1] + rad * sin(theta)
+        z = c[2] + rad * cos(theta)
+
+    return (x, y, z)
+
+
+def validate_value(label, x):
+    """Validate input value, and raise an exception."""
+    if x is not None and x < 0.0:
+        err = f"Invalid {label}, needs to be positive"
+        print(err)
+        raise Exception(err)
+
+
+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:
+    """
+    Pack molecules into a system based on the specified parameters.
+
+    Parameters
+    ----------
+        system (str): Path to the system file or name of the system.
+        molecule (str): Path to the molecule file or name of the molecule.
+        nmols (int): Number of molecules to insert.
+        arch (str): Architecture for the calculator.
+        model (str): Path to the model file.
+        device (str): Device to run calculations on (e.g., "cpu" or "cuda").
+        where (str): Region to insert molecules ("anywhere",
+                     "sphere", "cylinderZ", etc.).
+        center (Optional[Tuple[float, float, float]]): Center of the insertion region.
+        radius (Optional[float]): Radius for spherical or cylindrical insertion.
+        height (Optional[float]): Height for cylindrical insertion.
+        a, b, c (Optional[float]): Parameters for box or ellipsoid insertion.
+        seed (int): Random seed for reproducibility.
+        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.
+    """
+    kbt = temperature * 8.6173303e-5  # Boltzmann constant in eV/K
+    validate_value("temperature", temperature)
+    validate_value("radius", radius)
+    validate_value("height", height)
+    validate_value("fmax", fmax)
+    validate_value("seed", seed)
+    validate_value("box a", a)
+    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("nmols", nmols)
+    validate_value("cell box c", cc)
+
+    random.seed(seed)
+
+    try:
+        sys = read(system)
+        sysname = Path(system).stem
+    except Exception:
+        sys = Atoms(cell=[ca, cb, cc], pbc=[True, True, True])
+        sysname = "empty"
+
+    cell = sys.cell.lengths()
+
+    # Print initial information
+    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
+    elif where == "sphere":
+        if radius is None:
+            radius = min(cell) * 0.5
+    elif where in ["cylinderZ", "cylinderY", "cylinderX"]:
+        if radius is None:
+            if where == "cylinderZ":
+                radius = min(cell[0], cell[1]) * 0.5
+            elif where == "cylinderY":
+                radius = min(cell[0], cell[2]) * 0.5
+            elif where == "cylinderX":
+                radius = min(cell[2], cell[1]) * 0.5
+        if height is None:
+            height = 0.5
+    elif where == "box":
+        a, b, c = a or 1, b or 1, c or 1
+    elif where == "ellipsoid":
+        a, b, c = a or 0.5, b or 0.5, c or 0.5
+
+    calc = choose_calculator(
+        arch=arch, model_path=model, device=device, default_dtype="float64"
+    )
+    sys.calc = calc
+
+    e = sys.get_potential_energy() if len(sys) > 0 else 0.0
+
+    csys = sys.copy()
+    for i in range(nmols):
+        accept = False
+        for _itry in range(ntries):
+            mol = load_molecule(molecule)
+            tv = get_insertion_position(where, center, cell, a, b, c, radius, height)
+            mol = rotate_molecule(mol)
+            mol.translate(tv)
+
+            tsys = csys.copy() + mol.copy()
+            tsys.calc = calc
+            en = tsys.get_potential_energy()
+            de = en - e
+
+            acc = exp(-de / kbt)
+            u = random.random()
+            print(f"Old energy={e}, new energy={en}, {de=}, {acc=}, random={u}")
+
+            if u <= acc:
+                accept = True
+                break
+
+        if accept:
+            csys = tsys.copy()
+            e = en
+            print(f"Inserted particle {i + 1}")
+            write(f"{sysname}+{i + 1}{Path(molecule).stem}.cif", csys)
+        else:
+            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
+            )
+
+    # Perform final geometry optimization if requested
+    if geometry:
+        optimize_geometry(
+            f"{sysname}+{nmols}{Path(molecule).stem}.cif", device, arch, model, fmax
+        )
+
+
+def load_molecule(molecule: str):
+    """Load a molecule from a file or build it."""
+    try:
+        return build_molecule(molecule)
+    except KeyError:
+        return read(molecule)
+
+
+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,
+) -> 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)
+    if where == "ellipsoid":
+        return random_point_in_ellipsoid(center, cell[0] * a, cell[1] * b, cell[2] * c)
+    if where in ["cylinderZ", "cylinderY", "cylinderX"]:
+        axis = where[-1].lower()
+        return random_point_in_cylinder(center, radius, cell[2] * height, axis)
+    # now is anywhere
+    return random.random(3) * [a, b, c] * cell
+
+
+def rotate_molecule(mol):
+    """Rotate a molecule randomly."""
+    ang = random.random(3)
+    mol.euler_rotate(
+        phi=ang[0] * 360, theta=ang[1] * 180, psi=ang[2] * 360, center=(0.0, 0.0, 0.0)
+    )
+    return mol
+
+
+def optimize_geometry(
+    struct_path: str, device: str, arch: str, model: str, fmax: float
+) -> 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"},
+        filter_kwargs={"hydrostatic_strain": True},
+    )
+    geo.run()
+    write(f"{struct_path}-opt.cif", geo.struct)
+    return geo.struct.get_potential_energy()

pack_mm-0.0.14.dist-info/METADATA

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: pack-mm
+Version: 0.0.14
+Summary: packing materials and molecules in boxes using for machine learnt interatomic potentials
+Author: Alin M. Elena
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Development Status :: 3 - Alpha
+Project-URL: Repository, https://github.com/ddmms/pack-mm/
+Project-URL: Documentation, https://ddmms.github.io/pack-mm/
+Requires-Python: >=3.10
+Requires-Dist: janus-core>=0.7.2
+Requires-Dist: typer<1.0.0,>=0.12.5
+Requires-Dist: typer-config<2.0.0,>=1.4.2
+Description-Content-Type: text/markdown
+
+# pack materials and molecules
+
+[![Python versions][python-badge]][python-link]
+[![Build Status][ci-badge]][ci-link]
+[![Coverage Status][cov-badge]][cov-link]
+[![License][license-badge]][license-link]
+
+[python-badge]: https://img.shields.io/pypi/pyversions/pack-mm.svg
+[python-link]: https://pypi.org/project/pack-mm/
+[ci-badge]: https://github.com/ddmms/pack-mm/actions/workflows/build.yml/badge.svg?branch=main
+[ci-link]: https://github.com/ddmms/pack-mm/actions
+[cov-badge]: https://coveralls.io/repos/github/ddmms/pack-mm/badge.svg?branch=main
+[cov-link]: https://coveralls.io/github/ddmms/pack-mm?branch=main
+[license-badge]: https://img.shields.io/badge/License-MIT-yellow.svg
+[license-link]: https://opensource.org/license/MIT

pack_mm-0.0.14.dist-info/RECORD

@@ -0,0 +1,8 @@
+pack_mm-0.0.14.dist-info/METADATA,sha256=KOiX1eZqUv1OmoKdtpFyUC_ueiJ3BYGBhZjv6D8ZPMg,1583
+pack_mm-0.0.14.dist-info/WHEEL,sha256=thaaA2w1JzcGC48WYufAs8nrYZjJm8LqNfnXFOFyCC4,90
+pack_mm-0.0.14.dist-info/entry_points.txt,sha256=ajKA2oehIa_LCVCP2XTRxV0VNgjGl9c2wYkwk0BasrQ,66
+pack_mm-0.0.14.dist-info/licenses/LICENSE,sha256=ZOYkPdn_vQ8wYJqZnjesow79F_grMbVlHcJ9V91G1pE,1100
+pack_mm/__init__.py,sha256=ct7qfCmTDwhLYip6JKYWRLasmmaGYt0ColbK0CpvYZk,150
+pack_mm/cli/packmm.py,sha256=FWiBUQBG6Z5Vi5A1VH9DYUn8iBwIs4NbFR5a8mPtEpM,4797
+pack_mm/core/core.py,sha256=gP8j1NJg3_8dj4it3V2Z80dbAKhy0emwUjd_-wuKvws,10839
+pack_mm-0.0.14.dist-info/RECORD,,

pack_mm-0.0.14.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.3)
+Root-Is-Purelib: true
+Tag: py3-none-any

pack_mm-0.0.14.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+packmm = pack_mm.cli.packmm:app
+
+[gui_scripts]
+

pack_mm-0.0.14.dist-info/licenses/LICENSE

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