Multiscale and Multiresolution Methods

General Description

MrHyDE is designed to use heterogeneous computational architectures to enable concurrent multiscale modeling and simulation. The general form of a coupled multiscale system is:

where $u_c$ denotes the coarse-scale variables and $u_f$ denotes the fine scale variables. Either $F_c$ or $F_f$ may also depend on space and/or time, but we omit this explicit dependence for simplicity. If we assume that the fine scale variables can be eliminated (preferably locally), then we can solve an equation only involving the coarse scale variables:

where the notation $h(u_c)$ represents the local nonlinear elimination of the fine scale information, which depends on the current coarse scale state. As we will soon see, this is related to the Schur complement in the case of steady-state linear operators. At this point, there are two possible interpretations of the coupled system and the reduced system. If the objective is to compute an approximation to 𝑢𝑐 that is informed by the fine scale information, then one interpretation is that this can be obtained by solving the reduced system. However, if the objective is to approximate the fine scale solution that is informed by global information, then we can interpret the reduced system as providing the time evolution of the coarse scale global coupling between fine scale models. The appropriate interpretation is problem dependent.

For simplicity, we will ignore any spatial discretizations throughout this section and proceed as if we are solving coupled systems of ODEs, but in general, all of the use cases involve spatial discretization and are typically based on variational formulations.

To simplify the notation, we will rewrite the reduced system as:

where $g(u_c)$ represents the time derivative. The precise form of h(𝑢𝑐) depends on the multiscale formulation, e.g., variational multiscale, homogenization, FE2, etc. In some cases, it may simply be a numerical approximation of $u_f$ given $u_c$, and in other cases it may be a model for the subgrid effects. However, in all cases we refer to h as the Macro-Micro-Macro map, since macro-scale information is sent to the local fine scale (subgrid) models, fine scale information is computed, and a reduced (upscaled) version of this information gets returned to the coarse scale problem (see the following figure).

MrHyDE is designed to utilize any type of subgrid model, but the primary demonstration is a multiscale Dirichlet-to-Neumann map which is described in below. MrHyDE also requires the gradient of $h$ with respect to $u_c$ to enable accurate Jacobians for implicit time integration. This is often complicated since $h$ will can depend on $u_c$ either explicitly or implicitly through $u_f$, which depends on $u_c$. Thus, the subgrid models typically compute

Computing $\partial u_f / \partial u_c$ is the most challenging step. We first describe it for the steady-state case before moving on to the transient case.

Steady-state Case

In this section, we focus on solving the following steady-state multiscale system,

which is a simplification of the original coupled system. Recall that we assume that the fine scale equation can be localized, so given the current approximation for $u_c$, we can solve

for $u_f$. Note that this does assume that the fine scale solution can be uniquely determined given any coarse scale data, but this is a fairly reasonable assumption. The goal is then to solve the nonlinear coarse scale equation,

for $u_c$. The default procedure in MrHyDE is to use Newton’s method, which, given an approximation $u_c^{(k)}$, solves

where

and we set $_c^{(k+1)} = u_c^{(k)} +\Delta_c$. The iterations continue until a user-prescribed convergence 𝑐𝑐𝑐 tolerance, typically a relative tolerance on the norm of residual, is met. For the sake of simplicity, we will drop the iteration index on 𝑢𝑐 in the remainder of this section. In order to evaluate the residual, we need to be able to evaluate the Macro-Micro-Macro map, $h(u_c)$. This typically requires the following steps:

1. Either project the coarse scale data, $u_c$, onto the fine scale mesh or simply evaluate $u_c$ at the fine scale quadrature points.
2. Use another Newton-based procedure to solve for $u_f$ . Given an approximation $u_f^{(i)}$ (noting that $i$ is different from the outer Newton solve index $k$), we solve

where

and we set $u_f^{(i+1)} = u_f^{(i)} +\Delta_i$. Continue until convergence criteria is met.

3. Project $u_f$ back to the coarse scale or directly use the approximation.

At the discrete level, the projection steps above may involve a matrix-vector product or integrating the solutions against the appropriate test functions. MrHyDE precomputes the coarse scale basis functions at the fine scale quadrature points, so all of these integrals occur at the fine scale.

The coarse scale Jacobian can be written as,

Computing $\partial F_c/\partial h$ is typically straightforward, but computing $\partial h/\partial u_c$, i.e., the derivative of the upscaled information with respect to the coarse scale data, requires more work. MrHyDE assumes that the subgrid models will provide $\partial h/\partial u_c$, which can be written as

The key is computing $\partial u_f/\partial u_c$. To obtain this information, we differentiate the final scale equation with respect to $u_c$,

We note that $\partial F_f/\partial u_f = J_f$, which we have already computed. In MrHyDE, we store the LU factorization (if using a direct method) or multilevel preconditioner (if using an iterative method) for the last Jacobian in the subgrid Newton solver, and solve

which typically involves one additional linear solve per degree-of-freedom in $u_c$. Since the matrix is already assembled and numerically factorized, this sensitivity propagation is typically faster than the actual subgrid nonlinear solve for $u_f$.

Transient Case

Synchronous Time Integration

Asynchronous Time Integration