No pages match that search.
Product / TensorLynx / Full-field ROM
Learn · Full-field reduced-order prediction
A scalar surrogate says the pressure drop went down. It cannot say the separation moved or the peak stress migrated to the fillet, so every promising design waits for a full solve before anyone sees its field. The TensorLynx platform learns the whole field from designs you have already solved, and every prediction arrives with its error map, a baseline it had to beat, and a refusal when it cannot.
Scored on held-out designs, near-twins held out together Refused wherever a simpler baseline scores lower Declines outside its trained range and names the input
The cost of the old way
Design studies end in scalars: pressure loss, peak stress, mass. Scalars rank designs, but judgement lives in the field: where separation sits, which fillet carries the load, how evenly a manifold feeds its branches. Two designs can share a scalar and fail in different places.
So teams open fields only for the few designs they could afford to solve. Field predictors promise to close that gap, and industry is rightly cautious. In a 2026 NAFEMS × Teratec consultation, 47 % of respondents named trust and validation of results as a barrier Survey · source 1. In a 2026 survey of 350 engineering leaders, 92 % had deployed surrogate models, but only 8 % extensively Survey · source 2.
A field prediction that cannot show its own error is a picture, not evidence. The question is not “can a model draw a field?” but “where, and by how much, is this field wrong?”
How TensorLynx does it
The method is the one model reduction has refined for decades: proper orthogonal decomposition of solved snapshots, then a regression from design parameters to mode coefficients. TensorLynx wraps it in a workflow that scores and gates every field before it is offered.
Each converged evaluation contributes its whole field on a shared mesh, with run, study fingerprint, solver settings and units attached. Failed and unconverged evaluations stay in the corpus, labelled unusable with their reason, never used to train.
The snapshots are centred and decomposed. The rank is the smallest that keeps 99.9 % of the snapshot energy Method, capped at n − 1 and at 32 modes. The energy left out enters the model’s band.
A Gaussian process maps design parameters to each mode’s coefficient. The kernel, Matérn 5/2, Matérn 3/2 or squared exponential, is chosen by the closed-form leave-one-out residual over the whole field, never left at a default.
Predicted coefficients rebuild the full field: the mean plus weighted modes, every node, every quantity, one band per quantity. For flow fields the predicted velocity is projected so that it conserves mass.
Every fold refits basis, rank, kernel and hyperparameters. Near-duplicate designs are held out together, so an infill point cannot borrow accuracy from its twin. The score is judged against a field-error bar fixed before any measurement, and against simpler baselines on the same folds.
If a baseline scores lower on any split, the model is refused for that field, its numbers kept as evidence. Outside its trained region it declines and names the coordinate responsible. What is served stays labelled a prediction until a solver confirms it.
Five snapshots of an analytic plate field are decomposed in your browser and the mode coefficients interpolated between them. The hot spot travels with the design parameter, the hard case for a linear basis, and the error map shows where the reconstruction falls short. Drag beyond the trained range and the model declines.
Inside the engine
Designs placed by an optimiser cluster, so a plain leave-one-out scores a design with its near-twin still in training and reads optimistic. TensorLynx makes the grouped leave-out the headline: designs closer than half the expected nearest-neighbour spacing are linked, chains form groups, and each group is held out as one fold. The plain leave-one-out sits beside it with its own verdict.
The grouping rule and the bars were fixed before any score was computed.
X = [x1 − x̄, …, xn − x̄] = U Σ VT
r = min { k : Σi≤k σi2 / Σi σi2 ≥ 0.999 }, r ≤ min(n − 1, 32)
x̂(μ) = x̄ + Σk≤r ak(μ) φk, ak ~ GP
Every score is weighted by nodal volume or cell area, so boundary-layer clustering does not dominate the error. The band combines each mode’s variance with that of the truncated modes: a model band reported with its measured coverage, not a calibrated interval. Hyperparameters come from maximum marginal likelihood with seeded restarts, the seed recorded. Method
A model that reports one error number cannot be debugged. TensorLynx splits it into three parts, because each has a different fix.
One reduce-then-regress model with a menu: POD or PCA, kernel PCA and Isomap with an explicit pre-image, paired with radial-basis, Gaussian-process, ridge, polynomial or nearest-case regressors. Beside it sit POD on a canonical domain, Grassmann-manifold interpolation of the basis, operator networks and conditioned neural fields, always next to per-node and do-nothing baselines.
Methods say when they are the wrong choice. On a nine-case test where the modes barely rotated, the Grassmann route reported “probably not worth it here”, and the global basis scored lower. Measured · 9-case test corpus
Evidence you can check
Campaign-specific measurements on held-out designs, in physical units: not a general accuracy figure, and reported that way.
Steady turbulent flow through 90° circular bends: pressure, velocity and turbulence fields. With three cases held out on a mesh every model had seen, a per-node ridge baseline scored 0.0147 and POD with interpolation 0.0238; the baseline won, and the record says so. On six cases spanning three mesh topologies none had seen, every mesh-tied model declined, naming the mismatch (75,396 training nodes, 46,168 asked), and the mesh-free conditioned neural field answered at 0.0358.
Measured · bend corpus, 13 + 6 cases
From 42 solved plate designs, the POD-plus-Gaussian-process field model predicted the von Mises stress field at 0.036 leave-one-out and 0.038 grouped leave-out: PASS against the 0.05 bar, where the best baseline on the same grouped folds scored 0.123. Displacement fields went through the same rules; where a simpler baseline scored lower, the model was refused for that field.
Measured · 42 snapshots, one campaign
In an airfoil study with 9 design variables and 24 usable evaluations, the field model was refused: the rule asks for at least 90. The refusal carries a reason and a fix, and no number.
Measured · refusal on record
What it changes for your programme
A verdict per field you can accept or reject in review, and a field for every design, not just the few you could afford to open.
Field models from the runs you already have, with error maps, baselines and refusal reasons ready to show.
Fewer late surprises from a peak that moved; full solves spent where they matter.
Where loss and separation sit as the shape changes.
Where the load path concentrates across sizing parameters.
Flow distribution across branches, not one averaged outlet value.
Pressure distributions across shape parameters, beside the study they came from.
| Question | Typical workflow | With TensorLynx |
|---|---|---|
| What you see per design | A scalar; fields only for solved designs | The whole field, with a per-node error map |
| How accuracy is judged | Training fit or a few spot checks | Grouped leave-out, refit per fold, bar fixed in advance |
| When the model is weak | A field is drawn anyway | Refused per field, numbers and reason kept |
| Outside the data | Silent extrapolation | Declined, with the input that caused it named |
| The design you take forward | Read off the prediction | The best evaluated design, confirmed by an independent re-run |
Where it sits in the loop. Field models extend the trust-aware scalar surrogates to whole fields, under the same rule: a weak model stays silent. They are fitted as an analysis of a multidisciplinary optimisation run’s own kept fields: the run itself is never changed, and every value is labelled a prediction, never a solver result. Next, multi-fidelity optimisation decides where expensive solves go, and designs you take forward pass through high-fidelity reassessment. The whole loop is on the TensorLynx overview.
FAQ
At least max(15, 10·d) usable, converged cases for d design variables before any field claim: 30 for a three-parameter study. Below that the model is refused, with the count and the reason.
Fields written on a shared mesh support. On record are pressure, velocity and turbulence fields of a pipe-bend family and the von Mises stress field of a plate campaign. Each field is judged on its own: one can pass while another is refused.
Mesh-tied models such as POD decline a mesh they were not trained on and name the mismatch. The mesh-free conditioned neural field is the route to new topologies: on the bend corpus it answered on three it had never seen. A shape outside the trained family calls for new solves.
Read the grouped leave-out score against the field-error bar, the best baseline on the same folds, and the per-node error map. Bands carry their measured coverage and the label uncalibrated. Any design you take forward is confirmed by an independent solver re-run.
No. It explores between solved designs and shows where to look. Recommendations rest on solver-evaluated designs; required tests and sign-off stay where they are.
OLTRION engineers plan the snapshot campaign with you, set up the field model, review error maps and refusals with your team, and hand over a documented workflow.
Every capability hands its result to the next on the same model, the same units and the same record: geometry feeds physics, physics feeds sensitivities and learning, optimisation proposes, verification confirms, and the history keeps every step reproducible.
TensorLynx is built and run by the engineers who use it on client work. You can start small, with one geometry and one question, and grow into a workflow your own team owns.
Send a geometry, the objective and the constraints. We tell you which TensorLynx route answers it, what it needs from you, and what you will get back.
Our engineers run the loop on your problem: physics, sensitivities, optimisation and full-model verification, handed over with every setting on record.
A TensorLynx workflow, surrogate and verification gates set up around your product family, so the next design cycle starts where the last one ended.
Your team on TensorLynx, trained on your own cases, with OLTRION engineers behind it for the questions that need a specialist.
Simulation and AI predictions support engineering decisions; they do not replace the testing, approval and sign-off a product requires. Figures marked measured come from recorded TensorLynx runs on the stated case; figures marked synthetic or schematic illustrate a method.
