# Darcy Flow with Physics-Informed Fourier Neural Operator¶

## Introduction¶

This tutorial solves the 2D Darcy flow problem using Physics-Informed Neural Operators (PINO) 1. You will learn:

Differences between PINO and Fourier Neural Operators (FNO).

How to set up and train PINO in Modulus.

Defining a custom PDE constraint for grid data.

Note

This tutorial assumes that you are familiar with the basic functionality of Modulus and understand the PINO architecture. Please see the Lid Driven Cavity Background and Physics Informed Neural Operator sections for additional information. Additionally, this tutorial builds upon the Darcy Flow with Fourier Neural Operator which should be read prior to this one.

Warning

The Python package gdown is required for this example if you do not already have the example data downloaded and converted.
Install using `pip install gdown`

.

## Problem Description¶

This problem illustrates developing a surrogate model that learns the mapping between a permeability and pressure field of a Darcy flow system. The mapping learned, \(\textbf{K} \rightarrow \textbf{U}\), should be true for a distribution of permeability fields \(\textbf{K} \sim p(\textbf{K})\) and not just a single solution.

The key difference between PINO and FNO is that PINO adds a physics-informed term to the loss function of FNO. As discussed further in the Physics Informed Neural Operator theory, the PINO loss function is described by:

where

where \(\mathcal{G}_\theta(a)\) is a FNO model with learnable parameters \(\theta\) and input field \(a\), and \(\mathcal{L}_{pde}\) is an appropriate PDE loss. For the 2D Darcy problem (see Darcy Flow with Fourier Neural Operator) this is given by

where \(k(\textbf{x})\) is the permeability field, \(f(\textbf{x})\) is the forcing function equal to 1 in this case, and \(a=k\) in this case.

Note that the PDE loss involves computing various partial derivatives of the FNO ansatz, \(\mathcal{G}_\theta(a)\). In general this is nontrivial; in Modulus, three different methods for computing these are provided. These are based on the original PINO paper:

Numerical differentiation computed via Finite-Difference Method (FDM)

Numerical differentiation computed via spectral derivative

Hybrid differentiation based on a combination of first-order “exact”2 derivatives and second-order FDM derivatives

The first 2 approaches are the same as proposed in the original paper. The third approach is a modification of the “exact” approach proposed in the paper. This method is slower and more memory intensive than the numerical derivative approaches when computing second order derivatives because it requires the computation of a Hessian matrix. Instead, a “hybrid” approach is provided which offers a compromise by combining first-order “exact” derivatives and second-order FDM derivatives.

## Case setup¶

The setup for this problem is largely the same as the FNO example (Darcy Flow with Fourier Neural Operator), except that the PDE loss is defined and the FNO model is contrained using it. This process is described in detail in Defining PDE Loss below.

Similar to the FNO chapter, the training and validation data for this example can be found on the Fourier Neural Operator Github page.
However, an automated script for downloading and converting this dataset has been included.
This requires the package gdown which can easily installed through `pip install gdown`

.

Note

The python script for this problem can be found at `examples/darcy/darcy_pino.py`

.

### Configuration¶

The configuration for this problem is similar to the FNO example,
but importantly there is an extra parameter `custom.gradient_method`

where the method for computing the gradients in the PDE loss is selected.
This can be one of `fdm`

, `fourier`

, `hybrid`

corresponding to the three options above.
The balence between the data and PDE terms in the loss function can also be controlled using the `loss.weights`

parameter group.

```
defaults :
- modulus_default
- arch:
- fno
- scheduler: tf_exponential_lr
- optimizer: adam
- loss: sum
- _self_
jit: false
custom:
gradient_method: hybrid
ntrain: 1000
ntest: 100
arch:
fno:
dimension: 2
nr_fno_layers: 4
fno_layer_size: 32
fno_modes: 12
padding: 9
output_fc_layer_sizes:
- 128
scheduler:
decay_rate: 0.95
decay_steps: 1000
training:
rec_results_freq : 1000
max_steps : 10000
loss:
weights:
sol: 1.0
darcy: 0.1
batch_size:
grid: 16
validation: 8
```

### Defining PDE Loss¶

For this example, a custom PDE residual calculation is defined using the various approaches proposed above.
Defining a custom PDE residual using sympy and auto-diff is discussed in 1D Wave Equation, but in this problem we will not be relying on standard auto-diff for calculating the derivatives.
Rather, we want to explicitly define how the residual is calculated using a custom `torch.nn.Module`

called `Darcy`

.
The purpose of this module is to compute and return the Darcy PDE residual given the input and output tensors of the FNO model,
which is done via its `.forward(...)`

method:

```
from modulus.architecture.layers import fourier_derivatives# helper function for computing spectral derivatives
from ops import dx, ddx# helper function for computing finite difference derivatives
```

```
class Darcy(torch.nn.Module):
"Custom Darcy PDE definition for PINO"
def __init__(self, gradient_method: str = "hybrid"):
super().__init__()
self.gradient_method = str(gradient_method)
def forward(self, input_var: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]:
# get inputs
u = input_var["sol"]
c = input_var["coeff"]
dcdx = input_var["Kcoeff_y"] # data is reversed
dcdy = input_var["Kcoeff_x"]
dxf = 1.0 / u.shape[-2]
dyf = 1.0 / u.shape[-1]
# Compute gradients based on method
# Exact first order and FDM second order
if self.gradient_method == "hybrid":
dudx_exact = input_var["sol__x"]
dudy_exact = input_var["sol__y"]
dduddx_fdm = ddx(
u, dx=dxf, channel=0, dim=0, order=1, padding="replication"
)
dduddy_fdm = ddx(
u, dx=dyf, channel=0, dim=1, order=1, padding="replication"
)
# compute darcy equation
darcy = (
1.0
+ (dcdx * dudx_exact)
+ (c * dduddx_fdm)
+ (dcdy * dudy_exact)
+ (c * dduddy_fdm)
)
# FDM gradients
elif self.gradient_method == "fdm":
dudx_fdm = dx(u, dx=dxf, channel=0, dim=0, order=1, padding="replication")
dudy_fdm = dx(u, dx=dyf, channel=0, dim=1, order=1, padding="replication")
dduddx_fdm = ddx(
u, dx=dxf, channel=0, dim=0, order=1, padding="replication"
)
dduddy_fdm = ddx(
u, dx=dyf, channel=0, dim=1, order=1, padding="replication"
)
# compute darcy equation
darcy = (
1.0
+ (dcdx * dudx_fdm)
+ (c * dduddx_fdm)
+ (dcdy * dudy_fdm)
+ (c * dduddy_fdm)
)
# Fourier derivative
elif self.gradient_method == "fourier":
dim_u_x = u.shape[2]
dim_u_y = u.shape[3]
u = F.pad(
u, (0, dim_u_y - 1, 0, dim_u_x - 1), mode="reflect"
) # Constant seems to give best results
f_du, f_ddu = fourier_derivatives(u, [2.0, 2.0])
dudx_fourier = f_du[:, 0:1, :dim_u_x, :dim_u_y]
dudy_fourier = f_du[:, 1:2, :dim_u_x, :dim_u_y]
dduddx_fourier = f_ddu[:, 0:1, :dim_u_x, :dim_u_y]
dduddy_fourier = f_ddu[:, 1:2, :dim_u_x, :dim_u_y]
# compute darcy equation
darcy = (
1.0
+ (dcdx * dudx_fourier)
+ (c * dduddx_fourier)
+ (dcdy * dudy_fourier)
+ (c * dduddy_fourier)
)
else:
raise ValueError(f"Derivative method {self.gradient_method} not supported.")
# Zero outer boundary
darcy = F.pad(darcy[:, :, 2:-2, 2:-2], [2, 2, 2, 2], "constant", 0)
# Return darcy
output_var = {
"darcy": dxf * darcy,
} # weight boundary loss higher
```

The gradients of the FNO solution are computed according to the gradient method selected above.
The FNO model automatically outputs first order gradients when the `hybrid`

method is used, and so no extra computation of these is necessary.
Furthermore, note that the gradients of the permeability field are already included as tensors in the FNO input training data (with keys `Kcoeff_x`

and `Kcoeff_y`

)
and so these do not need to be computed.

Next, incorporate this module into Modulus by wrapping it into a Modulus `Node`

.
This ensures the module is incorporated into Modulus’ computational graph and can be used to optimise the FNO.

```
from modulus.node import Node
```

```
cfg=cfg.arch.fno,
domain_length=[1.0, 1.0],
)
# Make custom Darcy residual node for PINO
inputs = [
"sol",
"coeff",
"Kcoeff_x",
"Kcoeff_y",
]
if cfg.custom.gradient_method == "hybrid":
inputs += [
"sol__x",
"sol__y",
]
darcy_node = Node(
inputs=inputs,
```

Finally, define the PDE loss term by adding a constraint to the `darcy`

output variable (see Adding Constraints below).

### Loading Data¶

Loading both the training and validation datasets follows a similar process as the FNO example:

```
if DistributedManager().distributed:
print("Multi-GPU currently not supported for this example. Exiting.")
return
# load training/ test data
input_keys = [
Key("coeff", scale=(7.48360e00, 4.49996e00)),
Key("Kcoeff_x"),
Key("Kcoeff_y"),
]
output_keys = [
Key("sol", scale=(5.74634e-03, 3.88433e-03)),
]
download_FNO_dataset("Darcy_241", outdir="datasets/")
invar_train, outvar_train = load_FNO_dataset(
"datasets/Darcy_241/piececonst_r241_N1024_smooth1.hdf5",
[k.name for k in input_keys],
[k.name for k in output_keys],
n_examples=cfg.custom.ntrain,
)
invar_test, outvar_test = load_FNO_dataset(
"datasets/Darcy_241/piececonst_r241_N1024_smooth2.hdf5",
```

### Initializing the Model¶

Initializing the model also follows a similar process as the FNO example:

```
[k.name for k in output_keys],
n_examples=cfg.custom.ntest,
)
# Define FNO model
if cfg.custom.gradient_method == "hybrid":
output_keys += [
Key("sol", derivatives=[Key("x")]),
Key("sol", derivatives=[Key("y")]),
]
model = instantiate_arch(
input_keys=[input_keys[0]],
```

However, in the case where the `hybrid`

gradient method is used,
you need to additionally instruct the model to output the appropriate gradients by specifying these gradients in its output keys.

### Adding Constraints¶

Finally, add constraints to your model in a similar fashion to the FNO example.
The same `SupervisedGridConstraint`

can be used;
to include the PDE loss term you need to define additional target values for the `darcy`

output variable defined above (zeros, to minimise the PDE residual)
and add them to the `outvar_train`

dictionary:

```
name="Darcy Node",
)
nodes = model.make_nodes(name="FNO", jit=False) + [darcy_node]
# make domain
domain = Domain()
# add constraints to domain
outvar_train["darcy"] = np.zeros_like(outvar_train["sol"]) # constrain darcy node
supervised = SupervisedGridConstraint(
nodes=nodes,
invar=invar_train,
outvar=outvar_train,
batch_size=cfg.batch_size.grid,
```

The same data validator as the FNO example is used.

## Training the Model¶

The training can now be simply started by executing the python script.

```
python darcy_PINO.py
```

Warning

Multi-GPU training is currently not supported for this problem.

### Results and Post-processing¶

The checkpoint directory is saved based on the results recording frequency
specified in the `rec_results_freq`

parameter of its derivatives. See Results Frequency for more information.
The network directory folder (in this case `'outputs/darcy_pino/validators'`

) contains several plots of different
validation predictions.

### Comparison to FNO¶

The TensorBoard plot below compares the validation loss of PINO (all three gradient methods) and FNO. You can see that with large amounts of training data (1000 training examples), both FNO and PINO perform similarly.

A benefit of PINO is that the PDE loss regularises the model, meaning that it can be more effective in “small data” regimes. The plot below shows the validation loss when both models are trained with only 100 training examples:

We find that in this case the PINO outperforms the FNO.

References / Footnotes

- 1
Li, Zongyi, et al. “Physics-informed neural operator for learning partial differential equations.” arXiv preprint arXiv:2111.03794 (2021).

- 2
Note that the “exact” method is technically not exact because it uses a combination of numerical spectral derivatives and exact differentiation. See the original paper for more details.