nmag-python-3 0.0.2__py3-none-any.whl

nmag/simulation/support.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable, Iterable, Sequence
+from functools import cache, lru_cache
+from typing import Any, cast
+
+import numpy as np
+
+from si.physical import SI
+
+
+@cache
+def _si_unit(unit: str) -> SI:
+    return SI(1, unit)
+
+
+@lru_cache(maxsize=1)
+def _si_dimensionless() -> SI:
+    return SI(1)
+
+
+Vector = Sequence[float]
+VectorField = Callable[[Sequence[float]], Sequence[float]]
+VectorFieldInput = Sequence[float] | np.ndarray | VectorField
+ScalarField = Callable[[Sequence[float]], float | SI]
+ScalarFieldInput = float | SI | Sequence[float] | np.ndarray | ScalarField
+MU0 = 4.0 * np.pi * 1.0e-7
+MU0_OVER_4PI = 1.0 / (4.0 * np.pi)
+# Legacy Nmag's default simulation units make one magnetisation unit 1e6 A/m.
+# Its exported dmdt field uses that global reference rather than a material's Ms.
+LEGACY_DMDT_MAGNETISATION_SCALE = 1.0e6
+# Legacy Nmag's fixed simulation base length is one nanometre.  The demag
+# solver's weak divergence is boxed with this base volume when exporting rho,
+# independently of the unit_length supplied for a particular mesh.
+LEGACY_RHO_BOXED_VOLUME_M3 = 1.0e-27
+DERIVED_FIELD_NAMES = {
+    "M",
+    "H_total",
+    "H_anis",
+    "H_exch",
+    "dmdt",
+    "E_total",
+    "E_ext",
+    "E_anis",
+    "E_exch",
+    "E_demag",
+    "phi",
+    "rho",
+    "pin",
+    "dm_dcurrent",
+}
+_MESH_EDGE_SET_THRESHOLD = 4096
+_NO_CONSTANT_AVERAGE = object()
+_NO_COMPOSED_AVERAGE = object()
+
+
+def _copy_average_value(value: object) -> object:
+    if isinstance(value, np.ndarray):
+        return cast(list[Any], value.tolist())
+    if isinstance(value, list):
+        return list(cast(list[Any], value))
+    return value
+
+
+def _as_vector3(values: Sequence[Any], *, unit: SI | None = None) -> list[float]:
+    if len(values) != 3:
+        raise ValueError(f"Expected a 3-vector, got {len(values)} components.")
+
+    if unit is not None:
+        scale = unit.in_units_of(_si_unit("A/m"))
+        return [float(value) * scale for value in values]
+
+    result: list[float] = []
+    for value in values:
+        if isinstance(value, SI):
+            result.append(value.in_units_of(_si_unit("A/m")))
+        else:
+            result.append(float(value))
+    return result
+
+
+def _normalise_m(values: Sequence[Any]) -> list[float]:
+    vector = np.asarray(values, dtype=float)
+    if vector.shape != (3,):
+        raise ValueError(f"Magnetisation must be a 3-vector, got shape {vector.shape}.")
+
+    norm = float(np.linalg.norm(vector))
+    if norm == 0.0:
+        raise ValueError("Magnetisation vectors must be non-zero.")
+
+    return cast(list[float], (vector / norm).tolist())
+
+
+def _dimensionless_value(value: Any, *, fieldname: str) -> float:
+    result = value.in_units_of(_si_dimensionless()) if isinstance(value, SI) else float(value)
+    if not np.isfinite(result):
+        raise ValueError(f"{fieldname} values must be finite.")
+    return result
+
+
+def _scalar_nodal_field(
+    values: ScalarFieldInput,
+    points: Sequence[Sequence[float]],
+    *,
+    fieldname: str,
+) -> np.ndarray:
+    point_count = len(points)
+    if callable(values):
+        return np.asarray(
+            [_dimensionless_value(values(point), fieldname=fieldname) for point in points],
+            dtype=float,
+        )
+    if isinstance(values, SI) or np.isscalar(values):
+        return np.full(
+            point_count,
+            _dimensionless_value(values, fieldname=fieldname),
+            dtype=float,
+        )
+
+    array = np.asarray(values, dtype=float)
+    if array.shape != (point_count,):
+        raise ValueError(
+            f"{fieldname} must be a scalar, callable, or one value per mesh point; "
+            f"expected shape ({point_count},), got {array.shape}."
+        )
+    if not np.all(np.isfinite(array)):
+        raise ValueError(f"{fieldname} values must be finite.")
+    return np.array(array, dtype=float, copy=True)
+
+
+def _vector_in_units(
+    values: Sequence[Any],
+    *,
+    unit: SI | None,
+    expected_unit: SI,
+    fieldname: str,
+) -> np.ndarray:
+    if len(values) != 3:
+        raise ValueError(f"{fieldname} values must be 3-vectors, got {len(values)} components.")
+    if unit is not None:
+        vector = np.asarray(values, dtype=float) * unit.in_units_of(expected_unit)
+    else:
+        vector = np.asarray(
+            [
+                value.in_units_of(expected_unit) if isinstance(value, SI) else float(value)
+                for value in values
+            ],
+            dtype=float,
+        )
+    if not np.all(np.isfinite(vector)):
+        raise ValueError(f"{fieldname} values must be finite.")
+    return vector
+
+
+def _vector_nodal_field(
+    values: VectorFieldInput,
+    points: Sequence[Sequence[float]],
+    *,
+    unit: SI | None,
+    expected_unit: SI,
+    fieldname: str,
+) -> np.ndarray:
+    if callable(values):
+        return np.asarray(
+            [
+                _vector_in_units(
+                    values(point),
+                    unit=unit,
+                    expected_unit=expected_unit,
+                    fieldname=fieldname,
+                )
+                for point in points
+            ],
+            dtype=float,
+        )
+
+    array = np.asarray(values, dtype=object if unit is None else float)
+    if array.shape == (3,):
+        vector = _vector_in_units(
+            cast(Sequence[Any], values),
+            unit=unit,
+            expected_unit=expected_unit,
+            fieldname=fieldname,
+        )
+        return np.tile(vector, (len(points), 1))
+    if array.shape != (len(points), 3):
+        raise ValueError(
+            f"{fieldname} must be a 3-vector, callable, or one vector per mesh point; "
+            f"expected shape ({len(points)}, 3), got {array.shape}."
+        )
+    return np.asarray(
+        [
+            _vector_in_units(
+                cast(Sequence[Any], row),
+                unit=unit,
+                expected_unit=expected_unit,
+                fieldname=fieldname,
+            )
+            for row in array
+        ],
+        dtype=float,
+    )
+
+
+def _flatten_materials(region_materials: Iterable[tuple[str, Any]]) -> list[Any]:
+    materials: list[Any] = []
+    seen_names: set[str] = set()
+    for _, entry in region_materials:
+        region_mats: list[Any] = cast(list[Any], entry) if isinstance(entry, list) else [entry]
+        for material in region_mats:
+            if material.name not in seen_names:
+                seen_names.add(material.name)
+                materials.append(material)
+    return materials
+
+
+def _simulation_compatibility_binding(
+    name: str, fallback: Callable[..., Any]
+) -> Callable[..., Any]:
+    """Use a legacy simulation-module override when tests or extensions provide one."""
+
+    simulation_module = sys.modules.get("nmag.simulation")
+    return getattr(simulation_module, name, fallback) if simulation_module is not None else fallback

nmag_python_3-0.0.2.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: nmag-python-3
+Version: 0.0.2
+Summary: Standalone Python 3 implementation of the Nmag micromagnetic simulation interface
+Author-email: TriMagnetix <info@trimagnetix.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pint
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: numba
+Requires-Dist: tabulate
+Requires-Dist: meshio
+Requires-Dist: h5py
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-watch; extra == "test"
+Provides-Extra: rust
+Requires-Dist: maturin<2,>=1.14; extra == "rust"
+Provides-Extra: docs
+Requires-Dist: mkdocs==1.6.1; extra == "docs"
+Requires-Dist: mkdocs-material==9.7.7; extra == "docs"
+Requires-Dist: mkdocstrings==1.0.6; extra == "docs"
+Requires-Dist: mkdocstrings-python==2.0.5; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: maturin<2,>=1.14; extra == "dev"
+Requires-Dist: h5py-stubs<0.2,>=0.1.2; extra == "dev"
+Requires-Dist: pyright<2,>=1.1.400; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-watch; extra == "dev"
+Requires-Dist: ruff<1,>=0.12; extra == "dev"
+Dynamic: license-file
+
+# Nmag for Python 3
+
+`nmag-python-3` is a standalone Python implementation of the Nmag finite-element
+micromagnetic simulation interface. It supports tetrahedral meshes, magnetic
+materials, static effective fields, adaptive LLG dynamics and relaxation,
+NDT/HDF5 output, field probing, and native restart checkpoints.
+
+The human documentation is available at
+**<https://trimagnetix.github.io/nmag-python-3/>**. Start with the
+[installation guide](https://trimagnetix.github.io/nmag-python-3/getting-started/installation/)
+and [quickstart](https://trimagnetix.github.io/nmag-python-3/getting-started/quickstart/).
+
+## Requirements
+
+- Linux
+- Python 3.10 or newer
+- A C compiler for Python dependencies without a platform wheel
+- Rust and the matching Python development library only for optional native
+  acceleration
+
+## Installation
+
+From a clone of this repository:
+
+```bash
+./scripts/setup.sh
+```
+
+The setup script creates or reuses `.venv`, offers to build the optional Rust
+accelerator, and runs the standard checks. Run a simulation with:
+
+```bash
+.venv/bin/python {{simulation_file_name.py}}
+```
+
+## Minimal simulation
+
+```python
+import nmag
+import nmesh
+
+mesh = nmesh.mesh_from_points_and_simplices(
+    points=[[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]],
+    simplices_indices=[[0, 1, 2, 3]],
+    simplices_regions=[1],
+)
+mesh.save("sample.nmesh.h5")
+
+material = nmag.MagMaterial(
+    name="Py",
+    Ms=nmag.SI(1e6, "A/m"),
+    exchange_coupling=nmag.SI(13e-12, "J/m"),
+)
+
+simulation = nmag.Simulation(name="sample")
+simulation.load_mesh(
+    "sample.nmesh.h5",
+    [("magnetic", material)],
+    unit_length=nmag.SI(1e-9, "m"),
+)
+simulation.set_m([1, 0, 0])
+simulation.set_H_ext([0, 0, 0], nmag.SI("A/m"))
+simulation.save_data(fields="all")
+```
+
+For a tested, rerunnable version and a canonical sphere example, see the
+[getting-started guide](https://trimagnetix.github.io/nmag-python-3/getting-started/quickstart/).
+
+## Status
+
+The supported solver covers 3D tetrahedral demagnetization, exchange, uniform
+applied fields, uniaxial and cubic anisotropy, custom polynomial anisotropy,
+pinning, Zhang-Li current torque, adaptive dynamics and relaxation, checkpoints,
+and resource-aware demagnetization storage.
+
+Thermal dynamics, Slonczewski torque, periodic micromagnetic boundaries,
+material-specific magnetization at incompatible shared nodes, local
+inter-material coupling, and full legacy hysteresis compatibility are not yet
+supported. Validate new geometries and material models before relying on
+production results. The complete and current list is maintained in the
+[supported-scope guide](https://trimagnetix.github.io/nmag-python-3/guides/supported-scope/).
+
+## Configuration and acceleration
+
+Each simulation accepts an immutable `NmagConfig`. `accelerator="auto"` uses
+installed Rust kernels where helpful, `"off"` keeps Python/Numba paths, and
+`"rust"` requires the extension. Advanced callers can use
+`accelerator_overrides={nmag.RustKernel.LLG: "rust"}`.
+
+For a simulation created without an explicit configuration,
+`NMAG_ACCELERATOR=auto|off|rust` selects the process default. Prefer
+`NmagConfig` in reusable programs. See the
+[configuration guide](https://trimagnetix.github.io/nmag-python-3/guides/configuration/)
+for storage, memory, and integrator choices.
+
+## Development checks
+
+```bash
+./scripts/verify.sh
+./scripts/verify.sh --rust
+```
+
+Build the documentation locally with:
+
+```bash
+.venv/bin/python -m pip install -e '.[docs]'
+.venv/bin/mkdocs build --strict
+```
+
+## Project lineage
+
+This project modernizes the original
+[nmag-project/nmag-src](https://github.com/nmag-project/nmag-src). The
+[historical Nmag 0.2 manual](https://nmag.readthedocs.io/en/latest/) remains a
+useful background reference, but its Python 2 runtime and some of its features
+do not describe this rewrite.
+
+Nmag for Python 3 is distributed under the GNU General Public License version 2
+or, at your option, any later version. See [LICENSE](LICENSE).

nmag_python_3-0.0.2.dist-info/RECORD

@@ -0,0 +1,147 @@
+anisotropy/__init__.py,sha256=r3Tb3JG3xwHHJxlIi4ARHRKMI_jxJxJHP-AZYi0apKg,663
+anisotropy/anisotropy.py,sha256=5GiBbFXMdWwVkxLJVqCsDKMc8zY9mqxd3mYwliLHBgo,350
+anisotropy/evaluation.py,sha256=ecAMk5ePzhui2vGum5zoy-DEjwMfiH2m-YVp2kpwDcI,2253
+anisotropy/model.py,sha256=Ivn40QaLbxYPZcv_YjbKRpNlE1WOERsAYh2Y0NX2ql0,8499
+anisotropy/predefined.py,sha256=79RqdJ99d6CscEeUzrEF3zNpkeYFVVaCZkdpj0RdfAM,7776
+anisotropy/py.typed,sha256=GOJzfT--I5WXaP7ohUQllUQsQIgGVdJh2w-iL5dW-vM,46
+anisotropy/values.py,sha256=Wkp9RvlTz3bAtVYIFDzgWJt_NgtQqtzQ8M7gfN-hAxI,3074
+mag_material/__init__.py,sha256=_bZqAVD-qXHu0l4Ymg6D9kvOwYp498pb3G2hCUqiLvY,65
+mag_material/mag_material.py,sha256=1kUJ2-53X5Vje1aqboPPCh7XVkL0vgnXOl_fmPti1Tc,8491
+mag_material/parameters.py,sha256=NfyEYhtLbL5Q_Vsd_As0iaqKP4jCchtwQamUtcScjck,5495
+mag_material/py.typed,sha256=GOJzfT--I5WXaP7ohUQllUQsQIgGVdJh2w-iL5dW-vM,46
+nmag/__init__.py,sha256=Wn292AZkH_LfUTYP6TtIZVqljf7fzADQnKliWLL2ioU,935
+nmag/backends.py,sha256=PlLthhwVRPME6QBhfDx5MeKhMhhocbnXDgpSxiUlf5c,17230
+nmag/checkpoint.py,sha256=9X0-y8qlG8XR_LQNxXE28EJeCMsAWEv7ilvYZbeB2Ok,14018
+nmag/config.py,sha256=qnAZBizQARNkzNIiceh74UNfcFJNszQkjUd_K-rk6aA,7405
+nmag/output.py,sha256=4B7hpX6sYXkO3aBWADQWwvKd7_-s4J66W6fIvoFTfsY,972
+nmag/parallel.py,sha256=gQlbE11ODt3X0Auv5OdPEFonkb7H5CEyITJbqrGmpv4,1614
+nmag/py.typed,sha256=GOJzfT--I5WXaP7ohUQllUQsQIgGVdJh2w-iL5dW-vM,46
+nmag/resources.py,sha256=mvfh7h0vWStyHN5jK1o6Lz6DWIh1znBCc456b9CRXlM,1284
+nmag/demag/__init__.py,sha256=PoigX74IJT3jDEQ7DwEoclsC8awEZ69KtMqCS1-A328,1192
+nmag/demag/bem_operator.py,sha256=MQEwMdZaty5FA0NtyvLeiFDhN9bFbsOf792Nz9ld73g,4934
+nmag/demag/geometry.py,sha256=IyUKtTziDCc5kwrYWcjul1XS-kgv_zch-15AAkrycj8,4716
+nmag/demag/lindholm.py,sha256=1G5o7QVuUoFJGX-n02j8o1mq9EKEtaIIQeIcAjyBVl4,4720
+nmag/demag/lindholm_fast.py,sha256=qcpeQGJH61Bp4h663yGN6xdjwvK60KuHOlAomkreqSM,15456
+nmag/demag/linear.py,sha256=Q79t74O7lFwsRmefUR76d8632VHXO18VfDkh7O26Rfg,16387
+nmag/dynamics/__init__.py,sha256=oaJyBbA7_Thy2QkQkohX37AEPt4UBeiUoPjsnMcQQmw,10042
+nmag/simulation/__init__.py,sha256=91ThDmvv4AP8UNdg3tVr3TUaN5ZQHfvK7jBnA6aKpTc,21130
+nmag/simulation/implicit_dynamics.py,sha256=tNlDDSy3KRoZpBE-0_U-n77XpQZHTvxHF8tNI-9sqC8,8914
+nmag/simulation/restart.py,sha256=b6tTd2HeMoEbjmlWWAgtq8rfbH0IYzeGyarvlLuHNd8,4079
+nmag/simulation/support.py,sha256=PURw9d-kTjF93fzPE7hpvUPkM1525wC7uBMu1vYZDlM,6856
+nmag/simulation/anisotropy/__init__.py,sha256=2m62U71AlffeQ1pB3mVk8goa7sywFIQ-YHXLF060rcw,148
+nmag/simulation/anisotropy/fields.py,sha256=8x5mT_vP0C4rySGuuTEHZuIkVvIOMFmVimV7IlbXBRg,2248
+nmag/simulation/anisotropy/materials.py,sha256=MCpBdlejAqUt5e9-9zUTALRou3016SFAi9b6Bjd5qGg,5509
+nmag/simulation/demag/__init__.py,sha256=M43vg0nm_yeOrEunkM_kHeje_kdddynvnlplkUhcoaw,74
+nmag/simulation/demag/solver.py,sha256=3oBnChUBIlXH9iHfxkY1y_3aASgSvafjtq-P8wiZsTM,529
+nmag/simulation/demag/bem/__init__.py,sha256=RFTDdPDtzjPcmLjVf-seuZxVYOpLspp028_h8yv6emA,369
+nmag/simulation/demag/bem/diagnostics.py,sha256=qwgbKVFt7Xurzf-Fhwgm8N2v0LSGhyc9uawvBX-K0hs,2352
+nmag/simulation/demag/bem/dirichlet.py,sha256=AdWDGfzaPGnCZzJ_YiWqHtEAPyUdH3FnD2wWzJytJTs,3603
+nmag/simulation/demag/bem/hierarchical.py,sha256=zKVuCw3Eg7-S-ZM0VPMfqQ2OPHUfUTV-ZOc_zi3qKr8,2921
+nmag/simulation/demag/bem/operator.py,sha256=7QLzr1aRvA1YEZPnX7_nUtlLPtsAQJhYcO8iAjxCdv0,11897
+nmag/simulation/demag/fem/__init__.py,sha256=fMjXvCQDzWw2RzRccfEI_bxS8ixCqyJCkQ7W6rnrBYQ,369
+nmag/simulation/demag/fem/assembly.py,sha256=HixQNUlbz7xW3ESUCk0REraAQY7a6pNNAtV4huEEH4k,3672
+nmag/simulation/demag/fem/charges.py,sha256=JzVTp0nAm27JmJlv29ushoNJ1Vt5gm7ht7LJ3wrueUE,1320
+nmag/simulation/demag/fem/geometry.py,sha256=hOZy_VXm3M904I18ZQs2MWnL0mDeXkdlVAFJWMph5Bo,9928
+nmag/simulation/demag/fields/__init__.py,sha256=ygENeCf4IEaw0dm-gsgIGCdgrpIttOoI8PGFk8IrAaw,376
+nmag/simulation/demag/fields/auxiliary.py,sha256=z1STjxry6RCtI-CNJ2LQUQLwjtzVZWxgUXm_cox__kU,7589
+nmag/simulation/demag/fields/probe.py,sha256=B61Y5Dm_DTTNUtnMiylEDlNx7P3svxAWO1PJZ9UWFq8,2938
+nmag/simulation/demag/fields/recovery.py,sha256=ACA_l0Q9tVDI-9NyYLPvDcQiV-t7O8FVvVPCDha87C0,7919
+nmag/simulation/dynamics/__init__.py,sha256=V4zvEz-1HLIFww9jBa_eOr4cpRO0vC8LtthqzKJyItg,3259
+nmag/simulation/dynamics/advance.py,sha256=kNKGa-Sq39H0nBQoH1Qyv5E-HdEMKSd8HAUMQHhq_1g,7697
+nmag/simulation/dynamics/integrator.py,sha256=T_9t7P7aXWD0GXhAefAuvJeFHQYHHbwvJJjwYdpdL94,10320
+nmag/simulation/exchange/__init__.py,sha256=ONqkq_NrH8ZqJtnUiisgwXUtnzJL5_3GPUuQLNbacng,445
+nmag/simulation/exchange/coefficients.py,sha256=EPDAYa3eZS6CjFwTnRL77V-Tct-apXXKQzn7h_2tQTk,7782
+nmag/simulation/exchange/fields.py,sha256=7ocujbconk5N6Lk6ES51QJhpYGdNVIHzo_h3bxdVsj4,4044
+nmag/simulation/exchange/llg_rhs.py,sha256=XMvnHhVuSXJqEuHg2ecEu89kjbhasWpeiMzF7TDxFOM,8378
+nmag/simulation/fields/__init__.py,sha256=-wzKRQiRGvhutDuO3p8IWOhr2mWDq4L9qd-ycMKWmFQ,690
+nmag/simulation/fields/arrays.py,sha256=Pa6LxMXA98hdCbP-pmbA5rkPWtmGeI0Sw4KsiBiXdME,4088
+nmag/simulation/fields/availability.py,sha256=9AQTn2xcqAsXCnfLWTtI-4nEPksmvUO0n3Xn9Mz5o30,7194
+nmag/simulation/fields/averages.py,sha256=AAvql_dS3uVXif4W9KMe7M527PFPGbwHk-e2eQSQOoo,11646
+nmag/simulation/fields/derived.py,sha256=gYwuneeH_9wj1KTwwYdMbjcIbGwDGMRrQYBtmdrq7zo,6030
+nmag/simulation/fields/maxangle.py,sha256=xd_z6E8kO8RIpIZBNuhwN756DJD0fInVgEKm3Wc2r6Y,6380
+nmag/simulation/fields/probes.py,sha256=R9aChj4eld87fp11WOT2F0xnoSLitY7OFUJSe3fagvc,3790
+nmag/simulation/mesh/__init__.py,sha256=ajrIpZq0zs_OECVz6N1qTLCJaGwDGaPN00mS7-rXMhU,417
+nmag/simulation/mesh/geometry.py,sha256=dHYNdjOsP6enQ4HF5bdECur58iDl4JZOwI8qvo4BT2A,6563
+nmag/simulation/mesh/materials.py,sha256=U6cDHoXTZmIqU_uzSqnD4dgvIvd4_0JmjLWGyGNDI6g,11822
+nmag/simulation/mesh/probe.py,sha256=B-g64S0R5YAoJVhRfkFvmtOKWWxutTDWUYaAtN9N7Tk,8682
+nmag_python_3-0.0.2.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+nmesh/__init__.py,sha256=mEr5yQFBJ9Mfsj3s2T3WlqgLxcLWXYMh2eGRjNVoda8,2573
+nmesh/backend.py,sha256=ads5vOPf9u7il2tgeJMmTfIy1pyWQZ05BFMCy3IqA3o,10760
+nmesh/mesh_generation.py,sha256=_sv3zqhvYNxRsC4tiDMnS5_bYHVkfhA9jpJJDCEDowk,6660
+nmesh/mesh_io.py,sha256=6oVDgGm26AdCw_sYAi7Xv3eHqwNISH2h-75awfQAhHc,7423
+nmesh/mesh_model.py,sha256=T99hZLKE5CZiWuMHUX3f_dvdoDw8yzZwaHJoGXL1LaY,5017
+nmesh/mesh_utilities.py,sha256=CmvQx4kV41kQT91I4KtMcmiTKUYwtRXyNnWwZ-TMjjE,2362
+nmesh/nmesh.py,sha256=l0H6cEIs3oQKWr0YOqIrLncloa4OKbSZfoQYjsUtclA,2160
+nmesh/py.typed,sha256=GOJzfT--I5WXaP7ohUQllUQsQIgGVdJh2w-iL5dW-vM,46
+nmesh/geometry/__init__.py,sha256=yD0zDhtyv73NBYwWCXcbRR6yELzOxMayJzYJBkOYvpk,1060
+nmesh/geometry/boolean_operations.py,sha256=oVeFg-agCBFQYpMlFDoOdQ2yLMg3YIHUqHoJsSawNLU,5126
+nmesh/geometry/primitives.py,sha256=3jCy8kpHYeEvJv0pd5gC91J1Z7zV_nRrGYCjVb31URI,16706
+nmesh/geometry/transform.py,sha256=d_Hb8NCOT1Rbr2oTQcGTf_EZgbxnBAiIWEaP64GvN04,4499
+nmesh/io/__init__.py,sha256=EfvOieElK7ykZAHRUpyF8AN3-4K-VDnSyZV0jl8eiDE,1417
+nmesh/io/ascii.py,sha256=2DdaCLWXxgb84ggegiW68d_H04WoDsfD5n6HXhCwtUs,4197
+nmesh/io/legacy_nmesh_hdf5.py,sha256=orVKKQCMyfooE8AUE4eD52WkShTQFbFJpZQVn3l_Zx4,11347
+nmesh/io/meshio_support.py,sha256=sVWvG067vlYVFPfcT-TH_Pt-jE7lAg1nGSqEJa9ebbk,5353
+nmesh/mesher/__init__.py,sha256=TbGKSC7wTdBbl_lA8RGJa0Xo_d7rPOjD6v36GLkrCsA,416
+nmesh/mesher/driver.py,sha256=0L9JCgy9XY45tcFebqc9c4CK-BwA2EHpq40VdVuwvIs,5079
+nmesh/mesher/meshing_defaults.py,sha256=q6qYhGDm3d_e3Oyy9Vnh6DXfCp6wa5F8RfeUjupC45I,8615
+nmesh/mesher/meshing_parameters.py,sha256=dVT8i4XVPRzUOAWCQfQBNFBvRtLUzO9qhTosY_BUw0s,6536
+nmesh/mesher/parity.py,sha256=6Nmq9XVq1UZ7Q7GwaQ1IkzHCSDfr_OnRh2S5ausmBS4,604
+nmesh/mesher/parity_canonical.py,sha256=btYkn6lPdjAwkfO2DqEUe6IqDE5lEXTN2lVEKMM9K_U,4824
+nmesh/mesher/parity_comparison.py,sha256=hgKaQKfwQCcxM7jtiYOxu1UNfy3mE5EmS93xQuCcYUE,5710
+nmesh/mesher/parity_metrics.py,sha256=3MlmA7UOaFgzx1RrNg7M-ZVQMrTRLvuNMpmaOgSkv4k,3739
+nmesh/mesher/periodic.py,sha256=DB5bi5k6kL9ffkGJZBaeLJF-2WQRn-8xs1V7udSl5eU,2811
+nmesh/mesher/sectioned_config.py,sha256=3FU1ERYAV8tkaM4LAOrPHDPTzhk3bSADveQFq0W1VQI,2268
+nmesh/mesher/relaxation/__init__.py,sha256=5KldaMJer5v5uWvhVeIkzhP33ke-ML88iwLbnqKvfiE,438
+nmesh/mesher/relaxation/_constants.py,sha256=tt4Gy3NiMDii40SpgC-v7RfPKGwxAF82EJ3Q733yevQ,389
+nmesh/mesher/relaxation/_types.py,sha256=LtuqBAJ325o0zpyEeoRFEAvzMLKzvUBTCS-UwjTItBs,490
+nmesh/mesher/relaxation/density.py,sha256=6zL-MiKKyUy5McO6nlvHqC5DbawOTccmgBqgzYtZfaI,5572
+nmesh/mesher/relaxation/engine/__init__.py,sha256=ST0GmA5so8yiNzKJMiLewV6UcfYaWHth-0BjMbfz02U,517
+nmesh/mesher/relaxation/engine/state.py,sha256=GJirfosbHqWfWm0bQ8Gc1X-0YdWnZQqAZxpF7kbIYH0,5447
+nmesh/mesher/relaxation/engine/steps.py,sha256=TLmrKj0iOPKPMPH1l7N1YIjNJV9BEfLrh-YuWgtg_7o,8940
+nmesh/mesher/relaxation/engine/topology.py,sha256=J54WRL5BvV437j1hwYRmSfWBYkAfXlocvXayRanNrG8,9594
+nmesh/mesher/relaxation/forces/__init__.py,sha256=lctj-PTxx-Oz4asxw-Fo4pCDVEld9Ena4Z1QiP2Nr_k,2494
+nmesh/mesher/relaxation/forces/jit.py,sha256=gPu93S0jjpeirkHUUTXUrJrpTCSAYOjD0g4dkQhrN9U,3577
+nmesh/mesher/relaxation/forces/neighbors.py,sha256=HlkjcxWu8ons7QrOY309heSQVTFK7vuQJak0JOISndk,6353
+nmesh/mesher/relaxation/forces/simplex.py,sha256=3Z9a14Axcdo542ACcooraNRjN3P-XcBLdJfPYYylDXs,10708
+nmesh/mesher/relaxation/forces/summary.py,sha256=YxGphI3i8cGDulmxdF8ybX9jfvVjsWwOj3c7_iEv7fQ,6775
+nmesh/mesher/relaxation/forces/types.py,sha256=p-mF9-WBmYz2uzuF3gDl_LhJehQrCIvKLD7tAOCguSg,3177
+nmesh/mesher/relaxation/geometry/__init__.py,sha256=A0dbdZZxhmMn2xUsBLzfkY5qcQUDP-HGRJuHeFp1dMo,193
+nmesh/mesher/relaxation/geometry/builder.py,sha256=AWJuj1QPyAyWf4Jpz1ti58k4b1UyNk-whAZ7K37YWQE,5704
+nmesh/mesher/relaxation/geometry/model.py,sha256=-FmSkbx0creT5KNc-T7tt9rjCC1lMFJSbPB-ooBN9kQ,7959
+nmesh/mesher/relaxation/seeding/__init__.py,sha256=M3bTsnNmezXdgjlPSjY8FMOM1wtrLWfN8WZ6mL0I2xw,2838
+nmesh/mesher/relaxation/seeding/periodic.py,sha256=dTtZ1rkDZB45zv55iKqOg1NCW-IQp-sd-xdDO436uhE,3032
+nmesh/mesher/relaxation/seeding/points.py,sha256=fJEcYySn4aDUM-AVyWV7M9Kg_XIUJ-9gRG0dzZwSCws,3206
+nmesh/mesher/relaxation/seeding/sampling.py,sha256=Dzf_nmZFppluzbwSgQjypfIp0ejLVkcS1F3ijmcYOl8,5116
+nmesh/mesher/relaxation/topology/__init__.py,sha256=oSInLcg5v6Q6hIm-oS1sOOubsxm0c4h-Uxbs9Yp82NA,10713
+nmesh/mesher/relaxation/topology/finalize.py,sha256=PsTxumFdQ3IE_ZfyvBMpZIf4kaAX6QTfCqoF6Tk-XCM,3016
+nmesh/mesher/relaxation/topology/recovery.py,sha256=wFp5wdCdGhw2xWPRLd0QQwHWstBEHB0yXjmhyh_n8Vg,10480
+nmesh/utils/__init__.py,sha256=BzoGj3p-MD3dsvmEyR7cyUQYcUVYdiHKbUtgkH5Qz0k,761
+nmesh/utils/array_list_utils.py,sha256=9afxJFETC30UvEl4vtFqWR39qa1yLRGiGIJZO46qm5A,3207
+nmesh/utils/constants.py,sha256=6PKqWKU-E6i63u4eSMnVKmK5Px2_5yOGunbC5EQy4V4,653
+nmesh/utils/timing_memory_utils.py,sha256=7u4ppspfUJWQ9mTTWCZOwNUMM2upB6_n2QS_j2fBQgw,1500
+nmesh/utils/types.py,sha256=XsCW6B-x6N3Hl6twAgc-i8-NCMNUDQdftmU-q9jIafM,365
+si/constants.py,sha256=TLba7vLDXZ1SNdwzwF38Ya5o2b4JWtol70LDrDM6s9g,1540
+si/physical.py,sha256=P9ASoJA1uBPNTCtY75AXJxsPME6p5hhfVVS8jNhBe2s,26430
+si/py.typed,sha256=GOJzfT--I5WXaP7ohUQllUQsQIgGVdJh2w-iL5dW-vM,46
+simulation/__init__.py,sha256=tuyZH4HRgnKZIN_ECKcfv3nJFvTfAUyTL4_My9DNgvE,64
+simulation/clock.py,sha256=758F1XtpN_SJbQs2PBy1GB4vXbObNe7OKsOOLlrzqjs,9261
+simulation/data_writer.py,sha256=kENmfUz6RjsWPcMmb1EwU7IBn85V5N83KRFWmbbaMNY,10789
+simulation/data_writer_collection.py,sha256=CloSqh0ssnBNVlkK2QCADE1vJHg-eFlZRCJdki7KIwI,8651
+simulation/hysteresis.py,sha256=bxrKJ_Oz6a4pEi1QROLKe3GUy0qhm1XpTSXDydYPu8s,1918
+simulation/hysteresis_runner.py,sha256=GcGgCs3Ez8wzNRVMLExMai-aXsVus6MiEOI5HmMJPWI,9571
+simulation/hysteresis_schedule.py,sha256=0-YWebauvkf9KAN2jFk-zTRiT5vsRj8YgN_lmyabaa4,6277
+simulation/py.typed,sha256=GOJzfT--I5WXaP7ohUQllUQsQIgGVdJh2w-iL5dW-vM,46
+simulation/quantity.py,sha256=DTni24AYlcslnEsQuTJ_ztpTSx2As556UASFgfFeLi8,3450
+simulation/simulation_core.py,sha256=ZiOi_KWK7ukfpKP0yHpZOusatNNGuOireOuSMNnmqrk,15556
+simulation/inference/__init__.py,sha256=46Y9si-M2z4OJVZM5S3vBU7hjr3lAuC4KFAI2dDqjJw,106
+simulation/inference/inference.py,sha256=krpQTIiHfNOuTB76OFuo_gOGrvMLe-HuxOm1LkR3L48,3325
+throttler/__init__.py,sha256=XbUN-2RTJq4qc6goEc24iEWSOGhRWnUEN0LtBInp_6w,58
+throttler/py.typed,sha256=GOJzfT--I5WXaP7ohUQllUQsQIgGVdJh2w-iL5dW-vM,46
+throttler/throttler.py,sha256=d3WfvydFVYwe14sMq2QSJNct5nrIw83I_0-AHT3jD8U,1921
+when/__init__.py,sha256=ipmS4ydLkbH0SvaWanfpcfr808iioyCSthL2ac2YabA,129
+when/py.typed,sha256=GOJzfT--I5WXaP7ohUQllUQsQIgGVdJh2w-iL5dW-vM,46
+when/when.py,sha256=caOzizbppDryE9IdKKZo_x_CHhz0LHakiJiDSE0fsjU,12214
+nmag_python_3-0.0.2.dist-info/METADATA,sha256=sqP-4G7Y8BjlTJVgsTA3g5QUTvg_KP-N1wHaXTlfTxs,5301
+nmag_python_3-0.0.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+nmag_python_3-0.0.2.dist-info/top_level.txt,sha256=0rAfvr3Y2amdt2wtdGMXFKvCEcEPmMSaiKVjNa_sxWM,64
+nmag_python_3-0.0.2.dist-info/RECORD,,

nmag_python_3-0.0.2.dist-info/WHEEL

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