# Single run with FOM - LLNL/scaleupROM GitHub Wiki

## TL;DR

In this tutorial, we run the following commands:

`cd examples/poisson ../../bin/main -i poisson.yml ../../bin/main -i poisson.yml -f single_run/poisson0/k=1.5 ../../bin/main -i poisson.component.yml`

The `main`

category in the input file specifies the mode of `main`

and the type of the solver. For example, `examples/poisson/poisson.yml`

specifies,

```
main:
mode: single_run
use_rom: false
solver: poisson
```

that (1) it is `single_run`

mode, (2) FOM simulation will be run, and (3) Poisson equation will be solved.

# Parameterized problem

At `single_run`

mode, the equation will be solved on a particular right-hand side function and boundary condition set by the parameterized problem. In the tutorial for main driver, we ran the following command:

```
cd examples/poisson
../../bin/main -i poisson.yml
```

In `examples/poisson/poisson.yml`

, the type of the parameterized problem is set as:

```
parameterized_problem:
name: poisson0
```

The parameterized problem `poisson0`

defines a right-hand side and a boundary condition as:
$$-\nabla^2 u = \sin2\pi\left(kx + ky + kz + \theta\right)$$
$$u = 0 \qquad \text{on } \partial D$$
with parameters $k$ and $\theta$.
The parameters for each parameterized problem can be set under `single_run/[the name of parameterized problem]`

. For example of `examples/poisson/poisson.yml`

,

```
single_run:
poisson0:
k: 2.5
```

which sets the parameters as: $$k = 2.5$$ If the parameter values are not specified, hard-coded default values are used instead ($\theta=0$ by default).

There are a variety of parameterized problems defined for each physics solver, which can be found in the source code include/parameterized_problem.hpp.

It is possible to change these parameter values at runtime using forced inputs, as instructed here. For example, if we want to solve the same problem as above but with a different $k$,

```
../../bin/main -i poisson.yml -f single_run/poisson0/k=1.5
```

will return a solution with $k=1.5$,

# Domain decomposition

Domain decomposition option is set up in the input file as:

```
domain-decomposition:
type: interior_penalty
```

Currently either `interior_penalty`

or `none`

is supported:

`interior_penalty`

: DG interface enforcement between subdomains`none`

: The interfaces between subdomains are considered continuous. The equation is solved on a unified large mesh.

# Mesh options

## SubMesh

scaleupROM can use SubMesh feature for automatic decomposition, where you can simply specify one mesh filename. In the example of `examples/poisson/poisson.yml`

,

```
mesh:
filename: meshes/test.2x2.mesh
```

The domain is then decomposed according to element attributes. (For element attribute and the mesh format, see MFEM's documentation). In the example of `examples/poisson/poisson.yml`

, the domain is decomposed into 4 subdomains as shown below:

When using a single mesh file, it needs to cover the global, large scale domain and it cannot be built from unit cells in a bottom-up way.

## Component Meshes

In case of using component meshes, we need to specify component mesh files and the global configuration file that specifies the global topology and boundaries. For example, in `examples/poisson/poisson.component.yml`

,

```
mesh:
type: component-wise
uniform_refinement: 2
component-wise:
global_config: "config/2x2_config.h5"
components:
- name: "empty"
file: "meshes/square.mesh"
- name: "square-circle"
file: "meshes/square-circle.mesh"
- name: "square-square"
file: "meshes/square-square.mesh"
- name: "square-triangle"
file: "meshes/square-triangle.mesh"
- name: "square-star"
file: "meshes/square-star.mesh"
```

We defer the description of the data format used for the global configuration to here. Running the single run with this input file

```
../../bin/main -i poisson.component.yml
```

saves the solution visualization on each subdomain at `paraview_output_0`

, `paraview_output_1`

, ...

Currently, scaleupROM does not support saving the unified paraview when component meshes are used, and each subdomain paraview file has to be loaded one by one. Fortunately, ParaView provides automatic python script generator to create a macro. For the example of `examples/poisson/poisson.component.yml`

, you can import the macro file `examples/poisson/paraview_load.py`

from ParaView.

**NOTE:** before importing the macro file on ParaView, specify the path to visualization directories at the first line of `examples/poisson/paraview_load.py`

:

```
### Set the root directory where paraview_output_0, ... are located.
root_dir = '/absolute/path/to/your/paraview/output'
```

Running the macro will visualize the solution as below: