A Cost-Efficient Approach towards Computational Fluid Dynamics Simulations on Quantum Devices

Abstract

Numerical simulations of physical systems are found in many industries, as they currently play a crucial role in product development. There are many numerical methods for solving differential equations that describe the underlying physics behind the mathematical models in the simulation, among which, the finite element method (FEM) is one of the most commonly used. Although in many applications the FEM seems to provide an acceptable solution to the problem, there are still many complex real-life processes that can be challenging to simulate numerically due to their complexity and large size. Recently, there has been a shift in research towards efficiently applying quantum algorithms in finite element analysis (FEA), as the potential and speedup that they could offer have been shown, but little to no effort has been made towards the applicability and cost efficiency of these algorithms in real-world quantum devices. In this paper, we propose a cost-efficient method for applying quantum algorithms in FEA for industrial problems post-processed by classical algorithms in order to address the limitations of available quantum hardware and their cost when accessing them through different cloud-based services. We carry this out by approximating the solution of the initially large system with a suitable quantum algorithm and using the obtained solutions to generate a set of reduced-order models (ROMs) that are much smaller in complexity and size than the original model. This allows the simulation of the original model with different parameter sets and excitations to be run efficiently on classical computers without having the need to access quantum subroutines again. This way, we have reduced the usage of quantum hardware (and thus the development cost) while still taking advantage of its quantum speedup.

1. Introduction

The aim of numerical simulations is to approximate the behavior of physical systems on a computer with high precision. It is now a well established methodology that is widely used in many fields, such as solid mechanics, thermodynamics, computational fluid dynamics and chemistry, for a wide range of industries that require accurate solutions. It plays a crucial part in the designing phase of product development, where numerical simulations are carried out in advance for virtual prototyping, prior testing and optimization for time and cost efficiency. Numerical simulations can give us insights into understanding component and system behaviors for large-scale complex applications under extreme conditions and use cases that could be impossible to test physically beforehand. The range of application areas is growing constantly, with some examples being stress–strain simulations estimating the crash worthiness of automobile parts [1], stress analyses of high speed helical gears to reduce failures and for optimal design [2] and accurately predicting and confirming vehicle flight characteristics for Boeing commercial airplanes [3].

Among all the available numerical methods, the most commonly used ones are the finite difference method (FDM) [4,5], the finite element method (FEM) [6,7,8] and the finite volume method (FVM) [9,10,11]. These methods approximately solve differential equations that describe the underlying physics behind the mathematical models in the simulation. It works by discretizing the domain and converting the differential equations into a (typically large) set of linear equations. Although solving these large systems of linear equations with high performance computing (HPC) seems to be acceptable in many use cases, there are still many real-life processes that are difficult to simulate accurately due to their complexity and large size. Turbulent flows are examples of such complex systems that require more advanced methods to approach and to predict their behaviors [12,13,14].

Model order reduction (MOR) is a method that aims to reduce the computational complexity of large-scale dynamical and control systems. The main motivation behind MOR techniques is to remove the features and information of the full-order model (FOM) that are less important in terms of a given application while still maintaining a relatively high accuracy. By reducing the state-space dimension of the model (or degrees of freedom), an approximation to the original model is computed, which is commonly referred to as a reduced-order model (ROM) [15,16,17,18]. ROMs are small in complexity and cheap in terms of computational time; thus, they can be effectively applied in the early stages of product development, as in conceptual design, virtual prototyping and optimization (such as in naval shape design [19] and wind-driven ocean flows [20]), where highly accurate results are not yet desired. This allows for experimenting with different geometries and parameters under certain scenarios in a fast, iterative process before a high-order simulation is carried out for more accurate results and validation purposes. Reduced-order models are also extremely useful in settings where it is often unfeasible to perform numerical simulations using the complete full-order model due to limitations in computational resources or the requirements of the simulations setting. This is often the case in real-time simulation settings where a large number of simulations need to be performed [21,22]. For more applications of MOR in fields such as engineering, electromagnetics and neuroscience, refer to [23]. Most MOR methods can be classified as projection- or truncation-based techniques. Projection-based MOR techniques aim to lower the computational complexity by finding an appropriate space of reduced dimension where the high dimensional state-space can be projected onto and approximated by. Truncation-based reduction techniques tend to preserve the input–output dynamics of a system for a certain set of output states while removing any unnecessary details of the system that are irrelevant for the calculation of that given output set [24]. Lastly, there is an increasing number of work towards enhancing deep-learning for model-order reduction where traditional MOR algorithms could be problematic in capturing the nonlinear input–output dynamics of the system due to the strong variability characterizing the solution set [25,26,27].

Recently, researchers have been focusing on applying quantum computing in FEM and FVM [28,29], as the advantages that it could provide by exploiting its potential and computational speedup, compared to classical algorithms, have been shown. Nevertheless, little to no effort has been made towards their applicability and cost efficiency when used in real-world settings. In such cases, numerical simulations might need to be carried out numerous times with different parameters in product design, optimization and prior testing. As quantum hardware is mostly available through cloud services, each carried out simulation would increase the expenses and development costs, which could easily add up to the tens of thousands of dollars range in even small-complexity simulation problems. This could cancel out all of its benefits against classical computing for many small-to-medium-sized businesses, where a decision would have to be made between a faster development time and lower development cost.

In this paper, we propose a method for reducing the simulation time in computational fluid dynamics applications while also taking the development costs into account. We carry this out by combining a suitable quantum subroutine for solving the initially large system and post-processing the obtained solutions with classical MOR techniques to generate reduced-order models. The reduced models can then be used for effectively carrying out simulations of the original system with different excitations and with a high accuracy using classical computers. This way, we can take advantage of the quantum speedup, but the need for using a quantum hardware is also minimized. We strongly believe that this can be a crucial factor in the near future, when quantum computing is starting to be used more and more often for industrial problems, but the available hardware is still very limited and expensive. Minimizing the number of jobs submitted on quantum hardware by cleverly combining quantum subroutines with classical post-processing techniques could save valuable resources and reduce the cost for any industries planning to invest in quantum computing in the upcoming decade.

2. Related Works

The combination of quantum computing and finite element analysis holds great potential, especially in such cases where current classical computers are struggling to solve complex systems accurately in a relatively fast time, such as in computational fluid dynamics (CFD) applications or tightly coupled multiphysics systems. Nevertheless, this field has been mostly ignored before, but has been gaining more and more attention lately [28,30,31]. Since the output from FEM is often large-sized matrices that are produced algorithmically, it would be a great first step to find quantum algorithms that can solve a system of linear equations in the form $Ax=b$ with exponential speedup. The FEM also leads to sparse system matrices, which is a useful and often required property to reach quantum speedup via the quantum solver algorithm. Lastly, as mentioned in the introduction, FEM has a wide range of industrial applications, such as solid mechanics, thermodynamics, computational fluid mechanics, chemistry and many more. Thus, any achievable speedup can mean a huge difference and may have a large impact on the industry.

A quantum algorithm for solving large systems of linear equations was first introduced by Harrow, Hassidim and Lloyd [32], and was later improved by Childs [33]. In these papers, the quantum speedup in solving a linear system of equations is claimed to be exponential. However, there are challenges in efficiently preparing the classical input parameters and measuring the output states at each time step, as these two operations can cancel out the exponential speedup that the algorithm offers, as was later proven by Montanaro and Pallister [28]. These problems need to be faced by any quantum algorithms that wish to have an exponential speedup compared to their classical counterparts. Nevertheless, there are new research activities mainly focused on solving non-linear systems of equations that claim to have found a workaround to the previously mentioned problems and have reached an exponential speedup in large scale systems [30,31,34,35].

In a recently published paper, Lloyd et al. [30] proposed a method where the number of required resources scale quadratically and logarithmically in the integration time and in the dimension of space-time, respectively, thus preserving the exponential speedup of the solver. In a separate study by Childs [33], a different approach was taken, where they used Carleman linearization to transform nonlinear problems into a system of linear equations. This system of linear equations consists of an infinite number of equations that have to be carefully truncated and reduced to a finite set to be applicable in real-world settings. In another recent paper by Chen et al. [29], an alternative approach was proposed by taking advantage of quantum RAM (QRAM) in order to preserve the quantum speedup offered by the HHL algorithm. Although all of these results show great potential in the field of numerical simulation for a wide range of applications, such as in CFD, these methods will likely be refined, worked upon and used to develop new methods in the upcoming years, before a suitable quantum hardware is available.

In this paper, we propose a method for applying the previously mentioned and other newly discovered quantum algorithms for real-life problems by taking advantage of their quantum speedup, but also taking the limited availability of quantum computers and their costs into account. We carry this out by minimizing the need to use quantum algorithms for solving PDEs by post-processing the solutions obtained from a few critical initial cases and creating ROMs, which can be efficiently solved on classical computers afterwards with different parameter sets. We solely focus on the FEM as our discretization method and will introduce it in Section 3. Nevertheless, the method we describe in this paper is generalizable in a sense that FEM can be replaced by other similar methods, such as FVM [36,37].

3. Preliminaries

3.1. The Basic Concepts of Finite Element Method

Numerical simulations of real-life processes cannot be carried out unless the corresponding mathematical model of the physical system is defined along with the underlying physical laws that govern the system. These laws for space- and time-dependent problems can be expressed in terms of partial differential equations (PDEs). In most cases, however, these PDEs are extremely difficult if not impossible to solve analytically. Therefore, an approximation often has to be made that can be produced using different types of discretization methods, such as the FEM (as seen in Figure 1), FVM and FD. In the case of CFD problems, FVM is the most commonly used scheme, as it is a locally conservative method, meaning that the conservation laws are satisfied on every cell in the mesh. In FEM, the conservation laws are only satisfied globally. Local conservation is an attractive feature, especially in the case of the Navier–Stokes equations; however, FEM is more flexible and generalizable to other problems and use cases. Thus, in this paper, we decided to use FEM as our main discretization method. For more details regarding the differences between FEM and FVM, refer to [38,39].

The main features of FEM can be best explained using a simple example, but, for a more in-depth understanding, refer to [6,7,8]. For this reason, let us take a look at a heat conduction problem inside a thin metal rod of length L:

$$\begin{array}{cc}\hfill \mathrm{differential}\mathrm{equation}& -\lambda T^{″}\left(x\right)=f\left(x\right)\forall x\in (0,L),\hfill \end{array}$$

(1)

$$\begin{array}{cc}\hfill \mathrm{boundary}\mathrm{conditions}& \left\{\begin{array}{c}T(x=0)=0\hfill \\ T^{\prime }(x=L)=0.\hfill \end{array}\right.\hfill \end{array}$$

(2)

Here, $\lambda$ denotes the thermal conductivity, $T\left(x\right)$ denotes the temperature at point x and f is the rate of heat generation per unit volume $(\left[f\left(x\right)\right]=W/m^3)$. The left end of the rod is kept at constant temperature level 0, whereas, at the right end, no heat is allowed to enter or leave. The next step is to multiply both sides of Equation (1) with a so-called test function v and integrate both sides over the whole domain $\mathsf{\Omega }=(0,L)$:

$$-{\int }_0^L\lambda T^{″}\left(x\right)v\left(x\right)dx={\int }_0^{L}f\left(x\right)v\left(x\right)dx.$$

(3)

Next, using integration by parts, the equation becomes

$$-{\int }_0^L\lambda T^{″}\left(x\right)v\left(x\right)dx=-{\left[\lambda T^{\prime }v\right]}_{x=0}^{x=L}+{\int }_0^L\lambda T^{\prime }\left(x\right)v^{\prime }\left(x\right)dx.$$

(4)

If the test function v is required to satisfy the same Dirichlet boundary condition as the temperature T,

$$v(x=0)=0,$$

(5)

and with the aid of the homogeneous Neumann boundary condition from Equation (2)

$$T^{\prime }(x=L)=0,$$

(6)

one can simplify Equation (4) as follows:

$$-{\int }_0^L\lambda T^{″}\left(x\right)v\left(x\right)dx={\int }_0^L\lambda T^{\prime }\left(x\right)v^{\prime }\left(x\right)dx.$$

(7)

After substitution, we arrive at the following equation

$${\int }_0^L\lambda T^{\prime }\left(x\right)v^{\prime }\left(x\right)dx={\int }_0^{L}f\left(x\right)v\left(x\right)dx.$$

(8)

The transformations used so far are equivalent, and no approximation has been made yet. The first transformation that involves approximation is the Galerkin projection introduced in the next step. The idea behind the Galerkin projection is that solving Equation (8) on a computer requires the infinite-dimensional space V to be replaced by a finite-dimensional subspace S. The problem in Equation (8) then becomes finding $T_S\in S$, so that

$${\int }_0^L\lambda T_S^{\prime }\left(x\right)v^{\prime }\left(x\right)x={\int }_0^{L}f\left(x\right)v\left(x\right)dx\forall v\in S.$$

(9)

If we take an arbitrary basis $\{{\varphi }_i:1\le i\le n\}$, an element $T_S\in S$ can be represented as

$$T_S=\sum _{i=1}^n{T}_i{\varphi }_i.$$

(10)

The procedure is visualized in Figure 2, where T (solid blue line) is approximated by $T_S$ (dashed orange line) as a linear combination defined in Equation (9).

The substitution of the basis functions ${\varphi }_i$ into both sides of Equation (9) results in the so-called weak formulation

$$\sum _{i=1}^n{T}_i{\int }_0^L{\varphi }_i^{\prime }\left(x\right)v^{\prime }\left(x\right)dx=\frac{1}{\lambda }{\int }_0^{L}f\left(x\right)v\left(x\right)dx.$$

(11)

In Equation (11), the condition needs to be satisfied for all $v\in S$. Since v can be expressed as a linear combination of basis functions

$$v=\sum _{j=1}^n{\beta }_j{\varphi }_j,$$

(12)

we can transform Equation (11) as follows:

$$\sum _{i=1}^n{T}_i{\int }_0^L{\varphi }_i^{\prime }\left(x\right){\varphi }_j^{\prime }\left(x\right)dx=\frac{1}{\lambda }{\int }_0^{L}f\left(x\right){\varphi }_j\left(x\right)dx\forall j\in \{1,\cdots ,n\}.$$

(13)

The system of linear equations can then be written as

$$A\tilde{T}=b,$$

(14)

where A is an $N\times N$-dimensional symmetric and invertible matrix called the stiffness matrix, and $\tilde{T}$ and b are N-dimensional vectors defined as

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill \tilde{T}& :={\left(T_i\right)}_{i=1,\cdots ,n}\hfill \\ \hfill A& :={\left({\int }_0^L{\varphi }_i^{\prime }\left(x\right){\varphi }_j^{\prime }\left(x\right)dx\right)}_{i,j=1,\cdots ,n}\hfill \\ \hfill b& :={\left(\frac{1}{\lambda }{\int }_0^{L}f\left(x\right){\varphi }_j\left(x\right)dx\right)}_{j=1,\cdots ,n}\hfill \end{array}\end{array}$$

(15)

Usually, it is advisable to use preconditioners on the system matrix before solving it for a better convergence time, which is covered by [40,41,42]. The usage of preconditioners is especially important, in most cases, in CFD simulations.

3.2. Quantum Solver for System of Linear Equations

Various quantum algorithms for FEM have been proposed lately that claim to be exponentially faster than their classical counterparts, but it is hard to decide which method has the most potential as of now, especially with new algorithms being developed each year. Most of these algorithms utilize the famous Harrow–Hassidim–Lloyd (HHL) algorithm [32], which solves a system of linear equations. In this paper, we will treat it as a quantum black box, i.e., we are solely interested in the output returned by this quantum subroutine.

The HHL algorithm prepares the state $|x\rangle =\frac{|x^{\prime }\rangle }{\left|\right|x^{\prime }\left|\right|}$ that encodes the solution of the equation

$$A|x^{\prime }\rangle =|b\rangle .$$

(16)

Let $\left|\right|·\left|\right|$ be a norm (usually taken as $\left|\right|·{\left|\right|}_2$) and A be an $N\times N$ Hermitian matrix such that $\left|\right|A\left|\right|·\left|\right|A^{-1}\left|\right|\le k$ and A has, at most, s nonzero entries in each row. Assume that there is an algorithm ${\mathcal{P}}_A$ that, on input $(r,i)$, outputs the location and value of the ith nonzero entry in row r. Let b be an N-dimensional unit vector, and assume that there is an algorithm ${\mathcal{P}}_b$ that produces the corresponding state $|b\rangle$. Since A is a Hermitian matrix, it has a spectral decomposition:

$$A=\sum _{j=0}^{N-1}{\lambda }_j|u_j\rangle \langle u_j|,{\lambda }_j\in \mathbb{R},$$

(17)

where $(u_j,{\lambda }_j)$ is the jth eigenvector, eigenvalue pair of A. In the eigenbasis, A is diagonal; therefore,

$$A^{-1}=\sum _{j=0}^{N-1}{\lambda }_j^{-1}|u_j\rangle \langle u_j|.$$

(18)

The right-hand side of Equation (16) can also be rewritten in the eigenbasis as

$$|b\rangle =\sum _{j=0}^{N-1}{b}_j|u_j\rangle ,b_j\in \mathbb{C}.$$

(19)

The HHL algorithm solves the following equivalent equations

$$|x^{\prime }\rangle =A^{-1}|b\rangle =\sum _{j=0}^{N-1}{\lambda }_j^{-1}{b}_j|u_j\rangle ,|x\rangle =\frac{|x^{\prime }\rangle }{\left|\right|x^{\prime }\left|\right|},$$

(20)

by producing the state $|x\rangle$ up to accuracy $ϵ$ in $l_2$ norm, with a bounded probability of failure, and makes

$$O(skpolylog(sk/ϵ\left)\right)$$

uses of ${\mathcal{P}}_A$ and ${\mathcal{P}}_b$, and the run time is the same up to a $polylog\left(N\right)$ factor (where the $polylog\left(x\right)$ denotes the polynomial in terms of $log\left(x\right)$).

As mentioned in [28,29], if one hopes to preserve the quantum speedup, two operations are not allowed. The first one is the input state preparation $|b\rangle$ with an encoded quantum circuit, where reading all data entries requires $\mathcal{O}\left(N\right)$ time. The second one is measuring the output state to extract the state to a classical vector, which also requires $\mathcal{O}\left(N\right)$ time. Solving a time-dependent problem iteratively requires the discretized physical governing equation to be solved at every time step; thus, the two problems mentioned above exist in every time step. An additional $\mathcal{O}\left(N\right)$ time complexity cannot be allowed in the calculations if an exponential speedup is to be preserved.

One of the workarounds for this problem is using QRAM as mentioned in [29,43]. Following the work of [29], the runtime analysis concludes that the time complexity of their quantum procedure is

$$\mathcal{O}\left(\frac{(s^3+logN)sk{log}^{3}N}{{ϵ}^2}polylog(sk/ϵ)\right).$$

The classical counterpart’s time complexity is

$$\mathcal{O}(Nsklog1/ϵ)$$

when using the conjugate gradient (CG) as the linear solver. The accuracy parameter $ϵ$ has also been incorporated in their quantum time complexity, which is an important factor that has been left out in a few previous attempts claiming to reach exponential speedup incorrectly, as pointed out by Montanaro [28]. The algorithm they developed outperforms the classical algorithm when the relation $N\gg 1/{ϵ}^2$ holds.

3.3. Reducing Model Complexity

Problems in CFD often lead to large systems of equations that are computationally too expensive to solve on classical computers. Model order reduction methods aim to solve this problem by decreasing the complexity and computational cost of a system by removing “redundant” information from the high fidelity model. The main idea is to generate computationally efficient ROMs that work with a relatively high accuracy at points of interest and to remove any unnecessary complications in the model otherwise. One example is the proper orthogonal decomposition (POD) method, which is a widely used snapshot-based reduction method for CFD applications. The details of the POD method are discussed next in Section 3.3.1.

Snapshot-based model order reduction methods require a set of solutions that are computed or measured in advance. Standard MOR techniques assume that the snapshots, which are solutions sampled at different and evenly spaced times, use a constant spatial mesh. Adaptive snapshot computation methods also exist, where the mesh could be different in the case of each snapshot [44]. The solution of the ROM is represented as a linear combination of the snapshots, with the coefficients determined by a Galerkin projection based on a weak formulation of the governing equations. The two most commonly used MOR methods for nonlinear systems are the proper orthogonal decomposition (POD) [45,46,47] and trajectory piecewise-linear techniques (TPWL) [48,49,50,51], which are discussed in Section 3.3.1 and Section 3.3.2, respectively.

3.3.1. Proper Orthogonal Decomposition

The POD method generates a set of reduced basis functions from the solutions that are computed or measured in advance. The goal is to obtain an optimal low-dimensional basis for representing high-dimensional experimental or simulation data. This low-dimensional basis can be used to formulate ROMs of models with a high complexity. The main assumption in the snapshot-based MOR techniques is that an approximation to the solution of the problem can be expressed as a linear combination of spatial modes. Let $u(x,t)$ denote a given flow field and $u_r(x,t)$ denote its approximation in the reduced space. The POD method decomposes $u(x,t)$ into an orthonormal system of spatial modes ${\phi }_i\left(x\right)$ with temporal coefficients $a_i\left(t\right)$ as follows:

$$u(x,t)\approx u_r(x,t)=\sum _{i=1}^{N_r}{a}_i\left(t\right){\phi }_i\left(x\right).$$

(21)

The spatial modes have to be carefully selected, as a correct choice of basis functions could lead to an efficient ROM with a reduced simulation time and high accuracy in the online simulation phase. The POD is capable of selecting the spatial modes with the highest energies; thus, the method is usually a good choice for fluid flow applications. The POD basis

$$X_{N_r}^{POD}=span\left\{{\phi }_i\right\},i=1,\cdots ,N_r,$$

(22)

can be built from a set of snapshots of velocity solutions

$$u_n\left(x\right)=u(x,t_n),n=1,\cdots ,N_S,$$

(23)

where $N_r$ denotes the number of ROM functions and $N_S$ denotes the number of snapshots taken from the obtained solutions. By definition, the POD basis calculation can be thought of as the least square method, which minimizes the difference between the snapshots and the projection of the snapshots on the spatial modes in the X-norm. If the $L^2$-norm is chosen, the POD basis is optimal, considering the energy contained in the snapshots:

$$\begin{array}{c}{X}_{N_r}^{POD}=argmin\frac{1}{N_S}{\displaystyle \sum _{n=1}^{N_S}}\left|\right|u_n\left(x\right)-{\displaystyle \sum _{n=1}^{N_r}}{\langle u_n\left(x\right),\phi \left(x\right)\rangle }_{L^2}\phi \left(x\right){\left|\right|}_{L^2}^2,\\ {\langle {\phi }_i\left(x\right),{\phi }_j\left(x\right)\rangle }_{L^2}={\delta }_{i,j}.\end{array}$$

(24)

In order to solve Equation (24), the following eigenvalue problem is considered:

$$C\xi ={\lambda }_i\xi ,i=1,\cdots ,N_S,$$

(25)

where $C\in {\mathbb{R}}^{N_S\times N_S}$ is the correlation matrix, whose components are calculated as follows:

$${\left[C\right]}_{kl}=\frac{1}{N_r}{\langle u_k\left(x\right),u_l\left(x\right)\rangle }_{L^2}.$$

(26)

The (${\lambda }_i,{\xi }_i$) eigenvalue–eigenvector pair is used to construct the POD basis functions

$${\phi }_i\left(x\right)=\frac{1}{\sqrt{{\lambda }_i}}\sum _{n=1}^{N_S}{\xi }_{i,n}{u}_n\left(x\right),i=1,\cdots ,N_r.$$

(27)

Since the eigenvalues are sorted into descending order, the first modes have the property of retaining most of the energy present in the original solutions. The obtained basis functions are orthogonal and can be normalized in order to obtain

$${\langle {\phi }_i\left(x\right),{\phi }_j\left(x\right)\rangle }_{L^2}={\delta }_{ij},$$

(28)

where ${\delta }_{ij}$ is the Kronecker delta function. Replacing the velocity u with $u_r$ in the incompressible Navier–Stokes equations, as seen in [46], and applying a Galerkin projection on the POD basis functions, the following POD-Galerkin ROM is obtained:

$$\frac{d{a}_j\left(t\right)}{dt}=v\sum _{i=1}^{N_r}{B}_{ji}{a}_i\left(t\right)-\sum _{k=1}^{N_r}\sum _{i=1}^{N_r}{C}_{jki}{a}_k\left(t\right)a_i\left(t\right),j=1,\cdots ,N_r,$$

(29)

where

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill B_{ji}& ={\langle \nabla {\phi }_j,\nabla {\phi }_i\rangle }_{L^2}\hfill \\ \hfill C_{jki}& ={\langle {\phi }_j,({\phi }_k·\nabla ){\phi }_i\rangle }_{L^2}\hfill \\ \hfill a_j\left(0\right)& ={\langle {\phi }_j,u_1\left(x\right)\rangle }_{L^2}.\hfill \end{array}\end{array}$$

(30)

One can obtain the ROM by a projection of the state vector x using the POD basis functions

$$x\left(t\right)=V\widehat{x}\left(t\right),$$

(31)

where $\widehat{x}\left(t\right)$ is an m-dimensional vector in the reduced space, containing the time-dependent amplitudes of m basis vectors, contained in the columns of the projection matrix V. After applying the projection to the nonlinear system, the resulting ROM is of the form

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill \dot{\widehat{x}}\left(t\right)& =V^{T}f(V\widehat{x}\left(t\right),u\left(t\right))\hfill \\ \hfill \widehat{y}\left(t\right)& =h\left(V\widehat{x}\left(t\right)\right).\hfill \end{array}\end{array}$$

(32)

As for the time-domain discretization, a second-order backward Euler time discretization scheme is used in order to preserve the stability of the discretized system:

$$\dot{\widehat{x}}\left(t\right)\approx \frac{3{\widehat{x}}^n-4{\widehat{x}}^{n-1}+{\widehat{x}}^{n-2}}{2\mathsf{\Delta }t}=V^{T}f(V{\widehat{x}}^n,u^n),$$

(33)

where $\mathsf{\Delta }t$ denotes the time step and the superscript n denotes the time index of the current solution. Subtracting the right side from Equation (33), the nonlinear system of equations simplifies to

$$F\left({\widehat{x}}^n\right)=3{\widehat{x}}^n-4{\widehat{x}}^{n-1}+{\widehat{x}}^{n-2}-2\mathsf{\Delta }t{V}^{T}f(V{\widehat{x}}^n,u^n)=0,$$

(34)

for ${\widehat{x}}^n$, which is typically performed using Newton iteration. It is important to note that the Jacobian needs to be evaluated at every iteration at a given time step to obtain the flux term $f(·)$. This implies that the simulation of ROM could be no more efficient than the original system, since the flux term evaluation takes most of the computation time. This issue will be addressed in the next section. For an error assessment on the accuracy of the POD reduction method, refer to [44].

3.3.2. Reduced-Order Linearized Model

The motivation behind trajectory piecewise-linear techniques is to linearize nonlinear systems around suitably selected states and to approximate the system by combining a set of linearized reduced-order models via a weighting procedure. Let $(x_0,u_0),\cdots ,(x_{S-1},u_{S-1})$ be states obtained from previous simulations of the FOM on some finite time interval $\left[t_{start},t_{end}\right]$. Efficient linearized models can be extracted from the system by using a Taylor expansion of the nonlinearity around the states $(x_i,u_i)$

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill f(x,u)=f(x_i,u_i)& +A_i(x-x_i)+B_i(u-u_i)\hfill \\ \hfill & +\frac{1}{2}{W}_i(x-x_i)\otimes (x-x_i)+\cdots ,\hfill \end{array}\end{array}$$

(35)

where ⊗ is the Kronecker product and $A_i$ and $W_i$ are the Jacobian and the Hessian of $f(·)$ evaluated at the state $(x_i,u_i)$. The matrix $B_i=\frac{\partial f}{\partial u}$ is also evaluated at $(x_i,u_i)$. By removing the quadratic and higher terms, the nonlinear system can be linearized around any given state to yield a state-space model of the form:

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill \dot{x}\left(t\right)& =A_{i}x\left(t\right)+B_{i}u\left(t\right)+\left[f(x_i,u_i)-A_i{x}_i\left(t\right)-B_i{u}_i\right]\hfill \\ \hfill y\left(t\right)& =C_{i}x\left(t\right),\hfill \end{array}\end{array}$$

(36)

where $C_i=\frac{\partial h}{\partial x}$ is also evaluated at $(x_i,u_i)$. The vector of unknowns $x\left(t\right)$ can be written as

$$x\left(t\right)=x_i+x_i^{\prime }\left(t\right),$$

(37)

where $x_i$, fixed in time, is the value of state vector x at the linearization point i, and $x_i^{\prime }\left(t\right)$ contains the perturbation of the n unknown flow quantities about that linearization point $x_i$. The linearized equation can then be expressed as

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill {\dot{x}}_i^{\prime }\left(t\right)& =A_i{x}_i^{\prime }\left(t\right)+B_{1i}u\left(t\right)+B_{2i}\hfill \\ \hfill y\left(t\right)& =C_i{x}_i^{\prime }\left(t\right)+C_{0i},\hfill \end{array}\end{array}$$

(38)

where $B_{2i}=f(x_i,u_i)-B_i{u}_i$ and $C_{0i}=C_i{x}_i$. Since each of the linearizations approximates the nonlinear system around the expansion point $x_i$, a model including all of these linearizations could approximate the original system over a larger time interval and a larger part of the state-space.

Plotted in Figure 3 are four linearization points, $x_0$, $x_1$, $x_2$ and $x_3$, along a “training trajectory” A, which is obtained through a simulation of the original nonlinear system. The goal is to capture the most relevant dynamics of the system through a series of simulations in the offline training phase with inputs that reflect the dynamics of interest for the given application. Each linearized model has its own range of validity (denoted by the blue circles) specifying the range where approximation by linearization can be considered as accurate. Exploiting quantum algorithms for their exponential speedup in the offline training part could prove to be the most beneficial, as it is a computationally expensive part of the TPWL.

Using piecewise-linearized models for simulations might already be faster than simulating the original system. However, the linearized models can be further reduced by using previously described MOR techniques. One additional advantage of linearizing the system first is that it allows for the possibility of applying both linear and nonlinear MOR methods to the linear submodels. As a few examples for linear MOR methods, in [48], Rewiénski proposes the usage of Krylov-based reduction using the Arnoldi method. In [52] Vasilyev, Rewiénksi and White introduce balanced truncation to TPWL, and Voß [53] uses Poor Man’s TBR as a linear MOR kernel.

In this paper, we will continue the work described in Section 3.3.1 and use proper orthogonal decomposition (POD) for the reduction step. A reduced-order linearized model can be obtained by applying the projection defined before in Equation (31) to the system in Equation (38), yielding

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill \frac{\partial }{\partial t}{\widehat{x}}_i^{\prime }\left(t\right)& ={\widehat{A}}_i{\widehat{x}}_i^{\prime }\left(t\right)+{\widehat{B}}_{1i}u\left(t\right)+{\widehat{B}}_{2i}\hfill \\ \hfill {\widehat{y}}_i\left(t\right)& ={\widehat{C}}_i{\widehat{x}}_i^{\prime }\left(t\right)+C_{0i},\hfill \end{array}\end{array}$$

(39)

where the reduced-order matrices are given by

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill {\widehat{A}}_i& =V^T{A}_{i}V\hfill \\ \hfill {\widehat{B}}_{1i}& =V^T{B}_{1i}\hfill \\ \hfill {\widehat{B}}_{2i}& =V^T{B}_{2i}\hfill \\ \hfill {\widehat{C}}_i& =C_{i}V.\hfill \end{array}\end{array}$$

(40)

Each ROM has its own range of validity, as seen in the updated Figure 4 denoted by the orange circles. The orange dashed line represents the approximation made to the training trajectory A calculated along the points $x_1^{{}^{\prime }}$, $x_2^{{}^{\prime }}$ and $x_3^{{}^{\prime }}$ in the reduced space, which correspond to $x_1$, $x_2$ and $x_3$ points in the original system.

The last step is to apply a weighting function on the ROMs. Using the procedure described in [48], the piecewise-linear ROM becomes

$$\begin{array}{c}\hfill \begin{array}{cc}\hfill & \sum _{i=0}^{s-1}{w}_i\left(x\right)\left\{\frac{\partial }{\partial t}{\widehat{x}}_i^{\prime }\left(t\right)={\widehat{A}}_i{\widehat{x}}_i^{\prime }\left(t\right)+{\widehat{B}}_{1i}u\left(t\right)+{\widehat{B}}_{2i}\right\},\hfill \\ \hfill & \sum _{i=0}^{s-1}{w}_i\left(x\right)\left\{{\widehat{y}}_i\left(t\right)={\widehat{C}}_i{\widehat{x}}_i^{\prime }\left(t\right)+C_{0i}\right\},\hfill \end{array}\end{array}$$

(41)

where $w_i\left(x\right)$ are state-dependent weights. A typical choice is to let $w_i\left(x\right)$ be large for $x=x\left(t\right)$ close to $x_i$, and small otherwise. For other, more advanced schemes, refer to [50].

4. Quantum Reduced Finite Element Method

In this section, we will describe the different steps and details of our proposed method, combining all the preliminaries that we have seen in the previous sections. Our main motivation was to develop an approach where challenging problems in CFD applications can be accurately simulated with a minimization in computational time and development costs. The approach we have found combines quantum and classical algorithms that output a reusable set of linearized reduced-order models that can be efficiently simulated with different excitation sets on classical computers.

The steps in our method are briefly summarized in Figure 5, starting with the modeling of the physically relevant system that we plan to simulate numerically. This can be carried out in many commercially available FEA softwares, such as COMSOL, Abaqus, Ansys, OpenFOAM and Siemens NX, just to name a few of the most widely used ones. After obtaining an accurate model of the physical system, along with the governing equations and properties, we have to solve the originally large system for some initial states, which are called trajectories (this step is also called the offline training). The initial trajectories have to be carefully selected in order to obtain accurate results for the different excitation sets that we would like to simulate the physical system with using the reduced state later on.

The quantum solver in this context is taken as a black box that is assumed to solve the system of linear equations (exponentially) faster than existing classical algorithms in every step of the time integration. This is the part where we can achieve the most speedup, but it can also be the most expensive step if we are not careful enough and use the quantum hardware for more time than necessary, assuming that the price of a QCPU is much higher than that of a regular CPU. The solutions that we obtain from the solver need to be post-processed classically in order to acquire a reusable system of linearized reduced-order models, as seen in Section 3.3. For this, we first need to find the critical points in our system that hold the most nonlinearity and to linearize the system around these points. After the local linearization, we can start the reduction procedure at the given points to gather a set of reduced linear models.

In the last step, a weight has to be assigned to each model. The weighting function typically assigns a large weight to models close to the given point in the simulation and assigns a small weight otherwise, as seen in Equation (41). The result is a weighted linearized set of ROMs that can be used for approximating the solutions of the original system. This approximation can be carried out with different parameter sets, besides what was used at the offline training part (but within its range of validity) on classical computers with much efficiency. The disadvantage of the TPWL is that it is only applicable for excitations that are in the validation range of the offline training part. If different excitations need to be used that are outside the validation range, a new offline training part needs to be carried out, and the quantum solver has to be applied again in that case.

Additional steps could include an evaluation of the results and validation by comparing the gathered solutions to the ones obtained by solving the original full system. As there are no general rules or prior error analysis that we can make for estimating the accuracy of ROMs, experimenting with different configurations might be necessary initially when the models are yet to be fine-tuned for a specific problem in order to achieve more accurate results or a better performance.

4.1. Study: Flow Past a Cylinder

As a demonstration of the POD reduction method, we show an example of an unsteady, incompressible flow past a cylinder placed in a channel at a right angle to the oncoming fluid. The cylinder is offset from the center of the flow to make the steady-state symmetrical flow unstable. Vortex shedding is an interesting and well-known phenomenon in fluid dynamics that has been studied in relation with MOR techniques for reduction purposes [47,54,55]. For Reynolds numbers below 100, the flow can be treated as a steady laminar flow, and for values above 100, the flow starts developing turbulent behavior. In this simulation, the Reynolds number is equal to 161, which is already enough to show signs of the Karman vortex street, as seen in Figure 6.

The geometry definition and the simulation were carried out using OpenFOAM 2012 following the work of Kornbleuth [56]. The full-order model has 85.720 degrees of freedom. The simulation was run for 3 s, with a fixed time step of $dt=0.00001$ on eight cores in parallel on an Intel(R) Xeon(R) Gold 6248R, 3.00 GHz CPU for a total time of 10.309 s (≈171 min). For the model-order reduction step, Illinois Rocstar LLC’s AccelerateCFD was used, which is an open-source software that reduces a full-order CFD flow (defined in OpenFOAM) using the global POD reduction method. The POD basis was calculated using a total number of 250 snapshots evenly collected from the solutions of OpenFOAM. In Figure 7, we can see the cumulative flow energy in terms of how many basis vectors are selected. This can be used to decide the number of POD basis vectors used for computing the ROM.

The ROM simulations were carried out using different values of the POD velocity space dimension $N_r=14,33,54,75,95$. In these cases, the cumulative energies are 99.1%, 99.91%, 99.99%, 99.999% and 99.9999%, respectively. The simulations were run in series on the same processor that was used for the FOM simulation. The ROM simulation results can be seen in

Table 1. Comparison of ROMs calculated with different values of the POD velocity space dimension. The higher the number of POD basis functions is, the more accurate the results are, but with a decrease in the speedup factor.

Comparison of ROMs
Number of POD basis functions:	14	33	54	75	95
Cumulative energy:	99.1%	99.91%	99.99%	99.999%	99.9999%
Pre-processing:	43.55s	59.24s	87.81s	160.09s	286.38s
Computation:	1.67s	11.09s	44.7s	118.52s	245.52s
Post-processing	18.35s	20.18s	21.31s	22.37s	23.8s
Overall time:	63.57s	90.51s	153.82s	300.98s	555.7s
Speedup factor:	1297x	911x	536x	274x	148x

.

Naturally, the proposed method is optimal in terms of computational time and expenses compared to using either classical or quantum solvers alone. Since, for the offline training phase, a quantum solver is used, in this phase, the computations could be exponentially faster compared to a classical solver. On the other hand, if we consider the online simulation phase after the model-order reduction, the system’s small complexity allows for a much faster simulation time compared to both quantum and classical solvers, as the reduction and speedup factor can be substantial, as seen in Table 1. In this paper, $Re=161$ was used for simplicity, but for simulations of flow past a cylinder at high Reynolds numbers, refer to [57,58]. For POD reduction methods applied to turbulent flows with high Reynolds numbers, refer to [59,60,61].

4.2. Additional Quantum Speedup

As mentioned before, measuring the quantum states and preparing the input at each time step requires $\mathcal{O}\left(N\right)$ time. This $\mathcal{O}\left(N\right)$ multiplier can cancel out the speedup gained from using the quantum solver; therefore, if one aims for an exponential speedup, this problem needs to be addressed. However, with the use of snapshot-based MOR methods, it is possible to slightly speed up the computational time in favor of the quantum algorithm. The reason is that, in snapshot-based reduction methods, such as the POD described in Section 3.3.1, knowing the solution is not required at every time step. Rather, we need solutions sampled at different and evenly spaced times. This means that measuring the quantum state is only required at each snapshot. Since the described MOR methods do not require any addition preprocessing steps for the measured and prepared solutions, the $\mathcal{O}\left(N\right)$ time complexity remains unaffected. Nevertheless, finding the sufficient number of snapshots depends on the desired accuracy, and can vary greatly between applications. This makes it difficult to estimate what the optimal number of snapshots is in general, and requires a deep analysis and careful experimenting of the problem at hand. However, it is safe to say that, in the case where we select only every kth time step as a snapshot, then one can reduce the $\mathcal{O}\left(N\right)$ time complexity caused by measuring the quantum state at each time step by a factor of k. If every time step is selected as a snapshot, then there would be no additional speedup, and we would arrive back at the original time complexity.

Throughout this paper, we assumed that the snapshots are evenly spaced in the time domain, but there are more advanced adaptive methods for the snapshot selection [62,63,64]. With the use of such methods, the additional speedup could be even more significant.

5. Conclusions

In this paper, we have proposed a new method for solving computationally complex problems in CFD applications with a substantial speedup and with a reduced development cost compared to standalone classical or quantum solvers. We have achieved this by combining quantum algorithms for solving systems of linear equations with suitable classical algorithms for data processing and reducing the complexity of the given problem (TPWL-POD). We carry this out by discretizing the physical model using FEM and solving the resulting system of linear equations for an initial training set of inputs. In the training stage, a suitable quantum algorithm is applied for solving the system of equations with an exponential speedup. In the second part, we use snapshot-based classical model order reduction techniques to reduce the complexity of the original problem, making it eligible to be solved classically with different excitations in future simulations, avoiding the need for a quantum solver. This set of linearized reduced-order models can be used for real-time calculations in embedded systems, model validation and optimization purposes.

It is important to note that it is only possible to obtain accurate solutions if the parameter sets are in the range of the validity of the training set. Since it can be difficult to define the training trajectory in an optimal way, covering all the dynamics of interest of the system beforehand, this might require some experimenting at first. The positive side is that the training step only needs to be carried out once before the reduced models could be used for simulations, but any changes in the model, geometry and time-domain would require the retraining of the models. This would increase the number of times that the quantum solver is used, along with the development cost.

After obtaining a set of linearized reduced-order models, they can be used for simulating the physical system with different excitation sets. Since the complexity and size of the original problem is greatly reduced at this point, it is clearly faster to solve the reduced models classically than to solve the original problem. We would also argue that solving the reduced models could be computationally faster on a classical computer than solving the initial problem with a quantum solver. If the system is large enough and has to be simulated with many different excitations or is used in embedded systems for real-time calculations, our hybrid approach could mean a faster computational time compared to both classical and quantum algorithms, and since a mostly reduced version of the original problem is solved on classical CPUs, the cost would be much less than a full quantum or classical solution each time with the full sized matrix.

One of the other main advantages of our proposed method is that we only require the existence of the solutions, and do not have any prerequisites on how they are produced, meaning that it is general and flexible enough to replace the quantum solver and the reduction method for a more suitable one for a given application. This also makes it hard to estimate the limitations and constraints of our method, as it highly depends on the used algorithms. Therefore, one of the disadvantages of this method would be the difficulties of automatization, as there are no general rules for defining the training trajectories and critical points, as it can vary with each application.

6. Future Works

Regarding the next steps, we would like to scale up our approach to other applications besides CFD. This would include both linear and nonlinear use cases, such as thermodynamics, structural mechanics, electromagnetics and coupled multiphysics models, just to name a few. This would allow for the generalization of our method in order to use it for a wide range of industrial problems in the field of numerical simulations.

The majority of quantum solvers promise exponential speedup compared to classical algorithms for problems where the problem domain is large enough. Thus, we can make our method more efficient by making a prior estimation of whether it is actually worth using a quantum solver as opposed to a classical one in terms of the computational time depending on the problem’s complexity. A similar estimation could also be given for the reduced models, as their size could still be large enough to gain quantum speedup. This estimation is visualized as a decision tree in Figure 8. If the size is close to the boundaries of gaining any speedup from the quantum algorithm, an additional trade-off could be made. If the size of the ROM is further reduced, it can be solved faster and cheaper classically, but with less accuracy (as when we reduced the model size, we lost additional information). On the other hand, if the size of the ROM is kept at a larger size, it can be solved faster and more accurately with a quantum algorithm, but with a higher cost.

Simulation models are often parameterized to allow for different variations in the geometry, shape, material, loading, boundary and initial conditions during their design. The described MOR methods in this paper are not robust enough with respect to parametric variations, and a new set of ROMs needs to be generated each time a parameter is changed in the system. This limits the applicability of our method for product design and optimization problems, as the whole workflow needs to be reset and started from sketch. Thus, another important work would be the development and integration of parametric reduced-order models (PROMs) into our workflow, which could reflect the parameter-dependent behavior in the reduced-order systems. Parametric model order reduction (PMOR) methods are intended to solve this exact problem, and could benefit greatly in product design and optimization problems, where exploration cycles can be achieved by carrying out the parametric simulations in the reduced space [65,66,67] and with parametrized geometries [68,69].