radia-gpu 0.1.0__py3-none-win_amd64.whl

radia_gpu/LICENSE

@@ -0,0 +1,165 @@
+RADIA SOFTWARE LICENSE
+======================
+
+This software contains multiple components with different licenses:
+
+1. RADIA Core (BSD-style License)
+2. HACApK Library (MIT License)
+3. sparseSolv integration (Mozilla Public License 2.0)
+4. Intel Math Kernel Library runtime notices
+5. Radia SPICE/LTspice integration (MIT License)
+6. Eqnedit64 (BSD 2-Clause License with separately licensed assets)
+
+================================================================================
+PART 1: RADIA CORE
+================================================================================
+
+Copyright © 1997 - 2018, European Synchrotron Radiation Facility
+
+The RADIA software is distributed subject to the following license conditions:
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+DISCLAIMER: THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are
+those of the authors and should not be interpreted as representing official
+policies, either expressed or implied, of the RADIA project.
+
+================================================================================
+PART 2: HACApK (H-matrix Library)
+================================================================================
+
+Software Name : HACApK
+Version : 1.3.0
+Location: src/ext/HACApK/
+
+Copyright (c) 2015 Akihiro Ida and Takeshi Iwashita
+
+MIT License
+
+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.
+
+ppOpen-HPC project:
+  Open Source Infrastructure for Development and Execution of Large-Scale
+  Scientific Applications on Post-Peta-Scale Supercomputers with Automatic
+  Tuning (AT).
+
+Sponsorship:
+  Japan Science and Technology Agency (JST), Basic Research Programs: CREST,
+  Development of System Software Technologies for post-Peta Scale High
+  Performance Computing.
+
+================================================================================
+PART 3: sparseSolv integration
+================================================================================
+
+Location: src/ext/sparsesolv/
+
+The sparseSolv integration is licensed under the Mozilla Public License Version
+2.0. See src/ext/sparsesolv/LICENSE for the full license text.
+
+================================================================================
+PART 4: Intel Math Kernel Library (MKL) Runtime
+================================================================================
+
+This software distribution includes Intel Math Kernel Library (Intel MKL)
+runtime libraries for BLAS/LAPACK operations.
+
+Intel MKL License:
+The Intel MKL runtime libraries are redistributed under the terms of the
+Intel Simplified Software License (version August 2021) which allows
+redistribution of the software in binary form.
+
+Copyright (c) Intel Corporation. All rights reserved.
+
+The Intel MKL redistributable libraries included are:
+- mkl_rt.3.dll (or equivalent)
+- mkl_core.3.dll
+- mkl_intel_thread.3.dll
+- mkl_def.3.dll
+- mkl_avx2.3.dll
+
+Intel, the Intel logo, and Intel MKL are trademarks of Intel Corporation or
+its subsidiaries in the U.S. and/or other countries.
+
+================================================================================
+PART 5: RADIA SPICE/LTSPICE INTEGRATION
+================================================================================
+
+Location: src/radia/ltspice/
+
+Copyright (c) 2026 Mitsutoshi Sugahara
+
+MIT License
+
+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.
+
+For the full Intel Simplified Software License terms, please visit:
+https://www.intel.com/content/www/us/en/developer/articles/license/end-user-license-agreement.html
+
+================================================================================
+PART 6: EQNEDIT64
+================================================================================
+
+Location: tools/eqnedit64/
+
+Copyright (c) 2026 ksugahar
+
+Eqnedit64 is licensed under the BSD 2-Clause License. See
+tools/eqnedit64/LICENSE for the full license text.
+
+Redistributable font and icon assets retain their respective licenses. See
+tools/eqnedit64/assets/THIRD_PARTY_NOTICES.md and the license files beside
+those assets.
+
+================================================================================

radia_gpu/README.md

@@ -0,0 +1,137 @@
+# radia-gpu
+
+Independent GPU distribution from the Radia monorepo: MATLAB CUDA MEX
+kernels, readable Simulink blocks, and LTspice integration code.
+CPU electromagnetic execution belongs to `radia` (Python/pybind11/NGSolve).
+`radia-mcp` is the AI operation interface. Neither package is required merely
+to locate and use the installed GPU MATLAB files.
+
+Version 0.1.0 contains FP64 CUDA CSR Jacobi-PCG, a Simulink block for the same
+kernel, and the selected standalone LTspice workflow. It also contains experimental FP64 assembled-operator AMS and its versioned
+HDF5 exchange. This does not certify production AMS, ICCG, HDiv-MMM, or
+migration of the older CPU MEX application models.
+There is no CPU solver fallback.
+
+## Install
+
+```powershell
+python -m pip install radia-gpu
+radia-gpu-doctor --json
+radia-gpu-path
+```
+
+Add the reported directory to MATLAB's path. MATLAB R2026a, Parallel Computing
+Toolbox, an NVIDIA GPU and a compatible NVIDIA driver are external requirements.
+Python delivers and verifies the MATLAB payload; it does not execute GPU solves.
+The installed CUDA solvers do not require the Python `radia` or `ngsolve`
+packages. CSR-PCG consumes caller-provided matrix arrays; AMS consumes an
+already-built hierarchy. The current CPU hierarchy-generation route uses
+Radia/NGSolve in a separate preparation environment. Optional
+`radia-gpu[coupling]` installs Radia for workflows that explicitly need it.
+The Windows x64 binary contains sm_75/sm_80 code and compute_80 PTX.
+Develop and build `radia-gpu` on 100. Required release acceptance compares each
+published CUDA solver against Python/NGSolve on 100 (Quadro RTX 5000), and
+requires an independent review of the exact source. Record source/runtime
+versions, artifact hashes and machine-readable results. A100 validation and
+scaling are optional additional evidence, not publication requirements.
+Formal timing remains subject to the idle-mdx host policy; 100 timings are diagnostic. CPU-only mdx execution verifies
+the reference calculation, not CUDA execution. RTX 5000 installation acceptance
+does not certify A100 scaling.
+Cubit mesh export is tested separately on 100 and 102. NGSolve validation
+starts by checking and loading an exported `.vol` with its versioned label
+contract; it does not require Cubit on the NGSolve host.
+
+Deployment targets are 100 (build and RTX 5000 acceptance) and A100, excluding
+102. The 102 host tests `radia` and `radia-mcp` without installing `radia-gpu`.
+A100 is optional and never blocks development or publication. It is not always running: record its acceptance as pending while offline,
+then validate the same artifact hash when available. Do not treat an offline
+target as a successful test.
+
+Call `radia.gpu.csrPCG` with zero-based int32 CSR row pointers/columns and FP64
+GPU values, RHS and positive inverse diagonal for a symmetric positive-definite
+system. The caller owns FE assembly
+and the GPU arrays. The solver verifies the true residual and raises on invalid
+inputs, unsupported state, breakdown or nonconvergence.
+
+`radia.simulink.buildCudaPCGBlock` builds a typed Level-2 MATLAB S-Function
+block. Matrix upload occurs at Start; each RHS upload and solution download
+is explicit in the block. Simulink is optional for standalone MEX use.
+
+LTspice integration includes MATLAB `radia.ltspice`, Python
+`radia_gpu.ltspice`, and the selected sampled-data
+Simulink workflow. LTspice executes in its own installed runtime; it is not
+a GPU circuit solver. LTspice, MATLAB, Simulink, CUDA Toolkit and NVIDIA
+drivers are not redistributed. Install external products separately under
+their own licenses. This distribution includes Radia integration code only.
+
+## Build and release
+
+Build on 100 from a clean exact commit with `Build.ps1 -CudaMexOnly
+-RequireNativeProvenance` and `Build.ps1 -AmsCudaOnly
+-RequireNativeProvenance`, then run `python -m build --wheel` in this directory.
+mexcuda compilation and GPU execution never use NGSolve `TaskManager`.
+NGSolve preprocessing in this route does not use TaskManager. AMS setup may
+use CUDA or OpenMP when validated for the workload; compare numerical parity,
+transfer-inclusive timing and memory before selecting either backend. The
+current snapshot adapter uses a serial reference. CUDA kernels and cuBLAS
+provide GPU solve parallelism. Independent CPU Radia workflows retain their
+own threading policy.
+
+NGSolve's [device tutorial](https://docu.ngsolve.org/latest/i-tutorials/unit-5.5-cuda/poisson_cuda.html)
+uses `TaskManager` around `ngsolve.gpu` calls, but device operators are provided
+by `ngscuda`; [TaskManager itself](https://docu.ngsolve.org/latest/i-tutorials/appendix-taskmanager/taskmanager.html)
+manages host threads. Reconsider it for this route only with a demonstrated
+CUDA integration benefit and measured parity/performance, rather than assuming
+host parallel loops execute on the GPU.
+
+The wheel build requires the matching CUDA build receipt and binary hash.
+The independent CPU Radia reference follows its own Python threading policy.
+Canonical CUDA and MATLAB sources live in this package, under `native/` and
+`matlab/`. Packaging stages those sources; it does not read a root MATLAB tree.
+Use only the resulting verified wheel for deployment and PyPI publication.
+The initial alpha requires independent review before a stable release.
+
+`radia-gpu.yml` builds and accepts the installed wheel on the build host.
+`radia-gpu-release.yml` publishes that successful main CI artifact without
+rebuilding, requiring its exact SHA-256 and installed acceptance provenance.
+Stable versions additionally require the exact-source independent review and
+same-wheel 100 RTX 5000/CPU parity record described in
+[`validation_test/radia_gpu/releases`](../../validation_test/radia_gpu/releases/README.md).
+Configure PyPI Trusted Publishing for project `radia-gpu`, GitHub owner
+`ksugahar`, repository `Radia`, workflow `radia-gpu-release.yml`, environment
+`pypi`. A new project needs a pending publisher; checking availability does
+not reserve its name. Publish only the Windows wheel, not a source archive
+that would require an end user's proprietary build toolchain.
+
+GPU AMS is developed separately. HDiv-MMM is a subsequent evaluation target,
+after solver/preconditioner parity: preserve NGSolve's FE ownership and validate
+the electromagnetic formulation, nonlinear convergence and optimization outcome
+against the Python CPU route. Report transfer-inclusive timing and peak memory;
+neither successful PCG nor AMS alone certifies HDiv-MMM support.
+
+## Experimental AMS and large numeric exchange
+
+AMS CUDA and its snapshot adapter are package-owned native sources, built by
+`tools/build_ams_cuda.py` through the root build dispatcher. The CPU setup
+retains NGSolve and Radia ownership; the validation adapter is not installed
+as a CPU solver in this wheel. `radia.gpu.amsPCG` accepts a checked numeric
+hierarchy and RHS already uploaded to GPU memory, with no CPU fallback.
+
+All AMS file exchange uses `radia.ams-hdf5.v1` plain HDF5. Install optional
+`radia-gpu[exchange]` dependencies for the Python writer, and read the result
+with `radia.gpu.readAMSExchange`. Values stay FP64 and CSR indices stay
+zero-based int32. Shapes and array dimension order are explicit. HDF5 supports
+the project's >2 GB exchange requirement; it does not bypass int32 kernel
+capacity checks or the GPU working-memory budget. See
+[AMS validation](../../validation_test/ams_cuda/README.md) for numerical gates,
+transfer-inclusive timing and current limitations. Small-case A100 numerical
+and timing evidence is recorded in that validation; it does not certify
+A100 scaling or the exact artifact of a future release.
+
+Python circuit converters use `radia-ltspice`; install `radia-gpu[ltspice]`
+for the optional schemdraw route. MCP entry points, including
+`mcp-server-radia-ltspice`, belong to `radia-mcp` and load the GPU distribution
+only when circuit execution is requested. No circuit import alias is left in
+the CPU Radia distribution.
+
+The optional `coupling` extra requires Radia 5.3.1 or later with the CPU thermal-operator API. Existing Radia 5.3.0 wheels do not satisfy this contract; until that CPU release is available, use the standalone CUDA PCG, Simulink PCG and LTspice interfaces.

radia_gpu/__init__.py

@@ -0,0 +1,33 @@
+"""Locate and verify the independently installed MATLAB GPU payload."""
+from __future__ import annotations
+
+import hashlib
+import json
+from importlib.resources import files
+from pathlib import Path
+
+__version__ = "0.1.0"
+
+
+def matlab_path() -> Path:
+    """Return installed resources only; never borrow an editable solver tree."""
+    return Path(str(files(__package__).joinpath("matlab")))
+
+
+def verify() -> dict:
+    """Verify the installed payload without importing MATLAB, CUDA or Radia."""
+    root = Path(str(files(__package__)))
+    manifest_bytes = (root / "manifest.json").read_bytes()
+    manifest = json.loads(manifest_bytes)
+    if manifest.get("schema") != "radia.gpu.distribution.v1" or manifest.get("version") != __version__:
+        raise RuntimeError("Unsupported or mismatched radia-gpu manifest")
+    for relative, expected in manifest["files"].items():
+        path = (root / relative).resolve()
+        if not path.is_relative_to(root.resolve()) or not path.is_file():
+            raise RuntimeError(f"Missing or invalid payload path: {relative}")
+        if hashlib.sha256(path.read_bytes()).hexdigest() != expected:
+            raise RuntimeError(f"Payload hash mismatch: {relative}")
+    return dict(passed=True, runtime_checked=False, version=__version__, matlab_path=str(matlab_path()),
+                source_commit=manifest["source_commit"], capabilities=manifest["capabilities"],
+                manifest_sha256=hashlib.sha256(manifest_bytes).hexdigest(),
+                runtime_requirements=manifest["runtime_requirements"])

radia_gpu/ams-build.json

@@ -0,0 +1,9 @@
+{
+  "schema": "radia.ams-cuda-build.v1",
+  "source_commit": "babc16d4a7f7d27bb8ce078c1af370c2fe5d9fb4",
+  "source_dirty": false,
+  "matlab": "26.1.0.3346908 (R2026a) Update 5",
+  "no_cpu_solver_fallback": true,
+  "binary_sha256": "45f0d3b13e185663b6d20cca658c27ff12700907a9b9b0ae3f2aad6c555f8cdd",
+  "source_sha256": "e800d46affc628dc53d6c600189ba527e3a03933e6af9bc282aecca5e263dd8d"
+}

radia_gpu/ams_exchange.py

@@ -0,0 +1,101 @@
+"""Versioned plain-HDF5 numeric exchange for CPU-owned AMS snapshots.
+
+This is HDF5, not MATLAB's proprietary MAT v7.3 struct encoding. The matching
+MATLAB reader is radia.gpu.readAMSExchange. Arrays keep their NumPy shapes,
+FP64 values and zero-based int32 indices; the reader restores dimension order.
+All sizes use this format, including artifacts exceeding 2 GB.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+SCHEMA = "radia.ams-hdf5.v1"
+
+
+def write_exchange(path, payload):
+    """Write without collecting array data into a serialized in-memory blob."""
+    import h5py
+    import numpy as np
+
+    path = Path(path)
+    if path.suffix.lower() not in (".h5", ".hdf5"):
+        raise ValueError("AMS exchange requires an .h5 or .hdf5 file")
+    count = 0
+    numeric_bytes = 0
+    with h5py.File(path, "x") as handle:
+        arrays = handle.create_group("arrays")
+
+        def node(value):
+            nonlocal count, numeric_bytes
+            if isinstance(value, dict):
+                if any(not isinstance(k, str) or not k.isidentifier() for k in value):
+                    raise ValueError("Exchange fields must be valid identifiers")
+                return {"kind": "struct", "fields": {k: node(v) for k, v in value.items()}}
+            if isinstance(value, (list, tuple)):
+                return {"kind": "cell", "items": [node(v) for v in value]}
+            if isinstance(value, np.ndarray):
+                if value.dtype not in (np.dtype("float64"), np.dtype("int32"), np.dtype("uint8")) or not 1 <= value.ndim <= 2:
+                    raise ValueError("AMS exchange supports FP64/int32/uint8 vectors and matrices")
+                name = f"a{count:06d}"; count += 1
+                # h5py streams directly from contiguous native snapshot buffers.
+                # No compression, whole-payload copy, or MAT 2 GB length field.
+                arrays.create_dataset(name, data=value)
+                numeric_bytes += value.nbytes
+                return {"kind": "array", "path": "/arrays/" + name,
+                        "shape": list(value.shape), "dtype": value.dtype.name}
+            if isinstance(value, (bool, np.bool_)):
+                return {"kind": "logical", "value": bool(value)}
+            if isinstance(value, (int, float, np.integer, np.floating)):
+                return {"kind": "number", "value": float(value)}
+            if isinstance(value, str):
+                return {"kind": "string", "value": value}
+            raise TypeError(f"Unsupported exchange type: {type(value).__name__}")
+
+        manifest = {"schema": SCHEMA, "index_base": 0, "precision": "FP64",
+                    "array_order": "numpy", "units": "SI", "tree": node(payload)}
+        encoded = json.dumps(manifest, allow_nan=False, separators=(",", ":")).encode("utf-8")
+        handle.create_dataset("manifest", data=np.frombuffer(encoded, dtype=np.uint8))
+    return {"schema": SCHEMA, "format": "HDF5", "numeric_bytes": numeric_bytes,
+            "file_bytes": path.stat().st_size, "arrays": count}
+
+
+def read_exchange(path):
+    """Read the same schema for diagnostics and paired timing input identity."""
+    import h5py
+    import numpy as np
+
+    with h5py.File(path, "r") as handle:
+        manifest = json.loads(handle["manifest"][...].tobytes().decode("utf-8"))
+        if (manifest.get("schema") != SCHEMA or manifest.get("index_base") != 0
+                or manifest.get("precision") != "FP64" or manifest.get("array_order") != "numpy"):
+            raise ValueError("Unsupported AMS HDF5 exchange contract")
+
+        def node(spec):
+            kind = spec["kind"]
+            if kind == "struct":
+                return {k: node(v) for k, v in spec["fields"].items()}
+            if kind == "cell":
+                return [node(v) for v in spec["items"]]
+            if kind == "array":
+                name = spec["path"]
+                if not name.startswith("/arrays/a") or not name[9:].isdigit():
+                    raise ValueError("Invalid AMS dataset path")
+                dataset = handle[name]
+                if list(dataset.shape) != spec["shape"] or dataset.dtype != np.dtype(spec["dtype"]):
+                    raise ValueError("AMS dataset shape/type mismatch")
+                return dataset[...]
+            if kind in ("number", "logical", "string"):
+                return spec["value"]
+            raise ValueError("Unsupported AMS HDF5 node")
+        return node(manifest["tree"])
+
+
+def file_sha256(path):
+    """Hash even multi-GB inputs using bounded memory."""
+    import hashlib
+    digest = hashlib.sha256()
+    with open(path, "rb") as handle:
+        for block in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()

radia_gpu/build.json

@@ -0,0 +1,15 @@
+{
+  "schema": "radia.cuda-mex-build.v1",
+  "source_commit": "babc16d4a7f7d27bb8ce078c1af370c2fe5d9fb4",
+  "source_dirty": false,
+  "source_sha256": "63cb771b2f998a0a02b22048a36fce7295d96e0b5181c7913fc0fdbd5c29d29d",
+  "binary_sha256": "57476f482bdacc9568de413cef405bd52e2ade5d513ff696944dd405c89f27ec",
+  "matlab": "26.1.0.3346908 (R2026a) Update 5",
+  "release": "2026a",
+  "no_cpu_solver_fallback": true,
+  "cuda_targets": [
+    "sm_75",
+    "sm_80",
+    "compute_80 PTX"
+  ]
+}

radia_gpu/cli.py

@@ -0,0 +1,16 @@
+"""Small installation utilities; numerical execution stays in mexcuda."""
+import argparse
+import json
+from . import matlab_path, verify
+
+
+def path_main():
+    print(matlab_path())
+
+
+def doctor_main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--json", action="store_true")
+    options = parser.parse_args()
+    report = verify()
+    print(json.dumps(report, indent=2) if options.json else f"radia-gpu {report['version']}: payload verified")

radia_gpu/ltspice/LICENSE

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

radia_gpu/ltspice/__init__.py

@@ -0,0 +1,82 @@
+"""Radia's circuit-aware SPICE and LTspice integration.
+
+``radia_gpu.ltspice`` is the canonical Python namespace. Circuit integration
+is distributed independently from the CPU Radia solver.
+
+Public API
+----------
+- netlist_to_schemdraw(netlist, name) -> str
+- schemdraw_to_netlist(script, title) -> str
+- netlist_to_asc(netlist) -> str
+- asc_to_netlist(asc_text, use_ltspice=None) -> str   # None = auto (LTspice if installed)
+- topology_signature(netlist) -> str            (node-rename-invariant)
+- topology_equivalent(netlist_a, netlist_b) -> (bool, info)
+- circuit_knowledge(topic) -> dict
+- buck_seed(vin_v, vout_v, iout_a, fsw_hz=...) -> BuckSeed
+- patentability_search_plan(title, features, effects, domains) -> dict
+- summarize_measure_log(log_text) -> dict
+- summarize_stepped_measure_log(log_text) -> dict
+
+CLI / MCP server
+----------------
+- radia-ltspice                    (conversion and inspection CLI)
+- mcp-server-radia-ltspice         (FastMCP stdio server)
+"""
+from __future__ import annotations
+
+from .conversion import (
+    netlist_to_schemdraw,
+    schemdraw_to_netlist,
+    netlist_to_asc,
+    asc_to_netlist,
+)
+from .topology import topology_signature, topology_equivalent
+from .knowledge import circuit_knowledge, buck_seed, BuckSeed
+from .patentability import patentability_search_plan
+from .measure import (
+    parse_ltspice_measure_lines,
+    parse_ltspice_stepped_measure_tables,
+    parse_ltspice_step_lines,
+    parse_spice_scalar,
+    summarize_measure_log,
+    summarize_stepped_measure_log,
+)
+from .voltage_multiplier_gate import cockcroft_walton_stage_gate
+from .monte_carlo_gate import monte_carlo_tolerance_family_gate
+from .bipolar_efficiency_gate import bipolar_converter_efficiency_gate
+from .bipolar_rail_gate import bipolar_rail_power_quality_gate
+from .series_rlc_gate import series_rlc_complex_impedance_gate
+from .noise_gate import rc_thermal_noise_psd_gate
+from .three_phase_delta_gate import balanced_three_phase_delta_rl_gate
+from .ideal_transformer_gate import ideal_transformer_identity_gate
+from .ltspice_v44_gates import validate_ltspice_v44_public_identity
+
+__all__ = [
+    "netlist_to_schemdraw",
+    "schemdraw_to_netlist",
+    "netlist_to_asc",
+    "asc_to_netlist",
+    "topology_signature",
+    "topology_equivalent",
+    "circuit_knowledge",
+    "buck_seed",
+    "BuckSeed",
+    "patentability_search_plan",
+    "parse_spice_scalar",
+    "parse_ltspice_measure_lines",
+    "parse_ltspice_stepped_measure_tables",
+    "parse_ltspice_step_lines",
+    "summarize_measure_log",
+    "summarize_stepped_measure_log",
+    "cockcroft_walton_stage_gate",
+    "monte_carlo_tolerance_family_gate",
+    "bipolar_converter_efficiency_gate",
+    "bipolar_rail_power_quality_gate",
+    "series_rlc_complex_impedance_gate",
+    "rc_thermal_noise_psd_gate",
+    "balanced_three_phase_delta_rl_gate",
+    "ideal_transformer_identity_gate",
+    "validate_ltspice_v44_public_identity",
+]
+
+from radia_gpu import __version__

radia_gpu/ltspice/_artifact_identity.py

@@ -0,0 +1,21 @@
+"""Shared artifact provenance predicates, independent of numbered gate APIs."""
+from collections.abc import Mapping
+
+
+def digest_is_sha256(value: object) -> bool:
+    """Require a hexadecimal string; accept either letter case."""
+    if not isinstance(value, str):
+        return False
+    text = value.lower()
+    return len(text) == 64 and all(char in "0123456789abcdef" for char in text)
+
+
+def legacy_digest_is_sha256(value: object) -> bool:
+    """Preserve v43/v44 string coercion without weakening later contracts."""
+    return digest_is_sha256(str(value or ""))
+
+
+def same_generation(contract: Mapping[str, object], *names: str) -> bool:
+    """Require every named field to equal the nonempty generation identifier."""
+    generation = str(contract.get("generation_id") or "")
+    return bool(generation) and all(contract.get(name) == generation for name in names)