diff --git a/pvlib/ivtools/sdm/Villalva.ipynb b/pvlib/ivtools/sdm/Villalva.ipynb new file mode 100644 index 0000000000..dc5b4a5633 --- /dev/null +++ b/pvlib/ivtools/sdm/Villalva.ipynb @@ -0,0 +1,2078 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9d952e72", + "metadata": {}, + "source": [ + "# Villalva single-diode model: parameter extraction and I–V curves\n", + "\n", + "This notebook is organized as a compact pvlib-style example, analogous to the\n", + "De Soto workflow:\n", + "\n", + "1. extract the five single-diode equation (SDM) parameters at STC from\n", + " manufacturer datasheet values using Villalva's iterative fitting method;\n", + "2. inspect the evolution of the modeled maximum power as the series resistance\n", + " \\(R_s\\) is incremented;\n", + "3. validate the fitted STC I–V curve against the datasheet key points;\n", + "4. calculate the SDM parameters at different operating conditions using\n", + " Villalva's temperature and irradiance equations;\n", + "5. solve and plot the resulting operating-condition I–V curves with pvlib.\n", + "\n", + "The implementation is based on Villalva's thesis, Chapter 3 and Appendix A,\n", + "and Villalva, Gazoli, and Ruppert Filho (2009).\n", + "\n", + "The example PV module is the **JA Solar JAM78D40-625/MB**.\n", + "\n", + "References\n", + "----------\n", + "- M. G. Villalva, PhD thesis, Chapter 3 and Appendix A.\n", + "- M. G. Villalva, J. R. Gazoli, E. Ruppert Filho,\n", + " \"Comprehensive Approach to Modeling and Simulation of Photovoltaic Arrays\",\n", + " IEEE Transactions on Power Electronics, 2009.\n", + "- pvlib De Soto example:\n", + " https://pvlib-python.readthedocs.io/en/stable/gallery/iv-modeling/plot_singlediode.html" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6143cb3c", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from scipy import constants\n", + "\n", + "from pvlib import pvsystem" + ] + }, + { + "cell_type": "markdown", + "id": "c093d7cb", + "metadata": {}, + "source": [ + "## Proposed `pvlib.ivtools.sdm.fit_villalva`\n", + "\n", + "Villalva's basic fitting method assumes that the diode ideality factor \\(a\\)\n", + "is supplied by the user.\n", + "\n", + "The algorithm increments \\(R_s\\) from zero. For each candidate \\(R_s\\), the\n", + "corresponding \\(R_{sh}\\), \\(I_L\\), and \\(I_0\\) are calculated and the maximum\n", + "power of the resulting single-diode model is evaluated. The selected solution\n", + "is the one that minimizes\n", + "\n", + "\\[\n", + "P_mp,experimental - V_mp * I_mp.\n", + "\\]\n", + "\n", + "The helper function below combines Villalva's MPP relation, photocurrent\n", + "correction, and finite-\\(R_{sh}\\) open-circuit equation for one candidate\n", + "\\(R_s\\). This keeps each stored iteration internally self-consistent while\n", + "preserving Villalva's explicit outer \\(R_s\\) search." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "161ebc95", + "metadata": {}, + "outputs": [], + "source": [ + "def _villalva_params_at_rs(\n", + " resistance_series,\n", + " v_mp,\n", + " i_mp,\n", + " v_oc,\n", + " i_sc,\n", + " a_ref,\n", + "):\n", + " \"\"\"Calculate I_L, I_o and R_sh for one candidate R_s.\"\"\"\n", + "\n", + " exp_voc = np.expm1(v_oc / a_ref)\n", + " exp_vmp = np.expm1(\n", + " (v_mp + i_mp * resistance_series) / a_ref\n", + " )\n", + "\n", + " p_mp = v_mp * i_mp\n", + "\n", + " # Algebraic combination of Villalva's equations:\n", + " #\n", + " # I_L = (R_sh + R_s) / R_sh * I_sc\n", + " #\n", + " # I_o = (I_L - V_oc / R_sh) /\n", + " # (exp(V_oc / a_ref) - 1)\n", + " #\n", + " # and the R_sh(R_s) relation obtained at the MPP.\n", + " A = (\n", + " v_mp * i_sc\n", + " - v_mp * i_sc * exp_vmp / exp_voc\n", + " - p_mp\n", + " )\n", + "\n", + " B = (\n", + " v_mp * i_sc * resistance_series\n", + " - v_mp\n", + " * (i_sc * resistance_series - v_oc)\n", + " * exp_vmp / exp_voc\n", + " )\n", + "\n", + " resistance_shunt = (\n", + " v_mp * (v_mp + i_mp * resistance_series) - B\n", + " ) / A\n", + "\n", + " photocurrent = (\n", + " (resistance_shunt + resistance_series)\n", + " / resistance_shunt\n", + " * i_sc\n", + " )\n", + "\n", + " saturation_current = (\n", + " photocurrent - v_oc / resistance_shunt\n", + " ) / exp_voc\n", + "\n", + " return photocurrent, saturation_current, resistance_shunt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "af44e867", + "metadata": {}, + "outputs": [], + "source": [ + "def fit_villalva(\n", + " v_mp,\n", + " i_mp,\n", + " v_oc,\n", + " i_sc,\n", + " alpha_sc,\n", + " beta_voc,\n", + " cells_in_series,\n", + " diode_factor,\n", + " temp_ref=25.0,\n", + " irrad_ref=1000.0,\n", + " rs_step=1e-4,\n", + " rs_max=None,\n", + "):\n", + " \"\"\"Fit Villalva single-diode model parameters from datasheet values.\n", + "\n", + " The series resistance is swept from 0 to ``rs_max``.\n", + " The selected solution is the valid iteration that gives the\n", + " minimum absolute difference between modeled and reference Pmp.\n", + "\n", + " Parameters\n", + " ----------\n", + " v_mp : float\n", + " Maximum-power voltage at reference conditions [V].\n", + " i_mp : float\n", + " Maximum-power current at reference conditions [A].\n", + " v_oc : float\n", + " Open-circuit voltage at reference conditions [V].\n", + " i_sc : float\n", + " Short-circuit current at reference conditions [A].\n", + " alpha_sc : float\n", + " Short-circuit current temperature coefficient [A/K].\n", + " beta_voc : float\n", + " Open-circuit voltage temperature coefficient [V/K].\n", + " cells_in_series : int\n", + " Effective number of cells/junctions connected in series.\n", + " diode_factor : float\n", + " Dimensionless diode ideality factor used by Villalva.\n", + " temp_ref : float, default 25\n", + " Reference cell temperature [degC].\n", + " irrad_ref : float, default 1000\n", + " Reference irradiance [W/m2].\n", + " rs_step : float, default 1e-4\n", + " Increment of series resistance [ohm].\n", + " rs_max : float, optional\n", + " Maximum series resistance considered [ohm].\n", + " If None, ``v_oc / i_sc`` is used.\n", + "\n", + " Returns\n", + " -------\n", + " params : dict\n", + " Fitted Villalva reference parameters.\n", + " history : pandas.DataFrame\n", + " Full fitting history as R_s is incremented.\n", + " \"\"\"\n", + "\n", + " temp_ref_k = temp_ref + 273.15\n", + "\n", + " # a_ref = a * Ns * kT/q\n", + " a_ref = (\n", + " diode_factor\n", + " * cells_in_series\n", + " * constants.k\n", + " * temp_ref_k\n", + " / constants.e\n", + " )\n", + "\n", + " p_mp_ref = v_mp * i_mp\n", + "\n", + " # Villalva minimum shunt resistance.\n", + " r_sh_min = (\n", + " v_mp / (i_sc - i_mp)\n", + " - (v_oc - v_mp) / i_mp\n", + " )\n", + "\n", + " if r_sh_min <= 0:\n", + " raise ValueError(\"Villalva R_sh_min must be positive.\")\n", + "\n", + " if rs_max is None:\n", + " rs_max = v_oc / i_sc\n", + "\n", + " rows = []\n", + "\n", + " rs_values = np.arange(\n", + " 0.0,\n", + " rs_max + 0.5 * rs_step,\n", + " rs_step,\n", + " )\n", + "\n", + " for resistance_series in rs_values:\n", + "\n", + " try:\n", + " photocurrent, saturation_current, resistance_shunt = (\n", + " _villalva_params_at_rs(\n", + " resistance_series,\n", + " v_mp,\n", + " i_mp,\n", + " v_oc,\n", + " i_sc,\n", + " a_ref,\n", + " )\n", + " )\n", + " except (FloatingPointError, ZeroDivisionError):\n", + " continue\n", + "\n", + " if (\n", + " not np.isfinite(resistance_shunt)\n", + " or resistance_shunt < r_sh_min\n", + " or photocurrent <= 0\n", + " or saturation_current <= 0\n", + " ):\n", + " continue\n", + "\n", + " try:\n", + " mpp = pvsystem.max_power_point(\n", + " photocurrent=photocurrent,\n", + " saturation_current=saturation_current,\n", + " resistance_series=resistance_series,\n", + " resistance_shunt=resistance_shunt,\n", + " nNsVth=a_ref,\n", + " method=\"brentq\",\n", + " )\n", + " except (ValueError, RuntimeError):\n", + " continue\n", + "\n", + " p_mp_model = float(np.asarray(mpp[\"p_mp\"]))\n", + " power_error = p_mp_model - p_mp_ref\n", + "\n", + " rows.append({\n", + " \"R_s\": resistance_series,\n", + " \"R_sh_ref\": resistance_shunt,\n", + " \"I_L_ref\": photocurrent,\n", + " \"I_o_ref\": saturation_current,\n", + " \"v_mp_model\": float(np.asarray(mpp[\"v_mp\"])),\n", + " \"i_mp_model\": float(np.asarray(mpp[\"i_mp\"])),\n", + " \"p_mp_model\": p_mp_model,\n", + " \"p_mp_ref\": p_mp_ref,\n", + " \"power_error\": power_error,\n", + " \"abs_power_error\": abs(power_error),\n", + " })\n", + "\n", + " if not rows:\n", + " raise RuntimeError(\"No valid Villalva solution was found.\")\n", + "\n", + " history = pd.DataFrame(rows)\n", + "\n", + " # Select the Rs that gives the closest modeled Pmp to Vmp * Imp.\n", + " best = history.loc[\n", + " history[\"abs_power_error\"].idxmin()\n", + " ]\n", + "\n", + " params = {\n", + " \"I_L_ref\": float(best[\"I_L_ref\"]),\n", + " \"I_o_ref\": float(best[\"I_o_ref\"]),\n", + " \"R_s\": float(best[\"R_s\"]),\n", + " \"R_sh_ref\": float(best[\"R_sh_ref\"]),\n", + " \"a_ref\": float(a_ref),\n", + " \"alpha_sc\": alpha_sc,\n", + " \"beta_voc\": beta_voc,\n", + " \"i_sc_ref\": i_sc,\n", + " \"v_oc_ref\": v_oc,\n", + " \"irrad_ref\": irrad_ref,\n", + " \"temp_ref\": temp_ref,\n", + " }\n", + "\n", + " return params, history" + ] + }, + { + "cell_type": "markdown", + "id": "18e65416", + "metadata": {}, + "source": [ + "## Proposed `pvlib.pvsystem.calcparams_villalva`\n", + "\n", + "Villalva models the photocurrent as\n", + "\n", + "\\[\n", + "I_L =\n", + "\\left(I_{L,\\mathrm{ref}}+\\alpha_{sc}\\Delta T\\right)\n", + "\\frac{G}{G_{\\mathrm{ref}}}.\n", + "\\]\n", + "\n", + "The paper introduces the datasheet temperature coefficients of \\(I_{sc}\\) and\n", + "\\(V_{oc}\\) into the saturation-current equation. The thesis Appendix A also\n", + "shows a finite-\\(R_{sh}\\) form. That finite-\\(R_{sh}\\) form is used below so\n", + "that the operational model is consistent with the fitted reference parameters.\n", + "\n", + "The fitted \\(R_s\\) and \\(R_{sh}\\) are kept constant with operating condition,\n", + "following the thesis modeling assumption." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ede0beb1", + "metadata": {}, + "outputs": [], + "source": [ + "def calcparams_villalva(\n", + " effective_irradiance,\n", + " temp_cell,\n", + " alpha_sc,\n", + " beta_voc,\n", + " a_ref,\n", + " I_L_ref,\n", + " R_sh_ref,\n", + " R_s,\n", + " i_sc_ref,\n", + " v_oc_ref,\n", + " irrad_ref=1000.0,\n", + " temp_ref=25.0,\n", + "):\n", + " \"\"\"Calculate Villalva SDM parameters at operating conditions.\n", + "\n", + " Parameters\n", + " ----------\n", + " effective_irradiance : numeric\n", + " Effective irradiance [W/m2].\n", + " temp_cell : numeric\n", + " Cell temperature [degC].\n", + " alpha_sc : float\n", + " Short-circuit current temperature coefficient [A/K].\n", + " beta_voc : float\n", + " Open-circuit voltage temperature coefficient [V/K].\n", + " a_ref : float\n", + " n * Ns * Vth at the reference temperature [V].\n", + " I_L_ref : float\n", + " Light-generated current at reference conditions [A].\n", + " R_sh_ref : float\n", + " Shunt resistance at reference conditions [ohm].\n", + " R_s : float\n", + " Series resistance [ohm].\n", + " i_sc_ref : float\n", + " Short-circuit current at reference conditions [A].\n", + " v_oc_ref : float\n", + " Open-circuit voltage at reference conditions [V].\n", + " irrad_ref : float, default 1000\n", + " Reference irradiance [W/m2].\n", + " temp_ref : float, default 25\n", + " Reference cell temperature [degC].\n", + "\n", + " Returns\n", + " -------\n", + " photocurrent, saturation_current, resistance_series,\n", + " resistance_shunt, nNsVth\n", + " \"\"\"\n", + "\n", + " temp_ref_k = temp_ref + 273.15\n", + " temp_cell_k = temp_cell + 273.15\n", + "\n", + " delta_t = temp_cell - temp_ref\n", + "\n", + " # n * Ns * Vth at operating temperature.\n", + " nNsVth = a_ref * temp_cell_k / temp_ref_k\n", + "\n", + " # Villalva photocurrent equation.\n", + " photocurrent = (\n", + " I_L_ref + alpha_sc * delta_t\n", + " ) * effective_irradiance / irrad_ref\n", + "\n", + " # Datasheet temperature coefficients.\n", + " i_sc = i_sc_ref + alpha_sc * delta_t\n", + " v_oc = v_oc_ref + beta_voc * delta_t\n", + "\n", + " # Finite-Rsh form corresponding to Villalva's temperature-dependent\n", + " # saturation-current equation.\n", + " photocurrent_for_i0 = (\n", + " (R_sh_ref + R_s) / R_sh_ref * i_sc\n", + " )\n", + "\n", + " saturation_current = (\n", + " photocurrent_for_i0 - v_oc / R_sh_ref\n", + " ) / np.expm1(v_oc / nNsVth)\n", + "\n", + " resistance_series = R_s\n", + " resistance_shunt = R_sh_ref\n", + "\n", + " return (\n", + " photocurrent,\n", + " saturation_current,\n", + " resistance_series,\n", + " resistance_shunt,\n", + " nNsVth,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "2f74811d", + "metadata": {}, + "source": [ + "# Example: JA Solar JAM78D40-625/MB\n", + "\n", + "The manufacturer gives the following STC values for the 625 W variant:\n", + "\n", + "- \\(P_{max}=625\\) W\n", + "- \\(V_{oc}=55.49\\) V\n", + "- \\(I_{sc}=14.36\\) A\n", + "- \\(V_{mp}=46.37\\) V\n", + "- \\(I_{mp}=13.48\\) A\n", + "- \\(\\alpha_{Isc}=+0.046\\%/\\degree C\\)\n", + "- \\(\\beta_{Voc}=-0.260\\%/\\degree C\\)\n", + "\n", + "The module has 156 half-cells, represented here as 78 effective series\n", + "junctions.\n", + "\n", + "Villalva's basic algorithm requires the diode ideality factor to be specified.\n", + "Here `diode_factor = 1.10` is an example user choice." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "83f1cabd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Name JA Solar JAM78D40-625/MB\n", + "P_mp_ref 625.0\n", + "V_oc_ref 55.49\n", + "I_sc_ref 14.36\n", + "V_mp_ref 46.37\n", + "I_mp_ref 13.48\n", + "cells_in_series 78\n", + "alpha_sc_rel 0.00046\n", + "beta_voc_rel -0.0026\n", + "irrad_ref 1000.0\n", + "temp_ref 25.0\n", + "alpha_sc 0.006606\n", + "beta_voc -0.144274\n", + "P_mp_fit 625.0676\n", + "dtype: object" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "module = {\n", + " \"Name\": \"JA Solar JAM78D40-625/MB\",\n", + "\n", + " \"P_mp_ref\": 625.0,\n", + " \"V_oc_ref\": 55.49,\n", + " \"I_sc_ref\": 14.36,\n", + " \"V_mp_ref\": 46.37,\n", + " \"I_mp_ref\": 13.48,\n", + "\n", + " \"cells_in_series\": 78,\n", + "\n", + " \"alpha_sc_rel\": 0.00046,\n", + " \"beta_voc_rel\": -0.00260,\n", + "\n", + " \"irrad_ref\": 1000.0,\n", + " \"temp_ref\": 25.0,\n", + "}\n", + "\n", + "module[\"alpha_sc\"] = (\n", + " module[\"I_sc_ref\"] * module[\"alpha_sc_rel\"]\n", + ")\n", + "\n", + "module[\"beta_voc\"] = (\n", + " module[\"V_oc_ref\"] * module[\"beta_voc_rel\"]\n", + ")\n", + "\n", + "# Villalva uses Vmp * Imp as the experimental MPP target.\n", + "module[\"P_mp_fit\"] = (\n", + " module[\"V_mp_ref\"] * module[\"I_mp_ref\"]\n", + ")\n", + "\n", + "pd.Series(module)" + ] + }, + { + "cell_type": "markdown", + "id": "cccaf062", + "metadata": {}, + "source": [ + "## STC parameter extraction" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e113eec0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'I_L_ref': 14.377696765960255,\n", + " 'I_o_ref': 1.325600648888484e-11,\n", + " 'R_s': 0.2099,\n", + " 'R_sh_ref': 170.32287180435225,\n", + " 'a_ref': 2.004021171444696,\n", + " 'alpha_sc': 0.0066056,\n", + " 'beta_voc': -0.14427399999999999,\n", + " 'i_sc_ref': 14.36,\n", + " 'v_oc_ref': 55.49,\n", + " 'irrad_ref': 1000.0,\n", + " 'temp_ref': 25.0}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diode_factor = 1.0\n", + "\n", + "params, history = fit_villalva(\n", + " v_mp=module[\"V_mp_ref\"],\n", + " i_mp=module[\"I_mp_ref\"],\n", + " v_oc=module[\"V_oc_ref\"],\n", + " i_sc=module[\"I_sc_ref\"],\n", + " alpha_sc=module[\"alpha_sc\"],\n", + " beta_voc=module[\"beta_voc\"],\n", + " cells_in_series=module[\"cells_in_series\"],\n", + " diode_factor=diode_factor,\n", + " temp_ref=module[\"temp_ref\"],\n", + " irrad_ref=module[\"irrad_ref\"],\n", + " rs_step=1e-4,\n", + " rs_max=0.5,\n", + ")\n", + "\n", + "params" + ] + }, + { + "cell_type": "markdown", + "id": "81a04146", + "metadata": {}, + "source": [ + "### Evolution of \\(P_{mp}\\) as \\(R_s\\) is incremented\n", + "\n", + "The fitting is evaluated over the complete interval \\(0 \\le R_s \\le 0.7\\,\\Omega\\).\n", + "\n", + "The final fitted \\(R_s\\) is the valid iteration that minimizes\n", + "\n", + "\\[\n", + "\\left|P_{mp,\\mathrm{model}} - P_{mp,\\mathrm{ref}}\\right|,\n", + "\\qquad\n", + "P_{mp,\\mathrm{ref}} = V_{mp}I_{mp}.\n", + "\\]\n", + "\n", + "The plot therefore shows both the full \\(P_{mp}(R_s)\\) evolution and the\n", + "selected \\(R_s\\)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6ab3ef8d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best R_s = 0.209900 ohm\n", + "Modeled P_mp = 625.067601 W\n", + "Reference P_mp = 625.067600 W\n", + "Absolute error = 8.848201e-07 W\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Best Villalva iteration: closest Pmp to the reference value\n", + "best_idx = history[\"abs_power_error\"].idxmin()\n", + "best = history.loc[best_idx]\n", + "\n", + "print(f\"Best R_s = {best['R_s']:.6f} ohm\")\n", + "print(f\"Modeled P_mp = {best['p_mp_model']:.6f} W\")\n", + "print(f\"Reference P_mp = {best['p_mp_ref']:.6f} W\")\n", + "print(f\"Absolute error = {best['abs_power_error']:.6e} W\")\n", + "\n", + "plt.figure(figsize=(9, 5))\n", + "\n", + "plt.plot(\n", + " history[\"R_s\"],\n", + " history[\"p_mp_model\"],\n", + " label=\"Modeled $P_{mp}$\",\n", + ")\n", + "\n", + "plt.axhline(\n", + " module[\"P_mp_fit\"],\n", + " linestyle=\"--\",\n", + " label=\"Reference $V_{mp}I_{mp}$\",\n", + ")\n", + "\n", + "plt.scatter(\n", + " [best[\"R_s\"]],\n", + " [best[\"p_mp_model\"]],\n", + " zorder=3,\n", + " label=(\n", + " f\"Best $R_s$ = {best['R_s']:.4f} $\\\\Omega$\"\n", + " ),\n", + ")\n", + "\n", + "plt.axvline(\n", + " best[\"R_s\"],\n", + " linestyle=\":\",\n", + ")\n", + "\n", + "plt.xlim(0, 0.26)\n", + "\n", + "plt.xlabel(\"$R_s$ [$\\\\Omega$]\")\n", + "plt.ylabel(\"$P_{mp}$ [W]\")\n", + "plt.title(\"Villalva fitting evolution: $P_{mp}$ vs. $R_s$\")\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2e59f0b7", + "metadata": {}, + "source": [ + "### Final fitted SDM parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9809d929", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ValueUnit
diode_factor1.000000e+00-
a_ref2.004021e+00V
I_L_ref1.437770e+01A
I_o_ref1.325601e-11A
R_s2.099000e-01ohm
R_sh_ref1.703229e+02ohm
\n", + "
" + ], + "text/plain": [ + " Value Unit\n", + "diode_factor 1.000000e+00 -\n", + "a_ref 2.004021e+00 V\n", + "I_L_ref 1.437770e+01 A\n", + "I_o_ref 1.325601e-11 A\n", + "R_s 2.099000e-01 ohm\n", + "R_sh_ref 1.703229e+02 ohm" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "parameter_table = pd.DataFrame(\n", + " {\n", + " \"Value\": [\n", + " diode_factor,\n", + " params[\"a_ref\"],\n", + " params[\"I_L_ref\"],\n", + " params[\"I_o_ref\"],\n", + " params[\"R_s\"],\n", + " params[\"R_sh_ref\"],\n", + " ],\n", + " \"Unit\": [\n", + " \"-\",\n", + " \"V\",\n", + " \"A\",\n", + " \"A\",\n", + " \"ohm\",\n", + " \"ohm\",\n", + " ],\n", + " },\n", + " index=[\n", + " \"diode_factor\",\n", + " \"a_ref\",\n", + " \"I_L_ref\",\n", + " \"I_o_ref\",\n", + " \"R_s\",\n", + " \"R_sh_ref\",\n", + " ],\n", + ")\n", + "\n", + "parameter_table" + ] + }, + { + "cell_type": "markdown", + "id": "d4b0d366", + "metadata": {}, + "source": [ + "## STC I–V curve and datasheet key-point validation" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "82f978e7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DatasheetVillalvaErrorError [%]
i_sc14.360014.360000-4.633804e-11-3.226883e-10
v_oc55.490055.490000-2.202682e-13-3.969512e-13
i_mp13.480013.4801531.528975e-041.134254e-03
v_mp46.370046.369474-5.258821e-04-1.134100e-03
p_mp625.0676625.0676018.848201e-071.415559e-07
\n", + "
" + ], + "text/plain": [ + " Datasheet Villalva Error Error [%]\n", + "i_sc 14.3600 14.360000 -4.633804e-11 -3.226883e-10\n", + "v_oc 55.4900 55.490000 -2.202682e-13 -3.969512e-13\n", + "i_mp 13.4800 13.480153 1.528975e-04 1.134254e-03\n", + "v_mp 46.3700 46.369474 -5.258821e-04 -1.134100e-03\n", + "p_mp 625.0676 625.067601 8.848201e-07 1.415559e-07" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stc_sde = {\n", + " \"photocurrent\": params[\"I_L_ref\"],\n", + " \"saturation_current\": params[\"I_o_ref\"],\n", + " \"resistance_series\": params[\"R_s\"],\n", + " \"resistance_shunt\": params[\"R_sh_ref\"],\n", + " \"nNsVth\": params[\"a_ref\"],\n", + "}\n", + "\n", + "stc = pvsystem.singlediode(\n", + " method=\"lambertw\",\n", + " **stc_sde,\n", + ")\n", + "\n", + "datasheet = pd.Series(\n", + " {\n", + " \"i_sc\": module[\"I_sc_ref\"],\n", + " \"v_oc\": module[\"V_oc_ref\"],\n", + " \"i_mp\": module[\"I_mp_ref\"],\n", + " \"v_mp\": module[\"V_mp_ref\"],\n", + " \"p_mp\": module[\"P_mp_fit\"],\n", + " }\n", + ")\n", + "\n", + "model = pd.Series(\n", + " {\n", + " key: float(np.asarray(stc[key]))\n", + " for key in [\"i_sc\", \"v_oc\", \"i_mp\", \"v_mp\", \"p_mp\"]\n", + " }\n", + ")\n", + "\n", + "validation = pd.DataFrame(\n", + " {\n", + " \"Datasheet\": datasheet,\n", + " \"Villalva\": model,\n", + " }\n", + ")\n", + "\n", + "validation[\"Error\"] = (\n", + " validation[\"Villalva\"]\n", + " - validation[\"Datasheet\"]\n", + ")\n", + "\n", + "validation[\"Error [%]\"] = (\n", + " 100\n", + " * validation[\"Error\"]\n", + " / validation[\"Datasheet\"]\n", + ")\n", + "\n", + "validation" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6e19ba1f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "v_stc = np.linspace(\n", + " 0.0,\n", + " float(stc[\"v_oc\"]),\n", + " 200,\n", + ")\n", + "\n", + "i_stc = pvsystem.i_from_v(\n", + " voltage=v_stc,\n", + " method=\"lambertw\",\n", + " **stc_sde,\n", + ")\n", + "\n", + "plt.figure(figsize=(9, 6))\n", + "\n", + "plt.plot(\n", + " v_stc,\n", + " i_stc,\n", + " label=\"Villalva model\",\n", + ")\n", + "\n", + "plt.scatter(\n", + " [0.0, module[\"V_mp_ref\"], module[\"V_oc_ref\"]],\n", + " [module[\"I_sc_ref\"], module[\"I_mp_ref\"], 0.0],\n", + " label=\"Datasheet key points\",\n", + " zorder=3,\n", + ")\n", + "\n", + "plt.xlabel(\"Module voltage [V]\")\n", + "plt.ylabel(\"Module current [A]\")\n", + "plt.title(module[\"Name\"] + \"\\nSTC I-V curve\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "dca3db30", + "metadata": {}, + "source": [ + "## Additional validation: recover a known SDM parameter set\n", + "\n", + "This test follows the validation proposed for the Villalva fitting algorithm:\n", + "\n", + "1. assume a complete set of single-diode model parameters at STC;\n", + "2. use `pvlib.pvsystem.singlediode` to calculate the corresponding\n", + " \\(I_{sc}\\), \\(V_{oc}\\), \\(I_{mp}\\), \\(V_{mp}\\), and \\(P_{mp}\\);\n", + "3. use those synthetic key points as inputs to `fit_villalva`;\n", + "4. compare the recovered SDM parameters with the original parameters.\n", + "\n", + "The example uses the Canadian Solar CS5P-220M parameter set from the pvlib\n", + "single-diode gallery. Since the basic Villalva algorithm requires the\n", + "dimensionless diode ideality factor \\(a\\), it is calculated from the known\n", + "pvlib parameter\n", + "\n", + "a_ref = a × N_s × (k × T_ref / q)\n", + "\n", + "The purpose of this test is parameter recovery, so the inputs to Villalva are\n", + "the **synthetic key points calculated by `singlediode`**, not the rounded\n", + "datasheet values." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "8adcd797", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Synthetic STC key points\n" + ] + }, + { + "data": { + "text/plain": [ + "i_sc 5.099770\n", + "v_oc 59.400651\n", + "i_mp 4.689806\n", + "v_mp 46.902632\n", + "p_mp 219.964255\n", + "dtype: float64" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Known Villalva diode ideality factor: 1.069253300\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Starting valueRecovered valueAbsolute errorRelative error [%]
I_L_ref5.114000e+005.114000e+00-6.269092e-09-1.225869e-07
I_o_ref8.196000e-108.196000e-101.605503e-191.958886e-08
R_s1.065000e+001.065000e+000.000000e+000.000000e+00
R_sh_ref3.816800e+023.816800e+021.775631e-054.652146e-06
a_ref2.637300e+002.637300e+00-4.440892e-16-1.683878e-14
\n", + "
" + ], + "text/plain": [ + " Starting value Recovered value Absolute error Relative error [%]\n", + "I_L_ref 5.114000e+00 5.114000e+00 -6.269092e-09 -1.225869e-07\n", + "I_o_ref 8.196000e-10 8.196000e-10 1.605503e-19 1.958886e-08\n", + "R_s 1.065000e+00 1.065000e+00 0.000000e+00 0.000000e+00\n", + "R_sh_ref 3.816800e+02 3.816800e+02 1.775631e-05 4.652146e-06\n", + "a_ref 2.637300e+00 2.637300e+00 -4.440892e-16 -1.683878e-14" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAAJOCAYAAADhz3V3AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjIsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvgI3uAAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkuFJREFUeJzt3QV4U/f+x/FPUi8tpbi7y3AYY8KEKXNhLnfblbnejW3/ubvdKdM7d2UCTJigG27D3aEtUG/yf76/kt62tNCWtknT9+t5QpKTk5NfTg7p+eRnHr/f7xcAAAAAIGx4g10AAAAAAEDlIugBAAAAQJgh6AEAAABAmCHoAQAAAECYIegBAAAAQJgh6AEAAABAmCHoAQAAAECYIegBAAAAQJgh6AEAAABAmCHoAag1brjhBsXGxlZo2b68BoCqZf/n7P/e3paVpmPHjjrttNOqpVwAUF0IegBqpIcfflgej0fffPNNqetMmDDBrXPPPfdUa9kQHFdccYUSEhLY/ahW9h1z8803s9cBhByCHoAa6cILL1RUVJReeeWVUtcZPXq0IiIidNFFF7n7jz76qDIzM6uxlACCxf6v2//52l4GALUXQQ9AjdS4cWMdf/zx+uKLL7Rp06bdHk9NTdVHH32kY445Ri1btgxKGQEAAIKFoAegxrr00kuVk5OjN998c7fH3nnnHWVkZOiSSy6plP5z9qu8NdEKXJKSkjRs2DB99913e3zeQw895NafP3/+bo8999xz7rHp06fv02sYe58NGzbUli1bNHLkSNWtW1f169fX3/72N23btq1C7yWwTXv++eef77bXq1evCm/jzDPPdOs1b95cTz31lHt88+bNOuuss1SvXj01aNBAo0aNkt/v3+39zZ49W6eeeqrbVkxMjLp166Znn3224PERI0boP//5j3bu3FmkXKtXry7zNvb2nkti/bqsf9eGDRt0xhlnuPdx4IEHusfsfTz//PPq27ev4uLi3Hu3cs6ZM6fINmy9F154QQMHDlSdOnXUpEkT9xkuWrSoSM3Qbbfdpg4dOriyN23a1NVqr1271j3u8/nUtm1bHXHEESWWs0ePHho6dGiR19xb2ew1bR/eeeed7nPt37+/e207bq0c9nmXpGvXrjrggANKfKy85bR1A59lZGSkWrVqpX/84x/uOK9I/7jt27frX//6lxo1aqTExESdeOKJWrduXYnP39trL1++3D1W+P+5XU466aQ9lmFvn2Xxff/DDz+oX79+bludO3d2320AUCZ+AKih8vLy/G3atPF369Ztt8f69evnb9asmT8nJ6dg2fXXX++PiYkpsl5ZlxV/3eXLl/uvuOIKf3R0tH/GjBmlPnf9+vX+yMhI/w033LDbdvr37+/v06dPuV+jJBdffLG/fv36/tNOO83/zTff+FNTU/3jxo3zN2/e3D948OAi+6GsrxPY5umnn+7/+uuv/Vu3bvW/+uqrFdrGOeec4x8/frwr10svvWRJzv/RRx/5TzzxRP/YsWPdctu2LX/99deLbP/333/3x8XF+U8++WT//Pnz/Wlpaf7333/fn5iY6L/11lsL1rv88sv9derUKfF9lnUbZX3PAaeeeqo7Bk844QS3v7ds2eJ/44033GOXXHKJK4+9382bN/tXrlzpP++889xrLly4sGAbF154oSvbk08+6V+9erV/06ZN/g8//NB/1VVXucd9Pp//qKOO8iclJbnltq8mTZrk79q1q79169ZufXPnnXf6PR6Pf+nSpUXKOHHiRLdfX3nllYJlZSlbRkaGe97xxx/vHzlypH/RokX+xYsX+7/77jv/I4884h6bO3dukdeyfWDLR48eXeo+K085C9u5c6f/p59+8nfp0sV/xBFHuP0SYP/n7P9eYcWX2XE6bNgwf6NGjdxna/vxhx9+8I8YMcJ9hvZZlmZPr21lvummm0p8XvEylPWzDOz7k046yX0uS5YscY9deumlbt8V3+8AUBKCHoAazU4a7YTITuQDpk+f7pbdcsstRdatrKBXWMuWLf3XXHPNHp9rJ2uNGzcuErZmzpzpyvjss8+W+zVKYgHFtvfuu+8WWf7ZZ5+55e+88065Xyewzbfffnuvz93bNqwcxYO4BQ0Le4UNHDjQf9BBBxVZ1rdvX3cinJ2dXWT5gw8+6ILlhg0b9hr0yrqN8r5nCwe2vgWHwn777Te3/Iknniiy3F6/ffv2LvgaCw+23sMPP1zqa4wZM8at89xzzxVZPmvWLHfSHwgZFta8Xq////7v/4qsZ6EuISHBv3379nKVLRA2mjZt6s/MzCyyrgXa2NhYF+6L74/Cr1WSspazNIFj2kJneYKefUb2vP/+979F1vvqq6/c8j0FvT29dnmCXlk/y8C+twBa+Ji1fRMfH++/9tpr91pWAKDpJoAazZomer1eN/BKgN22Zk8XX3xxpb3Ojh07XLNCa5ZmTagKNw1cvHjxHp9r5di4caO++uqrgmU2iIxt5+yzz66U1wg44YQTity35njW7Myaf1X0dYpvs7zbsOVHH310kWX2PGtmaX0oC7PmlEuXLi24v2bNGte01ZrD2eA7hVnzv+zsbE2cOHGP+6Qi2yj8ngPHU+GLNTkNsG0Wf39ffvmluz799NOLLLd1Dz74YP3888/u/pgxY9x14eOguPHjx7vrU045pchya1JqTfkCj1vTwuHDh+v11193TSSN7eP333/fNQUNjEha1rIFHHXUUa6JYWHWpNWa4lqzaXsNY00PP//8c9eEdU+jn5a1nGbKlCnus7A+uTawUuGmkWX9P1F8PxY/no899lhFR0fvtn5lvnZ5P8uAI488ssgxa/umTZs2Rf6PAEBpCHoAajQ7abST7A8++MCFD+vb8vbbb+uwww5T+/btK+117KT2pZdectM62AltXl6e6+dkgcX6Ce6JhRnrlxYYIdSChZXRTvaSk5Mr5TUCJ4Hx8fFFltkJqvV9KxxMyvM61tevpJP28mzD3mPxoGD9o2zbxctry1NSUgrur1+/3l3b61hgtfdjFwv3AwYMcI/trb9WebdR2nsuTbNmzdy2SnpNOykPvKatYxcLOIHXsx8ALEDYNkpj69rzLHAUZ/27Cn+21sdw1apVGjt2rLv/4Ycfun5phX/0KGvZAlq0aFFiuS6//HKlpaW5Y9m8/PLLys3NLdMPLGUp54IFC3TIIYe4Mv7444/u/7cdY+PGjXOPl+X/RGH2vuxHCft8C7P9b332Cqvs167IZ2lKOi6s/IX/jwBAaQh6AGo8O2m0EzGrEbCRNu0kyAZqqSx2cvb111/r6quvdr/wW22GnaxZbcSKFSv2+nw7kbbBFmzOPxv44bPPPnPbLHxSu6+vYWwfpKenF1lmAcy2bWGvIq9TvAasItsIDFhR1uWF2cAo5u6773Yhwt6PXey1dnU/cLW6lbmN4u/Zjq/AeoFLYJul7SN7PFDzF3hNe73AawY+JwsYdr+0AUGM7V97Xkmjy9ogMIXLYp+HbfPVV1919+3aakmHDBlS7rLt6f0ZC8k2gIwNzmLbsaC3p4FYCitLOe3HG/vhxrZrg7TYoDFm2bJlqgj7P2Dbs3BamL3n4vu2sl+7Ip9lWf+PAEBpCHoAajybZsF+DbcmdnaxE7rCI9/tq8DJVvFaKQuVNrJnWViosxO8N954w9XstWvXToceemilvkbhZnkBFsjsJPzwww+vtNeprLKWhdU6WbO2Tz75xL2PPbERK622dF+2UZnHpAUICwx7Yk1rzZ5GUgx8dp9++mmR5XPnztXChQsLHjfWBPG8885zPyZYc9Rffvlltxq2spatLC677DLNnDlTN910k2siW9bm0mUpZ+BYK36clTTKbllYLX9J/0fsB5iSjpuyvrbVSmdlZZWpDOX5LAFgXxH0ANR41rzKaswmTZrk+hfZsPjFT9D29Vd4G/Ldhu+fOnWqa2JmfZFsaH6rhSgLa0Zqw9Hbc6z5l9UgFf61vjJew7bx8ccf6/vvv3fPtyZn1rzOal5sGoDKfJ193UZ5vPjii64pnfUps752VuNkzf7sZNnCcqCPWM+ePV2TOjtxt1qqimyjslhfN6tVvv766/XMM8+4vov2GjbFw3333eeCUWA9O3bvuOMOPf30064ZrNWYWmi2GtNA01/rS3jzzTe7sGo1UrbfrT+bNQm21yjMApMFF3vcauMsUFWkbGVhTXjth5XHH3/cvZb93yurvZXzuOOOczXF1157rdsnK1eudMezTT9REbYf7b3b+/7222/dcfvTTz+5qS3sx4CKvrYdd7/++muJtXQllaE8nyUA7AuCHoCwYM3rAsGp8Nx5lcWahQ4aNMgNTGETsNsv+7aspEEc9lRGq/UwdnJf2a9h79+a0VnfOetXZX0ArYbA5kAr3PyuMt5LZWyjrKw53x9//OH6zVkNmM1Vd9BBB7laMJtnzGryjM3Hd9FFF7nAYO+38Dx6Zd1GZbLPwYLUu+++6wKw1Tpb2SyMFj6ht2aLjzzyiF577TU3t5o1FbSgd8UVV7jH7X188cUXbv43m5PNmvdZELG51ezHjeL9y7p37+7erwVZq70rqT9YWcu2N9bnLdDs1fZrSa9Vmr2V0+bte++999x7tGPMAnmnTp0KAnB5WXCz2jybO++cc85x/d8ee+wxF/Tsx6KKvnZgLsbWrVvvNo9eceX9LAFgX3hs4NF92gIAIOgsRFozuOKDOQBV7d5779X//d//uVFlLbQAAEIDNXoAAKDCrCbXar2KTzEBAAiuom0VAAAAysAGF7KpFebMmeOaL9rosgCA0EHQAwAA5WKDj1gfR+vreOWVV7o+ZwCA0EIfPQAAAAAIM/TRAwAAAIAwQ9ADAAAAgDATGQ6dwW2C2cTExCKTDwMAAABAOLGZ8bZv367mzZu7+UHDOuhZyGvVqlWwiwEAAAAA1WLVqlVuapuwDnpWk2eWLVum+vXrB7s4CAE5OTn6/vvvdeSRRyoqKirYxUEI4JgAxwX4rgB/PxAO5xRpaWmukiuQgcI66AWaa9qbrVu3brCLgxD5DxgfH++OB4IeOCbAdwX4+wHOKRBu55ll6bLGYCwAAAAAEGYIegAAAAAQZgh6AAAAABBmCHoAAAAAEGYIegAAAAAQZgh6AAAAABBmCHoAAAAAEGYIegAAAAAQZgh6AAAAABBmCHoAAAAAEGYIegAAAAAQZgh6AAAAABBmCHoAAAAAEGYIegAAAAAQZgh6AAAAABBmCHoAAAAAEGbCIujFdztY01amKs/nD3ZRAAAAACDowiLoNTrh3/rH+/N14EM/6Ns564JdHAAAAAAIqrAIegHrUzP1r7f+JOwBAAAAqNXCKugFGm7e9eU8mnECAAAAqLUiFWYs7K1LzdTrT92m7nXS9FejY5Rat5MiIzxqkLlSbbb+Lk9E1K5LZMFtb2SUdtTfT3l1WyjS61VMbqoSty+VNzJaEZGRu66jFBEZo4ioKHnrJCsyJtFtN8ojRXp8ioyMkscbVtkZAAAAQA0UdkEvoOHWPzQkdaJeX15f3+0apOUE7+8aGf1sqc+5Nvtf+tR3kLt9uPcPvRL9WKnr3pZzkd7KG+5uD/HO1bvR97nbuX6vchWhXEUq1xOhPEVodMSZ+jL6aEVFeNXJv1w3Zz6hPEXK54lUnidSPm+k/J4Id39y4nDNTDo8P5jmbdbRm1+T3xsl2TreqF23I6SIKG2o11cbGgxWZIRXcb6d6rDhW3kjotxjnsgoeb35QdZCak7d1spJzg+8kcpVYupfLrh6LbhGRLrwGhkVkx9mY+ooMjYhP8R6vfJ6PZX86QAAAACoSmEb9DbXH6BJMa3Vq34/1Y9urTyfT622d9EfWw+Tx5crjz9XXrv4dl37c5WY1EI9I+sqN8+vBll1tTqzqSL9efK6WGbRLU+R/vxr+zcgSrkFt13NnnyScgqWZWama/XODHe7gWeL2scsL7Xc36W10dcru7vbPTzLdXvM16Wu++zSE/VobpK73c6zTj/G3FPquq/mHq27c893t5toqybHXlHquu/mHqpRuZe624lK14yYS3e9e69yPZEFQdZC7K+Rg/VC3KUuxEZ7fXok7d/y7Qqt7uLNv/Z7IrUivrt+aXhWftiM8Or4tU/J4/Hmh1gLqAUhNlo741tqdbMj3XqRXo/arv9WkR6/PBHRu8JrpAu1VhOruPrKathDUbZdr1fRKYuVmbpe61YsVExsnCIioxUVFa2IqGgXZiOjYxXh9cjjIcACAAAgPIVd0LNT96ZJsbrw6nvcyfz+RR7tLSk/7JTk7iL3DpZ0TanrPijpfp9fOT6fcnMOV2rGpcrLzVZebo5yc7KUl5Pj7vvycnRGTCOdEJ2sXJ9fvvSumr25vXy5OfLlZsufl+PW8eflSnk56pHYTXfV6aycPJ9iMhpo0trL5ffluMfky5HHlyeP3fflKqHOYJ2S0ML1R0zIjNT0jUNdYLUQG+HCbJ4idoXY3NgW6hSd4MpQL3enNmbWl9U3utjm9/0vyHp8LsgFuMc9fkUUBNesIvvBm5WiJTt2utsxylaX2IWl7rMNaRn6ZJXt13z3xnwkr6fkKTF+zttPd05rWXB/Tsz/KcGTWeK6U3xddEb2HQX3p8b8SyM9qdLS3ded42urEdn3u9sWDL+O/LeaaovydtW+ur3gbkdqbUQz3Z14Z36AjPDq8rQn1Ni3UT5PVEGAtWt5IrQzqr6+bXGlC5p23A3Z/JHq5m6Wx2phXYi12tVIF2b9UfFa3uY0t55tu8mWaYrLTckPsVajuivA5l9ilN2kjwvSFpBjMjYrSjkuvFotrIXXqMhoRUZHKzIymqbDAAAACL+gF6ifueP47u4kuqpZk8YYb4RiIiOkuNgyPqu+pA5lXLe9VCyqFjZ4tyVHlbpuJ0l/L7LkjBLX8/vydGaeT6f5vfkhNjdPm9MOcKE1NzdXeblZLszm5eSH2C5RdfVenTauFjQ3N1szVj/vgqkF2UCI1a4gGxHTTLfU76qcPL/y8nyasvxvbl2PC7G5BTWtdr0tqq2OS26mPNuuz6e/1vdVtC9DXqthdeE1P8TaJSWymVonxCs3z6ccn1/pOfHa7s/eVeeYp2hPXsH7yy00/pCVo05kuup60ovthPyrzGxp3rq0gsWtoueqk3dNiftttb+h3l1zUsH9k6M/U29vCUlT0lZ/gs76o0vB/feiH1Rf7/wS1830R6lr1hsF91+NeliHRcxQaTpmv60Ib4QLhvd4ntfB+jN/L+wKr9ZU2O5breut9R+RPyLeBcjjdn6snlkzXM2rzzURzg+ystrYiEiNb3mF8qISFBHhUZfU39R85wLXRNgCrAr3d/VGaV2rY+SPTnBlSNqxRIkZa/Ifc31co1xNrAVVa1Lsr99eEdH5ZYjOS1dEXmZ+rWtkpAuvUZExrvYWAAAA5RNWZ1BWk2ch7+iezYJdlBrLYyHBLpLiXM1elJTQpuwb6HZ2OV7t8VIfGSjpf7HJfFvqum0lHVnofk7ObI0ZM0bHHnusoqKi5Pf5lJeXq9ycbHXMy9OMiDgX8ixA+lO+1arsTBdMc3fVslqo9efmKMcTpTfq984PkHl+bVt7h6ZlpbgAG7i4EOvLVZYnVtc36eyCpjUT3rTmBE3KXFdQ+2pNhLWrqXCmJ1bDGzZx27Ua1pStnTQ/27Or9tUCrGsk6+5bGZrUjXFB2mp55Y9Utj8yvyFtsdrQPL9HuT67+JSV61N81HY1iEjNfzCwaqGnzFiVpizl15KeFjVPvSOmlLqP/77mWKUo0d2+L3KM9o8cX+q6Q6fW0xo1crdvjXxLl0aOKXXdI7Ie1mJ/fs3ttZEf6urIT3dbx2fvSxE623+P/vJ2cAHyDP93usD3mfI83l3hdVd/113Nhl+rd7nWxnZyP/j0zZyig7Z/owZZuZqx5L+7+rpG7ur3GqlZTU5WSp32rta2WfoitUuZ6IKr1cTmh9fI/D6vEVHa1migchNauJrYuOwtSkpbJI8LrYEQa82D82tjPYnNFBGX6Gp5rXl3hC/LNSGOtGbEFowZuAkAAIRr0Lvhhhv0+uuvF1nWrVs3/fLLL+XazqYvHtYnb7+mI3q3q5aaPNQsdkId6c0/wd5NUueyb6jnyD0+fEiRe3ftcd2he6mbLWxyKbW2vrw85eRkuQCbu6uWdXJsAxcILRgqtaOWZaYUqYF1TYbzsuXLzdUzjQcr14VDv5I2Xqqp248sVAMbaC6c52pdL2zaTZkeC5w+xW4+SJO3J7oQa7WvrrnwrhpZu927RUu1UYIrQ8SOFlqU0dE1inUB1r+rgazVxipPsbFxSvBFujJHldKM1wJttHKVnu1Xmj+/P2xERIqaRm3KD64lPG3x6o36w5/sbneImK9+Ub/mP/C/CtoC/1ndXr/sGrDpzIgfdFbU6FI/i39kX6PvfIPc7RO8v+np6P+UaXCn4d5pejm66A8bOX63V9zlEe9F+ibycEV5Peqthbol+5n8ALsruLrBm1wta4R+TDxBMxMPdt91zfPW6Litb7rA6i5WA+v9X03ryuQhWpc80NWYJualqPPGb1x4tSbEgfBqodauM5I6Kat+JzcAU5Q/S0kpc12tq6uBtXC6K8y6ZsNxSYqIr5ff39ZGHVaeC7GEVwAAQkdQg96OHTt0wAEH6NVXX/1fgSrQTCt9/gQNaJ1EyEOt4o2IUExEvGJi40teoeH/mofuXdH60+KGFLmXP1hQaZ7bwzOL+6rIvWNc02ELrbk5OcrJyXYB1fV9zcnWC7GNlGODAVmI3dFJf6Wd64KrBdn8psIWYK2GNUeXJg/QuVFJbt2ElGhN3NRS69euVpNGDVwYlfWJ9eW6dYc06KeO0S3duq3S9tPUrcfkh1h/XpEga9eNG7RW/8hkF3jrZzTQsow2u0JsfpAt6PeqPPkiYhXl8bja4Ag3QFNRUZ48RSm/WXFmdo42ZeT3f+3kTVGr6LUlBljz0Y79NG51V3d7oGex7ogZV+r+nbAiS8/l5Q/Y1MOzTF/HPFrqus/knqTHcs8oNLjT9eUe3MlGHc6P8hFu1GHr8/qN91C9EHOBG1SprjdTT+68uUjtqwuyu0Lqwri++qnBGfmDKnnzdMb6x/NrXl0T4kBNbH4t67aEDlrR9Ei3Xavl7bL2Y3k9EQXNhPNDbP7ATXnxTZTZqFd+X1evRwnbFigiwiu/vMpK3aANK/9SdGy8C7KR1pQ4vm5+iN3V5xYAgJoo6E03o6Oj1bBhw2AXA0CoNB2Otkus4va4pjUjLWttbCvl5AxzzXkH7mrOW3oU7SnpglK31KvIvQMllR6Gntp18futT+pRysz5t6t9tWCaUxBg8wdt+kd0fV0YmZjfnDijh+Zt6eeaEfvycncN2pRbEGb3r9tdXePauJrY6J0NNGn9dQWDOVl4dYM27aqNbVx3iM6u09oF06QMadrGw+X1/68m1lto0CZPQhv1jMkfdbhRTppWpzfLD7CFwquNQmy1dzmucff/AmvxUYdjCo067M/eodXp+aMO11ea2seWPurw4h3RGrN2vbsdqyw9Glv6qMNj8gbpwemtA6+i5bFFh9Mq7Ke83row56aC+3NjLlIdT36wdj2mC3WnnezrqpHZtxfcnxRzuepre0F4LbQ3tDiine6Iv9UFQguGt+64X8n+FDddTn6Y3dXn1ROp1Ogm+qrZlYqOzA+mB216Vwl5aVJk9K5+rnZtAzJFKy8mSRtaH+fWs0vDbTMV7cvMr1m1aXDc6MGB6zhF1Gup6Mj8daM8PkVF0jQYABACQe/HH39U69atlZSUpIMOOkh33XWXGjXK798DADWdTePhBpex1gpxdcrwjHpSJ+t5WhZt9jhg0+6jDh9X6rrdJBWddOWsUtf9h6RLd406nJeXp9T0Ecqz0YZdbWx+M2GrlfXlZmlgZJI+jWviRgfOzc7U7PWv72pC/L8Bm6xPrAXVurEtdXdyD1cL6svJ1KQVu0YdtgCbZzWrFlLz72fGdtKpSS1dOM7LzdOfaw8smCrnf1Pn5NcvpsS0VqeY/FGHrZnwtoxkZSgzf7RhF2YtoOa50Jrr/9+ow8ZCa7Qn1zUfLm59Tl0t2bTzf59GzEK18GwpcZ8t3N5SH687ueD++dGfqKN3bYnrrvI10tkT/zfq8BfRt6qXd1mJ627xJ6p/1osF99+Lvkf7e+cr229jJUfl14K7dxqldE+c/pH4bP50OJFeXZj+ujrm/qU8G0k4IkZ53hh37YuMkSJi9Uu7qxUTFamYSK/ap05SUs5GeaNi8y/RcS5kuqAZEyd/k16KjY5WTJRXMb6M/OfFxruWBwCAWhj0mjVrpkcffVSHHHKI1qxZo3//+98aOnSoZsyYofj4kpujZWVluUtAWlp+p5sc19Trf78io/YKHAccD+CYqFreXaMPRyXkNw/du0Sp3Yiyv8CBpfd17Sfp+CJLPit13ba7Rdw5Bd8RY8eO1fDhw6WoKGX7fOqbl6dZfq8LkBYMs7b/qjWuH6xNm5PrwqmNMGxh1euJ1lt1O+WHWJ9fa9c+pHXZO1xNbMFgTbsuGREJ+nejTsrJ9Ss7z6eVq0/SpuwtrvbV68ty1xZivb4cpXnr6sB6DZSdawNB+bQttZWW5vp2zeNq4dRFOHd/p+JkU4L6/UXndbXRhqN3NQ0OSPPFa9HGHQX360fNV8+I2SXuM+tDeuaK/+3hF6Ne1aCIaaXu4y6ZrytL+f2gH496TqdE5PeLtcBpy7M8MW4gqmxPrG5PflC+2HqKj4rQIRnj1Dl7rnyR8W7qGU9UnBQdL290HXlj6mhbqyMUE5eguOgIJeZuVYI3V/F1kxWfkFRyv+t9xN8PcEwg1L8nyvO6Hr+1KwoRGzduVKtWrfT888/rb3/7W4nr3Hnnna7Wr7h33nmn1HAIAEC4sr/i1gvUBuZVboZrvms1oDYisGvW69912+fX6piObr1cv9QyY77q5G7bNZiShcxsRfjt2p7j0wexpyvH1vVJJ2R9oc55iwqFzBxF59cZKtqfoyPynlKOz+PWfzbqKR23h1F8u2W+qgzlT0n0aNQLOi1iQqnrDsx8TpusltumTop8QxdFflfw2E5/jHYqXjs9ccpQnO6Pvko7ohooLkIa4Julzr7Fyo2IV15EnHyRcfK5IBkvT0yivLH1FGVTIwFADZOenq6zzz5bqampqlu3bmg33SyscePGrhnnggULSl1n1KhRuu6664rU6Fk4PPTQQ9WgQYNqKilCWeFf6Yv3x0LtxDEBjouSHLPHA6PozKxH73HdwrN75uYcqpTMDGVnpSsnK0PZGTuVnblTORk7lJO1U48mD1RGjs15mqeEdSfr99Ru8mSnu5DqzU1XRG6GIvPSFZmXqXYNGqleTrQysvMUkxWpDF+04jzZ7nWsn2UdWQufbe7+X2mR2rhrrtQjI2fq+EKhsLjhWQ9rVWRrJcdHu9F2D8v7XVlR9ZQTk6TNGVL9Fh0VXbexohMbKbL1ADWsX1/J8VGuKTZqF/5+INSOiUBrxrKIDLWEunbt2j320YuJiXGX4mxHc1IPjgnsCd8T4Lionv9ncfGl90ftW+Re+z1u64Mi9w53/2ZnZWpn2jalb9+qjO3blLUjRdk7U3Rz8gFKy/ZoR1auktccqMnbYhSZs11ROTsUnbdDsXk7VMe3Q0n+NG3zJyozx6d1qZmqG7lIvSL/lMuMgZati4qGwkX+lm7+zH/E/ajj9bPSYxopO66xfAlNFJHUXLH1miuhUSs1aNNDSYkJ5d9pCHn8/UCoHBPlec2gBT3rZ3fFFVe4Grr27dtr06ZNuvzyy92ABWedVfogAAAAoPaKjolVdKNmSm7UbA8BslOpz/f7fPoxK1cpGbnaujNb2WvqaOqGYcrbsVm+nVuUvnmlkqNyFJuTovjcNPniGkjpcoMENcpcpi6RC6XchZKNw7O56LaPznpQa6Lbq0VynI6P/lP9/XOkeq0V07CNEpt2UOM23VS3Hq2PAFSPoAU9q5U78MADNWLECK1YscIts/s2WXrLlv8bbQwAAKCyeLxeJcZFu0ur+vFSq2GShhU0ybKpWA4pNBXLeKtFzPVp844spaxqoj/XnqiclDXypa1XxM4Nis3cpITsTUr2bdEaf0Ntz8rVgvXbdU7kL9o/cpy0qWgN4WbV08aolvqi/R1Kbt5B7RslqENinlo2ru9CLABUlqA23bzgggvcJTMzU7GxfLkBAIDQY9NRNK8Xp+b1Bki9BpS63uTsXK1NydCqbRny/bVNE9c2V/SOVUrIWKuGuevVQKlqqBQ1zEnRyJmp2j4zf0yCuyJf0zkR47UiooU21+mo7IbdFd9qPzXpNEBNWrR34RQAyisk+ugR8gAAQE0XHx2pjo0T3UVdzpVkl/9JS9miDcvmKmXtX7ooureWbd6pZZt3qM3mLYr0+NTGt0pttq+Stv8o2dSJE6RU1dE1Td5QmxbN1btVkvo1iVTrpo0JfwBqRtADAAAId9Y/r27fg6W+B2tgoeV+33htXLdC6//6Q+mrZipy8zw12LFILfNWK1sR+nFFtrRiuVv35ajHVDdikVbEdVdGk75K7DBEbfY7SIlJ9YP2vgCEJoIeAABAEFnTzMYt2rmLdFrB8qzMdG1bvkiP7WyguWvTNGPVNvXYsFzJSlNyxiRpuV2el2+cR8si2mhdg8FKO/gu7d+hgerFV/6E8gBqFoIeAABACIqJjVfnrr3VWdKp/fOXZWXO0cI5k7Ttr98Vte4PNd8+W808m9TOt1ybNsTon2//KZvur0fzurq6zlg17dBHnQcf7bYFoHYh6AEAANQQFti6DDhMsssum9eu0MpZP+qvjdnquDlBizfu0Mo1a3V4zNPyrvQr/YcYTa/TXznth6vdAaeoUfO2QX0PAKoHQQ8AAKAGa9i8jRo2v1D9dg3/sjEtU9PnztO0yceoXcpENfJsU9/036U5drlLiyM6aEmXS9T18AvUpkHpk9sDqNkIegAAAGGkcd1YHTWknzTkXTdB/OLZv2vTn1+q/pof1SnnL3XMW6LRM5foH3/+pF4tknRy13gd1SFOLdp3C3bRAVQigh4AAEAYD/TSsfeB7mK2bFitJb98oJQtPRWxIlez16Sq//r31eK3NzU/qod2dBupbkecr4S6ycEuOoB9RNADAACoJRo0aakGp12nQRb6dmTpu7kbVO+Xj5S33aNuOXOlWbcrfeZ9mlrvUMUPvkDd9z+aOfuAGsob7AIAAACg+jVIiNHZg1vr2Bte09Z/zNDEdldolae54j1ZGpj6rXp8f5aW39tbb//2l3Zm5fIRATUMQQ8AAKCWs5E4h1xwn1r+31wtOPYjTUkeoZ3+WC3MaaJbv1yk/R8Yr3u/mqfVq1YGu6gAyoimmwAAACjo09d10HBp0HDtSNuqtKkL1W56lpZt3qnvf5ukm6beoOkJQ5Qw/GZ16nMQew0IYQQ9AAAA7Cahbn2dcfgQnXaoXz8v2qTl3z6jqG156rvzV+mzEZr53SDFHH6zug44nL0HhCCabgIAAKD0k0WvR4d2aayLrr5HK878UVOTjlSe36PeGVPU9atTNPuBYZo36Vv2IBBiCHoAAAAokzZd+2ngtR9q3Xm/akq9Y5Xjj1CvrOlq/c0FuuKVH7Row3b2JBAiaLoJAACAcmnZsadaXvOu1i5fqFVf3qefN8Trq0UZGvPkBI0c2FrXHdhQjRo3Y68CQUSNHgAAACqkedsuGnzlmzr9msd0dI+m8vmlldO+Vp3/9NbEV/+t9B2p7FkgSAh6AAAA2CftGtbRC+f114f/HKKL6v7h5uIbsvJFpT7aXzN/+IC9CwQBQQ8AAACVYmDb+jr83+/rj0GPa70aqZk2qfeES/Xnoydo89oVBevl+fyauGSLPp+xxl3bfQCViz56AAAAqNS5+Pofe7HSDz5Nk94apQHr3lW/HT9r+4uD9et+tymt06m65+t5WpeaWfCcZkmxuuP47jq6J/36gMpCjR4AAAAqXXxCkvb/53NacerX+iuysxI9GXp8WrYue+fPIiHPrE/N1L/e+lPfzlnHJwFUEoIeAAAAqkyH/Q5Qh5snavx+j2u6v0uJ6wQabt715TyacQKVhKAHAACAKhURGan43icVBLqS2GNW0zdl2VY+DaASEPQAAABQ5TZuz6zU9QDsGUEPAAAAVa5xYmylrgdgzwh6AAAAqHKD2tV3o2t6SnncI58aerarS1IenwZQCQh6AAAAqHIRXo+bQsF4Suyh59G9kaP14wvXaMH6ND4RYB8R9AAAAFAtbJ6858/tp6ZJRZtnNkuK0+0H1lFSVJ5u33GKTv7P7/pi5lo+FWAfMGE6AAAAqjXsDe/e1I2uaQOvWJ88a9ZpNX7bDh2qfu9N1y+LNuuqd/9U3rwvddLIS90k7ADKh6AHAACAamWhbkiHBrstT64TrdcvGqRHv18ozy+P6+SF72vqU+PU+7L/KjqGQVqA8uDnEQAAAIRUCLzp6K46tH8P5fq9Gpj6vRY+frS2pzK/HlAeBD0AAACEnIGnXK25w15Suj9GvbKma+PTh2nT2uXBLhZQYxD0AAAAEJJ6H3q61pz0kbYoSR3ylinvpcO1Yv4fwS4WUCMQ9AAAABCyOvU9WJnnf6dVnuZqqs1KfP8kzV++KtjFAkIeQQ8AAAAhrUX7bkq47ActjOysB3NG6qw352vOmtRgFwsIaQQ9AAAAhLzkRs3U9NoJ+qv5yUpJz9HZL0/S7FUpwS4WELIIegAAAKgRkurE6b8XD1K/1vUUlblF2a8cpYV//hzsYgEhiaAHAACAGiMxNkpvXjxYDyV/rv5aoOafj9SCaeODXSwg5BD0AAAAUKMkxERq/3+9oHlRPZXoyVDLL8/R4pm/BrtYQEgh6AEAAKDGSaibrLZXj9G86F5K8GQo+dOztXrxnGAXCwgZBD0AAADUSPEJSWp5+RdaEtFeDZQq79unaPPaFcEuFhASCHoAAACoseom1VfSpZ9rjaeJmvs3aNmrFyktMyfYxQKCjqAHAACAGq1h09bSeZ/qD/XQNTvO16VvTFNmTl6wiwUEFUEPAAAANV6L9j0Uc+k3So1ppsnLtuqqd6crN88X7GIBQUPQAwAAQFjo2SJJL53fX9ERXuUtGKOJL10d7CIBQUPQAwAAQNg4oENDvXhcPb0U9bgO2vCmpnz8RLCLBAQFQQ8AAABh5dADhmhKm0vd7T6z7tH8yd8Fu0hAtSPoAQAAIOwMvuAh/ZFwiKI9eWryzSVat2JhsIsEVCuCHgAAAMKON8Krbv/8rxZHdFB9pSnjjTO0c3tKsIsFVBuCHgAAAMJ2QvWEC97XFiWpvW+5Fr5wrnx5TLuA2oGgBwAAgLDVtHUnbTr2FWX7IzUrNU7P/EATTtQOkcEuAAAAAFCVug4arm/SP9Od36bJ88My9W/bWAd2ashOR1ijRg8AAABh75hhB+msQa3k90vXvfeHNm3eGOwiAVWKoAcAAIBa4Y7je2hI41w9kX2XNrx8uvJyc4NdJKDKEPQAAABQK8RGRejB49qor3exembN0JQ3bwl2kYAqQ9ADAABArdGmSx/N7Xenuz14xUua89uXwS4SUCUIegAAAKhVBp54mabUO1Zej19Nx16hzetXBbtIQKUj6AEAAKDW6XXpS1ruba2GStG6185nfj2EHYIeAAAAap24OonynP660v0x6pX1p6Z88FCwiwRUKoIeAAAAaqU23fprdvfr9ZevhR6Zl6Slm3YEu0hApSHoAQAAoNYaeNoNeqDVi/ojp62u/3Cm8nz+YBcJqBQEPQAAANRa3ogI3Xv6ACXGRGr6yhS9Pn56sIsEVAqCHgAAAGq1FvXidPuIrros4nON/PUYLZs7OdhFAvYZQQ8AAAC13mn9W2l40ioleDLl++Sfys7KrPX7BDUbQQ8AAAC1nsfrVavzX9Q2JapD3lL98d9RtX6foGYj6AEAAACSGjZtraWD7nH7YuCq17Vk5i/sF9RYBD0AAABgl/7HXqQ/Eg9VpMenyG9ukM+Xx75BjUTQAwAAAAppc84zSlMddcxbIi0dx75BjUTQAwAAAApp2LSV5ve4Xpn+KM3f5tG6VAZmQc1D0AMAAACKGXjKNbq64Ut6KfdY3fP1AvYPahyCHgAAAFD8JDkiQledPExej19j52/U93PXs49QoxD0AAAAgBJ0bpKow5r51c/zlxI+Pks7t6ewn1BjEPQAAACAUhzdIkdPx76gA3x/avZbN7OfUGMQ9AAAAIBSREVGaNOBu+bWW/+eFs/8jX2FGoGgBwAAAOxBz4NPdnPrRXj8yv3yevl9PvYXQh5BDwAAANiL1mc9qXR/jLrmztcfY0azvxDyCHoAAADAXjRq3lYz2/3N3W417UFl7NzOPkNII+gBAAAAZdD3jNu0To3URFv0+yf/YZ8hpBH0AAAAgDKIjU/Q6iF36+rsy3TFX720NiWD/YaQRdADAAAAymjAkWdpXesTlJEjPfztAvYbQhZBDwAAACgjj8ej24/vLo9HGjtjiebMmcm+Q0gi6AEAAADl0LNFkm7sulU/xlyv6M8ukS8vj/2HkEPQAwAAAMrpjKMOUbyy1Dn3L/3x1YvsP4SckAl6kyZN0hVXXKGPP/442EUBAAAA9qhh09aa3eFSd7vN9EeUmb6DPYaQEhJBb+vWrTr77LP1zjvv6Jdffgl2cQAAAIC96nv6zW66hcbaqukfP8IeQ0gJiaB30UUX6ZJLLlHr1q2DXRQAAACgTGLj6mh1n2vc7W5LRis1ZQt7DiEj6EHv6aef1rZt23TzzTcHuygAAABAufQb8U8t97ZSPe3QvA/vZe8hZEQG88VnzJih++67T1OmTJHXW7bMmZWV5S4BaWlp7jonJ8ddgMBxwPGAAI4JlITjAhwTqKzviS0Db1TbyVdp7aqlWrt1hxolxrBzw1ROkM8zy/O6Hr/f71cQ7Ny5U/369dMdd9zh+ueZPn36aNiwYXryySdLfd6dd96pu+66a7fl1r8vPj6+SssMAAAAFOf3+fXpnPX6eWcrHdTUp9Pa+dhJqBLp6ekuO6Wmpqpu3bqhGfRefPFF3XTTTTr33HMLlr3//vtq0aKFDjzwQNeks6RavpJq9Fq1aqV169apQYMG1VZ+hC77pWPs2LEaPny4oqKigl0chACOCXBcgO8KVPXfj0lLt+q816YpKsKjb68aqtb1qYAIRzlBPs+07NOwYcMyBb2gNd084IADdO+9Rdsxx8TEKDk5WV27dpXH4ynxebaOXYqzHc1JPTgmsCd8T4DjAmXBdwUqckwc1KWJDurUUMsWz9e0T59Wh3/+HzsyjEUFKXuU5zWDFvR69erlLoWNHj1avXv3dvPpAQAAADXJLQfWU/uVNyhqXa6WzT1S7XoMDnaRUIsFfdRNAAAAIBx069JFcxMPkNfjV+rXdwS7OKjlQirojRo1SqeddlqwiwEAAABUSMMT7lau36s+6RO1YOp49iKCJqSC3siRI91ALAAAAEBN1LpzH/2ZfLS7nfXDg8EuDmqxkAp6AAAAQE3X4oTbXK1e74wpWjR9QrCLg1qKoAcAAABUohbte2h6veHu9o6xD7BvERQEPQAAAKCSNTnuFqX64/VrWmPNWb2N/YtqR9ADAAAAqqCv3j1dPtVjuWfo2R+Xsn9R7Qh6AAAAQBX4x+E95PFI385drwXr09jHqFYEPQAAAKAKdGqSqGN7NNUQ71z99eGd7GNUq8jqfTkAAACg9riuf4Q6LL5Pvs0erZh/jtp06x/sIqGWoEYPAAAAqCIduvXR9DoHyuvxa9M397OfUW0IegAAAEAVSjzyFnfdN3W8Vv41g32NakHQAwAAAKpQx95DNSN+iCI8fq0f8xD7GtWCoAcAAABUsdhDb3DXfbZ9p01rl7O/UeUIegAAAEAV6zrwCM2P6qFoT54Wf/kY+xtVjqAHAAAAVIOsQVdosa+5PltbT9szc9jnqFJMrwAAAABUg/0OG6kjZzbV4s0Z6jhllS49uD37HVWGGj0AAACgGngjInTpIR3d7Vd+XabsXB/7HVWGoAcAAABUk5P6tlDLBOmInV9q2ndvsd9RZQh6AAAAQDWJiYzQQ22m6N6o19T0j8fk91Grh6pB0AMAAACqUc8RV2qnP1btfcs16+dP2PeoEgQ9AAAAoBolJTfU7KYnu9sRE59m36NKEPQAAACAatZ2xA3K8UeoZ/ZMLZo+gf2PSkfQAwAAAKpZ01YdNTPpMHc7bTwTqKPyEfQAAACAIEgefoO77r19gtavWsxngEpF0AMAAACCoEOv/TUnuo9+8vXWV9OW8BmgUhH0AAAAgCBZM+ItXZJzo/4z26PMnDw+B1Qagh4AAAAQJIf3aKEW9eK0LT1HX8xYy+eASkPQAwAAAIIkMsKr84e0UQttUtoPjzOBOioNQQ8AAAAIopF9Guj7mJt0Scarmj/5Oz4LVAqCHgAAABBE9ZLqaU6DI93tzF+f47NApSDoAQAAAEHW+Iir3HXvHb9o/cpFwS4OwgBBDwAAAAiydt0Hak5MH0V4/Fr2zdPBLg7CAEEPAAAACAE5/S91193WfaKMnTuCXRzUcAQ9AAAAIATsd9iZWutprHraodnfjg52cVDDEfQAAACAEBARGamVHc7Rdn+cpi9aKb/fH+wioQaLDHYBAAAAAOTrdvzVGvZob21JiVbf5ds0qF19dg0qhBo9AAAAIEQkJSVreJ8O7vY7k1cEuziowQh6AAAAQAg5e3BrSX6tn/Oztm3eEOzioIYi6AEAAAAhZL+W9fR63Zf0XuQdWvjt88EuDmoogh4AAAAQYuI7D3PXLZa8L7/PF+zioAYi6AEAAAAhpsdRf9MOf5xa+ddq7u9fBbs4qIEIegAAAECIqZNYT3MbHuVuZ09iTj2UH0EPAAAACEENh/3LXffa/qs2r18V7OKghiHoAQAAACGoQ6/9tSCyq6I8eVr8HYOyoHwIegAAAECISutxnruOWjFBPp8/2MVBDULQAwAAAEJUryMv1D91i05Lv0m/LN4c7OKgBiHoAQAAACEqrk6CmvYbIb+8envSimAXBzUIQQ8AAAAIYecMbu2uJyxYqw2btgS7OKghCHoAAABACOvUJFE3NZ6sX6Mu19KvHg52cVBDEPQAAACAEDegfRM19KSp9cpP5cvLC3ZxUAMQ9AAAAIAQ1+OIc7XDH6cW/g2aP/m7YBcHNQBBDwAAAAhx8QlJmlf/cHc7ffLrwS4OagCCHgAAAFAD1D3gInfdI+UnbU/dGuziIMQR9AAAAIAaoEv/w7TC21LxnizNH/dGsIuDEBdZ1hVTUlLKteF69epVpDwAAAAASuDxerW23alqs+Qp1Z3/vqRr2U/Y96CXnJys8vD7/eVaHwAAAMCedTriEr3210K9nzVMz27coY6NE9hl2LegZ6ZOnVqm9QYOHFiezQIAAAAog4bNWuu3jjdowfyN+vCPVRp1TDf2G/Yt6HXp0kUDBgwo87oAAAAAKt9p/Vtp3PyN+uTPNbrxyC6KjGDYDeyuzEfFggULVBXrAgAAACi7w7o21mHxSzUq8wnN/vljdh1KVOnxf+PGjZW9SQAAAAC7REd69fdGc3VKxK/SH8yphyoMenl5eRozZoxOOeUUtWzZsjI2CQAAAKAUTQ652F333DFRWzasZj+hcoPesmXL9H//939q06aNzjnnHMXFxentt9/el00CAAAA2It23Qfqr8jOivLkadG4V9lf2LdRN01WVpY+/fRTjR49Wj/99JOGDRumNWvWKCcnR5GR5d4cAAAAgArY1vkMad69arzE+undzj5ExWv0rr76ajVv3lzXXHONG4Fz4cKFGjdunHuMkAcAAABUn65HXKhsf6Ta+5Zr6ZzJ7HpUPOg9/fTT6tSpkyZPnqwHH3xQHTp0KM/TAQAAAFSSpPqNNCdhiLu98dc32K+oeNB78cUX5fP5XMA78cQT9fXXX7uBWAAAAAAEwX5naomvmX7eFK88n5+PABULen//+981ZcoUTZ8+XW3bttX555/vrs3ixYvZrQAAAEA16nHYSJ3ifUrP7zxUE5dsYd9j30bd7NWrl5566imtXbtWjzzyiA4//HB17tzZLbdROAEAAABUvZioKI3o3dzd/mQ60yygkqZXiImJ0ZlnnukGZFm6dKlOOukkvf46kzYCAAAA1eXkvi0Uo2xpzqdK35HKjkflTZhurAnnPffco+XLl1fWJgEAAADsRf82yfoy7m497n1S8358j/2F8gW9pk2blmm9iIiIMq8LAAAAYN94PB5taXmYux0990N2J5wyz3C+YcOGgjnzyrIuAAAAgOrR8pALpbdGq0fGNG1ev1INm7Zm19dyZQ56Zvjw4VVXEgAAAAAV0qpjLy2M7KIuuQu1+Ic31PBsBkis7crcdNPv95frAgAAAKD6pHQ6xV03XPIpux2VNxgLAAAAgODpfNgFyvFHqGPeEq2Y/wcfRS1H0AMAAADCQHKjZppbZ5C7vXDymGAXBzWpjx4AAACA0JU6ZJQOGbNYOeva6gifX16vJ9hFQpBQowcAAACEicH7H6it0S21NjVTf6zcFuzioKYFvYSEhAo9BgAAAKDqxEZF6Mge+XNafz1jJbu6FqtQ0Nu5c2eJy3NyctwFAAAAQHCc0jlKL0Y9rn/MOFW5Odl8DLVUufrovfXWWyXeNj6fT5MnT1anTp0qr3QAAAAAymVQ9w7a8dlCJWu7Zk8co14Hn8QerIXKFfRuuOGGEm+bqKgotW3bVs8991zllQ4AAABAuURFx+ivBodp8JbPlTH9A4mgVyuVK+itX7/eXffs2VNz5sypqjIBAAAA2AcJ/UZKYz9X120/KSsrQzExcezPWqZCffQIeQAAAEDo6jr4KG1Ssupqp+b/8lmwi4OaNI/ejBkz9Pvvv2vr1q27PXbbbbeVeTt+v1+LFy/Wjh071KFDB9WtW7eiRQIAAAAgKSIyUksaH6lGG99X7qyPpCPOYr/UMhUKek8//bSuueYaN/BKcnJyhYPep59+qptuusn174uMjNSiRYvcdu+///6KFAsAAADALsmDzpS+el/dU39Rxs7tiquTyL6pRSoU9B555BG99957OuOMM/bpxa028Mcff1SLFi3c/QkTJuiQQw7RsGHDdOSRR+7TtgEAAIDarHO/YfppzP6akNVJAxeu1zH9CHq1SYX66G3fvl0jRozY5xe/+OKLC0Ke2X///V3NXmDQFwAAAAAV4/F6NXnQU3o17xh9NjeV3VjLVKhGb9CgQZo0aZIOO+ywfS6A1erNmjVLaWlpevXVV9W/f3+dcsoppa6flZXlLgH2PMNk7QiwY6HwNcAxgZJwXIBjArXhe+KY7o31/E9L9OPCTdq6PV2JsVHBLlKNlhPkY6I8r+vx22go5XTPPffomWee0bXXXquOHTvK4/EUefy0004r87amTJmif//739q8ebPWrl2rhx56SJdeemmp699555266667dlv+zjvvKD4+vpzvBAAAAAhfdqb/7IxM9c2Zpm7NktWgVY9gFwn7ID09XWeffbZSU1P3OohlhYJevXr19vh4SkqKKuLXX3/VEUcc4Wr27A2UtUavVatWWrdunRo0aFCh10V4sV86xo4dq+HDh7uBfgCOCfBdAf5+oDafU0x9c5QOWPWyZsYOVPfrvwl2cWq0nCAfE5Z9GjZsWKagV6GmmxUNcntz4IEHumah3333XalBLyYmxl2Ksx1dk/8DovJxTIBjAnxXgL8f4JxCannQudI7L6t7xp/akbJZyY2acWDU0PPM8rxmhQZjqQw+n89VPRaWnZ2t5cuXq1GjRsEqFgAAABBWWnfuo8URHRTlydNfP70T7OKgmlQ46M2bN0+jRo3SyJEjC5Z98MEHysjIKNPzrfnlwIED9eijj2rMmDGuj91RRx3lll955ZUVLRYAAACAYja1Ptpdxy35mn1TS1Qo6I0fP14DBgzQ3LlzXbgLsNEzn3322TJtIy4uTj/88INrZ/r888/riy++0NFHH60FCxaoTZs2FSkWAAAAgBK0HHqWu+6eMV0pm5nKrDaoUB+9W265RS+99JLOPffcIiNunnPOOTr++ON14403lmk7TZo00d13312RIgAAAAAoo1Yde2lJRDt1yFumRRPe18BTrmbfhbkK1ejNmTOnYK67wkGvdevWWrlyZeWVDgAAAECl2NjyKOX5Pdq4fC57tBaoUNBLTEx00xkUD3o2J17z5s0rr3QAAAAAKkWTwy7X4KzndM2Wk5SaXnMngUcVBr0zzjhD11xzjbZu3VowgubPP//sJjo/88wzK7JJAAAAAFWofZvWqt+khXLy/Bo7fwP7OsxVKOg98MADLtzZNAh2bTV8w4YNU9euXXXnnXdWfikBAAAA7LNje+XPoffjzCXszTBXocFY6tSpo6+//lrTp0/XtGnTXNjr16+fmy4BAAAAQGg6rkuiBv18r/quWKy0lAWqW69BsIuEUAp6nTp10qJFi9S3b193AQAAABD6OrZoouioNMX5sjV3wgcacMK/gl0khFLTzS1btiglJaXySwMAAACgyni8Xq1tfpS7HbHgC/Z0GKtQ0Dv99NPLPDE6AAAAgNDRZP+R7rr7zqnakbYt2MVBKDXd3LBhg5sw/b333lP37t0VHR1d5PG33nqrssoHAAAAoBK16z5QqzzN1UprNfuXjzTguEvZv2GoQjV69erV0wUXXKABAwYoPj5ekZGRRS4AAAAAQrf55upmw93tiHmfB7s4qCIVSmX33nuvWrZsWfmlAQAAAFDlGg0eKX36hrrtmKT0HSmKT6jHXg8zFarRa926deWXBAAAAEC16NBriMZEHKb/y71IP/+1lb0ehioU9Jo3b67Vq1dXfmkAAAAAVEvzzZkD7teHecP01QJG0w9HFQp6119/va688kpt2rSp8ksEAAAAoMod3aOpu/554SZl5eaxx8NMhfroPfroo1q7dq0+++wzNWrUaLdRN6ntAwAAAEJb75b11CshTQMyftOcSVL/A/Pn10MtDnr33Xdf5ZcEAAAAQLXxej26LelbDc79TJP/SJEIemGlQkHvwgsvrPySAAAAAKhW8b1Pkn74TB23TVBebq4imCqtdvfRAwAAAFDzdd3/WKUpXg2Uqr/+GB/s4iDYQS82NnaPFwAAAAChLyo6Rn/VPcDdTvnz02AXB8FuuvnRRx8Vue/z+bRo0SI9/PDDuvbaayurbAAAAACqmLf78dKkcWq98Qf5fT439QJqadAbMWJEicv79u3rBmq5+eab97VcAAAAAKpB1wNPVubEG9RCG7R03lS17zmY/R4GKjWuDx48WNOmTavMTQIAAACoQvEJSVpQZ4Cy/JFaOGsS+7o21+jtqUlncnJyZW4SAAAAQBVbvf+dOmfMarXe1ETHsLdrb9Dr06fPbsu2bdvmJkp/8cUXK6NcAAAAAKrJAf37KeObLZq/Lk2rtqarVf149n1tDHrnnnvubsusJm/o0KHq2rVrZZQLAAAAQDWpXydag9rV16SlWzVu1gpdNKwb+742Br0bbrih8ksCAAAAIGjOablZt66+TRG/JUrDfuWTqI2DseTl5WnOnDm7Lbdl9hgAAACAmmVAj87q5V2urtlztGXD6mAXB8EIeg899JDefffd3Za/8847evTRR/e1TAAAAACqWbM2XbQ4ooO8Hr+W/Fp03mzUkqD3/PPP67LLLtttuS174YUXKqNcAAAAAKrZppbD3XXM4jHs+9oY9LZu3aqIiIjdltuyDRs2VEa5AAAAAFSzZoNPc9dd0/9U+o4U9n9tC3oDBw7UM888s9vyp556yj0GAAAAoOZp07W/1nqaKMaTo4W/fxns4qC6R9287777dPjhh+uXX37RwQcfLL/frwkTJmjq1KkaP378vpQHAAAAQJB4vF6tbHSImm/8QDnzxkhHnsdnUZtq9Gy+vEmTJqlVq1b6+OOP9emnn6p169ZumT0GAAAAoGaq0+cUfZ53gN5N66U8nz/YxUF11uiZPn366O23367o0wEAAACEoK6Dj9LZ33u1PT1X565KUf82ycEuEqqrRg8AAABAeIqK8GpYl8bu9rj5DLRYUxH0AAAAABRxRNdG6uJZqfgZr7FnalvTTQAAAADhaVibWB0XfYsiM31as/QCtWjfPdhFQjlRowcAAACgiKT6DbUwppe7vWrSJ+yd2hb0bHL0iRMnVl5pAAAAAISE7W2OcNcJK8YGuyiorqC3bds2jRgxQk2bNtUBBxxQsPyEE07Qb7/9VpFNAgAAAAghrYac6q67ZM5W6rbNwS4OqiPo3Xjjje56yZIlRZZfeeWVuueeeyqySQAAAAAhpEX7HlrhbaUoT54W/f5psIuD6gh6X3/9tZ5//nm1b9++yPKBAwfql19+qcgmAQAAAISYtU0Ozb+x4JtgFwXVEfRSUlKUlJTkbns8noLlaWlpioiIqMgmAQAAAISY5L7Hu+sW22coJzc32MVBVQc9q7n75JNPigQ9v9+vBx54oEifPQAAAAA1V6d+h+ky7206JPNxTV2REuzioKrn0bNAd/TRR+unn35yAW/UqFH6/vvvNX/+fE2YMKEimwQAAAAQYiIiIxXf7Uhl/7Fa4+Zt1AEdGga7SKjKGr2hQ4fq999/dyGvW7du+uyzz9S1a1dNnjxZAwYMqMgmAQAAAISgI7o1cdfjF2xw5/8I4xo906tXL73xxhuVWxoAAAAAIeWgTg3176gPddT2SVq54G216dY/2EVCVU+YDgAAACC81YmJ1IF1VqmDd53WTfs82MVBZdfo1atXr1yjcgIAAAAID+ltDpcWTlPdVT9IujvYxUFlBr3Ro0eXdVUAAAAAYaTV4JOlhQ+pc9ZcpaVsUd16DYJdJFRW0DvttNPKuioAAACAMNKifTet8LZUG99qLfr9C/U/9qJgFwl7QR89AAAAAHu1ttFB7tq38Fv2VriOuhkbG7vHxzMzMytaHgAAAAAhKLHXcdKGd9U+daJ8eXnyRkQEu0io7KD30UcfFbnv8/m0aNEiPfzww7r22msrskkAAAAAIazzwCO1ZGwLTcnrrJ7L16pXh1bBLhIqO+iNGDGixOV9+/bVfffdp5tvvrkimwUAAAAQoqJjYvRop//qmznrdfXSDPXqEOwSodr66A0ePFjTpk2rzE0CAAAACBGHdm3srn9cuDHYRUF1Bj1r0pmcnFyZmwQAAAAQIoZ1aSSvfIpYM02bNq4LdnFQ2U03+/Tps9uybdu2afXq1XrxxRcrskkAAAAAIa5xYqw+TnxMfXOma8pvXjU6+apgFwmVGfTOPffc3ZZZTd7QoUPVtWvXimwSAAAAQA2Q2bS/tGq6IhaPlUTQC6ugd8MNN1R+SQAAAACEvAZ9j5dWjVbnHVOVk52lqOiYYBcJJWDCdAAAAABl1rH3Qdqqukr0ZGjh1O/ZczU96Nkk6WW9AAAAAAhPNlH6kqQh7vaOWV8HuzjY16abn332WcHt6dOnu/ny/vnPf2rgwIFu2dSpU/XCCy/o1ltvZWcDAAAAYczb5ShpyndqtumXYBcF+xr0jj766ILb9957r957770iE6ePHDlShxxyiB5++GGNGjWqrJsFAAAAUMN0HHKiciffoDa+1VqzdIFatGdAxrDoozdz5kwdfPDBuy23oGePAQAAAAhfSckN9VrS5To16w6NWxMR7OKgsoJe/fr19cEHH+y23JY1aNCgIpsEAAAAUIPk9b9If/i76KfF24JdFFTW9Ar33HOP/va3v+mLL75wffT8fr+mTZumMWPG6I033qjIJgEAAADUIId0bqQHv1mgiUu3KDMnT7FR1OzV+KB3/vnnu4nRn3rqKX3yySduWffu3TVp0iQNGDCgsssIAAAAIMR0bZqoEQkLtH/mb1o4xaPeQ/83pgdqaNAzgwYN0ttvv125pQEAAABQI3g8Hp2fME2Dcsdr4qzGEkEvvCZM37RpkzZu3Fg5pQEAAABQY0R0PtJdN9/0a7CLgsoIej6fT4888ogaNmyoxo0bq0mTJu62LbPHAAAAAIS/jvsfr1y/V218q7RuxcJgFweVMRjLM888o5tvvln777+/q7adOHGiHnzwQaWnp+uOO+6oyGYBAAAA1CBJ9RtqfnRXdcuZp1VTvlSzNl2CXSTsS9B7+eWX3VQKhx12WMGyoUOHql+/frrgggsIegAAAEAtkdL8YGnFPEUt+0HSDcEuDval6ab1yStpdM3+/fvTXw8AAACoRRr2Oc5dd9r5p7KzMoNdHOxL0LOpFf773//utvzNN99Uly5U1wIAAAC1RYf9hmqr6mqzv67mzp8b7OJgX/vonXrqqfryyy/dNAtm8uTJGj9+vD7++OOKbBIAAABADeSNiNDjnf6rt2bv1L/W11HfYBcIFa/RO/HEEzVt2jQ30qaFva+++kqNGjVyy+wxAAAAALXHgO6d3PVPCzcFuyjY1wnT+/Tpo7feequiTwcAAAAQJg7q1FAej7Ro3VZt2JqiJvXrBbtItV65gt7mzZvLtJ7V9AEAAACoHRokxOiRep/qqPSvtODnW9Tk5KuCXaRar1xBz5pnloXf76/1OxYAAACoTVo2qKvEjAx5l4yXRNCrcU0327Rpo4suukiDBw+umhIBAAAAqHHq7XeMtPoVddwxVbk52YqMig52kWq1cgW9mTNnavTo0Xr66afVrFkzXXzxxTrvvPNoqgkAAADUch37HqLUMXWUpJ1aMGOCug48IthFqtXKNermfvvt50Le2rVrdcstt7jRNlu2bKnTTz9d3377bdWVEgAAAEBIsxq8xQkD3e1ts74JdnFqvQpNrxATE6Ozzz7bzZs3a9YsrVixQsccc0y5tzNv3jxdeuml6tGjh3r37q3LL79c69evr/UfCgAAAFAT5XU43F03WDch2EWp9SoU9MyiRYs0atQoDRs2zI3Gedddd5Xr+Xl5eRo5cqT2339/ffjhh3rllVc0Z84cHX744crIyKj1HwwAAABQ07QddLy77pizSKlbqMCpMX300tPTC0LZ1KlTdfLJJ+u///2vDjvsMHls4oxyiIiIcLWBhZ9n2+3UqZMmT57sAiQAAACAmqNxi3YaG3WoZqU3UK+lW3Vkg6bBLlKtVa6g17RpU9WvX18XXnihC2XJyclu+ZYtWyo0j17xcJiVleWuo6MZoQcAAACoiSb3vl+jf12mM1fm6sj8LnsI9aC3fft2d7FmmntqqlmRefTsOTfffLM6d+6sgQNLPyIsDAYCoUlLS3PXOTk57gIEjgOOBwRwTKAkHBfgmMDe8D1RMQe0T3ZB7+e/Nik7O7vcLf9CWU6QzzPL87oefzlS2bhx48q03hFHlH8o1RtvvFEvvfSSfv75Z/Xp06fU9e68884SQ+Y777yj+Pj4cr8uAAAAgMqTnSc9ODVDgz1zNbRbOyXUbcDurSTWlc4GxUxNTVXdunUrL+hVldtuu81N2/Ddd99pyJAhe1y3pBq9Vq1aad26dWrQgIMI+b90jB07VsOHD1dUVBS7BBwTKBHfFeCYwN7wPVFxCx4drl5Z0zWx0w0acMbNYXOw5QT5PNOyj3WTK0vQK1fTzapw++23u5Bn8/DtLeQFpnawS3G2ozmpB8cE9oTvCXBcoCz4rgDHxL7b2fJgacl0xa/+RVFR/xd2B1VUkLJHeV6zwtMrVAZrgvnkk0+6kHfAAQcEsygAAAAAKkmjPse6607pM5SVmc5+DYKgBb2tW7e6/nZW/XnKKae4ET0DF+tvBwAAAKBmatd9oDarnuI9WVr8x4/BLk6tFLSmmzY1g/WrK0lSUlK1lwcAAABA5fBGRGh53YFqmDZW2+d+Kw09jl1bW4KeDbNqtXcAAAAAwo+/w2HS9LFquOG3YBelVgpqHz0AAAAA4andwPxavPa5S7V1U8kt+VB1CHoAAAAAKl3D5m10X/xNOjDrKf26NugzutU6BD0AAAAAVcLT82StVUP98tcm9nA1I+gBAAAAqBIHd2rkrn9ZtFl+P7V61SnoE6YDAAAACE8D2ibr/KgfNCxjmlYsqKe23foHu0i1BjV6AAAAAKpEbFSETq8zXYdFzND6P79mL1cjgh4AAACAKpPe8mB3Hb9qAnu5GhH0AAAAAFSZxv3yp1nolDFTmRk72dPVhKAHAAAAoMq07dpfm5SsOE+2Fv/5A3u6mhD0AAAAAFQZj9erFXUHuNvb541nT1cTgh4AAACAKuVrd4i7rr/hd/Z0NSHoAQAAAKhSrQccoyx/pDZlRyl1ZyZ7uxoQ9AAAAABUqaatOurEhHd0bvYtmrw8hb1dDQh6AAAAAKrcwE4t3PVvizezt6sBQQ8AAABAlRvasYG7nrV4OXu7GkRWx4sAAAAAqN2GtEnSl9G3qEfaCm1cM12NW7QLdpHCGjV6AAAAAKpcUmK8YqOj5PX4tWLaN+zxKkbQAwAAAFAtNjcekn9j6U/s8SpG0AMAAABQLRK7HeGu26ROld/nY69XIYIeAAAAgGrRsf/hyvJHqbG2auWiWez1KkTQAwAAAFAtYuMTtCi2h7u9bvq37PUqRNADAAAAUG22Nx/qrmNWTmCvVyGCHgAAAIBqU7/3cfok70C9nT5QuXn006sqBD0AAAAA1abjfgfozoir9FHmIM1Zm8aeryIEPQAAAADVJsLr0ZAODdzt3xZvZs9XEYIeAAAAgGo1tEN9dfWsVO6sj9nzVSSyqjYMAAAAACUZ1jBN58fcrKytUcpMv9yNxonKRY0eAAAAgGrVquN+2qAGivHkaNG08ez9KkDQAwAAAFCtPF6vViYNdLd3zB/H3q8CBD0AAAAA1c7TYZi7brhpInu/ChD0AAAAAFS7NgOOcdcdchYrdcsGPoFKRtADAAAAUO0aNW+r5d5W8nr8WjL1Gz6BSkbQAwAAABAUGxoMdtfZi3/iE6hkTK8AAAAAICjy+l2kc77spM0ZffUdn0GlokYPAAAAQFD07DtYE/29tHBLrtakZPApVCKCHgAAAICgqBsbpd6t6rnbvy3ezKdQiQh6AAAAAIJmRPOdujXyLSVNfIhPoRLRRw8AAABA0OzfKEc9Isdo85Z68vuedpOpY9+xFwEAAAAETcf+hyrDH62GStHKhdP5JCoJQQ8AAABA0MTExmtJbHd3e/2ssXwSlYSgBwAAACCotjcb4q6jVv7GJ1FJCHoAAAAAgiq5++Huut3O6fLl5fFpVAKCHgAAAICg6tDnIKX7Y5Ss7Vo+fxqfRiUg6AEAAAAIqqjoWC2J66n1/mQtWrKYT6MSEPQAAAAABN3kAU9o/6xn9VFql2AXJSwQ9AAAAAAE3YAubSR5NHnpFuX5/MEuTo1H0AMAAAAQdD2b11VCTKS2Z2ZrwepNwS5OjUfQAwAAABB0kRFe3ZH8nabF/EvbJzwf7OLUeAQ9AAAAACGhVcNENfBsV+ya34NdlBqPoAcAAAAgJDToeYS77pA+U7k52cEuTo1G0AMAAAAQEtr3HKI01VGiJ0NLZ08MdnFqNIIeAAAAgJAQERmpJfG93e2tc8YFuzg1GkEPAAAAQMjIanmAu45fS43eviDoAQAAAAgZjXoNd9cdM2YpJzsr2MWpsQh6AAAAAEJGu+4D9bt667W8ozRnxYZgF6fGIugBAAAACBneiAi92eEJPZJ7pn5fzcibFUXQAwAAABBShnRo4K4nLtkS7KLUWAQ9AAAAACEX9BKUrjorxikrMz3YxamRIoNdAAAAAAAorFOjOvox9kY10jbNm9Ff3fc/mh1UTtToAQAAAAgpHq9XqxL2c7dT5/0Y7OLUSAQ9AAAAACEnp/VB7jpxPfPpVQRBDwAAAEDIadYnfz69TlnzlJmxM9jFqXEIegAAAABCTquO+2mTkhXjydHiP2m+WV4EPQAAAAAh2U9vRWJ/d3v7fIJeeRH0AAAAAISkvLYHuuukDZOCXZQah+kVAAAAAISk5v1H6LY/V2hKTk99np2nuOiIYBepxqBGDwAAAEBIatmmo8YnHK+/8ppp2oqtwS5OjULQAwAAABCSPB6PhrRv4G5PXLIl2MWpUQh6AAAAAELWwa0idW7EWLWb9Xiwi1Kj0EcPAAAAQMga1DxKJ0W9ptydXu3c/rDqJNYLdpFqBGr0AAAAAISs5m27aL0aKdLj0xLm0yszgh4AAACAkLYqqa+73vnXz8EuSo1B0AMAAAAQ0vyth7rrehunBLsoNQZBDwAAAEBIa9b7cHfdIXuhMtN3BLs4NQJBDwAAAEBIa9m+hzYpWdGeXC2ZTvPNsiDoAQAAAAhpHq9XKxP7Ks/v0fqls4NdnBqBoAcAAAAg5C3vd7N6Z72s0RnDgl2UGoGgBwAAACDk7de9u3YoXn+u3KbsXF+wixPyCHoAAAAAQl7HxgmqXydaWbk+zVqdEuzihDyCHgAAAICQ5/F4dEWDP/VJ9O3KmvBksIsT8gh6AAAAAGqE7sm56uddrMS1vwW7KCGPoAcAAACgRmjUc9d8ehlzlJuTHezihLSgB73t27frhRde0DXXXKPFixcHuzgAAAAAQlTbbgOUpjqq48nUktkTg12ckBbUoDd69Gh16dJFP/74o5566imtXr06mMUBAAAAEMIiIiO1NH4/d3vbvB+CXZyQFtSgN3DgQC1cuFCPPfZYMIsBAAAAoIbIbL6/u45dMznYRQlpQQ16vXv3VmJiYjCLAAAAAKAGqd/9UHfdPmOW8nJzg12ckBWpGiYrK8tdAtLS0tx1Tk6OuwCB44DjAQEcEygJxwU4JrA3fE+EplZdB2jl5000x9dGrZetUJe2rWvNMZFTjtf1+P1+v4LM+ua1atXK9dUbNmzYHte98847ddddd+22/J133lF8fHwVlhIAAABAKHhhvlfzU7w6uW2ehjULepypNunp6Tr77LOVmpqqunXrhleN3qhRo3TdddcVqdGzkHjooYeqQYMGQS0bQoP90jF27FgNHz5cUVFRwS4OQgDHBDguwHcF+PsRXlbWWar54xZrR1wzHXtsn1pzTpG2qzVjWdS4oBcTE+MuxdmO5qQeHBPYE74nwHGBsuC7AhwToe+ATo302LhF2rh8niIj+svj9daK74mocrxmjQt6AAAAAGq3Xs3r6qeY69XWv17LF/ZU2279g12kkBPUoDdlyhTXt27Hjh3u/rPPPqvPPvtMRx99tLsAAAAAQHHRUZHaEdtUylqvDbPGE/RCLeglJCSobdu27vYTTzxRsLxevXpBLBUAAACAULe9yWBp5QxFrv492EUJSUENet27d3cXAAAAACiPul2HSStfVJvt0+X3+aq9n16oY28AAAAAqHE69D1EWf4oNVSKVi+ZHezihByCHgAAAIAaJzaujpZEd3W31836IdjFCTkEPQAAAAA1UmqTge7au+K3YBcl5DC9AgAAAIAaKbbHcXp5+XrNyhik/n6/PB5PsIsUMgh6AAAAAGqkLv2H6fQvs5W73a9/b8tQq/rxwS5SyKDpJgAAAIAaKT46Ur1aJrnbk5dtDXZxQgpBDwAAAECNNbR1HQ31ztbOGZ8GuyghhaAHAAAAoMYaHr9Ib0c/oCNWPxPsooQUgh4AAACAGqtdv8OU5/eohX+DNq1dHuzihAyCHgAAAIAaq269Bloe2c7dXjljfLCLEzIIegAAAABqtM31+7nr3KXMpxdA0AMAAABQo0W2O8BdN9z2Z7CLEjJqxTx6eXl5ysnJCXYxUE3ss46MjFRmZqb77FF1oqKiFBERwS4GAABB1abPEdIUqV3ucqWlbHHNOWu7sA96O3bs0OrVq+X3+4NdFFQT+6ybNm2qVatWyePxsN+rkO3fli1bKiEhgf0MAACCpmHzNlrtaaqWWq9l039Q70NPr/WfRlgHPavNsZAXHx+vRo0acdJfS/h8PhfwLXx4vbROrspAvWnTJvd/rFOnTtTsAQCAoPq69b/12V9ZOiyzu3rzWYR30LMmfHYyaiEvLi4u2MVBNQa97OxsxcbGEvSqmP3fWr58ufu/RhNOAAAQTPV6Dtf8hbOVuCKND6K2DMZC8z2A/1sAACC8DWxb313PWJ2irFzGaQjrGj0AAAAAtUO7hnV0dvwU9c+ZpsUz4tVjwCGqzWpFjR4q5qKLLtItt9zC7gMAAECNaMV3WtyfOjXiV6XN/V61HUEvBNm0AA8//LCGDBmi9u3b64gjjtDLL79cZIqI8847T7fffnulvWZJ29u2bZvS0tJC4v1effXVbiRNu7Rq1Ur77befzj77bH322We7be+aa65Rly5ddMMNN+z22IMPPui2Yc8FAABAeMluMdhdx6+fotqOppsh6NJLL9Xvv/+up59+Wt27d9eKFSv0/vvva+vWrbrpppsKQliDBpU3P0hJ23v99derZYCNsrzf1NRUFwI/+eQTN9jKxo0bNX78eP3tb3/Tm2++qQ8++MDNnRdY137RefXVV3XfffcVDMRjz3v++efdY7ZtAAAAhJcG3Q+R/npE7TLmKC83VxG7zg9ro9r7zkOU1WJZaHnhhRd03HHHuWXt2rXTsGHDXFAJ1G6NGzdOP/74o9577z237Ndff3W1YG+88Ya7b6Ft//33d0HHarACzjjjDHXs2FHp6ekaM2aMevXq5eZBK2l79txmzZrp/vvvL3iuDaNvI1qOHTvWTV9x1llnadSoUQUD3uTm5ur//u//9NFHH6lu3bruPWzYsMFNdfDYY49V6P0GREdHF7yX5s2bq0+fPq72b8CAAXrxxRd1+eWXF6zbs2dPN/T/xx9/rHPPPdct++6779worIceeihBDwAAIAy16zFYOz+NVV1PupbM/0MdeuXX8NVGtarppp3kp2fnBuVS1gnbrQbNaqZmzpy522OBOeHuvvtuHXTQQTrnnHM0Y8YMd7FwdOuttxbcf+edd5SSkqITTjihyGtbTZY1X0xOTnZBz8Jhadsr3nQz8FwLkR9++KELgvfee68LagHW/NPCptXOWU2bDb1vr2G1bBV9v3vSu3dvHXnkkQUBtTCr7XvllVcK7ttt63fI3HoAAADhKTIqWkvierjbm+f9qNqsVtXoZeTkqfvt3wXltefdfZTio/e+uy2EWJi67rrr9M0337iaraFDh+qYY45xc5aZpKQkxcTEuIngC9fWWQ2aXYwtt8Bl686fP981iQywUHfHHXcUed2StleSo446SjfffLO7bbV7I0aMcLWBI0eOVFZWlgt4//nPf1x5zejRo/X999/v0/vdmx49erhQWZwFVyvrkiVL3H756quv9Oijj+q2224r03YBAABQ8+xsMlBa8YciV09SbVaravRqiiuvvFILFizQP/7xD23ZssWFIKthK1xzVpKVK1fq73//uxuoxJo2WhNNq82zWrXC+vbtW+GyWagqrHHjxtq8ebO7vWzZMu3cudMFtcLNLfv3718l77dwraA1Iy2ufv36rkbztddec6H3wAMPVNu2bcv4TgEAAFAT1e18sHx+j3J2bC1zq7pwVKtq9OKiIlzNWrBeuzw6dOjgAo9dbFRK6wtnIe70008vdQJ4qwWzIGZNJS3oWZPINm3auD51hcXGxlb4fZQ0OEvgP1DgdaKiooo8bmGvKt5vwNKlS9W6desSH7v44otdE87ExMRKHaUUAAAAoal9v8M0cMxL2pJXRxO2Zqh1g3jVRrWqRs8CgzWfDMZlb2FlTyyYHX/88a6f244dO9wyC3GFBytZu3at5s2b5/rNDR482E1BYH3sCk9RsCfFt1cRNiqmBcFZs2YVCYGzZ8/e5/dbGhvoxfoaWhPSkthgLVYmW+/kk08uVzkAAABQ89iI661btHC3py6vvSOt16qgVxNYPzfr72bTDdjtQJNIG5XSApzVTJkWLVpo4cKFBbVpNkCK9bH78ssv3X2bfuBf//pXmV+3+PYqwkbWtH5xVnO2bt0615zS+sRZH7l9fb/F2eieNkro8OHDXW2e1QSW1gfQBnpZvHjxPtVkAgAAoOYY1La+u562LL+LUW1E0AsxNijKaaed5gYRsT5mNpiKTYFgtWU2ZUHAZZdd5gKUPW4DqKxatcr1RbOpECwcWVNIm17Bwl9ZFN+eBaOKeOKJJ9SkSRM3ZYOFzwkTJrgBVkprvlnW92ssDFrZrF+ghUor84knnqhJkya555WmXr16btsAAACoHQ6pn6L3o+/W3+ZdqNrK46/hPRRt+H87ybcBQYpP+G19vax2yAb2qIm1OVYjZoObBEbSLMn27dvdOjZCZaD/nDXZtOfYfavZC4zSGXjM+tBZUNrb9uy2bSNQq1bSc20dK6eFqcKsyaXtc2sSaoPDBObbq+j7tWacGRkZ7rZt095T8b6AAVZOW99q+kqaSsEes2aqNsUE9k1N+T9mTZitie+xxx5b6nGD2ofjAhwT4HsifKVu2aCkZzq721svm6f6jfObctb0vx2B7GPns3vKCLVuMJaaxkLW3j5AC2HFmzcWDjBW+1XaY3vbXvHwVtJzi7/2b7/95vrDWR87+w3h4YcfdiNqnnrqqdqX92sH9J5q7Yqvu6c+kWXdDgAAAGqmpAZNtNzbWm19K7V8+g+qf9R5qm1ouolKZaN+vv/++65G0Gr+Xn31VX3++efq3Dn/FxUAAACgOmxI7ueus5f+Wit3ODV6qFRWC2hBzwZLsaptG/UIAAAAqG4RbQ+Qtnym+lv+rJU7nxo9VAnrR0fIAwAAQLC06n2Yu26fs1g7t6fUug+CoAcAAAAg7DRp3Unr1UiRHp+WTv9ZtQ1NNwEAAACEpb/qHajZW1Zqy6Zs9VLtQo0eAAAAgLC0ashdujTnen2xtZVqG4IeAAAAgLA0qG19dz19ZYpy8nyqTQh6AAAAAMJSh0YJqhcfpfo567Vg8VLVJgQ91DhvvfWW/vOf/+zzdi677DJNmzatzPcrsk0AAAAEj9fr0X/iR+u32Ku1Y+pbteqjYDCWEDR69Gj9+mv+xI5RUVFq2bKlTjzxRPXp0yfYRQsJkyZN0vr163X55Zfv9tgTTzzh5vC79NJLd3ssKyvLBbFzzz1Xhx56qN555x0ddthhGjBggHt8b/fLoiLPqYivv/7aHSM7d+5Uz549deaZZ6pu3boFj99www3avHmzPB6PYmJi1LhxY1emo48+WtHR0UW2FVj36quvVt++fYs89vjjj2vWrFk6/fTTddxxx1XpewIAAKgKEU26Sju+U+zaybVqB1OjF4LsBN7CzLBhwzR48GCtWrVK/fv317vvvhvsooW8xMRE/d///Z9SUnafK+Wzzz7TG2+8oc6dO7v7zz33nAYOHKiaxO/364wzznBB1gJb165dNXPmTPcjwNy5cwvW++ijj9w+OOSQQ9yxY88bNWqUOnTooN9++63INm1dm+T+mWeeKbJ827Ztuu222/Tee+9p9uzZ1fYeAQAAKlNyt0Pcddv02fL7ak8/PWr0QlTTpk114YUXutuXXHKJO2l/8MEHddZZZxWsk5OT42qQJk+erKSkJB1zzDE6+OCDi2zH1rGTeAuOycnJOu+88wqCjklLS9Mrr7yiBQsWqFGjRjrnnHPUrVu3gseslueWW25Rp06dCp6zfPly3XnnnXrkkUfcc/ZWjokTJ7qwcN1117nXWrNmjR566CE1bNhQ69at0+uvv64VK1aoTZs2rratVauioyJNnTpVb7/9tmJjY3XEEUfscb9Zzda1116rDz74wNVUFWavbTVaLVq0KAjUti/sdcvCgpKV1+v1qnnz5q6Ga8iQIaWub7Vhts8vuuiiIsstPFn4Ovnkk8u9zenTp+vDDz90+3T//fcvWJ6amuo+h8Is/AWOIWOf2d/+9jeNGDFCixYtcvs/4JRTTnH77Omnn1ZCQoJbZvt80KBBWrx4cZn2DwAAQChq12uoMr+MUrJnu1YsmqU2XWpHKzlq9GoICyRWsxeQmZnpamssvHTp0kV16tRxzessXASkp6e7wHXXXXe5EGFBaeTIkQUn7jt27HDN+SwIdu/eXatXr3ZN9yZMmOAet6aA1mzvtddeK1IWqxWz4GghryzlWLJkiV566SUdfvjhioyM1EEHHeTKMmPGDPXu3duVx64t7O23336uhipg3LhxOuCAA5SRkaEmTZro+uuvdzVQpbGQYq9v/fgKs22PHz/eheYAC6cWWsvKQo/Vsh544IGueaiFxv/+97+lrm/Nbm+//Xb5Cv1yZK93//33q1mzZhXaptWyBWouC7OAXTi4lSQiIsI1bbXmnsVfo1evXu4YsGMhwD7Tiy++eI/bBAAACHXRMbFaGtPF3d4w5yfVFrWzRi97Z+mPeSKkqNgyruuVouL2vm50He2LvLw8/fjjjy4EBdgJu9Xg/PLLL+4E3gwdOlTHHnus/v73v7vA89hjj7mQ9ddff6levXpuHavtCtT8WBizoPbTTz+54GVsW7bOH3/84e5bDZ/V8tx3332uv1cgIFnNYFnLYex1LDhYKAz4xz/+4frZ3XHHHQXLrD/Zrbfeqq+++srdv/HGG906Tz75pLt/wQUXqG3btnvcXxZOLJxa7ZfVnBm7b8HUarMqymrgCrNazrvvvrtgXxRnodpqMX/++WfXJzCw76z5ZKA2rrzbtOe1b9/e7V97nxaCrQbQAnZZ1K9f39XY2r4pzrYXCHc2oMyyZct02mmnuVpHAACAmiytYT9p7RxpVe3pp1c7g979zUt/rNOR0jkf/u/+Ix2lnPSS121zoHTR1/+7/2QvKX3L7uvdmVruIlpTSmt2Z7U8dtJt/bFeffXVIoNxWHiysGT9r+ySnZ3tltlzrabum2++cSfqgZBn4uPjC25bADnppJMKQp6xpqH2OlbbZyHN7lvYsn5dVutkzSit2Z8FwLKWw9hrFG7OaYN/TJkyxQ0SYrVsgeda7d7SpUsLmo5arZ8FzcJBZW/NNy34WN81C3eB/mnWPNRCotUoVtT27dtdc8b58+e7sm3atMmV1d5v8QFOjL234cOHu+cEgp7dDuy7imzTAp19Bk899ZS+/PJLF8ADTVatj13hAVlKY7WB9vkWZ5+1BVMriw0IZPfj4gr9kAEAAFBDxXUYKq19U81SZ6i2qJ1BrwawcGZN+mykyC1btrgAVLjWxpZZc04LX4VZCLJROgPN/CxslMZCRYMGDYosCzT/27hxowt61sTQRpG0MGKvZddWi9SuXbsylyPQtDBQIxh4nrEgWLiPnIXBQMCx8gXCXWF2v6TBVgqzvn5Wo2kXa4pqTTf3pRmihTALjbY/TjjhBFcGa4ZpQdeayJYUyoyFuiuuuMJNB2EBat68ea5s+7JNW8+a49rFmrTaIDM2OIsdHzbAzN5s2LBBPXr02G25hUT7YeDZZ591A/9YU1cAAIBw0LbPoXr1x6M11ddF927PVIPEQi34wlTtDHq3rN1z083Cbly856abhV0zu0oGY7GTeOvfZjVS1oTTWIiy2qnCg20UZ+vsaSCN1q1b79ZHzZrr2cAghUOaBRPrG2fNNK0PV+GmlmUpR0ks3NjrWDPE0pop2rZtnZUrVxYJJhbaLDjuidVwWRPITz/91AUh6xdYeBCa8rLQs3XrVhfWArWCe+orGGA1plbbaeHNBlCxUVQ7duy4T9sszGrcrObNam9t+3tjzXjtmCj8GRZmg7VY7aNN2VDVU0QAAABUl6QGTfRu/cu0aOMOnbwyRUf2aBr2O792DsZifeZKuxTun7fXdYs1ayttvX1kYcea6lnN1Oeff+6WnX/++e629a8LsEE/bHTLwgHNgoM1fwywIfht0BVjg5Z8/PHHBWHPmgva61jtUuHaJBuR0WqYbBRLCyY2vH9AWcpREqs9shBkA5MEau4CtZAWWgL99awvmjXdtH6KxvqWBcLunlhN5fHHH+/69lnQKzwIS0VYbaT1RbSBTIzVpBUecKY0Vstm79MGP7F9EqjNq+g2rTmsDVBTmD3fmvdac9U9sc/dahgtNBf+DAuzPpQ22I711QMAAAgnA9omu+s/VuQPbhfuameNXg1kA7HYSboNjGEDilgtmIU2G6XRmlJaDZeNVmlNJq02y1gN4J9//uketxot66tmQc1ql4xtY8yYMerXr587wbdmhRbSrD9b8T5dFv6s+aFN3F64KWVZylGaF1980TUVtIBi5bN+YzZ4TKDfmbGml9aE1d6/DVRi78dG6CwLa6ppQdHKZKF2X9iUEVYjaFMW2Nx71r/QRjItCwt39nyrtbMBWvZlm1aDZ9NaWC2hBTbbpk0TYTWkjz76aJF1LeBaiLd+njZiq/Xts/1hfflKaxZqSqthBQAAqMkGtkzQ0qnzlbhgmnRsya2bwglBLwRZ7VNJg2U8/PDD+vbbb11YsxEkbV69K6+80s1fZyNeWmArPged1dDZXHh2km/99WxEzMBJvtUUWlNMqyWz5oO2TQt8JYUA6w9mYc6mAyhub+WwAGjlKM76A1pNoL2+1VTZ9AkWeApPHWBBaOHCha4WywZ0scctDFrt197YQChWO2XhqaRBRYpPmL6n+1a7aFNKWG2iDSRjc+HZfHw2IErhAW5KmoTdymHh2ebUs30cUNZtFmb9Gb/77jvXnNUCtdUI2gTxNi1GYRb6AseQvY599hYoi/fJDKxrU2OUxprs7q22EAAAINQNqr9Tp8Tco6zUKGVm3KjYuJLPt8KFx2/VPDWYDWhhNTZ2olz8JNZGfrQ+ZzZwSOGRJRHerFbSjgtrHmphFlWnpvwfs0BstddWo2nzGwIcF+C7Avz9qH38Pp+23d1G9ZWm+cd+pG6Dhte4c4pA9klNTd3raOucBQMAAAAIex6vVyvq9HK3Uxb+onBH0AMAAABQK2Q1y++GFLtuqsIdQQ8AAABArZDcNX/u57bpc1xTznBG0AMAAABQK7TrOVRZ/iglK02rFs9SOCPoAQAAAKgVomPjtDS6s7u9Yc7PCmdMrwAAAACg1vij89X6958b1SPvABWdFCu8UKMHAAAAoNZo1nOYZvvba8rK7QpnBD0AAAAAtUb/Nsnueummndq6M1vhiqCHIn766SfNmlU1HVN//fVX/fnnnyFZtqqUkpKi9957T9nZ4ftFAgAAUFPUi4/W+clz9GDkS1o69VuFK4JeiMrJydHkyZP1xRdfaM6cOfL7/ZX+Gr/88oumT59eZNm9996rd955p0q2/eijj+rVV1+t8DYrq2zVbfny5TrrrLOUlpZW5uds27bNhUM7DgAAAFC5RsTO0pmRPyln4fdhu2sZjCUETZw4UWeeeaZiYmLUrVs3rVixwi3/z3/+o6FDh1ba6zz00EPq2LGj+vbtW2nb3NO2DzroINWvX1+1TXJyskaOHOk+z7JasmSJC4cW+OrVq1el5QMAAKh1Wu8vbftK9Tb/oXBF0CuDPJ9fU5Zt1cbtmWqcGKtB7eorwuupsg/lvPPO0+GHH65XXnlFHk/+68yfP19r1qxxt2fPnq21a9fqqKOOKvK8mTNnav369W65NXO0UNWmTRtXs5aXl6f9999fderUcetabaFtw+fzuZojc9xxxxVsKzU1tcTnBVgN4x9//KHVq1erffv22m+//QoeK23bgwcPVnx8/G7bsddZtWqVevbsqQ4dOpRrX1mNpwUpC5Fmy5Yt+v333125DzzwQDVs2NAtt7J8+OGHblmLFi0Knm/rffTRR7stN5s3b9a4ceN0+umnu/2/dOlSF7w7depUYq3djBkzVLduXR1wwAGKjY0teCwpKUknnXRSQdALbPeMM87QwoULXaizbXbp0sU9vnPnTn3/ff6vS5988onbZ/Y5DhkyRBkZGW7/2nX//v3VuHHjcu0vAAAASE17HiLNlNpnL1JWZrpiYoueo4YDgt5efDtnne76cp7WpWYWLGuWFKs7ju+uo3s2q/QPJDMz053433nnnQUhz1jAsEsgzIwYMcKFrCZNmhSsc8kll+jggw92Qc+aOdq2LPhZgFi8eLFrBmi1hfYc6yu3YcMGFyo+++wz93x7bqAvnYWIkp5n7HknnniiCyzdu3d3/eas9s62k5CQUOq2relmy5Yt1a9fP7ds3bp1Ovnkk7Vs2TL3evZaFqruu+++ve4nC2iXXnqpK+vYsWPdsueff16jRo3SgAEDlJubq4suukgvvviiC1Rer9c9/ttvv+npp58u2M63336r888/3wXT4hYsWOBq1d58800XRO392+vdfffd+ve//12w3q233qonn3zSBTz7THbs2KGvv/66IPwGmm5u2rTJBc/Adq0ZqoV32+4PP/ygu+66SzfddJPS09P188/587rYdqKioty2ExMT3Q8ArVu3VtOmTV2T3ptvvln/+Mc/ynWMAQAA1HatOvTUVtVVfU+aFsz6TV0HDVe4oY/eXkLev976s0jIM+tTM91ye7yyWU1Q79699eCDD2rMmDEuLBU3bNgwtWvXTv/9738LltlJ/7Rp0/S3v/2tYNlff/3l+spZWLDHbdvPPfece+xf//qXa1Z5zDHHuFo3uzRv3nyvzzP2Gj169HDrWY2a1UpZqLRwubdtF3bBBRcoIiJCixYtcu/VtmO1fntjr3Xqqae6GjQLXlbbZbVcFpLsvtWGWcC0gGbh1wKWsWD49ttvKysrq2Bb1mfQQmuDBg1KfT17zMKs1cLZe7FgZ2U2FhwfeOABfffddy5wzp07170He6299au0z9lqRe29W+3tHXfc4WrqGjVqVBB2bbm95lVXXaWnnnrKffZTp07Vl19+6faXBWcAAACUj8fr1Yr4Xu52ysJfwnL3EfT20FzTavJKOlUPLLPHbb3K9umnn7qmfKeccoprCmg1YPfff78LOAEXX3yxXnvttYL7FggsYFgAC7Dmgs2a5dc6Wq2Q9e+zcLA3e3rexo0bXTCx8lmzQmsO+fnnn7vg+eOPP5b5PVptngWj22+/3b1HYzWYJ5xwwh6fZwOaHH300W4kS2ueGmi6+MYbb7haRastszLZPrSaNauNtABsLBxa+LLyGquR/Oqrr4qE45LccMMNBbWrtm+sqaq9d2MhzJqNWtNPYzWHVqs4ZcoUV1O5JxaIAyzAWQAN9McsSVxcnKsBtBpdEx0dXaS5LQAAAMous1n+dOkx66aG5W6j6WYprE9e8Zq8wize2eO23pAOpdcGVYSFJgsq1oTPmkFa80Kr4bHwEGgKeeGFF+q2227TpEmTXLNHq6kK1KgFFB/4xPqIBWq39mRPz7NmiMaaclqNWmFlqY0LWLlypbvu3LmzyuP11193/e2sNjEQEAPlsn6F1t/OwpwFPAupVlsX6F9oNZPnnHOOq8Wz5pxWI2pB8cgjj9zja7Zt23a3zycQyOzagl9hgX6GJT1W2n4O9N8rHOaLu+WWW1wNZaD5qwXeyy+/vFYOcAMAALCvkrseJC15Ukrf6s4fC3ebCgcEvVLYwCuVuV5F2CAcVlNkFxtw5MYbb3RNOS24WL+u448/3oUWq+Wx5TZSZ1ULhCtrJmn9xioqMJKk1U5ZcCqrf/7zn67Z5LHHHutqEK2ZY6BcFrCshs2CoNX82TKrYSvMmlRas1LrS2c1otZ8tPg6xdnIlzagSuH7gUFe7DpQwxawdevWgscqk/XLsxpIC7QTJkzQww8/rHfffVfz5s2r1NcBAACoDdrtd6AGf/6SNuQm6IfNO9W+UYLCCU03S2Gja1bmemVlISVQ21WY1fRYjVThIfqtduf999930y6cdtppRWq4ysIGTtlTDVJJbIAWq+F64YUXdnssMCpoWbZtNXnWt8760RW2txpHa6748ccfu3B42GGHFaxvtVvWlNOabhZmzTMLT1RuA6RYDeiVV17p+h/agC17E6hFDdQcWi1rYJoLC+EWOC38BVjTUaspLG9tZWG2/0zhfRjYvxY6LeRbc14bDbQ88/MBAAAgX0xMrFq1aOVuT1vxv3O5cEGNXilsCgUbXdMGXimpF55V7DZNyp9qoTLZaJIWYKxp3qBBg9xAIDZtggUra7oXGfm/j8zCjZ30W9CwkFNeNjqljRY5evRoFyzK0t/LqrStFtGChtUs2XMs5Fi/PRt8xUaBLMu2bTsvvfSSa1ppNWLWR836AdrFBhopS9izPoy2r2zESpuSwvrNWX85C3FWY2ijeH7zzTcumNlzCtfq/f3vf3evWZbpHB555BEXGK1GzUbsPOSQQwqmtrAaQftsbFs2+qWF9CeeeEIvv/xyuebNK87CtH321ofx0EMPdfdtf1ltoY28aaHf7luz0/IGfAAAAOTr3zbZhbw/lm3VGQPyQ1+4oEavFDZPnk2hYIq31g3ct8crez4961dmYceaYdoUBTb6pTXVtCBnJ/1FPjyv1wUuCyuBqRECLBzYqI6FWU1WYL45YyM5WjCz/nZWa7V9+/YyPc/WseaCFuZs1EkbGMVqlwIhr7Rt2zZsWwEWUizEWoixue+s79kHH3xQ6r4pXLZA2LOgZ6HKRu+017HQZQO92GiWVqNmIc+mJSjMBlQxexuEJcBG8rRgZdu0gFg4iNrr2mdjg+NYH0prQmujc9qUDaVNmG7NTe2+PTfAHrNltq6x17PtWEi217ORNq2pqdXi2vQb9r6sGWtgYBkAAACU38H1U/V21H26aP7FYbf7PP69jQEf4qzZmtVqWY1L8SHyrdmbjXxozfwKT2AdyvPolYd9dDb6pZ38Fw5Ztd2e+ugZay56zTXXuKaQNpLlngKehVOb8qCix0+4q4z/Y9XBBuexWmfr22k/pgAcF+C7Avz9gNm2eb2Sn+3ibqdcsVD1GjZVKJ9TBLKPtazbW6summ7uhYW54d2butE1beAV65NnzTUruyavvGz+OjvI7EO2mh3s3dKlS13tm01Gf9111+0x5AEAACD8JTdsqhXelmrjW63lM35UnyPOUrgg6JWBhbrKnkJhX9kE3VajZ5ODB0awxJ7ZdAfjx493ffgs6O1NSU0sAQAAEF42JPVWm22rlbHkd4mgh2CzkTZRPtbHzy7lGWHUpmsAAABAGGu1v7Tta9Xb/IfCCYOxAAAAAKi1mvbMH9SwXfZfys6qujmyqxtBDwAAAECt1arjftqmRMV6crR87iSFi1rRR6+GDywKhCz+bwEAgJrO4/Vqfp3BykrbpO3r0tRZ4SGsa/QCg2hkZ2cHuyhAWAr832LAGgAAUJNNH/CQLsq5Sd+ltFS4COsavcjISMXHx2vTpk1unouS5lRDeM6jZwHE5njjM6/a/Wz/t+z/mP1fAwAAqKn6t0l219NWbHUtljye4E6lVhnC+uzMPqBmzZq5CZ1taH3UDvaf0yY5t3nywuE/aSizIN26dWv2MwAAqNF6t6znplTzp63Xuk2b1bxxI9V0IRH0Vq1apQ0bNqhz5857neG9vKKjo9WpUyeab9YiOTk5mjBhgg4++GBXk4uqY/+/qDUFAAA1XVx0hN6q85SUmaoPvpYGH3yMBrWr78JfTRXUoGdN68455xx98803atOmjat1e+ihh9yE1pXJTkRjY2MrdZsIXdZfLDc3133mBD0AAADszbdz1umW9Eu0NS9eWihp4SQ1S4rVHcd319E9m6kmCmqntbvuuktTpkzRkiVLNH/+fL3zzju66qqrNHny5GAWCwAAAEAtCnn/eutPbc2LK7J8fWqmW26P10RBDXqvvfaaLrnkEtePzpx00knq2bOnWw4AAAAAVSnP59ddX85T/mRsRZtpBiZos8dtvZomaE03165d6/rl9e/fv8jyQYMGafr06aU+Lysry10CUlNT3fXWrVursLSoaX300tPTtWXLFppugmMCfFeAvx/gnAKlmrYyVetSM0t93OKdPT5u5jINaJ0U9PPM7du3l3me8KAFvUAwa9CgQZHldn9Poe2BBx5wTT6Ls4FcAAAAAKCs4rsdrEYn/Huv651yzkVKnz9BocICX1JSUmgGvUACtgFZCrNh8W0kv9KMGjVK1113XcH9lJQUN5DLypUr9/pmUTukpaWpVatWbjTXyh7FFTUTxwQ4LsB3Bfj7gX1yy0EhcU5hNXkW8po3b77XdYMW9GwH2WiYa9asKbLc7tu8XKWJiYlxl+Is5HFSj8LseOCYAMcE9obvCnBMgO8J1KS/HWWt3AraYCzx8fE64IAD9MUXXxQs27lzp8aNG6fhw4cHq1gAAAAAUOMFdR69e++914U6a445ZMgQPfPMM2rcuLH+/ve/B7NYAAAAAFCjBXV6hUMOOUQ//vijmyj9qaeeUo8ePfTrr78qISGhzNuwZpx33HFHic05UTtxTIBjAnxXgL8f4JwCtf080+Mvy9icAAAAAIAaI6g1egAAAACAykfQAwAAAIAwQ9ADAAAAgDAT1FE399WWLVu0dOlSNydf06ZNg10cBMH69eu1ePFi9erVq9Q5RVavXu3W69SpU5nnHUHNZXNxbt68WR06dCh1YKfU1FQtWrRITZo0cd8fCG+ZmZlauHChEhMT1bZtWzeHa3G5ubmaO3euIiMj1b17d3k8nqCUFdVr06ZN7tiw46Jly5a7PW7nGNu2bVPXrl1Vp04dPp4wtXHjRv3111+7LbdpwIp/X3DuWTu/J1atWuW+B2x6uOKys7M1Z84c9x3RpUsXhRR/DXX77bf7Y2Ji/N27d3fXF198sT8vLy/YxUI1+eOPP/ynnXaav3HjxjaYkH/s2LG7rZOZmenWiYuL83fr1s0fGxvrf+KJJ/iMwtQ333zj7927t7958+b+/fbbzx8fH++/+eabd1vv6aefLjgm7PqUU05xxwrCT0ZGhv+6667zN2jQwN+3b19/kyZN/J06dfL/9ttvRdabPHmyv2XLlv5WrVq5dTp37uyfP39+0MqN6pGdne0fPHiw3+v1+h944IEij6WkpPgPPfRQf2Jiojse7Prtt9/mowlTr732mj86Oto/dOjQIpf09PQi63HuWbukpaX5Tz/9dH+dOnX8AwYM8Ldu3dodK4V99913/oYNG/rbtWvnr1+/vvtbs3r1an+oqJFB77PPPvNHRUUV/LFesGCBPykpyf/UU08Fu2ioJm+++ab//fff969cubLUoHfbbbe5k/7Af7gvv/zSrVv8JA/h4T//+Y9/5syZBfcnTpzofgR64403CpZNmjTJ7/F4/F988YW7v2bNGneMjBo1KihlRtVav369/4UXXvBnZWW5+7m5uf7zzjvP/bEOsJBvIe/vf/+7u28/GJ5wwgnuxwKEtxtvvNF/wQUXuHBfPOhdeOGF7odkC3zm+eefd+cdixcvDlJpUZXs5L1FixZ7XIdzz9rn6KOPdj8gb9iwwd234P/qq68WPL5lyxaXP+wHgMDfE/uBYPjw4f5QUSODnv0Rtp1f2CWXXOI+DNQu69atKzXo2Qm8hb3C+vTp42p/UTvsv//+/ksvvbTgvp3M2zFQmB0jdqKH2uGll15yPwAEWoBY6LfvkFWrVhX5QcCWTZ06NYglRVX69ttv/R06dHC/2BcPenYyZy1A7EeCADtebL077riDDyZMg16zZs38s2fP9s+ZM6fgx6HCOPesXX777Tf3d2DChAl7/Hti3xXbt28v8oOAPc8qIkJBjRyMZfr06erfv3+RZYMGDXLtY3NycoJWLoRWe/u1a9eWeJzY8YPwt337dtf3pmPHjnv97tiwYYPWrVsXhFKiOixYsEATJkzQ66+/rvvvv1933XVXQb8bOyasr2bh/lkDBgxwffT4rghP9v/9b3/7m958803Xb7O4+fPnu36dhb8r7Hix+xwT4cv+Bpx66qkaMWKE6tevryeeeKLI45x71i7jx49XvXr1dOCBB7o+/ZYx7Huh+DFhffIKjwdg5xRmxowZCgU1cjCWrVu3qkGDBkWW2f28vDylpaXt9hhqHztGTEnHSeAxhLd//etfio2N1cUXX7zX747AY82aNav2cqLqvf322xo3bpyWLFmizp0768QTT9zjMREREeH+wPNdEX6sJdN5552nSy+91A20Ud6/H8uWLauWcqJ62WBtdiLfo0cPd/+DDz7QmWee6QbpOfnkk90yzj1rl7Vr16px48Y64YQT3I8/NlCXDez35JNP6sILLyzTOUUoqJE1elFRUbul6oyMDHcdHR0dpFIh1I4RU9JxwjES/m688UZ99dVX+uKLL4p8CfPdUTvdc889mjhxohuR1UboPfTQQ7Vz585Sjwljy/iuCD8vv/yy5s2bp2HDhunXX391F2sJtGLFCk2ePNmtw9+P2mfo0KEFIc+cccYZOuyww/Tee+8VLOPvR+0SFRXlRmK1H4RsdHdrGfLAAw+4H4mstVBNySM1Mui1adPG/cEuzO7bL7AlNcNA7dOiRQv3q3xJx0nr1q2DVi5UvVGjRumll17Sd99955rgleW7w5pllTS0OsKL/VG+5ppr3K+ygSZ4dkxYUz5rERJgv8TaH2u+K8KPNcm1WprbbrtNN998s7tYM+9vvvnG/SAQOCYMfz9qN2vSXfgY4Nyzdmnbtq27/uc//1mw7JJLLnGtAuyHwz0dEyZU/n7UyKA3fPhwjRkzpsgf5s8//9wtB4w12TvooINcjU6AnbiNHTuW4ySM3XLLLXruuedcyBs8ePBuj9t3hDXhS09PL/LdYb/mxsXFVXNpUdUCtXaF2S+zJlDTe8QRR7j1rD9G4WPCQuEhhxzChxRm7Nf4QE1e4GL9sexkzloBBE7wrG9v4b8f1n9rypQp/P2oJd8Vdr5gx0bPnj0LlnHuWbsceeSR7rpwkLMfCS17NGrUqOCYsNYAs2bNKvL3wyqeBg4cqJDgr4HWrl3r5k+zOdJsxLR//OMfbs4sGy0JtcPGjRv9v/zyi//zzz93oxvZ/Hh2f8WKFQXr/Prrr244bBtC29Y78sgj/W3btvWnpqYGteyoGvfdd5+bOuHRRx91x0LgMnfu3IJ1bIS99u3bu2PBjombbrrJHxkZ6f/555/5WMLQK6+84uZJtOlYvv/+e/c9YSMnjhw5ssh6F110kZti4a233vKPHj3aX69ePf8tt9wStHKjepU0vcJHH33kvhvse+WTTz7xDxo0yN+vXz9/Tk4OH08YOvbYY/233nqrm4bJpm6yIfLtPHPp0qUF63DuWftcdNFFbqqdDz/80P/pp58WfA8UHpX1mGOO8Xft2tX/wQcf+J955hk3CqfN1xsqPPaPaiDrEP3www+7drJWPXrttdeqd+/ewS4Wqsn333+vu+++e7flF1xwgfvFNsCq15999ln3K4z9MmfNdBhwIzxddtllRX5VC7Dauoceeqjgvh0LDz74oGbPnu2a5lx++eVuHYQnq8V/9913tXr1atek+/jjj3eDK1gTvoDc3Fz3PfHtt9+6DvcnnXSSG8Sn8DoIXzY4j/XJOuecc4ost5YBo0eP1rZt29yv8zfddJP7pR7hx1p5vPDCC/r5559dtw87n7zqqquUnJxcZD3OPWuX3Nxcvfjii/r666/d3wZrKXT11VcXGWXTan8ff/xxd+zEx8frrLPO0siRIxUqamzQAwAAAACEUR89AAAAAEDpCHoAAAAAEGYIegAAAAAQZgh6AAAAABBmCHoAAAAAEGYIegAAAAAQZgh6AAAAABBmIoNdAAAASmOTmHfo0EGdOnUq80768ssv1aNHD7Vv3z6oOzZUylGaDz74QD6fTzExMW4S+fJ+LikpKe72Kaecoujo6CoqJQCgoqjRAwCU23fffaf33ntPa9as2e2xadOmucdmzZq1z3v2hhtucK9VHldeeaV++OEHBVvxcnzxxRdatmyZQsXZZ5+tF154Qd98840LfO+//74WLVpU4rpbtmxxn+nWrVvd/fHjx+v111/XWWedpbS0tGouOQCgLAh6AIByu+mmm9xJ/kMPPVRkud/vd8vt8s4777BnC7nsssv0888/h9Q+ufnmm/XSSy/J6/Xq+eefd59rSSwQXnHFFapTp467/8gjj+jBBx+s5tICAMqDppsAgAo5+OCD9fbbb7uTfmv+ZyzIbN++XV26dNltfVv++++/KysrS4MHD1aTJk12W2fDhg2aNGmSmjdvrt69e+/2uNUqHXrooUWeO2bMGNe0c0/NO7Ozs912U1NT1b17d9cctDQTJkxQbGysBg0aVGS5vTdbbmUv6/sJsFrJjIwMTZ482W0jIiJCp59+usaNG6fNmzfL4/GoWbNm6tu3rxITE3d7/vr1691zA/vFagqLN2ktz3ssycUXX+wuGzduVOPGjYuE99dee03nnntuwecMAAh91OgBACpkyJAhatq0qT799NOCZaNHj9YFF1ygyMiivyNaU7/WrVvr1ltv1eOPP6527dq5WqLCvv76a9efzWqKrrvuOheetm3bVmQdqymcPXt2kWW27p6ad86YMUOdO3fWNddc42qv9t9/f/3zn/8sdf2JEye6Zo2FWYiyfmxz584t8/sp7Mcff3RB788//9Rnn33m+u8FwqPd/+STT3T99derY8eO+vXXX4s81/avbd/2i61j5bdAVvg9l/c9luS0005zNXb//e9/iyz/6aeftGTJEl1yySXl2h4AIMj8AACUU+/evf033XST/9FHH/UPHz7cLdu2bZs/Li7Ov2DBAn+PHj3c4yYjI8PfqlUr/w033FDw/Ndff90fExPjX7p0acE6LVq08N9xxx0F6zzyyCN++zP1zDPPFCyz+2PHji1Sli5duhRZp02bNv6XX37Z3c7Ozva3bdvW/8QTTxQ8vnHjRn+zZs387777bonvbeXKlX6Px+OfNGlSwbJPP/3UHxsb609NTS3T+yleDmPv77XXXtvjfr3vvvv8PXv2LLifnp7ub9q0aZH9Yu+l8H6pyHs0ERER/m+++abIsssuu8zfvXv3IsvOOecc/+DBg3d7/vTp0105Nm3atMf3BAAIDmr0AAAVdv7557umjitWrNBbb72l/v3779Zs87ffftOqVas0atSoIs+z5oGB2kCrxVq7dq2rsSo8mElcXNw+fTpWk2Zls9f66KOP9OGHH7pl1qzRrkvSqlWrgmapAXb7+OOPV926dcv0fspj5cqVrnbOBkOJiorSnDlzlJ6eXrBfrDlr4f1iff3i4+P36T2WxmoK582b55qAGmsGarWNthwAULPQRw8AUGGNGjXScccd50ZgtCaIV1999W7rWAipV6+e6tevX7DM+qRZM017LBB2GjRoUKR/mvUHsz5p+2L58uVu6H8b8bKwFi1auKaOpTnnnHN02223uWaZFrq++uorF8TK+n7KysKs9X8bOHCgGjZs6Jp3mk2bNqlNmzYuUBbfL/Z+Cu+Xir7HkvTr18/1E3z11Vdd808bUMcGajnzzDPLtR0AQPAR9AAA+8Rqe6xPmw3RbwOMFGcBxgYuyc3NLdJ3z4bqt8eMhRkbpt+2YcEioHgfPQtUtk5hmZmZpZbNauCsf531HUxISCjze7L3YSHMBktZt26d67t2zDHHlPn9lIX11/vPf/7jpjQIDJxiNWnWVzG/lapcmNzbfqnoe9zT53nLLbfoySef1CuvvKIzzjijxAFiAAChjaabAIB9ctRRR7mBSu6+++6C4fcLs9oqC0Sff/55wbIFCxa4gU0OPPDAgnUCI2gG2EAlgXnbCtdSLV68uOC+DRJitV6lGTZsmKvtsgFKCsvLy3NNIktjNXbHHnusa7JpFws71qyyrO+nJBbCCodSG0nTmqZazV2ANb0szF7LQp9NUB5gTUdtXrt9fY97qs3MyclxNZp//PEHg7AAQA1FjR4AYJ/YVAHW/LA0Nm2A1RBddNFFLhBZ7dBjjz2mk046yU2VYKwp4rXXXqvzzjvPze1mQeqpp57arYbK+sLdeeedLohYALJarD3147NRQa1mymrn7LVtJM/Vq1fr448/1v33368RI0aU+lybTsDKY+HMQmx53k9JBgwY4JpEWv86K/MRRxzh3p+FSCuHTZ9g/euKB9urrrrKlcPmuLP98vTTT7vnWe3mvr7H0kLuqaeeqieeeELdunXTAQccUK7nAwBCA0EPAFBuRx99dInz3AVYM8fCj99+++2u75c1S7RmhnfccYcLbYU98MADbv43G0DEwpT1i7Oh/gv3M7vnnntcXzhr4mgBx8KM1WQVXscGTSk8h5xNM2Dhx/rY2cAx9nwLVCXN9VeY9T20mkoLZcXDTlneT/FyWEB77rnn3NQMFlKteai9D5uo3KYwsPJY+e69994iNaMPP/ywevbs6Wo4bb9YXzyrRS3cnLKi79G2af0C7X0WZuHSwvQpp5xS4vOshnHmzJl73DYAILg8NvRmkMsAAABKYc1XCw/8YnPmWci0+QQtAFaUNdG05p3Wx694s8+9ufHGGwuazL788sv04QOAEETQAwAghNlE7D/88INr6rl582ZXM3jYYYe5ETEBACgNQQ8AgBBn8/NZk0/rDzl06FDXrw8AgD0h6AEAAABAmGF6BQAAAAAIMwQ9AAAAAAgzBD0AAAAACDMEPQAAAAAIMwQ9AAAAAAgzBD0AAAAACDMEPQAAAAAIMwQ9AAAAAAgzBD0AAAAAUHj5f9YGtaZfhBHgAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ---------------------------------------------------------------------\n", + "# 1. Assume a known SDM parameter set at STC\n", + "# ---------------------------------------------------------------------\n", + "known = {\n", + " \"Name\": \"Canadian Solar CS5P-220M\",\n", + " \"N_s\": 96,\n", + " \"alpha_sc\": 0.004539, # A/K\n", + " \"beta_voc\": -0.22216, # V/K\n", + " \"a_ref\": 2.6373, # n * Ns * Vth [V]\n", + " \"I_L_ref\": 5.114, # A\n", + " \"I_o_ref\": 8.196e-10, # A\n", + " \"R_s\": 1.065, # ohm\n", + " \"R_sh_ref\": 381.68, # ohm\n", + " \"temp_ref\": 25.0, # degC\n", + " \"irrad_ref\": 1000.0, # W/m2\n", + "}\n", + "\n", + "# Convert pvlib a_ref to Villalva's dimensionless diode ideality factor.\n", + "T_ref_K = known[\"temp_ref\"] + 273.15\n", + "\n", + "diode_factor_known = (\n", + " known[\"a_ref\"]\n", + " / (\n", + " known[\"N_s\"]\n", + " * constants.k\n", + " * T_ref_K\n", + " / constants.e\n", + " )\n", + ")\n", + "\n", + "\n", + "# ---------------------------------------------------------------------\n", + "# 2. Generate synthetic Isc, Voc, Imp, Vmp and Pmp with pvlib\n", + "# ---------------------------------------------------------------------\n", + "synthetic = pvsystem.singlediode(\n", + " photocurrent=known[\"I_L_ref\"],\n", + " saturation_current=known[\"I_o_ref\"],\n", + " resistance_series=known[\"R_s\"],\n", + " resistance_shunt=known[\"R_sh_ref\"],\n", + " nNsVth=known[\"a_ref\"],\n", + " method=\"lambertw\",\n", + ")\n", + "\n", + "synthetic_points = {\n", + " key: float(np.asarray(synthetic[key]))\n", + " for key in [\"i_sc\", \"v_oc\", \"i_mp\", \"v_mp\", \"p_mp\"]\n", + "}\n", + "\n", + "print(\"Synthetic STC key points\")\n", + "display(pd.Series(synthetic_points))\n", + "\n", + "\n", + "# ---------------------------------------------------------------------\n", + "# 3. Apply the basic Villalva algorithm to the synthetic key points\n", + "# ---------------------------------------------------------------------\n", + "recovered, recovery_history = fit_villalva(\n", + " v_mp=synthetic_points[\"v_mp\"],\n", + " i_mp=synthetic_points[\"i_mp\"],\n", + " v_oc=synthetic_points[\"v_oc\"],\n", + " i_sc=synthetic_points[\"i_sc\"],\n", + " alpha_sc=known[\"alpha_sc\"],\n", + " beta_voc=known[\"beta_voc\"],\n", + " cells_in_series=known[\"N_s\"],\n", + " diode_factor=diode_factor_known,\n", + " temp_ref=known[\"temp_ref\"],\n", + " irrad_ref=known[\"irrad_ref\"],\n", + " rs_step=1e-4,\n", + " rs_max=1.5,\n", + ")\n", + "\n", + "\n", + "# ---------------------------------------------------------------------\n", + "# 4. Compare original and recovered SDM parameters\n", + "# ---------------------------------------------------------------------\n", + "parameter_names = [\n", + " \"I_L_ref\",\n", + " \"I_o_ref\",\n", + " \"R_s\",\n", + " \"R_sh_ref\",\n", + " \"a_ref\",\n", + "]\n", + "\n", + "recovery_table = pd.DataFrame(\n", + " {\n", + " \"Starting value\": [\n", + " known[name] for name in parameter_names\n", + " ],\n", + " \"Recovered value\": [\n", + " recovered[name] for name in parameter_names\n", + " ],\n", + " },\n", + " index=parameter_names,\n", + ")\n", + "\n", + "recovery_table[\"Absolute error\"] = (\n", + " recovery_table[\"Recovered value\"]\n", + " - recovery_table[\"Starting value\"]\n", + ")\n", + "\n", + "recovery_table[\"Relative error [%]\"] = (\n", + " 100\n", + " * recovery_table[\"Absolute error\"]\n", + " / recovery_table[\"Starting value\"]\n", + ")\n", + "\n", + "print(\n", + " f\"Known Villalva diode ideality factor: \"\n", + " f\"{diode_factor_known:.9f}\"\n", + ")\n", + "display(recovery_table)\n", + "\n", + "\n", + "# ---------------------------------------------------------------------\n", + "# 5. Compare the complete original and recovered I-V curves\n", + "# ---------------------------------------------------------------------\n", + "v_validation = np.linspace(\n", + " 0.0,\n", + " synthetic_points[\"v_oc\"],\n", + " 300,\n", + ")\n", + "\n", + "i_original = pvsystem.i_from_v(\n", + " voltage=v_validation,\n", + " photocurrent=known[\"I_L_ref\"],\n", + " saturation_current=known[\"I_o_ref\"],\n", + " resistance_series=known[\"R_s\"],\n", + " resistance_shunt=known[\"R_sh_ref\"],\n", + " nNsVth=known[\"a_ref\"],\n", + " method=\"lambertw\",\n", + ")\n", + "\n", + "i_recovered = pvsystem.i_from_v(\n", + " voltage=v_validation,\n", + " photocurrent=recovered[\"I_L_ref\"],\n", + " saturation_current=recovered[\"I_o_ref\"],\n", + " resistance_series=recovered[\"R_s\"],\n", + " resistance_shunt=recovered[\"R_sh_ref\"],\n", + " nNsVth=recovered[\"a_ref\"],\n", + " method=\"lambertw\",\n", + ")\n", + "\n", + "plt.figure(figsize=(9, 6))\n", + "\n", + "plt.plot(\n", + " v_validation,\n", + " i_original,\n", + " label=\"Starting SDM\",\n", + ")\n", + "\n", + "plt.plot(\n", + " v_validation,\n", + " i_recovered,\n", + " linestyle=\"--\",\n", + " label=\"Recovered Villalva SDM\",\n", + ")\n", + "\n", + "plt.scatter(\n", + " [\n", + " 0.0,\n", + " synthetic_points[\"v_mp\"],\n", + " synthetic_points[\"v_oc\"],\n", + " ],\n", + " [\n", + " synthetic_points[\"i_sc\"],\n", + " synthetic_points[\"i_mp\"],\n", + " 0.0,\n", + " ],\n", + " label=\"Synthetic key points\",\n", + " zorder=3,\n", + ")\n", + "\n", + "plt.xlabel(\"Module voltage [V]\")\n", + "plt.ylabel(\"Module current [A]\")\n", + "plt.title(\"Villalva parameter-recovery validation\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.grid(True)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b0a09dea", + "metadata": {}, + "source": [ + "# I–V curves under operating conditions\n", + "\n", + "The workflow is intentionally parallel to pvlib's De Soto gallery example:\n", + "\n", + "1. use `calcparams_villalva` to calculate the five SDM parameters for each\n", + " irradiance and cell temperature;\n", + "2. use `pvsystem.singlediode` and `pvsystem.i_from_v` to solve the I–V curves.\n", + "\n", + "The same operating-condition cases used in the De Soto example are used here." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "009795d1", + "metadata": {}, + "outputs": [], + "source": [ + "cases = [\n", + " (1000, 55),\n", + " (800, 55),\n", + " (600, 55),\n", + " (400, 25),\n", + " (400, 40),\n", + " (400, 55),\n", + "]\n", + "\n", + "conditions = pd.DataFrame(\n", + " cases,\n", + " columns=[\"Geff\", \"Tcell\"],\n", + ")\n", + "\n", + "IL, I0, Rs, Rsh, nNsVth = calcparams_villalva(\n", + " effective_irradiance=conditions[\"Geff\"],\n", + " temp_cell=conditions[\"Tcell\"],\n", + " alpha_sc=params[\"alpha_sc\"],\n", + " beta_voc=params[\"beta_voc\"],\n", + " a_ref=params[\"a_ref\"],\n", + " I_L_ref=params[\"I_L_ref\"],\n", + " R_sh_ref=params[\"R_sh_ref\"],\n", + " R_s=params[\"R_s\"],\n", + " i_sc_ref=params[\"i_sc_ref\"],\n", + " v_oc_ref=params[\"v_oc_ref\"],\n", + " irrad_ref=params[\"irrad_ref\"],\n", + " temp_ref=params[\"temp_ref\"],\n", + ")\n", + "\n", + "SDE_params = {\n", + " \"photocurrent\": IL,\n", + " \"saturation_current\": I0,\n", + " \"resistance_series\": Rs,\n", + " \"resistance_shunt\": Rsh,\n", + " \"nNsVth\": nNsVth,\n", + "}\n", + "\n", + "curve_info = pvsystem.singlediode(\n", + " method=\"lambertw\",\n", + " **SDE_params,\n", + ")\n", + "\n", + "v = pd.DataFrame(\n", + " np.linspace(\n", + " 0.0,\n", + " curve_info[\"v_oc\"],\n", + " 100,\n", + " )\n", + ")\n", + "\n", + "i = pd.DataFrame(\n", + " pvsystem.i_from_v(\n", + " voltage=v,\n", + " method=\"lambertw\",\n", + " **SDE_params,\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "200d5984", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(9, 6))\n", + "\n", + "for idx, case in conditions.iterrows():\n", + "\n", + " label = (\n", + " \"$G_{eff}$ \"\n", + " + f\"{case['Geff']:.0f} W/m$^2$\\n\"\n", + " \"$T_{cell}$ \"\n", + " + f\"{case['Tcell']:.0f} °C\"\n", + " )\n", + "\n", + " plt.plot(\n", + " v[idx],\n", + " i[idx],\n", + " label=label,\n", + " )\n", + "\n", + " plt.plot(\n", + " [curve_info[\"v_mp\"][idx]],\n", + " [curve_info[\"i_mp\"][idx]],\n", + " linestyle=\"\",\n", + " marker=\"o\",\n", + " )\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "plt.xlabel(\"Module voltage [V]\")\n", + "plt.ylabel(\"Module current [A]\")\n", + "plt.title(module[\"Name\"])\n", + "\n", + "plt.legend(\n", + " loc=\"center left\",\n", + " bbox_to_anchor=(1.0, 0.5),\n", + ")\n", + "\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "ce104370", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Geff [W/m2]Tcell [degC]i_sc [A]v_oc [V]i_mp [A]v_mp [V]p_mp [W]
010005514.55792451.16174213.55933541.829649567.182223
18005511.64633950.65850210.81220141.862314452.623757
2600558.73475450.0056438.05963341.748936336.481106
3400255.74400053.5869215.25182946.077520241.991255
4400405.78358551.3307455.27910743.707762230.737973
5400555.82317049.0748535.30328741.358770219.337433
\n", + "
" + ], + "text/plain": [ + " Geff [W/m2] Tcell [degC] i_sc [A] v_oc [V] i_mp [A] v_mp [V] \\\n", + "0 1000 55 14.557924 51.161742 13.559335 41.829649 \n", + "1 800 55 11.646339 50.658502 10.812201 41.862314 \n", + "2 600 55 8.734754 50.005643 8.059633 41.748936 \n", + "3 400 25 5.744000 53.586921 5.251829 46.077520 \n", + "4 400 40 5.783585 51.330745 5.279107 43.707762 \n", + "5 400 55 5.823170 49.074853 5.303287 41.358770 \n", + "\n", + " p_mp [W] \n", + "0 567.182223 \n", + "1 452.623757 \n", + "2 336.481106 \n", + "3 241.991255 \n", + "4 230.737973 \n", + "5 219.337433 " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "operating_results = pd.DataFrame(\n", + " {\n", + " \"Geff [W/m2]\": conditions[\"Geff\"],\n", + " \"Tcell [degC]\": conditions[\"Tcell\"],\n", + " \"i_sc [A]\": curve_info[\"i_sc\"],\n", + " \"v_oc [V]\": curve_info[\"v_oc\"],\n", + " \"i_mp [A]\": curve_info[\"i_mp\"],\n", + " \"v_mp [V]\": curve_info[\"v_mp\"],\n", + " \"p_mp [W]\": curve_info[\"p_mp\"],\n", + " }\n", + ")\n", + "\n", + "operating_results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reference values for pvlib unit tests\n", + "\n", + "The round-trip validation above can also provide fixed reference values for the\n", + "pvlib test suite.\n", + "\n", + "The idea is to **archive the numerical results produced by this notebook** and\n", + "then use unit tests to verify that future implementations continue to reproduce\n", + "them. These are regression tests rather than an independent validation of the\n", + "model.\n", + "\n", + "Two tests are useful:\n", + "\n", + "1. `fit_villalva`: use fixed synthetic STC key points and verify that the\n", + " extracted SDM parameters match the archived values.\n", + "2. `calcparams_villalva`: evaluate a few irradiance and temperature conditions,\n", + " including `NaN`, and compare the five returned SDM parameters against\n", + " archived results.\n", + "\n", + "Keeping the reference values explicitly in the notebook provides the provenance\n", + "for the values later copied into the pvlib test files.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ArchivedRecomputedDifference
I_L_ref5.114000e+005.114000e+000.000000e+00
I_o_ref8.196000e-108.196000e-10-2.998530e-24
R_s1.065000e+001.065000e+000.000000e+00
R_sh_ref3.816800e+023.816800e+020.000000e+00
a_ref2.637300e+002.637300e+00-4.440892e-16
\n", + "
" + ], + "text/plain": [ + " Archived Recomputed Difference\n", + "I_L_ref 5.114000e+00 5.114000e+00 0.000000e+00\n", + "I_o_ref 8.196000e-10 8.196000e-10 -2.998530e-24\n", + "R_s 1.065000e+00 1.065000e+00 0.000000e+00\n", + "R_sh_ref 3.816800e+02 3.816800e+02 0.000000e+00\n", + "a_ref 2.637300e+00 2.637300e+00 -4.440892e-16" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Archived inputs and expected outputs for a fit_villalva regression test\n", + "\n", + "FIT_VILLALVA_INPUT = {\n", + " \"v_mp\": 46.90263243704522,\n", + " \"i_mp\": 4.6898061801386035,\n", + " \"v_oc\": 59.40065126750112,\n", + " \"i_sc\": 5.099770128570936,\n", + " \"alpha_sc\": 0.004539,\n", + " \"beta_voc\": -0.22216,\n", + " \"cells_in_series\": 96,\n", + " \"diode_factor\": 1.0692532995822863,\n", + " \"temp_ref\": 25.0,\n", + " \"irrad_ref\": 1000.0,\n", + " \"rs_step\": 1e-4,\n", + " \"rs_max\": 1.5,\n", + "}\n", + "\n", + "FIT_VILLALVA_EXPECTED = {\n", + " \"I_L_ref\": 5.113999993730909,\n", + " \"I_o_ref\": 8.196000001605002e-10,\n", + " \"R_s\": 1.065,\n", + " \"R_sh_ref\": 381.6800177562556,\n", + " \"a_ref\": 2.6373,\n", + "}\n", + "\n", + "fit_result, _ = fit_villalva(**FIT_VILLALVA_INPUT)\n", + "\n", + "fit_test_table = pd.DataFrame({\n", + " \"Archived\": FIT_VILLALVA_EXPECTED,\n", + " \"Recomputed\": {\n", + " key: fit_result[key]\n", + " for key in FIT_VILLALVA_EXPECTED\n", + " },\n", + "})\n", + "\n", + "fit_test_table[\"Difference\"] = (\n", + " fit_test_table[\"Recomputed\"]\n", + " - fit_test_table[\"Archived\"]\n", + ")\n", + "\n", + "fit_test_table\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### `calcparams_villalva` reference cases\n", + "\n", + "The following cases test normal operating conditions as well as `NaN`\n", + "propagation.\n", + "\n", + "For the case with `effective_irradiance = NaN` and a valid temperature,\n", + "photocurrent is `NaN`, while saturation current remains finite because\n", + "Villalva's \\(I_0\\) temperature equation does not depend on irradiance.\n", + "\n", + "When cell temperature is `NaN`, all temperature-dependent quantities become\n", + "`NaN`.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Geff [W/m2]Tcell [degC]I_L expected [A]I_L calculated [A]I_o expected [A]I_o calculated [A]nNsVth expected [V]nNsVth calculated [V]
01000.025.05.1140005.1140008.196000e-108.196000e-102.6373002.637300
1800.045.04.1638244.1638241.671475e-081.671475e-082.8142112.814211
2400.055.02.1000682.1000686.581579e-086.581579e-082.9026662.902666
3NaN25.0NaNNaN8.196000e-108.196000e-102.6373002.637300
4600.0NaNNaNNaNNaNNaNNaNNaN
\n", + "
" + ], + "text/plain": [ + " Geff [W/m2] Tcell [degC] I_L expected [A] I_L calculated [A] \\\n", + "0 1000.0 25.0 5.114000 5.114000 \n", + "1 800.0 45.0 4.163824 4.163824 \n", + "2 400.0 55.0 2.100068 2.100068 \n", + "3 NaN 25.0 NaN NaN \n", + "4 600.0 NaN NaN NaN \n", + "\n", + " I_o expected [A] I_o calculated [A] nNsVth expected [V] \\\n", + "0 8.196000e-10 8.196000e-10 2.637300 \n", + "1 1.671475e-08 1.671475e-08 2.814211 \n", + "2 6.581579e-08 6.581579e-08 2.902666 \n", + "3 8.196000e-10 8.196000e-10 2.637300 \n", + "4 NaN NaN NaN \n", + "\n", + " nNsVth calculated [V] \n", + "0 2.637300 \n", + "1 2.814211 \n", + "2 2.902666 \n", + "3 2.637300 \n", + "4 NaN " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Archived inputs and expected outputs for calcparams_villalva\n", + "\n", + "effective_irradiance_test = np.array([\n", + " 1000.0,\n", + " 800.0,\n", + " 400.0,\n", + " np.nan,\n", + " 600.0,\n", + "])\n", + "\n", + "temp_cell_test = np.array([\n", + " 25.0,\n", + " 45.0,\n", + " 55.0,\n", + " 25.0,\n", + " np.nan,\n", + "])\n", + "\n", + "CALCPARAMS_EXPECTED = (\n", + " np.array([\n", + " 5.113999993730909,\n", + " 4.163823994984726,\n", + " 2.100067997492364,\n", + " np.nan,\n", + " np.nan,\n", + " ]),\n", + " np.array([\n", + " 8.196000001605002e-10,\n", + " 1.671475175084766e-08,\n", + " 6.581579176008610e-08,\n", + " 8.196000001605002e-10,\n", + " np.nan,\n", + " ]),\n", + " 1.065,\n", + " 381.6800177562556,\n", + " np.array([\n", + " 2.6373,\n", + " 2.814210950863659,\n", + " 2.902666426295489,\n", + " 2.6373,\n", + " np.nan,\n", + " ]),\n", + ")\n", + "\n", + "calcparams_result = calcparams_villalva(\n", + " effective_irradiance=effective_irradiance_test,\n", + " temp_cell=temp_cell_test,\n", + " alpha_sc=0.004539,\n", + " beta_voc=-0.22216,\n", + " a_ref=2.6373,\n", + " I_L_ref=5.113999993730909,\n", + " R_sh_ref=381.6800177562556,\n", + " R_s=1.065,\n", + " i_sc_ref=5.099770128570936,\n", + " v_oc_ref=59.40065126750112,\n", + " irrad_ref=1000.0,\n", + " temp_ref=25.0,\n", + ")\n", + "\n", + "calcparams_test_table = pd.DataFrame({\n", + " \"Geff [W/m2]\": effective_irradiance_test,\n", + " \"Tcell [degC]\": temp_cell_test,\n", + " \"I_L expected [A]\": CALCPARAMS_EXPECTED[0],\n", + " \"I_L calculated [A]\": calcparams_result[0],\n", + " \"I_o expected [A]\": CALCPARAMS_EXPECTED[1],\n", + " \"I_o calculated [A]\": calcparams_result[1],\n", + " \"nNsVth expected [V]\": CALCPARAMS_EXPECTED[4],\n", + " \"nNsVth calculated [V]\": calcparams_result[4],\n", + "})\n", + "\n", + "calcparams_test_table\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pytest-style checks\n", + "\n", + "The actual pvlib contribution should place these checks in the test suite rather\n", + "than rely on the notebook. `equal_nan=True` is important for the operating\n", + "condition test.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Archived Villalva reference tests passed.\n" + ] + } + ], + "source": [ + "# These assertions mirror the tests that can be added to pvlib.\n", + "\n", + "np.testing.assert_allclose(\n", + " [fit_result[key] for key in FIT_VILLALVA_EXPECTED],\n", + " [FIT_VILLALVA_EXPECTED[key] for key in FIT_VILLALVA_EXPECTED],\n", + " rtol=1e-7,\n", + " atol=1e-12,\n", + ")\n", + "\n", + "for calculated, expected in zip(\n", + " calcparams_result,\n", + " CALCPARAMS_EXPECTED,\n", + "):\n", + " np.testing.assert_allclose(\n", + " calculated,\n", + " expected,\n", + " rtol=1e-10,\n", + " atol=1e-12,\n", + " equal_nan=True,\n", + " )\n", + "\n", + "print(\"Archived Villalva reference tests passed.\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "004708bc", + "metadata": {}, + "source": [ + "## Notes for a pvlib-python API reference addition\n", + "\n", + "The two proposed public functions represented by this notebook are:\n", + "\n", + "```python\n", + "pvlib.ivtools.sdm.fit_villalva(...)\n", + "pvlib.pvsystem.calcparams_villalva(...)\n", + "```\n", + "\n", + "`fit_villalva` is analogous in role to `pvlib.ivtools.sdm.fit_desoto`: it\n", + "extracts reference-condition SDM parameters from module datasheet values.\n", + "\n", + "`calcparams_villalva` is analogous in role to\n", + "`pvlib.pvsystem.calcparams_desoto`: it converts the reference parameters to\n", + "the five SDM parameters at an arbitrary irradiance and cell temperature.\n", + "\n", + "The actual I–V solution continues to use the existing pvlib functions\n", + "`pvsystem.singlediode` and `pvsystem.i_from_v`." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}