docs: remove outdated files

b7f67bd9 · Hu Zhao · 3e038d48 · 3e038d48 · 3e038d48 · 3e038d48
Commit b7f67bd9 authored 2 years ago by Hu Zhao
--- a/docs/contributing.md
+++ b/docs/contributing.md
-```{include} ../CONTRIBUTING.md
-```
\ No newline at end of file
--- a/docs/examples/emulator_robustgasp.ipynb
+++ b/docs/examples/emulator_robustgasp.ipynb
--- a/docs/examples/run_simulator.ipynb
+++ b/docs/examples/run_simulator.ipynb
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "74f2899d",
-   "metadata": {},
-   "source": [
-    "# Run Simulator\n",
-    "\n",
-    "This example demonstrates how to execute a simulator (in serial or parallel) at a set of samples."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "9a8d41a8",
-   "metadata": {},
-   "source": [
-    "### Import\n",
-    "\n",
-    "First, we need to import the class `RunSimulator` from the module `psimpy.simulator.run_simulator`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "727743d3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from psimpy.simulator.run_simulator import RunSimulator"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "5b18c1d6",
-   "metadata": {},
-   "source": [
-    "### Instantiation\n",
-    "\n",
-    "Then we need to create a new class that inherets from the class `RunSimulator` and override the abstract method `simulator()`. The `simulator()` method cannot have any positional-only arguments, has to contain the `**kwargs` argument and it has to return the results in form of a numpy array.\n",
-    "\n",
-    "Here we're going to use the method `run` of the class `MPM` from the module `psimpy.simulator.mass_point_model` as our simulator. This method solves the mass point model using the ode solver `scipy.integrate.ode` given following inputs: topography, friction parameters, and initial condition of the mass point (location and velocity).\n",
-    "\n",
-    "To do this, we first define the child class `MpmSolver`, override the `__init__` method to create a new instance of `MPM`, then we override the `simulator()` method in order to return the outputs of the method `run()` from the `MPM` class. "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "fb475422",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from psimpy.simulator.mass_point_model import MPM\n",
-    "\n",
-    "class MpmSolver(RunSimulator):\n",
-    "    def __init__(self, *args, **kwargs):\n",
-    "        self.mpm = MPM()\n",
-    "        super(MpmSolver, self).__init__(*args, **kwargs)\n",
-    "        \n",
-    "    def simulator(self, elevation, coulomb_friction, turbulent_friction, x0, y0,\n",
-    "            ux0=0, uy0=0, dt=1, tend=300, t0=0, g=9.8, atol=1e-4, rtol=1e-4,\n",
-    "            curvature=False, **kwargs):\n",
-    "        \n",
-    "        return self.mpm.run(elevation=elevation, coulomb_friction=coulomb_friction,\n",
-    "                            turbulent_friction=turbulent_friction, x0=x0, y0=y0, ux0=ux0,\n",
-    "                            uy0=uy0, dt=dt, tend=tend, t0=t0, g=g, atol=atol, rtol=rtol,\n",
-    "                            curvature=curvature)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3546d6b4",
-   "metadata": {},
-   "source": [
-    "Now we can create a new instance of `MpmSolver`. In order to initialize `MpmSolver`, which has the same `__init__()` method as `RunSimulator`, the user needs to define the parent folder to save simulation outputs `sim_dir`, a list consists of all variable input names `var_inp_name` and a dictionary consists of all fixed input name-value pairs `fix_inp`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "bd2936f9",
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "\n",
-    "sim_dir = os.path.join(os.path.abspath(''), \"../../tests/sim_log\")\n",
-    "fix_inp = {\n",
-    "    \"elevation\" :  os.path.join(os.path.abspath(''), \"../../tests/data/mpm_topo.asc\"), \n",
-    "    \"x0\" : 800,\n",
-    "    \"y0\" : 2000,\n",
-    "    \"ux0\" : 1e-10,\n",
-    "    \"uy0\" : 1e-10,\n",
-    "    \"dt\" : 2,\n",
-    "    \"tend\" : 600\n",
-    "}\n",
-    "var_inp_name=[\"coulomb_friction\", \"turbulent_friction\"]\n",
-    "\n",
-    "mpmsolver = MpmSolver(sim_dir=sim_dir, var_inp_name=var_inp_name, fix_inp=fix_inp)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "b1535843",
-   "metadata": {},
-   "source": [
-    "`coulomb_friction` and `turbulent_friction` are variable inputs and the other inputs are fixed. We may vary `coulomb_friction` between 0.1 to 0.3 and `turbulent_friction` between 500 to 2000."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "6e2270ee",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import itertools\n",
-    "\n",
-    "cf = np.arange(0.1, 0.3, 0.05)\n",
-    "tf = np.arange(500, 2000, 150)\n",
-    "\n",
-    "var_samples = np.array([x for x in itertools.product(cf, tf)])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8f7da917",
-   "metadata": {},
-   "source": [
-    "## Serial Execution\n",
-    "In order to perform a serial execution of the simulator, we need to pass `var_samples` to the `serial_run()` method. The user can also specify optional arguments like `prefixes`, `append` or `save_out`. Here we like to save the results with the \"serial\" prefixes."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "31f7328b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "serial_prefixes = [\"serial\"+str(i) for i in range(len(var_samples))]\n",
-    "\n",
-    "mpmsolver.serial_run(var_samples=var_samples, prefixes=serial_prefixes, save_out=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "8149f7b0",
-   "metadata": {},
-   "source": [
-    "To check the results one could either check `mpmsolver.outputs` or load the files available in `sim_dir`.\n",
-    "\n",
-    "## Parallel Execution\n",
-    "Now let's run the same simulator in parallel. Once again we prepare samples of the variable inputs."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "d5a94bbf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "cf = np.arange(0.1, 0.30, 0.04)\n",
-    "tf = np.arange(500, 2000, 100)\n",
-    "\n",
-    "var_samples = np.array([x for x in itertools.product(cf, tf)])"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "c87aeaf8",
-   "metadata": {},
-   "source": [
-    "This time we will pass the first 40 samples and then append the rest. We can also specify the maximum number of tasks running in parallel `max_workers` as well as `prefixes`, `append` and `save_out`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "9e772a13",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mpmsolver.parallel_run(var_samples=var_samples[:40], max_workers=2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f05e6619",
-   "metadata": {},
-   "source": [
-    "Now, let's append the rest of the samples."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "127faf15",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "mpmsolver.parallel_run(var_samples=var_samples[40:], append=True, max_workers=2)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6e83cd2f",
-   "metadata": {},
-   "source": [
-    "Same as serial execution, we can check the results either by using `mpmsolver.outputs` or loading the files available in `sim_dir`."
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
-%% Cell type:markdown id:74f2899d tags:
-
-# Run Simulator
-
-This example demonstrates how to execute a simulator (in serial or parallel) at a set of samples.
-
-%% Cell type:markdown id:9a8d41a8 tags:
-
-### Import
-
-First, we need to import the class `RunSimulator` from the module `psimpy.simulator.run_simulator`.
-
-%% Cell type:code id:727743d3 tags:
-
-``` python
-from psimpy.simulator.run_simulator import RunSimulator
-```
-
-%% Cell type:markdown id:5b18c1d6 tags:
-
-### Instantiation
-
-Then we need to create a new class that inherets from the class `RunSimulator` and override the abstract method `simulator()`. The `simulator()` method cannot have any positional-only arguments, has to contain the `**kwargs` argument and it has to return the results in form of a numpy array.
-
-Here we're going to use the method `run` of the class `MPM` from the module `psimpy.simulator.mass_point_model` as our simulator. This method solves the mass point model using the ode solver `scipy.integrate.ode` given following inputs: topography, friction parameters, and initial condition of the mass point (location and velocity).
-
-To do this, we first define the child class `MpmSolver`, override the `__init__` method to create a new instance of `MPM`, then we override the `simulator()` method in order to return the outputs of the method `run()` from the `MPM` class.
-
-%% Cell type:code id:fb475422 tags:
-
-``` python
-from psimpy.simulator.mass_point_model import MPM
-
-class MpmSolver(RunSimulator):
-    def __init__(self, *args, **kwargs):
-        self.mpm = MPM()
-        super(MpmSolver, self).__init__(*args, **kwargs)
-
-    def simulator(self, elevation, coulomb_friction, turbulent_friction, x0, y0,
-            ux0=0, uy0=0, dt=1, tend=300, t0=0, g=9.8, atol=1e-4, rtol=1e-4,
-            curvature=False, **kwargs):
-
-        return self.mpm.run(elevation=elevation, coulomb_friction=coulomb_friction,
-                            turbulent_friction=turbulent_friction, x0=x0, y0=y0, ux0=ux0,
-                            uy0=uy0, dt=dt, tend=tend, t0=t0, g=g, atol=atol, rtol=rtol,
-                            curvature=curvature)
-```
-
-%% Cell type:markdown id:3546d6b4 tags:
-
-Now we can create a new instance of `MpmSolver`. In order to initialize `MpmSolver`, which has the same `__init__()` method as `RunSimulator`, the user needs to define the parent folder to save simulation outputs `sim_dir`, a list consists of all variable input names `var_inp_name` and a dictionary consists of all fixed input name-value pairs `fix_inp`.
-
-%% Cell type:code id:bd2936f9 tags:
-
-``` python
-import os
-
-sim_dir = os.path.join(os.path.abspath(''), "../../tests/sim_log")
-fix_inp = {
-    "elevation" :  os.path.join(os.path.abspath(''), "../../tests/data/mpm_topo.asc"),
-    "x0" : 800,
-    "y0" : 2000,
-    "ux0" : 1e-10,
-    "uy0" : 1e-10,
-    "dt" : 2,
-    "tend" : 600
-}
-var_inp_name=["coulomb_friction", "turbulent_friction"]
-
-mpmsolver = MpmSolver(sim_dir=sim_dir, var_inp_name=var_inp_name, fix_inp=fix_inp)
-```
-
-%% Cell type:markdown id:b1535843 tags:
-
-`coulomb_friction` and `turbulent_friction` are variable inputs and the other inputs are fixed. We may vary `coulomb_friction` between 0.1 to 0.3 and `turbulent_friction` between 500 to 2000.
-
-%% Cell type:code id:6e2270ee tags:
-
-``` python
-import numpy as np
-import itertools
-
-cf = np.arange(0.1, 0.3, 0.05)
-tf = np.arange(500, 2000, 150)
-
-var_samples = np.array([x for x in itertools.product(cf, tf)])
-```
-
-%% Cell type:markdown id:8f7da917 tags:
-
-## Serial Execution
-In order to perform a serial execution of the simulator, we need to pass `var_samples` to the `serial_run()` method. The user can also specify optional arguments like `prefixes`, `append` or `save_out`. Here we like to save the results with the "serial" prefixes.
-
-%% Cell type:code id:31f7328b tags:
-
-``` python
-serial_prefixes = ["serial"+str(i) for i in range(len(var_samples))]
-
-mpmsolver.serial_run(var_samples=var_samples, prefixes=serial_prefixes, save_out=True)
-```
-
-%% Cell type:markdown id:8149f7b0 tags:
-
-To check the results one could either check `mpmsolver.outputs` or load the files available in `sim_dir`.
-
-## Parallel Execution
-Now let's run the same simulator in parallel. Once again we prepare samples of the variable inputs.
-
-%% Cell type:code id:d5a94bbf tags:
-
-``` python
-cf = np.arange(0.1, 0.30, 0.04)
-tf = np.arange(500, 2000, 100)
-
-var_samples = np.array([x for x in itertools.product(cf, tf)])
-```
-
-%% Cell type:markdown id:c87aeaf8 tags:
-
-This time we will pass the first 40 samples and then append the rest. We can also specify the maximum number of tasks running in parallel `max_workers` as well as `prefixes`, `append` and `save_out`.
-
-%% Cell type:code id:9e772a13 tags:
-
-``` python
-mpmsolver.parallel_run(var_samples=var_samples[:40], max_workers=2)
-```
-
-%% Cell type:markdown id:f05e6619 tags:
-
-Now, let's append the rest of the samples.
-
-%% Cell type:code id:127faf15 tags:
-
-``` python
-mpmsolver.parallel_run(var_samples=var_samples[40:], append=True, max_workers=2)
-```
-
-%% Cell type:markdown id:6e83cd2f tags:
-
-Same as serial execution, we can check the results either by using `mpmsolver.outputs` or loading the files available in `sim_dir`.
--- a/docs/examples/sampler_latin.ipynb
+++ b/docs/examples/sampler_latin.ipynb
--- a/docs/examples/sampler_saltelli.ipynb
+++ b/docs/examples/sampler_saltelli.ipynb
--- a/docs/index.md
+++ b/docs/index.md
@@ -6,7 +6,6 @@
 :hidden:

 changelog.md
-contributing.md
 conduct.md
 autoapi/index
 ```