Update Omega website docs and fix various typos

Author: bclyons12

docs/src/develop.md

@@ -51,22 +51,22 @@ A crucial part of our PR process is **code review**. It is where your peers get
 ## Add/modify entries in `dd`
 
 The `dd` data structure is defined under the [IMASdd.jl](https://github.com/ProjectTorreyPines/IMASdd.jl) package.
-See the documentation there to how add/modify entries in `dd`.
+See the documentation there for how to add/modify entries in `dd`.
 
 ## Write a new actor
 
 See the Jupyter [new actor tutorial](https://github.com/ProjectTorreyPines/FuseExamples/blob/master/new_actor.ipynb)
 
 ## Add/modify examples
 
-The [FuseExamples repository](https://github.com/ProjectTorreyPines/FuseExamples) contains jupyter notebook that showcase some possible uses of FUSE.
+The [FuseExamples repository](https://github.com/ProjectTorreyPines/FuseExamples) contains jupyter notebooks that showcase some possible uses of FUSE.
 
 !!! note
-    When committing changes to in a jupyter notebook, make sure that all the output cells are cleared! This is important to keep the size of the repository in check.
+    When committing changes to a jupyter notebook, make sure that all the output cells are cleared! This is important to keep the size of the repository in check.
 
 ## Add/modify a new cluster
 
-The `parallel_environment()` function is used to easily setup the working environment for distributed jobs. Edit it [here](https://github.com/search?q=repo%3AProjectTorreyPines%2FFUSE.jl+%22function+parallel_environment%22&type=code) with your own cluster, folllowing the others as a template.
+The `parallel_environment()` function is used to easily setup the working environment for distributed jobs. Edit it [here](https://github.com/search?q=repo%3AProjectTorreyPines%2FFUSE.jl+%22function+parallel_environment%22&type=code) with your own cluster, following the others as a template.
 
 ## Write IMAS physics functions
 
@@ -94,14 +94,14 @@ end
 
 ## Add/modify entries in `ini` and `act`
 
-The functinoality of the `ini` and `act` parameters is implemented in the [SimulationParameters.jl](https://github.com/ProjectTorreyPines/SimulationParameters.jl) package.
+The functionality of the `ini` and `act` parameters is implemented in the [SimulationParameters.jl](https://github.com/ProjectTorreyPines/SimulationParameters.jl) package.
 
 * The `ini` parameters are all defined in the `FUSE/src/parameters_init.jl` file. Add/edit entries there.
 * The `act` parameters of each actor are defined where that actor is defined. Add/edit entries there.
 
 ## Profiling and writing fast Julia code
 
-First let's do some profiling to identify problemetic functions:
+First let's do some profiling to identify problematic functions:
 
 1. Run FUSE from the VScode Julia REPL (`<Command-Shift-p>` and then `Julia: Start REPL`)
    ```julia
@@ -118,7 +118,7 @@ First let's do some profiling to identify problemetic functions:
 
 1. Use `@time` to monitor execution time and allocations
 
-1. For functions that return very quickly one can use `BenchmarkTooks.@benchmark`
+1. For functions that return very quickly one can use `BenchmarkTools.@benchmark`
 
 1. Graphical profiling of the execution time is a powerful way to understand where time is spent
    ```julia
@@ -265,7 +265,7 @@ This can be particularly useful for benchmarking FUSE physics against existing P
    ```
 
    !!! note
-       If you have more than one Julia version on our system, we could specify it with an argument:
+       If you have more than one Julia version on your system, we could specify it with an argument:
        ```
        julia.install(julia="/Users/meneghini/.julia/juliaup/julia-1.8.5+0.x64.apple.darwin14/bin/julia")
        ```

docs/src/install.md

@@ -6,7 +6,7 @@ We highly recommend using the [Juliaup](https://github.com/JuliaLang/juliaup) ma
 * Mac & Linux: `curl -fsSL https://install.julialang.org | sh`
 * Windows: `winget install julia -s msstore --accept-source-agreements --accept-package-agreements`
 
-Once installed, restart your termninal to pick-up the `julia` executable.
+Once installed, restart your terminal to pick-up the `julia` executable.
 
 ## FUSE installation
 
@@ -57,7 +57,7 @@ For installation start your Julia interpreter by typing `julia` at the terminal,
 
        Make sure WebIO is working with `jupyter labextension list`. If it is working properly, you should see something like: webio-jupyterlab-provider v0.1.0 enabled OK (python, webio_jupyter_extension). This can also be checked with `jupyter nbextension list`, which should show something like: webio-jupyter-nbextension/nbextension  enabled.
 
-       If the extension has compatibility issues, install an older verision of Jupyter (eg. `conda install jupyterlab=3.6.7`). Also ensure that the WebIO and Interact packages are fully up-to-date, and restart the notebook session before testing that it works. Finally, it may be necessary to downgrade your system's version of Python - the recommended version for compatibility with Interact is 3.11.11.
+       If the extension has compatibility issues, install an older version of Jupyter (eg. `conda install jupyterlab=3.6.7`). Also ensure that the WebIO and Interact packages are fully up-to-date, and restart the notebook session before testing that it works. Finally, it may be necessary to downgrade your system's version of Python - the recommended version for compatibility with Interact is 3.11.11.
 
 1. Install the `IJulia` package by running:
 

docs/src/install_omega.md

@@ -1,5 +1,8 @@
 # On GA's OMEGA cluster
 
+   !!! note
+       FUSE should only be run on `somega` or on a worker node, never on the `omega` login nodes.
+
 ## FUSE module
 
 If you only intend to use FUSE and don't plan to develop the source code, release versions of FUSE
@@ -31,37 +34,18 @@ The FUSE module does several things:
    start a Jupyter session and select the desired kernels. There is a kernel with 1 thread meant
    for the login nodes and 10 & 16 threads for the worker nodes.
    !!! warning
-       **Problem**: There's a bug that may occur when a new user first launches one of these
+       **Potential Problem**: There's a bug that may occur when a new user first launches one of these
        Julia + FUSE Jupyter kernels.
-       In your terminal, you will see output about precompiling IJulia, which is expected.
+       In your terminal, you may see output about precompiling IJulia, which is expected.
        Once the precompilation is done, it will report `Starting kernel event loops` but then the
        kernel may hang and your notebook may not work. It is unclear why this happens, but it is
        only the first time for each user.
 
-       **Solution**: Restart the kernel. Occasionally this needs to be done twice, perhaps if you
+       **Solution**: The latest installations on Omega seemed to have fixed this issue, but if it happens,
+       restart the kernel. Occasionally this needs to be done twice, perhaps if you
        restart too quickly and the precompilation was not finished. In any case, if the problem
        does not resolve after restarting the kernel twice, reach out to the FUSE developers.
 
-## Running Julia/FUSE via VScode
-
-The simplest way to start using FUSE is with [VScode and remote SHH connection](https://code.visualstudio.com/docs/remote/ssh-tutorial) to Omega.
-
-To do this:
-
-* Open a remote connection to Omega
-
-* Install the `Julia` and the `Jupyter` VScode extensions in on Omega
-
-* Open the `Code > Settings... > Settings` menu
-
-  * Select the `Remote [SSH: omega]` tab
-
-  * Search for `julia executable` in the search bar
-
-  * Edit the `julia: Executable Path` to `/fusion/projects/codes/julia/fuse/julia_with_fuse`
-
-Now Julia scripts and notebooks can be run directly from this remote VScode session.
-
 ## Connecting to a Jupyter-lab server running on OMEGA from your laptop
 
 1. Connect to `omega` and launch `screen`
@@ -139,6 +123,26 @@ Keep in mind that each worker node on Omega has 128 CPUs
 
    Here we will use the `FUSE.parallel_environment("omega", ...)` call.
 
+## Running Julia/FUSE via VScode
+
+You can use [VScode and remote SHH connection](https://code.visualstudio.com/docs/remote/ssh-tutorial) to run Julia and FUSE on Omega.
+
+To do this:
+
+* Open a remote connection to Omega
+
+* Install the `Julia` and the `Jupyter` VScode extensions in on Omega
+
+* Open the `Code > Settings... > Settings` menu
+
+  * Select the `Remote [SSH: omega]` tab
+
+  * Search for `julia executable` in the search bar
+
+  * Edit the `julia: Executable Path` to `/fusion/projects/codes/julia/fuse/julia_with_fuse`
+
+Now Julia scripts and notebooks can be run directly from this remote VScode session.
+
 ## Using Revise on Omega
 When working on omega it seems ones need to manually trigger revise to pick up code changes:
 ```