Fast Radial Basis Functions in Digital Engineering Applications ^†

Abstract

Radial Basis Functions (RBFs), since their inception in the 1960s, have emerged as a key tool in digital engineering applications. As interpolators in multidimensional spaces, RBFs play a crucial role both in generic data science problems and in 3D space manipulation. Their ability to represent large 3D datasets in a mesh-free manner has established them as the standard approach for data mapping and mesh deformation. A fast implementation of RBFs is essential to fully exploit this mathematical approach in digital engineering applications. This paper provides an overview of fast RBF methods in digital engineering and presents practical applications in the field of Computer-Aided Engineering (CAE), highlighting the role of RBFs in the development of a digital twin capable of real-time interaction with 3D structural components; after detailing the workflow for a simple plate with a hole, the method is demonstrated for the structural redesign of a scooter engine connecting rod and for the interactive conceptual design of a CubeSat.

1. Introduction

Radial Basis Functions (RBFs) have established themselves as a powerful mathematical tool for interpolating and manipulating data in multidimensional spaces. Since their theoretical formulation in the 1960s [1,2], RBFs have gained wide adoption across various engineering and scientific domains, particularly for mesh morphing, shape optimization, and data mapping in three-dimensional applications. Their meshless nature makes them ideal for handling complex geometries and large datasets. Beyond their role as spatial field manipulators in two- and three-dimensional spaces, RBFs—sometimes referred to as RBF neural networks—have also been widely adopted for interpolating data in generic n-dimensional spaces. This makes them an excellent tool for machine learning tasks, where they serve as exact or approximate interpolators capable of supporting subsequent inference and prediction.

In the context of digital engineering, the increasing demand for interactive and real-time applications—such as digital twins (DTs) and virtual reality (VR) environments—has pushed traditional numerical methods beyond their practical limits. High-fidelity simulations based on the Finite Element Method (FEM) often result in millions of degrees of freedom, making them computationally unsuitable for real-time feedback or immersive interaction. To overcome these limitations, Reduced-Order Model (ROM) techniques have emerged as crucial enablers. These methods aim to compress large-scale simulation data into low-dimensional representations while preserving essential physical accuracy. Among these, Proper Orthogonal Decomposition (POD) based on SVD [3], and RBF-based reduction methods allow for the efficient approximation of structural responses under varying input conditions. The synergy between ROM and Artificial Intelligence (AI)—including data-driven surrogate models and neural network-based regression (including RBF ones)—opens new avenues for predictive and interactive design. However, to fully capitalize on these capabilities, fast and efficient algorithms for data interpolation and transformation remain a bottleneck.

The research topic addressed in this paper is rapidly evolving, with a growing number of AI-based methods being developed to replace or accelerate high-fidelity simulations, especially in computationally expensive fields such as Computational Fluid Dynamics (CFD) for aerodynamic analysis [4]. Major CAE vendors have already introduced integrated solutions—such as those offered by Navasto, SimAI, and Neural Concept [5,6,7]—and the field has reached mainstream attention with platforms like NVIDIA’s PhysicsNeMo and the GNN-based Domino project [8].

The fundamental idea behind these approaches is to reuse existing databases of high-fidelity simulations, enabling new designs to benefit from previously computed results. In this paradigm, the more data that is available, the faster a new evaluation can be performed. Among the different strategies proposed in the literature and industry, two main directions are particularly relevant here: deep learning-based methods, such as those mentioned above, and model order reduction approaches based on POD, which form the core of the present work.

In both cases, the training process relies on high-fidelity simulation data defined over surface or volume meshes. For the training to be effective and the predictions to be reliable, the individual designs in the dataset must be consistent in terms of geometry and physical configuration—clearly, an aerodynamic model for a car cannot be trained using aircraft data. The key limitation of the POD-based approach lies in its requirement for iso-topological meshes, where the mesh topology remains identical across all samples. In contrast, deep learning methods can operate on datasets with varying mesh topologies and resolutions, thanks to architectures such as Graph Neural Networks (GNN).

Nevertheless, many public and industrial simulation datasets are inherently generated via mesh morphing techniques, which facilitate consistency in shape and mesh structure. This leads to another challenge: while a morphed mesh may be sufficient for data compression and ROM, it may be excessively distorted for direct use in new high-fidelity simulations. This issue can be mitigated by generating a new computational mesh for the updated geometry and subsequently mapping the simulation results back onto the original morphed mesh. In such scenario, RBFs serve three critical roles. First, they are used to morph the reference shape, enabling the generation of new designs. Second, they provide an accurate mapping of high-fidelity results between different mesh configurations [9,10]. Third, they support the training phase by transferring data and enabling inference within a consistent morphing framework [11].

It is important to note that, although deep learning methods are significantly faster than full high-fidelity simulations, they still involve considerable overhead in data generation (a cost shared with all machine learning techniques), as well as long training times and non-negligible inference durations—often in the order of minutes. In contrast, POD-based approaches, once trained, provide near-instantaneous inference and can be deployed in real-time applications. This real-time capability is especially critical in domains such as healthcare, where immediate access to simulation data is essential [12].

This paper addresses the so-called “AI challenge” by focusing on fast RBF implementations, which are instrumental for bridging high-fidelity simulation data and low-latency interaction. A practical application in Computer-Aided Engineering (CAE) is presented, where fast RBFs are used to develop a DT capable of responding in real time to user input and deformation requests. The approach demonstrates how physical accuracy, algorithmic speed, and data compression can be integrated into a single framework for next-generation engineering tools. While the methodology is generic and applicable to both Computational Fluid Dynamics (CFD) and Computational Structural Mechanics (CSM) problems, the remainder of this paper will focus on structural applications, where high-fidelity simulations are performed using standard Finite Element Analysis (FEA) solvers.

Three representative use cases are explored to demonstrate the versatility and effectiveness of the proposed methodology. The first is a benchmark example involving a plate with a hole, which illustrates how real-time simulation and visualization can be achieved for a simple structural component. The second focuses on the interactive structural redesign of a scooter engine connecting rod, showcasing how fast RBF methods support industrial component development. The third addresses the conceptual design of a CubeSat, highlighting how the method enables intuitive interaction with complex systems in early-stage space engineering. All the examples are based on implicit FEA solvers for static analyses: dynamic FEA can be faced, as well as is demonstrated in [13], for automotive Noise, Vibration and Harshness (NVH) by adopting an in-house solver, and in [14] for the simulation of aortic surgery by adopting LS-DYNA explicit solver.

2. Materials and Methods

2.1. Radial Basis Function Interpolation

RBFs offer a robust and flexible method for interpolating scattered data in multidimensional domains [15,16,17]. Given a set of nodes and associated values, the interpolating function is expressed as a linear combination of radially symmetric basis functions centred at the data points, possibly augmented by a low-degree polynomial to ensure solvability. The interpolant takes the following general form:

$$s\left(\mathit{x}\right)=\sum _{i=1}^N{\lambda }_i\hspace{0.17em}\varphi \left(|\mathit{x}-{\mathit{x}}_{\mathit{i}}|\right)+p\left(\mathit{x}\right)$$

where $\varphi \left(r\right)$ denotes a chosen radial function, such as Gaussian or Thin Plate Spline, and $p\left(\mathit{x}\right)$ is a polynomial term. The radial function can have a global or compact support [18]. The interpolation coefficients are determined by solving a symmetric linear system involving the radial function matrix and the polynomial basis. RBF interpolation has found widespread use in mesh morphing [19,20], geometric modelling [21,22,23,24], fluid–structure interaction [10], and physical field reconstruction [25,26,27] due to its meshless formulation and ability to smoothly interpolate scattered data in 2D and 3D spaces. In generic n-dimensional spaces, RBFs are adopted in computer science as a tool for machine learning [28,29,30].

2.2. Acceleration Strategies for Fast RBF

Despite their versatility, classical RBF implementations suffer from poor scalability, as they typically require the solution of dense linear systems whose size grows with the number of data points. To enable the use of RBFs in real-time applications, especially in interactive DT environments, several acceleration strategies have been adopted in this work [31].

The computational burden could be mitigated by reducing the number of interpolation centres through informed sampling strategies [32]. These may include random sampling, clustering, or greedy selection methods aimed at preserving geometric fidelity while reducing matrix dimensions. Furthermore, the interpolation domain is divided into overlapping subregions, each associated with a local interpolant, within a Partition of Unity (POU) framework [33,34,35]. This localization significantly reduces the computational complexity without sacrificing global consistency. The above strategies can be combined as in the Local Correction Method (LCM) implemented in the RBF Morph software [36] and in two-step methods based on sparse solvers [37].

To solve the resulting linear systems more efficiently, iterative solvers such as GMRES [38] and FGP [39,40] are employed in combination with suitable preconditioners, which help to maintain numerical stability even as the system size increases. RBF evaluation becomes a costly stage when using iterative solvers during training and can be accelerated according to the Fast Multipole Method (FMM) [41,42,43,44], which is considered among the top ten algorithms of the 20th century [45]. The FMM combines near-field interactions (considered in full) and far-field interactions (approximated by their multipole expansion), obtaining almost a linear scalability for full populated linear systems of global supported RBFs (iterative solvers scales with a quadratic law). In addition, the implementation exploits parallelism at both the algorithmic and hardware levels. The inherent independence of radial evaluations at different points makes RBF interpolation particularly suitable for parallel processing on multicore CPUs. More significantly, the use of GPU acceleration provides a substantial performance gain, enabling the on-the-fly computation of deformations and updates in immersive environments. These optimizations collectively support the development of fast RBF algorithms tailored for real-time digital engineering applications.

2.3. Workflow for Real-Time Digital Twin Integration

The integration of fast RBF interpolation into a real-time DT framework requires a combination of geometric transformation, model order reduction, and efficient data flow. The process begins with the construction of a high-fidelity model using conventional FEM, which provides detailed information about displacements, stresses, or modal responses under various conditions.

To enable fast prediction in response to user interaction, the high-dimensional simulation data are compressed using ROM techniques, with POD being a prominent choice [46,47,48]. This approach decomposes the solution space into a set of orthonormal basis vectors, allowing for the rapid evaluation of structural responses in a reduced subspace.

Fast RBF interpolation is then used to deform the structural mesh in real time according to user-specified geometric changes. These deformations are immediately mapped into the ROM input space, triggering an update of the predicted fields such as displacements or stress distributions. The entire pipeline is implemented to ensure low-latency feedback, allowing for the seamless interaction between the user and the digital model, either through a graphical interface or an immersive VR environment.

2.4. Test Cases Overview

To assess the applicability, versatility, and performance of the proposed fast RBF framework, three representative case studies are presented. Each case explores a different level of complexity and interactivity, ranging from a canonical academic example to realistic industrial and space engineering scenarios. The selection is intended to demonstrate the scalability of the method, from simple boundary-driven deformation to geometry-intensive redesign tasks and system-level conceptual exploration. In all cases, the goal is to enable the real-time interaction between a user and a structural model, leveraging fast RBF-based morphing and ROM to ensure a low-latency response and the accurate prediction of structural behaviour.

2.4.1. Plate with a Hole

The first test case summarized in Figure 1 concerns a rectangular plate featuring a central circular hole, subjected to uniaxial tensile loading. This classical problem, widely used in structural mechanics as a validation benchmark, serves here to verify the responsiveness and accuracy of the proposed fast RBF framework under idealized conditions. The plate geometry can be interactively modified by adjusting the hole diameter or altering the boundary constraints. These changes are propagated in real time through the computational mesh using RBF morphing. The structural response, such as stress distribution or displacement, is then computed via a ROM based on POD. This simple example allows for a clear assessment of the latency, numerical error, and visual fluidity of the system, providing a baseline for more complex cases.

2.4.2. Engine Connecting Rod

In the second test case, summarized in Figure 2, a realistic structural component is considered: the connecting rod of a scooter engine. This example illustrates how the proposed methodology supports the interactive redesign of an industrial part under performance constraints. Key geometric features of the rod—such as the profile near the small and big ends—can be directly manipulated by the user within a dedicated interface. The fast RBF engine applies the deformation to the detailed finite element mesh in real time. A precomputed ROM, generated from high-fidelity simulations, provides instant feedback on critical performance indicators including the von Mises stress, deformation under load, and first natural frequency. This test case highlights the method’s capability to support early-stage design iterations in a mechanically meaningful way, reducing the turnaround time and enabling the rapid exploration of design alternatives.

2.4.3. CubeSat Conceptual Design

The third and most complex case summarised in Figure 3 addresses the structural design of a CubeSat, a miniaturized satellite platform typically used in research and low Earth orbit missions. A simplified model of the CubeSat is used to enable the interactive exploration of layout configurations. Users can modify internal structural elements, reposition payload components, and adjust the wall or rib stiffness. The resulting geometric modifications are applied using RBF-based mesh deformation techniques and are immediately reflected in the structural response predicted by a dedicated ROM. This case demonstrates how the proposed framework extends beyond classical structural components, offering a viable solution for multidisciplinary design environments where rapid iteration, functional feedback, and system-level consistency are crucial.

3. Results and Discussion

Interactive models defined according to the approach proposed in this paper are presented in this section. The full details of each individual study are not provided as the reader could refer to the references for each individual study. The focus of this discussion is on the ability to make the process generally, as sketched in the blocks of Figure 4. The need to deploy interactive solutions based on high-fidelity FEA models depends on the domain and the intended usage, and requires automation for the generation of a synthetic dataset from the numerical models, the compression of the results and a proper architecture to deploy the solution.

3.1. Plate with a Hole

This is the first classical demonstrator of the technology and is intended for the generic deployment of the FEA models. As anticipated in Section 2.4.1 and summarized in Figure 1, the simple geometry is modelled with a full 3D FEA, and, considering a geometrical parameter, the variation in the size of the hole achieved by a simple mesh morphing setup where the nodes at the hole surface are moved along the surface normal, the nodes on the lateral faces are fixed and the nodes inside the volume mesh are deformed by the RBF field. A physical parameter is considered as well by changing the value of the transversal load applied to the loaded end. The parametric model is then adopted to generate 30 snapshots, and the resulting data is processed according to POD and the reconstructed response validated according to the Leave One Out (LOO) method which involves training the ROM with all the snapshots but one and then verifying the quality of the ROM vs. the excluded one.

Figure 5 shows the interactive results achieved. A desktop application based on Ansys Twin Builder visualization tool is shown. In this case, the interaction with the ROM is performed by acting on two sliders on the left so that the two parameters (hole size and load intensity) can be changed. The rendering is updated accordingly and both the shape and the stress contour map are updated in real time. The same model has been transferred to the Meta Quest 3 VR device (Figure 5 right). In this case, the user can position the component by hand manipulation and change the parameters acting on physical controllers, via blue cylinders that can be dragged to have a real-time variation in both the shape and the results. Thanks to the compression and to the on-device GPU calculations, the update of the physical models happens to be stable at 60 FPS [49].

3.2. Engine Connecting Rod

An industrial problem is considered in this case. The full study demonstrates an advanced shape optimization process conducted on a connecting rod [50]. The synthetic dataset comprises 120 design points. Each design is representative of the worst load case (pressure peak crank angle at 6500 RPM) and is obtained by a combination of the six design parameters shown in Figure 2. To better understand the components’ behaviour, an interactive model has been defined, as in the case of the plate with a hole, and is shown in Figure 6. The UI is the same of Figure 5 left but in this case we have six parameters that can be changed acting on the slider. The accuracy is very high and the maximum stress peak deviation registered by dividing the 120 snapshots in six sets is 6%. The k-fold approach is in this case adopted after the LOO; it consists of dividing the data in a certain number of sets (six in this case, each one with 20 designs) and then training the model with all the sets but one and checking how the design in the removed set is represented. The aim of this specific study is to provide the structural analysts with a quick tool intended to drive design decisions.

3.3. CubeSat Conceptual Design

The third example is in relation to the design of the CubeSat CUSP [51,52]. As anticipated in Figure 3, a high-fidelity FEA model is adopted for the virtual assessment of the full system. This is very useful in the architectural design review stage of the program, and the specific need was a collaborative VR experience intended for the support of decisional processes and also for dissemination purposes. The resulting interactive model is shown in Figure 7, where the full FEA model adopted is shown and compared with the physical prototype. The interactive experience occurs in the orbit where CUSP is supposed to be in operation. The immersive experience (a video is available [53]) is not only intended to provide insights about the component under investigation; it also works as an interesting demonstrator providing the user with a space experience and, thanks to a virtual space banner, it acts as a recognition for the partners working on the program.

4. Conclusions

This work has shown that fast Radial Basis Functions are a practical enabler for real-time structural DTs. In the proposed workflow, RBFs play three complementary roles: (i) geometry manipulation through mesh morphing to explore shape variations on high-fidelity FE models; (ii) consistent field/data transfer to support training, validation, and cross-model comparisons; and (iii) low-latency coupling between user interaction and ROMs so that updates of stresses, displacements, or modal metrics remain visually smooth. The result is a solver-agnostic pipeline that takes high-quality structural simulations and turns them into interactive experiences deployable on desktop interfaces and VR devices.

Across the benchmark plate with a hole, the scooter connecting rod, and the CubeSat case, the same pattern emerges: once the reduced basis is identified (POD) and a lean RBF setup is in place (sampling + localization + iterative/FMM/GPU where appropriate), inference becomes effectively instantaneous, while the end-to-end loop (UI event → RBF deformation → ROM update → rendering) stays below the perceptual thresholds for design-in-the-loop usage. In addition, standard validation strategies (e.g., LOO/K-fold on the snapshot set) provide transparent accuracy estimates that are meaningful for structural decision making.

From an AI perspective, fast RBFs complement data-driven ROMs by solving a notoriously hard part of deployment: geometric consistency. Even when AI models can operate on varying meshes, engineering programmes still require a reliable way to (a) generate families of shapes from a single reference, (b) keep fields aligned across variants, and (c) push predictions back into an interactive environment. RBF morphing and mapping provide this geometric “operating system” so that AI-powered reduced models can be trained, validated, and—crucially—served in real time (e.g., as Functional Mock-up Units inside Twin Builder/Unity/VR).