GPU finite-element analysis · self-serve · v2.5.0

GPU motor FEM you run yourself, with a validation card on every number that says how far it was checked.

cufemlab is a self-serve GPU finite-element service for permanent-magnet machines. Sign in and run 2-D magnetostatic workflows in the browser — the flagship is moving-band cogging torque, and every cogging result ships with an independent cross-check against the open-source FEMM and GetDP solvers, so a number is never just “it ran.” Operating-torque and iron-loss estimates, signed reports, artifacts and an API/SDK are in the same app.

Moving-band cogging cross-checked against the open-source FEMM & GetDP solvers — a per-run validation card on every result.
cogging_torque_movingband · RTX 5090PASS
Cogging amplitude0.04807 Nm
Cogging period30 deg
Independent cross-checkFEMM / GetDP see Validation
Mesh convergenceladder + ripple gate
GPU solve~2.1 s · float64
Flagship moving-band (Arkkio) reference run · 4-pole / 12-slot, 2 mm airgap · deterministic, HMAC-signed evidence pack
self-serve
run it yourself in the browser at /app
3 solvers
cross-check every cogging result (cufem · FEMM · GetDP)
per-run
validation card on each result, stating how far it was checked
float64
GPU FEM on RTX 5090 (sm_120)
The product

What you can run today, in the app

The live app at /app is self-serve: sign in, pick a workflow, submit, and watch it run to a result with a downloadable signed report and artifacts. The cross-checked validated reference is moving-band cogging torque. Operating-torque and iron-loss are honest engineering estimates — available in the app, but not the cross-checked reference and not third-party-certified. Nothing here is a placeholder.

cogging_torque_movingband

Moving-band cogging torque (flagship · validated)

Convergence-grade cogging torque via a moving-band (Arkkio) airgap, with a mesh-convergence ladder and ripple gate. Cross-checked against the open-source FEMM and GetDP solvers with a per-run validation card.

~0.048 Nm · cross-checked vs FEMM/GetDP · GPU
pmsm_operating_torque

PMSM operating-point torque (estimate)

Steady-state torque at a chosen operating point, on the GPU. An engineering estimate with a mesh-convergence check — available in the app; it is not the cross-checked validated reference.

operating-point estimate · GPU
iron_loss_estimate

Iron-loss estimate (estimate)

Approximate iron-loss from a reference field, split by region (rotor / stator tooth / yoke). An estimate for a given electrical-steel grade — not a certified core-loss figure and not a hysteresis/eddy mechanism split.

estimate · CPU
signed_report_generation

Signed evidence report

A deterministic report for a completed analysis — inputs, mesh, verdict, cross-check and provenance, with SHA-256 tamper-evidence (integrity hash, not a PKI signature).

reproducible · audit-ready
material_comparison · demo

Material comparison & quick check

Side-by-side comparison of cited material profiles, plus a free quick-check smoke run to confirm your geometry and the pipeline. Free-trial-eligible.

free-eligible · fast
cogging_sweep_2d

2-D cogging sweep (legacy)

Legacy / superseded. An earlier 2-D angle-sweep cogging path, kept for continuity. Use moving-band cogging above for the convergence-grade, cross-checked result.

legacy · superseded by moving-band

Also in the app: the result.v1 envelope with a validation card, authenticated report / artifact downloads, an API-key lifecycle, the Python cufemlab_client SDK, and GPU Jupyter notebooks. A dedicated 3-D field validation & geometry pipeline (cufem3d) handles geometry, meshing and magnetic field/flux — see the 3-D lane. Full 3-D torque, skew and end-effects are roadmap.

New (2026-07-11): thermal, core-loss & a neural surrogate. Six new GPU/CPU analysis types are live — steady & transient thermal conduction, eddy→thermal and core-loss→thermal coupling, Bertotti core-loss, and an experimental field-to-field neural surrogate. The five physics types are validated internally (MMS / energy-balance / cited coefficients) with no external passport yet; the neural surrogate is an in-distribution self-validating demo, not a general-purpose operator, and does not accept arbitrary custom fields. See the docs and the feature matrix.

3-D lane

3D field validation and geometry pipeline

Cufemlab includes a 3D validation lane for geometry handling, meshing and magnetic field/flux evaluation. It supports the engineering path toward full 3D motor simulation while keeping production-grade 3D torque, skew and end-effects as roadmap extensions.

New: GPU-accelerated 3-D field analysis is available on compatible GPU workers. Runtime metadata reports the actual execution backend and fallback state. It ships as its own analysis type (cufem3d_gpu_field_analysis, experimental) alongside the existing CPU 3-D field-validation utility, and it is not an independently validated 3-D torque prediction. See the feature matrix.

geometry / mesh

Geometry & mesh ready

GPU-first 3-D geometry import, meshing and rotor-sweep for a PM machine — the geometry pipeline that feeds a 3-D field solve.

CAD/STEP · mesh
field / flux

3D field / flux evidence

3-D magnetostatic field and flux-density evaluation with VTU field output you can inspect — the validated 3-D field lane.

field/flux · VTU
roadmap

3D torque — roadmap

Production-grade 3-D torque, skew and end-effects are roadmap extensions on the same geometry/field pipeline, built on validated foundations.

3D torque roadmap
Validation

Moving-band cogging is cross-checked against the open-source FEMM and GetDP solvers on every run; the legacy sweep is not

The headline cogging discrepancy this workflow was built to resolve was settled by running independent finite-element codes that share no source. We publish the agreement, and we publish our negatives.

Validated reference (the one canonical fact): On the frozen 4-pole/12-slot, 2 mm-airgap PMSM reference, cufem 2-D moving-band matched GetDP at −0.64% amplitude full-gap with waveform Pearson r=0.9941, and FEMM at +5.30% amplitude-only, inside pre-declared ±20% amplitude and r≥0.95 thresholds.

Quantitycufem 2-D (GPU)Open-source referenceAgreementMethod
Cogging amplitude (full-gap)0.04804 NmGetDP 0.0483 Nm−0.64%2-D magnetostatic, Arkkio
Cogging waveform (vs GetDP)31-pt sweepGetDP per-angler=0.9941periodic resample, Pearson
Cogging amplitude (vs FEMM)0.04991 NmFEMM 0.0474 Nm+5.30%amplitude-only
Product benchmark suite290 / 290cited closed-formsPASS18 suites · 6 GPU
We publish our negatives. The same pre-declared ±20% bar that validates the moving-band cogging path was applied to a first 3-D (2.5-D) torque attempt — and it did not pass; that result is recorded openly as a FAIL, not hidden. Operating-torque and iron-loss in the app are estimates, not this cross-checked reference. Commercial tools (ANSYS Maxwell / JMAG / COMSOL) have not been measured — no speed or accuracy comparison is claimed; a fair protocol is available on request.
Scope

What it is — and what it is not

cufemlab is a focused 2-D motor pre-analysis service, not a general multiphysics suite. We state the boundary plainly; if any page contradicts this, treat it as a bug.

Live in the app (self-serve)

  • Moving-band cogging torque — cross-checked, validated reference
  • PMSM operating-point torque — estimate
  • Iron-loss estimate; material comparison; quick check
  • Signed reports, artifacts, result.v1, API-key + SDK, GPU Jupyter
  • Thermal conduction (steady/transient), eddy→thermal & core-loss→thermal coupling, core-loss — internally validated (external passport pending)
  • Field-to-field neural surrogate — experimental, in-distribution

Available with stated limits

  • Operating-torque / iron-loss are estimates, not the cross-checked reference
  • Legacy 2-D cogging sweep — superseded by moving-band
  • 3-D field validation & geometry/mesh pipeline (cufem3d); full 3-D torque is roadmap
  • Paid credits are in beta — not marketed as production billing

Roadmap / not claimed

  • Full production 3-D torque, end-effects, skew — roadmap
  • Time-harmonic & transient eddy currents, conductive regions — roadmap
  • External validation passports for the new thermal/core-loss types; general-purpose neural operator with custom-field input — R&D
  • Not a drop-in replacement for ANSYS Maxwell / COMSOL / JMAG

What we do not claim. The new thermal, core-loss and coupling types are validated internally (MMS / energy-balance / cited coefficients) but carry no external validation passport yet; the neural surrogate is an in-distribution self-validating demo, not a general-purpose operator, and does not accept arbitrary custom fields. We do not claim validated production 3-D torque, externally-certified iron/core-loss, standalone eddy-current as a customer API type, or any measured speed/accuracy advantage over a commercial tool (none has been benchmarked). Two things are cross-checked against an external reference: the 2-D moving-band cogging workflow, against the open-source FEMM and GetDP solvers, and CPU 3-D field validation, against an analytic sphere; operating-torque and iron-loss are engineering estimates. The app is self-serve at /app; an assisted pilot is also available if you want us to run a scoped case for you.

How it works

Run it yourself in the app — or send us a scoped case

Sign in at /app, create a project, pick a workflow, submit, and the job runs to a result with a signed report and downloadable artifacts. Prefer we run it for you? An assisted pilot is available. The same real cufem GPU engine below powers both.

self-serve · Python SDK against the live APIPython
from cufemlab_client import Client
client = Client.from_env()                  # CUFEMLAB_API_KEY + base URL
proj = client.create_project("cogging study")
job  = client.analyze(
    project_id=proj.id,
    analysis_type="cogging_torque_movingband",
    input_file_ids=[fid],
)
job.wait()                                  # poll to terminal
res = job.result()                          # result.v1 + validation card
job.report_pdf("report.pdf")              # signed report
engine — the real cufem GPU solverPython
import cufem, math
m = cufem.Mesh(cufem.ElementType.TRIANGLE3, n_nodes, n_elems)
# m.set_node(id,x,y); m.set_element(id,[a,b,c],region_tag)

prob = cufem.MagnetostaticProblem(m)
mag = cufem.MagnetostaticRegion(); mag.mu_r = 1.05
mag.M_x = Br/(4e-7*math.pi*1.05)        # remanence → M
prob.set_region_material(4, mag)
prob.add_dirichlet_nodes(boundary, 0.0)

res = prob.solve()                          # GPU solve
print(res.converged, res.bmax(), res.total_time_ms)

Full reference: the cufemlab_client SDK, the real cufem classes, the result.v1 envelope and the validation-card schema — in the documentation. To start, open the app or request an assisted pilot.

Research & method validation

A separate 24-phase V&V program backs the methods

Distinct from the shipped workflows above, cufemlab maintains an internal scientific verification & validation program — 24 lettered phases (A–X) of cited closed-form and benchmark checks that validate the underlying numerical methods against the published literature. It is method validation, not a list of product features.

Coverage

290 / 290

Product-benchmark checks PASS across 18 test suites, from a dated run; 0 FAIL. The broader 24-phase research roadmap is tracked separately — its totals were withdrawn as unsourced, not hidden.

Discipline

Benchmark-as-truth

Each check cites a published reference (Jackson, Stoll 1974, Bertotti…), a tolerance and a measured error. No reference, no PASS.

Recent

CAD, surrogates, dipole

Phase U (CAD/geometry) and S (ML surrogate) completed via gmsh/OpenCASCADE and torch FNO/DeepONet on the RTX 5090; the 3-D magnetic dipole re-derived with an axisymmetric solver.

See the full 24-phase roadmap →

There is one figure, and it is sourced: 290 / 290 checks PASS across 18 test suites, from a dated verification run. A second, broader research V&V total used to appear here and on the roadmap, in two versions that contradicted each other and could not be traced to a source. It has been withdrawn — an unsourced number is not evidence.

Access

Open the app — self-serve, with a pilot option

The app is live and self-serve at /app: create an account, get free-trial credits and run the free-eligible workflows immediately. Paid credits are in beta (not yet production billing). Prefer a guided evaluation, an on-prem deployment, or validation against your bench data? Talk to us.

Self-serve app
Free trial
  • Create an account at /app
  • Run free-eligible workflows (demo, material, cogging sweep)
  • Result.v1, validation card, signed report, artifacts
  • API key + Python SDK
Assisted pilot
Talk to us
  • Scoped 2-D pilot on your geometry
  • Independent FEMM/GetDP cross-check
  • Pre-declared success criteria
  • Signed evidence pack you keep
On-prem / design-partner
Talk to us
  • Deploy on your GPU box
  • Custom 2-D motor workflows
  • Validation against your bench data
  • Direct engineering support

Open the app   Request an assisted pilot