console-to-shell (#439)

Author: sbryngelson

README.md

@@ -52,23 +52,23 @@ You can navigate [to this webpage](https://mflowcode.github.io/documentation/md_
 It's rather straightforward.
 We'll give a brief intro. here for MacOS.
 Using [brew](https://brew.sh), install MFC's modest set of dependencies:
-```console
+```shell
 brew install wget python cmake gcc@13 mpich
 ```
 You're now ready to build and test MFC!
 Put it to a convenient directory via
-```console
+```shell
 git clone https://github.com/mflowcode/MFC.git
 cd MFC
 ```
 and make sure MFC knows what compilers to use by putting the following in your `~/.profile`
-```console
+```shell
 export CC=gcc-13
 export CXX=g++-13
 export FC=gfortran-13
 ```
 and source that file, build, and test!
-```console
+```shell
 source ~/.profile
 ./mfc.sh build -j 8
 ./mfc.sh test -j 8
@@ -78,7 +78,7 @@ And... you're done!
 You can learn more about MFC's capabilities [via its documentation](https://mflowcode.github.io/documentation/index.html) or play with the examples located in the `examples/` directory (some are [shown here](https://mflowcode.github.io/documentation/md_examples.html))!
 
 The shock-droplet interaction case above was run via
-```console
+```shell
 ./mfc.sh run ./examples/3d_shockdroplet/case.py -n 8
 ```
 where `8` is the number of cores the example will run on.

docs/documentation/case.md

@@ -22,7 +22,7 @@ print(json.dumps({
 
 Thus, you can run your case file with Python to view the computed case dictionary that will be processed by MFC when you run:
 
-```console
+```shell
 python3 my_case_file.py
 ```
 
@@ -56,13 +56,13 @@ You can add as many additional positional arguments as you may need.
 
 To run such a case, use the following format:
 
-```console
+```shell
 ./mfc.sh run <path/to/case.py> <positional arguments> <regular mfc.sh run arguments>
 ```
 
 For example, to run the 3D_weak_scaling case with `gbpp=2`:
 
-```console
+```shell
 ./mfc.sh run examples/3D_weak_scaling/case.py 2 -t pre_process -j 8
 ```
 
@@ -192,7 +192,7 @@ The code outputs error messages when an empty region is left in the domain.
 
 Some parameters, as described above, can be defined by analytical functions in the input file. For example, one can define the following patch:
 
-```console
+```shell
 'patch_icpp(2)%geometry'    : 15,
 'patch_icpp(2)%x_centroid'  : 0.25,
 'patch_icpp(2)%length_x'    : 9.5,

docs/documentation/getting-started.md

@@ -4,7 +4,7 @@
 
 You can either download MFC's [latest release from GitHub](https://github.com/MFlowCode/MFC/releases/latest) or clone the repository:
 
-```console
+```shell
 git clone https://github.com/MFlowCode/MFC.git
 cd MFC
 ```
@@ -19,13 +19,13 @@ Please select your desired configuration from the list bellow:
 
 - **On supported clusters:** Load environment modules
 
-```console
+```shell
 . ./mfc.sh load
 ```
 
 - **Via [Aptitude](https://wiki.debian.org/Aptitude):**
 
-```console
+```shell
 sudo apt update
 sudo apt upgrade
 sudo apt install tar wget make cmake gcc g++ \
@@ -36,7 +36,7 @@ sudo apt install tar wget make cmake gcc g++ \
 
 - **Via [Pacman](https://wiki.archlinux.org/title/pacman):**
 
-```console
+```shell
 sudo pacman -Syu
 sudo pacman -S base-devel coreutils  \
                  git ninja gcc-fortran \
@@ -67,7 +67,7 @@ Install the latest version of:
 - [Intel® oneAPI HPC Toolkit](https://www.intel.com/content/www/us/en/developer/tools/oneapi/hpc-toolkit-download.html)
 
 Then, in order to initialize your development environment, open a terminal window and run:
-```console
+```shell
 "C:\Program Files (x86)\Intel\oneAPI\setvars.bat"
 ```
 
@@ -92,14 +92,14 @@ You can now follow the appropriate instructions for your distribution.
 
   - **If you use [ZSH]** (Verify with `echo $SHELL`)
 
-```console
+```shell
 touch ~/.zshrc
 open ~/.zshrc
 ```
 
   - **If you use [BASH]** (Verify with `echo $SHELL`)
 
-```console
+```shell
 touch ~/.bash_profile
 open ~/.bash_profile
 ```
@@ -111,7 +111,7 @@ These lines ensure that LLVM's Clang, and Apple's modified version of GCC, won't
 Further reading on `open-mpi` incompatibility with `clang`-based `gcc` on macOS: [here](https://stackoverflow.com/questions/27930481/how-to-build-openmpi-with-homebrew-and-gcc-4-9).
 We do *not* support `clang` due to conflicts with the Silo dependency.
 
-```console
+```shell
 export MFC_GCC_VER=13
 export CC=gcc-$MFC_GCC_VER
 export CXX=g++-$MFC_GCC_VER
@@ -120,7 +120,7 @@ export FC=gfortran-$MFC_GCC_VER
 
 **Close the open editor and terminal window**. Open a **new terminal** window before executing the commands below.
 
-```console
+```shell
 brew install wget python cmake gcc@$MFC_GCC_VER mpich
 ```
 
@@ -138,22 +138,22 @@ First install Docker and Git:
 - Windows: [Docker](https://docs.docker.com/get-docker/) + [Git](https://git-scm.com/downloads).
 - macOS: `brew install git docker` (requires [Homebrew](https://brew.sh/)).
 - Other systems:
-```console
+```shell
 sudo apt install git docker # Debian / Ubuntu via Aptitude
 sudo pacman -S git docker   # Arch Linux via Pacman
 ```
 
 Once Docker and Git are installed on your system, clone MFC with
 
-```console
+```shell
 git clone https://github.com/MFlowCode/MFC
 cd MFC 
 ```
 
 To fetch the prebuilt Docker image and enter an interactive bash session with the
 recommended settings applied, run
 
-```console
+```shell
   ./mfc.sh  docker # If on \*nix/macOS
   .\mfc.bat docker # If on Windows
 ```
@@ -190,7 +190,7 @@ To only select a subset, use the `-t` (i.e., `--targets`) argument.
 For a detailed list of options, arguments, and features, please refer to `./mfc.sh build --help`.
 
 Most first-time users will want to build MFC using 8 threads (or more!) with MPI support:
-```console
+```shell
 ./mfc.sh build -j 8
 ```
 
@@ -204,7 +204,7 @@ Examples:
 
 Run MFC's test suite with 8 threads:
 
-```console
+```shell
 ./mfc.sh test -j 8
 ```
 
@@ -214,7 +214,7 @@ Please refer to the [Testing](testing.md) document for more information.
 
 MFC has example cases in the `examples` folder. You can run such a case interactively using 2 tasks by typing:
 
-```console
+```shell
 ./mfc.sh run examples/2D_shockbubble/case.py -n 2
 ```
 

docs/documentation/running.md

@@ -32,7 +32,7 @@ Please refer to `./mfc.sh run -h` for a complete list of arguments and options,
 
 To run all stages of MFC, that is [pre_process](https://github.com/MFlowCode/MFC/tree/master/src/pre_process/), [simulation](https://github.com/MFlowCode/MFC/tree/master/src/simulation/), and [post_process](https://github.com/MFlowCode/MFC/tree/master/src/post_process/) on the sample case [2D_shockbubble](https://github.com/MFlowCode/MFC/tree/master/examples/2D_shockbubble/),
 
-```console
+```shell
 ./mfc.sh run examples/2D_shockbubble/case.py
 ```
 
@@ -45,14 +45,14 @@ For example,
 
 - Running [pre_process](https://github.com/MFlowCode/MFC/tree/master/src/pre_process/) with 2 cores:
 
-```console
+```shell
 ./mfc.sh run examples/2D_shockbubble/case.py -t pre_process -n 2
 ```
 
 - Running [simulation](https://github.com/MFlowCode/MFC/tree/master/src/simulation/) and [post_process](https://github.com/MFlowCode/MFC/tree/master/src/post_process/)
 using 4 cores:
 
-```console
+```shell
 ./mfc.sh run examples/2D_shockbubble/case.py -t simulation post_process -n 4
 ```
 
@@ -64,7 +64,7 @@ The number of nodes can be specified with the `-N` (i.e., `--nodes`) option.
 
 We provide a list of (baked-in) submission batch scripts in the `toolchain/templates` folder.
 
-```console
+```shell
 ./mfc.sh run examples/2D_shockbubble/case.py -e batch -N 2 -n 4 -t simulation -c <computer name>
 ```
 
@@ -167,14 +167,14 @@ in which $t_i$ is the starting time, $t_f$ is the final time, and $SF$ is the sa
 	- There are several ways to do this. Keep in mind that, regardless of the .py file used, the post_process command will generate output files in the [`t_step_start`, `t_step_stop`] range, with `t_step_save` as the spacing between files.
 	- One way is to set `t_step_stop` to the restarting point $t_s$ in `case.py`. Then, run the commands below. The first command will run on timesteps $[t_i, t_s]$. The second command will run on $[t_s, t_{f2}]$. Therefore, the whole range $[t_i, t_{f2}]$ will be post processed.
 
-```console
+```shell
 ./mfc.sh run case.py -t post_process
 ./mfc.sh run restart_case.py -t post_process
 ```	
 
 We have provided an example, `case.py` and `restart_case.py` in `/examples/1D_vacuum_restart/`. This simulation is a duplicate of the `1D_vacuum` case. It demonstrates stopping at timestep 7000, adding a new patch, and restarting the simulation. To test this code, run:
 
-```console
+```shell
 ./mfc.sh run examples/1D_vacuum_restart/case.py -t pre_process simulation
 ./mfc.sh run examples/1D_vacuum_restart/restart_case.py -t pre_process simulation
 ./mfc.sh run examples/1D_vacuum_restart/case.py -t post_process
@@ -185,7 +185,7 @@ We have provided an example, `case.py` and `restart_case.py` in `/examples/1D_va
 
 - Oak Ridge National Laboratory's [Summit](https://www.olcf.ornl.gov/summit/):
 
-```console
+```shell
 ./mfc.sh run examples/2D_shockbubble/case.py -e batch \
                -N 2 -n 4 -t simulation -a <redacted> -c summit
 ```

docs/documentation/testing.md

@@ -1,7 +1,7 @@
 ## Testing
 
 To run MFC's test suite, run
-```console
+```shell
 ./mfc.sh test -j <thread count>
 ```
 
@@ -21,7 +21,7 @@ To run a (non-contiguous) subset of tests, use the `--only` (`-o`) option instea
 ### Creating Tests
 
 To (re)generate *golden files*, append the `--generate` option:
-```console
+```shell
 ./mfc.sh test --generate -j 8
 ```
 
@@ -87,7 +87,7 @@ Finally, the case is appended to the `cases` list, which will be returned by the
 ### Testing Post Process
 
 To test updated post process code, append the `-a` or `--test-all` option: 
-```console
+```shell
 ./mfc.sh test -a -j 8
 ```
 

docs/documentation/visualization.md

@@ -91,7 +91,7 @@ This is optional and defaults to whatever is set on line 52 of `pace-paraview-se
 Once you run `./pace-paraview-server <options>`, it'll take a bit to start up. 
 In the meantime, you'll see the below message:
 
-```console
+```shell
 Submitted batch job <job #>
 Waiting for ParaView server to start. This may take several minutes  ...
 ```

examples/3D_weak_scaling/README.md

@@ -16,7 +16,7 @@ Weak scaling benchmarks can be produced by keeping _gbpp_ constant and varying _
 For example, to run a weak scaling test that uses ~4GB of GPU memory per rank
 on 8 2-rank nodes with case optimization, one could:
 
-```console
+```shell
 ./mfc.sh run examples/3D_weak_scaling/case.py 4 -t pre_process simulation          \
              -e batch -p mypartition -N 8 -n 2 -w "01:00:00" -# "MFC Weak Scaling" \
              --case-optimization -j 32