A Reduced Order Model for Domain Decompositions with Non-conforming Interfaces

Abstract

In this paper, we propose a reduced-order modeling strategy for two-way Dirichlet–Neumann parametric coupled problems solved with domain-decomposition (DD) sub-structuring methods. We split the original coupled differential problem into two sub-problems with Dirichlet and Neumann interface conditions, respectively. After discretization by, e.g., the finite element method, the full-order model (FOM) is solved by Dirichlet–Neumann iterations between the two sub-problems until interface convergence is reached. We then apply the reduced basis (RB) method to obtain a low-dimensional representation of the solution of each sub-problem. Furthermore, we apply the discrete empirical interpolation method (DEIM) at the interface level to achieve a fully reduced-order representation of the DD techniques implemented. To deal with non-conforming FE interface discretizations, we employ the INTERNODES method combined with the interface DEIM reduction. The reduced-order model (ROM) is then solved by sub-iterating between the two reduced-order sub-problems until the convergence of the approximated high-fidelity interface solutions. The ROM scheme is numerically verified on both steady and unsteady coupled problems, in the case of non-conforming FE interfaces.

Appendices

Appendix: Detailed Error and Computational Costs Analysis for the Steady Test Case

We report here a detailed analysis of the model performances for the test case Test#1. described in Sect. 5.1, including a study of the effect of the ROM hyper-parameters on the approximation error, number of iterations before solution convergence, and overall computational costs. A simplified analysis for the other test cases, which confirm the results reported here, is given in Sect. 5.3.

Relative approximation errors employing the $H^1(\Omega _i)$ norm, $i = 1,2$, for both slave and master solutions are computed according to (27). Figures 21, 22 and 23 depict such errors as functions of the reduced order hyper-parameters, i.e. of the variations of the number of basis functions chosen to approximate the slave solution, the master solution, and interface data. Both problem solutions are shown to depend on all the reduced quantities involved, and a decreasing approximation error can be achieved every time that the number of basis functions for one between the reduced slave solution, master solution, or interface data, is increased. The major influence on the approximation of both master and slave solution comes from the reduction operated on in the interface data: it can be observed, indeed, a higher reduction of the approximation error when $M_1$ and $M_2$ are increased, whereas the error decrease is much slower when either $n_1$ or $n_2$ are increased. A more expensive and careful approximation of the interface data is therefore to be preferred over an expensive approximation of the slave and master solutions.

Fig. 21

Test#1. $H^1(\Omega _i)$ mean relative error (z axis) over the slave (top row) and master (bottom row) solution for $N_\text {test}=20$ different instances of the parameters between the FOM and ROM solutions varying the number of basis functions used to represent the master solution and $n_2$, and the interface data $M_1$ and $M_2$ (x and y axis), and fixing the number of basis functions employed to approximate the slave solution

Fig. 22

Test#1. $H^1(\Omega _i)$ mean relative error (z axis) over the slave (top row) and master (bottom row) solution for $N_\text {test}=20$ different instances of the parameters between the FOM and ROM solutions varying the number of basis functions used to represent the slave and the master solution $n_1$ and $n_2$ (x and y axis), and fixing the number of basis functions employed to approximate interface data $M_1$ and $M_2$

Fig. 23

Test#1. $H^1(\Omega _i)$ mean relative error (z axis) over the slave (top row) and master (bottom row) solution for $N_\text {test}=20$ different instances of the parameters between the FOM and ROM solutions varying the number of basis functions used to represent the slave solution $n_1$ and the interface data $M_1$ and $M_2$ (x and y axis), and fixing the number of basis functions employed to approximate the master solution

The computational costs of the ROM are investigated by means of the number of iterations needed by the scheme to reach the solution interface convergence, as well as by the effective CPU time. Since both quantities depend on parameter instance, we compute the ratio between the iterations number of the ROM and FOM computations, as well as the ratio between the FOM and ROM computational times. The last ratio is able to describe the speed-up achieved by employing the ROM. Figure 24 shows the variation of such iterations ratio depending on $n_1$, $n_2$, $M_1$ and $M_2$, comparing the results obtained with both the coarse and the fine discretization. The graphs show a dependency of the iterations number from the number of basis functions employed to compute the slave solution and interface data. Specifically, a greater approximation accuracy (and a number of basis functions) of the slave solution increases the number of iterations required to achieve the solution convergence, whereas a higher approximation accuracy of the interface data decreases the number of iterations. The same effect can be observed also in Fig. 25, where we compare the iterations ratio with the approximation error. Varying the number of basis functions to compute the master solution has instead a minor effect on the number of iterations.

Fig. 24

Test#1. Ratio between the number of iterations obtained with ROM and FOM schemes versus the number of basis functions employed to approximate the slave solutions (first row), the interface data (second row), or the master solution (third row), either employing the coarse discretization (left) or the fine discretization (right) for the FOM computation

Fig. 25

Test#1. Iterations ratio versus approximation error depending on the number of basis functions employed to approximate the slave solutions (first row), the interface data (second row), or the master solution (third row), either employing the coarse discretization (left) or the fine discretization (right) for the FOM computation

We report the CPU time ratio compared to the basis functions number in Fig. 26, for both coarse and fine FOM discretizations, showing that independently of the number of basis functions imposed for any reduced quantity, we achieve very similar computational speed up.

Fig. 26

Test#1. Ratio between the CPU time of FOM and ROM versus the number of basis functions employed to approximate the slave solutions (first row), the interface data (second row), or the master solution (third row), either employing the coarse discretization (left) or the fine discretization (right) for the FOM computation

Preliminary Results Employing Radial Basis Functions to Interpolate Data Across the Domain Interfaces

In this appendix, we present a very preliminary investigation of the effects of utilizing a more advanced interpolation technique compared to the nearest neighbor approach outlined and utilized throughout the rest of the paper, to interpolate in the ROM algorithm the Dirichlet–Neumann data across the non-conforming interfaces. Specifically, in accordance with Remark 12 of Sect. 4, we have implemented Radial Basis Function (RBF) interpolation to interpolate the model solution between $\Gamma _2$ and $\Gamma _1$ (i.e., the Dirichlet interface data), as well as the residual vector between $\Gamma _1$ and $\Gamma _2$ (i.e., the Neumann interface data) at the subdomain interfaces. We subsequently apply this RBF scheme to Test#2 in Sect. 5.2, and a partial application to the test case Test#3 in Sect. 5.3.

1.1 Test#2. Steady Case: Diffusion Reaction Equation with Parametrized Source

In this subsection we compute a comprehensive set of approximated ROM solutions of problem (25) with source term (28), by employing varying numbers of basis functions for the master, slave, and interface data, and employing the RBF method to interpolate reduced order Dirichlet and Neumann data across the domain interface. This approach allows us to achieve different levels of approximation accuracy for each quantity depending on the parameters choice, reflecting the methodology outlined in Sect. 5.

For the sake of fairness, we employing the same parameters—encompassing both physical and reduced basis parameters (such as $N_{\text {train}}$ and $N_{\text {test}}$ dimensions)—of Test#2, presenting the same error analysis procedure as depicted in Fig. 12.

In Fig. 27 we therefore report the approximation errors obtained by varying the basis functions for two quantities between the master solution, slave solution, or interface data reduction, while keeping the basis functions for the third quantity constant. Specifically, the number of basis functions held constant in each graph are those required by the POD/DEIM algorithm to attain an approximation accuracy for the respective quantity of $10^{-5}$. These graphs aim at providing a comprehensive overview of the algorithm’s behavior.

Fig. 27

Test#2. $H_1(\Omega _i)$ mean relative error (z axis) over the solution for $N_{test}=20$ different instances of the parameters between the FOM and ROM solutions varying the number of basis functions used to represent the slave and the master solution $n_1$ and $n_2$, and the interface data $M_1$ and $M_2$(x and y axis). On the top row, we fix the number of basis functions of the master problem to 8 (on the left) and to 10 for the slave problem (on the right), while on the bottom we fix the number of basis functions equal to 8 for the interface data representation

We observe that although the overall reduction in computational error appears to be more stable and consistent compared to the test presented in Sect. 5.2 (which utilized nearest neighbor interpolation), the overall values of the approximation errors are of a similar magnitude to those discussed in the paper. Furthermore, in terms of the number of Dirichlet–Neumann iterations required for the algorithms to reach convergence, we have not observed any differences compared to the case of nearest neighbor interpolation. We believe this can be largely due to the number of FOM Dirichlet–Neumann iterations, and not to the interpolation method employed.

1.2 Test#3. Unsteady Case: Time-Dependent Heat Equation

In this subsection we instead investigate the effect of the RBF interpolation on the ROM algorithm on test case #3 presented in Sect. 5.3.

Considering the results obtained in Sect. 1 and recognizing that the interpolation specifically targets the interface data, thereby impacting mostly the effectiveness of the DEIM, we proceed to investigate the influence of the RBF methods, by varying the prescribed approximation accuracy only for the interface data. Therefore, differently from previous tests, here we present error graphs obtained by varying the number of basis functions employed to approximate the interface quantities, while always prescribing an accuracy of $10^{-5}$ for both the slave and master solutions. The results are illustrated in Fig. 28, where we depict the approximation error on the solution in both the slave and master domains.

Fig. 28

Test#3. $H_1(\Omega _i)$ mean relative error over the solution for $N_{test}=20$ different instances of the parameters between the FOM and ROM solutions varying the number of basis functions used to represent the interface data $M_1$ and $M_2$ when either nearest neighbor (P0) or Radial Basis Functions (RBF) interpolation is used to exchange the data across the interfaces. The number of basis functions for master and slave solutions is fixed to 10 and 8, respectively, to prescribe an approximation accuracy of $10^{-5}$

We observed a remarkably similar behavior in the reduction of the approximation error when employing both the nearest neighbor approach and the RBF interpolation. It is noteworthy that the RBF proves to be more effective in approximating the master solution, while the nearest neighbor approach yields better results for the slave model. Nevertheless, these distinctions are quite minor, whereas the computational error magnitude remains consistent for each set of selected basis functions, regardless of the interpolation method employed.

Taking into account the results presented in this appendix, we observe a very similar overall outcome when using either the RBF or the nearest neighbor approach. While one might anticipate the RBF to exhibit a superior convergence rate, several factors could contribute to these findings: (i) the interface non-conformity may not be pronounced enough to favor the RBF over the simpler P0 method, (ii) the test cases considered are straightforward and do not experience significant issues with the basic P0 interpolation, (iii) the snapshots used for constructing the RBF do not incorporate interface interpolation. Each of these points requires separate investigation through a comprehensive convergence analysis, which will be the focus of future work.