diff --git a/batch/hpc_init.sh b/batch/hpc_init.sh index 2a73268f5..b48a2759a 100644 --- a/batch/hpc_init.sh +++ b/batch/hpc_init.sh @@ -112,7 +112,7 @@ read FLEPI_RUN_INDEX cat << EOM > The HPC init script has successfully finished. -If you are testing if this worked, say installing for the first time, you can use the inference example from the \`flepimop_sample\` repository: +If you are testing if this worked, say installing for the first time, you can use the inference example from the \`flepiMoP/examples/tutorials\` directory: \`\`\`bash cd \$PROJECT_PATH flepimop-inference-main -c \$CONFIG_PATH -j 1 -n 1 -k 1 diff --git a/documentation/gitbook/gempyor/output-files.md b/documentation/gitbook/gempyor/output-files.md index b1a0cd129..942d2a906 100644 --- a/documentation/gitbook/gempyor/output-files.md +++ b/documentation/gitbook/gempyor/output-files.md @@ -12,7 +12,7 @@ These files contain the values of the variables for both the infection and (if i Within the `model_output` directory in the project's directory, the files will be organized into folders named for the file types: `seir`, `spar`, `snpi`, `hpar`, `hnpi`, `seed`, `init`, or `llik` (see descriptions below). Within each file type folder, files will further be organized by the simulation name (`setup_name` in config), the modifier scenario names - if scenarios exist for either `seir` or `outcome` parameters (specified with `seir_modifiers::scenarios` and `outcome_modifiers::scenarios` in config), and the `run_id` (the date and time of the simulation, by default). For example: -
flepimop_sample
+
flepiMoP/examples/tutorials
 ├── model_output
 │   ├── {setup_name}_{seir_modifier_scenario}_{outcome_modifier_scenario}
 │   │   └── run_id
diff --git a/documentation/gitbook/how-to-run/advanced-run-guides/quick-start-guide-conda.md b/documentation/gitbook/how-to-run/advanced-run-guides/quick-start-guide-conda.md
index eb632bf41..1110f99c5 100644
--- a/documentation/gitbook/how-to-run/advanced-run-guides/quick-start-guide-conda.md
+++ b/documentation/gitbook/how-to-run/advanced-run-guides/quick-start-guide-conda.md
@@ -6,28 +6,23 @@ description: Short tutorial on running locally using an "Anaconda" environment.
 
 ### Access model files
 
-As is the case for any run, first see the [Before any run](../before-any-run.md) section to ensure you have access to the correct files needed to run. On your local machine, determine the file paths to:
+Follow all the steps in the [Before any run](before-any-run.md) section to ensure you have access to the correct files needed to run your model with flepiMoP.
 
-* the directory containing the flepimop code (likely the folder you cloned from Github), which we'll call `FLEPI_PATH`
-* the directory containing your project code including input configuration file and population structure (again likely from Github), which we'll call `DATA_PATH`
+Take note of the location of the directory on your local computer where you cloned the flepiMoP model code (which we'll call `FLEPI_PATH`).
 
 {% hint style="info" %}
-For example, if you clone your Github repositories into a local folder called Github and are using the flepimop\_sample as a project repository, your directory names could be\
+For example, if you cloned your Github repositories into a local folder called `Github` and are using `flepiMoP/examples/tutorials` as a project repository, your directory names could be\
 \
 _**On Mac:**_
 
-\ = /Users/YourName/Github/flepiMoP
+/Users/YourName/Github/flepiMoP
 
-\ = /Users/YourName/Github/flepimop\_sample\
+/Users/YourName/Github/fleiMoP/examples/tutorials
 \
 _**On Windows:**_\
-\ = C:\Users\YourName\Github\flepiMoP
+C:\Users\YourName\Github\flepiMoP
 
-\ = C:\Users\YourName\Github\flepimop\_sample\\
-
-(hint: if you navigate to a directory like `C:\Users\YourName\Github` using `cd C:\Users\YourName\Github`, modify the above `` paths to be `.\flepiMoP` and `.\flepimop_sample)`
-
-:warning: Note again that these are best cloned **flat.**
+C:\Users\YourName\Github\flepiMoP\examples\tutorials
 {% endhint %}
 
 ## 🧱 Setup (do this once)
@@ -80,62 +75,45 @@ In this `conda` environment, commands with R and python will uses this environme
 
 ### Define environment variables
 
-First, you'll need to fill in some variables that are used by the model. This can be done in a script (an example is provided at the end of this page). For your first time, it's better to run each command individually to be sure it exits successfully.
+Since you'll be navigating frequently between the folder that contains your project code and the folder that contains the core flepiMoP model code, it's helpful to define shortcuts for these file paths. You can do this by creating environmental variables that you can then quickly call instead of writing out the whole file path.
 
-First, in `myparentfolder` populate the folder name variables for the paths to the flepimop code folder and the project folder:
+If you're on a **Mac** or Linux/Unix based operating system, define the FLEPI\_PATH and PROJECT\_PATH environmental variables to be your directory locations, for example
 
 ```bash
-export FLEPI_PATH=$(pwd)/flepiMoP
-export DATA_PATH=$(pwd)/flepimop_sample
+export FLEPI_PATH=/Users/YourName/Github/flepiMoP
+export PROJECT_PATH=/Users/YourName/Github/flepiMoP/examples/tutorials
 ```
 
-Go into the code directory (making sure it is up to date on your favorite branch) and do the installation required of the repository:
+or, if you have already navigated to your flepiMoP directory
 
 ```bash
-cd $FLEPI_PATH # move to the flepimop directory
-Rscript build/local_install.R # Install R packages
-pip install --no-deps -e flepimop/gempyor_pkg/ # Install Python package gempyor
+export FLEPI_PATH=$(pwd)
+export PROJECT_PATH=$(pwd)/examples/tutorials
 ```
 
-Each installation step may take a few minutes to run.
-
-{% hint style="info" %}
-Note: These installations take place in your conda environment and not the local operating system. They must be made once while in your environment and need not be done for every time you run a model, provided they have been installed once. You will need an active internet connection for installing the R packages (since some are hosted online), but not for other steps of running the model.
-{% endhint %}
-
-

-
-Help! I have errors in installation
-
-If you get an error because no cran mirror is selected, just create in your home directory a `.Rprofile` file:
+You can check that the variables have been set by either typing `env` to see all defined environmental variables, or typing `echo $FLEPI_PATH` to see the value of `FLEPI_PATH`.
 
-{% code title="~/.Rprofile" lineNumbers="true" %}
-```r
-local({r <- getOption("repos")
-       r["CRAN"] <- "http://cran.r-project.org" 
-       options(repos=r)
-})
-```
-{% endcode %}
+If you're on a **Windows** machine
 
-Perhaps this should be added to the top of the local\_install.R script #todo
+
set FLEPI_PATH=C:\Users\YourName\Github\flepiMoP
+set PROJECT_PATH=C:\Users\YourName\Github\flepiMoP\examples\tutorials
+

 
-When running `local_install.R` the first time, you may get an error:
+or, if you have already navigated to your flepiMoP directory
 
-
ERROR: dependency ‘report.generation’ is not available for package ‘inference’
-[...]
-installation of package ‘./R/pkgs//inference’ had non-zero exit status
-

+
set FLEPI_PATH=%CD%
+set PROJECT_PATH=%CD%\examples\tutorials
+

 
-and the second time it'll finish successfully (no non-zero exit status at the end). That's because there is a circular dependency in this file (inference requires report.generation which is built after) and will hopefully get fixed.
+You can check that the variables have been set by either typing `set` to see all defined environmental variables, or typing `echo $FLEPI_PATH$` to see the value of `FLEPI_PATH`.
 
-For subsequent runs, once is enough because the package is already installed once.
-
-

+{% hint style="info" %}
+If you choose not to define environment variables, remember to use the full or relative path names for navigating to the right files or folders in future steps.
+{% endhint %}
 
-Other environmental variables can be set at any point in process of setting up your model run. These options are listed in ... ADD ENVAR PAGE
+Other environmental variables can be set at any point in process of setting up your model run. These options are listed in ... **ADD ENVAR PAGE**
 
-For example, some frequently used environmental variables which we recommend setting are:
+For example, some frequently used environmental variables we recommend setting are:
 
 {% code overflow="wrap" %}
 ```bash
@@ -153,19 +131,19 @@ The next step depends on what sort of simulation you want to run: One that inclu
 In either case, navigate to the project folder and make sure to delete any old model output files that are there.
 
 ```bash
-cd $DATA_PATH       # goes to your project repository
+cd $PROJECT_PATH       # goes to your project repository
 rm -r model_output/ # delete the outputs of past run if there are
 ```
 
 #### Inference run
 
-An inference run requires a configuration file that has an `inference` section. Stay in the `$DATA_PATH` folder, and run the inference script, providing the name of the configuration file you want to run (ex. `config.yml`). In the example data folder (flepimop\_sample), try out the example config XXX.
+An inference run requires a configuration file that has an `inference` section. Stay in the `$PROJECT_PATH` folder, and run the inference script, providing the name of the configuration file you want to run (ex. `config.yml`). 
 
 ```bash
 flepimop-inference-main.R -c config.yml
 ```
 
-This will run the model and create [a lot of output files](../../gempyor/output-files.md) in `$DATA_PATH/model_output/`.
+This will run the model and create [a lot of output files](../../gempyor/output-files.md) in `$PROJECT_PATH/model_output/`.
 
 The last few lines visible on the command prompt should be:
 
@@ -191,7 +169,7 @@ where:
 
 #### Non-inference run
 
-Stay in the `$DATA_PATH` folder, and run a simulation directly from forward-simulation Python package `gempyor`. To do this, call `flepimop simulate` providing the name of the configuration file you want to run (ex. `config.yml`). An example config is provided in `flepimop_sample/config_sample_2pop_interventions.yml.`
+Stay in the `$PROJECT_PATH` folder, and run a simulation directly from forward-simulation Python package `gempyor`. To do this, call `flepimop simulate` providing the name of the configuration file you want to run (ex. `config.yml`). An example config is provided in `PROJECT_PATH/config_sample_2pop_interventions.yml.`
 
 ```
 flepimop simulate config.yml
@@ -203,23 +181,4 @@ It is currently required that all configuration files have an `interventions` se
 
 You can also try to knit the Rmd file in `flepiMoP/flepimop/gempyor_pkg/docs` which will show you how to analyze these files.
 
-### Do it all with a script
-
-The following script does all the above commands in an easy script. Save it in `myparentfolder` as `quick_setup.sh`. Then, just go to `myparentfolder` and type `source quick_setup_flu.sh` and it'll do everything for you!
 
-{% code title="quick_setup_flu.sh" lineNumbers="true" %}
-```bash
-export FLEPI_PATH=$(pwd)/flepiMoP
-export DATA_PATH=$(pwd)/flepimop_sample
-
-cd $FLEPI_PATH
-Rscript build/local_install.R
-pip install --no-deps -e gempyor_pkg/ # before: python setup.py develop --no-deps
-
-cd $DATA_PATH
-rm -rf model_output
-export CONFIG_PATH=config.yml # set your configuration file path
-
-flepimop-inference-main -j 1 -n 1 -k 1
-```
-{% endcode %}
diff --git a/documentation/gitbook/how-to-run/advanced-run-guides/running-on-a-hpc-with-slurm.md b/documentation/gitbook/how-to-run/advanced-run-guides/running-on-a-hpc-with-slurm.md
index 8c9fa7967..d7eccd6fa 100644
--- a/documentation/gitbook/how-to-run/advanced-run-guides/running-on-a-hpc-with-slurm.md
+++ b/documentation/gitbook/how-to-run/advanced-run-guides/running-on-a-hpc-with-slurm.md
@@ -56,8 +56,7 @@ $ ./flepiMoP/build/hpc_install_or_update.sh 
 
 These steps to initialize the environment need to run on a per run or as needed basis.
 
-Change directory to where a full clone of the `flepiMoP` repository was placed (it will state the location in the output of the script above). And then run the `hpc_init.sh` script, substituting `` with either `rockfish` or `longleaf`. This script will assume the same defaults as the script before for where the `flepiMoP` clone is and the name of the conda environment. This script will also ask about a project directory and config, if this is your first time initializing `flepiMoP` it might be helpful to clone [the `flepimop_sample` GitHub repository](https://github.com/HopkinsIDD/flepimop\_sample) to the same directory to use as a test.
-
+Change directory to where a full clone of the `flepiMoP` repository was placed (it will state the location in the output of the script above). And then run the `hpc_init.sh` script, substituting `` with either `rockfish` or `longleaf`. This script will assume the same defaults as the script before for where the `flepiMoP` clone is and the name of the conda environment. This script will also ask about a project directory and config, if this is your first time initializing `flepiMoP` it might be helpful to use configs out of `flepiMoP/examples/tutorials` directory as a test. 
 ```
 $ source batch/hpc_init.sh 
 ```
@@ -82,7 +81,7 @@ If you'd like to have more control, you can specify the arguments manually:
 $ python $FLEPI_PATH/batch/inference_job_launcher.py --slurm \
                     -c $CONFIG_PATH \
                     -p $FLEPI_PATH \
-                    --data-path $DATA_PATH \
+                    --data-path $PROJECT_PATH \
                     --upload-to-s3 True \
                     --id $FLEPI_RUN_INDEX \
                     --fs-folder /scratch4/primary-user/flepimop-runs \
diff --git a/documentation/gitbook/how-to-run/advanced-run-guides/running-on-aws.md b/documentation/gitbook/how-to-run/advanced-run-guides/running-on-aws.md
index 69ddbb2a3..19134489d 100644
--- a/documentation/gitbook/how-to-run/advanced-run-guides/running-on-aws.md
+++ b/documentation/gitbook/how-to-run/advanced-run-guides/running-on-aws.md
@@ -110,11 +110,11 @@ export FLEPI_MEM_PROFILE=TRUE
 export FLEPI_MEM_PROF_ITERS=50
 ```
 
-Then prepare the pipeline directory (if you have already done that and the pipeline hasn't been updated (`git pull` says it's up to date). You need to set $DATA\_PATH to your data folder. For a COVID-19 run, do:
+Then prepare the pipeline directory (if you have already done that and the pipeline hasn't been updated (`git pull` says it's up to date). You need to set $PROJECT\_PATH to your data folder. For a COVID-19 run, do:
 
 ```bash
 cd ~/drp
-export DATA_PATH=$(pwd)/COVID19_USA
+export PROJECT_PATH=$(pwd)/COVID19_USA
 export GT_DATA_SOURCE="csse_case, fluview_death, hhs_hosp"
 ```
 
@@ -122,13 +122,13 @@ for Flu do:
 
 ```bash
 cd ~/drp
-export DATA_PATH=$(pwd)/Flu_USA
+export PROJECT_PATH=$(pwd)/Flu_USA
 ```
 
 Now for any type of run:
 
 ```bash
-cd $DATA_PATH
+cd $PROJECT_PATH
 export FLEPI_PATH=$(pwd)/flepiMoP
 cd $FLEPI_PATH
 git checkout main
@@ -153,12 +153,12 @@ For now, just in case: update the `arrow` package from 8.0.0 in the docker to 11
 Now flepiMoP is ready 🎉 ;
 
 ```bash
-cd $DATA_PATH
+cd $PROJECT_PATH
 git pull 
 git checkout main
 ```
 
-Do some clean-up before your run. The fast way is to restore the `$DATA_PATH` git repository to its blank states (⚠️ removes everything that does not come from git):
+Do some clean-up before your run. The fast way is to restore the `$PROJECT_PATH` git repository to its blank states (⚠️ removes everything that does not come from git):
 
 
git reset --hard && git clean -f -d  # this deletes everything that is not on github in this repo !!!
 

@@ -178,7 +178,7 @@ rm -rf model_output data/us_data.csv data-truth &&
    rm -rf data/seeding_territories_Level5.csv data/seeding_territories_Level67.csv
 
 # don't delete model_output if you have another run in //
-rm -rf $DATA_PATH/model_output
+rm -rf $PROJECT_PATH/model_output
 ```
 
 
@@ -240,7 +240,7 @@ If you'd like to have more control, you can specify the arguments manually:
 
python $FLEPI_PATH/batch/inference_job_launcher.py --aws \ ## FIX THIS TO REFLECT AWS OPTIONS
                     -c $CONFIG_PATH \
                     -p $FLEPI_PATH \
-                    --data-path $DATA_PATH \
+                    --data-path $PROJECT_PATH \
                     --upload-to-s3 True \
                     --id $FLEPI_RUN_INDEX \
                     --restart-from-location $RESUME_LOCATION
@@ -250,7 +250,7 @@ We allow for a number of different jobs, with different setups, e.g., you may _n
 
 {% tabs %}
 {% tab title="Standard" %}
-
cd $DATA_PATH 
+
cd $PROJECT_PATH 
 
 $FLEPI_PATH/batch/inference_job_launcher.py --aws -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic
 

@@ -259,7 +259,7 @@ We allow for a number of different jobs, with different setups, e.g., you may _n
 {% tab title="Non-inference" %}
 {% code overflow="wrap" %}
 ```bash
-cd $DATA_PATH 
+cd $PROJECT_PATH 
 
 $FLEPI_PATH/batch/inference_job_launcher.py --aws -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic -j 1 -k 1
 ```
@@ -271,7 +271,7 @@ $FLEPI_PATH/batch/inference_job_launcher.py --aws -c $CONFIG_PATH -q $COMPUTE_QU
 
 **Carrying seeding** (_do this to use seeding fits from resumed run_):
 
-
cd $DATA_PATH 
+
cd $PROJECT_PATH
 
 $FLEPI_PATH/batch/inference_job_launcher.py --aws -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic --resume-carry-seeding --restart-from-location $RESUME_LOCATION
 

@@ -280,7 +280,7 @@ $FLEPI_PATH/batch/inference_job_launcher.py --aws -c $CONFIG_PATH -q $COMPUTE_QU
 
 {% code overflow="wrap" %}
 ```bash
-cd $DATA_PATH 
+cd $PROJECT_PATH 
 
 $COVID_PATH/batch/inference_job_launcher.py --aws -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic --resume-discard-seeding --restart-from-location $RESUME_LOCATION
 ```
@@ -290,7 +290,7 @@ $COVID_PATH/batch/inference_job_launcher.py --aws -c $CONFIG_PATH -q $COMPUTE_QU
 
 {% code overflow="wrap" %}
 ```bash
-cd $DATA_PATH 
+cd $PROJECT_PATH 
 
 $COVID_PATH/batch/inference_job_launcher.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic --resume-carry-seeding --restart-from-location $RESUME_LOCATION
 ```
diff --git a/documentation/gitbook/how-to-run/advanced-run-guides/running-with-docker-locally.md b/documentation/gitbook/how-to-run/advanced-run-guides/running-with-docker-locally.md
index b81eb8018..d1de4e8e3 100644
--- a/documentation/gitbook/how-to-run/advanced-run-guides/running-with-docker-locally.md
+++ b/documentation/gitbook/how-to-run/advanced-run-guides/running-with-docker-locally.md
@@ -10,26 +10,22 @@ description: >-
 
 See the [Before any run](../before-any-run.md) section to ensure you have access to the correct files needed to run. On your local machine, determine the file paths to:
 
-* the directory containing the flepimop code (likely the folder you cloned from Github), which we'll call ``
-* the directory containing your project code including input configuration file and population structure (again likely from Github), which we'll call ``
+* the directory containing the flepimop code (likely the folder you cloned from Github), which we'll call ``
+* the directory containing your project code including input configuration file and population structure, which we'll call ``
 
 {% hint style="info" %}
 For example, if you clone your Github repositories into a local folder called Github and are using the flepimop\_sample as a project repository, your directory names could be\
 \
 _**On Mac:** ;
 
-\ = /Users/YourName/Github/flepiMoP
+\ = /Users/YourName/Github/flepiMoP
 
-\ = /Users/YourName/Github/flepimop\_sample\
+\ = /Users/YourName/Github/fleiMoP/examples/tutorials
 \
 _**On Windows:**_ \
-\ = C:\Users\YourName\Github\flepiMoP
-
-\ = C:\Users\YourName\Github\flepimop\_sample\
-
-
-(hint: if you navigate to a directory like `C:\Users\YourName\Github` using `cd C:\Users\YourName\Github`, modify the above `` paths to be `.\flepiMoP` and `.\flepimop_sample)`\
+\ = C:\Users\YourName\Github\flepiMoP
 
+\ = C:\Users\YourName\Github\flepiMoP\examples\tutorials
 
 Note that Docker file and directory names are case sensitive
 {% endhint %}
@@ -82,12 +78,12 @@ First, make sure you have the latest version of the flepimop Docker (`hopkinsidd
 docker pull hopkinsidd/flepimop:latest-dev
 ```
 
-Next, run the Docker image by entering the following, replace `` and `` with the path names for your machine (no quotes or brackets, just the path text):
+Next, run the Docker image by entering the following, replace `` and `` with the path names for your machine (no quotes or brackets, just the path text):
 
 ```
 docker run -it \
-  -v :/home/app/flepimop \
-  -v :/home/app/drp \
+  -v :/home/app/flepimop \
+  -v :/home/app/drp \
 hopkinsidd/flepimop:latest-dev
 ```
 
@@ -97,7 +93,7 @@ _On Windows:_ If you get an error, you may need to delete the "\\" line breaks a
 
 In this command, we run the Docker container, creating a volume and mounting (`-v`) your code and project directories into the container. Creating a volume and mounting it to a container basically allocates space in Docker for it to mirror - and have read and write access - to files on your local machine ;
 
-The folder with the flepiMoP code `` will be on the path `flepimop` within the Docker environment, while the project folder will be at the path `drp. ;
+The folder with the flepiMoP code `` will be on the path `flepimop` within the Docker environment, while the project folder will be at the path `drp. ;
 
 {% hint style="success" %}
 You now have a local Docker container installed, which includes the R and Python versions required to run flepiMop with all the required packagers already installed ;
@@ -113,7 +109,7 @@ Create environmental variables for the paths to the flepimop code folder and the
 
 ```bash
 export FLEPI_PATH=/home/app/flepimop/
-export DATA_PATH=/home/app/drp/
+export PROJECT_PATH=/home/app/drp/
 ```
 
 Go into the code directory and do the installation the R and Python code packages
@@ -137,19 +133,19 @@ Everything is now ready 🎉  The next step depends on what sort of simulation y
 In either case, navigate to the project folder and make sure to delete any old model output files that are there
 
 ```bash
-cd $DATA_PATH       # goes to your project repository
+cd $PROJECT_PATH       # goes to your project repository
 rm -r model_output/ # delete the outputs of past run if there are
 ```
 
 ### Inference run
 
-An inference run requires a configuration file that has the `inference` section. Stay in the `$DATA_PATH` folder, and run the inference script, providing the name of the configuration file you want to run (ex. `config.yml` ;
+An inference run requires a configuration file that has the `inference` section. Stay in the `$PROJECT_PATH` folder, and run the inference script, providing the name of the configuration file you want to run (ex. `config.yml` ;
 
 ```bash
 flepimop-inference-main -c config.yml
 ```
 
-This will run the model and create a lot of output files in `$DATA_PATH/model_output/` ;
+This will run the model and create a lot of output files in `$PROJECT_PATH/model_output/` ;
 
 The last few lines visible on the command prompt should be:
 
@@ -177,22 +173,22 @@ You can put all of this together into a single script that can be run all at onc
 
 
docker pull hopkinsidd/flepimop:latest-dev
 docker run -it \
-  -v <dir1>:/home/app/flepimop \
-  -v <dir2>:/home/app/drp \
+  -v <FLEPI_PATH>:/home/app/flepimop \
+  -v <PROJECT_PATH>:/home/app/drp \
 hopkinsidd/flepimop:latest-dev
 export FLEPI_PATH=/home/app/flepimop/
-export DATA_PATH=/home/app/drp/
+export PROJECT_PATH=/home/app/drp/
 cd $FLEPI_PATH
 Rscript build/local_install.R
 pip install --no-deps -e flepimop/gempyor_pkg/
-cd $DATA_PATH
+cd $PROJECT_PATH
 rm -rf model_output
 flepimop-inference-main -j 1 -n 1 -k 1 -c config.yml
 

 
 ### Non-inference run
 
-Stay in the `$DATA_PATH` folder, and run a simulation directly from forward-simulation Python package `gempyor,`call `flepimop simulate` providing the name of the configuration file you want to run (ex. `config.yml`):
+Stay in the `$PROJECT_PATH` folder, and run a simulation directly from forward-simulation Python package `gempyor,`call `flepimop simulate` providing the name of the configuration file you want to run (ex. `config.yml`):
 
 ```
 flepimop simulate config.yml
@@ -206,15 +202,15 @@ You can put all of this together into a single script that can be run all at onc
 
 
docker pull hopkinsidd/flepimop:latest-dev
 docker run -it \
-  -v <dir1>:/home/app/flepimop \
-  -v <dir2>:/home/app/drp \
+  -v <FLEPI_PATH>:/home/app/flepimop \
+  -v <PROJECT_PATH>:/home/app/drp \
 hopkinsidd/flepimop:latest-dev
 export FLEPI_PATH=/home/app/flepimop/
-export DATA_PATH=/home/app/drp/
+export PROJECT_PATH=/home/app/drp/
 cd $FLEPI_PATH
 Rscript build/local_install.R
 pip install --no-deps -e flepimop/gempyor_pkg/
-cd $DATA_PATH
+cd $PROJECT_PATH
 rm -rf model_output
 flepimop simulate config.yml
 

diff --git a/documentation/gitbook/how-to-run/advanced-run-guides/slurm-submission-on-marcc.md b/documentation/gitbook/how-to-run/advanced-run-guides/slurm-submission-on-marcc.md
index 30e99d0ff..151c325f6 100644
--- a/documentation/gitbook/how-to-run/advanced-run-guides/slurm-submission-on-marcc.md
+++ b/documentation/gitbook/how-to-run/advanced-run-guides/slurm-submission-on-marcc.md
@@ -151,7 +151,7 @@ Create environmental variables for the paths to the flepiMoP code folder and the
 ```bash
 cd /scratch4/primary-user/flepimop-code/$USER # move to the directory where all your code is stored
 export FLEPI_PATH=$(pwd)/flepiMoP 
-export DATA_PATH=$(pwd)/flepimop-sample  # whatever your project directory is called
+export PROJECT_PATH=$(pwd)/flepiMoP/examples/tutorials  # whatever your project directory is called
 ```
 
 Go into the code directory and do the installation the R and Python code packages:
@@ -171,7 +171,7 @@ Everything is now ready 🎉 The next step depends on what sort of simulation yo
 In either case, navigate to the project directory and make sure to delete any old model output files that are there. Note that in the example config provided, the output is saved to `model_output`, but this might be otherwise defined in `config::model_output_dirname.`
 
 ```bash
-cd $DATA_PATH       # goes to your project repository
+cd $PROJECT_PATH       # goes to your project repository
 rm -r model_output/ # delete the outputs of past run if there are
 ```
 
@@ -212,7 +212,7 @@ If you'd like to have more control, you can specify the arguments manually:
 
python $FLEPI_PATH/batch/inference_job_launcher.py --slurm \
                     -c $CONFIG_PATH \
                     -p $FLEPI_PATH \
-                    --data-path $DATA_PATH \
+                    --data-path $PROJECT_PATH \
                     --upload-to-s3 True \
                     --id $FLEPI_RUN_INDEX \
                     --fs-folder /scratch4/primary-user/flepimop-runs \
diff --git a/documentation/gitbook/how-to-run/before-any-run.md b/documentation/gitbook/how-to-run/before-any-run.md
index e03bccfe7..a626d1f11 100644
--- a/documentation/gitbook/how-to-run/before-any-run.md
+++ b/documentation/gitbook/how-to-run/before-any-run.md
@@ -1,8 +1,14 @@
+---
+description: >-
+  Instructions on how to begin engaging with flepiMoP both remotely and locally.
+  Provide users with a script that will locally install flepiMoP and all packages/dependencies.
+---
+
 # Before any run
 
 ## ⇅ Get set up to use Github
 
-You need to interact with Github to run and edit `flepimop` code. [Github](https://github.com/) is a web platform for people to share and manage software, and it is based on a 'version control' software called `git` that helps programmers keep track of changes to code. Flepimop core code as well as example projects using flepimop code are all stored on Github, and frequently being updated. The first step to using flepimop for your own project is making sure you're set up to interact with code shared on Github.
+You need to interact with Github to run and edit `flepiMoP` code. [Github](https://github.com/) is a web platform for people to share and manage software, and it is based on a 'version control' software called `git` that helps programmers keep track of changes to code. Flepimop core code as well as example projects using flepimop code are all stored on Github, and frequently being updated. The first step to using flepimop for your own project is making sure you're set up to interact with code shared on Github.
 
 If you are totally new to Github, navigate to [Github.com](https://github.com/) and Sign Up for a new account. Read about the [basics of git](https://docs.github.com/en/get-started/getting-started-with-git/set-up-git).
 
@@ -10,89 +16,51 @@ To work with `flepimop` code, you can do some tasks from the Github website, but
 
 If you are a veteran user, make sure you're signed in on Github.com and through whatever method you use locally on your computer to interact with Github.
 
-## 🧺 Organizing your folders
-
-In order to run any model with flepiMoP, you need access to two separate directories: One containing the flepiMoP code (**code** directory), and another containing the specific input files to run the model of your choosing (and to save the output from that model) (**project** directory). The [flepiMoP code](https://github.com/HopkinsIDD/flepiMoP) is available in a public repository on Github which can be pulled locally to serve as the code directory. We highly recommend also using Github to create your project directory. To get familiar with the code, we recommend starting with our example configurations by making a fork of [flepimop\_sample](https://github.com/HopkinsIDD/flepimop\_sample). If you need to create your own project repository from scratch, see instructions [below](before-any-run.md#create-a-project-repository).
-
-For both the project repository and flepiMoP code repository, make sure you're on the correct branch, then pull updates from Github. Take note of the local file path to each directory.
-
-{% hint style="info" %}
-These directories can be located on your computer wherever you prefer, since you can tell flepiMoP where they are, but we recommend you clone these **flat**, e.g.
-
-```
-parentdirectory
-├── flepiMoP
-├── flepimop_sample
-└── project_directory_1
-```
-{% endhint %}
-
-### 🔐 Access the flepiMoP model code
+## 🔐 Access the flepiMoP model code
 
-To get access to the flepiMoP model code - stored as a [repository on Github.com](https://github.com/HopkinsIDD/flepiMoP) - you need to copy it to your local computer (called "[cloning](../)" in git lingo).
+In order to run a model with flepiMoP, you will need to clone the flepiMoP **code** to your machine. 
 
-**To clone the `flepimop` code repository**
+**To clone the `flepiMoP` code repository:**
 
-* If you're using the command line in a terminal, first navigate to your local directory you'll use as the parent directory for all these files. Then, use the command:\
-  `git clone https://github.com/HopkinsIDD/flepiMoP`
-* If you're using Github Desktop, go File -> Clone Repository, switch to the "URL" tab and copy the URL `https://github.com/HopkinsIDD/flepiMoP` there. For the "Local Path" option, make sure you choose your desired parent directory.
+* If you're using the command line in a terminal, first navigate to the local directory you'll use as the directory for the files that make up `flepiMoP`. Then, use the command: `git clone https://github.com/HopkinsIDD/flepiMoP`
+* If you're using Github Desktop, go File -> Clone Repository, switch to the "URL" tab and copy the URL `https://github.com/HopkinsIDD/flepiMoP` there. For the "Local Path" option, make sure you choose your desired directory.
 
-### 📂 Create a project repository from `flepimop_sample`
+You can routinely ensure that your local clone of the flepiMoP code is up to date with upstream `flepiMoP` by navigating in terminal to your `flepiMoP` directory and using the command: `git pull`
 
-The flepimop\_sample repository contains example configuration files you can use to run simple models, as well as structured model inputs (e.g., population sizes, initial conditions) organized as we recommend organizing your own project repositories. A good way to start out with flepimop is to try running these simple models, or use them as a template to make more complex ones ;
+# Locally install `flepiMoP`
 
-In order to create a sample project repository from the [flepimop\_sample](https://github.com/HopkinsIDD/flepimop\_sample) repository you can follow these steps:
+## 🐍 Install `conda`
 
-1. **Fork the sample project repository,** [flepimop\_sample](https://github.com/HopkinsIDD/flepimop\_sample), to your desired Github account and give it a repository name. Instructions for forking a repository are available [here](https://docs.github.com/en/get-started/quickstart/fork-a-repo). Copy the URL of your forked version of the repository.
-2. **Clone the sample project repository locally**.
-   * If you're using the command line in a terminal, first navigate to your local directory you'll use as the parent directory for all these files. Then, use the command:\
-     `git clone `
-   * If you're using Github Desktop, go File -> Clone Repository and either find the repository name under the Github.com list, or switch to the "URL" tab and copy the URL there. For the "Local Path" option, make sure you choose your desired parent directory.
-   * In either case, make you are cloning your forked version of the repository, not the version owned by HopkinsIDD
-3. **Make sure the sample project repository files are up to date**
-   * To make sure that changes in the core flepimop code are always in sync with our example configuration files, we keep the newest versions of the sample code in the flepimop repository (in the `examples` directory). We try to keep flepimop\_sample repository up to date, but in case we haven't kept up, it's best to copy the most up to date files over yourself
-   * Copy all the contents of the `examples/tutorials` directory into your local version of `flepimop_sample` . You can do this by copying and pasting the files, or, by running the following at the command line in your terminal (assuming you have navigated to the parent directory that contains both your repositories):
-     * `cp -a ./flepiMoP/examples/tutorials/. ./flepimop_sample/`
-   * You will see if there are any changes to flepimop\_sample files by looking at Github's change tracking feature locally ;
+In order to complete `flepiMoP` installation, you must have [`conda`](https://docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html) installed on your machine. `conda` is a tool that will assist you in managing software environments and code packages on your device, and it will be very helpful in ensuring consistent, reproducible environments across different projects. To install `conda` follow [the directions](https://docs.conda.io/projects/conda/en/stable/user-guide/install/index.html) according to your operating system. We would recommend selecting the `Anaconda Distribution` installer of `conda`.
 
-### 📂 Create a project repository from scratch
+Installation of `conda` may take a few minutes.
 
-Create a repository for your project on Github, naming it _something other than_ flepiMoP. This repository will eventually contain the configuration file specifying your model, any other input files or data, and will be where the model output will be stored. These files are always kept completely separately from the universal `flepimop` code that runs the model.
+## ⬇️ Install flepiMoP packages and dependencies
 
-{% hint style="info" %}
-How to create a repository on Github: [https://docs.github.com/en/get-started/quickstart/create-a-repo](https://docs.github.com/en/get-started/quickstart/create-a-repo)
-{% endhint %}
-
-**Clone the repository** locally (as above), either before or after populating it with files described below.
-
-### 👨‍👩‍👧‍👦 Populate the repository
-
-#### Add config file
-
-Put your model configuration file(s) directly in this repository.
+Navigate to the `flepiMoP` directory and run the following command:
 
-#### Create a folder for model inputs
-
-This folder (which can have any name, but for simplicity can just be called **model\_input**) should contain your files specifying the [population structure, population mixing](../gempyor/model-implementation/specifying-population-structure.md), [seeding/initial conditions](../gempyor/model-implementation/specifying-initial-conditions.md), and optional input such as time-series parameters.
+**Note: This installation script is currently only designed for Mac/Linux operating systems. Windows installation script coming soon.**
+```bash
+./build/local_install_or_update
+```
+Successfully running this script will do the following:
+1. Determine `$FLEPI_PATH` and `$FLEPI_CONDA` environment variables
+2. Activate your conda environment
+3. Install `gempyor` and related Python dependencies
+4. Install necessary R packages and dependencies
 
 {% hint style="success" %}
 Now you area ready to run the code using your desired method (see below)!
 {% endhint %}
-
-## 🏃🏽‍♀️ Running the code
-
 {% hint style="warning" %}
 If you have any trouble or questions while trying to run `flepimop`, please report them on the [GitHub Q\&A](https://github.com/HopkinsIDD/flepiMoP/discussions/categories/q-a).
 {% endhint %}
 
-### 🤔 Deciding how to run
+## 🤔 Deciding how to run
 
 The code is written in a combination of [R](https://www.r-project.org/) and [Python](https://www.python.org/). The Python part of the model is a package called [_gempyor_](../gempyor/model-description.md), and includes all the code to simulate the epidemic model and the observational model and apply time-dependent interventions. The R component conducts the (optional) parameter inference, and all the (optional) provided pre and post processing scripts are also written in R. Most uses of the code require interacting with components written in both languages, and thus making sure that both are installed along with a set of required packages. However, Python alone can be used to do forward simulations of the model using `gempyor`.
 
 Because of the need for multiple software packages and dependencies, we describe different ways you can run the model, depending on the requirements of your model setup. See [Quick Start Guide](quick-start-guide.md) for a quick introduction to using `gempyor` and `flepiMoP`. We also provide some more [advanced](advanced-run-guides/) ways to run our model, particularly for doing more complex model inference tasks.
 
-## Final notes
 
-Since you will be editing files in your **project repository** frequently, get in the habit of using the git workflow - committing those changes when you've completed a concrete task, pushing your changes to the remote (online) version of your repository on Github.com, and making sure to fetch changes from the remote version to download to your local version before you start a new task (if you share your project with others or switch computers).
 
-The setup described above assumes that a typical user will not be editing the core `flepimop` user code. If however you are involved in the project in a way that you do plan on editing code, or if you want to add your own enhancements, please consider **forking the repository** and create a version in your own account, instead of just cloning our (user:HopkinsIDD) version. Set your [fork to be synced](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo) with the HopkinsIDD version though, so that you get notified of code updates or bug fixes that may also impact your fork.
diff --git a/documentation/gitbook/how-to-run/quick-start-guide.md b/documentation/gitbook/how-to-run/quick-start-guide.md
index 79df980d9..74488e0aa 100644
--- a/documentation/gitbook/how-to-run/quick-start-guide.md
+++ b/documentation/gitbook/how-to-run/quick-start-guide.md
@@ -1,154 +1,51 @@
 ---
 description: >-
-  Instructions to get started with using gempyor and flepiMoP, using some
-  provided example configs to help you.
+  Instructions to get started with using gempyor and flepiMoP.
+  Executing a simple run with provided example configs.
 ---
 
 # Quick Start Guide
 
 ## 🧱 Set up
 
-### Access model files
-
-Follow all the steps in the [Before any run](before-any-run.md) section to ensure you have access to the correct files needed to run your custom model or a sample model with flepiMoP.
-
-Take note of the location of the directory on your local computer where you cloned the flepiMoP model code (which we'll call `FLEPI_PATH`), as well as where you cloned your project files (which we'll call `PROJECT_PATH`).
-
-{% hint style="info" %}
-For example, if you cloned your Github repositories into a local folder called `Github` and are using [_flepimop\_sample_](https://github.com/HopkinsIDD/flepimop_sample) as a project repository, your directory names could be\
-\
-&#xNAN;_**On Mac:**_
-
-/Users/YourName/Github/flepiMoP
-
-/Users/YourName/Github/flepimop\_sample\
-\
-&#xNAN;_**On Windows:**_\
-C:\Users\YourName\Github\flepiMoP
-
-C:\Users\YourName\Github\flepimop\_sample
-{% endhint %}
+Before completing this **Quick Start Guide**, make sureyou have followed all the steps in the [Before any run](before-any-run.md) section to ensure you have access to the correct files needed to run your model with flepiMoP.
 
 ### Define environment variables (optional)
 
 Since you'll be navigating frequently between the folder that contains your project code and the folder that contains the core flepiMoP model code, it's helpful to define shortcuts for these file paths. You can do this by creating environmental variables that you can then quickly call instead of writing out the whole file path.
 
-If you're on a **Mac** or Linux/Unix based operating system, define the FLEPI\_PATH and PROJECT\_PATH environmental variables to be your directory locations, for example
+For example, if you're on a **Mac** or Linux/Unix based operating system and storing the `flepiMoP` code in a directory called `Github`, you define the FLEPI\_PATH and PROJECT\_PATH environmental variables to be your directory locations as follows:
 
 ```bash
 export FLEPI_PATH=/Users/YourName/Github/flepiMoP
-export PROJECT_PATH=/Users/YourName/Github/flepimop_sample
+export PROJECT_PATH=/Users/YourName/Github/flepiMoP/examples/tutorials
 ```
 
-or, if you have already navigated to your parent directory
+or, if you have already navigated to your flepiMoP directory
 
 ```bash
-export FLEPI_PATH=$(pwd)/flepiMoP
-export PROJECT_PATH=$(pwd)/flepimop_sample
+export FLEPI_PATH=$(pwd)
+export PROJECT_PATH=$(pwd)/examples/tutorials
 ```
 
 You can check that the variables have been set by either typing `env` to see all defined environmental variables, or typing `echo $FLEPI_PATH` to see the value of `FLEPI_PATH`.
 
-If you're on a **Windows** machine
+If you're on a **Windows** machine:
 
 
set FLEPI_PATH=C:\Users\YourName\Github\flepiMoP
-set PROJECT_PATH=C:\Users\YourName\Github\flepimop_sample
+set PROJECT_PATH=C:\Users\YourName\Github\flepiMoP\examples\tutorials
 

 
-or, if you have already navigated to your parent directory
+or, if you have already navigated to your flepiMoP directory
 
-
set FLEPI_PATH=%CD%\flepiMoP
-set PROJECT_PATH=%CD%\flepimop_sample
+
set FLEPI_PATH=%CD%
+set PROJECT_PATH=%CD%\examples\tutorials
 

 
 You can check that the variables have been set by either typing `set` to see all defined environmental variables, or typing `echo $FLEPI_PATH$` to see the value of `FLEPI_PATH`.
 
 {% hint style="info" %}
-If you don't want to bother defining the environmental variables, it's no problem, just remember to use the full or relative path names for navigating to the right files or folders in future steps
-{% endhint %}
-
-### Install packages
-
-The code is written in a combination of [R](https://www.r-project.org/) and [Python](https://www.python.org/). The Python part of the model is a package called [_gempyor_](../gempyor/model-description.md), and includes all the code to simulate the epidemic model and the observational model and apply time-dependent interventions. The R component conducts the (optional) parameter inference, and all the (optional) provided pre and post processing scripts are also written in R. Most uses of the code require interacting with components written in both languages, and thus making sure that both are installed along with a set of required packages. However, Python alone can be used to do forward simulations of the model using _gempyor_.
-
-First, ensure you have python and R installed. You need a working python3.7+ installation. We recommend using the latest stable python release (python 3.12) to benefit from huge speed-ups and future-proof your installation. We also recommend installing Rstudio to interact with the R code and for exploring your model outputs.
-
-{% hint style="info" %}
-_**On Mac**_ 🍏
-
-Python 3 is installed by default on recent MacOS installation. If it is not, you might want to check [homebrew](https://brew.sh/) and install the appropriate installation.
-
-However, this may result in two versions of Python being installed on your computer. If there are multiple versions of Python (e.g., multiple versions of Python 3), you may need to specify which version to use in the installation. This can be done by following the instructions for using a conda environment, in which case the version of Python to use can be specified in the creation of the virtual environment, e.g., `conda create -c conda-forge -n flepimop-env python=3.12 numba pandas numpy seaborn tqdm matplotlib click confuse pyarrow sympy dask pytest scipy graphviz emcee xarray boto3 slack_sdk`. The conda environment will be activated in the same way and when installing gempyor, the version of pip used in the installation will reflect the Python version used in the conda environment (e.g., 3.12), so you can use `pip install -e flepimop/gempyor_pkg/` in this case.
-
-There is also the possibility that multiple versions of _gempyor_ have been installed on your computer in the various iterations of Python. You will only want to have _gempyor_ installed on the latest version of Python (e.g., Python 3.8+) that you have. You can remove a _gempyor_ iteration installed for a given version of Python using `pip[version] uninstall gempyor` e.g., `pip3.7 uninstall gempyor`. Then, you will need to specify which version of Python to install _gempyor_ on during that step (see above).
-{% endhint %}
-
-#### Install packages
-
-To install the python portions of the code (_gempyor_ ) and all the necessary dependencies, go to the flepiMoP directory and run the installation, using the following commands:
-
-```bash
-cd $FLEPI_PATH
-pip install -e flepimop/gempyor_pkg/ # Install Python package gempyor (and dependencies)
-```
-
-{% hint style="danger" %}
-_**A warning for Windows**_\
-Once _gempyor_ is successfully installed locally, you will need to make sure the executable file `gempyor-seir.exe` is runnable via command line. To do this, you will need to add the directory where it was created to PATH. Follow the instructions [here](https://techpp.com/2021/08/26/set-path-variable-in-windows-guide/) to add the directory where this .exe file is located to PATH. This can be done via GUI or CLI.
-{% endhint %}
-
-If you would like to install _gempyor_ directly from GitHub, go to the flepiMoP directory and use the following command:
-
-```bash
-cd $FLEPI_PATH
-pip install --no-deps "git+https://github.com/HopkinsIDD/flepiMoP.git@main#egg=gempyor&subdirectory=flepimop/gempyor_pkg"
-```
-
-If you just want to [run a forward simulation](quick-start-guide.md#non-inference-run), installing python's _gempyor_ is all you need.
-
-To [run an inference run](quick-start-guide.md#inference-run) and to explore your model outputs using provided post-processing functionality, there are some packages you'll need to **install in R**. Open your **R terminal** (at the bottom of RStudio, or in the R IDE), and run the following command to install the necessary R packages:
-
-
# while in R
->install.packages(c("readr","sf","lubridate","tidyverse","gridExtra","reticulate","truncnorm","xts","ggfortify","flextable","doParallel","foreach","optparse","arrow","devtools","cowplot","ggraph","data.table"))
-

-
-{% hint style="info" %}
-_**On Linux**_
-
-The R packages "`sf"` and "`ggraph"` require you to have `libgdal-dev` and `libopenblas-dev` installed on your local linux machine.
-{% endhint %}
-
-This step does not need to be repeated unless you use a new computer or delete and reinstall R.
-
-Now return to your system terminal. To install _flepiMop_-internal R packages, run the following from command line:
-
-{% code overflow="wrap" %}
-```bash
-Rscript build/local_install.R  # Install R packages
-```
-{% endcode %}
-
-After installing the _flepiMoP_ R packages, we need to do one more step to install the command line tools for the inference package. If you are not running in a conda environment, you need to point this installation step to a location that is on your executable search path (i.e., whenever you call a command from the terminal, the places that are searched to find that executable). To find a consistent location, type
-
-```
->which gempyor-simulate
-```
-
-The location that is returned will be of the form `EXECUTABLE_SEARCH_PATH/gempyor-simulate`. Then run the following in an R terminal:
-
-```r
-# While in R
->library(inference)
->inference::install_cli("EXECUTABLE_SEARCH_PATH")
-```
-
-To install the inference package's CLI tools.
-
-Each installation step may take a few minutes to run.
-
-{% hint style="info" %}
-Note: These installations take place on your local operating system. You will need an active internet connection for installation, but not for other steps of running the model.\
-If you are concerned about disrupting your base environment that you use for other projects, try using [Docker](advanced-run-guides/running-with-docker-locally.md) or [conda](advanced-run-guides/quick-start-guide-conda.md) instead.
+If you choose not to define environment variables, remember to use the full or relative path names for navigating to the right files or folders in future steps.
 {% endhint %}
 
 ## 🚀 Run the code
@@ -157,11 +54,11 @@ Everything is now ready 🎉 .
 
 The next step depends on what sort of simulation you want to run: One that includes inference (fitting model to data) or only a forward simulation (non-inference). Inference is run from R, while forward-only simulations are run directly from the Python package `gempyor`.
 
-First, navigate to the project folder and make sure to delete any old model output files that are there.
+First, navigate to the `PROJECT_PATH` folder and make sure to delete any old model output files that are there:
 
 ```bash
-cd $PROJECT_PATH       # goes to your project repository
-rm -r model_output/ # delete the outputs of past run if there are
+cd $PROJECT_PATH        # goes to your project repository
+rm -r model_output/     # delete the outputs of past run if there are
 ```
 
 For the following examples we use an example config from _flepimop\_sample_, but you can provide the name of any configuration file you want.
@@ -170,29 +67,27 @@ To get started, let's start with just running a forward simulation (non-inferenc
 
 ### Non-inference run
 
-Stay in the `PROJECT_PATH` folder, and run a simulation directly from forward-simulation Python package gempyor. Call `flepimop simulate` providing the name of the configuration file you want to run. For example here, we use `config_sample_2pop.yml` from _flepimop\_sample_.
+Stay in the `PROJECT_PATH` folder, and run a simulation directly from forward-simulation Python package `gempyor`. Call `flepimop simulate` providing the name of the configuration file you want to run. For example here, we use `config_sample_2pop.yml`.
 
 ```
 flepimop simulate config_sample_2pop.yml
 ```
 
-This will produce a `model_output` folder, which you can look using provided post-processing functions and scripts.
+This will produce a `model_output` folder, which you can look at using provided post-processing functions and scripts.
 
-We recommend using `model_output_notebook.Rmd` from _flepimop\_sample_ as a starting point to interact with your model outputs. First, modify the yaml preamble in the notebook, then knit this markdown. This will produce some nice plots of the prevalence of infection states over time. You can edit this markdown to produce any figures you'd like to explore your model output.
+We recommend using `model_output_notebook.Rmd` as a starting point to interact with your model outputs. First, modify the YAML preamble in the notebook (make sure the configuration file listed matches the one used in simulation), then knit this markdown. This will produce plots of the prevalence of infection states over time. You can edit this markdown to produce any figures you'd like to explore your model output.
 
-The first time you run all this, it's , it's better to run each command individually as described above to be sure each exits successfully. However, eventually you can **put all these steps together in a script**, like below
+For your first `flepiMoP` run, it's better to run each command individually as described above to be sure each exits successfully. However, eventually you can **put all these steps together in a script**, seen below:
 
 ```
 export FLEPI_PATH=/Users/YourName/Github/flepiMoP
-export PROJECT_PATH=/Users/YourName/Github/flepiMoP_sample
-cd $FLEPI_PATH
-pip install --no-deps -e flepimop/gempyor_pkg/
+export PROJECT_PATH=/Users/YourName/Github/flepiMoP/examples/tutorials
 cd $PROJECT_PATH
 rm -rf model_output
 flepimop simulate config.yml
 ```
 
-Note that you only have to re-run the installation steps once each time you update any of the files in the flepimop repository (either by pulling changes made by the developers and stored on Github, or by changing them yourself). If you're just running the same or different configuration file, just repeat the final steps
+Note that you only have to re-run the installation steps once each time you update any of the files in the flepimop repository (either by pulling changes made by the developers and stored on Github, or by changing them yourself). If you're just running the same or different configuration file, just repeat the final steps:
 
 ```
 rm -rf model_output
@@ -201,7 +96,7 @@ flepimop simulate new_config.yml
 
 ### Inference run
 
-An inference run requires a configuration file that has the `inference` section. Stay in the `$PROJECT_PATH` folder, and run the inference script, providing the name of the configuration file you want to run. For example here, we use `config_sample_2pop_inference.yml` from _flepimop\_sample_.
+An inference run requires a configuration file that has the `inference` section. Stay in the `$PROJECT_PATH` folder, and run the inference script, providing the name of the configuration file you want to run. For example here, we use `config_sample_2pop_inference.yml`.
 
 {% code overflow="wrap" %}
 ```bash
@@ -233,13 +128,13 @@ where:
 * `j` is the number of CPU cores to use on your machine (if `j` > `n`, only `n` cores will actually be used. If `j` <`n`, some cores will run multiple slots in sequence)
 * `k` is the number of iterations per slots.
 
-Again, it is helpful to run the model output notebook (`model_output_notebook.Rmd` from _flepimop\_sample)_ to explore your model outputs. Knitting this file for an inference run will also provide an analysis of your fits: the acceptance probabilities, likelihoods overtime, and the fits against the provided ground truth.
+Again, it is helpful to run the model output notebook (`model_output_notebook.Rmd` to explore your model outputs. Knitting this file for an inference run will also provide an analysis of your fits: the acceptance probabilities, likelihoods overtime, and the fits against the provided ground truth.
 
-The first time you run all this, it's , it's better to run each command individually as described above to be sure each exits successfully. However, eventually you can **put all these steps together in a script**, like below
+For your first `flepiMoP` inference run, it's better to run each command individually as described above to be sure each exits successfully. However, eventually you can **put all these steps together in a script**, seen below:
 
 ```bash
 export FLEPI_PATH=/Users/YourName/Github/flepiMoP
-export PROJECT_PATH=/Users/YourName/Github/flepiMoP_sample
+export PROJECT_PATH=/Users/YourName/Github/flepiMoP/examples/tutorials
 cd $FLEPI_PATH
 pip install --no-deps -e flepimop/gempyor_pkg/
 Rscript build/local_install.R
diff --git a/documentation/gitbook/how-to-run/useful-commands.md b/documentation/gitbook/how-to-run/useful-commands.md
index 1f400849f..98acd7541 100644
--- a/documentation/gitbook/how-to-run/useful-commands.md
+++ b/documentation/gitbook/how-to-run/useful-commands.md
@@ -53,7 +53,7 @@ Don't paste them if you don't know what they do
 ### Filepaths structure
 
 in configs with a setup `name: USA`
-
+ 
 ```
 model_output/{FileType}/{Prefix}{Index}.{run_id}.{FileType}.{Extension}
                            ^ 
@@ -71,7 +71,7 @@ where, eg:
 
 ```bash
 export COVID_PATH=$(pwd)/COVIDScenarioPipeline
-export DATA_PATH=$(pwd)/COVID19_USA
+export PROJECT_PATH=$(pwd)/COVID19_USA
 conda activate covidSP
 cd $COVID_PATH
 Rscript local_install.R
@@ -79,7 +79,7 @@ pip install --no-deps -e gempyor_pkg # before: python setup.py develop --no-deps
 git lfs install
 git lfs pull
 export CENSUS_API_KEY=YOUR_KEY
-cd $DATA_PATH
+cd $PROJECT_PATH
 git restore data/
 export CONFIG_PATH=config_smh_r11_optsev_highie_base_deathscases_blk1.yml
 Rscript $COVID_PATH/R/scripts/build_US_setup.R
diff --git a/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-locally.md b/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-locally.md
index bec4d0899..32dcba334 100644
--- a/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-locally.md
+++ b/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-locally.md
@@ -44,7 +44,7 @@ First, populate the folder name variables:
 
 ```bash
 export FLEPI_PATH=/home/app/csp/
-export DATA_PATH=/home/app/drp/
+export PROJECT_PATH=/home/app/drp/
 ```
 
 Then, export variables for some flags and the census API key (you can use your own):
@@ -87,13 +87,13 @@ Note: These installations take place in the docker container and not the Operati
 Everything is now ready. 🎉 Let's do some clean-up in the data folder (these files might not exist, but it's good practice to make sure your simulation isn't re-using some old files) ;
 
 ```bash
-cd $DATA_PATH       # goes to Flu_USA
+cd $PROJECT_PATH       # goes to Flu_USA
 git restore data/
 rm -rf data/mobility_territories.csv data/geodata_territories.csv data/us_data.csv
 rm -r model_output/ # delete the outputs of past run if there are
 ```
 
-Stay in `$DATA_PATH`, select a config, and build the setup. The setup creates the population seeding file (geodata) and the population mobility file (mobility). Then, run inference:
+Stay in `$PROJECT_PATH`, select a config, and build the setup. The setup creates the population seeding file (geodata) and the population mobility file (mobility). Then, run inference:
 
 ```bash
 export CONFIG_PATH=config_SMH_R1_lowVac_optImm_2022.yml
diff --git a/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-on-aws/aws-submission-instructions-covid-19.md b/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-on-aws/aws-submission-instructions-covid-19.md
index 661893301..7472f2eb7 100644
--- a/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-on-aws/aws-submission-instructions-covid-19.md
+++ b/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-on-aws/aws-submission-instructions-covid-19.md
@@ -130,11 +130,11 @@ export RESUME_LOCATION=s3://idd-inference-runs/USA-20230423T235232
 export CONFIG_NAME=config_$SCENARIO.yml && 
    export CONFIG_PATH=/home/app/drp/COVID19_USA/$CONFIG_NAME && 
    export FLEPI_PATH=/home/app/drp/flepiMoP && 
-   export DATA_PATH=/home/app/drp/COVID19_USA && 
+   export PROJECT_PATH=/home/app/drp/COVID19_USA && 
    export INTERVENTION_NAME="med" && 
    export FLEPI_STOCHASTIC=FALSE && 
-   rm -rf $DATA_PATH/model_output DATA_PATH/us_data.csv && 
-   cd $DATA_PATH && 
+   rm -rf $PROJECT_PATH/model_output $PROJECT_PATH/us_data.csv && 
+   cd $PROJECT_PATH && 
    Rscript $FLEPI_PATH/R/scripts/build_US_setup.R -c $CONFIG_NAME && 
    Rscript $FLEPI_PATH/R/scripts/build_covid_data.R -c $CONFIG_NAME && 
    Rscript $FLEPI_PATH/R/scripts/full_filter.R -c $CONFIG_NAME -j 1 -n 1 -k 1 && 
@@ -162,7 +162,7 @@ You will be prompted to enter the following items. These can be found in a file
 {% tabs %}
 {% tab title="Standard" %}
 
export CONFIG_PATH=$CONFIG_NAME &&
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $FLEPI_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic &&
 printenv CONFIG_NAME
 

@@ -171,7 +171,7 @@ printenv CONFIG_NAME
 {% tab title="Non-inference" %}
 ```
 export CONFIG_PATH=$CONFIG_NAME &&
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $FLEPI_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic -j 1 -k 1 &&
 printenv CONFIG_NAME
 ```
@@ -185,7 +185,7 @@ printenv CONFIG_NAME
 **Carrying seeding**  (_do this to use seeding fits from resumed run_):
 
 
export CONFIG_PATH=$CONFIG_NAME &&
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $FLEPI_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic --resume-carry-seeding --restart-from-location=s3://idd-inference-runs/$RESUME_S3 --restart-from-run-id=$RESUME_ID &&
 printenv CONFIG_NAME
 

@@ -196,7 +196,7 @@ printenv CONFIG_NAME
 
 ```
 export CONFIG_PATH=$CONFIG_NAME &&  
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $COVID_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic --resume-discard-seeding --restart-from-location=s3://idd-inference-runs/$RESUME_S3 --restart-from-run-id=$RESUME_ID &&
 printenv CONFIG_NAME
 ```
@@ -207,7 +207,7 @@ printenv CONFIG_NAME
 
 ```
 export CONFIG_PATH=$CONFIG_NAME &&
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $COVID_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic --resume-carry-seeding --restart-from-location=s3://idd-inference-runs/$RESUME_S3 --restart-from-run-id=$RESUME_ID -j 1 -k 1 &&
 printenv CONFIG_NAME
 ```
diff --git a/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-on-aws/aws-submission-instructions-influenza.md b/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-on-aws/aws-submission-instructions-influenza.md
index 5ebe2e091..827afeeb3 100644
--- a/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-on-aws/aws-submission-instructions-influenza.md
+++ b/documentation/gitbook/jhu-internal/us-specific-how-to-run/running-with-docker-on-aws/aws-submission-instructions-influenza.md
@@ -121,12 +121,12 @@ export RESUME_ID=FCH_R1_highVac_pesImm_2022_Nov20 &&
    export CONFIG_NAME=config_$SCENARIO.yml && 
    export CONFIG_PATH=/home/app/drp/$CONFIG_NAME && 
    export COVID_PATH=/home/app/drp/COVIDScenarioPipeline && 
-   export DATA_PATH=/home/app/drp && 
+   export PROJECT_PATH=/home/app/drp && 
    export INTERVENTION_NAME="med" && 
    export COVID_STOCHASTIC=FALSE && 
-   rm -rf $DATA_PATH/model_output $DATA_PATH/us_data.csv &&
-   rm -rf $DATA_PATH/seeding_territories.csv && 
-   cd $DATA_PATH && Rscript $COVID_PATH/R/scripts/build_US_setup.R -c $CONFIG_NAME && 
+   rm -rf $PROJECT_PATH/model_output $PROJECT_PATH/us_data.csv &&
+   rm -rf $PROJECT_PATH/seeding_territories.csv && 
+   cd $PROJECT_PATH && Rscript $COVID_PATH/R/scripts/build_US_setup.R -c $CONFIG_NAME && 
    Rscript $COVID_PATH/R/scripts/build_flu_data.R -c $CONFIG_NAME && 
    Rscript $COVID_PATH/R/scripts/full_filter.R -c $CONFIG_NAME -j 1 -n 1 -k 1 && 
    printenv CONFIG_NAME
@@ -152,7 +152,7 @@ You will be prompted to enter the following items. These can be found in a file
 {% tabs %}
 {% tab title="Standard" %}
 
export CONFIG_PATH=$CONFIG_NAME &&
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $COVID_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic &&
 printenv CONFIG_NAME
 

@@ -161,7 +161,7 @@ printenv CONFIG_NAME
 {% tab title="Non-inference" %}
 ```
 export CONFIG_PATH=$CONFIG_NAME &&
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $COVID_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic -j 1 -k 1 &&
 printenv CONFIG_NAME
 ```
@@ -175,7 +175,7 @@ printenv CONFIG_NAME
 **Carrying seeding**  (_do this to use seeding fits from resumed run_):
 
 
export CONFIG_PATH=$CONFIG_NAME &&
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $COVID_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic --resume-carry-seeding --restart-from-location=s3://idd-inference-runs/$RESUME_S3 --restart-from-run-id=$RESUME_ID &&
 printenv CONFIG_NAME
 

@@ -186,7 +186,7 @@ printenv CONFIG_NAME
 
 ```
 export CONFIG_PATH=$CONFIG_NAME &&  
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $COVID_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic --resume-discard-seeding --restart-from-location=s3://idd-inference-runs/$RESUME_S3 --restart-from-run-id=$RESUME_ID &&
 printenv CONFIG_NAME
 ```
@@ -197,7 +197,7 @@ printenv CONFIG_NAME
 
 ```
 export CONFIG_PATH=$CONFIG_NAME &&
-cd $DATA_PATH &&
+cd $PROJECT_PATH &&
 $COVID_PATH/batch/inference_job.py -c $CONFIG_PATH -q $COMPUTE_QUEUE --non-stochastic --resume-carry-seeding --restart-from-location=s3://idd-inference-runs/$RESUME_S3 --restart-from-run-id=$RESUME_ID -j 1 -k 1 &&
 printenv CONFIG_NAME
 ```
diff --git a/documentation/gitbook/jhu-internal/us-specific-how-to-run/slurm-submission-on-marcc.md b/documentation/gitbook/jhu-internal/us-specific-how-to-run/slurm-submission-on-marcc.md
index c0f8dd762..07bef44b2 100644
--- a/documentation/gitbook/jhu-internal/us-specific-how-to-run/slurm-submission-on-marcc.md
+++ b/documentation/gitbook/jhu-internal/us-specific-how-to-run/slurm-submission-on-marcc.md
@@ -19,7 +19,7 @@ Rockfish administrators provided [several partitions](https://www.arch.jhu.edu/s
 Note that the repository is cloned **flat,** i.e the `flepiMoP` repository is at the same level as the data repository, not inside it!
 {% endhint %}
 
-* **output folder:**`/scratch4/struelo1/flepimop-runs` stores the run outputs. After an inference run finishes, it's output and the logs files are copied from the `$DATA_PATH/model_output` to `/scratch4/struelo1/flepimop-runs/THISRUNJOBNAME` where the jobname is usually of the form `USA-DATE.`
+* **output folder:**`/scratch4/struelo1/flepimop-runs` stores the run outputs. After an inference run finishes, it's output and the logs files are copied from the `$PROJECT_PATH/model_output` to `/scratch4/struelo1/flepimop-runs/THISRUNJOBNAME` where the jobname is usually of the form `USA-DATE.`
 
 {% hint style="warning" %}
 When logging on you'll see two folders `data_struelo1` and `scr4_struelo1`, which are shortcuts to `/data/struelo1` and `/scratch4/struelo1`. We don't use `data/struelo1`.
@@ -200,13 +200,13 @@ pip install --no-deps -e flepimop/gempyor_pkg/
 
 Now flepiMoP is ready 🎉. If the `R` command doesn't work, try `r` and if that doesn't work run `module load `r/4.0.2`.
 
-Next step is to setup the data. First $DATA\_PATH to your data folder, and set any data options. If you are using the Delph Epidata API, first register for a key here: [https://cmu-delphi.github.io/delphi-epidata/](https://cmu-delphi.github.io/delphi-epidata/). Once you have a key, add that below where you see \[YOUR API KEY]. Alternatively, you can put that key in your config file in the `inference` section as `gt_api_key: "YOUR API KEY"`.
+Next step is to setup the data. First $PROJECT\_PATH to your data folder, and set any data options. If you are using the Delph Epidata API, first register for a key here: [https://cmu-delphi.github.io/delphi-epidata/](https://cmu-delphi.github.io/delphi-epidata/). Once you have a key, add that below where you see \[YOUR API KEY]. Alternatively, you can put that key in your config file in the `inference` section as `gt_api_key: "YOUR API KEY"`.
 
 For a COVID-19 run, do:
 
 ```bash
 cd /scratch4/struelo1/flepimop-code/$USER
-export DATA_PATH=$(pwd)/COVID19_USA
+export PROJECT_PATH=$(pwd)/COVID19_USA
 export GT_DATA_SOURCE="csse_case, fluview_death, hhs_hosp"
 export DELPHI_API_KEY="[YOUR API KEY]"
 ```
@@ -215,18 +215,18 @@ for Flu do:
 
 ```bash
 cd /scratch4/struelo1/flepimop-code/$USER
-export DATA_PATH=$(pwd)/Flu_USA
+export PROJECT_PATH=$(pwd)/Flu_USA
 ```
 
 Now for any type of run:
 
 ```bash
-cd $DATA_PATH
+cd $PROJECT_PATH
 git pull 
 git checkout main
 ```
 
-Do some clean-up before your run. The fast way is to restore the `$DATA_PATH` git repository to its blank states (⚠️ removes everything that does not come from git):
+Do some clean-up before your run. The fast way is to restore the `$PROJECT_PATH` git repository to its blank states (⚠️ removes everything that does not come from git):
 
 
git reset --hard && git clean -f -d  # this deletes everything that is not on github in this repo !!!
 

@@ -246,7 +246,7 @@ rm -rf model_output data/us_data.csv data-truth &&
    rm -rf data/seeding_territories_Level5.csv data/seeding_territories_Level67.csv
 
 # don't delete model_output if you have another run in //
-rm -rf $DATA_PATH/model_output
+rm -rf $PROJECT_PATH/model_output
 # delete log files from previous runs
 rm *.out
 ```
@@ -309,7 +309,7 @@ If you'd like to have more control, you can specify the arguments manually:
 
python $FLEPI_PATH/batch/inference_job_launcher.py --slurm \
                     -c $CONFIG_PATH \
                     -p $FLEPI_PATH \
-                    --data-path $DATA_PATH \
+                    --data-path $PROJECT_PATH \
                     --upload-to-s3 True \
                     --id $FLEPI_RUN_INDEX \
                     --fs-folder /scratch4/struelo1/flepimop-runs \
@@ -332,7 +332,7 @@ but DO NOT finish up by git checking main like the aws instructions, as the run
 
 TODO JPSEH WRITE UP TO HERE
 
-Two types of logfiles: in \`$DATA\_PATH\`: slurm-JOBID\_SLOTID.out and and filter\_MC logs:
+Two types of logfiles: in \`$PROJECT\_PATH\`: slurm-JOBID\_SLOTID.out and and filter\_MC logs:
 
 \`\`\`tail -f /scratch4/struelo1/flepimop-runs/USA-20230130T163847/log\_FCH\_R16\_lowBoo\_modVar\_ContRes\_blk4\_Jan29\_tsvacc\_100.txt
 
@@ -359,7 +359,7 @@ cleanup:
 ```
 rm -r /scratch4/struelo1/flepimop-runs/
 rm -r model_output
-cd $COVID_PATH;git pull;cd $DATA_PATH
+cd $COVID_PATH;git pull;cd $PROJECT_PATH
 rm *.out
 ```
 
diff --git a/documentation/gitbook/model-inference/inference-model-output.md b/documentation/gitbook/model-inference/inference-model-output.md
index 89e47e18a..f27087076 100644
--- a/documentation/gitbook/model-inference/inference-model-output.md
+++ b/documentation/gitbook/model-inference/inference-model-output.md
@@ -35,7 +35,7 @@ The meanings of the columns are:
 For inference runs, `...` _flepiMoP_ produces one file per parallel slot, for both global and chimeric outputs...
 
 ```
-flepimop_sample
+flepiMoP/examples/tutorials
 ├── model_output
 │   ├── seir
 │   ├── spar
diff --git a/documentation/gitbook/more/setting-up-the-model-and-post-processing/create-a-post-processing-script.md b/documentation/gitbook/more/setting-up-the-model-and-post-processing/create-a-post-processing-script.md
index 4f0f7b224..1aadfa091 100644
--- a/documentation/gitbook/more/setting-up-the-model-and-post-processing/create-a-post-processing-script.md
+++ b/documentation/gitbook/more/setting-up-the-model-and-post-processing/create-a-post-processing-script.md
@@ -13,10 +13,10 @@ Some information to consider if you'd like your script to be run automatically a
   * `$JOB_NAME` this job name (e.g `USA-20230130T163847_inference_med`)
   * `$FS_RESULTS_PATH` the path where lies the model results. It's a folder that contains the model\_ouput/ as a subfolder
   * `$FLEPI_PATH` path of the flepiMoP repository.
-  * `$DATA_PATH` path of the Data directory (e.g Flu\_USA or COVID19\_USA).
+  * `$PROJECT_PATH` path of the Data directory (e.g Flu\_USA or COVID19\_USA).
   * Anything you ask can theoretically be provided here.
 * The script must run without any user intervention.
-* The script is run from $DATA\_PATH.
+* The script is run from $PROJECT\_PATH.
 * Your script lies in the flepiMoP directory (preferably) or it's ok if it is in a data directory if it makes sense ;
 * It is run on a 64Gb of RAM multicore machine. All scripts combined must complete under 4 hours, and you can use multiprocessing (48 cores)
 * Outputs (pdf, csv, html, txt, png ...) must be saved in a directory named `pplot/` (you can assume that it exists) in order to be sent to slack by FlepiBot 🤖 after the run.
diff --git a/examples/tutorials/README.md b/examples/tutorials/README.md
index 10d15c372..fc6153e1c 100644
--- a/examples/tutorials/README.md
+++ b/examples/tutorials/README.md
@@ -1,3 +1,3 @@
-# flepimop_sample
+# flepiMoP/examples/tutorials
 
-This repository mirrors the contents in the **examples/tutorial** folder of the FlepiMoP repository ([link](https://github.com/HopkinsIDD/flepiMoP/tree/main/examples/tutorials)). It can be used to try out running simple projects using `flepimop` code and as a template for new projects. 
+This directory can be used to try out running simple projects using `flepimop` code and as a template for new projects. 
diff --git a/examples/tutorials/model_output_notebook.Rmd b/examples/tutorials/model_output_notebook.Rmd
index 61ee0fe40..d22c497be 100644
--- a/examples/tutorials/model_output_notebook.Rmd
+++ b/examples/tutorials/model_output_notebook.Rmd
@@ -9,7 +9,7 @@ output:
     keep_tex: FALSE
 params:
   report_location: offline # if report is being run within an environment in which a model run was already specified and that already has all                                flepmiop packages installed, "online", otherwise, "offline"
-  opt: !r option_list = list(optparse::make_option(c("-c", "--config"), action="store", default=Sys.getenv("CONFIG_PATH", Sys.getenv("CONFIG_PATH")), type='character', help="path to the config file"), optparse::make_option(c("-d", "--data_path"), action="store", default=Sys.getenv("DATA_PATH", Sys.getenv("DATA_PATH")), type='character', help="path to the data repo"), optparse::make_option(c("-u","--run-id"), action="store", dest = "run_id", type='character', help="Unique identifier for this run", default = Sys.getenv("FLEPI_RUN_INDEX",flepicommon::run_id())),  optparse::make_option(c("-R", "--results-path"), action="store", dest = "results_path",  type='character', help="Path for model output", default = Sys.getenv("FS_RESULTS_PATH", Sys.getenv("FS_RESULTS_PATH")))) # parameter options that will be used if report ran "online". If "offline", options below will be used
+  opt: !r option_list = list(optparse::make_option(c("-c", "--config"), action="store", default=Sys.getenv("CONFIG_PATH", Sys.getenv("CONFIG_PATH")), type='character', help="path to the config file"), optparse::make_option(c("-d", "--data_path"), action="store", default=Sys.getenv("PROJECT_PATH", Sys.getenv("PROJECT_PATH")), type='character', help="path to the data repo"), optparse::make_option(c("-u","--run-id"), action="store", dest = "run_id", type='character', help="Unique identifier for this run", default = Sys.getenv("FLEPI_RUN_INDEX",flepicommon::run_id())),  optparse::make_option(c("-R", "--results-path"), action="store", dest = "results_path",  type='character', help="Path for model output", default = Sys.getenv("FS_RESULTS_PATH", Sys.getenv("FS_RESULTS_PATH")))) # parameter options that will be used if report ran "online". If "offline", options below will be used
   config: config_sample_2pop_inference.yml #name of configuration file
   model_output_dir: model_output #usually model_output, but if results were moved, might be different
   #results_path:  # path to the project folder within which the model_output directory lies. Comment out if current directory 
diff --git a/flepimop/R_packages/inference/inst/scripts/flepimop-inference-main.R b/flepimop/R_packages/inference/inst/scripts/flepimop-inference-main.R
index aa7b03d4c..e2496399b 100755
--- a/flepimop/R_packages/inference/inst/scripts/flepimop-inference-main.R
+++ b/flepimop/R_packages/inference/inst/scripts/flepimop-inference-main.R
@@ -15,7 +15,7 @@ options(readr.num_columns = 0)
 
 # There are multiple ways to specify options when flepimop-inference-main is run, which take the following precedence:
 #  1) (optional) options called along with the script at the command line (ie > flepimop-inference-main -c my_config.yml)
-#  2) (optional) environmental variables set by the user (ie user could set > export CONFIG_PATH = ~/flepimop_sample/my_config.yml to not have t specify it each time the script is run)
+#  2) (optional) environmental variables set by the user (ie user could set > export CONFIG_PATH = ~/examples/tutorials/my_config.yml to not have t specify it each time the script is run)
 # If neither are specified, then a default value is used, given by the second argument of Sys.getenv() commands below. 
 #  *3) For some options, a default doesn't exist, and the value specified in the config will be used if the option is not specified at the command line or by an environmental variable (iterations_per_slot, slots)
 
diff --git a/flepimop/R_packages/inference/inst/scripts/flepimop-inference-slot.R b/flepimop/R_packages/inference/inst/scripts/flepimop-inference-slot.R
index 451b72aea..afccafe13 100755
--- a/flepimop/R_packages/inference/inst/scripts/flepimop-inference-slot.R
+++ b/flepimop/R_packages/inference/inst/scripts/flepimop-inference-slot.R
@@ -28,7 +28,7 @@ required_packages <- c("dplyr", "magrittr", "xts", "zoo", "stringr")
 
 # There are multiple ways to specify options when flepimop-inference-slot is run, which take the following precedence:
 #  1) (optional) options called along with the script at the command line (ie > flepimop-inference-slot -c my_config.yml)
-#  2) (optional) environmental variables set by the user (ie user could set > export CONFIG_PATH = ~/flepimop_sample/my_config.yml to not have t specify it each time the script is run)
+#  2) (optional) environmental variables set by the user (ie user could set > export CONFIG_PATH = ~/examples/tutorials/my_config.yml to not have t specify it each time the script is run)
 # If neither are specified, then a default value is used, given by the second argument of Sys.getenv() commands below.
 #  *3) For some options, a default doesn't exist, and the value specified in the config will be used if the option is not specified at the command line or by an environmental variable (iterations_per_slot, slots)