feat(scenarios): simplifying python version of page

Author: amyheather

pages/experiments/scenarios.qmd

@@ -193,8 +193,6 @@ If you are running several scenarios, it can be useful to define a helper functi
 
 > "[HSMA - little book of DES](https://des.hsma.co.uk/)" from Sammi Rosser, Dan Chalk and Amy Heather 2025 (MIT Licence).
 
-We walk through it step-by-step below.
-
 ```{python}
 def run_scenarios(scenarios, param_factory=None):
     """
@@ -262,146 +260,6 @@ def run_scenarios(scenarios, param_factory=None):
     return pd.concat(results)
 ```
 
-### Explaining the `run_scenarios` function
-
-```{.python}
-def run_scenarios(scenarios, param_factory=None):
-    """
-    Execute a set of scenarios and return the results from each run.
-
-    Parameters
-    ----------
-    scenarios : dict
-        Dictionary where key is name of parameter and value is a list with
-        different values to run in scenarios.
-    param_factory : callable or None, optional
-        A callable that returns a new Parameters object for each scenario run.
-        This can be a class (e.g., `Parameters`) or a factory function/lambda
-        with preset arguments (e.g., `lambda: Parameters(number_of_runs=4)`).
-        If not provided, defaults to using `Parameters()` with no arguments.
-
-    Returns
-    -------
-    pandas.DataFrame
-        DataFrame with results from each run of each scenario.
-
-    Notes
-    -----
-    Function adapted from Rosser, Chalk and Heather 2025.
-    """
-    # If none provided, use Parameters
-    if param_factory is None:
-        param_factory = Parameters
-```
-
-The first argument, `scenarios`, is a dictionary. The keys should be parameter names, and the values should be lists of values to run. For example:
-
-```
-{"interarrival_time": [4, 5, 6],
- "number_of_doctors": [2, 3, 4]}
-```
-
-The second argument, `param_factory`, is a callable that returns a fresh Parameters instance for each scenario run. This ensures every scenario gets an independent set of parameters and avoids carrying state from one scenario to another.
-
-* For a default base case, supply `param_factory = Parameters`.
-
-* To use a specific preset (e.g., altering the number of runs for all scenarios), supply a lambda: `param_factory = lambda: Parameters(number_of_runs=4)`
-
-<br>
-
-```{.python}
-# Find every possible permutation of the scenarios
-all_scenarios_tuples = list(itertools.product(*scenarios.values()))
-```
-
-This line generates all possible combinations of values for each parameter.
-
-<br>
-
-```{.python}
-# Convert back into dictionaries
-all_scenarios_dicts = [
-    dict(zip(scenarios.keys(), p)) for p in all_scenarios_tuples
-]
-
-# Preview some of the scenarios
-print(f"There are {len(all_scenarios_dicts)} scenarios. Running:")
-```
-
-Each scenario is converted from a tuple of values into a dictionary, making it easier to update parameters by name when running scenarios.
-
-<br>
-
-```{.python}
-# Run the scenarios...
-results = []
-for index, scenario_to_run in enumerate(all_scenarios_dicts):
-    print(scenario_to_run)
-```
-
-We loop over each scenario dictionary and run it. Printing the scenario shows which parameter values are being used for each run.
-
-<br>
-
-```{.python}
-# Create fresh instance of parameter class for each scenario
-param = param_factory()
-
-# Update parameter list with the scenario parameters
-param.scenario_name = index
-for key in scenario_to_run:
-    setattr(param, key, scenario_to_run[key])     
-```
-
-For each scenario, we create a new (independent) parameter object, then update its attributes to match the scenario values. This ensures each run starts with a fresh configuration and avoids parameter sharing between scenarios.
-
-<br>
-
-```{.python}
-# Perform replications
-scenario_exp = Runner(param)
-scenario_res = scenario_exp.run_reps()["run"]
-
-# Add scenario number and values to the results dataframe
-scenario_res["scenario"] = index
-for key in scenario_to_run:
-    scenario_res[key] = scenario_to_run[key]
-
-# Add results from scenario to list
-results.append(scenario_res)
-```
-
-Run the model for each scenario and collect results, adding the scenario numbers and settings to the output.
-
-<br>
-
-```{.python}
-return pd.concat(results)
-```
-
-Combine results from all scenarios into a single dataframe.
-
-### Run scenarios
-
-We can now use `run_scenarios()` to execute every possible combination of the specified parameters.
-
-```{python}
-# Run scenarios
-scenario_results = run_scenarios(
-    scenarios = {"interarrival_time": [4, 5, 6, 7, 8],
-                 "number_of_doctors": [3, 4, 5]},
-    param_factory = lambda: Parameters(number_of_runs = 100)
-)
-
-# Save to CSV
-scenario_results.to_csv(
-    "scenarios_resources/python_scenario_results.csv", index=False
-)
-
-# View scenario results
-HTML(to_html_datatable(scenario_results.head(200)))
-```
-
 :::
 
 ::: {.r-content}
@@ -476,14 +334,39 @@ run_scenarios <- function(scenarios, base_list, verbose = TRUE) {
 }
 ```
 
-This function generates all possible scenario combinations from the values supplied in `scenarios`.
+:::
+
+The function generates all possible scenario combinations from the values supplied in `scenarios`.
 
 It then iterates through these, creating a fresh set of parameters for each scenario run. This ensures every scenario gets an independent set of parameters and avoids carrying state from one scenario to another.
 
 The replication results from each scenario are saved in a list and finally combined into a single table.
 
 Let's run it!
 
+::: {.python-content}
+
+```{python}
+# Run scenarios
+scenario_results = run_scenarios(
+    scenarios = {"interarrival_time": [4, 5, 6, 7, 8],
+                 "number_of_doctors": [3, 4, 5]},
+    param_factory = lambda: Parameters(number_of_runs = 100)
+)
+
+# Save to CSV
+scenario_results.to_csv(
+    "scenarios_resources/python_scenario_results.csv", index=False
+)
+
+# View scenario results
+HTML(to_html_datatable(scenario_results.head(200)))
+```
+
+:::
+
+::: {.r-content}
+
 ```{r}
 # Run scenarios
 scenarios <- list(