momwire 0.2.3__tar.gz

momwire-0.2.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steven Burns
+
+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.

momwire-0.2.3/MANIFEST.in

@@ -0,0 +1,4 @@
+# setuptools auto-includes the C++ ext source (_accelerators.cpp) in the sdist,
+# but not the header it pulls in via #include "_bspline_static_moments_inline.h".
+# Without this, a source build from the sdist fails to compile the extension.
+include src/momwire/_bspline_static_moments_inline.h

momwire-0.2.3/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: momwire
+Version: 0.2.3
+Summary: A pure-Python method-of-moments antenna simulator with optional C++ accelerators
+Author-email: "Steven M. Burns" <smburns47@gmail.com>
+Project-URL: Homepage, https://github.com/stevenmburns/momwire
+Project-URL: Issues, https://github.com/stevenmburns/momwire/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Requires-Dist: scipy>=1.7
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: matplotlib; extra == "test"
+Requires-Dist: scikit-rf; extra == "test"
+Provides-Extra: validation
+Requires-Dist: pymininec>=1.2; extra == "validation"
+Dynamic: license-file
+
+# momwire
+
+A pure-Python method-of-moments antenna simulator with optional C++ accelerators (pybind11).
+
+Extracted from [antenna_designer](https://github.com/stevenmburns/antenna_designer).
+
+## Install
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install --upgrade pip
+pip install -e .
+```
+
+**macOS:** the C++ accelerator uses Homebrew's OpenMP runtime, so `brew install
+libomp` is required — both to compile from source and to run the prebuilt
+Apple-Silicon wheel. The wheel deliberately does **not** bundle `libomp` (it links
+Homebrew's by absolute path) so that it shares a single OpenMP runtime with
+pynec-accel; two private copies in one process abort with `OMP: Error #15` (or
+deadlock). Without `libomp` installed, the accelerator can't load and momwire
+warns and falls back to the slower pure-Python path. On Linux the system
+`libgomp` covers this, so no extra step is needed.
+
+## Test
+
+```bash
+pip install -e ".[test]"   # core + test deps (pytest, matplotlib, scikit-rf)
+pytest tests/
+```
+
+The cross-validation against NEC2 (`tests/test_pynec_backend.py`) additionally
+needs PyNEC — a test-only dependency installed separately from a wheel (see
+below). Those tests skip cleanly when it isn't present; everything else runs
+without it.
+
+## Optional: PyNEC backend (test-only)
+
+momwire can be cross-validated against NEC2 via [PyNEC](https://github.com/tmolteno/python-necpp) (the `tests/test_pynec_backend.py` suite); NEC2 also delivers ~5–10× faster single-frequency solves. PyNEC is a **test-flow-only** dependency — momwire's own solver never imports it.
+
+### Install the PyNEC wheel
+
+Install PyNEC from the [python-necpp fork](https://github.com/stevenmburns/python-necpp)'s release. The wheels are self-contained — OpenBLAS is vendored (via scipy-openblas32), so no system BLAS, SWIG, or build toolchain is needed — and cover Linux + Windows on CPython 3.10–3.14:
+
+```bash
+pip install PyNEC --no-index \
+    --find-links https://github.com/stevenmburns/python-necpp/releases/expanded_assets/v1.7.4-accel.1
+```
+
+`--no-index` ensures pip takes the fork's wheel rather than upstream PyNEC on PyPI (same version, but its builds are broken on current Python and it lacks the OpenBLAS/OpenMP work). After install, `from PyNEC import nec_context` works and the cross-validation tests run; without it they're skipped (momwire itself needs no PyNEC).
+
+### Runtime thread pinning
+
+The wheel links OpenBLAS and parallelises the NEC2 matrix fill with OpenMP. Pick thread counts up front:
+
+```bash
+export OMP_NUM_THREADS=$(nproc --all)   # PyNEC matrix fill
+export OPENBLAS_NUM_THREADS=1           # muzzle numpy/scipy's idle pool
+```
+
+Pinning `OPENBLAS_NUM_THREADS=1` stops numpy/scipy from spinning up their own OpenBLAS thread pool that contends with PyNEC's threads on the same cores. On a 100-director Yagi (2142 segs) this is worth ~8% wall time at NP=4.

momwire-0.2.3/README.md

@@ -0,0 +1,61 @@
+# momwire
+
+A pure-Python method-of-moments antenna simulator with optional C++ accelerators (pybind11).
+
+Extracted from [antenna_designer](https://github.com/stevenmburns/antenna_designer).
+
+## Install
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install --upgrade pip
+pip install -e .
+```
+
+**macOS:** the C++ accelerator uses Homebrew's OpenMP runtime, so `brew install
+libomp` is required — both to compile from source and to run the prebuilt
+Apple-Silicon wheel. The wheel deliberately does **not** bundle `libomp` (it links
+Homebrew's by absolute path) so that it shares a single OpenMP runtime with
+pynec-accel; two private copies in one process abort with `OMP: Error #15` (or
+deadlock). Without `libomp` installed, the accelerator can't load and momwire
+warns and falls back to the slower pure-Python path. On Linux the system
+`libgomp` covers this, so no extra step is needed.
+
+## Test
+
+```bash
+pip install -e ".[test]"   # core + test deps (pytest, matplotlib, scikit-rf)
+pytest tests/
+```
+
+The cross-validation against NEC2 (`tests/test_pynec_backend.py`) additionally
+needs PyNEC — a test-only dependency installed separately from a wheel (see
+below). Those tests skip cleanly when it isn't present; everything else runs
+without it.
+
+## Optional: PyNEC backend (test-only)
+
+momwire can be cross-validated against NEC2 via [PyNEC](https://github.com/tmolteno/python-necpp) (the `tests/test_pynec_backend.py` suite); NEC2 also delivers ~5–10× faster single-frequency solves. PyNEC is a **test-flow-only** dependency — momwire's own solver never imports it.
+
+### Install the PyNEC wheel
+
+Install PyNEC from the [python-necpp fork](https://github.com/stevenmburns/python-necpp)'s release. The wheels are self-contained — OpenBLAS is vendored (via scipy-openblas32), so no system BLAS, SWIG, or build toolchain is needed — and cover Linux + Windows on CPython 3.10–3.14:
+
+```bash
+pip install PyNEC --no-index \
+    --find-links https://github.com/stevenmburns/python-necpp/releases/expanded_assets/v1.7.4-accel.1
+```
+
+`--no-index` ensures pip takes the fork's wheel rather than upstream PyNEC on PyPI (same version, but its builds are broken on current Python and it lacks the OpenBLAS/OpenMP work). After install, `from PyNEC import nec_context` works and the cross-validation tests run; without it they're skipped (momwire itself needs no PyNEC).
+
+### Runtime thread pinning
+
+The wheel links OpenBLAS and parallelises the NEC2 matrix fill with OpenMP. Pick thread counts up front:
+
+```bash
+export OMP_NUM_THREADS=$(nproc --all)   # PyNEC matrix fill
+export OPENBLAS_NUM_THREADS=1           # muzzle numpy/scipy's idle pool
+```
+
+Pinning `OPENBLAS_NUM_THREADS=1` stops numpy/scipy from spinning up their own OpenBLAS thread pool that contends with PyNEC's threads on the same cores. On a 100-director Yagi (2142 segs) this is worth ~8% wall time at NP=4.

momwire-0.2.3/pyproject.toml

@@ -0,0 +1,133 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel", "pybind11"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "momwire"
+version = "0.2.3"
+authors = [
+  { name="Steven M. Burns", email="smburns47@gmail.com" },
+]
+description = "A pure-Python method-of-moments antenna simulator with optional C++ accelerators"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    # Accelerated wheels are built for these three; other platforms fall back to
+    # the pure-Python solver (the C++ extension is an optional build). Not "OS
+    # Independent" — that connotes a pure-Python package, which this isn't.
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS",
+]
+# Core runtime deps: the solver and its helpers import these unconditionally
+# (numpy/scipy throughout src/momwire). The C++ _accelerators extension is an
+# optional speedup, not required for import.
+dependencies = [
+    "numpy>=1.21",
+    "scipy>=1.7",
+]
+
+[project.optional-dependencies]
+# Test/dev flow: `pip install -e .[test]` reproduces the suite. numpy/scipy are
+# core deps; these are the extra imports the tests use (matplotlib for the
+# plot-marked tests, scikit-rf for the network tests) plus the runner. The
+# PyNEC cross-check (tests/test_pynec_backend.py) additionally needs PyNEC,
+# installed separately from the python-necpp fork's wheel — see README — and
+# those tests skip cleanly without it, so it stays out of this list (it's a
+# platform-specific --find-links wheel, not a PyPI package a name could pin).
+test = [
+    "pytest",
+    "matplotlib",
+    "scikit-rf",
+]
+# Optional third-party MoM solvers used by the comparator scripts in
+# scripts/. (PyNEC is installed separately from the python-necpp fork's
+# release wheel — see README — not from PyPI.)
+validation = [
+    "pymininec>=1.2",
+]
+
+[project.urls]
+Homepage = "https://github.com/stevenmburns/momwire"
+Issues = "https://github.com/stevenmburns/momwire/issues"
+
+[tool.pytest.ini_options]
+# Only collect the project's own tests.
+testpaths = ["tests"]
+markers = [
+    "slow: tests that take more than a couple seconds (deselect with -m 'not slow')",
+    "plot: tests that produce plots for visual inspection (deselect with -m 'not plot')",
+]
+# Put the project root on sys.path so the `validation` harness package (which
+# lives next to `tests/`, not under src/) is importable from the backend tests.
+pythonpath = ["."]
+
+[tool.cibuildwheel]
+# Modern CPython only. requires-python is >=3.8, but 3.8/3.9 predate the
+# AVX2-baseline target; 3.10+ matches the "modern Linux/Windows" goal.
+build = "cp310-* cp311-* cp312-* cp313-* cp314-*"
+# 64-bit glibc Linux + 64-bit Windows only. Skip musllinux (Alpine/musl has no
+# libmvec, and the -lmvec link in setup.py would fail), 32-bit, and PyPy.
+skip = "*-musllinux_* *_i686 *-win32 pp*"
+test-requires = "pytest"
+# First assert the compiled C++ accelerator actually loads in the wheel: a
+# failed import would otherwise be swallowed by triangular.py's pure-Python
+# fallback, so the tests below would pass on a silently-degraded wheel. The
+# direct import + _HAVE_* flags make that a hard failure instead.
+#
+# Then run only the three core solver modules — they exercise the accelerator
+# without the PyNEC cross-check backend (a separately-built wheel, test-only).
+# -m skips slow/plot. cibuildwheel runs this from a temp dir against the
+# installed wheel, so `import momwire` resolves to the wheel, not src/.
+test-command = 'python -c "import momwire._accelerators; from momwire import triangular as t; assert t._HAVE_ASSEMBLE_Z and t._HAVE_ASSEMBLE_Z_GENERAL" && pytest {project}/tests/test_momwire.py {project}/tests/test_hmatrix.py {project}/tests/test_array_block.py -m "not slow and not plot"'
+
+[tool.cibuildwheel.linux]
+# glibc >= 2.28 ships libmvec; manylinux2014 (glibc 2.17) does NOT, so the
+# -lmvec link in setup.py would fail. _2_28 is the right "modern Linux" floor.
+# (It is also cibuildwheel 3.x+'s default, but pin it explicitly so a future
+# default change can't silently drop libmvec.)
+manylinux-x86_64-image = "manylinux_2_28"
+# Do NOT vendor libgomp (`--exclude libgomp.so.1`): auditwheel would otherwise
+# bundle a private copy (momwire.libs/libgomp-<hash>.so) that uses initial-exec
+# TLS. When another OpenMP extension (e.g. pynec-accel) loads the system libgomp
+# first, momwire's vendored copy then fails to dlopen with "cannot allocate
+# memory in static TLS block" and the accelerator silently drops to the slow
+# pure-Python path. Excluding it makes momwire link the SYSTEM libgomp, so both
+# engines share one runtime — the Linux mirror of the macOS `--exclude libomp`,
+# and matching what pynec-accel already does. Needs a system libgomp at runtime
+# (the GCC OpenMP runtime, universal on glibc Linux; `apt install libgomp1` if
+# absent — manylinux images already have it for the build).
+repair-wheel-command = "auditwheel repair --exclude libgomp.so.1 -w {dest_dir} {wheel}"
+
+[tool.cibuildwheel.macos]
+# Native Apple Silicon only for this first cut (the macos-14 runner is arm64).
+# Intel macOS (x86_64) is intentionally out of scope.
+archs = ["arm64"]
+# libomp is provided by `brew install libomp` — at build AND at runtime (the
+# wheel no longer bundles it, see --exclude below). Point setup.py's darwin
+# branch at it and pin the deployment target to the runner's floor.
+environment = { LIBOMP_PREFIX = "/opt/homebrew/opt/libomp", MACOSX_DEPLOYMENT_TARGET = "14.0" }
+# Do NOT vendor libomp (`--exclude libomp`): leave the extension referencing
+# Homebrew's libomp by its absolute install-name
+# (/opt/homebrew/opt/libomp/lib/libomp.dylib). pynec-accel's macOS wheel excludes
+# it too, so when both load in one process they share ONE libomp image instead of
+# each loading a private copy. Two private copies is what triggered the OMP
+# "Error #15" duplicate-runtime abort + the join-barrier deadlock, forcing the
+# KMP_DUPLICATE_LIB_OK / OMP_NUM_THREADS=1 stopgap; one shared runtime keeps both
+# backends fully multithreaded with no env vars. This mirrors the Linux wheels,
+# where neither side vendors libgomp (glibc's is shared) — macOS has no system
+# libomp, so the shared copy is Homebrew's, hence `brew install libomp` is a
+# runtime requirement of the macOS wheel. DYLD_LIBRARY_PATH lets delocate resolve
+# the (now-external) libomp during repair.
+repair-wheel-command = "DYLD_LIBRARY_PATH=$(brew --prefix libomp)/lib delocate-wheel --exclude libomp --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
+
+[tool.ruff.lint]
+ignore = ["E741"]
+# Keep "imported but unused" as a warning instead of auto-stripping.
+# Without this, multi-pass edits (add imports first, then add code that
+# uses them) can have the import deleted between edits — by the editor's
+# format-on-save, the project's auto-fix hook, or a pre-commit run —
+# producing a broken next edit. Manual cleanup of unused imports is fine.
+unfixable = ["F401"]

momwire-0.2.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

momwire-0.2.3/setup.py

@@ -0,0 +1,150 @@
+import os
+import sys
+import warnings
+
+from setuptools import setup
+from setuptools.command.build_ext import build_ext
+from pybind11.setup_helpers import Pybind11Extension
+
+# Build-time error classes. setuptools.errors is the modern home (distutils is
+# removed in Python 3.12+); fall back to distutils for very old setuptools.
+try:
+    from setuptools.errors import CCompilerError, ExecError, PlatformError, FileError
+except ImportError:  # pragma: no cover - ancient setuptools
+    from distutils.errors import (  # type: ignore[no-redef]
+        CCompilerError,
+        DistutilsExecError as ExecError,
+        DistutilsPlatformError as PlatformError,
+        DistutilsFileError as FileError,
+    )
+
+# momwire._accelerators is an *optional* C++ speedup: every module that imports
+# it (triangular, _triangular_kernels, _bspline_kernels, bspline, hmatrix,
+# sinusoidal) guards the import with `try/except ImportError` and falls back to
+# a pure-Python/numpy path. So a platform with no working compiler / libmvec /
+# libomp (musllinux, glibc < 2.28, an arch outside the wheel matrix, or no
+# toolchain at all) should still get a usable install rather than a hard
+# `pip install` failure. This cmdclass makes a failed extension build a warning
+# instead of an error, leaving the package importable in pure-Python mode.
+#
+# This does NOT let a silently-degraded *wheel* ship: the cibuildwheel
+# test-command asserts `import momwire._accelerators` succeeds, so any CI wheel
+# that fails to compile the extension fails its tests. The graceful path is only
+# for source (sdist) installs on unsupported platforms.
+_OPTIONAL_BUILD_ERRORS = (
+    CCompilerError,
+    ExecError,
+    PlatformError,
+    FileError,  # inplace copy of an extension that never got built
+    FileNotFoundError,  # compiler binary absent
+)
+
+
+class OptionalBuildExt(build_ext):
+    def run(self):
+        try:
+            super().run()
+        except _OPTIONAL_BUILD_ERRORS as exc:
+            self._warn(exc)
+
+    def build_extension(self, ext):
+        try:
+            super().build_extension(ext)
+        except _OPTIONAL_BUILD_ERRORS as exc:
+            self._warn(exc)
+
+    @staticmethod
+    def _warn(exc):
+        warnings.warn(
+            f"momwire._accelerators C++ extension failed to build ({exc!r}); "
+            "installing in pure-Python mode. The solver will work but run "
+            "slower. Install a C++ toolchain (and on Linux, glibc>=2.28 with "
+            "libmvec) for the accelerated path.",
+            stacklevel=2,
+        )
+
+# The accelerator is built on all three platforms; the vectorization strategy
+# differs per platform. Linux/GCC binds the inner sincos to glibc's libmvec
+# (-lmvec) via the `omp declare simd` block in _accelerators.cpp; Windows/MSVC
+# has no libmvec, so it relies on /arch:AVX2 autovectorization plus OpenMP
+# parallelism; macOS Apple Silicon (arm64) has neither libmvec nor AVX2, so it
+# relies on Homebrew libomp for OpenMP parallelism and lets clang autovectorize
+# the inner loops for NEON. The .cpp guards the libmvec-specific declarations to
+# non-MSVC, non-Apple compilers. If the extension fails to build/import,
+# triangular.py falls back to pure Python.
+if sys.platform == "win32":
+    # OpenMP on MSVC is a minefield for this code: /openmp:experimental rejects
+    # unsigned loop indices (the kernels use size_t) and silently drops the
+    # `reduction` clause from `omp simd` (a correctness hazard), while
+    # /openmp:llvm rejects the `omp simd` directive outright. We use
+    # /openmp:llvm — it supports the OpenMP 3.0 `collapse` clause and unsigned
+    # loop indices, so the parallel-for loops need no changes — and the .cpp
+    # neutralizes the `omp simd` directives under _MSC_VER, leaving /arch:AVX2
+    # autovectorization to handle the inner loops. /arch:AVX2 matches the Linux
+    # AVX2 baseline.
+    extra_compile_args = ["/O2", "/arch:AVX2", "/openmp:llvm", "/fp:fast"]
+    extra_link_args = []
+elif sys.platform == "darwin":
+    # Apple clang ships no OpenMP runtime and macOS has no libmvec, so this
+    # branch is deliberately the "simple pragmas" port: Homebrew's libomp gives
+    # us the OpenMP parallel-for + omp-simd directives (passed through Apple
+    # clang via -Xpreprocessor -fopenmp), and clang autovectorizes the inner
+    # sincos for NEON on its own. No -mavx2/-mfma (arm64 has no AVX2) and no
+    # -lmvec (no vectorized libm on macOS); the libmvec `declare simd` block in
+    # _accelerators.cpp is #ifdef'd off under __APPLE__. delocate vendors the
+    # libomp dylib into the wheel (the -rpath below points the extension at it).
+    _libomp = os.environ.get("LIBOMP_PREFIX", "/opt/homebrew/opt/libomp")
+    extra_compile_args = [
+        "-O3",
+        "-Xpreprocessor",
+        "-fopenmp",
+        # Same errno rationale as the Linux branch: let the vectorizer run.
+        "-fno-math-errno",
+        "-std=gnu++11",
+        f"-I{os.path.join(_libomp, 'include')}",
+    ]
+    extra_link_args = [
+        f"-L{os.path.join(_libomp, 'lib')}",
+        "-lomp",
+        f"-Wl,-rpath,{os.path.join(_libomp, 'lib')}",
+    ]
+else:
+    extra_compile_args = [
+        # Force -O3 -- Debian's Python CFLAGS inject -O2 before our flags
+        # and pybind11's default -O3 doesn't override that. Our -O3 here
+        # comes after both and wins (gcc takes the last -O).
+        "-O3",
+        "-fopenmp",
+        "-fopenmp-simd",
+        # AVX2 + FMA: required for the SIMD inner-loop sincos in
+        # _accelerators.cpp to use libmvec (vectorized libm). KBL/HSW
+        # and newer Intel; matches what pybind11 release wheels can't
+        # assume but a local pip install -e . can.
+        "-mavx2",
+        "-mfma",
+        # `std::cos` / `std::sin` set errno on domain errors by default,
+        # which is a global side effect that blocks auto-vectorization.
+        # We don't care about errno from a deterministic-domain real input,
+        # so disable the side effect to let the vectorizer kick in.
+        "-fno-math-errno",
+        "-g",
+        "-fno-omit-frame-pointer",
+        "-std=gnu++11",
+    ]
+    extra_link_args = ["-fopenmp", "-lpthread", "-lmvec"]
+
+ext_modules = [
+    Pybind11Extension(
+        "momwire._accelerators",
+        ["src/momwire/_accelerators.cpp"],
+        extra_compile_args=extra_compile_args,
+        extra_link_args=extra_link_args,
+    ),
+]
+
+setup(
+    ext_modules=ext_modules,
+    cmdclass={"build_ext": OptionalBuildExt},
+    packages=["momwire"],
+    package_dir={"": "src/"},
+)

momwire-0.2.3/src/momwire/__init__.py

@@ -0,0 +1,17 @@
+from ._accel import LOADED as accelerated
+from .bspline import BSplineSolver
+from .hmatrix import HMatrixSolver
+from .array_block import ArrayBlockSolver
+from .sinusoidal import SinusoidalSolver
+from .triangular import TriangularSolver
+
+# `accelerated` is True iff the optional C++ accelerator loaded; consumers can
+# assert it to guard against a silent fall-back to the slow pure-Python path.
+__all__ = [
+    "TriangularSolver",
+    "SinusoidalSolver",
+    "BSplineSolver",
+    "HMatrixSolver",
+    "ArrayBlockSolver",
+    "accelerated",
+]