The Cost Boundary of Classical Solvers: When Physics-AI Surrogates Actually Pay Off in 2026

New
License: Original (DClaw) · Updated 2026-11-09
My rating

Why This Guide

"An FNO is a thousand times faster than CFD" is a measurement of one clock, not a cost conclusion. It says that a trained forward pass is cheap. It says nothing about the thousands of trusted solves that produced the training corpus, the GPU hours spent training and tuning, the verification work needed before anyone signs off, or the number of times the model will actually be queried. For a team that needs twelve high-fidelity runs, the surrogate may never repay its setup. For a design loop that needs twelve thousand, the same surrogate may save months of wall-clock time. The boundary between the two is arithmetic, and it can be computed before a single training job is launched.

This guide is written as a decision document. It assumes a physics problem, a compute budget, a trusted solver that can generate reference data, and a deliverable whose accuracy requirement is stated. The companion guide on neural operator selection decides whether a model fits the data contract; this one decides whether it fits the budget. The PINN landscape guide covers residual-based per-instance training, which has a different cost shape again.

The central claim is that cost and accuracy form a frontier, not a ranking. A 2026 reproducible benchmark by Huang and Stuart compared neural-operator surrogates with problem-matched classical solvers on Darcy flow, incompressible Navier-Stokes forecasting and vehicle aerodynamics, separating floating-point work from wall-clock runtime. Its conclusion is deliberately narrow: surrogates are most competitive at low-to-moderate accuracy requirements; as the target tolerance tightens, classical solvers win, and they remain necessary for verification and high-accuracy computation. That conclusion holds even in a regime the authors deliberately made favourable to the surrogate, with data acquisition and training treated as fully amortised.

Sections 1 to 3 build the four-ledger cost model and the three mechanisms that produce a speedup. Sections 4 and 5 explain what happens as tolerance tightens and give a reproducible break-even calculation with two published cases. Sections 6 to 8 cover hybrid deployment, the hidden costs of CAE delivery and how to report cost honestly. Section 9 links to resources on this site. Section 10 rules on conflicting public claims. Every number is attributed; single-study figures are labelled directional and carry their hardware and resolution context.

1. Four Ledgers, Not One Runtime

The first ledger is the classical solve itself. A single high-fidelity run includes geometry cleanup, meshing, discretisation, linear or nonlinear iterations, time stepping and post-processing. Its cost is paid on every query and scales with resolution, often superlinearly. In one 2026 cardiac valve study, the reported empirical scaling of the FEM cost with mesh size was about O(N^1.66), measured across two mesh resolutions and explicitly described by the authors as indicative rather than a precise complexity bound.

The second ledger is corpus generation. Every supervised operator needs input-output pairs, and the outputs come from the trusted solver. If one solve takes minutes and the corpus needs thousands of pairs, the data-generation bill can dominate the entire project. This ledger is frequently omitted from speedup claims because it happens before the timing starts. It also has a quality dimension: the corpus must cover the parameter range, the boundary condition types and the spectral richness the deployment will see, which usually means more solves than a naive sample count suggests.

The third ledger is training and tuning. Operator training wants accelerator hardware, and the selected configuration depends on the budget. A 2026 replication on The Well showed that a 12-hour per-run cap favours configurations that are cheap per step, and that extending the budget to 36 hours on one task changed both the selected hyperparameters and the attainable error by a factor of about 4.7, with the selected run completing 38 epochs instead of 17. A fixed wall-clock cap is not neutral with respect to model configuration. Tuning is therefore a cost line, not a free preliminary.

The fourth ledger is verification, guarding and maintenance. An operator needs acceptance tests, physical guards, a fallback path, a versioned corpus and periodic retraining when the operating regime drifts. In regulated workflows it also needs an auditable accuracy argument. These costs recur for as long as the model is in service. They are the reason a technically fast surrogate can still be the expensive choice in a certification-bound process.

A cost conclusion that reports only inference milliseconds has accounted for none of the last three ledgers. The useful quantity is the cumulative cost as a function of query count: a classical curve starting near zero with a steep slope, and a surrogate curve starting at the setup cost with a shallow slope. Where they cross is the break-even point.

2. The 2026 Cost-Accuracy Frontier

Huang and Stuart's study is the clearest anchor because it is reproducible and deliberately fair. The authors fix the post-training, many-query limit and compare per-query prediction error, floating-point cost and wall-clock runtime against problem-matched classical baselines. Code and workflow notes are public; timings were measured on Intel Xeon Platinum 8358 CPUs and NVIDIA A100 GPUs, and the authors state that runtime is hardware- and implementation-dependent. Three workloads carry the argument.

Darcy flow predicts a pressure field with mean relative L2 error against a finite-element geometric-multigrid baseline. At comparable low-to-moderate error, the neural operator is slightly faster than the baseline on CPUs and about an order of magnitude faster on GPUs. Geometric multigrid nevertheless uses substantially fewer floating-point operations and extends to smaller errors. The authors attribute the wall-clock result chiefly to dense tensor operations and FFTs that suit modern accelerators. Arithmetic efficiency and elapsed-time efficiency point in different directions on the same problem.

Vehicle aerodynamics predicts the surface pressure coefficient only. The surrogate does not output the full three-dimensional flow field, and it bypasses the outer nonlinear iteration and its associated linear solves. Across six test geometries, errors are measured against each geometry's large-mesh OpenFOAM reference with 7,000 iterations. This is a win produced by predicting less, not by solving the same equations faster. Any comparison that silently changes the output scope is comparing two different tasks.

Incompressible Navier-Stokes forecasting uses a Fourier pseudospectral discretisation with RK4 time integration as the classical baseline. The surrogate reduces the depth of sequential time stepping. This is a third and separate mechanism: removing an inherently serial loop. The authors' overall reading is that floating-point advantage depends strongly on problem structure, and that additional wall-clock speedups come from dense operations mapping well onto modern hardware.

The frontier has a shape. At loose tolerances and with high query counts, the surrogate curve sits below the classical curve. As the required error shrinks, reaching that error with an operator becomes increasingly hard while a classical solver has a refinement path: refine the mesh, tighten the tolerance, and the error falls in a way covered by convergence theory. The study therefore keeps classical solvers in the loop for verification and high-accuracy computation. This is a statement about the shape of the frontier, not a claim that either family is obsolete.

3. Three Acceleration Mechanisms and Their Boundaries

Mechanism one is avoiding temporal or nonlinear iterations. A trained operator produces a field or a quantity of interest in one forward pass; an implicit CFD solve may need hundreds of outer iterations, each with linear solves. The gain is real and largest when the baseline is iteration-heavy. Its boundary is the validity of the learned map: the surrogate has no per-instance residual check, so an input outside the training envelope still produces an answer quickly. The mechanism buys speed by removing the very loop that would have detected the problem.

Mechanism two is predicting a reduced quantity of interest. Surface pressure, lift and drag coefficients, maximum temperature or a scalar compliance can be modelled with an output head far smaller than a full field. The vehicle aerodynamics result belongs here. The boundary is that the deliverable must actually need only that quantity. If the same programme later needs wall shear, separation location or a full field for a thermal stress calculation, the reduced model does not extend to it and a new corpus is needed.

Mechanism three is hardware fit. Dense tensor operations, FFTs and batched inference map efficiently onto GPUs, while sparse iterative solves are often limited by memory bandwidth and communication. The Darcy result is the clean example: fewer floating-point operations in the multigrid baseline, shorter wall-clock time for the operator on an A100. The boundary is portability. A speedup measured on one accelerator, with one batch size and one implementation, does not transfer automatically to a CPU-only HPC queue or a different memory hierarchy. Report the hardware with the number.

A fourth, weaker mechanism is sometimes claimed: resolution transfer, where a model trained on a coarse grid is queried on a finer one. It can reduce the number of high-resolution training solves needed, and a 2026 heart-valve study reports a learned operator applied from 64 by 64 training grids to 256 by 256 simulations without retraining. The boundary is that this is a resolution-transfer result, not an accuracy guarantee at the finer scale; the reference must still be recomputed at the target resolution to know the error. The neural operator selection guide treats this distinction in detail.

4. What Changes When the Tolerance Tightens

A classical solver carries a convergence statement. Under the usual assumptions, refining the discretisation reduces the discretisation error, and a posteriori estimators or refinement studies give a per-instance handle on it. Verification and validation practice in CFD, going back to the work of Roache and of Oberkampf and Trucano, separates "are the equations solved correctly" from "are the right equations being solved". Mesh convergence studies, manufactured solutions and conservation checks are the everyday instruments of that discipline.

A trained operator carries a statistical statement: the error on a held-out sample from a stated distribution. It has no per-instance bound and no refinement path. Adding more modes or parameters may reduce held-out error, but there is no operation analogous to halving the mesh spacing that reliably buys a factor of accuracy on this particular input. A 2026 cardiac valve study reports that the learned operator's inference cost scales roughly as O(N^0.89) against about O(N^1.66) for FEM on the two resolutions tested, which is a favourable scaling for cost and at the same time a reminder that the learned model has no convergence knob.

This asymmetry is why the cost-accuracy frontier bends. At loose tolerance, the surrogate's approximation error is acceptable and its per-query cost wins. At tight tolerance, the surrogate needs more capacity, more data and more tuning, and may still not reach the target; the classical solver simply runs longer or on a finer mesh and reaches it. Huang and Stuart state this explicitly: classical solvers outperform surrogates in the high-accuracy regime and remain important for verification. For a deliverable with a hard numerical tolerance, the classical solver is the acceptance instrument even when a surrogate is used for screening.

There is a second, quieter effect. High-accuracy work usually needs the full field, conserved quantities and local extrema, which is exactly where relative L2 error under-reports. The Well reports VRMSE normalised by field variance, binned spectral error and per-field analysis, and notes significant degradation over long autoregressive rollouts. A screening surrogate can be excellent at ranking candidates and still be inadmissible as the final answer. Defining which role the model plays, screening versus sign-off, is a cost decision as much as a technical one.

5. A Reproducible Break-Even Calculation

Define N as the number of queries the workflow will make over the model's service life. Let C_s be the fully loaded cost of one trusted solve in the same units, covering preprocessing and the solve. Let C_data be the number of corpus samples times C_s, C_train the training and tuning cost, and C_maint the expected verification, guarding and retraining cost over the service life. Let C_q be the per-query inference cost including guards. The surrogate is cheaper when N times C_s exceeds C_data plus C_train plus C_maint plus N times C_q. The break-even query count is therefore the setup sum divided by the per-query saving: N* = (C_data + C_train + C_maint) / (C_s - C_q).

Three properties of this expression matter in practice. It is linear in the number of queries, so a wrong estimate of N moves the answer proportionally. It is sensitive to the denominator: if the trusted solve is already cheap on the available hardware, the saving per query is small and N* becomes large. And it assumes C_q includes the guards; if a fraction p of queries defer to the solver, the effective per-query cost is C_q + p times C_s and the break-even point moves out again.

Two published cases make the arithmetic concrete, with their limitations attached. A 2026 study on physics-conditioned neural operators for heart valve mechanics reports 12.29 GPU-hours of training and a mean inference time of 55.57 ms over 74,930 examples. On a fine mesh where FEM averaged 847.98 s per simulation, the break-even point was 52 FEM-equivalent simulations, under 0.1 percent of that test set. On a coarse mesh where FEM averaged 13.59 s, the break-even point was 3,258 simulations, under 1.3 percent of the coarse test set. The authors note that the scaling exponents come from only two mesh resolutions and are indicative. These are single-study, single-workload figures; they show how strongly the mesh cost changes the answer, not what another team's N* will be.

A second case is hybrid rather than substitutional. The NOWS work, published in Computer Methods in Applied Mechanics and Engineering in 2026, uses a trained operator only as an initial guess for conjugate gradient or GMRES. The discretisation and the solver are unchanged, so the convergence guarantees survive. The authors report up to 90 percent reduction in computational time across benchmarks, about tenfold speedup and roughly 90 percent fewer iterations on irregular-domain elasticity, and more than 70 percent fewer iterations with a threefold runtime improvement when a model trained on 64 by 64 grids is applied to 256 by 256 smoke simulations. Because the classical solver still runs to its own tolerance, this route does not need a break-even argument of the same kind: it purchases a shorter solve on every query, including the first.

The practical instruction is to compute N* from local measurements before training. If N* exceeds the plausible query count by a wide margin, the correct decision is to keep the solver. If N* is small, continue to the stress tests in the companion selection guide, because a model that repays its cost can still fail outside its training envelope.

6. Hybrid Deployment: Put the Surrogate Inside the Solver

The substitution model, where the operator replaces the solver, is the hardest deployment path: it inherits the full accuracy and auditability burden. The hybrid path keeps the governing computation in the loop and gives the learned model a narrower job. This is also where the literature on turbulence modelling points: Duraisamy, Iaccarino and Xiao argue that the weak link in classical turbulent-flow simulation is often the closure, the semi-empirical model standing in for unresolved scales, and that data-driven corrections attach most naturally there because the modelled quantity was never derived from first principles.

Warm starts are the cleanest hybrid. The operator produces an initial iterate; Krylov iterations then remove the large-scale error and enforce the discrete equations. NOWS demonstrates this across finite differences, finite elements, isogeometric analysis and finite volumes, with several preconditioners, and reports that the acceleration is solver-agnostic. The value is that the accuracy contract is unchanged: the same tolerance, the same convergence criterion, the same sign-off path.

A second hybrid family is solver-in-the-loop training, where a differentiable solver participates in the training loop so the learned correction is optimised for the effect it has on the eventual numerical solution. A third is correction of empirical components, such as turbulence closures or constitutive models, with the resolved dynamics left to the physics core. A fourth is adaptive fidelity: use the surrogate for screening, then escalate to a higher-fidelity solve when a goal-oriented error estimator or a physical guard exceeds a threshold. All four reduce the required trust in the surrogate.

Real-time CAE guidance makes the operational point explicit. If an operator supplies a warm start or a residual predictor, guard it with physics-based residuals and energy checks; if a predicted field violates a maximum principle or produces a negative stiffness artefact, fall back to a conservative initialisation and log the provenance. Goal-oriented error estimators, such as dual-weighted residuals, connect discretisation error to the quantity of interest and can drive progressive refinement. Publishing a delta-to-sign-off indicator lets a design team see which results are exploratory and which are certifiable.

The hybrid route also changes the cost ledger. There is still a corpus and a training cost, but the per-query saving is now a reduction in iterations, and the fourth ledger shrinks because the classical verification path remains intact. For certification-bound industries this is often the only shape that clears the audit requirement at all.

7. Hidden Costs in CAE Delivery

Geometry cleanup and meshing are frequently excluded from benchmark timings. Huang and Stuart state that their costs begin after discretisation and that geometric preprocessing and mesh generation are excluded. In an industrial workflow those steps can consume a large share of elapsed engineering time, and a surrogate trained on one mesh family does not remove them for a new geometry. Any local N* calculation should use the fully loaded C_s, including these steps.

Licensing, queueing and hardware heterogeneity matter. A published GPU speedup assumes the GPU is available. A team whose production runs are scheduled on a CPU cluster with a commercial solver licence faces a different denominator. Conversely, a team with idle accelerator capacity may find C_q far cheaper than the paper's figure. Report costs in the unit the organisation actually pays, whether GPU-hours, core-hours or licence-bound wall-clock slots.

Verification and validation remain a cost even when the surrogate is only a screening tool. The classical literature separates code verification from solution validation and from certification against requirements; a learned component adds distribution diagnostics, out-of-distribution stress tests and seed-variance reporting to that list. The Well baseline replication is a useful caution: an under-tuned baseline measured under a 12-hour cap was widely read as an architectural result, and a short tuning effort changed the picture on 15 of 17 tasks. Evaluation budgets belong in the project plan.

Model drift is the recurring cost that is easiest to forget. A change of material model, boundary condition family, operating regime or upstream CAD convention can move the inputs outside the training envelope with no visible warning. Versioning the corpus, the model and the reference solver together, plus a scheduled re-validation against fresh trusted solves, is cheaper than discovering the drift in a delivered result. Organisational cost counts too: an auditable response surface with known statistical properties can be easier to defend to a certification authority than a large operator network, and that difference has a price even when both meet the same numeric tolerance.

8. How to Report Cost Honestly

Separate floating-point work from wall-clock runtime, and attach the hardware, implementation, batch size and solver settings to both. The Darcy comparison shows why: fewer FLOPs in the classical baseline, shorter elapsed time for the surrogate on an accelerator. A single "times faster" number collapses two different claims into one and cannot be audited.

State the output scope next to the error. A surface pressure coefficient and a full three-dimensional field are different deliverables. State the accuracy regime: low-to-moderate or tight, with the actual tolerance. State the clock: inference only, or the full lifecycle. If training and data generation are amortised, say so explicitly and give the assumed query count.

Report the acceptance role. Screening, design-space exploration, real-time estimation and sign-off have different accuracy and auditability requirements. A model that is excellent for ranking ten thousand candidates can be inadmissible for the final certificate, and that is a legitimate and economical division of labour. Include the deferral rate: the fraction of queries that fall back to the trusted solver belongs in the per-query cost.

Finally, publish the negative result. If N* is larger than the expected query count, or if the stress matrix shows that the tolerance cannot be met at any reasonable model size, the correct conclusion is to keep the classical solver. A cost study that always ends with a deployment recommendation is a sales document, not an engineering one.

One more definition is easy to leave implicit: what counts as a query. A design iteration may call the surrogate dozens of times for a sensitivity sweep, while a sign-off analysis may include three mesh refinements and a recomputation. Changing the counting unit from forward calls to design iterations changes both N and N* and can reverse the conclusion. State the unit, the time window (a year, a project cycle or the model service life), and whether retries and deferred queries are included. Two otherwise rigorous cost studies can disagree purely because these definitions differ.

9. How This Guide Connects to the Site

This is the third guide in a three-part decision set. The PINN landscape guide covers residual-based training; the neural operator selection guide covers function-space contracts, architecture families and stress testing. Read that second guide before this one when the data contract is still unsettled, and return here once the query count and tolerance are known.

The classical baseline side is indexed in the numerics and solvers collection and the performance engineering collection. Concrete solver entries include OpenFOAM, FEniCS, PETSc, SU2 and JAX-CFD. The AMGX GPU linear solver case, the OpenFOAM multiphysics case and the SU2 aero optimisation case give a sense of what the per-query baseline includes. The physics simulation primer and physics-based deep learning cover the underlying numerical and hybrid concepts.

The surrogate side runs through the surrogate modelling and ROM collection, the neural operator collection, PhysicsNeMo and the NeuralOperator library. PDEBench and The Well paper are the benchmark anchors; the FNO paper and the PhysicsNeMo paper give the implementation lineage. Workloads worth reading for the cost argument include automotive aerodynamics, TCAD chip thermal, building energy surrogate and topology optimisation. Uncertainty quantification and Bayesian inversion, multiphysics coupling and PhiFlow cover the confidence and differentiable-solver side of hybrid deployment.

Read together, the three paths make the cost argument traceable: solver entries describe what C_s contains, benchmark entries bound the scale of C_data and C_train, and case entries show the real shape of N. The site keeps editorial conclusions in the guides collection and verifiable primary records in the resource collections exactly so that any cost claim can be traced back to a named solver, benchmark and workload. When a local measurement disagrees with a directional figure quoted here, the local measurement governs and should be written back into the team cost baseline.

Every term in the four ledgers can be traced to an openable entry: OpenFOAM explains which measurable quantities make up C_s, NeuralOperator documents the model and corpus conventions inside C_train, and the battery pack temperature case shows a concrete attempt to cut labelled simulations with a physics residual. These three entries are now bilingual long-form pages linked to the PINN landscape guide, the neural operator selection guide and this page. The break-even count N* must be filled with local measurements, and the case structure, version strings and hardware conventions recorded in those entries are exactly the inputs such measurements need.

10. DISCREPANCIES

1. Does a large inference speedup constitute a cost conclusion? Account A: benchmark posts quote orders-of-magnitude speedups as the decisive advantage. Account B: the figure measures one clock and omits corpus generation, training, tuning, guards and re-validation. Ruling: this guide uses a four-ledger cumulative cost and a break-even query count; raw speed ratios are reported only with the clock they measure. Source grade: technical blog versus peer-reviewed cost-accuracy study.

2. Do fewer floating-point operations imply shorter runtime? Account A: arithmetic cost is treated as the primary efficiency measure. Account B: in the Darcy benchmark of Huang and Stuart, finite-element geometric multigrid uses substantially fewer FLOPs and reaches smaller errors, while the neural operator is about an order of magnitude faster on GPUs because dense tensor operations suit the accelerator. Ruling: FLOPs and wall-clock time are reported separately with hardware attached. Source grade: reproducible benchmark with public code.

3. Do surrogates remain competitive at tight tolerances? Account A: strong low-to-moderate accuracy results are sometimes read as a general replacement claim. Account B: the same benchmark states that as the target accuracy is tightened, classical solvers outperform surrogates and remain necessary for verification and high-accuracy computation. Ruling: the substitution case is recorded for low-to-moderate accuracy with high query counts; tight-tolerance work keeps the classical solver as the acceptance instrument. Source grade: reproducible benchmark versus promotional framing.

4. Does hybrid deployment forfeit numerical convergence guarantees? Account A: introducing a learned component is assumed to remove the guarantees of the underlying discretisation. Account B: NOWS uses the operator only as an initial guess for CG or GMRES, leaving the discretisation, solver and convergence criterion intact, and reports reductions in iteration count and runtime of up to 90 percent. Ruling: substitutional and warm-start hybrids are treated as different contracts, with the latter retaining the classical convergence argument. Source grade: peer-reviewed journal article and preprint.

5. Can published break-even counts be reused directly? Account A: a 2026 cardiac valve study reports break-even after 52 FEM-equivalent simulations on a fine mesh and 3,258 on a coarse mesh, and these figures are tempting to quote as general thresholds. Account B: the numbers come from a single clinical workload, the scaling exponents are estimated from two mesh resolutions and labelled indicative, and the per-query cost depends on local hardware and preprocessing. Ruling: the formula in section 5 is the deliverable; published counts are directional examples that must be recomputed locally. Source grade: single-study preprint versus reproducible method.

References

  1. Huang D.Z., Stuart A.M., "Cost-Accuracy Trade-offs: Neural Operator vs Classical Numerical Solver", arXiv:2609.24021 (2026).
  2. Eshaghi M.S. et al., "NOWS: Neural Operator Warm Starts for Accelerating Iterative Solvers", Computer Methods in Applied Mechanics and Engineering 458 (2026) 118989; arXiv:2511.02481.
  3. "Real-time Generalizable Heart Valve Mechanics for Clinical Disease Assessment via a Physics-Conditioned Neural Operator", arXiv:2609.23826 (2026).
  4. Li Z. et al., "Fourier Neural Operator for Parametric Partial Differential Equations", ICLR 2021.
  5. Kovachki N. et al., "Neural Operator: Learning Maps Between Function Spaces", arXiv:2108.08481 (2021).
  6. Takamoto M. et al., "PDEBench: An Extensive Benchmark for Scientific Machine Learning", NeurIPS 2022 Datasets and Benchmarks Track.
  7. Ohana R. et al., "The Well: a Large-Scale Collection of Diverse Physics Simulations for Machine Learning", arXiv:2412.00568.
  8. "Performance of Neural Operator Baselines on 'The Well' Dataset", arXiv:2610.33967 (2026).
  9. "Diagnosing Failure Modes of Neural Operators Across Diverse PDE Families", arXiv:2601.11428 (2026).
  10. Duraisamy K., Iaccarino G., Xiao H., "Turbulence Modeling in the Age of Data", Annual Review of Fluid Mechanics 51 (2019) 357-377.
  11. Brandt A., "Multi-Level Adaptive Solutions to Boundary-Value Problems", Mathematics of Computation 31 (1977) 333-390.
  12. Oberkampf W.L., Trucano T.G., "Verification and validation in computational fluid dynamics", Progress in Aerospace Sciences 38 (2002) 209-272.
  13. Roache P.J., "Verification and Validation in Computational Science and Engineering", Hermosa Publishers (1998).
  14. Um K. et al., "Solver-in-the-Loop: Learning from Differentiable Physics to Interact with Iterative PDE-Solvers", NeurIPS 2020.
Disclaimer: This guide is original editorial content. All quantitative figures are attributed and directional; published break-even counts and speedups depend on hardware, implementation, mesh and workload, and do not replace a local measurement. Product names and framework versions change over time.
Tags: