nmag-python-3 0.0.3__tar.gz → 0.0.4__tar.gz

{nmag_python_3-0.0.3/src/nmag_python_3.egg-info → nmag_python_3-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nmag-python-3
-Version: 0.0.3
+Version: 0.0.4
 Summary: Standalone Python 3 implementation of the Nmag micromagnetic simulation interface
 Author-email: TriMagnetix <info@trimagnetix.com>
 Classifier: Programming Language :: Python :: 3

{nmag_python_3-0.0.3 → nmag_python_3-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nmag-python-3"
-version = "0.0.3"
+version = "0.0.4"
 authors = [{ name = "TriMagnetix", email = "info@trimagnetix.com" }]
 description = "Standalone Python 3 implementation of the Nmag micromagnetic simulation interface"
 readme = "README.md"
@@ -14,6 +14,10 @@ classifiers = [
   "Operating System :: OS Independent" ]
 dependencies = ["pint", "numpy", "scipy", "numba", "tabulate", "meshio", "h5py"]
 
+[project.scripts]
+nmeshimport = "nmesh.cli.nmeshimport:main"
+nmagpp = "nmag.cli.nmagpp:main"
+
 [project.optional-dependencies]
 test = ["pytest", "pytest-cov", "pytest-watch"]
 rust = ["maturin>=1.14,<2"]

{nmag_python_3-0.0.3 → nmag_python_3-0.0.4}/src/nmag/__init__.py

@@ -1,5 +1,7 @@
 """Public Python 3 entrypoint for the nmag rewrite."""
 
+from typing import Any
+
 from anisotropy import (
     PredefinedAnisotropy,
     cubic_anisotropy,
@@ -15,6 +17,8 @@ from .dynamics import IntegratorConfig, IntegratorStats
 from .parallel import ParallelRuntimeInfo, parallel_runtime_info
 from .simulation import Simulation
 
+_OUTPUT_EXPORTS = {"export_vtk", "resolve_snapshot"}
+
 __all__ = [
     "MagMaterial",
     "NmagConfig",
@@ -33,4 +37,16 @@ __all__ = [
     "parallel_runtime_info",
     "uniaxial_anisotropy",
     "want_anisotropy",
+    "export_vtk",
+    "resolve_snapshot",
 ]
+
+
+def __getattr__(name: str) -> Any:
+    if name in _OUTPUT_EXPORTS:
+        from . import vtk_export
+
+        value = getattr(vtk_export, name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

nmag_python_3-0.0.4/src/nmag/cli/__init__.py

@@ -0,0 +1 @@
+"""Command-line entry points for Nmag utilities."""

nmag_python_3-0.0.4/src/nmag/cli/nmagpp.py

@@ -0,0 +1,43 @@
+"""Export modern Nmag snapshots to VTK-compatible files."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+from pathlib import Path
+
+import h5py
+
+from ..vtk_export import export_vtk, resolve_snapshot
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="nmagpp",
+        description="Export a modern Nmag HDF5 snapshot to VTK.",
+    )
+    parser.add_argument("--vtk", dest="output", required=True, type=Path)
+    parser.add_argument("input", type=Path, help="snapshot path or simulation base name")
+    parser.add_argument("--mesh", type=Path, help="mesh file supplying cell topology")
+    parser.add_argument("--field", action="append", dest="fields", metavar="NAME")
+    parser.add_argument("--all-fields", action="store_true")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    snapshot = resolve_snapshot(args.input)
+    if args.all_fields:
+        with h5py.File(str(snapshot), "r") as handle:
+            group = handle.get("fields")
+            if not isinstance(group, h5py.Group):
+                raise ValueError("Snapshot is missing the /fields group.")
+            fields = tuple(str(name) for name in group.keys())
+    else:
+        fields = tuple(args.fields or ("m",))
+    export_vtk(snapshot, args.output, mesh_path=args.mesh, fields=fields)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

nmag_python_3-0.0.4/src/nmag/vtk_export.py

@@ -0,0 +1,124 @@
+"""Export modern Nmag spatial snapshots to VTK-compatible mesh files."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+
+import h5py
+import meshio
+import numpy as np
+
+import nmesh
+
+
+def _dataset_names(handle: h5py.File) -> list[str]:
+    fields = handle.get("fields")
+    if not isinstance(fields, h5py.Group):
+        raise ValueError("Snapshot is missing the /fields group.")
+    return sorted(str(name) for name in fields.keys())
+
+
+def _read_points(handle: h5py.File) -> np.ndarray:
+    try:
+        points = np.asarray(handle["mesh/points"], dtype=float)
+    except KeyError as exc:
+        raise ValueError("Snapshot is missing /mesh/points.") from exc
+    if points.ndim != 2 or points.shape[1] != 3:
+        raise ValueError(f"Snapshot points must have shape (N, 3), got {points.shape}.")
+    return points
+
+
+def _read_topology(
+    handle: h5py.File,
+    mesh_path: str | Path | None,
+) -> tuple[np.ndarray, np.ndarray | None, np.ndarray]:
+    if "mesh/simplices" in handle:
+        simplices = np.asarray(handle["mesh/simplices"], dtype=np.int64)
+        regions = (
+            np.asarray(handle["mesh/simplicesregions"], dtype=np.int64)
+            if "mesh/simplicesregions" in handle
+            else None
+        )
+    elif mesh_path is not None:
+        source_mesh = nmesh.load(mesh_path)
+        simplices = np.asarray(source_mesh.simplices, dtype=np.int64)
+        regions = np.asarray(source_mesh.regions, dtype=np.int64)
+    else:
+        raise ValueError(
+            "Snapshot contains point coordinates but no cell topology; provide --mesh."
+        )
+
+    if simplices.ndim != 2 or simplices.shape[1] != 4:
+        raise ValueError(f"VTK export requires tetrahedral cells, got {simplices.shape}.")
+    if regions is not None and len(regions) != len(simplices):
+        raise ValueError("Mesh region data does not match the number of cells.")
+    return simplices, regions, _read_points(handle)
+
+
+def export_vtk(
+    snapshot_path: str | Path,
+    output_path: str | Path,
+    *,
+    mesh_path: str | Path | None = None,
+    fields: Iterable[str] = ("m",),
+) -> Path:
+    """Export selected point fields from a modern Nmag HDF5 snapshot."""
+
+    snapshot = Path(snapshot_path)
+    output = Path(output_path)
+    selected_fields = tuple(dict.fromkeys(fields))
+    if not selected_fields:
+        raise ValueError("At least one point field must be selected.")
+
+    with h5py.File(str(snapshot), "r") as handle:
+        points = _read_points(handle)
+        simplices, regions, _ = _read_topology(handle, mesh_path)
+        if np.any(simplices < 0) or np.any(simplices >= len(points)):
+            raise ValueError("Mesh cell indices are outside the snapshot point range.")
+
+        point_data: dict[str, np.ndarray] = {}
+        field_group = handle.get("fields")
+        if not isinstance(field_group, h5py.Group):
+            raise ValueError("Snapshot is missing the /fields group.")
+        for field_name in selected_fields:
+            if field_name not in field_group:
+                available = ", ".join(_dataset_names(handle))
+                raise KeyError(f"Field {field_name!r} is not present; available fields: {available}")
+            values = np.asarray(field_group[field_name])
+            if values.ndim not in (1, 2) or values.shape[0] != len(points):
+                raise ValueError(
+                    f"Field {field_name!r} must have one value per point, got {values.shape}."
+                )
+            if values.ndim == 2 and values.shape[1] not in (1, 3):
+                raise ValueError(
+                    f"Field {field_name!r} must be scalar or three-component vector, "
+                    f"got {values.shape}."
+                )
+            point_data[field_name] = np.asarray(values, dtype=float)
+
+    cell_data: dict[str, list[np.ndarray]] = {}
+    if regions is not None:
+        cell_data["region"] = [regions]
+    mesh = meshio.Mesh(
+        points=points,
+        cells=[("tetra", simplices)],
+        point_data=point_data,
+        cell_data=cell_data or None,
+    )
+    output.parent.mkdir(parents=True, exist_ok=True)
+    meshio.write(output, mesh)
+    return output
+
+
+def resolve_snapshot(path: str | Path) -> Path:
+    """Resolve a snapshot path or a simulation base name."""
+
+    candidate = Path(path)
+    if candidate.is_file():
+        return candidate
+    if candidate.suffix == "":
+        suffixed = candidate.with_name(f"{candidate.name}_dat.h5")
+        if suffixed.is_file():
+            return suffixed
+    raise FileNotFoundError(f"Nmag snapshot does not exist: {candidate}")

{nmag_python_3-0.0.3 → nmag_python_3-0.0.4/src/nmag_python_3.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nmag-python-3
-Version: 0.0.3
+Version: 0.0.4
 Summary: Standalone Python 3 implementation of the Nmag micromagnetic simulation interface
 Author-email: TriMagnetix <info@trimagnetix.com>
 Classifier: Programming Language :: Python :: 3

{nmag_python_3-0.0.3 → nmag_python_3-0.0.4}/src/nmag_python_3.egg-info/SOURCES.txt

@@ -20,6 +20,9 @@ src/nmag/output.py
 src/nmag/parallel.py
 src/nmag/py.typed
 src/nmag/resources.py
+src/nmag/vtk_export.py
+src/nmag/cli/__init__.py
+src/nmag/cli/nmagpp.py
 src/nmag/demag/__init__.py
 src/nmag/demag/bem_operator.py
 src/nmag/demag/geometry.py
@@ -70,6 +73,7 @@ src/nmag/simulation/mesh/probe.py
 src/nmag_python_3.egg-info/PKG-INFO
 src/nmag_python_3.egg-info/SOURCES.txt
 src/nmag_python_3.egg-info/dependency_links.txt
+src/nmag_python_3.egg-info/entry_points.txt
 src/nmag_python_3.egg-info/requires.txt
 src/nmag_python_3.egg-info/top_level.txt
 src/nmesh/__init__.py
@@ -80,6 +84,8 @@ src/nmesh/mesh_model.py
 src/nmesh/mesh_utilities.py
 src/nmesh/nmesh.py
 src/nmesh/py.typed
+src/nmesh/cli/__init__.py
+src/nmesh/cli/nmeshimport.py
 src/nmesh/geometry/__init__.py
 src/nmesh/geometry/boolean_operations.py
 src/nmesh/geometry/primitives.py
@@ -88,6 +94,7 @@ src/nmesh/io/__init__.py
 src/nmesh/io/ascii.py
 src/nmesh/io/legacy_nmesh_hdf5.py
 src/nmesh/io/meshio_support.py
+src/nmesh/io/netgen.py
 src/nmesh/mesher/__init__.py
 src/nmesh/mesher/driver.py
 src/nmesh/mesher/meshing_defaults.py

nmag_python_3-0.0.4/src/nmag_python_3.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+nmagpp = nmag.cli.nmagpp:main
+nmeshimport = nmesh.cli.nmeshimport:main

{nmag_python_3-0.0.3 → nmag_python_3-0.0.4}/src/nmesh/__init__.py

@@ -52,6 +52,7 @@ _MESHER_EXPORTS = {
     "do_every_n_steps_driver",
     "make_mg_gendriver",
 }
+_NETGEN_EXPORTS = {"read_netgen_neutral"}
 
 __all__ = [
     "Mesh",
@@ -96,10 +97,17 @@ __all__ = [
     "inverse_shift",
     "make_mg_gendriver",
     "union",
+    "read_netgen_neutral",
 ]
 
 
 def __getattr__(name: str) -> Any:
+    if name in _NETGEN_EXPORTS:
+        from .io.netgen import read_netgen_neutral
+
+        globals()[name] = read_netgen_neutral
+        return read_netgen_neutral
+
     if name in _GEOMETRY_EXPORTS:
         from . import geometry
 

nmag_python_3-0.0.4/src/nmesh/cli/__init__.py

@@ -0,0 +1 @@
+"""Command-line entry points for mesh utilities."""

nmag_python_3-0.0.4/src/nmesh/cli/nmeshimport.py

@@ -0,0 +1,39 @@
+"""Convert Netgen Neutral meshes to legacy Nmesh HDF5."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+from pathlib import Path
+
+from ..io import save_raw_mesh_as_legacy_nmesh_hdf5
+from ..io.netgen import read_netgen_neutral
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="nmeshimport",
+        description="Convert a Netgen Neutral tetrahedral mesh to Nmesh HDF5.",
+    )
+    parser.add_argument(
+        "--netgen",
+        action="store_true",
+        help="read Netgen Neutral input (the supported conversion mode)",
+    )
+    parser.add_argument("input", type=Path)
+    parser.add_argument("output", type=Path)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    if not args.netgen:
+        raise SystemExit("nmeshimport currently requires --netgen.")
+    mesh = read_netgen_neutral(args.input)
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    save_raw_mesh_as_legacy_nmesh_hdf5(args.output, mesh)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{nmag_python_3-0.0.3 → nmag_python_3-0.0.4}/src/nmesh/io/__init__.py

@@ -23,12 +23,15 @@ _MESHIO_EXPORTS = {
     "save_raw_mesh_with_meshio",
 }
 
+_NETGEN_EXPORTS = {"read_netgen_neutral"}
+
 __all__ = [
     "is_legacy_nmesh_hdf5",
     "load_raw_mesh_from_legacy_nmesh_hdf5",
     "load_raw_mesh_with_meshio",
     "save_raw_mesh_as_legacy_nmesh_hdf5",
     "save_raw_mesh_with_meshio",
+    "read_netgen_neutral",
 ]
 
 
@@ -47,4 +50,10 @@ def __getattr__(name: str) -> Any:
         globals()[name] = value
         return value
 
+    if name in _NETGEN_EXPORTS:
+        from .netgen import read_netgen_neutral
+
+        globals()[name] = read_netgen_neutral
+        return read_netgen_neutral
+
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

nmag_python_3-0.0.4/src/nmesh/io/netgen.py

@@ -0,0 +1,122 @@
+"""Readers for Netgen Neutral tetrahedral meshes."""
+
+from __future__ import annotations
+
+import gzip
+from pathlib import Path
+from typing import TextIO
+
+from ..backend import RawMesh
+
+
+def _open_text(path: Path) -> TextIO:
+    if path.suffix == ".gz":
+        return gzip.open(path, "rt", encoding="utf-8")
+    return path.open("r", encoding="utf-8")
+
+
+class _LineReader:
+    def __init__(self, stream: TextIO, path: Path) -> None:
+        self.stream = stream
+        self.path = path
+        self.line_number = 0
+
+    def next(self, description: str) -> tuple[int, str]:
+        for line in self.stream:
+            self.line_number += 1
+            stripped = line.strip()
+            if stripped:
+                return self.line_number, stripped
+        raise ValueError(f"{self.path} ended while reading {description}.")
+
+
+def _parse_count(line: str, path: Path, line_number: int, description: str) -> int:
+    try:
+        count = int(line)
+    except ValueError as exc:
+        raise ValueError(
+            f"{path}:{line_number} has an invalid {description} count: {line!r}."
+        ) from exc
+    if count < 0:
+        raise ValueError(f"{path}:{line_number} has a negative {description} count.")
+    return count
+
+
+def read_netgen_neutral(path: str | Path) -> RawMesh:
+    """Read a Netgen Neutral tetrahedral mesh into a :class:`RawMesh`.
+
+    Netgen Neutral element indices are one-based.  They are converted to the
+    zero-based indexing used by ``nmesh`` while region IDs are preserved.
+    Gzip-compressed files are accepted when the filename ends in ``.gz``.
+    """
+
+    mesh_path = Path(path)
+    if not mesh_path.is_file():
+        raise FileNotFoundError(f"Netgen mesh does not exist: {mesh_path}")
+
+    try:
+        with _open_text(mesh_path) as stream:
+            reader = _LineReader(stream, mesh_path)
+            point_count_line, point_count_text = reader.next("point")
+            point_count = _parse_count(
+                point_count_text, mesh_path, point_count_line, "point"
+            )
+            if point_count == 0:
+                raise ValueError(f"{mesh_path} contains no points.")
+
+            points: list[list[float]] = []
+            for index in range(point_count):
+                line_number, line = reader.next(f"point {index + 1}")
+                values = line.split()
+                if len(values) != 3:
+                    raise ValueError(
+                        f"{mesh_path}:{line_number} point {index + 1} must have three coordinates."
+                    )
+                try:
+                    points.append([float(value) for value in values])
+                except ValueError as exc:
+                    raise ValueError(
+                        f"{mesh_path}:{line_number} contains a non-numeric point coordinate."
+                    ) from exc
+
+            simplex_count_line, simplex_count_text = reader.next("tetrahedron")
+            simplex_count = _parse_count(
+                simplex_count_text,
+                mesh_path,
+                simplex_count_line,
+                "tetrahedron",
+            )
+            if simplex_count == 0:
+                raise ValueError(f"{mesh_path} contains no tetrahedra.")
+
+            simplices: list[list[int]] = []
+            regions: list[int] = []
+            for index in range(simplex_count):
+                line_number, line = reader.next(f"tetrahedron {index + 1}")
+                values = line.split()
+                if len(values) != 5:
+                    raise ValueError(
+                        f"{mesh_path}:{line_number} tetrahedron {index + 1} must contain "
+                        "one region ID and four point indices."
+                    )
+                try:
+                    region = int(values[0])
+                    indices = [int(value) - 1 for value in values[1:]]
+                except ValueError as exc:
+                    raise ValueError(
+                        f"{mesh_path}:{line_number} contains a non-integer tetrahedron value."
+                    ) from exc
+                if region <= 0:
+                    raise ValueError(
+                        f"{mesh_path}:{line_number} has invalid region ID {region}; expected > 0."
+                    )
+                if any(point < 0 or point >= point_count for point in indices):
+                    raise ValueError(
+                        f"{mesh_path}:{line_number} contains a point index outside 1..{point_count}."
+                    )
+                simplices.append(indices)
+                regions.append(region)
+    except (OSError, UnicodeError) as exc:
+        raise ValueError(f"Unable to read Netgen mesh {mesh_path}: {exc}") from exc
+
+    return RawMesh(points=points, simplices=simplices, regions=regions, dim=3)