docs: updated first problem page

docs/_data/navigation.yml

@@ -13,10 +13,8 @@ leftcontents:
     children:
       - title: "Installation"
         url: /getting-started/installation/
-      - title: "Running the code"
+      - title: "Running your first problem"
         url: /getting-started/running/
-      - title: "Examples"
-        url: /getting-started/examples/
       - title: "Source code documentation"
         url: /source_docs
   - title: General
@@ -35,8 +33,6 @@ leftcontents:
     children:
       - title: "About Pylbo"
         url: /pylbo/about_pylbo/
-      - title: "Installing Pylbo"
-        url: /pylbo/installing_pylbo/
       - title: "Interfacing with Legolas"
         url: /pylbo/legolas_interface/
       - title: "Using Pylbo"

docs/getting-started/running.md

@@ -1,28 +1,78 @@
 ---
 title: Running Legolas
 layout: single
+classes: wide
 sidebar:
   nav: "leftcontents"
-toc: true
-last_modified_at: 2021-02-02
+toc: false
+last_modified_at: 2021-07-26
 ---
 
-Once you have compiled Legolas it will have placed an executable in your current working directory (or in the
-source directory if you chose an [in-repository build](../installation/#1-in-repository-build)).
-The executable can be run in two ways, either through direct calling or through the Pylbo interface.
+Once you cloned the repository and installed the Pylbo framework you are set to run your first problem.
+As an example here we will run one of the pre-implemented equilibria already present in the source code.
 
-# 1. Running Legolas directly
-Passing parameters to Legolas is done through the use of a parameter file.
-If you've set up your current running directory using `setuplegolas.py`, the script will have asked to copy over the
-parfile. Edit this file to your needs, take a look at the different [possibilities](../../general/parameter_file).
-Afterwards you simply call the executable from the command line, passing the parfile as an option:
+## Running your first problem
+Navigate to a directory of your choosing where you want to place the configuration files and output, and call the setup script:
 ```bash
-./legolas -i parfile.par
+cd my_favourite_directory
+setuplegolas.py
 ```
-The output is one single file, placed by default in a subdirectory `output` which is created during compilation.
+Follow the instructions, this script will do and ask you a couple of things:
+1. It copies over a `CMakeLists.txt` file if not already present
+2. Ask if you want to copy over `pylbo_wrapper.py`, you need this if you want to plot your results immediately after running. **Answer yes**
+3. Ask if you want to copy over a parfile if none was found. **Answer no**
+4. Ask if you want to copy over a default submodule template `smod_user_defined.f08` if none was found. **Answer no**
 
-# 2. Interfacing with Pylbo
-A second way to run Legolas is through the Pylbo-interface, which is extremely handy when you are doing parametric studies 
-or want to run multiple setups at once. This obviously requires you to have Pylbo installed, explained [here](../../pylbo/installing_pylbo).
-More information on how to run Legolas like this can be found on the [Interfacing with Legolas](../../pylbo/legolas_interface) page.
+Since we are running a pre-implemented equilibrium we do not need the `smod_user_defined.f08` file, this one is only needed if you want to
+set up and run your own problem.
 
+Next call the build script:
+```bash
+buildlegolas.sh
+```
+If everything went well you should have 5 items in your current working directory: a `CMakeLists.txt` file, a `build` folder, an `output` folder,
+the file `pylbo_wrapper.py` and the `legolas` executable.
+
+<i class="fa fa-exclamation-triangle" aria-hidden="true"></i>
+It is NOT recommended to create custom build or run directories _inside_ the main legolas folder.
+Keeping the repository clean ensures that you don't run into merge conflicts when updating the code.
+Run the setup scripts in a separate directory and let them take care of linking.
+{: .notice--warning}
+
+## Creating the configuration file
+Configuring Legolas is done through use of a "parfile", where various options are passed in the form of Fortran namelists. For an overview
+of different possibilities you can take a look [here](../../general/parameter_file).
+During setup we answered "no" when the script asked to copy over the parfile.
+ For now, create a new file called `my_setup.par` in which you copy the following lines:
+```fortran
+&gridlist
+  gridpoints = 50
+/
+
+&equilibriumlist
+  equilibrium_type = "rayleigh_taylor"
+/
+
+&savelist
+  write_eigenfunctions = .true.
+  show_results = .true.
+/
+```
+
+## Running the code
+Finally call `legolas` and supply the parfile you just created as argument:
+```bash
+./legolas -i my_setup.par
+```
+This will run a setup which defines Rayleigh-Taylor instabilities in a Cartesian geometry,
+the spectrum itself should correspond to case **a** in Section 13.2, p. 487 of [MHD of Laboratory and Astrophysical Plasmas](http://doi.org/10.1017/9781316403679).
+
+When the run is completed (this should take a few seconds) the code will immediately fire up the post-processing framework since we set `show_results = .true.` in the parfile.
+A few interactive figures will pop up, including the spectrum. Click on one of the eigenvalues in the figure and press `Enter`, this will draw the corresponding eigenfunctions.
+You can cycle through multiple eigenfunctions using the arrow keys, right-clicking a point unselects it and pressing the `d` key clears all selected points.
+
+The legend shows the various continuum regions, which can also be interactively toggled by clicking on their legend entries.
+More information on the interface can be found [here](../../pylbo/using_pylbo/#interactive-continua--eigenfunctions).
+
+This covers the basics of running Legolas on a single equilibrium. You can take a look at the various [pre-implemented equilibria](../../general/equilibria) and
+modify the `equilibriumlist` or `paramlist` accordingly to play around with different options.