Radia

Electromagnetic CAE you can operate through AI and MCP
Connect CAD, mesh control, field analysis, and result inspection on NGSolve, with Python, MCP, MATLAB, and Simulink interfaces.

_{Design for a field target: a stream-function active-shield demonstration. This comparison is for the illustrated coil configuration, not a universal shielding-performance claim.}

You set the analysis direction. AI helps operate the CAE tools.

Radia is an open-source electromagnetic CAE platform that an AI assistant can operate through MCP. Specify the analysis task and conditions; connected tools can prepare geometry, control meshing, execute supported calculations, and inspect results. This reduces the need to memorize each tool's commands and interaction sequences while keeping the model and results inspectable.

The distributions are independent within this monorepo:

The normal radia distribution excludes CUDA MEX, MATLAB, Simulink and LTspice integration payloads and dependencies. Install radia-gpu separately for those interfaces. External products are installed separately under their own licenses.

Start from supported CAD, mesh, or model data where available, instead of rebuilding every input. What transfers depends on the format and workflow; materials, sources, boundary conditions, and units still need to be checked. The user defines the physical assumptions, analysis plan, and acceptance criteria and evaluates the engineering conclusions. Radia's current positioning is AI-operable CAE, not autonomous design decision-making.

Radia is deliberately not another monolithic finite-element solver. It is built on NGSolve, which remains the numerical foundation for finite-element spaces, mappings, quadrature, weak forms, assembly, and field evaluation. Radia adds electromagnetic methods, open-boundary operators, application workflows, native kernels, and orchestration around that foundation.

Radia extends NGSolve; it does not compete with it.

Quick start | NGSolve from MATLAB | Capabilities | Simulink | MCP | Eqnedit64 | Documentation | Contributing

Find your next engineering workflow

Use the documentation to discover capabilities and inspect results. Carry out analysis through MCP, or through human–AI collaboration using Cubit and Simulink. The executable samples live in tests/ for small usage and contract examples, and validation_test/ for physics and application cases with numerical evidence.

Start here · Result gallery · Accuracy and validation

NGSolve from MATLAB

CPU execution belongs to radia through Python/pybind11/NGSolve. GPU execution belongs to radia-gpu through MATLAB mexcuda. CPU Radia MEX is unsupported. NGSolve owns FE assembly; the initial GPU kernel accepts assembled CSR operators and verifies the true residual.

MATLAB, Simulink and LTspice integration source, builds and distribution live in radia-gpu, within this monorepo. radia-mcp provides cross-package knowledge and operation. The independently released radia-optuna retains its own MATLAB optimization API and MEX.

The initial GPU alpha supports CSR Jacobi-PCG, its readable Simulink block and LTspice integration. Historical CPU MEX models are source-only until ported and validated. Poisson acceptance does not certify AMS, ICCG or HDiv-MMM. Deploy GPU artifacts to 100 and A100, never 102. A100 acceptance stays pending while unavailable.

Why Radia?

• Operate CAE through an AI assistant. Use MCP to invoke supported operations from a stated analysis task, reducing tool-specific command and UI memorization.
• Build on existing inputs. Reuse supported geometry, meshes and model data, with explicit checks on the physical information carried into the calculation.
• Connect geometry, mesh and analysis. Drive CAD operations through MCP and control the mesh through the connected meshing workflow before solving.
• Use optimization when you choose it. Run coil, material, geometry or other supported optimization workflows with user-defined objectives and constraints.
• Open boundaries are first-class. Combine analytical source fields, Kelvin and DtN techniques, volume and boundary integral methods, SIBC, and model reduction without automatically surrounding every problem with a large air mesh.
• AI and humans share the engineering contract. Python and MCP are the first-class AI surface; MATLAB and masked Simulink blocks are the production human surface; both produce inspectable artifacts rather than hidden GUI state.
• The numerical backend stays visible. NGSolve owns finite-element mathematics. Radia supplies the missing physical operator or coupling and keeps independent analytical or integral routes where they improve trust.
• Integration is a feature. build123d, Coreform Cubit, Netgen, Gmsh, LTspice, MATLAB, Simulink, NumPy, SciPy, MKL, HACApK, and proven sparse solvers are connected through explicit boundaries instead of reimplemented.
• Results carry evidence. Production runs write checked meshes, logs, machine-readable result metadata, and visualization artifacts. Executable samples in tests/ and validation_test/ show expected behavior; documentation notebooks introduce features through saved results.

What can you build?

Quick start

The current production wheel targets Windows x64, Python 3.12, and NGSolve/Netgen 6.2.2607.

python -m pip install --upgrade radia

Evaluate an analytical open-boundary magnetic field in SI units:

import numpy as np
import radia as rad

mu0 = 4.0 * np.pi * 1e-7
remanence_t = 1.2

magnet = rad.ObjRecMag(
    [0.0, 0.0, 0.0],
    [0.01, 0.01, 0.01],
    [0.0, 0.0, remanence_t / mu0],
)

b_t = rad.Fld(magnet, "b", [0.0, 0.0, 0.02])
print(f"Bz [T] = {b_t[2]:.8f}")
rad.UtiDelAll()

Bz [T] = 0.02356629

This first example needs no air mesh. Move to NGSolve when the problem needs finite-element spaces, material domains, weak forms, or coupled field equations.

Turn solved SI field samples into electromagnetic force and torque through Lorentz volume integration, air-side Maxwell stress, time-averaged complex phasors, virtual work/coenergy, or a cylindrical air-gap shear estimate:

from radia.force import integrate_lorentz_force

# One quadrature sample: J = 2 MA/m^2 in +z, B = 0.3 T in +y,
# with 2.5 cm^3 of physical volume. The force points in -x.
force_n = integrate_lorentz_force(
    [0.0, 0.0, 2.0e6],
    [0.0, 0.3, 0.0],
    2.5e-6,
)
print(force_n)  # [-1.5, 0.0, 0.0] N

Supplying quadrature positions and a pivot to integrate_lorentz_force_and_torque returns both resultants. The same contracts are available in MATLAB under radia.force, including integrateLorentzForceTorque, integrateTimeAverageMaxwellSurfaceForceTorque, virtualWorkForce, and coenergyTorque. The force and torque validation corpus records the Lorentz, Maxwell-stress, and virtual-work checks used to verify signs and force extraction before attaching them to a production field solve.

Install only the integrations you need:

# AI-facing domain tools and executable workflow knowledge
python -m pip install radia-mcp

# Coreform Cubit export and strict .vol checking
python -m pip install "radia[cubit]"
cubit-plugin-install
cubit-plugin-install --verify-only

# Optional accelerator tracking and topology-to-CAD workflows
python -m pip install "radia[beam]"
python -m pip install "radia[topopt-cad]"

See Installation for MATLAB/Simulink, visualization, and source-build paths.

Eqnedit64

Eqnedit64 is a portable Windows x64 equation editor and a browser edition maintained together in Radia. The native application connects fast structural input directly to UTF-8 TeX. Its structural canvas and live TeX pane are both editable, Tab traverses template slots, and the palette teaches the TeX spelling of inserted structures without a separate command-entry mode.

The single executable needs no installer, Python runtime, or file-type registration. Copy places equivalent TeX, editable Office Math, EMF, and opaque bitmap representations on the clipboard; Google Slides and headless TeX-to-PNG paths are included. Eqnedit64 is released independently from Radia: the Python/API distribution is on PyPI, and the matching signed standalone binary is published in the Eqnedit64 3.0.13 release. radia-mcp.presentation discovers that installation as an optional rendering and clipboard backend; neither package depends on the other at runtime. Legacy Eqnedit32/MTEF binaries and conversion sources are deliberately not part of the public component.

The laboratory homepage publishes the browser edition, while tools/eqnedit64/web remains its source of truth. Native and Web changes share the same TeX-learning and Office Math parity policy.

Architecture

flowchart TB
    AI["AI / LLM"] --> MCP["radia-mcp"]
    Human["Human engineer"] --> Simulink["MATLAB / Simulink"]
    Python["Python API"] --> Contract["DesignSpec + typed artifacts"]
    MCP --> Contract
    Simulink --> Contract

    Contract --> CAD["CAD and mesh<br/>build123d | Cubit | Netgen"]
    Contract --> Methods["Radia physical methods<br/>Hodograph | VIM | Eddy | PEEC | Stream Function"]
    CAD --> NGSolve["NGSolve / ngsolve.bem<br/>spaces | mappings | quadrature | assembly"]
    NGSolve <--> Methods

    Methods --> Native["C++ / pybind11 / standalone MEX<br/>HACApK | sparse solvers | reduced state"]
    Methods --> Results["Durable results<br/>result.json | run.log | .msh | notebooks"]
    Native --> Results
    Results --> Viz["WebGUI | Gmsh | plots | animation"]

The same engineering model can therefore be driven by an AI agent, a Python program, or a Simulink composition without making the user-facing interface the source of numerical truth.

Responsibility boundaries

Capabilities

Analytical and open-boundary magnetics

Radia retains the analytical magnetostatic strengths of the original Radia project: permanent magnets, coils, source fields, forces, energies, and field evaluation in open space. Around those sources, the current platform provides Kelvin transformations, exterior DtN formulations, infinite elements, equivalent sources, and integral formulations for problems where truncating a large air domain is undesirable.

Radia targets the magneto-quasi-static to Darwin regime. Its propagation kernels are Laplace kernels; frequency enters conductor physics through skin depth, impedance, and reduced dynamics. Radia is not a full-wave Helmholtz solver for radiation-dominated problems.

Clebsch-Hodograph design

Hodograph methods transform selected nonlinear magnetic-design problems into tractable design problems in a transformed coordinate space. The implementation supports flux-line and pole-face design, field-quality studies, end effects, and accelerator-magnet workflows.

• Clebsch-Hodograph documentation
• Result-bearing accelerator design notebooks

HDiv-VIM and magnetic materials

The HDiv Volume Integral Method uses NGSolve meshes and finite-element spaces while Radia supplies the magnetic charge-Gram and open-boundary interaction. The C++ HACApK path provides compressed operators for large repeated actions, and the Python surface stays compatible with NGSolve's field and space vocabulary.

This is Radia's forward path for soft magnetic materials, nonlinear magnetization, demagnetizing fields, topology-aware material design, and independent FEM/integral cross-checks.

• HDiv-VIM documentation
• Open-boundary method map

Eddy currents, SIBC, and ESIM

Radia combines high-order NGSolve HCurl discretizations with BEM-A, surface impedance, effective surface impedance, cohomology handling, and reduced models. The Eddyable concept packages response bases for repeated low-frequency solves while preserving the underlying field formulation.

• Eddy-current method guide
• ESIM formulation and usage
• Foster, PRIMA, and Modal-bulk SIBC models

Stream functions and coil topology

The stream-function layer solves inverse source problems for target magnetic fields, supports regularized ACA+ / TSVD compression, extracts current contours, and turns them into connected winding paths. It is used for planar, cylindrical, and free-form current sheets as well as field-shaping and coil optimization.

• Stream Function documentation
• Single-stroke winding policy and algorithms

PEEC, circuits, and model reduction

PEEC workflows cover partial inductance, resistance, proximity and skin effects, shield coupling, circuit assembly, and SPICE-compatible extraction. PRIMA, block Lanczos, Foster modal models, and universal relaxation networks provide reusable reduced models for circuit and transient studies.

The independent radia_gpu.ltspice package connects SPICE netlists, editable LTspice schematics, KiCad-derived circuits, RAW results, and sampled-data Simulink plants. Circuit conversion has one Python source of truth and exposes checked MATLAB adapters.

• PEEC integration
• SPICE and LTspice integration
• Universal relaxation networks

Optimization and geometry regeneration

Radia supports global, local, and gradient-based design loops:

• TPE, CMA-ES, GP, NSGA-II/III, QMC, and finite define-by-run search;
• MATLAB-native Optuna 5.0.0-oracled Study/Trial workflows, table-backed resume/replay, parameter importance, termination callbacks, automatic sampler routing, and live Pareto monitoring;
• analytic-adjoint MMA and SQP for continuous field optimization;
• HDiv-VIM and HCurl material topology;
• stream-function, sheet-metal, and electromagnet topology optimization;
• density/level-set to watertight STL and checked Cubit/Netgen mesh regeneration.

Optimization is tied to the same mesh, material, result, and provenance contracts as direct analysis. A new geometry is not accepted merely because an optimizer produced it.

Accelerator fields and particle trajectories

Radia's C++ core provides inspectable SI field sampling, relativistic Lorentz equations, RK4/Boris steps, fixed-step trajectories, and distributed R/T/U transfer attribution. It can also hand solved magnetic fields to CERN Xsuite for accelerator-coordinate tracking or use SciPy for adaptive trajectories, event handling, and closed-orbit workflows. Gmsh exports preserve trajectory quantities and can animate a beam through the solved field.

For high-order map analysis, NGSolve remains the source of truth for conforming HCurl/HDiv projection and curved finite-element evaluation. Radia adds a tracking-specialized CanonicalHCurl vacuum chain fitted from full-volume field samples, with adaptive fringe grading, periodic ring closure, and direct longitudinal-polynomial coupling to a nonautonomous fourth-order Lie-map integrator. Independent canonical A-map and projected B-map Runge--Kutta routes keep field-projection error separate from Lie truncation error.

• Executed particle-orbit notebook
• Native beam and transfer API design
• Canonical HCurl and Lie-map validation
• Gmsh post-processing guide

Interfaces

Python and MCP

Python is the complete programmable API. MCP makes the same platform discoverable and executable by AI agents.

The user chooses the analysis purpose, assumptions and success criteria. An AI assistant uses the available MCP tools to carry out the requested operations and return inspectable artifacts. Tool execution can be automated; responsibility for the analysis plan and engineering judgement remains with the user.

The radia-mcp package provides domain servers for Radia, NGSolve, Cubit, Gmsh, build123d, PEEC, induction heating, optimization, materials, electric machines, accelerator magnets, and supporting engineering knowledge. It is intentionally lightweight at import time: knowledge and contract tools can run without loading the full native Radia/NGSolve stack.

python -m pip install radia-mcp

Treat radia-mcp as the executable operating manual for agent-driven work. The top-level README explains the platform; MCP returns the current workflow, arguments, prerequisites, failure modes, and validation route for a concrete operation.

• MCP package and client setup
• Use each server's live tools/list response for the authoritative tool inventory; the checked radia_mcp.meta catalog supplies discovery metadata.

MATLAB and native MEX

Use the independently distributed radia-gpu. Its supported solver route is MATLAB mexcuda, with explicit transfer and numerical validation against Python CPU execution. Build on 100 with Build.ps1 -CudaMexOnly -RequireNativeProvenance.

MathWorks' official MATLAB MCP Server and Simulink Agentic Toolkit own generic MATLAB/Simulink operations; radia-mcp adds domain and distribution contracts.

Simulink

radia-gpu owns the readable CUDA PCG Level-2 S-Function, typed ports and lifecycle checks. Standalone numerical MEX remains independently callable. radia-optuna independently owns its optimization blocks. Historical library models remain in the owning package's source tree and require migration and validation before GPU release; they are not supported CPU MEX routes.

Documentation and visualization

docs/**/*.ipynb is the feature-introduction layer. Demonstrations are executed notebooks with narrative, code, saved results, and saved ngsolve.webgui.Draw or netgen.webgui.Draw scenes. They are not hidden production workbenches. Executable samples live in tests/ and validation_test/. Benchmarks and numerical evidence live under validation_test/ with machine-readable JSON; docs notebooks need no sidecar.

Field-producing application runs write checked Gmsh .msh v4.1 artifacts. The Gmsh toolchain supports scalar/vector/tensor fields, sections, clipping, isosurfaces, LIC, streamlines, file-series statistics, shared-camera comparisons, and particle-track animation. Geometry is shown at physical 1:1:1 axis scale unless an explicit display exaggeration is recorded.

Engineering contracts

Radia favors fail-loud, inspectable boundaries over convenient ambiguity.

For Cubit-to-NGSolve workflows, Cubit produces the mesh and Radia/NGSolve consumes it. The exporter does not infer material constants from labels; conductivity, permeability, BH data, frequency, and other physics remain explicit configuration.

Installation

Supported production stack

Python packages

This monorepo contains five independently versioned distributions. SPICE/LTspice integration ships inside radia; its extra only adds schemdraw support.

The separately verified radia-optuna wheel is also emitted as a CI artifact. Release-quad validates that exact candidate on four hosts; the dedicated release workflow publishes the verified artifact without rebuilding it.

Pin release versions together when reproducing a validated deployment. Release notes and immutable native/Simulink assets are published on the GitHub Releases page.

Build from source

git clone https://github.com/ksugahar/Radia.git
Set-Location Radia
python -m pip install -e ".[dev]"
python -m pip install -e packages/radia-mcp
python -m pip install -e packages/cubit-mesh-export
python -m pip install packages/eqnedit64
pwsh -NoProfile -ExecutionPolicy Bypass -File .\Build.ps1 -RadiaOnly

See BUILD.md for compiler, NGSolve, MKL, and packaging details.

Repository map

src/core/                       C++ Radia and native electromagnetic kernels
src/radia/                      Python package, NGSolve integration, methods
src/radia/ltspice/              SPICE, LTspice, KiCad, and circuit workflows
packages/radia-gpu/matlab/+radia/                  MATLAB API, MEX wrappers, Simulink builders
packages/radia-mcp/             MCP servers and executable domain knowledge
packages/cubit-mesh-export/     Cubit exporters, plugin, and check-vol
packages/radia-optuna/          Standalone MATLAB/Simulink Optuna package
packages/eqnedit64/             Windows Eqnedit64 Python/API distribution
tools/eqnedit64/                Canonical native and browser editor source
tests/                          Small executable samples and fast regressions
validation_test/                Physics/application samples and validation gates
docs/                           Feature introductions, saved results and theory
tools/                          Build, policy, release, and verification tools

Loose examples/ scripts are retired. New experiments begin outside the repository and are promoted only when they become a reusable API, focused test, validation problem, or result-bearing docs notebook.

Documentation

Start with the path closest to your task:

• Documentation index
• Python API reference
• Radia and NGSolve integration notebook
• Analytical electromagnetic formulas
• HDiv-VIM
• Clebsch-Hodograph
• Eddy-current methods
• Stream Function
• PEEC integration
• Induction heating
• Electric machines
• Magnetic levitation
• Gmsh post-processing
• MATLAB and Simulink
• MCP servers and tools
• Cubit mesh export

Contributing

Radia welcomes focused contributions to physical methods, NGSolve-native integration, independent validation, CAD/mesh boundaries, MATLAB/MEX parity, documentation, and application workflows.

# Run one focused regression while developing
python -m pytest -q tests/test_vim_eddy_hybrid.py

# Broaden only after the focused lane is green
python -m pytest -q tests

Fast regressions belong in tests/. Long numerical studies, convergence sweeps, and benchmark-quality checks belong in validation_test/. These two directories also provide executable samples. Feature introductions and saved demonstrations belong under docs/; operational workflows use MCP or human–AI collaboration through Cubit and Simulink.

• Read CONTRIBUTING.md before opening a pull request.
• Use the issue tracker for bugs and concrete feature requests.
• Report vulnerabilities through the private process in SECURITY.md.
• Include the smallest reproducible geometry/configuration and the generated result.json or checker report when reporting a numerical workflow issue.

If Radia is useful to your engineering or research, star the repository. It helps other electromagnetic developers discover the project and follow its progress.

Project status

Radia is an active research and engineering platform. The core analytical magnetostatics package is mature; newer VIM, Eddy, optimization, MATLAB/MEX, and Simulink families are developed behind explicit tests and release gates. Not every method has the same maturity or platform coverage, and unsupported paths are expected to fail loudly rather than select a weaker substitute.

Current priorities are:

1. strengthen HDiv-VIM, topology optimization, and scalable open-boundary operators;
2. complete robust Hodograph and accelerator-magnet design workflows;
3. deepen Eddy, SIBC/ESIM, PEEC, Foster reduction, and thermal coupling;
4. expand measured Python/MATLAB/MEX parity and native Simulink dynamics;
5. improve executed documentation, independent validation, and reproducible application artifacts.

Heritage, acknowledgements, and license

Radia originates from the magnetostatics work developed by Oleg Chubar, Pascal Elleaume, and collaborators at the European Synchrotron Radiation Facility. The current project extends that heritage with NGSolve integration, open-boundary engineering methods, high-order formulations, optimization, native MATLAB/Simulink interfaces, and AI-oriented automation.

We gratefully acknowledge Joachim Schöberl and the Netgen/NGSolve development team and community for the numerical foundation that makes these workflows possible. NGSolve provides the finite-element spaces, geometric mappings, quadrature, assembly, and field evaluation on which Radia builds its electromagnetic applications. Radia also integrates the HACApK H-matrix library, sparseSolv, Netgen, Gmsh, build123d, Coreform Cubit, and the broader Python/MATLAB scientific ecosystems.

The repository contains components under different compatible terms, including the BSD-style Radia core, MIT-licensed HACApK, MPL-2.0 sparseSolv integration, and redistributable runtime notices. See LICENSE for the complete terms.