HostingCapacity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CIRED 2024 Article\n",
    "\n",
    "This notebook contains the simulation presented in the article submitted to the CIRED 2024 conference by Roseau Technologies.\n",
    "\n",
    "You can find the article in pdf format here: [Roseau_Load_Flow_CIRED_2024.pdf](./Article/Roseau_Load_Flow_CIRED_2024.pdf)\n",
    "\n",
    "<!-- TODO: Add the published pdf when available and add citation -->\n",
    "\n",
    "The goal of the article is study the hosting capacity of a low-voltage grid with a non-firm connection of PV farm.\n",
    "The flexibility of the non-firm connection is modelled with the\n",
    "[flexible loads](https://roseau-load-flow.roseautechnologies.com/models/Load/FlexibleLoad/index.html)\n",
    "built into the _Roseau Load Flow_ solver.\n",
    "\n",
    "The low-voltage grid chosen to perform this study is the following:\n",
    "https://roseau-load-flow.roseautechnologies.com/_static/Network/LVFeeder00939.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import IFrame\n",
    "\n",
    "url = \"https://roseau-load-flow.roseautechnologies.com/_static/Network/LVFeeder00939.html\"\n",
    "IFrame(url, width=1000, height=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cmath\n",
    "from pathlib import Path\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import roseau.load_flow as lf\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set_theme()\n",
    "DATA_DIR = Path(\"data\")\n",
    "RESULTS_DIR = Path(\"results\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Activate the public [license](https://roseau-load-flow.roseautechnologies.com/License.html) of _Roseau Load Flow_.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext dotenv\n",
    "%dotenv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read the loads profiles\n",
    "\n",
    "The load profiles are randomly generated using [pyLPG](https://github.com/FZJ-IEK3-VSA/pylpg)[1]\n",
    "\n",
    "```bibliography\n",
    "[1] Pflugradt et al., (2022). “LoadProfileGenerator: An Agent-Based Behavior Simulation\n",
    "for Generating Residential Load Profiles”. Journal of Open Source Software, 7(71), 3574,\n",
    "https://doi.org/10.21105/joss.03574.\n",
    "```\n",
    "\n",
    "Here we have load profiles of the full year 2020 with a 1-minute time step generated in advance\n",
    "and stored in an HDF file. We load the profiles into a dataframe and resample it into a 10-minute\n",
    "time series.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "load_profiles_original: pd.DataFrame = pd.read_hdf(DATA_DIR / \"10_random_load_curves.hdf\")\n",
    "# Resample to 10 minutes\n",
    "load_profiles = load_profiles_original.resample(\"10min\").mean()\n",
    "load_profiles.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can take a look at how these load profiles roughly look like by plotting the first day:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_day_mask: \"pd.Series[bool]\" = load_profiles.index.date == pd.to_datetime(\"2020-01-01\").date()\n",
    "first_day = load_profiles.loc[first_day_mask]\n",
    "first_day_plot_df = first_day.melt(var_name=\"House\", value_name=\"Power (kW)\", ignore_index=False).reset_index(\n",
    "    names=\"Time\"\n",
    ")\n",
    "g = sns.relplot(\n",
    "    first_day_plot_df,\n",
    "    x=\"Time\",\n",
    "    y=\"Power (kW)\",\n",
    "    style=\"House\",\n",
    "    hue=\"House\",\n",
    "    height=5,\n",
    "    aspect=2.5,\n",
    "    kind=\"scatter\",\n",
    "    facet_kws={\"sharey\": False},\n",
    ")\n",
    "g.figure.autofmt_xdate()\n",
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "load_profile_names = load_profiles.columns.tolist()\n",
    "load_profile_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Read the generation profile\n",
    "\n",
    "The PV power profile are generated using the Photovoltaic Geographical Information System (PVGIS)[2]\n",
    "\n",
    "```bibliography\n",
    "[2] Thomas Huld, Richard Müller, Attilio Gambardella, \"A new solar radiation database for\n",
    "estimating PV performance in Europe and Africa,\" Solar Energy, Volume 86, Issue 6, 2012,\n",
    "Pages 1803-1815, ISSN 0038-092X, https://doi.org/10.1016/j.solener.2012.03.006.\n",
    "```\n",
    "\n",
    "Here we have a single PV profile of the full year 2019 with a 5-minute sample time stored in a\n",
    "CSV file. We load the profile into a dataframe and resample it into a 10-minute time series.\n",
    "\n",
    "The data is stored in the form of a coefficient between 0 and 1 that represents the generated\n",
    "power as a percentage of the rated power of the inverter.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This data is for the year 2019 but the loads profiles are for the year 2020 which is a leap year\n",
    "# This data is one day short of a full year 2020 (equivalent to 144 records of 10 minutes)\n",
    "producer_profile_original = pd.read_csv(DATA_DIR / \"PV_Profile_PVGIS_1.csv\", index_col=0, parse_dates=[\"HORODATE\"])\n",
    "# The production data is sampled every 5 minutes, we need to resample it to 10 minutes\n",
    "# Note: using resample() method produces NaN values around the DST transition so we resample with iloc\n",
    "producer_profile = producer_profile_original.iloc[0::2][\"COEFFICIENT_AJUSTE\"].rename(\"coefficient\")\n",
    "# Replace the index of the producer_profile series by the index of the load_profiles dataframe\n",
    "producer_profile.index = load_profiles.index[: len(producer_profile)]\n",
    "producer_profile.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the network with a flexible PV generator\n",
    "\n",
    "The farthest bus from the substation is `LVBus004115` (see the map above).\n",
    "We choose this bus to connect our PV installation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_network(s_max: int, projection: str) -> lf.ElectricalNetwork:\n",
    "    \"\"\"Create a network with a non-firm PV generator represented by the load with ID \"producer\".\n",
    "\n",
    "    Args:\n",
    "        s_max: The rated power of the inverter of the non-firm PV installation.\n",
    "        projection: The type of the projection used (\"euclidean\", \"keep_p\", or \"keep_q\").\n",
    "\n",
    "    Returns:\n",
    "        The created network.\n",
    "    \"\"\"\n",
    "    en = lf.ElectricalNetwork.from_catalogue(\"LVFeeder00939\", \"summer\")\n",
    "\n",
    "    u_max = 1.085 * 230  # The voltage limit is set to the nominal voltage + 8.5%\n",
    "    uq_up, uq_max = u_max - 10, u_max - 5  # 10V before the limit, the Q(U) control activates\n",
    "    up_up, up_max = u_max - 5, u_max  # 5V before the limit, the P(U) control activates\n",
    "\n",
    "    # A PV inverter is modelled with a constant-power load with negative active power\n",
    "    lf.PowerLoad(\n",
    "        \"producer\",\n",
    "        bus=en.buses[\"LVBus004115\"],\n",
    "        phases=\"abcn\",  # three-phase PV inverter\n",
    "        powers=[-s_max, -s_max, -s_max],\n",
    "        flexible_params=[\n",
    "            lf.FlexibleParameter.pq_u_production(\n",
    "                up_up=up_up,\n",
    "                up_max=up_max,\n",
    "                uq_min=207,\n",
    "                uq_down=212,\n",
    "                uq_up=uq_up,\n",
    "                uq_max=uq_max,\n",
    "                s_max=s_max,\n",
    "                type_proj=projection,\n",
    "            )\n",
    "            for _ in range(3)  # Three flexible parameters, one per phase\n",
    "        ],\n",
    "    )\n",
    "    vs = en.sources[\"VoltageSource\"]\n",
    "    vs.voltages *= 1.05  # Set the voltage of the upstream MV grid\n",
    "    return en"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run the simulation\n",
    "\n",
    "We run three simulations, one for each projection type.\n",
    "\n",
    "1. Set the `projection` variable in the following cell to `\"euclidean\"`, `\"keep_p\"`, or `\"keep_q\"` then\n",
    "   execute all the cells below to run the time series simulation and save its results to the disk.\n",
    "2. Repeat this procedure for the other two projections.\n",
    "3. At the end, we will have a \"results\" folder with the time series results as well as file\n",
    "   \"statistics.csv\" for each projection.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lf_results = []\n",
    "bus_results = []\n",
    "line_results = []\n",
    "transformer_results = []\n",
    "loads_results = []\n",
    "\n",
    "# Choose the projection type (uncomment the corresponding line)\n",
    "# -------------------------------------------------------------\n",
    "projection = \"euclidean\"\n",
    "# projection = \"keep_p\"\n",
    "# projection = \"keep_q\"\n",
    "\n",
    "# We consider that the PV inverters operate with a cos Phi = 0.98 by default\n",
    "complex_power = cmath.exp(1j * cmath.acos(-0.98))\n",
    "producer_s_max = 24_000\n",
    "\n",
    "# Create the network and add the non-firm producer\n",
    "# ------------------------------------------------\n",
    "en = create_network(producer_s_max, projection)\n",
    "non_firm_producer: lf.PowerLoad = en.loads[\"producer\"]\n",
    "\n",
    "# We also add a normal single-phase producer on bus LVBus004116 to help create voltage constraints\n",
    "firm_producer: lf.PowerLoad = en.loads[\"LVBus004116_production\"]\n",
    "\n",
    "\n",
    "# Run the time series simulation\n",
    "# ------------------------------\n",
    "load: lf.PowerLoad\n",
    "indices = range(min(load_profiles.shape[0], producer_profile.shape[0]))\n",
    "for idx in indices:\n",
    "    # Get the next time step\n",
    "    ts = load_profiles.index[idx]\n",
    "    ts_prod = producer_profile.index[idx]\n",
    "\n",
    "    # Update the power of all loads\n",
    "    col_idx = 0\n",
    "    prod_power_coef = max(producer_profile.at[ts_prod], 1e-3)\n",
    "    for load in en.loads.values():\n",
    "        if load.id.endswith(\"_consumption\"):\n",
    "            # Load powers are read from the load_profiles data frame\n",
    "            load.powers = [load_profiles.at[ts, load_profile_names[col_idx]] * 1e3]\n",
    "            col_idx += 1\n",
    "        elif load.id == firm_producer.id:\n",
    "            # The normal (firm) producer's power is 12kVA multiplied by the PV profile coefficient\n",
    "            load.powers = [12_000 * complex_power * prod_power_coef]\n",
    "        elif load.id == non_firm_producer.id:\n",
    "            # The non-firm producer's power is 24kVA (per phase) multiplied by the PV profile coefficient\n",
    "            load.powers = [producer_s_max * complex_power * prod_power_coef] * 3  # three-phase\n",
    "        else:\n",
    "            # Other existing dummy producers are not active\n",
    "            load.powers = [0]  # Set powers of other producers to 0\n",
    "\n",
    "    # Run the load flow with the updated loads\n",
    "    iterations, residual = en.solve_load_flow()\n",
    "\n",
    "    # Store the results of the load flow\n",
    "    lf_results.append({\"timestamp\": ts, \"iterations\": iterations, \"residual\": residual})\n",
    "\n",
    "    # Store the results of all LV buses\n",
    "    for bus in en.buses.values():\n",
    "        if bus.id == \"MVLV03045\":\n",
    "            continue  # Skip the substation\n",
    "        res_voltages = abs(bus.res_voltages.m)\n",
    "        res_violated = (res_voltages < bus.min_voltage.m) | (res_voltages > bus.max_voltage.m)\n",
    "        vuf = bus.res_voltage_unbalance().m\n",
    "        for ph, voltage, violated in zip(bus.voltage_phases, res_voltages, res_violated, strict=True):\n",
    "            bus_results.append({\n",
    "                \"timestamp\": ts,\n",
    "                \"bus\": bus.id,\n",
    "                \"phase\": ph,\n",
    "                \"type\": \"voltage\",\n",
    "                \"value\": voltage,\n",
    "                \"violated\": violated,\n",
    "                \"unbalance_factor\": vuf,\n",
    "            })\n",
    "\n",
    "    # Store the results of the lines and transformers\n",
    "    for branch in en.branches.values():\n",
    "        if isinstance(branch, lf.Line):\n",
    "            res_currents = abs(branch.res_series_currents.m)\n",
    "            res_violated = res_currents > branch.parameters.max_current.m\n",
    "            for ph, current, power, violated in zip(\n",
    "                branch.phases, res_currents, branch.res_power_losses.m.real, res_violated, strict=True\n",
    "            ):\n",
    "                line_results.append({\n",
    "                    \"timestamp\": ts,\n",
    "                    \"branch\": branch.id,\n",
    "                    \"phase\": ph,\n",
    "                    \"type\": \"current\",\n",
    "                    \"value\": current,\n",
    "                    \"violated\": violated,\n",
    "                })\n",
    "                line_results.append({\n",
    "                    \"timestamp\": ts,\n",
    "                    \"branch\": branch.id,\n",
    "                    \"phase\": ph,\n",
    "                    \"type\": \"power\",\n",
    "                    \"value\": power,\n",
    "                    \"violated\": violated,\n",
    "                })\n",
    "        elif isinstance(branch, lf.Transformer):\n",
    "            res_powers1, res_powers2 = (p.m.sum() for p in branch.res_powers)\n",
    "            max_power = branch.parameters.max_power.m\n",
    "            violated = abs(res_powers1) > max_power or abs(res_powers2) > max_power\n",
    "            ph1, ph2 = branch.phases1, branch.phases2\n",
    "            transformer_results.append({\n",
    "                \"timestamp\": ts,\n",
    "                \"branch\": branch.id,\n",
    "                \"phase\": ph1,\n",
    "                \"type\": \"active_power\",\n",
    "                \"value\": res_powers1.real,\n",
    "                \"violated\": violated,\n",
    "                \"side\": \"primary\",\n",
    "            })\n",
    "            transformer_results.append({\n",
    "                \"timestamp\": ts,\n",
    "                \"branch\": branch.id,\n",
    "                \"phase\": ph1,\n",
    "                \"type\": \"reactive_power\",\n",
    "                \"value\": res_powers1.imag,\n",
    "                \"violated\": violated,\n",
    "                \"side\": \"primary\",\n",
    "            })\n",
    "            transformer_results.append({\n",
    "                \"timestamp\": ts,\n",
    "                \"branch\": branch.id,\n",
    "                \"phase\": ph2,\n",
    "                \"type\": \"active_power\",\n",
    "                \"value\": res_powers2.real,\n",
    "                \"violated\": violated,\n",
    "                \"side\": \"secondary\",\n",
    "            })\n",
    "            transformer_results.append({\n",
    "                \"timestamp\": ts,\n",
    "                \"branch\": branch.id,\n",
    "                \"phase\": ph2,\n",
    "                \"type\": \"reactive_power\",\n",
    "                \"value\": res_powers2.imag,\n",
    "                \"violated\": violated,\n",
    "                \"side\": \"secondary\",\n",
    "            })\n",
    "\n",
    "    # Store the results of the non-firm PV\n",
    "    load_theoretical_power = non_firm_producer.powers.m.sum()\n",
    "    res_flexible_power = non_firm_producer.res_flexible_powers.m.sum()\n",
    "    loads_results.append({\n",
    "        \"timestamp\": ts,\n",
    "        \"load\": non_firm_producer.id,\n",
    "        \"phase\": non_firm_producer.phases,\n",
    "        \"type\": \"active_power\",\n",
    "        \"value\": res_flexible_power.real,\n",
    "        \"flexible\": True,\n",
    "    })\n",
    "    loads_results.append({\n",
    "        \"timestamp\": ts,\n",
    "        \"load\": non_firm_producer.id,\n",
    "        \"phase\": non_firm_producer.phases,\n",
    "        \"type\": \"reactive_power\",\n",
    "        \"value\": res_flexible_power.imag,\n",
    "        \"flexible\": True,\n",
    "    })\n",
    "    loads_results.append({\n",
    "        \"timestamp\": ts,\n",
    "        \"load\": non_firm_producer.id,\n",
    "        \"phase\": non_firm_producer.phases,\n",
    "        \"type\": \"active_power\",\n",
    "        \"value\": load_theoretical_power.real,\n",
    "        \"flexible\": False,\n",
    "    })\n",
    "    loads_results.append({\n",
    "        \"timestamp\": ts,\n",
    "        \"load\": non_firm_producer.id,\n",
    "        \"phase\": non_firm_producer.phases,\n",
    "        \"type\": \"reactive_power\",\n",
    "        \"value\": load_theoretical_power.imag,\n",
    "        \"flexible\": False,\n",
    "    })"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulation results and statistics\n",
    "\n",
    "We read the results into data frames and calculate some statistics including the annual energy curtailment\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Reading load flow results ...\")\n",
    "lf_results_df = pd.DataFrame(lf_results)\n",
    "print(\"Reading bus results ...\")\n",
    "bus_results_df = pd.DataFrame(bus_results)\n",
    "print(\"Reading line results ...\")\n",
    "line_results_df = pd.DataFrame(line_results)\n",
    "print(\"Reading transformer results ...\")\n",
    "transformer_results_df = pd.DataFrame(transformer_results)\n",
    "print(\"Reading loads results ...\")\n",
    "load_results_df = pd.DataFrame(loads_results)\n",
    "print(\"Done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_energy(df: pd.DataFrame) -> float:\n",
    "    \"\"\"E(Wh) = ∑ P(W) * 10 (min) / 60 (hour).\"\"\"\n",
    "    powers = -df.loc[(df[\"type\"] == \"active_power\") & (df[\"load\"] == \"producer\"), \"value\"]\n",
    "    total_wh_energy = powers.sum() / 6\n",
    "\n",
    "    # # Alternatively, we can integrate using the trapezoid method\n",
    "    # from scipy import integrate\n",
    "    # total_wh_energy = integrate.trapezoid(powers.values, dx=1 / 6)\n",
    "\n",
    "    return total_wh_energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Statistics\n",
    "statistics = []\n",
    "\n",
    "# Producer\n",
    "theoretical_energy = calculate_energy(load_results_df.loc[~load_results_df[\"flexible\"]])\n",
    "flexible_energy = calculate_energy(load_results_df.loc[load_results_df[\"flexible\"]])\n",
    "curtailment = (theoretical_energy - flexible_energy) / theoretical_energy\n",
    "statistics.append({\"name\": \"Theoretical producer energy\", \"value\": theoretical_energy, \"unit\": \"Wh\"})\n",
    "statistics.append({\"name\": \"Flexible producer energy\", \"value\": flexible_energy, \"unit\": \"Wh\"})\n",
    "statistics.append({\"name\": \"Producer energy curtailment\", \"value\": curtailment * 100, \"unit\": \"%\"})\n",
    "\n",
    "# Buses\n",
    "statistics.append({\"name\": \"Voltage violations count\", \"value\": bus_results_df[\"violated\"].sum() // 3, \"unit\": \"\"})\n",
    "statistics.append({\"name\": \"Maximum voltage\", \"value\": bus_results_df[\"value\"].max(), \"unit\": \"V\"})\n",
    "statistics.append({\"name\": \"Minimum voltage\", \"value\": bus_results_df[\"value\"].min(), \"unit\": \"V\"})\n",
    "statistics.append({\"name\": \"Average voltage\", \"value\": bus_results_df[\"value\"].mean(), \"unit\": \"V\"})\n",
    "statistics.append({\"name\": \"Maximum VUF\", \"value\": bus_results_df[\"unbalance_factor\"].max(), \"unit\": \"%\"})\n",
    "statistics.append({\"name\": \"Minimum VUF\", \"value\": bus_results_df[\"unbalance_factor\"].min(), \"unit\": \"%\"})\n",
    "statistics.append({\"name\": \"Average VUF\", \"value\": bus_results_df[\"unbalance_factor\"].mean(), \"unit\": \"%\"})\n",
    "\n",
    "# Lines\n",
    "statistics.append({\n",
    "    \"name\": \"Maximum line current\",\n",
    "    \"value\": line_results_df.loc[\n",
    "        (line_results_df[\"phase\"].isin(tuple(\"abc\"))) & (line_results_df[\"type\"] == \"current\"), \"value\"\n",
    "    ].max(),\n",
    "    \"unit\": \"A\",\n",
    "})\n",
    "statistics.append({\n",
    "    \"name\": \"Maximum neutral current\",\n",
    "    \"value\": line_results_df.loc[\n",
    "        (line_results_df[\"phase\"] == \"n\") & (line_results_df[\"type\"] == \"current\"), \"value\"\n",
    "    ].max(),\n",
    "    \"unit\": \"A\",\n",
    "})\n",
    "\n",
    "# Transformer\n",
    "tr_p = transformer_results_df.loc[transformer_results_df[\"type\"] == \"active_power\"]\n",
    "tr_q = transformer_results_df.loc[transformer_results_df[\"type\"] == \"reactive_power\"]\n",
    "statistics.append({\"name\": \"Maximum transformer active power\", \"value\": np.max(abs(tr_p[\"value\"])), \"unit\": \"W\"})\n",
    "statistics.append({\"name\": \"Maximum transformer reactive power\", \"value\": (np.max(abs(tr_q[\"value\"]))), \"unit\": \"VAr\"})\n",
    "statistics.append({\n",
    "    \"name\": \"Transformer injected energy\",\n",
    "    \"value\": tr_p.loc[tr_p[\"side\"] == \"primary\", \"value\"].sum() / 6,\n",
    "    \"unit\": \"Wh\",\n",
    "})\n",
    "\n",
    "# Energy losses\n",
    "statistics.append({\n",
    "    \"name\": \"Lines losses\",\n",
    "    \"value\": (line_losses := line_results_df.loc[line_results_df[\"type\"] == \"power\", \"value\"].sum() / 6),\n",
    "    \"unit\": \"Wh\",\n",
    "})\n",
    "statistics.append({\n",
    "    \"name\": \"Transformer losses\",\n",
    "    \"value\": (transformer_losses := tr_p[\"value\"].sum() / 6),\n",
    "    \"unit\": \"Wh\",\n",
    "})\n",
    "statistics.append({\"name\": \"Total losses\", \"value\": line_losses + transformer_losses, \"unit\": \"Wh\"})\n",
    "\n",
    "statistics_df = pd.DataFrame(statistics)\n",
    "statistics_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the results\n",
    "\n",
    "We then save the time series and statistics results to the disk for later analysis\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(RESULTS_DIR / projection).mkdir(parents=True, exist_ok=True)\n",
    "print(\"Saving the network ...\")\n",
    "en.to_json(RESULTS_DIR / projection / \"network.json\", include_results=False)\n",
    "print(\"Saving load flow results ...\")\n",
    "lf_results_df.to_csv(RESULTS_DIR / projection / \"load_flow.csv\", index=False)\n",
    "print(\"Saving bus results ...\")\n",
    "bus_results_df.to_csv(RESULTS_DIR / projection / \"bus.csv\", index=False)\n",
    "print(\"Saving line results ...\")\n",
    "line_results_df.to_csv(RESULTS_DIR / projection / \"line.csv\", index=False)\n",
    "print(\"Saving transformer results ...\")\n",
    "transformer_results_df.to_csv(RESULTS_DIR / projection / \"transformer.csv\", index=False)\n",
    "print(\"Saving load results ...\")\n",
    "load_results_df.to_csv(RESULTS_DIR / projection / \"load.csv\", index=False)\n",
    "print(\"Saving the statistics ...\")\n",
    "statistics_df.to_csv(RESULTS_DIR / projection / \"statistics.csv\", index=False)\n",
    "print(\"Done\")"
   ]
  }
 ],
 "metadata": {
  "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}