From 7727b17d0ed003190243648b3ea7bc8a9a739a70 Mon Sep 17 00:00:00 2001 From: paulf81 Date: Mon, 6 May 2024 08:52:43 -0600 Subject: [PATCH 01/12] Add test for v3_to_v4 input file converters (#880) --- .gitignore | 6 + tests/convert_v3_to_v4_test.py | 52 ++++ tests/v3_to_v4_convert_test/gch.yaml | 237 +++++++++++++++++++ tests/v3_to_v4_convert_test/nrel_5MW_v3.yaml | 212 +++++++++++++++++ 4 files changed, 507 insertions(+) create mode 100644 tests/convert_v3_to_v4_test.py create mode 100644 tests/v3_to_v4_convert_test/gch.yaml create mode 100644 tests/v3_to_v4_convert_test/nrel_5MW_v3.yaml diff --git a/.gitignore b/.gitignore index 33188a17a..ec1725e56 100644 --- a/.gitignore +++ b/.gitignore @@ -40,3 +40,9 @@ examples/SLSQP.out # Log files *.log + +# Temp files in convert test +tests/v3_to_v4_convert_test/convert_turbine_v3_to_v4.py +tests/v3_to_v4_convert_test/convert_floris_input_v3_to_v4.py +tests/v3_to_v4_convert_test/gch_v4.yaml +tests/v3_to_v4_convert_test/nrel_5MW_v3_v4.yaml diff --git a/tests/convert_v3_to_v4_test.py b/tests/convert_v3_to_v4_test.py new file mode 100644 index 000000000..9a015e860 --- /dev/null +++ b/tests/convert_v3_to_v4_test.py @@ -0,0 +1,52 @@ +import os +from pathlib import Path + +from floris import FlorisModel + + +CONVERT_FOLDER = Path(__file__).resolve().parent / "v3_to_v4_convert_test" +FLORIS_FOLDER = Path(__file__).resolve().parent / ".." / "floris" + + +def test_v3_to_v4_convert(): + # Note certain filenames + filename_v3_floris = "gch.yaml" + filename_v4_floris = "gch_v4.yaml" + filename_v3_turbine = "nrel_5MW_v3.yaml" + filename_v4_turbine = "nrel_5MW_v3_v4.yaml" + + # Copy convert scripts from FLORIS_FOLDER to CONVERT_FOLDER + os.system(f"cp {FLORIS_FOLDER / 'convert_turbine_v3_to_v4.py'} {CONVERT_FOLDER}") + os.system(f"cp {FLORIS_FOLDER / 'convert_floris_input_v3_to_v4.py'} {CONVERT_FOLDER}") + + # Change directory to the test folder + os.chdir(CONVERT_FOLDER) + + # Print the current directory + print(os.getcwd()) + + # Run the converter on the turbine file + os.system(f"python convert_turbine_v3_to_v4.py {filename_v3_turbine}") + + # Run the converter on the floris file + os.system(f"python convert_floris_input_v3_to_v4.py {filename_v3_floris}") + + # Go through the file filename_v4_floris and where the place-holder string "XXXXX" is found + # replace it with the string f"!include {filename_v4_turbine}" + with open(filename_v4_floris, "r") as file: + filedata = file.read() + filedata = filedata.replace("XXXXX", f"!include {filename_v4_turbine}") + with open(filename_v4_floris, "w") as file: + file.write(filedata) + + # Now confirm that the converted file can be loaded by FLORIS + fmodel = FlorisModel(filename_v4_floris) + + # Now confirm this model runs + fmodel.run() + + # Delete the newly created files to clean up + os.system(f"rm {filename_v4_floris}") + os.system(f"rm {filename_v4_turbine}") + os.system("rm convert_turbine_v3_to_v4.py") + os.system("rm convert_floris_input_v3_to_v4.py") diff --git a/tests/v3_to_v4_convert_test/gch.yaml b/tests/v3_to_v4_convert_test/gch.yaml new file mode 100644 index 000000000..dc58985fc --- /dev/null +++ b/tests/v3_to_v4_convert_test/gch.yaml @@ -0,0 +1,237 @@ + +### +# A name for this input file. +# This is not currently only for the user's reference. +name: GCH + +### +# A description of the contents of this input file. +# This is not currently only for the user's reference. +description: Three turbines using Gauss Curl Hybrid model + +### +# The earliest verion of FLORIS this input file supports. +# This is not currently only for the user's reference. +floris_version: v3.0.0 + +### +# Configure the logging level and where to show the logs. +logging: + + ### + # Settings for logging to the console (i.e. terminal). + console: + + ### + # Can be "true" or "false". + enable: true + + ### + # Set the severity to show output. Messages at this level or higher will be shown. + # Can be one of "CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG". + level: WARNING + + ### + # Settings for logging to a file. + file: + + ### + # Can be "true" or "false". + enable: false + + ### + # Set the severity to show output. Messages at this level or higher will be shown. + # Can be one of "CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG". + level: WARNING + +### +# Configure the solver for the type of simulation. +solver: + + ### + # Select the solver type. + # Can be one of: "turbine_grid", "flow_field_grid", "flow_field_planar_grid". + type: turbine_grid + + ### + # Options for the turbine type selected above. See the solver documentation for available parameters. + turbine_grid_points: 3 + +### +# Configure the turbine types and their placement within the wind farm. +farm: + + ### + # Coordinates for the turbine locations in the x-direction which is typically considered + # to be the streamwise direction (left, right) when the wind is out of the west. + # The order of the coordinates here corresponds to the index of the turbine in the primary + # data structures. + layout_x: + - 0.0 + + + ### + # Coordinates for the turbine locations in the y-direction which is typically considered + # to be the spanwise direction (up, down) when the wind is out of the west. + # The order of the coordinates here corresponds to the index of the turbine in the primary + # data structures. + layout_y: + - 0.0 + + + ### + # Listing of turbine types for placement at the x and y coordinates given above. + # The list length must be 1 or the same as ``layout_x`` and ``layout_y``. If it is a + # single value, all turbines are of the same type. Otherwise, the turbine type + # is mapped to the location at the same index in ``layout_x`` and ``layout_y``. + # The types can be either a name included in the turbine_library or + # a full definition of a wind turbine directly. + turbine_type: + - XXXXX + +### +# Configure the atmospheric conditions. +flow_field: + + ### + # Air density. + air_density: 1.225 + + ### + # The height to consider the "center" of the vertical wind speed profile + # due to shear. With a shear exponent not 1, the wind speed at this height + # will be the value given in ``wind_speeds``. Above and below this height, + # the wind speed will change according to the shear profile; see + # :py:meth:`.FlowField.initialize_velocity_field`. + # For farms consisting of one wind turbine type, use ``reference_wind_height: -1`` + # to use the hub height of the wind turbine definition. For multiple wind turbine + # types, the reference wind height must be given explicitly. + reference_wind_height: -1 + + ### + # The level of turbulence intensity level in the wind. + turbulence_intensity: 0.06 + + ### + # The wind directions to include in the simulation. + # 0 is north and 270 is west. + wind_directions: + - 270.0 + + ### + # The exponent used to model the wind shear profile; see + # :py:meth:`.FlowField.initialize_velocity_field`. + wind_shear: 0.12 + + ### + # The wind speeds to include in the simulation. + wind_speeds: + - 8.0 + + ### + # The wind veer as a constant value for all points in the grid. + wind_veer: 0.0 + + ### + # The conditions that are specified for use with the multi-dimensional Cp/Ct capbility. + # These conditions are external to FLORIS and specified by the user. They are used internally + # through a nearest-neighbor selection process to choose the correct Cp/Ct interpolants + # to use. These conditions are only used with the ``multidim_cp_ct`` velocity deficit model. + multidim_conditions: + Tp: 2.5 + Hs: 3.01 + +### +# Configure the wake model. +wake: + + ### + # Select the models to use for the simulation. + # See :py:mod:`~.wake` for a list + # of available models and their descriptions. + model_strings: + + ### + # Select the wake combination model. + combination_model: sosfs + + ### + # Select the wake deflection model. + deflection_model: gauss + + ### + # Select the wake turbulence model. + turbulence_model: crespo_hernandez + + ### + # Select the wake velocity deficit model. + velocity_model: gauss + + ### + # Can be "true" or "false". + enable_secondary_steering: true + + ### + # Can be "true" or "false". + enable_yaw_added_recovery: true + + ### + # Can be "true" or "false". + enable_transverse_velocities: true + + ### + # Configure the parameters for the wake deflection model + # selected above. + # Additional blocks can be provided for + # models that are not enabled, but the enabled model + # must have a corresponding parameter block. + wake_deflection_parameters: + gauss: + ad: 0.0 + alpha: 0.58 + bd: 0.0 + beta: 0.077 + dm: 1.0 + ka: 0.38 + kb: 0.004 + jimenez: + ad: 0.0 + bd: 0.0 + kd: 0.05 + + ### + # Configure the parameters for the wake velocity deficit model + # selected above. + # Additional blocks can be provided for + # models that are not enabled, but the enabled model + # must have a corresponding parameter block. + wake_velocity_parameters: + cc: + a_s: 0.179367259 + b_s: 0.0118889215 + c_s1: 0.0563691592 + c_s2: 0.13290157 + a_f: 3.11 + b_f: -0.68 + c_f: 2.41 + alpha_mod: 1.0 + gauss: + alpha: 0.58 + beta: 0.077 + ka: 0.38 + kb: 0.004 + jensen: + we: 0.05 + + ### + # Configure the parameters for the wake turbulence model + # selected above. + # Additional blocks can be provided for + # models that are not enabled, but the enabled model + # must have a corresponding parameter block. + wake_turbulence_parameters: + crespo_hernandez: + initial: 0.1 + constant: 0.5 + ai: 0.8 + downstream: -0.32 diff --git a/tests/v3_to_v4_convert_test/nrel_5MW_v3.yaml b/tests/v3_to_v4_convert_test/nrel_5MW_v3.yaml new file mode 100644 index 000000000..653ef14c7 --- /dev/null +++ b/tests/v3_to_v4_convert_test/nrel_5MW_v3.yaml @@ -0,0 +1,212 @@ + +### +# An ID for this type of turbine definition. +# This is not currently used, but it will be enabled in the future. This should typically +# match the root name of the file. +turbine_type: 'nrel_5MW' + +### +# Setting for generator losses to power. +generator_efficiency: 1.0 + +### +# Hub height. +hub_height: 90.0 + +### +# Cosine exponent for power loss due to yaw misalignment. +pP: 1.88 + +### +# Cosine exponent for power loss due to tilt. +pT: 1.88 + +### +# Rotor diameter. +rotor_diameter: 126.0 + +### +# Tip speed ratio defined as linear blade tip speed normalized by the incoming wind speed. +TSR: 8.0 + +### +# The air density at which the Cp and Ct curves are defined. +ref_density_cp_ct: 1.225 + +### +# The tilt angle at which the Cp and Ct curves are defined. This is used to capture +# the effects of a floating platform on a turbine's power and wake. +ref_tilt_cp_ct: 5.0 + +### +# Cp and Ct as a function of wind speed for the turbine's full range of operating conditions. +power_thrust_table: + power: + - 0.0 + - 0.000000 + - 0.000000 + - 0.178085 + - 0.289075 + - 0.349022 + - 0.384728 + - 0.406059 + - 0.420228 + - 0.428823 + - 0.433873 + - 0.436223 + - 0.436845 + - 0.436575 + - 0.436511 + - 0.436561 + - 0.436517 + - 0.435903 + - 0.434673 + - 0.433230 + - 0.430466 + - 0.378869 + - 0.335199 + - 0.297991 + - 0.266092 + - 0.238588 + - 0.214748 + - 0.193981 + - 0.175808 + - 0.159835 + - 0.145741 + - 0.133256 + - 0.122157 + - 0.112257 + - 0.103399 + - 0.095449 + - 0.088294 + - 0.081836 + - 0.075993 + - 0.070692 + - 0.065875 + - 0.061484 + - 0.057476 + - 0.053809 + - 0.050447 + - 0.047358 + - 0.044518 + - 0.041900 + - 0.039483 + - 0.0 + - 0.0 + thrust: + - 0.0 + - 0.0 + - 0.0 + - 0.99 + - 0.99 + - 0.97373036 + - 0.92826162 + - 0.89210543 + - 0.86100905 + - 0.835423 + - 0.81237673 + - 0.79225789 + - 0.77584769 + - 0.7629228 + - 0.76156073 + - 0.76261984 + - 0.76169723 + - 0.75232027 + - 0.74026851 + - 0.72987175 + - 0.70701647 + - 0.54054532 + - 0.45509459 + - 0.39343381 + - 0.34250785 + - 0.30487242 + - 0.27164979 + - 0.24361964 + - 0.21973831 + - 0.19918151 + - 0.18131868 + - 0.16537679 + - 0.15103727 + - 0.13998636 + - 0.1289037 + - 0.11970413 + - 0.11087113 + - 0.10339901 + - 0.09617888 + - 0.09009926 + - 0.08395078 + - 0.0791188 + - 0.07448356 + - 0.07050731 + - 0.06684119 + - 0.06345518 + - 0.06032267 + - 0.05741999 + - 0.05472609 + - 0.0 + - 0.0 + wind_speed: + - 0.0 + - 2.0 + - 2.5 + - 3.0 + - 3.5 + - 4.0 + - 4.5 + - 5.0 + - 5.5 + - 6.0 + - 6.5 + - 7.0 + - 7.5 + - 8.0 + - 8.5 + - 9.0 + - 9.5 + - 10.0 + - 10.5 + - 11.0 + - 11.5 + - 12.0 + - 12.5 + - 13.0 + - 13.5 + - 14.0 + - 14.5 + - 15.0 + - 15.5 + - 16.0 + - 16.5 + - 17.0 + - 17.5 + - 18.0 + - 18.5 + - 19.0 + - 19.5 + - 20.0 + - 20.5 + - 21.0 + - 21.5 + - 22.0 + - 22.5 + - 23.0 + - 23.5 + - 24.0 + - 24.5 + - 25.0 + - 25.01 + - 25.02 + - 50.0 + +### +# A boolean flag used when the user wants FLORIS to use the user-supplied multi-dimensional +# Cp/Ct information. +multi_dimensional_cp_ct: False + +### +# The path to the .csv file that contains the multi-dimensional Cp/Ct data. The format of this +# file is such that any external conditions, such as wave height or wave period, that the +# Cp/Ct data is dependent on come first, in column format. The last three columns of the .csv +# file must be ``ws``, ``Cp``, and ``Ct``, in that order. An example of fictional data is given +# in ``floris/turbine_library/iea_15MW_multi_dim_Tp_Hs.csv``. +power_thrust_data_file: '../floris/turbine_library/iea_15MW_multi_dim_Tp_Hs.csv' From d0442eca0df3840a66f9dd7938e5a3a4f42e025e Mon Sep 17 00:00:00 2001 From: misi9170 <39596329+misi9170@users.noreply.github.com> Date: Mon, 6 May 2024 16:12:03 -0400 Subject: [PATCH 02/12] Peak shaving turbine operation model (#888) * First pass implementation of operation model, including tests. * Operation model tests are more unit than integration tests. * Pipe TI through FLORIS. * handling for zero velocities to award division by zero error. * Documentation. * Handling for flat grid turbulence_intensities. * Update turbine unit tests. * Update reg tests; fix missed argument in turbopark_solver. * Ruff * Add axial induction factor correction. * Add example to examples_control_types. * update docs to reflect ai correction. --- docs/operation_models_user.ipynb | 86 ++++++++++++ .../005_peak_shaving.py | 124 ++++++++++++++++++ floris/core/solver.py | 17 +++ floris/core/turbine/__init__.py | 1 + floris/core/turbine/operation_models.py | 117 +++++++++++++++++ floris/core/turbine/turbine.py | 18 +++ floris/floris_model.py | 3 + floris/turbine_library/nrel_5MW.yaml | 5 + tests/conftest.py | 2 + .../cumulative_curl_regression_test.py | 18 +++ .../empirical_gauss_regression_test.py | 22 ++++ tests/reg_tests/gauss_regression_test.py | 26 ++++ .../jensen_jimenez_regression_test.py | 10 ++ tests/reg_tests/none_regression_test.py | 6 + tests/reg_tests/turbopark_regression_test.py | 10 ++ tests/turbine_multi_dim_unit_test.py | 15 +++ ... => turbine_operation_models_unit_test.py} | 97 ++++++++++++++ tests/turbine_unit_test.py | 17 +++ 18 files changed, 594 insertions(+) create mode 100644 examples/examples_control_types/005_peak_shaving.py rename tests/{turbine_operation_models_integration_test.py => turbine_operation_models_unit_test.py} (85%) diff --git a/docs/operation_models_user.ipynb b/docs/operation_models_user.ipynb index d2ccbc973..6ad796d68 100644 --- a/docs/operation_models_user.ipynb +++ b/docs/operation_models_user.ipynb @@ -380,6 +380,92 @@ "cell_type": "markdown", "id": "25f9c86c", "metadata": {}, + "source": [ + "### Peak shaving model\n", + "\n", + "User-level name: `\"peak-shaving\"`\n", + "\n", + "Underlying class: `PeakShavingTurbine`\n", + "\n", + "Required data on `power_thrust_table`:\n", + "- `ref_air_density` (scalar)\n", + "- `ref_tilt` (scalar)\n", + "- `wind_speed` (list)\n", + "- `power` (list)\n", + "- `thrust_coefficient` (list)\n", + "- `peak_shaving_fraction` (scalar)\n", + "- `peak_shaving_TI_threshold` (scalar)\n", + "\n", + "The `\"peak-shaving\"` operation model allows users to implement peak shaving, where the thrust\n", + "of the wind turbine is reduced from the nominal curve near rated to reduce unwanted structural\n", + "loading. Peak shaving here is implemented here by reducing the thrust by a fixed fraction from\n", + "the peak thrust on the nominal thrust curve, as specified by `peak_shaving_fraction`.This only\n", + "affects wind speeds near the peak in the thrust\n", + "curve (usually near rated wind speed), as thrust values away from the peak will be below the\n", + "fraction regardless. Further, peak shaving is only applied if the turbulence intensity experienced\n", + "by the turbine meets the `peak_shaving_TI_threshold`. To apply peak shaving in all wind conditions,\n", + "`peak_shaving_TI_threshold` may be set to zero.\n", + "\n", + "When the turbine is peak shaving to reduce thrust, the power output is updated accordingly. Letting\n", + "$C_{T}$ represent the thrust coefficient when peak shaving (at given wind speed), and $C_{T}'$\n", + "represent the thrust coefficient that the turbine would be operating at under nominal control, then\n", + "the power $P$ due to peak shaving (compared to the power $P'$ available under nominal control) is \n", + "computed (based on actuator disk theory) as\n", + "\n", + "$$ P = \\frac{C_T (1 - a)}{C_T' (1 - a')} P'$$\n", + "\n", + "where $a$ (respectively, $a'$) is the axial induction factor corresponding to $C_T$\n", + "(respectively, $C_T'$), computed using the usual relationship from actuator disk theory,\n", + "i.e. the lesser solution to $C_T=4a(1-a)$.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1eff05f3", + "metadata": {}, + "outputs": [], + "source": [ + "# Set up the FlorisModel\n", + "fmodel = FlorisModel(\"../examples/inputs/gch.yaml\")\n", + "fmodel.set(\n", + " layout_x=[0.0], layout_y=[0.0],\n", + " wind_data=TimeSeries(\n", + " wind_speeds=wind_speeds,\n", + " wind_directions=np.ones(100) * 270.0,\n", + " turbulence_intensities=0.2 # Higher than threshold value of 0.1\n", + " )\n", + ")\n", + "fmodel.reset_operation()\n", + "fmodel.set_operation_model(\"simple\")\n", + "fmodel.run()\n", + "powers_base = fmodel.get_turbine_powers()/1000\n", + "thrust_coefficients_base = fmodel.get_turbine_thrust_coefficients()\n", + "fmodel.set_operation_model(\"peak-shaving\")\n", + "fmodel.run()\n", + "powers_peak_shaving = fmodel.get_turbine_powers()/1000\n", + "thrust_coefficients_peak_shaving = fmodel.get_turbine_thrust_coefficients()\n", + "\n", + "fig, ax = plt.subplots(2,1,sharex=True)\n", + "ax[0].plot(wind_speeds, thrust_coefficients_base, label=\"Without peak shaving\", color=\"black\")\n", + "ax[0].plot(wind_speeds, thrust_coefficients_peak_shaving, label=\"With peak shaving\", color=\"C0\")\n", + "ax[1].plot(wind_speeds, powers_base, label=\"Without peak shaving\", color=\"black\")\n", + "ax[1].plot(wind_speeds, powers_peak_shaving, label=\"With peak shaving\", color=\"C0\")\n", + "\n", + "ax[1].grid()\n", + "ax[0].grid()\n", + "ax[0].legend()\n", + "ax[0].set_ylabel(\"Thrust coefficient [-]\")\n", + "ax[1].set_xlabel(\"Wind speed [m/s]\")\n", + "ax[1].set_ylabel(\"Power [kW]\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "92912bf7", + "metadata": {}, + "outputs": [], "source": [] } ], diff --git a/examples/examples_control_types/005_peak_shaving.py b/examples/examples_control_types/005_peak_shaving.py new file mode 100644 index 000000000..40710ecf0 --- /dev/null +++ b/examples/examples_control_types/005_peak_shaving.py @@ -0,0 +1,124 @@ +"""Example of using the peak-shaving turbine operation model. + +This example demonstrates how to use the peak-shaving operation model in FLORIS. +The peak-shaving operation model allows the user to a thrust reduction near rated wind speed to +reduce loads on the turbine. The power is reduced accordingly, and wind turbine wakes +are shallower due to the reduced thrust. + +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel, TimeSeries + + +fmodel = FlorisModel("../inputs/gch.yaml") +fmodel.set(layout_x=[0, 1000.0], layout_y=[0.0, 0.0]) +wind_speeds = np.linspace(0, 30, 100) +fmodel.set( + wind_data=TimeSeries( + wind_directions=270 * np.ones_like(wind_speeds), + wind_speeds=wind_speeds, + turbulence_intensities=0.10, # High enough to engage peak shaving + ) +) + +# Start with "normal" operation under the simple turbine operation model +fmodel.set_operation_model("simple") +fmodel.run() +powers_base = fmodel.get_turbine_powers()/1000 +thrust_coefficients_base = fmodel.get_turbine_thrust_coefficients() + +# Switch to the peak-shaving operation model +fmodel.set_operation_model("peak-shaving") +fmodel.run() +powers_peak_shaving = fmodel.get_turbine_powers()/1000 +thrust_coefficients_peak_shaving = fmodel.get_turbine_thrust_coefficients() + +# Compare the power and thrust coefficients of the upstream turbine +fig, ax = plt.subplots(2,1,sharex=True) +ax[0].plot( + wind_speeds, + thrust_coefficients_base[:,0], + label="Without peak shaving", + color="black" +) +ax[0].plot( + wind_speeds, + thrust_coefficients_peak_shaving[:,0], + label="With peak shaving", + color="C0" +) +ax[1].plot( + wind_speeds, + powers_base[:,0], + label="Without peak shaving", + color="black" +) +ax[1].plot( + wind_speeds, + powers_peak_shaving[:,0], + label="With peak shaving", + color="C0" +) +ax[1].grid() +ax[0].grid() +ax[0].legend() +ax[0].set_ylabel("Thrust coefficient [-]") +ax[1].set_xlabel("Wind speed [m/s]") +ax[1].set_ylabel("Power [kW]") + +# Look at the total power across the two turbines for each case +fig, ax = plt.subplots(2,1,sharex=True,sharey=True) +ax[0].fill_between( + wind_speeds, + 0, + powers_base[:, 0]/1e6, + color='C0', + label='Turbine 1' +) +ax[0].fill_between( + wind_speeds, + powers_base[:, 0]/1e6, + powers_base[:, :2].sum(axis=1)/1e6, + color='C1', + label='Turbine 2' + ) +ax[0].plot( + wind_speeds, + powers_base[:,:2].sum(axis=1)/1e6, + color='k', + label='Farm' +) +ax[1].fill_between( + wind_speeds, + 0, + powers_peak_shaving[:, 0]/1e6, + color='C0', + label='Turbine 1' +) +ax[1].fill_between( + wind_speeds, + powers_peak_shaving[:, 0]/1e6, + powers_peak_shaving[:, :2].sum(axis=1)/1e6, + color='C1', + label='Turbine 2' + ) +ax[1].plot( + wind_speeds, + powers_peak_shaving[:,:2].sum(axis=1)/1e6, + color='k', + label='Farm' +) +ax[0].legend() +ax[0].set_title("Without peak shaving") +ax[1].set_title("With peak shaving") +ax[0].set_ylabel("Power [MW]") +ax[1].set_ylabel("Power [MW]") +ax[0].grid() +ax[1].grid() + +ax[1].set_xlabel("Free stream wind speed [m/s]") + +plt.show() diff --git a/floris/core/solver.py b/floris/core/solver.py index 8307b27c8..a7c3d8796 100644 --- a/floris/core/solver.py +++ b/floris/core/solver.py @@ -91,6 +91,7 @@ def sequential_solver( ct_i = thrust_coefficient( velocities=flow_field.u_sorted, + turbulence_intensities=flow_field.turbulence_intensity_field_sorted, air_density=flow_field.air_density, yaw_angles=farm.yaw_angles_sorted, tilt_angles=farm.tilt_angles_sorted, @@ -112,6 +113,7 @@ def sequential_solver( ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=flow_field.u_sorted, + turbulence_intensities=flow_field.turbulence_intensity_field_sorted, air_density=flow_field.air_density, yaw_angles=farm.yaw_angles_sorted, tilt_angles=farm.tilt_angles_sorted, @@ -327,6 +329,7 @@ def full_flow_sequential_solver( ct_i = thrust_coefficient( velocities=turbine_grid_flow_field.u_sorted, + turbulence_intensities=turbine_grid_flow_field.turbulence_intensity_field_sorted, air_density=turbine_grid_flow_field.air_density, yaw_angles=turbine_grid_farm.yaw_angles_sorted, tilt_angles=turbine_grid_farm.tilt_angles_sorted, @@ -348,6 +351,7 @@ def full_flow_sequential_solver( ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=turbine_grid_flow_field.u_sorted, + turbulence_intensities=turbine_grid_flow_field.turbulence_intensity_field_sorted, air_density=turbine_grid_flow_field.air_density, yaw_angles=turbine_grid_farm.yaw_angles_sorted, tilt_angles=turbine_grid_farm.tilt_angles_sorted, @@ -506,6 +510,7 @@ def cc_solver( turb_avg_vels = average_velocity(turb_inflow_field) turb_Cts = thrust_coefficient( turb_avg_vels, + flow_field.turbulence_intensity_field_sorted, flow_field.air_density, farm.yaw_angles_sorted, farm.tilt_angles_sorted, @@ -524,6 +529,7 @@ def cc_solver( turb_Cts = turb_Cts[:, :, None, None] turb_aIs = axial_induction( turb_avg_vels, + flow_field.turbulence_intensity_field_sorted, flow_field.air_density, farm.yaw_angles_sorted, farm.tilt_angles_sorted, @@ -547,6 +553,7 @@ def cc_solver( axial_induction_i = axial_induction( velocities=flow_field.u_sorted, + turbulence_intensities=flow_field.turbulence_intensity_field_sorted, air_density=flow_field.air_density, yaw_angles=farm.yaw_angles_sorted, tilt_angles=farm.tilt_angles_sorted, @@ -762,6 +769,7 @@ def full_flow_cc_solver( turb_avg_vels = average_velocity(turbine_grid_flow_field.u_sorted) turb_Cts = thrust_coefficient( velocities=turb_avg_vels, + turbulence_intensities=turbine_grid_flow_field.turbulence_intensity_field_sorted, air_density=turbine_grid_flow_field.air_density, yaw_angles=turbine_grid_farm.yaw_angles_sorted, tilt_angles=turbine_grid_farm.tilt_angles_sorted, @@ -781,6 +789,7 @@ def full_flow_cc_solver( axial_induction_i = axial_induction( velocities=turbine_grid_flow_field.u_sorted, + turbulence_intensities=turbine_grid_flow_field.turbulence_intensity_field_sorted, air_density=turbine_grid_flow_field.air_density, yaw_angles=turbine_grid_farm.yaw_angles_sorted, tilt_angles=turbine_grid_farm.tilt_angles_sorted, @@ -923,6 +932,7 @@ def turbopark_solver( Cts = thrust_coefficient( velocities=flow_field.u_sorted, + turbulence_intensities=flow_field.turbulence_intensity_field_sorted, air_density=flow_field.air_density, yaw_angles=farm.yaw_angles_sorted, tilt_angles=farm.tilt_angles_sorted, @@ -941,6 +951,7 @@ def turbopark_solver( ct_i = thrust_coefficient( velocities=flow_field.u_sorted, + turbulence_intensities=flow_field.turbulence_intensity_field_sorted, air_density=flow_field.air_density, yaw_angles=farm.yaw_angles_sorted, tilt_angles=farm.tilt_angles_sorted, @@ -962,6 +973,7 @@ def turbopark_solver( ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=flow_field.u_sorted, + turbulence_intensities=flow_field.turbulence_intensity_field_sorted, air_density=flow_field.air_density, yaw_angles=farm.yaw_angles_sorted, tilt_angles=farm.tilt_angles_sorted, @@ -1010,6 +1022,7 @@ def turbopark_solver( turbulence_intensity_ii = turbine_turbulence_intensity[:, ii:ii+1] ct_ii = thrust_coefficient( velocities=flow_field.u_sorted, + turbulence_intensities=flow_field.turbulence_intensity_field_sorted, air_density=flow_field.air_density, yaw_angles=farm.yaw_angles_sorted, tilt_angles=farm.tilt_angles_sorted, @@ -1187,6 +1200,7 @@ def empirical_gauss_solver( ct_i = thrust_coefficient( velocities=flow_field.u_sorted, + turbulence_intensities=flow_field.turbulence_intensity_field_sorted, air_density=flow_field.air_density, yaw_angles=farm.yaw_angles_sorted, tilt_angles=farm.tilt_angles_sorted, @@ -1208,6 +1222,7 @@ def empirical_gauss_solver( ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=flow_field.u_sorted, + turbulence_intensities=flow_field.turbulence_intensity_field_sorted, air_density=flow_field.air_density, yaw_angles=farm.yaw_angles_sorted, tilt_angles=farm.tilt_angles_sorted, @@ -1408,6 +1423,7 @@ def full_flow_empirical_gauss_solver( ct_i = thrust_coefficient( velocities=turbine_grid_flow_field.u_sorted, + turbulence_intensities=turbine_grid_flow_field.turbulence_intensity_field_sorted, air_density=turbine_grid_flow_field.air_density, yaw_angles=turbine_grid_farm.yaw_angles_sorted, tilt_angles=turbine_grid_farm.tilt_angles_sorted, @@ -1429,6 +1445,7 @@ def full_flow_empirical_gauss_solver( ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=turbine_grid_flow_field.u_sorted, + turbulence_intensities=turbine_grid_flow_field.turbulence_intensity_field_sorted, air_density=turbine_grid_flow_field.air_density, yaw_angles=turbine_grid_farm.yaw_angles_sorted, tilt_angles=turbine_grid_farm.tilt_angles_sorted, diff --git a/floris/core/turbine/__init__.py b/floris/core/turbine/__init__.py index 6216fe2b0..a7cde822a 100644 --- a/floris/core/turbine/__init__.py +++ b/floris/core/turbine/__init__.py @@ -3,6 +3,7 @@ AWCTurbine, CosineLossTurbine, MixedOperationTurbine, + PeakShavingTurbine, SimpleDeratingTurbine, SimpleTurbine, ) diff --git a/floris/core/turbine/operation_models.py b/floris/core/turbine/operation_models.py index bd592343c..a6c1ff160 100644 --- a/floris/core/turbine/operation_models.py +++ b/floris/core/turbine/operation_models.py @@ -581,3 +581,120 @@ def axial_induction( ) return (1 - np.sqrt(1 - thrust_coefficient))/2 + +@define +class PeakShavingTurbine(): + + def power( + power_thrust_table: dict, + velocities: NDArrayFloat, + turbulence_intensities: NDArrayFloat, + air_density: float, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + base_powers = SimpleTurbine.power( + power_thrust_table=power_thrust_table, + velocities=velocities, + air_density=air_density, + average_method=average_method, + cubature_weights=cubature_weights + ) + + # Get fraction by thrust + base_thrust_coefficients = SimpleTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + average_method=average_method, + cubature_weights=cubature_weights + ) + peak_shaving_thrust_coefficients = PeakShavingTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + turbulence_intensities=turbulence_intensities, + average_method=average_method, + cubature_weights=cubature_weights + ) + + # Compute equivalent axial inductions + base_ais = (1 - np.sqrt(1 - base_thrust_coefficients))/2 + peak_shaving_ais = (1 - np.sqrt(1 - peak_shaving_thrust_coefficients))/2 + + # Power proportion + power_fractions = ( + (peak_shaving_thrust_coefficients * (1-peak_shaving_ais)) + / (base_thrust_coefficients * (1-base_ais)) + ) + + # Apply fraction to power and return + powers = power_fractions * base_powers + + return powers + + def thrust_coefficient( + power_thrust_table: dict, + velocities: NDArrayFloat, + turbulence_intensities: NDArrayFloat, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + base_thrust_coefficients = SimpleTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + average_method=average_method, + cubature_weights=cubature_weights + ) + + peak_normal_thrust_prime = np.max( + np.array(power_thrust_table["wind_speed"])**2 + * np.array(power_thrust_table["thrust_coefficient"]) + ) + rotor_average_velocities = average_velocity( + velocities=velocities, + method=average_method, + cubature_weights=cubature_weights, + ) + # Replace zeros with small values to avoid division by zero + rotor_average_velocities = np.maximum(rotor_average_velocities, 0.01) + max_allowable_thrust_coefficient = ( + (1-power_thrust_table["peak_shaving_fraction"]) + * peak_normal_thrust_prime + / rotor_average_velocities**2 + ) + + # Apply TI mask + max_allowable_thrust_coefficient = np.where( + ( + turbulence_intensities.mean( + axis=tuple([2 + i for i in range(turbulence_intensities.ndim - 2)]) + ) + >= power_thrust_table["peak_shaving_TI_threshold"] + ), + max_allowable_thrust_coefficient, + base_thrust_coefficients + ) + + thrust_coefficient = np.minimum(base_thrust_coefficients, max_allowable_thrust_coefficient) + + return thrust_coefficient + + def axial_induction( + power_thrust_table: dict, + velocities: NDArrayFloat, + turbulence_intensities: NDArrayFloat, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + + thrust_coefficient = PeakShavingTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + turbulence_intensities=turbulence_intensities, + average_method=average_method, + cubature_weights=cubature_weights, + ) + + return (1 - np.sqrt(1 - thrust_coefficient))/2 diff --git a/floris/core/turbine/turbine.py b/floris/core/turbine/turbine.py index 17fd956e3..2f98c45ea 100644 --- a/floris/core/turbine/turbine.py +++ b/floris/core/turbine/turbine.py @@ -16,6 +16,7 @@ AWCTurbine, CosineLossTurbine, MixedOperationTurbine, + PeakShavingTurbine, SimpleDeratingTurbine, SimpleTurbine, ) @@ -39,6 +40,7 @@ "simple-derating": SimpleDeratingTurbine, "mixed": MixedOperationTurbine, "awc": AWCTurbine, + "peak-shaving": PeakShavingTurbine, }, } @@ -73,6 +75,7 @@ def select_multidim_condition( def power( velocities: NDArrayFloat, + turbulence_intensities: NDArrayFloat, air_density: float, power_functions: dict[str, Callable], yaw_angles: NDArrayFloat, @@ -95,6 +98,8 @@ def power( Args: velocities (NDArrayFloat[n_findex, n_turbines, n_grid, n_grid]): The velocities at a turbine. + turbulence_intensities (NDArrayFloat[findex, turbines]): The turbulence intensity at + each turbine. air_density (float): air density for simulation [kg/m^3] power_functions (dict[str, Callable]): A dictionary of power functions for each turbine type. Keys are the turbine type and values are the callable functions. @@ -130,6 +135,7 @@ def power( # Down-select inputs if ix_filter is given if ix_filter is not None: velocities = velocities[:, ix_filter] + turbulence_intensities = turbulence_intensities[:, ix_filter] yaw_angles = yaw_angles[:, ix_filter] tilt_angles = tilt_angles[:, ix_filter] power_setpoints = power_setpoints[:, ix_filter] @@ -161,6 +167,7 @@ def power( power_model_kwargs = { "power_thrust_table": power_thrust_table, "velocities": velocities, + "turbulence_intensities": turbulence_intensities, "air_density": air_density, "yaw_angles": yaw_angles, "tilt_angles": tilt_angles, @@ -182,6 +189,7 @@ def power( def thrust_coefficient( velocities: NDArrayFloat, + turbulence_intensities: NDArrayFloat, air_density: float, yaw_angles: NDArrayFloat, tilt_angles: NDArrayFloat, @@ -206,6 +214,8 @@ def thrust_coefficient( Args: velocities (NDArrayFloat[findex, turbines, grid1, grid2]): The velocity field at a turbine. + turbulence_intensities (NDArrayFloat[findex, turbines]): The turbulence intensity at + each turbine. air_density (float): air density for simulation [kg/m^3] yaw_angles (NDArrayFloat[findex, turbines]): The yaw angle for each turbine. tilt_angles (NDArrayFloat[findex, turbines]): The tilt angle for each turbine. @@ -241,6 +251,7 @@ def thrust_coefficient( # Down-select inputs if ix_filter is given if ix_filter is not None: velocities = velocities[:, ix_filter] + turbulence_intensities = turbulence_intensities[:, ix_filter] yaw_angles = yaw_angles[:, ix_filter] tilt_angles = tilt_angles[:, ix_filter] power_setpoints = power_setpoints[:, ix_filter] @@ -272,6 +283,7 @@ def thrust_coefficient( thrust_model_kwargs = { "power_thrust_table": power_thrust_table, "velocities": velocities, + "turbulence_intensities": turbulence_intensities, "air_density": air_density, "yaw_angles": yaw_angles, "tilt_angles": tilt_angles, @@ -296,6 +308,7 @@ def thrust_coefficient( def axial_induction( velocities: NDArrayFloat, + turbulence_intensities: NDArrayFloat, air_density: float, yaw_angles: NDArrayFloat, tilt_angles: NDArrayFloat, @@ -318,6 +331,9 @@ def axial_induction( Args: velocities (NDArrayFloat): The velocity field at each turbine; should be shape: (number of turbines, ngrid, ngrid), or (ngrid, ngrid) for a single turbine. + turbulence_intensities (NDArrayFloat[findex, turbines]): The turbulence intensity at + each turbine. + air_density (float): air density for simulation [kg/m^3] yaw_angles (NDArrayFloat[findex, turbines]): The yaw angle for each turbine. tilt_angles (NDArrayFloat[findex, turbines]): The tilt angle for each turbine. power_setpoints: (NDArrayFloat[findex, turbines]): Maximum power setpoint for each @@ -350,6 +366,7 @@ def axial_induction( # Down-select inputs if ix_filter is given if ix_filter is not None: velocities = velocities[:, ix_filter] + turbulence_intensities = turbulence_intensities[:, ix_filter] yaw_angles = yaw_angles[:, ix_filter] tilt_angles = tilt_angles[:, ix_filter] power_setpoints = power_setpoints[:, ix_filter] @@ -381,6 +398,7 @@ def axial_induction( axial_induction_model_kwargs = { "power_thrust_table": power_thrust_table, "velocities": velocities, + "turbulence_intensities": turbulence_intensities, "air_density": air_density, "yaw_angles": yaw_angles, "tilt_angles": tilt_angles, diff --git a/floris/floris_model.py b/floris/floris_model.py index 99ab55eab..474a211ae 100644 --- a/floris/floris_model.py +++ b/floris/floris_model.py @@ -492,6 +492,7 @@ def _get_turbine_powers(self) -> NDArrayFloat: turbine_powers = power( velocities=self.core.flow_field.u, + turbulence_intensities=self.core.flow_field.turbulence_intensity_field[:,:,None,None], air_density=self.core.flow_field.air_density, power_functions=self.core.farm.turbine_power_functions, yaw_angles=self.core.farm.yaw_angles, @@ -900,6 +901,7 @@ def get_farm_AVP( def get_turbine_ais(self) -> NDArrayFloat: turbine_ais = axial_induction( velocities=self.core.flow_field.u, + turbulence_intensities=self.core.flow_field.turbulence_intensity_field[:,:,None,None], air_density=self.core.flow_field.air_density, yaw_angles=self.core.farm.yaw_angles, tilt_angles=self.core.farm.tilt_angles, @@ -920,6 +922,7 @@ def get_turbine_ais(self) -> NDArrayFloat: def get_turbine_thrust_coefficients(self) -> NDArrayFloat: turbine_thrust_coefficients = thrust_coefficient( velocities=self.core.flow_field.u, + turbulence_intensities=self.core.flow_field.turbulence_intensity_field[:,:,None,None], air_density=self.core.flow_field.air_density, yaw_angles=self.core.farm.yaw_angles, tilt_angles=self.core.farm.tilt_angles, diff --git a/floris/turbine_library/nrel_5MW.yaml b/floris/turbine_library/nrel_5MW.yaml index 228abd219..bc2ef4137 100644 --- a/floris/turbine_library/nrel_5MW.yaml +++ b/floris/turbine_library/nrel_5MW.yaml @@ -49,6 +49,11 @@ power_thrust_table: helix_power_c: 1.629e-10 helix_thrust_b: 1.027e-03 helix_thrust_c: 1.378e-06 + ### Peak shaving parameters + # Fraction of peak thrust by which to reduce + peak_shaving_fraction: 0.2 + # Threshold turbulence intensity above which to apply peak shaving + peak_shaving_TI_threshold: 0.1 ### Power thrust table data # wind speeds for look-up tables of power and thrust_coefficient wind_speed: diff --git a/tests/conftest.py b/tests/conftest.py index 2b939e689..d31b7dee1 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -216,6 +216,8 @@ def __init__(self): "helix_power_c": 1.629e-10, "helix_thrust_b": 1.027e-03, "helix_thrust_c": 1.378e-06, + "peak_shaving_fraction": 0.2, + "peak_shaving_TI_threshold": 0.1, "power": [ 0.0, 0.0, diff --git a/tests/reg_tests/cumulative_curl_regression_test.py b/tests/reg_tests/cumulative_curl_regression_test.py index 6de08a83b..c9428b261 100644 --- a/tests/reg_tests/cumulative_curl_regression_test.py +++ b/tests/reg_tests/cumulative_curl_regression_test.py @@ -200,6 +200,7 @@ def test_regression_tandem(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -213,6 +214,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -227,6 +229,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -240,6 +243,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -370,6 +374,7 @@ def test_regression_yaw(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -383,6 +388,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -397,6 +403,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -410,6 +417,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -467,6 +475,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -480,6 +489,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -494,6 +504,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -507,6 +518,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -563,6 +575,7 @@ def test_regression_secondary_steering(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -576,6 +589,7 @@ def test_regression_secondary_steering(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -590,6 +604,7 @@ def test_regression_secondary_steering(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -603,6 +618,7 @@ def test_regression_secondary_steering(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -673,6 +689,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -682,6 +699,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, diff --git a/tests/reg_tests/empirical_gauss_regression_test.py b/tests/reg_tests/empirical_gauss_regression_test.py index 392989076..a6bdaa991 100644 --- a/tests/reg_tests/empirical_gauss_regression_test.py +++ b/tests/reg_tests/empirical_gauss_regression_test.py @@ -203,6 +203,7 @@ def test_regression_tandem(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -216,6 +217,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -230,6 +232,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -243,6 +246,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -375,6 +379,7 @@ def test_regression_yaw(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -388,6 +393,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -402,6 +408,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -415,6 +422,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -472,6 +480,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -485,6 +494,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -499,6 +509,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -512,6 +523,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -552,6 +564,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -565,6 +578,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -579,6 +593,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -592,6 +607,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -644,6 +660,7 @@ def test_regression_helix(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -657,6 +674,7 @@ def test_regression_helix(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -671,6 +689,7 @@ def test_regression_helix(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -684,6 +703,7 @@ def test_regression_helix(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -755,6 +775,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field # farm_eff_velocities = rotor_effective_velocity( # floris.flow_field.air_density, @@ -771,6 +792,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): # ) farm_powers = power( velocities, + turbulence_intensities, floris.flow_field.air_density, floris.farm.turbine_power_functions, floris.farm.yaw_angles, diff --git a/tests/reg_tests/gauss_regression_test.py b/tests/reg_tests/gauss_regression_test.py index cd3dcce0b..3c97ee0a1 100644 --- a/tests/reg_tests/gauss_regression_test.py +++ b/tests/reg_tests/gauss_regression_test.py @@ -292,6 +292,7 @@ def test_regression_tandem(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -305,6 +306,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -319,6 +321,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -332,6 +335,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -463,6 +467,7 @@ def test_regression_yaw(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -476,6 +481,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -490,6 +496,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -503,6 +510,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -557,6 +565,7 @@ def test_regression_gch(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -570,6 +579,7 @@ def test_regression_gch(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -584,6 +594,7 @@ def test_regression_gch(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -597,6 +608,7 @@ def test_regression_gch(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -646,6 +658,7 @@ def test_regression_gch(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -659,6 +672,7 @@ def test_regression_gch(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -673,6 +687,7 @@ def test_regression_gch(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -686,6 +701,7 @@ def test_regression_gch(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -743,6 +759,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -756,6 +773,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -770,6 +788,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -783,6 +802,7 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -839,6 +859,7 @@ def test_regression_secondary_steering(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -852,6 +873,7 @@ def test_regression_secondary_steering(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -866,6 +888,7 @@ def test_regression_secondary_steering(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -879,6 +902,7 @@ def test_regression_secondary_steering(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -949,6 +973,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles power_setpoints = floris.farm.power_setpoints @@ -957,6 +982,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): farm_powers = power( velocities, + turbulence_intensities, floris.flow_field.air_density, floris.farm.turbine_power_functions, yaw_angles, diff --git a/tests/reg_tests/jensen_jimenez_regression_test.py b/tests/reg_tests/jensen_jimenez_regression_test.py index 8c6a2accd..026bfc0c9 100644 --- a/tests/reg_tests/jensen_jimenez_regression_test.py +++ b/tests/reg_tests/jensen_jimenez_regression_test.py @@ -142,6 +142,7 @@ def test_regression_tandem(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -155,6 +156,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -169,6 +171,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -182,6 +185,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -312,6 +316,7 @@ def test_regression_yaw(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -325,6 +330,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -339,6 +345,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -352,6 +359,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -422,6 +430,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -444,6 +453,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): # ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, diff --git a/tests/reg_tests/none_regression_test.py b/tests/reg_tests/none_regression_test.py index d8b7e87f3..5f50920cb 100644 --- a/tests/reg_tests/none_regression_test.py +++ b/tests/reg_tests/none_regression_test.py @@ -143,6 +143,7 @@ def test_regression_tandem(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -156,6 +157,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -170,6 +172,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -183,6 +186,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -350,6 +354,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -359,6 +364,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, diff --git a/tests/reg_tests/turbopark_regression_test.py b/tests/reg_tests/turbopark_regression_test.py index 397a8586c..f4be3f384 100644 --- a/tests/reg_tests/turbopark_regression_test.py +++ b/tests/reg_tests/turbopark_regression_test.py @@ -102,6 +102,7 @@ def test_regression_tandem(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -115,6 +116,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -129,6 +131,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -142,6 +145,7 @@ def test_regression_tandem(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -273,6 +277,7 @@ def test_regression_yaw(sample_inputs_fixture): n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles @@ -286,6 +291,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_cts = thrust_coefficient( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -300,6 +306,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_powers = power( velocities, + turbulence_intensities, air_density, floris.farm.turbine_power_functions, yaw_angles, @@ -313,6 +320,7 @@ def test_regression_yaw(sample_inputs_fixture): ) farm_axial_inductions = axial_induction( velocities, + turbulence_intensities, air_density, yaw_angles, tilt_angles, @@ -378,6 +386,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u + turbulence_intensities = floris.flow_field.turbulence_intensity_field yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles power_setpoints = floris.farm.power_setpoints @@ -386,6 +395,7 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): farm_powers = power( velocities, + turbulence_intensities, floris.flow_field.air_density, floris.farm.turbine_power_functions, yaw_angles, diff --git a/tests/turbine_multi_dim_unit_test.py b/tests/turbine_multi_dim_unit_test.py index 8a429a74c..0c11c2564 100644 --- a/tests/turbine_multi_dim_unit_test.py +++ b/tests/turbine_multi_dim_unit_test.py @@ -82,6 +82,7 @@ def test_ct(): wind_speed = 10.0 thrust = thrust_coefficient( velocities=wind_speed * np.ones((1, 1, 3, 3)), + turbulence_intensities=0.06 * np.ones((1, 1, 3, 3)), air_density=None, yaw_angles=np.zeros((1, 1)), tilt_angles=np.ones((1, 1)) * 5.0, @@ -102,6 +103,10 @@ def test_ct(): # 4 turbines with 3 x 3 grid arrays thrusts = thrust_coefficient( velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 16 x 4 x 3 x 3 + turbulence_intensities=( + 0.06 * np.ones((N_TURBINES, 3, 3)) + * np.ones_like(WIND_CONDITION_BROADCAST) + ), air_density=None, yaw_angles=np.zeros((1, N_TURBINES)), tilt_angles=np.ones((1, N_TURBINES)) * 5.0, @@ -155,6 +160,7 @@ def test_power(): wind_speed = 10.0 p = power( velocities=wind_speed * np.ones((1, 1, 3, 3)), + turbulence_intensities=0.06 * np.ones((1, 1, 3, 3)), air_density=AIR_DENSITY, power_functions={turbine.turbine_type: turbine.power_function}, yaw_angles=np.zeros((1, 1)), # 1 findex, 1 turbine @@ -176,6 +182,10 @@ def test_power(): velocities = np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST p = power( velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 16 x 4 x 3 x 3 + turbulence_intensities=( + 0.06 * np.ones((N_TURBINES, 3, 3)) + * np.ones_like(WIND_CONDITION_BROADCAST) + ), air_density=AIR_DENSITY, power_functions={turbine.turbine_type: turbine.power_function}, yaw_angles=np.zeros((1, N_TURBINES)), @@ -218,6 +228,7 @@ def test_axial_induction(): wind_speed = 10.0 ai = axial_induction( velocities=wind_speed * np.ones((1, 1, 3, 3)), + turbulence_intensities=0.06 * np.ones((1, 1, 3, 3)), air_density=None, yaw_angles=np.zeros((1, 1)), tilt_angles=np.ones((1, 1)) * 5.0, @@ -236,6 +247,10 @@ def test_axial_induction(): # Multiple turbines with ix filter ai = axial_induction( velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 16 x 4 x 3 x 3 + turbulence_intensities=( + 0.06 * np.ones((N_TURBINES, 3, 3)) + * np.ones_like(WIND_CONDITION_BROADCAST) + ), air_density=None, yaw_angles=np.zeros((1, N_TURBINES)), tilt_angles=np.ones((1, N_TURBINES)) * 5.0, diff --git a/tests/turbine_operation_models_integration_test.py b/tests/turbine_operation_models_unit_test.py similarity index 85% rename from tests/turbine_operation_models_integration_test.py rename to tests/turbine_operation_models_unit_test.py index db4f0cc41..b50aab54b 100644 --- a/tests/turbine_operation_models_integration_test.py +++ b/tests/turbine_operation_models_unit_test.py @@ -5,6 +5,7 @@ AWCTurbine, CosineLossTurbine, MixedOperationTurbine, + PeakShavingTurbine, POWER_SETPOINT_DEFAULT, SimpleDeratingTurbine, SimpleTurbine, @@ -35,6 +36,10 @@ def test_submodel_attributes(): assert hasattr(AWCTurbine, "thrust_coefficient") assert hasattr(AWCTurbine, "axial_induction") + assert hasattr(PeakShavingTurbine, "power") + assert hasattr(PeakShavingTurbine, "thrust_coefficient") + assert hasattr(PeakShavingTurbine, "axial_induction") + def test_SimpleTurbine(): n_turbines = 1 @@ -562,3 +567,95 @@ def test_AWCTurbine(): ) assert test_ai < base_ai assert test_ai > 0 + +def test_PeakShavingTurbine(): + + n_turbines = 1 + wind_speed = 10.0 + turbulence_intensity_low = 0.05 + turbulence_intensity_high = 0.2 + turbine_data = SampleInputs().turbine + + + # Baseline + base_Ct = SimpleTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + ) + base_power = SimpleTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + ) + base_ai = SimpleTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + ) + + # Test no change to Ct, power, or ai when below TI threshold + test_Ct = PeakShavingTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + turbulence_intensities=turbulence_intensity_low * np.ones((1, n_turbines, 3, 3)), + ) + assert np.allclose(test_Ct, base_Ct) + + test_power = PeakShavingTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + turbulence_intensities=turbulence_intensity_low * np.ones((1, n_turbines, 3, 3)), + ) + assert np.allclose(test_power, base_power) + + test_ai = PeakShavingTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + turbulence_intensities=turbulence_intensity_low * np.ones((1, n_turbines, 3, 3)), + ) + assert np.allclose(test_ai, base_ai) + + # Test that Ct, power, and ai all decrease when above TI threshold + test_Ct = PeakShavingTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + turbulence_intensities=turbulence_intensity_high * np.ones((1, n_turbines, 3, 3)), + ) + assert test_Ct < base_Ct + assert test_Ct > 0 + + test_power = PeakShavingTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + turbulence_intensities=turbulence_intensity_high * np.ones((1, n_turbines, 3, 3)), + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + ) + + assert test_power < base_power + assert test_power > 0 + + test_ai = PeakShavingTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + turbulence_intensities=turbulence_intensity_high * np.ones((1, n_turbines, 3, 3)), + ) + assert test_ai < base_ai + assert test_ai > 0 + + # Test that, for an array of wind speeds, only wind speeds near rated are affected + wind_speeds = np.linspace(1, 20, 10) + turbulence_intensities = turbulence_intensity_high * np.ones_like(wind_speeds) + base_power = SimpleTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speeds[:, None, None, None], + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + ) + test_power = PeakShavingTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speeds[:, None, None, None], + turbulence_intensities=turbulence_intensities[:, None, None, None], + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + ) + assert (test_power <= base_power).all() + assert test_power[0,0] == base_power[0,0] + assert test_power[-1,0] == base_power[-1,0] diff --git a/tests/turbine_unit_test.py b/tests/turbine_unit_test.py index ca5e73777..73e87c853 100644 --- a/tests/turbine_unit_test.py +++ b/tests/turbine_unit_test.py @@ -173,6 +173,7 @@ def test_ct(): wind_speed = 10.0 thrust = thrust_coefficient( velocities=wind_speed * np.ones((1, 1, 3, 3)), + turbulence_intensities=0.06 * np.zeros((1, 1, 3, 3)), air_density=None, yaw_angles=np.zeros((1, 1)), tilt_angles=np.ones((1, 1)) * 5.0, @@ -196,6 +197,10 @@ def test_ct(): # 4 turbines with 3 x 3 grid arrays thrusts = thrust_coefficient( velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 12 x 4 x 3 x 3 + turbulence_intensities=( + 0.06 * np.ones((N_TURBINES, 3, 3)) + * np.ones_like(WIND_CONDITION_BROADCAST) + ), air_density=None, yaw_angles=np.zeros((1, N_TURBINES)), tilt_angles=np.ones((1, N_TURBINES)) * 5.0, @@ -221,6 +226,7 @@ def test_ct(): # Single floating turbine; note that 'tilt_interp' is not set to None thrust = thrust_coefficient( velocities=wind_speed * np.ones((1, 1, 3, 3)), # One findex, one turbine + turbulence_intensities=0.06 * np.ones((1, 1, 3, 3)), air_density=None, yaw_angles=np.zeros((1, 1)), tilt_angles=np.ones((1, 1)) * 5.0, @@ -255,6 +261,7 @@ def test_power(): turbine_type_map = turbine_type_map[None, :] test_power = power( velocities=wind_speed * np.ones((1, 1, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + turbulence_intensities=0.06 * np.ones((1, 1, 3, 3)), air_density=turbine.power_thrust_table["ref_air_density"], power_functions={turbine.turbine_type: turbine.power_function}, yaw_angles=np.zeros((1, 1)), # 1 findex, 1 turbine @@ -277,6 +284,7 @@ def test_power(): wind_speed = 18.0 rated_power = power( velocities=wind_speed * np.ones((1, 1, 3, 3)), + turbulence_intensities=0.06 * np.ones((1, 1, 3, 3)), air_density=turbine.power_thrust_table["ref_air_density"], power_functions={turbine.turbine_type: turbine.power_function}, yaw_angles=np.zeros((1, 1)), # 1 findex, 1 turbine @@ -295,6 +303,7 @@ def test_power(): wind_speed = 0.0 zero_power = power( velocities=wind_speed * np.ones((1, 1, 3, 3)), + turbulence_intensities=0.06 * np.ones((1, 1, 3, 3)), air_density=turbine.power_thrust_table["ref_air_density"], power_functions={turbine.turbine_type: turbine.power_function}, yaw_angles=np.zeros((1, 1)), # 1 findex, 1 turbine @@ -318,6 +327,7 @@ def test_power(): turbine_type_map = turbine_type_map[None, :] test_4_power = power( velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), + turbulence_intensities=0.06 * np.ones((1, n_turbines, 3, 3)), air_density=turbine.power_thrust_table["ref_air_density"], power_functions={turbine.turbine_type: turbine.power_function}, yaw_angles=np.zeros((1, n_turbines)), @@ -341,6 +351,7 @@ def test_power(): turbine_type_map = turbine_type_map[None, :] test_grid_power = power( velocities=wind_speed * np.ones((1, n_turbines, 1)), + turbulence_intensities=0.06 * np.ones((1, n_turbines, 3)), air_density=turbine.power_thrust_table["ref_air_density"], power_functions={turbine.turbine_type: turbine.power_function}, yaw_angles=np.zeros((1, n_turbines)), @@ -374,6 +385,7 @@ def test_axial_induction(): wind_speed = 10.0 ai = axial_induction( velocities=wind_speed * np.ones((1, 1, 3, 3)), # 1 findex, 1 Turbine + turbulence_intensities=0.06 * np.ones((1, 1, 3, 3)), air_density=None, yaw_angles=np.zeros((1, 1)), tilt_angles=np.ones((1, 1)) * 5.0, @@ -391,6 +403,10 @@ def test_axial_induction(): # Multiple turbines with ix filter ai = axial_induction( velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 12 x 4 x 3 x 3 + turbulence_intensities=( + 0.06 * np.ones((N_TURBINES, 3, 3)) + * np.ones_like(WIND_CONDITION_BROADCAST) + ), air_density=None, yaw_angles=np.zeros((1, N_TURBINES)), tilt_angles=np.ones((1, N_TURBINES)) * 5.0, @@ -413,6 +429,7 @@ def test_axial_induction(): # Single floating turbine; note that 'tilt_interp' is not set to None ai = axial_induction( velocities=wind_speed * np.ones((1, 1, 3, 3)), + turbulence_intensities=0.06 * np.ones((1, 1, 3, 3)), air_density=None, yaw_angles=np.zeros((1, 1)), tilt_angles=np.ones((1, 1)) * 5.0, From d7fe2e6fed453d1347298cfa73a48e10b14ec50f Mon Sep 17 00:00:00 2001 From: misi9170 <39596329+misi9170@users.noreply.github.com> Date: Tue, 7 May 2024 09:52:30 -0400 Subject: [PATCH 03/12] [BUGFIX] `NoneWakeTurbulence` returns zero (added) turbulence (#894) * NoneWakeTurbulence returns zero (added) turbulence, rather than ambient TI. * Update comment on setting multiple conditions. * Add test for NoneWakeTurbulence model. * Format layout list. --- examples/002_visualizations.py | 6 ++-- floris/core/wake_turbulence/none.py | 2 +- .../turbulence_models_regression_test.py | 30 +++++++++++++++++++ 3 files changed, 35 insertions(+), 3 deletions(-) create mode 100644 tests/reg_tests/turbulence_models_regression_test.py diff --git a/examples/002_visualizations.py b/examples/002_visualizations.py index f8c946324..8ed7f2a3d 100644 --- a/examples/002_visualizations.py +++ b/examples/002_visualizations.py @@ -69,8 +69,10 @@ # we show the horizontal plane at hub height, further examples are provided within # the examples_visualizations folder -# For flow visualizations, the FlorisModel must be set to run a single condition -# (n_findex = 1) +# For flow visualizations, the FlorisModel may be set to run a single condition +# (n_findex = 1). Otherwise, the user may set multiple conditions and then use +# the findex_for_viz keyword argument to calculate_horizontal_plane to specify which +# flow condition to visualize. fmodel.set(wind_speeds=[8.0], wind_directions=[290.0], turbulence_intensities=[0.06]) horizontal_plane = fmodel.calculate_horizontal_plane( x_resolution=200, diff --git a/floris/core/wake_turbulence/none.py b/floris/core/wake_turbulence/none.py index 146ca970b..09de7a30b 100644 --- a/floris/core/wake_turbulence/none.py +++ b/floris/core/wake_turbulence/none.py @@ -29,4 +29,4 @@ def function( self.logger.info( "The wake-turbulence model is set to 'none'. Turbulence model disabled." ) - return np.ones_like(x) * ambient_TI + return np.zeros_like(x) diff --git a/tests/reg_tests/turbulence_models_regression_test.py b/tests/reg_tests/turbulence_models_regression_test.py new file mode 100644 index 000000000..42e63be41 --- /dev/null +++ b/tests/reg_tests/turbulence_models_regression_test.py @@ -0,0 +1,30 @@ +from floris.core import Core +from floris.core.wake_turbulence import NoneWakeTurbulence + + +VELOCITY_MODEL = "gauss" +DEFLECTION_MODEL = "gauss" + +def test_NoneWakeTurbulence(sample_inputs_fixture): + + turbulence_intensities = [0.1, 0.05] + + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = "none" + sample_inputs_fixture.core["farm"]["layout_x"] = [0.0, 0.0, 600.0, 600.0] + sample_inputs_fixture.core["farm"]["layout_y"] = [0.0, 600.0, 0.0, 600.0] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = turbulence_intensities + + core = Core.from_dict(sample_inputs_fixture.core) + core.initialize_domain() + core.steady_state_atmospheric_condition() + + assert ( + core.flow_field.turbulence_intensity_field_sorted[0,:] == turbulence_intensities[0] + ).all() + assert ( + core.flow_field.turbulence_intensity_field_sorted[1,:] == turbulence_intensities[1] + ).all() From 19b018d2cdad0fc307a8f4113df482fd5d9a3a2e Mon Sep 17 00:00:00 2001 From: misi9170 <39596329+misi9170@users.noreply.github.com> Date: Wed, 8 May 2024 09:39:23 -0400 Subject: [PATCH 04/12] turbulence_intensities input added to turbine_preview code. (#900) --- floris/turbine_library/turbine_previewer.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/floris/turbine_library/turbine_previewer.py b/floris/turbine_library/turbine_previewer.py index 17d33d1d0..d8b20064f 100644 --- a/floris/turbine_library/turbine_previewer.py +++ b/floris/turbine_library/turbine_previewer.py @@ -104,6 +104,7 @@ def power_curve( power_mw = { k: power( velocities=wind_speeds.reshape(shape), + turbulence_intensities=np.zeros(shape), air_density=np.full(shape, v["ref_air_density"]), power_functions={self.turbine.turbine_type: self.turbine.power_function}, yaw_angles=np.zeros(shape), @@ -120,6 +121,7 @@ def power_curve( else: power_mw = power( velocities=wind_speeds.reshape(shape), + turbulence_intensities=np.zeros(shape), air_density=np.full(shape, self.turbine.power_thrust_table["ref_air_density"]), power_functions={self.turbine.turbine_type: self.turbine.power_function}, yaw_angles=np.zeros(shape), @@ -155,6 +157,7 @@ def thrust_coefficient_curve( ct_curve = { k: thrust_coefficient( velocities=wind_speeds.reshape(shape), + turbulence_intensities=np.zeros(shape), air_density=np.full(shape, v["ref_air_density"]), yaw_angles=np.zeros(shape), tilt_angles=np.full(shape, v["ref_tilt"]), @@ -174,6 +177,7 @@ def thrust_coefficient_curve( else: ct_curve = thrust_coefficient( velocities=wind_speeds.reshape(shape), + turbulence_intensities=np.zeros(shape), air_density=np.full(shape, self.turbine.power_thrust_table["ref_air_density"]), yaw_angles=np.zeros(shape), tilt_angles=np.full(shape, self.turbine.power_thrust_table["ref_tilt"]), From a313286848888b9cd090f9ffefdb5f01657f78bb Mon Sep 17 00:00:00 2001 From: paulf81 Date: Wed, 8 May 2024 17:06:34 -0600 Subject: [PATCH 05/12] Ignore includes in v3->v4 conversions (#904) --- floris/convert_floris_input_v3_to_v4.py | 46 ++++++++++++++++++------- tests/convert_v3_to_v4_test.py | 11 +++--- tests/v3_to_v4_convert_test/gch.yaml | 2 +- 3 files changed, 39 insertions(+), 20 deletions(-) diff --git a/floris/convert_floris_input_v3_to_v4.py b/floris/convert_floris_input_v3_to_v4.py index abdc7a76a..be2e99a50 100644 --- a/floris/convert_floris_input_v3_to_v4.py +++ b/floris/convert_floris_input_v3_to_v4.py @@ -1,11 +1,8 @@ - import sys from pathlib import Path import yaml -from floris.utilities import load_yaml - """ This script is intended to be called with an argument and converts a floris input @@ -19,12 +16,20 @@ """ +def ignore_include(loader, node): + # Parrot back the !include tag + return node.tag + " " + node.value + + if __name__ == "__main__": if len(sys.argv) != 2: raise Exception( "Usage: python convert_floris_input_v3_to_v4.py .yaml" ) + # Set the yaml loader to ignore the !include tag + yaml.SafeLoader.add_constructor("!include", ignore_include) + input_yaml = sys.argv[1] # Handling the path and new filename @@ -32,11 +37,12 @@ split_input = input_path.parts [filename_v3, extension] = split_input[-1].split(".") filename_v4 = filename_v3 + "_v4" - split_output = list(split_input[:-1]) + [filename_v4+"."+extension] + split_output = list(split_input[:-1]) + [filename_v4 + "." + extension] output_path = Path(*split_output) # Load existing v3 model - v3_floris_input_dict = load_yaml(input_yaml) + with open(input_yaml, "r") as file: + v3_floris_input_dict = yaml.safe_load(file) v4_floris_input_dict = v3_floris_input_dict.copy() # Change turbulence_intensity field to turbulence_intensities as list @@ -44,9 +50,9 @@ if "turbulence_intensity" in v3_floris_input_dict["flow_field"]: del v4_floris_input_dict["flow_field"]["turbulence_intensity"] elif "turbulence_intensity" in v3_floris_input_dict["flow_field"]: - v4_floris_input_dict["flow_field"]["turbulence_intensities"] = ( - [v3_floris_input_dict["flow_field"]["turbulence_intensity"]] - ) + v4_floris_input_dict["flow_field"]["turbulence_intensities"] = [ + v3_floris_input_dict["flow_field"]["turbulence_intensity"] + ] del v4_floris_input_dict["flow_field"]["turbulence_intensity"] # Change multidim_cp_ct velocity model to gauss @@ -64,10 +70,24 @@ # Add enable_active_wake_mixing field v4_floris_input_dict["wake"]["enable_active_wake_mixing"] = False - yaml.dump( - v4_floris_input_dict, - open(output_path, "w"), - sort_keys=False - ) + # Write the new v4 model to a new file, note that the in order to ignore the !include tag + # it is wrapped in single quotes by the ignore include/load/dump sequence and these will + # need to be removed in the next block of code + yaml.dump(v4_floris_input_dict, open(output_path, "w"), sort_keys=False) + + # Open the output file and loop through line by line + # if a line contains the substring !include, then strip all + # occurrences of ' from the line to remove the extra single quotes + # added by the ignore include/load/dump sequence + temp_output_path = output_path.with_name("temp.yaml") + with open(temp_output_path, "w") as file: + with open(output_path, "r") as f: + for line in f: + if "!include" in line: + line = line.replace("'", "") + file.write(line) + + # Move the temp file to the output file + temp_output_path.replace(output_path) print(output_path, "created.") diff --git a/tests/convert_v3_to_v4_test.py b/tests/convert_v3_to_v4_test.py index 9a015e860..66c038747 100644 --- a/tests/convert_v3_to_v4_test.py +++ b/tests/convert_v3_to_v4_test.py @@ -22,20 +22,19 @@ def test_v3_to_v4_convert(): # Change directory to the test folder os.chdir(CONVERT_FOLDER) - # Print the current directory - print(os.getcwd()) - # Run the converter on the turbine file os.system(f"python convert_turbine_v3_to_v4.py {filename_v3_turbine}") # Run the converter on the floris file os.system(f"python convert_floris_input_v3_to_v4.py {filename_v3_floris}") - # Go through the file filename_v4_floris and where the place-holder string "XXXXX" is found - # replace it with the string f"!include {filename_v4_turbine}" + # Go through the file filename_v4_floris and replace f"!include {filename_v3_turbine}" + # with f"!include {filename_v4_turbine}" with open(filename_v4_floris, "r") as file: filedata = file.read() - filedata = filedata.replace("XXXXX", f"!include {filename_v4_turbine}") + filedata = filedata.replace( + f"!include {filename_v3_turbine}", f"!include {filename_v4_turbine}" + ) with open(filename_v4_floris, "w") as file: file.write(filedata) diff --git a/tests/v3_to_v4_convert_test/gch.yaml b/tests/v3_to_v4_convert_test/gch.yaml index dc58985fc..b383e9c5b 100644 --- a/tests/v3_to_v4_convert_test/gch.yaml +++ b/tests/v3_to_v4_convert_test/gch.yaml @@ -87,7 +87,7 @@ farm: # The types can be either a name included in the turbine_library or # a full definition of a wind turbine directly. turbine_type: - - XXXXX + - !include nrel_5MW_v3.yaml ### # Configure the atmospheric conditions. From 0c437c442da29de26a701b9ec18f10df6755e52b Mon Sep 17 00:00:00 2001 From: paulf81 Date: Tue, 14 May 2024 09:04:21 -0600 Subject: [PATCH 06/12] Expanded capabilities for heterogeneity (#902) --- docs/_toc.yml | 1 + docs/heterogeneous_map.ipynb | 252 +++++++++++ .../001_heterogeneous_inflow_single.py | 11 +- ...y => 002_heterogeneous_using_wind_data.py} | 62 ++- .../003_heterogeneous_speedup_by_wd_and_ws.py | 113 +++++ ...d_3d.py => 004_heterogeneous_2d_and_3d.py} | 0 floris/__init__.py | 1 + floris/core/flow_field.py | 45 +- floris/floris_model.py | 17 + floris/flow_visualization.py | 94 +--- floris/heterogeneous_map.py | 421 ++++++++++++++++++ floris/wind_data.py | 335 ++++++++------ tests/heterogeneous_map_integration_test.py | 234 ++++++++++ tests/wind_data_integration_test.py | 139 ++++-- 14 files changed, 1440 insertions(+), 285 deletions(-) create mode 100644 docs/heterogeneous_map.ipynb rename examples/examples_heterogeneous/{002_heterogeneous_inflow_multi.py => 002_heterogeneous_using_wind_data.py} (63%) create mode 100644 examples/examples_heterogeneous/003_heterogeneous_speedup_by_wd_and_ws.py rename examples/examples_heterogeneous/{003_heterogeneous_2d_and_3d.py => 004_heterogeneous_2d_and_3d.py} (100%) create mode 100644 floris/heterogeneous_map.py create mode 100644 tests/heterogeneous_map_integration_test.py diff --git a/docs/_toc.yml b/docs/_toc.yml index d0d63ed72..784be504d 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -14,6 +14,7 @@ parts: - file: intro_concepts - file: advanced_concepts - file: wind_data_user + - file: heterogeneous_map - file: floating_wind_turbine - file: turbine_interaction - file: operation_models_user diff --git a/docs/heterogeneous_map.ipynb b/docs/heterogeneous_map.ipynb new file mode 100644 index 000000000..e28b8c05d --- /dev/null +++ b/docs/heterogeneous_map.ipynb @@ -0,0 +1,252 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# HeterogeneousMap" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "FLORIS provides a HeterogeneousMap object to enable a heterogeneity in the background wind speed. This notebook demonstrates how to use the HeterogeneousMap object in FLORIS." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that more detailed examples are provided within the examples_heterogeneous folder" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from floris import (\n", + " FlorisModel,\n", + " HeterogeneousMap,\n", + " TimeSeries,\n", + ")\n", + "from floris.flow_visualization import visualize_heterogeneous_cut_plane" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The HeterogeneousMap defines the heterogeneity in the background wind speed. For a set of x,y coordinates, a speed up (or low down), relative to the inflow wind speed, can be defined. This can vary according to the inflow wind speed and wind direction. For wind directions and wind speeds not directly defined with the HeterogeneousMap, the nearest defined value is used." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Define a map in which there is ab observed speed up for wind from the east (90 degrees)\n", + "# but not from the west (270 degrees)\n", + "heterogeneous_map = HeterogeneousMap(\n", + " x=np.array([0.0, 0.0, 250.0, 500.0, 500.0]),\n", + " y=np.array([0.0, 500.0, 250.0, 0.0, 500.0]),\n", + " speed_multipliers=np.array(\n", + " [\n", + " [1.0, 1.0, 1.0, 1.0, 1.0],\n", + " [1.0, 1.0, 1.0, 1.0, 1.0],\n", + " [1.5, 1.0, 1.25, 1.5, 1.0],\n", + " [1.0, 1.5, 1.25, 1.0, 1.5],\n", + " ]\n", + " ),\n", + " wind_directions=np.array([270.0, 270.0, 90.0, 90.0]),\n", + " wind_speeds=np.array([5.0, 10.0, 5.0, 10.0]),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "HeterogeneousMap includes methods to visualize the speed up for a given wind speed and wind direction. Note that in FLORIS, heterogeneity in the ambient flow only exists for points within the convex hull surrounding the defined points. This boundary is illustrated in the flow. All points outside the boundary are assume to be 1.0 * the inflow wind speed." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Heterogeneous speedup map for several directions and wind speeds')" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABPMAAAHPCAYAAAA24J/fAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3QUVRvA4d/spncCBBJKCKGHHmooAekdaSIgIAIqRUEB5bMAoqACIiIgWAARVLqKhd47SO+9hN5SIWX3fn/EHVjSYUMSeJ9zcs7unXfu3NmdnTd7984dTSmlEEIIIYQQQgghhBBCZHuGrG6AEEIIIYQQQgghhBAifaQzTwghhBBCCCGEEEKIHEI684QQQgghhBBCCCGEyCGkM08IIYQQQgghhBBCiBxCOvOEEEIIIYQQQgghhMghpDNPCCGEEEIIIYQQQogcQjrzhBBCCCGEEEIIIYTIIaQzTwghhBBCCCGEEEKIHEI684QQQgghhBBCCCGEyCGkM08IIYQQyRo5ciSapmV1M7K9f/75h4oVK+Lk5ISmady5cyerm5RjrVu3Dk3TWLdu3SOtn9wxW6RIEXr27Pn4jbOh7NimJ+3s2bNomsasWbMypf6ePXtSpEiRbF9ndpHZ74cQQgjbks48IYTIBLNmzULTNHbt2pXs8nr16lG2bNlHqnvevHl8+eWXj9E6IYSt3Lx5k06dOuHs7MyUKVOYM2cOrq6uWd0skQ1s2bKFkSNHSueuEEIIIWzOLqsbIIQQImPmzZvHwYMHGTRoUFY3RYhn3s6dO4mMjGT06NE0bNgwq5sjknHs2DEMhif/+/WWLVsYNWoUPXv2xMvLK1u06Vny7bffYjabs7oZQgghRKaQ/yKEEEJgNpu5d+9eVjdDiBzn2rVrAEk6ax5HdHS0zerKatlhXxwdHbG3t0815km3Mz1tEo/H3t4eR0fHrG6GEEIIkSmkM08IIbKRn376ieDgYJydnfH29qZz585cuHBBX16vXj3+/PNPzp07h6ZpaJpmNX9PbGwsI0aMoFixYjg6OlKoUCGGDRtGbGys1XY0TWPAgAHMnTuXoKAgHB0d+eeffwDYs2cPzZo1w8PDAzc3Nxo0aMC2bduStHX//v2Ehobi7OxMwYIF+fjjj5k5cyaapnH27Fmr2L///ps6derg6uqKu7s7LVq04NChQ1YxPXv2xM3NjbCwMNq2bYubmxt58+ZlyJAhmEwmq1iz2cyXX35JUFAQTk5O5MuXj1dffZXbt28naefUqVP1ffTz86N///5JLntLaf6qevXqUa9ePauyyZMnExQUhIuLC7ly5aJKlSrMmzcvyboPS2s9y1xfR48epVOnTnh4eJA7d27efPPNZDta0zpWLLZv307Tpk3x9PTExcWF0NBQNm/enCRu06ZNVK1aFScnJwIDA5k+fXqSmNTmVNI0jZEjRz7y/jzMcim65ThzcXGhWLFiLFy4EID169dTvXp1nJ2dKVmyJKtWrbJa/9y5c/Tr14+SJUvi7OxM7ty56dixY5Jj03JJ/IYNG3j11VfJnTs3Hh4edO/ePdnj6eE29ujRA4CqVauiaZrVcbRgwQL9PcqTJw/dunUjLCzMqg7LcX/q1CmaN2+Ou7s7Xbt2TXGbkZGRDBo0iCJFiuDo6IiPjw+NGjXi33//tYpL631fuHAhmqaxfv36JNuYPn06mqZx8OBBvezo0aN06NABb29vnJycqFKlCr///nuyr+X69evp168fPj4+FCxYEEj/+5ER6TlmIennO7V2QvrOV5bXpFOnTuTNm1c/Dt977z0g8fgfOnQoAAEBAfr52rK/yZ1zTp8+TceOHfH29sbFxYUaNWrw559/WsVY5hScP38+n3zyCQULFsTJyYkGDRpw8uRJq9gTJ07Qvn178ufPj5OTEwULFqRz586Eh4en+rpu3LiRjh07UrhwYT2PDB48mLt371rFZeScfefOHXr27ImnpydeXl706NEjXZcf37lzB6PRyFdffaWX3bhxA4PBQO7cuVFK6eWvv/46+fPnt2rfg/nRcv4aP348M2bMIDAwEEdHR6pWrcrOnTuTbHvp0qWULVsWJycnypYty5IlS9Jsr8WuXbto0qQJefLkwdnZmYCAAHr16pVsWyZOnIi/vz/Ozs6EhoZafe4s0vP5s7xegwYNolChQjg6OlKsWDE+++yzJCMU0/t+XLlyhZdffpmCBQvi6OiIr68vbdq0eazPrRBCCNuQy2yFECIThYeHc+PGjSTl8fHxSco++eQTPvjgAzp16kTv3r25fv06kydPpm7duuzZswcvLy/ee+89wsPDuXjxIhMnTgTAzc0NSOzgat26NZs2baJv376ULl2aAwcOMHHiRI4fP87SpUuttrdmzRrmz5/PgAEDyJMnD0WKFOHQoUPUqVMHDw8Phg0bhr29PdOnT6devXp65wlAWFgY9evXR9M0hg8fjqurK999912yoyDmzJlDjx49aNKkCZ999hkxMTFMmzaN2rVrs2fPHqsvWyaTiSZNmlC9enXGjx/PqlWrmDBhAoGBgbz++ut63KuvvsqsWbN4+eWXeeONNzhz5gxff/01e/bsYfPmzfqIl5EjRzJq1CgaNmzI66+/zrFjx5g2bRo7d+60ikuvb7/9ljfeeIMOHTronVL79+9n+/btdOnSxSbrderUiSJFijB27Fi2bdvGV199xe3bt/nxxx/1mPQcK5b3uFmzZgQHBzNixAgMBgMzZ87kueeeY+PGjVSrVg2AAwcO0LhxY/LmzcvIkSNJSEhgxIgR5MuXL0OvT3LSsz8puX37Ni1btqRz58507NiRadOm0blzZ+bOncugQYN47bXX6NKlC+PGjaNDhw5cuHABd3d3IPHy1y1bttC5c2cKFizI2bNnmTZtGvXq1ePw4cO4uLhYbWvAgAF4eXkxcuRI/Tg5d+6c3nmSnPfee4+SJUsyY8YMPvroIwICAggMDATQj8+qVasyduxYrl69yqRJk9i8ebPVewSQkJBAkyZNqF27NuPHj0/Stge99tprLFy4kAEDBlCmTBlu3rzJpk2bOHLkCJUrVwbS9763aNECNzc35s+fT2hoqNU2fv31V4KCgvR5PQ8dOkStWrUoUKAA7777Lq6ursyfP5+2bduyaNEinn/+eav1+/XrR968efnwww/1EW8ZfT/SYotjNrl2pvd8tX//furUqYO9vT19+/alSJEinDp1ij/++INPPvmEdu3acfz4cX7++WcmTpxInjx5AMibN2+ybbl69SohISHExMTwxhtvkDt3bmbPnk3r1q1ZuHBhktf4008/xWAwMGTIEMLDw/n888/p2rUr27dvByAuLo4mTZoQGxvLwIEDyZ8/P2FhYSxbtow7d+7g6emZ4uuyYMECYmJieP3118mdOzc7duxg8uTJXLx4kQULFljFpuecrZSiTZs2bNq0iddee43SpUuzZMkSvSM8NV5eXpQtW5YNGzbwxhtvAImduJqmcevWLQ4fPkxQUBCQ2AlZp06dNOucN28ekZGRvPrqq2iaxueff067du04ffq0nhNWrFhB+/btKVOmDGPHjuXmzZt6p1Zarl27ph+b7777Ll5eXpw9e5bFixcnif3xxx+JjIykf//+3Lt3j0mTJvHcc89x4MAB/VhO7+cvJiaG0NBQwsLCePXVVylcuDBbtmxh+PDhXL58WZ9rNyPvR/v27Tl06BADBw6kSJEiXLt2jZUrV3L+/Pmn9kYgQgiRYyghhBA2N3PmTAWk+hcUFKTHnz17VhmNRvXJJ59Y1XPgwAFlZ2dnVd6iRQvl7++fZJtz5sxRBoNBbdy40ar8m2++UYDavHmzXgYog8GgDh06ZBXbtm1b5eDgoE6dOqWXXbp0Sbm7u6u6devqZQMHDlSapqk9e/boZTdv3lTe3t4KUGfOnFFKKRUZGam8vLxUnz59rLZz5coV5enpaVXeo0cPBaiPPvrIKrZSpUoqODhYf75x40YFqLlz51rF/fPPP1bl165dUw4ODqpx48bKZDLpcV9//bUC1A8//KCX+fv7qx49eqiHhYaGqtDQUP15mzZtrN639ErPeiNGjFCAat26tVV5v379FKD27dunlEr/sWI2m1Xx4sVVkyZNlNls1uNiYmJUQECAatSokV7Wtm1b5eTkpM6dO6eXHT58WBmNRvXgvwpnzpxRgJo5c2aS9gNqxIgRGd6flISGhipAzZs3Ty87evSofuxu27ZNL1++fHmSdsXExCSpc+vWrQpQP/74o15m+awGBweruLg4vfzzzz9XgPrtt99Sbadl/Z07d+plcXFxysfHR5UtW1bdvXtXL1+2bJkC1IcffqiXWY77d999N9XtWHh6eqr+/funuDwj7/uLL76ofHx8VEJCgl52+fJlZTAYrD6HDRo0UOXKlVP37t2z2k5ISIgqXrx4kteidu3aVnVatv+w5N6PtWvXKkCtXbs21dchvcesUkk/3ym1MyPnq7p16yp3d3er7SulrF7zcePGWZ0PU2vToEGDFGB1/o6MjFQBAQGqSJEi+jnM8vqULl1axcbG6rGTJk1SgDpw4IBSSqk9e/YoQC1YsCDJttOS3Hs1duxYpWma1f6m95y9dOlSBajPP/9cL0tISFB16tRJ8XzyoP79+6t8+fLpz9966y1Vt25d5ePjo6ZNm6aUSsw/mqapSZMmWbXvwVxpOX/lzp1b3bp1Sy//7bffFKD++OMPvaxixYrK19dX3blzRy9bsWKFApLNvw9asmRJknPCwyxtcXZ2VhcvXtTLt2/frgA1ePBgvSy9n7/Ro0crV1dXdfz4cattvfvuu8poNKrz588rpdL/fty+fVsBaty4canurxBCiKwhl9kKIUQmmjJlCitXrkzyV758eau4xYsXYzab6dSpEzdu3ND/8ufPT/HixVm7dm2a21qwYAGlS5emVKlSVnU899xzAEnqCA0NpUyZMvpzk8nEihUraNu2LUWLFtXLfX196dKlC5s2bSIiIgKAf/75h5o1a1KxYkU9ztvbO8nlgStXruTOnTu8+OKLVm0yGo1Ur1492f167bXXrJ7XqVOH06dPW+2np6cnjRo1sqozODgYNzc3vc5Vq1YRFxfHoEGDrCaa79OnDx4eHkkuX0sPLy8vLl68mOwlWbZar3///lbPBw4cCMBff/0FpP9Y2bt3LydOnKBLly7cvHlTj4uOjqZBgwZs2LABs9mMyWRi+fLltG3blsKFC+vbLV26NE2aNMnQfj7K/qTGzc2Nzp07689LliyJl5cXpUuX1keJAvrjB48TZ2dn/XF8fDw3b96kWLFieHl5JbkkFaBv375WIzVff/117Ozs0tXOh+3atYtr167Rr18/nJyc9PIWLVpQqlSpZI+9B0eepsbLy4vt27dz6dKlZJen930HeOGFF7h27Rrr1q3T11+4cCFms5kXXngBgFu3brFmzRo6depEZGSkXt/Nmzdp0qQJJ06cSHLpcJ8+fTAajVZlGX0/UmOrY/bhdqb3fHX9+nU2bNhAr169rLYPpDiKMy1//fUX1apVo3bt2nqZm5sbffv25ezZsxw+fNgq/uWXX8bBwUF/bhmRZvkMWEbeLV++nJiYmAy15cH3Kjo6mhs3bhASEoJSij179iSJT+uc/ddff2FnZ2d1jBuNRv1ckJY6depw9epVjh07BiSOwKtbty516tRh48aNQOJoPaVUukbmvfDCC+TKlcuqfrj/2l2+fJm9e/fSo0cPqxGMjRo1ssqZKbGMul22bFmyo/Af1LZtWwoUKKA/r1atGtWrV9fPOxn5/C1YsIA6deqQK1cuq+O3YcOGmEwmNmzYAKT//XB2dsbBwYF169alOeWAEEKIJ08usxVCiExUrVo1qlSpkqTc8s+2xYkTJ1BKUbx48WTrSc/loCdOnODIkSMpXsZlmajfIiAgwOr59evXiYmJoWTJkknWLV26NGazmQsXLhAUFMS5c+eoWbNmkrhixYolaROgdyg+zMPDw+q5k5NTkvbnypXL6ovEiRMnCA8Px8fHJ9k6Lft57tw5gCT74+DgQNGiRfXlGfHOO++watUqqlWrRrFixWjcuDFdunShVq1aNlvv4WMgMDAQg8Ggz1GU3mPF8tqndilbeHg4sbGx3L17N9n6SpYs+UidWQ9Ka39SU7BgwSSdI56enhQqVChJGWB1nNy9e5exY8cyc+ZMwsLCrObWSm7OsIfb6ebmhq+v7yPNDZXSsQdQqlQpNm3aZFVmZ2eXrsv3AD7//HN69OhBoUKFCA4Opnnz5nTv3l3vgE/v+54rVy59Tr1ff/2VBg0aAImX2FasWJESJUoAcPLkSZRSfPDBB3zwwQfJ1nft2jWrDomHzy2Q8fcjNdevX7fJMftwO9N7vrJ0+lguQ7aFc+fOWXVQW5QuXVpf/uD2Hu5EtHROWT4DAQEBvPXWW3zxxRfMnTuXOnXq0Lp1a7p165bqJbYA58+f58MPP+T3339P0onz8HuVnnP2uXPn8PX11aeEsEju85EcS2fbxo0bKViwIHv27OHjjz8mb968jB8/Xl/m4eFBhQoV0qwvrdfO8vlN6fhKq/M5NDSU9u3bM2rUKCZOnEi9evVo27YtXbp0STIVRXLbKFGiBPPnzwcy9vk7ceIE+/fvT/N/gPS+H46Ojnz22We8/fbb5MuXjxo1atCyZUu6d+9uNTehEEKIrCGdeUIIkQ2YzWY0TePvv/9OMqIFSPJPd0p1lCtXji+++CLZ5Q93gDw4+iKzWEYAzZkzJ9l//u3srNNQcvueXJ0+Pj7MnTs32eUpfZFJTUqjaUwmk1WbSpcuzbFjx1i2bBn//PMPixYtYurUqXz44YeMGjUqxfofdb3k2pbeY8Xy2o8bN85qBOXDsQ/fHCUjbbF4eLL7R6kjOSkdDymVP9hBNHDgQGbOnMmgQYOoWbMmnp6eaJpG586dk0wGn9UcHR2tRo+mplOnTtSpU4clS5awYsUKxo0bx2effcbixYtp1qxZut93y3bbtm3LkiVLmDp1KlevXmXz5s2MGTNGj7XUN2TIkBRHvT3ciZ/cuSU7vh8PtzOj56uslJ7PwIQJE+jZsye//fYbK1as4I033tDnrkyp89hkMtGoUSNu3brFO++8Q6lSpXB1dSUsLIyePXsmea/Sc85+XH5+fgQEBLBhwwaKFCmCUoqaNWuSN29e3nzzTc6dO8fGjRsJCQlJ1+coPa/d49A0jYULF7Jt2zb++OMPli9fTq9evZgwYQLbtm1LVz63yMjnz2w206hRI4YNG5ZsnKWDPiMGDRpEq1atWLp0KcuXL+eDDz5g7NixrFmzhkqVKmW4PiGEELaTff4rEUKIZ1hgYCBKKQICAtL8hzulzpDAwED27dtHgwYNHulSr7x58+Li4qJfyvSgo0ePYjAY9A5Bf3//JHdOBJKUWW4G4OPjQ8OGDTPcpuQEBgayatUqatWqlWqHpL+/PwDHjh2zumw4Li6OM2fOWLUnV65cyd7J79y5c1brAri6uvLCCy/wwgsvEBcXR7t27fjkk08YPny41SWVD0vveidOnLAaMXTy5EnMZrM+2Xh6jxXLa+/h4ZHqa2+5E6dlVNKDHj4WLCNYHn6tUhvlmNb+ZJaFCxfSo0cPJkyYoJfdu3cvxTtonjhxgvr16+vPo6KiuHz5Ms2bN8/wth889h4e5XXs2DF9+aPy9fWlX79+9OvXj2vXrlG5cmU++eQTmjVrlu733eKFF15g9uzZrF69miNHjqCU0i+xBfTj397e/rE+wxl9P1KTkWM2I9J7vrK8JsnddfRBGTkP+/v7p3jutSx/FOXKlaNcuXK8//77bNmyhVq1avHNN9/w8ccfJxt/4MABjh8/zuzZs+nevbtevnLlykfaPiS2ffXq1URFRVl1ZGXkvapTpw4bNmwgICCAihUr4u7uToUKFfD09OSff/7h33//TfOHkYy0F3js46tGjRrUqFGDTz75hHnz5tG1a1d++eUXevfurcckt43jx4/r58eMfP4CAwOJiopKMy6j70dgYCBvv/02b7/9NidOnKBixYpMmDCBn376KdXtCCGEyFwyZ54QQmQD7dq1w2g0MmrUqCSjA5RS3Lx5U3/u6uqa7GVpnTp1IiwsjG+//TbJsrt37+p3a0yJ0WikcePG/Pbbb1aXFl69epV58+ZRu3Zt/TKzJk2asHXrVvbu3avH3bp1K8louSZNmuDh4cGYMWOSnTvo+vXrqbYpOZ06dcJkMjF69OgkyxISEvTOgYYNG+Lg4MBXX31l9Zp+//33hIeH06JFC70sMDCQbdu2ERcXp5ctW7aMCxcuWNX/4PsAiZfslilTBqVUqnMjZWS9KVOmWD2fPHkyAM2aNQPSf6wEBwcTGBjI+PHjiYqKStImy2tvNBpp0qQJS5cu5fz58/ryI0eOsHz5cqt1PDw8yJMnjz73ksXUqVNT3Pe09iezGI3GJK/P5MmTUxxFOGPGDKv3Ytq0aSQkJDxSO6tUqYKPjw/ffPON1cjHv//+myNHjlgdexlhMpmSfPZ9fHzw8/PTt5Pe992iYcOGeHt78+uvv/Lrr79SrVo1q85XHx8f6tWrx/Tp07l8+XKa9aUko+9HWnWl95jNiPSer/LmzUvdunX54YcfrLYP1qO7XF1dgaSd38lp3rw5O3bsYOvWrXpZdHQ0M2bMoEiRIumaq+1BERERJCQkWJWVK1cOg8GQ6mhcy6i1B/dDKcWkSZMytP0HNW/enISEBKZNm6aXmUwm/VyQHnXq1OHs2bP8+uuv+mW3BoOBkJAQvvjiC+Lj49M1X156+Pr6UrFiRWbPnm31eVu5cmWSuQuTc/v27STHumWU7MOv/dKlS63mnNyxYwfbt2/XzzsZ+fx16tSJrVu3JvsZuHPnjn48pPf9iImJ4d69e1ZlgYGBuLu7Z2hEtxBCiMwhI/OEECIbCAwM5OOPP2b48OGcPXuWtm3b4u7uzpkzZ1iyZAl9+/ZlyJAhQOKX9V9//ZW33nqLqlWr4ubmRqtWrXjppZeYP38+r732GmvXrqVWrVqYTCaOHj3K/PnzWb58ebLz9z3o448/ZuXKldSuXZt+/fphZ2fH9OnTiY2N5fPPP9fjhg0bxk8//USjRo0YOHAgrq6ufPfddxQuXJhbt27pI1I8PDyYNm0aL730EpUrV6Zz587kzZuX8+fP8+eff1KrVi2+/vrrDL1WoaGhvPrqq4wdO5a9e/fSuHFj7O3tOXHiBAsWLGDSpEl06NCBvHnzMnz4cEaNGkXTpk1p3bo1x44dY+rUqVStWpVu3brpdfbu3ZuFCxfStGlTOnXqxKlTp/jpp5/0kToWjRs3Jn/+/NSqVYt8+fJx5MgRvv76a1q0aIG7u3uKbc7IemfOnKF169Y0bdqUrVu38tNPP9GlSxd9Lqj0HisGg4HvvvuOZs2aERQUxMsvv0yBAgUICwtj7dq1eHh48McffwAwatQo/vnnH+rUqUO/fv1ISEhg8uTJBAUFsX//fqv29e7dm08//ZTevXtTpUoVNmzYwPHjx1Pc97T2J7O0bNmSOXPm4OnpSZkyZdi6dSurVq0id+7cycbHxcXRoEEDOnXqpB8ntWvXpnXr1hnetr29PZ999hkvv/wyoaGhvPjii1y9epVJkyZRpEgRBg8e/Ej7FBkZScGCBenQoQMVKlTAzc2NVatWsXPnTn3EW0bed0tb27Vrxy+//EJ0dLQ+B9mDpkyZQu3atSlXrhx9+vShaNGiXL16la1bt3Lx4kX27duXZtsz+n6kJSPHbHpl5Hz11VdfUbt2bSpXrkzfvn0JCAjg7Nmz/Pnnn/qPHMHBwQC89957dO7cGXt7e1q1aqV38j3o3Xff5eeff6ZZs2a88cYbeHt7M3v2bM6cOcOiRYvSfRm2xZo1axgwYAAdO3akRIkSJCQkMGfOHIxGI+3bt09xvVKlShEYGMiQIUMICwvDw8ODRYsWPdYNEFq1akWtWrV49913OXv2LGXKlGHx4sUZmivR0lF37Ngxq8vA69aty99//42joyNVq1Z95DY+bOzYsbRo0YLatWvTq1cvbt26pR9fyXWSP2j27NlMnTqV559/nsDAQCIjI/n222/x8PBIMtK3WLFi1K5dm9dff53Y2Fi+/PJLcufObXWpbHo/f0OHDuX333+nZcuW9OzZk+DgYKKjozlw4AALFy7k7Nmz5MmTJ93vx/Hjx/VzYpkyZbCzs2PJkiVcvXrV6sZEQgghssiTuWmuEEI8W2bOnKkAtXPnzmSXh4aGqqCgoCTlixYtUrVr11aurq7K1dVVlSpVSvXv318dO3ZMj4mKilJdunRRXl5eClD+/v76sri4OPXZZ5+poKAg5ejoqHLlyqWCg4PVqFGjVHh4uB4HqP79+yfbtn///Vc1adJEubm5KRcXF1W/fn21ZcuWJHF79uxRderUUY6OjqpgwYJq7Nix6quvvlKAunLlilXs2rVrVZMmTZSnp6dycnJSgYGBqmfPnmrXrl16TI8ePZSrq2uS7YwYMUIll65mzJihgoODlbOzs3J3d1flypVTw4YNU5cuXbKK+/rrr1WpUqWUvb29ypcvn3r99dfV7du3k9Q3YcIEVaBAAeXo6Khq1aqldu3apUJDQ1VoaKgeM336dFW3bl2VO3du5ejoqAIDA9XQoUOtXtvkpGc9y34ePnxYdejQQbm7u6tcuXKpAQMGqLt37yapMz3HilKJ71O7du30bfv7+6tOnTqp1atXW8WtX79eBQcHKwcHB1W0aFH1zTffJPvax8TEqFdeeUV5enoqd3d31alTJ3Xt2jUFqBEjRjzy/jwspc+Iv7+/atGiRZLyh4/p27dvq5dfflnlyZNHubm5qSZNmqijR48qf39/1aNHDz3O8lldv3696tu3r8qVK5dyc3NTXbt2VTdv3kyznal91n/99VdVqVIl5ejoqLy9vVXXrl3VxYsXrWJSOu6TExsbq4YOHaoqVKig3N3dlaurq6pQoYKaOnVqktj0vu9KKbVy5UoFKE3T1IULF5Ld9qlTp1T37t1V/vz5lb29vSpQoIBq2bKlWrhwYbpei/S+H2vXrlWAWrt2bZqvR3qP2ZTe85TOz+k5Xyml1MGDB9Xzzz+vvLy8lJOTkypZsqT64IMPrGJGjx6tChQooAwGgwLUmTNnkm2TUomvcYcOHfT6qlWrppYtW5akbYBasGCBVfmZM2cUoGbOnKmUUur06dOqV69eKjAwUDk5OSlvb29Vv359tWrVqtReUqWUUocPH1YNGzZUbm5uKk+ePKpPnz5q3759VvUrlbFz9s2bN9VLL72kPDw8lKenp3rppZfUnj17ktSZGh8fHwWoq1ev6mWbNm1SgKpTp06S+B49eljlR8trNG7cuCSxD5+/lEo8x5YuXVo5OjqqMmXKqMWLFyepMzn//vuvevHFF1XhwoWVo6Oj8vHxUS1btrQ6fh5sy4QJE1ShQoWUo6OjqlOnjtq3b1+SOtPz+VNKqcjISDV8+HBVrFgx5eDgoPLkyaNCQkLU+PHjVVxcnB6Xnvfjxo0bqn///qpUqVLK1dVVeXp6qurVq6v58+enuv9CCCGeDE0pG832KoQQ4pk3aNAgpk+fTlRU1BOZGP1pMnLkSEaNGsX169fJkydPVjfnseWU/Zk1axYvv/wyO3fuTHPkqhBC2MLZs2cJCAhg3Lhx+qh7IYQQIiNkzjwhhBCP5O7du1bPb968yZw5c6hdu7Z05AkhhBBCCCFEJpE584QQQjySmjVrUq9ePUqXLs3Vq1f5/vvviYiI4IMPPsjqpgkhhBBCCCHEU0s684QQQjyS5s2bs3DhQmbMmIGmaVSuXJnvv/+eunXrZnXThBBCCCGEEOKpJXPmCSGEEEIIIYQQQgiRQ8iceUIIIYQQQgghhBBC5BDSmSeEEEIIIYQQQgghRA4hnXlCCCGEEEIIIYQQQuQQ0pknhBBCCCGEEEIIIUQOIZ15QgghhBBCCCGEEELkENKZJ4QQQgghhBBCCCFEDiGdeUIIIYQQQgghhBBC5BDSmSeEEEIIIYQQQgghRA4hnXlCCCGEEEIIIYQQQuQQ0pknhBBCCCGEEEIIIUQOIZ15QgghhBBCCCGEEELkENKZJ4QQQgghhBBCCCFEDiGdeUIIIYQQQgghhBBC5BDSmSeEEEIIIYQQQgghRA4hnXlCCCGEEEIIIYQQQuQQ0pknhBBCCCGEEEIIIUQOIZ15QgghhBBCCCGEEELkENKZJ4QQQgghhBBCCJGNbNiwgVatWuHn54emaSxdujTLt9ezZ080TbP6a9q06SNv8/Lly3Tp0oUSJUpgMBgYNGjQo+/AM0Y684QQQgghhBBCCCGykejoaCpUqMCUKVOy1faaNm3K5cuX9b+ff/45xdizZ8+iaVqKy2NjY8mbNy/vv/8+FSpUeOS2P4vssroBQgghhBBCCCGEEOK+Zs2a0axZsxSXx8bG8t577/Hzzz9z584dypYty2effUa9evUyZXsWjo6O5M+f/5G28bAiRYowadIkAH744Qeb1PmskJF5QgghhBBCCCGEEDnIgAED2Lp1K7/88gv79++nY8eONG3alBMnTmTqdtetW4ePjw8lS5bk9ddf5+bNm5m6PZE8GZknhBBCCCGEEEIIkUOcP3+emTNncv78efz8/AAYMmQI//zzDzNnzmTMmDGZst2mTZvSrl07AgICOHXqFP/73/9o1qwZW7duxWg0Zso2RfKkM08IIYQQQgghhBAihzhw4AAmk4kSJUpYlcfGxpI7d24Ajh49SunSpVOt55133uHTTz9N93Y7d+6sPy5Xrhzly5cnMDCQdevW0aBBAwCCgoI4d+4cAEopANzc3PT16tSpw99//53ubYrkSWeeEEIIIYQQQgghRA4RFRWF0Whk9+7dSUbEWTrOihYtypEjR1Ktx9Lx96iKFi1Knjx5OHnypN6Z99dffxEfHw9AWFgY9erVY+/evfo6zs7Oj7VNkUg684QQQgghhBBCCCFyiEqVKmEymbh27Rp16tRJNsbBwYFSpUplajsuXrzIzZs38fX11cv8/f31x3Z2iV1OxYoVy9R2PIukM08IIYQQQgghhBAiG4mKiuLkyZP68zNnzrB37168vb0pUaIEXbt2pXv37kyYMIFKlSpx/fp1Vq9eTfny5WnRooVNt1e4cGGioqIYNWoU7du3J3/+/Jw6dYphw4ZRrFgxmjRp8sj7aRm1FxUVxfXr19m7dy8ODg6UKVPmket8FmjKchGzEEIIIYQQQgghhMhy69ato379+knKe/TowaxZs4iPj+fjjz/mxx9/JCwsjDx58lCjRg1GjRpFuXLlbL69u3fv0rZtW/bs2cOdO3fw8/OjcePGjB49mnz58iVb59mzZwkICCC1bidN05KU+fv7c/bs2Qzvw7NEOvOEEEIIIYQQQgghRI41bdo0pk2bpncCBgUF8eGHH9KsWbNk4+Pj4xk7diyzZ88mLCyMkiVL8tlnn9G0aVM9JjIykg8++IAlS5Zw7do1KlWqxKRJk6hataoek1xnJMDnn3/O0KFDbbeDDzFkWs1CCCGEEEIIIYQQQmSyggUL8umnn7J792527drFc889R5s2bTh06FCy8e+//z7Tp09n8uTJHD58mNdee43nn3+ePXv26DG9e/dm5cqVzJkzhwMHDtC4cWMaNmxIWFiYHnP58mWrvx9++AFN02jfvn2m7q+MzBNCCCGEEEIIIYQQTxVvb2/GjRvHK6+8kmSZn58f7733Hv3799fL2rdvj7OzMz/99BN3797F3d2d3377zWoOwuDgYJo1a8bHH3+c7Dbbtm1LZGQkq1evtv0OPUBugCGEENnEvXv3iIuLs1l9Dg4OODk52aw+IYQQOZ8tc43kGSGEEA+zZZ5RSiW5jNXR0RFHR8dU1zOZTCxYsIDo6Ghq1qyZbExsbGySHObs7MymTZsASEhIwGQypRrzsKtXr/Lnn38ye/bsVNtnC9KZJ4QQ2cC9e/cI8HfjyjWTzerMnz8/Z86ckS9aQgghANvnGskzQgghHnTv3j08nXMRxz2b1Ofm5kZUVJRV2YgRIxg5cmSy8QcOHKBmzZrcu3cPNzc3lixZkuJdcZs0acIXX3xB3bp1CQwMZPXq1SxevBiTKTFHuru7U7NmTUaPHk3p0qXJly8fP//8M1u3bqVYsWLJ1jl79mzc3d1p167do+90OslltkIIkQ1ERETg6enJud1F8HB//OlMIyLN+AefJTw8HA8PDxu0UAghRE5ny1wjeUYIIcTDLHmmNs2xw/6x6kognk38xYULF6zyTGoj8+Li4jh//jzh4eEsXLiQ7777jvXr1yfboXf9+nX69OnDH3/8gaZpBAYG0rBhQ3744Qfu3r0LwKlTp+jVqxcbNmzAaDRSuXJlSpQowe7duzly5EiSOkuVKkWjRo2YPHnyY+17esjIPCGEyEY83A14uBuzuhlCCCGeYpJrhBBCZCY77LHTHq8zj/+GnXl4eKT7RyMHBwd91FxwcDA7d+5k0qRJTJ8+PUls3rx5Wbp0Kffu3ePmzZv4+fnx7rvvUrRoUT0mMDCQ9evXEx0dTUREBL6+vrzwwgtWMRYbN27k2LFj/Prrr4+wsxknd7MVQgghhBBCCCGEEE8Vs9lMbGxsqjFOTk4UKFCAhIQEFi1aRJs2bZLEuLq64uvry+3bt1m+fHmyMd9//z3BwcFUqFDBZu1PjYzME0IIIYQQQgghhBA51vDhw2nWrBmFCxcmMjKSefPmsW7dOpYvXw5A9+7dKVCgAGPHjgVg+/bthIWFUbFiRcLCwhg5ciRms5lhw4bpdS5fvhylFCVLluTkyZMMHTqUUqVK8fLLL1ttOyIiggULFjBhwoQntr/SmSeEEEIIIYQQQgghcqxr167RvXt3Ll++jKenJ+XLl2f58uU0atQIgPPnz2Mw3L849d69e7z//vucPn0aNzc3mjdvzpw5c/Dy8tJjwsPDGT58OBcvXsTb25v27dvzySefYG9vfQnxL7/8glKKF1988YnsK8gNMIQQIluwTBZ7+3hRm8xjFBFpIleJ0zIxuRBCCJ0tc43kGSGEEA+z5Jl6tHnsOfMSVDzr+E3yTApkzjwhhBBCCCGEEEIIIXII6cwTQgghhBBCCCGEECKHkM48IYQQQgghhBBCCCFyCOnME0IIIYQQQgghhBAih5DOPCGEEGzYsIFWrVrh5+eHpmksXbo03etu3rwZOzs7KlasaFVuMpn44IMPCAgIwNnZmcDAQEaPHo3cd0kIIZ49kmeEEEII25HOPCGEEERHR1OhQgWmTJmSofXu3LlD9+7dadCgQZJln332GdOmTePrr7/myJEjfPbZZ3z++edMnjzZVs0WQgiRQ0ieEUIIIWxHOvOecevWrUPTNNatW5et67QYOXIkmqbZvN7HkR3bJERGNWvWjI8//pjnn38+Q+u99tprdOnShZo1ayZZtmXLFtq0aUOLFi0oUqQIHTp0oHHjxuzYscNWzRbZjOSUx5cd2ySELUieEbYgeebxZcc2CSEyTjrzcrD58+ejaRpLlixJsqxChQpomsbatWuTLCtcuDAhISFPoompmjVrFpqm6X9OTk74+fnRpEkTvvrqKyIjI7O6ibqYmBhGjhyZKUk+O4mLi2PMmDGUKlUKJycn8uXLR4sWLbh48aJVXGxsLO+88w5+fn44OztTvXp1Vq5cme7thIWF0alTJ7y8vPDw8KBNmzacPn3a1rsjgIiICKu/2NhYm9U9c+ZMTp8+zYgRI5JdHhISwurVqzl+/DgA+/btY9OmTTRr1sxmbRC2IznlyXkWcsqKFSt45ZVXKFu2LEajkSJFiiQbd+nSJbp160bJkiVxd3fHy8uLatWqMXv27GQvlXzc/LFlyxZq166Ni4sL+fPn54033iAqKupRd1MgeUakn+SZJ+dpzzMxMTFMmTKFxo0b4+vri7u7O5UqVWLatGmYTKYk8ZcvX6Zv375Wl+S/9dZb3Lx5M0nskSNHaNq0KW5ubnh7e/PSSy9x/fr1dLft999/p3Llyjg5OVG4cGFGjBhBQkLCY+2vEMmRzrwcrHbt2gBs2rTJqjwiIoKDBw9iZ2fH5s2brZZduHCBCxcu6OvWrVuXu3fvUrdu3SfT6GR89NFHzJkzh2nTpjFw4EAABg0aRLly5di/f79V7Pvvv8/du3efeBtjYmIYNWpUsgkxq9pka/Hx8bRo0YJPPvmEpk2bMnXqVIYNG4arqyvh4eFWsT179uSLL76ga9euTJo0CaPRSPPmzZMci8mJioqifv36rF+/nv/973+MGjWKPXv2EBoammxCFY+nUKFCeHp66n9jx461Sb0nTpzg3Xff5aeffsLOzi7ZmHfffZfOnTtTqlQp7O3tqVSpEoMGDaJr1642aYOwLckpT86zkFPmzZvHvHnz8PT0xM/PL8W4GzducPHiRTp06MD48eP5+OOP8fX1pWfPnrz33ntWsY+bP/bu3UuDBg2IiYnhiy++oHfv3syYMYOOHTs+9v4+yyTPiPSSPPPkPO155vTp0wwcOBClFG+99Rbjx48nICCAfv360atXL6vYqKgoatasyZIlS+jevTuTJ0+mefPmfP311zRs2BCz2azHXrx4kbp163Ly5EnGjBnDkCFD+PPPP2nUqBFxcXFptuvvv/+mbdu2eHl5MXnyZNq2bcvHH3+sHydC2FLymVHkCH5+fgQEBCRJiFu3bkUpRceOHZMsszy3JESDwYCTk9OTaXAKmjVrRpUqVfTnw4cPZ82aNbRs2ZLWrVtz5MgRnJ2dAbCzs0vxHzoLs9lMXFzcE9uv9LQpJ5g4cSLr169n06ZNVKtWLcW4HTt28MsvvzBu3DiGDBkCQPfu3SlbtizDhg1jy5YtqW5n6tSpnDhxgh07dlC1alUg8RgoW7YsEyZMYMyYMbbbKcGFCxfw8PDQnzs6Oj52nSaTiS5dujBq1ChKlCiRYtz8+fOZO3cu8+bNIygoiL179zJo0CD8/Pzo0aPHY7dD2JbklORJTnk0Y8aM4dtvv8Xe3p6WLVty8ODBZOPKly+f5MvmgAEDaNWqFV999RWjR4/GaDQCj58//ve//5ErVy7WrVunnxeLFClCnz59WLFiBY0bN37MvX42SZ4R6SV5JnmSZzIuf/78HDhwgKCgIL3s1VdfpVevXsycOZMPPviAYsWKAYkj5c6dO8eyZcto0aKFHu/t7c1HH33Evn37qFSpEpCYu6Kjo9m9ezeFCxcGoFq1ajRq1IhZs2bRt2/fVNs1ZMgQypcvz4oVK/TX2MPDgzFjxvDmm29SqlQpm74O4tkmI/NyuNq1a7Nnzx6rX1c2b95MUFAQzZo1Y9u2bVa/NmzevBlN06hVqxaQ/BwR9erVo2zZshw+fJj69evj4uJCgQIF+Pzzz5Ns/+LFi7Rt2xZXV1d8fHwYPHiwTS6veO655/jggw84d+4cP/30k16e3BwPmqYxYMAA5s6dS1BQEI6Ojvzzzz9A4uU4vXr1Il++fDg6OhIUFMQPP/yQZHv37t1j5MiRlChRAicnJ3x9fWnXrh2nTp3i7Nmz5M2bF4BRo0bpQ+tHjhyZYpsSEhIYPXo0gYGBODo6UqRIEf73v/8leW2KFClCy5Yt9Q40JycnihYtyo8//vjYr2FGmM1mJk2axPPPP0+1atVISEggJiYm2diFCxdiNBqtkpmTkxOvvPIKW7du5cKFC6lua+HChVStWlX/IgZQqlQpGjRowPz5822zQ0Ln4eFh9WeLL1mRkZHs2rWLAQMG6P8QWv4ZsrOzY82aNQAMHTpUHzVRrlw5XnrpJQYPHmyzURvC9iSnSE6xFT8/P+zt7R95/SJFihATE2M1EuJx8kdERAQrV66kW7duVh1P3bt3x83NTfLPY5A8IzJC8ozkGVvIkyePVUeehWVOziNHjuhlERERAOTLl88q1tfXF0DveAVYtGgRLVu21DvyABo2bEiJEiXSzBOHDx/m8OHD9O3b16qztF+/fiilWLhwYXp3T4h0kc68HK527drEx8ezfft2vWzz5s2EhIQQEhJCeHi41a/hmzdvplSpUuTOnTvVem/fvk3Tpk2pUKECEyZMoFSpUrzzzjv8/fffeszdu3dp0KABy5cvZ8CAAbz33nts3LiRYcOG2WTfXnrpJSBx3p20rFmzhsGDB/PCCy8wadIkihQpwtWrV6lRowarVq1iwIABTJo0iWLFivHKK6/w5Zdf6uuaTCZatmzJqFGjCA4OZsKECbz55pv6a5c3b16mTZsGJCaIOXPmMGfOHNq1a5die3r37s2HH35I5cqVmThxIqGhoYwdO5bOnTsniT158iQdOnSgUaNGTJgwgVy5ctGzZ08OHTqU5n7fvn2bGzdupPmXUsecxeHDh7l06RLly5enb9++uLq64urqSvny5ZPMXbJnzx5KlChh9WUI0Efz7d27N8XtmM1m9u/fb/Vr5oPrnzp1KlvNNyKS5+HhwYEDB9i7d6/+99prr1GyZEn27t1L9erVgcRLPAwG6zRjNBqt/kkX2YvklESSUx4vpzyKu3fvcuPGDc6ePcvs2bOZOXMmNWvW1L9kPW7+OHDgAAkJCUnWd3BwoGLFiuzZs8e2OyQei+SZp5fkmUSSZzInz1y5cgVI7OyzqFu3LgaDgTfffJNt27Zx8eJF/vrrLz755BPatm2rj5YLCwvj2rVrKeaZtPKEZfnD6/v5+VGwYEHJM8L2lMjRDh06pAA1evRopZRS8fHxytXVVc2ePVsppVS+fPnUlClTlFJKRUREKKPRqPr06aOvv3btWgWotWvX6mWhoaEKUD/++KNeFhsbq/Lnz6/at2+vl3355ZcKUPPnz9fLoqOjVbFixZLUmZyZM2cqQO3cuTPFGE9PT1WpUiX9+YgRI9TDhy2gDAaDOnTokFX5K6+8onx9fdWNGzesyjt37qw8PT1VTEyMUkqpH374QQHqiy++SLJ9s9mslFLq+vXrClAjRoxIEvNwm/bu3asA1bt3b6u4IUOGKECtWbNGL/P391eA2rBhg1527do15ejoqN5+++1kX5MHWdZP6y+5dj9o8eLFClC5c+dWxYsXVzNnzlQzZ85UxYsXVw4ODmrfvn16bFBQkHruueeS1GE5Fr/55psUt2N5HT/66KMky6ZMmaIAdfTo0TT3+2kUHh6uAHX7eFFlulz8sf9uHy+qABUeHp6u7UdGRqo9e/aoPXv26J+HPXv2qHPnzimllHr33XfVSy+9lOL6I0aMUBUqVLAq69GjhypQoIBatmyZOnPmjFq8eLHKkyePGjZs2CO/TiJzSU6RnGKLnPKwFi1aKH9//1Rjxo4da7WNBg0aqPPnz+vLHzd/LFiwIMlrY9GxY0eVP3/+9O9QDmbLXCN5RjwKyTOSZzIjzyiV+J6XKVNGBQQEqPj4eKtl3333nfLy8rLaRo8ePazidu7cmeQ4shg6dKgC1L1791Lc/rhx4xRglbssqlatqmrUqJHhfcqJLHmmHm1UQ63DY/3Vo02G8syzJmdfLC8oXbo0uXPn1ueT2LdvH9HR0fodn0JCQti8eTP9+vVj69atmEwmfc6J1Li5udGtWzf9uYODA9WqVbO6Y9xff/2Fr68vHTp00MtcXFzo27evzX7hcnNzS9dIrdDQUMqUKaM/V0qxaNEiOnXqhFKKGzdu6MuaNGnCL7/8wr///kutWrVYtGgRefLkSXZi0ke5bftff/0FwFtvvWVV/vbbbzN+/Hj+/PNP6tevr5eXKVOGOnXq6M/z5s1LyZIl03V3vrlz56ZrAtuiRYumutxyJ7/IyEj27NlDoUKFgMRLBooVK8bnn3+uXzJw9+7dZC+hsczzkVp7LMsedX2ReXbt2mV1XFqO3x49ejBr1iwuX77M+fPnM1Tn5MmT+eCDD+jXrx/Xrl3Dz8+PV199lQ8//NCmbRe2IzklkeSU1KWVUx7Fiy++SJUqVbh+/TrLli3j6tWrVm153PyR1vqSezKf5BkBkmcsJM+k7lHyzIABAzh8+DB//vlnkjkBCxQoQLVq1WjevDn+/v5s3LiRr776ijx58jB+/Hgg/XkmpakE0lrfcrmvELYinXk5nKZphISEsGHDBsxmM5s3b8bHx0ef8DMkJISvv/4aQL87VHoSYsGCBZMkg1y5clndoencuXMUK1YsSVzJkiUfa58eFBUVhY+PT5pxAQEBVs+vX7/OnTt3mDFjBjNmzEh2nWvXrgFw6tQpSpYsabOJYM+dO4fBYNDfA4v8+fPj5eXFuXPnrMofnJPBIleuXNy+fTvNbVnmD3lclsuYatWqpXfkWdpWu3Ztq5taODs7Jzu3yL1796zqSm07j7q+yDz16tVDKZXi8lmzZqW6/siRI/W5WCzc3d358ssvrS4NEdmb5JREklOePH9/f/z9/YHEjr2+ffvSsGFDjh07hrOz82Pnj7TWl9yT+STPCJA8YyF5xrbGjRvHt99+y+jRo2nevLnVss2bN9OyZUu2bdumXwLbtm1bPDw8GDVqFL169aJMmTKSZ0SOI515T4HatWvzxx9/cODAAX3OCYuQkBCGDh1KWFgYmzZtws/PL12/dFjuHPew1P4Js7WLFy8SHh6eJLEk5+GTo2WulG7duqV4N7Py5cs/fiNTkd5fxh7ntb5+/TomkynNODc3N9zc3FJc7ufnBySdGBbAx8fHao4HX19fwsLCksRdvnzZqq7keHt74+joqMdmdH0hROaTnCI5JS1p5RRb6NChA99++y0bNmygSZMmj50/LBOdp7S+5B4hnhzJM5Jn0pKRPDNr1izeeecdXnvtNd5///0ky6dPn06+fPmSzGXXunVrRo4cyZYtWyhTpkyaecKSh1Ly4PoPDo6wlFnmFxfCVqQz7ylg+bVq06ZNbN68mUGDBunLgoODcXR0ZN26dWzfvj3JLxWPw9/fn4MHD6KUsjr5Hzt2zCb1z5kzB0gcWp5RefPmxd3dHZPJRMOGDVONDQwMZPv27cTHx6d4572MDFn39/fHbDZz4sQJSpcurZdfvXqVO3fu6CMPbKFq1apJfi1LzogRI5L8mv2gcuXKYW9vn2wn3aVLl/Q7YgFUrFiRtWvXEhERYXUTDMtExhUrVkxxOwaDgXLlyrFr164ky7Zv307RokVxd3dPc3+EEJlHckpSklOspZVTbMFyuVJ4eDjw+PmjbNmy2NnZsWvXLjp16qSXx8XFsXfvXqsyIUTmkjyTlOQZa+nNM7/99hu9e/emXbt2TJkyJdmYq1evJtuBGB8fDyTeyRcSL8XNmzdvsnlmx44dqX7HgfvfgXbt2mXVcXfp0iUuXrxI375909wfITJC7mb7FKhSpQpOTk7MnTuXsLAwq1+3HB0dqVy5MlOmTCE6Ojpdw9TTq3nz5ly6dMnqNtsxMTEpDg3PiDVr1jB69GgCAgLo2rVrhtc3Go20b9+eRYsWWd0Ry+L69ev64/bt23Pjxg19SP+DLL8wubi4AHDnzp00t235p+PhSz6++OILAFq0aJGufUiPuXPnsnLlyjT/unfvnmo97u7uNG/enC1btnD06FG9/MiRI2zZsoVGjRrpZR06dMBkMlm9z7GxscycOZPq1atb/RJ1/vx5q/os6+/cudMqUR47dow1a9bQsWPHR34thBC2ITklKckpGcspGfHga/eg77//Hk3TqFy5sl6Wkfxx9OhRq/nXPD09adiwIT/99JPVfFZz5swhKipK8o8QT5DkmaQkz2Q8z2zYsIHOnTtTt25d5s6dm+TO1hYlSpTg6tWrrFu3zqr8559/BqBSpUp6Wfv27Vm2bBkXLlzQy1avXs3x48et8kR8fDxHjx61GsUXFBREqVKlmDFjhlXn4bRp09A0zWquRiFsQUbmPQUcHByoWrUqGzduxNHRkeDgYKvlISEhTJgwAUjfnBPp1adPH77++mu6d+/O7t278fX1Zc6cOXrySK+///6bo0ePkpCQwNWrV1mzZg0rV67E39+f33//XZ9wNKM+/fRT1q5dS/Xq1enTpw9lypTh1q1b/Pvvv6xatYpbt24B0L17d3788UfeeustduzYQZ06dYiOjmbVqlX069ePNm3a4OzsTJkyZfj1118pUaIE3t7elC1blrJlyybZboUKFejRowczZszgzp07hIaGsmPHDmbPnk3btm2tJpB9XLacd2LMmDGsXr2a5557jjfeeAOAr776Cm9vb/73v//pcdWrV6djx44MHz6ca9euUaxYMWbPns3Zs2f5/vvvrers3r0769evtxp2369fP7799ltatGjBkCFDsLe354svviBfvny8/fbbNtsfIcSjkZySPMkpGbN//35+//13AE6ePEl4eDgff/wxkLhPrVq1AuCTTz5h8+bNNG3alMKFC3Pr1i0WLVrEzp07GThwoNXlahnJH6VLlyY0NNTqy9snn3xCSEgIoaGh9O3bl4sXLzJhwgQaN25M06ZNbbbvQojUSZ5JnuSZ9Dt37hytW7fWO8kWLFhgtbx8+fL6ZckDBgxg5syZtGrVioEDB+Lv78/69ev5+eefadSoEdWrV9fX+9///seCBQuoX78+b775JlFRUYwbN45y5crx8ssv63FhYWGULl1av4GPxbhx42jdujWNGzemc+fOHDx4kK+//prevXtbjXoUwiae6L1zRaYZPny4AlRISEiSZYsXL1aAcnd3VwkJCVbLUrq9e1BQUJJ6evToofz9/a3Kzp07p1q3bq1cXFxUnjx51Jtvvqn++eefDN3e3fLn4OCg8ufPrxo1aqQmTZqkIiIikqyT0u3d+/fvn+w2rl69qvr3768KFSqk7O3tVf78+VWDBg3UjBkzrOJiYmLUe++9pwICAvS4Dh06qFOnTukxW7ZsUcHBwcrBwcHqlunJtSk+Pl6NGjVKr69QoUJq+PDhSW5n7u/vr1q0aJGk3aGhoSo0NDTF1y6z7N69WzVs2FC5uroqd3d31aZNG3X8+PEkcXfv3lVDhgxR+fPnV46Ojqpq1arqn3/+SRIXGhqa5LVRSqkLFy6oDh06KA8PD+Xm5qZatmypTpw4kSn7lFNYbuN++3hRZbpc/LH/bh8vKrdyF49McorklMf18Pvx4F+PHj30uBUrVqiWLVsqPz8/ZW9vr9zd3VWtWrXUzJkzldlsTlJvevMHkOw+b9y4UYWEhCgnJyeVN29e1b9//2SPjaeVLXON5BnxOCTPSJ55HJbjIKU/y75aHD16VHXo0EF/Xf39/dWQIUNUdHR0kroPHjyoGjdurFxcXJSXl5fq2rWrunLlilXMmTNnkuQziyVLlqiKFSsqR0dHVbBgQfX++++ruLg4W+5+tmbJM/VooxpqHR7rrx5tJM+kQlPqCc4KKoQQIlkRERF4enpy+3hRPNyTn1g4Q/VFmshV4jTh4eFWcxsKIYR4dtky10ieEUII8TBLnqlHG+y05Od0TK8EFc86fpM8kwKZM08IIYQQQgghhBBCiBxCOvOEEEIIIYQQQgghhMghpDNPCCGEEEIIIYQQQogcQjrzhBBCCCGEEEIIIYTIIaQzTwghhBBCCCGEEEKIHEI688RjW7duHZqmsW7dumxdZ3akaRojR47M6mYIIUS2Jnnm0UmeEUIIa5JTHp3kFCGyD+nMe8bNnz8fTdNYsmRJkmUVKlRA0zTWrl2bZFnhwoUJCQl5Ek1M04EDB+jQoQP+/v44OTlRoEABGjVqxOTJk7O6adnSvXv3GDt2LGXKlMHFxYUCBQrQsWNHDh06lOa6Z8+eRdO0ZP9++eWXJ9B6IUROI3nm2Xbq1CmcnJzQNI1du3alax2z2cznn39OQEAATk5OlC9fnp9//jmTWyqEyAkkpzx7fv31V7p160bx4sXRNI169eqlGv/vv//SunVrvL29cXFxoWzZsnz11Vfp2lZYWBidOnXCy8sLDw8P2rRpw+nTp22wF0LYnl1WN0Bkrdq1awOwadMmnn/+eb08IiKCgwcPYmdnx+bNm6lfv76+7MKFC1y4cIHOnTsDULduXe7evYuDg8OTbTywZcsW6tevT+HChenTpw/58+fnwoULbNu2jUmTJjFw4MAn3qbsrmvXrvz+++/06dOHypUrc+nSJaZMmULNmjU5cOAA/v7+adbx4osv0rx5c6uymjVrZlaThRA5mOSZZ9vgwYOxs7MjNjY23eu89957fPrpp/Tp04eqVavy22+/0aVLFzRN048JIcSzSXLKs2fatGns3r2bqlWrcvPmzVRjV6xYQatWrahUqRIffPABbm5unDp1iosXL6a5naioKOrXr094eDj/+9//sLe3Z+LEiYSGhrJ3715y585tq10SwiakM+8Z5+fnR0BAAJs2bbIq37p1K0opOnbsmGSZ5bklmRoMBpycnJ5Mgx/yySef4Onpyc6dO/Hy8rJadu3atSxpU3YWFhbG4sWLGTJkCOPGjdPL69Spw3PPPcfixYsZPHhwmvVUrlyZbt26ZWZThRBPCckzz67ly5ezfPlyhg0bxscff5yudcLCwpgwYQL9+/fn66+/BqB3796EhoYydOhQOnbsiNFozMxmCyGyMckpz545c+ZQoEABDAYDZcuWTTEuIiKC7t2706JFCxYuXIjBkLGLEKdOncqJEyfYsWMHVatWBaBZs2aULVuWCRMmMGbMmMfaDyFsTS6zFdSuXZs9e/Zw9+5dvWzz5s0EBQXRrFkztm3bhtlstlqmaRq1atUCkp8jol69epQtW5bDhw9Tv359/XLOzz//PMn2L168SNu2bXF1dcXHx4fBgwen+xf8U6dOERQUlCQZAvj4+Fg91zSNAQMGMHfuXEqWLImTkxPBwcFs2LAhybphYWH06tWLfPny4ejoSFBQED/88EOSuNjYWEaMGEGxYsVwdHSkUKFCDBs2LEn7Y2NjGTx4MHnz5sXd3Z3WrVun6xciW4uMjAQgX758VuW+vr4AODs7p7uu6Oho4uLibNc4IcRTS/LMs5NnLOLj43nzzTd58803CQwMTPd6v/32G/Hx8fTr108v0zSN119/nYsXL7J169bMaK4QIgeRnPJs5ZRChQqlq2Nu3rx5XL16lU8++QSDwUB0dLTVcZCWhQsXUrVqVb0jD6BUqVI0aNCA+fPnP1LbhchM0pknqF27NvHx8Wzfvl0v27x5MyEhIYSEhBAeHs7BgwetlpUqVSrNoca3b9+madOmVKhQgQkTJlCqVCneeecd/v77bz3m7t27NGjQgOXLlzNgwADee+89Nm7cyLBhw9LVdn9/f3bv3m3VvtSsX7+eQYMG0a1bNz766CNu3rxJ06ZNrda/evUqNWrUYNWqVQwYMIBJkyZRrFgxXnnlFb788ks9zmw207p1a8aPH0+rVq2YPHkybdu2ZeLEibzwwgtW2+3duzdffvkljRs35tNPP8Xe3p4WLVqkq80AN27cSNdfWv9IBAYGUrBgQSZMmMAff/zBxYsX2bFjB6+99hoBAQHpvnxp1KhRuLm54eTkRNWqVVmxYkW690UI8eyRPPPs5BmLL7/8ktu3b/P++++nuw0Ae/bswdXVldKlS1uVV6tWTV8uhHi2SU559nJKeqxatQoPDw/CwsIoWbIkbm5ueHh48Prrr3Pv3r1U1zWbzezfv58qVaokWVatWjVOnTqlD4oQIttQ4pl36NAhBajRo0crpZSKj49Xrq6uavbs2UoppfLly6emTJmilFIqIiJCGY1G1adPH339tWvXKkCtXbtWLwsNDVWA+vHHH/Wy2NhYlT9/ftW+fXu97Msvv1SAmj9/vl4WHR2tihUrlqTO5KxYsUIZjUZlNBpVzZo11bBhw9Ty5ctVXFxcklhAAWrXrl162blz55STk5N6/vnn9bJXXnlF+fr6qhs3blit37lzZ+Xp6aliYmKUUkrNmTNHGQwGtXHjRqu4b775RgFq8+bNSiml9u7dqwDVr18/q7guXbooQI0YMSLVfXyw7Wn9zZw5M826tm/frgIDA63WCw4OVpcvX05z3XPnzqnGjRuradOmqd9//119+eWXqnDhwspgMKhly5alub5IWXh4uALU7eNFlely8cf+u328qAJUeHh4Vu+aEJJnnrE8c/nyZeXu7q6mT5+ulFJq5syZClA7d+5Mc90WLVqookWLJimPjo5WgHr33XfTrEOkzJa5RvKMyCqSU56tnPKgoKAgFRoamuyy8uXLKxcXF+Xi4qIGDhyoFi1apAYOHKgA1blz51TrvX79ugLURx99lGTZlClTFKCOHj2aobY+qyx5ph5tVEOtw2P91aON5JlUyJx5gtKlS5M7d259Pol9+/YRHR2t3/EpJCSEzZs3069fP7Zu3YrJZNLnnEiNm5ub1bxqDg4OVKtWzeqOQH/99Re+vr506NBBL3NxcaFv377p+oWrUaNGbN26lbFjx7J8+XK2bt3K559/Tt68efnuu+9o3bq1VXzNmjUJDg7WnxcuXJg2bdrwxx9/YDKZMBgMLFq0iE6dOqGU4saNG3pskyZN+OWXX/j333+pVasWCxYsoHTp0pQqVcoq7rnnngNg7dq1hISE8NdffwHwxhtvWLVl0KBBzJs3L819BFi5cmW64oKCgtKMyZUrFxUrVqRjx47UqFGDkydPMnbsWDp27MjKlStTnUOkcOHCLF++3KrspZdeokyZMrz99tsZ+sVOCPHskDzzbOWZd955h6JFi9K7d+901fmgu3fv4ujomKTckpsevKxOCPFskpzybOWU9IqKiiImJobXXntNv3ttu3btiIuLY/r06Xz00UcUL1482XUtuUXyj8hJpDNPoGkaISEhbNiwAbPZzObNm/Hx8aFYsWJAYkK0TEK9efNmgHQlxIIFC6JpmlVZrly52L9/v/783LlzFCtWLElcyZIl093+qlWrsnjxYuLi4ti3bx9Llixh4sSJdOjQgb1791KmTBk9NrkTeIkSJYiJieH69esYDAbu3LnDjBkzmDFjRrLbs0xOe+LECY4cOULevHlTjTt37hwGgyHJnEEZ2ceGDRumOzY14eHh1KlTh6FDh/L222/r5VWqVKFevXrMnDmT119/PUN1ent78/LLL/Ppp59y8eJFChYsaJO2CiGeHpJnnp08s23bNubMmcPq1aszPPk4JM7dmtxlV5ZLpDIyt6sQ4ukkOeXZySkZYckPL774olV5ly5dmD59Olu3bk2xM8+yruQfkZNIZ54AEhPcH3/8wYEDB/Q5JyxCQkIYOnQoYWFhbNq0CT8/P4oWLZpmnSndbU4pZbN2P8jBwUGftLREiRK8/PLLLFiwgBEjRqS7Dsskqd26daNHjx7JxpQvX16PLVeuHF988UWycYUKFcrgHqTsypUr6Yrz9PRMNdEsWrSIq1evJvnVLzQ0FA8PDzZv3pzhzjy4v6+3bt2SzjwhRLIkzyR62vPMsGHDqFOnDgEBAZw9exZAHwFy+fJlzp8/T+HChVNc39fXl7Vr16KUsvqyfPnyZSDxTpZCCCE5JdHTnlMyws/Pj0OHDiW50Z/lxiK3b99OcV1vb28cHR31XPMgyT8iu5LOPAHc/7Vq06ZNbN68mUGDBunLgoODcXR0ZN26dWzfvp3mzZvbbLv+/v4cPHgwyT/tx44de6x6LZOXPnxCPnHiRJLY48eP4+Liov9K5e7ujslkSvMXpcDAQPbt20eDBg2S/Dr3IH9/f8xmM6dOnbL6RSsj+2i522xaZs6cSc+ePVNcfvXqVQBMJpNVuVIKk8lEQkJCutv0IMvlByn90ieEEJJnno08c/78ec6dO0dAQECSZa1bt8bT05M7d+6kuH7FihX57rvvOHLkiNXoFMtE9xUrVkxXO4UQTzfJKc9GTsmI4OBgVq5cqd8Aw+LSpUtA6t9TDAYD5cqVY9euXUmWbd++naJFi+Lu7m6TdgphK3I3WwEkJhAnJyfmzp1LWFiY1a9bjo6OVK5cmSlTphAdHZ2uYerp1bx5cy5dusTChQv1spiYmBSHiT/M8uv9wyxzPTw8HHzr1q38+++/+vMLFy7w22+/0bhxY4xGI0ajkfbt27No0aJk7zJ1/fp1/XGnTp0ICwvj22+/TRJ39+5doqOjAWjWrBmAPneDxYN3l0rLypUr0/XXpEmTVOspUaIEAL/88otV+e+//050dDSVKlXSy8LDwzl69Cjh4eF62YP7bxEWFsYPP/xA+fLl0524hRDPHskzz0aemTFjBkuWLLH6GzhwIADjx49n7ty5emxyeaZNmzbY29szdepUvUwpxTfffEOBAgWsjhshxLNLcsqzkVMyolOnTgB8//33VuXfffcddnZ21KtXTy87f/48R48etYrr0KEDO3futOrQO3bsGGvWrKFjx442a6cQtiIj8wRwf5j3xo0bcXR0tJpoFRKHq0+YMAFI35wT6dWnTx++/vprunfvzu7du/H19WXOnDm4uLika/2BAwcSExPD888/T6lSpYiLi2PLli38+uuvFClShJdfftkqvmzZsjRp0oQ33ngDR0dH/cvCqFGj9JhPP/2UtWvXUr16dfr06UOZMmW4desW//77L6tWreLWrVtA4o0f5s+fz2uvvcbatWupVasWJpOJo0ePMn/+fJYvX06VKlWoWLEiL774IlOnTiU8PJyQkBBWr17NyZMn0/062WreiVatWhEUFMRHH33EuXPn9BtgfP311/j6+vLKK6/osUuWLOHll1+2+sVs2LBhnDp1igYNGuDn58fZs2eZPn060dHRTJo0ySZtFEI8nSTPPBt5pnHjxknKLCPxQkND9dEnkHyeKViwIIMGDWLcuHHEx8dTtWpVli5dysaNG5k7d26Kl8EJIZ4tklOejZwCsGHDBjZs2AAkdk5GR0fz8ccfA1C3bl3q1q0LQKVKlejVqxc//PADCQkJhIaGsm7dOhYsWMDw4cOtLpPt3r0769evt+pY7devH99++y0tWrRgyJAh2Nvb88UXX5AvXz6rucaFyC6kM0/oateuzcaNG/Wh6Q+qVasWEyZMwN3dnQoVKthsmy4uLqxevZqBAwcyefJkXFxc6Nq1K82aNaNp06Zprj9+/HgWLFjAX3/9xYwZM4iLi6Nw4cL069eP999/Hy8vL6v40NBQatasyahRozh//jxlypRh1qxZ+lwSAPny5WPHjh189NFHLF68mKlTp5I7d26CgoL47LPP9DiDwcDSpUuZOHEiP/74I0uWLMHFxYWiRYvy5ptv6qPgAH744Qfy5s3L3LlzWbp0Kc899xx//vmnTeemSA8HBwc2btzI6NGj+fPPP/n5559xd3enbdu2jBkzhjx58qS6fuPGjfnmm2+YMmUKt2/fxsvLi7p16/L+++9TuXLlJ7QXQoicSvJMoqc5z9jCp59+Sq5cuZg+fTqzZs2iePHi/PTTT3Tp0iWrmyaEyEYkpyR62nPKmjVrrDovAT744AMARowYoXfmAXzzzTcULlyYmTNnsmTJEvz9/Zk4caLVZdgpcXd3Z926dQwePJiPP/4Ys9lMvXr1mDhxokwlJLIlTWXWjJ5CZDOaptG/f3/97lZCZCcRERF4enpy+3hRPNwff+RJRKSJXCVOEx4ejoeHhw1aKIRIi+QZkd3ZMtdInhEic0lOETmRJc/Uow12mv1j1ZWg4lnHb5JnUiBz5gkhhBBCCCGEEEIIkUNIZ54QQgghhBBCCCGEEDmEdOYJIYQQQgghhBBCCJFDyA0wxDNDpocUQgiRmSTPCCGEsBXJKUKI1MjIPCGEEEIIIYQQQgghcgjpzBNCCCGEEEIIIYQQIoeQy2wBs9nMpUuXcHd3R9O0rG6OECKHUUoRGRmJn58fBoP8RiKSkjwjhHgckmdEWiTPCCEel+SanEU684BLly5RqFChrG6GECKHu3DhAgULFszqZohsSPKMEMIWJM+IlEieEULYiuSanEE68wB3d3cg8aD18PDI4tYIIXKaiIgIChUqpJ9LhHiY5BkhxOOQPCPSInlGCPG4JNfkLNKZB/pQdA8PD0l+QohHlpMva9mwYQPjxo1j9+7dXL58mSVLltC2bdt0rbt582ZCQ0MpW7Yse/fu1cvHjh3L4sWLOXr0KM7OzoSEhPDZZ59RsmTJzNmJbEzyjBDCFiTPSJ5JieQZIYSt5ORc8yyRC6GFEEIQHR1NhQoVmDJlSobWu3PnDt27d6dBgwZJlq1fv57+/fuzbds2Vq5cSXx8PI0bNyY6OtpWzRZCCJFDSJ4RQgghbEdG5gkhhKBZs2Y0a9Ysw+u99tprdOnSBaPRyNKlS62W/fPPP1bPZ82ahY+PD7t376Zu3bqP01whhBA5jOQZIYQQwnZkZJ4QQjzFIiIirP5iY2NtVvfMmTM5ffo0I0aMSFd8eHg4AN7e3jZrgxBCiKwleUYIIYR48qQzTwghnmKFChXC09NT/xs7dqxN6j1x4gTvvvsuP/30E3Z2aQ/yNpvNDBo0iFq1alG2bFmbtEEIIUTWkzwjhBBCPHlyma0QQjzFHr6rnaOj42PXaTKZ6NKlC6NGjaJEiRLpWqd///4cPHiQTZs2Pfb2hRBCZB+SZ4QQQognTzrzhBDiKZYZd7WLjIxk165d7NmzhwEDBgCJIyKUUtjZ2bFixQqee+45PX7AgAEsW7aMDRs2ULBgQZu2RQghRNaSPCOEEEI8edKZJ4QQIkM8PDw4cOCAVdnUqVNZs2YNCxcuJCAgAAClFAMHDmTJkiWsW7dOLxdCCCFSI3lGCCGESJ105gkhhCAqKoqTJ0/qz8+cOcPevXvx9vamcOHCDB8+nLCwMH788UcMBkOS+Yh8fHxwcnKyKu/fvz/z5s3jt99+w93dnStXrgDg6emJs7Pzk9kxIYQQ2YLkGSGEEMJ2pDNPCCEEu3bton79+vrzt956C4AePXowa9YsLl++zPnz5zNU57Rp0wCoV6+eVfnMmTPp2bPnY7VXCCFEziJ5RgghhLAdTSmlsroRWS0iIgJPT0/Cw8NtPueHEOLpZ4tziKWO28eL4uFufPw2RZrIVeK0nNeyCckzQojHYatziC1zjeSZ7EXyjBDicdnyO0092mCn2T9WexJUPOv4Tc5rKTBkdQOEEEIIIYQQQgghhBDpI515QgghhBBCCCGEEELkENKZJ4QQQgghhBBCCCFEDiGdeUIIIYQQQgghhBBC5BDSmSeEEEIIIYQQQgghRA4hnXlCCCGEEEIIIYQQQuQQWdqZN3LkSDRNs/orVaqUvvzevXv079+f3Llz4+bmRvv27bl69apVHefPn6dFixa4uLjg4+PD0KFDSUhIeNK7IoQQQgghhBBCCCFEpsvykXlBQUFcvnxZ/9u0aZO+bPDgwfzxxx8sWLCA9evXc+nSJdq1a6cvN5lMtGjRgri4OLZs2cLs2bOZNWsWH374YVbsShIRERGcOXOGiIiIrG6KEM88+TyKp5Uc20JkH/J5FE8jOa6FyD7k8ygs7LK8AXZ25M+fP0l5eHg433//PfPmzeO5554DYObMmZQuXZpt27ZRo0YNVqxYweHDh1m1ahX58uWjYsWKjB49mnfeeYeRI0fi4ODwpHdH9++//7Js2TKUUmiaRosWLShXrlyK8UajEaPRCIDZbE51dOGDsUop4uPjbRJrMBiws7PL1FiAuLg4m8Rqmoa9vf0jxcbHx6OUeqKxgNUxmZHYhIQEzGazTWLt7e3RNC1TY00mEyaTySaxdnZ2GAyGx4rdu3cvf//9N5D4nrVs2ZLKlSunWI8QOYXkmuRjQXLNo8RKrpFcI8TDJM8kHwuSZx4lVvKM5BlhO1nemXfixAn8/PxwcnKiZs2ajB07lsKFC7N7927i4+Np2LChHluqVCkKFy7M1q1bqVGjBlu3bqVcuXLky5dPj2nSpAmvv/46hw4dolKlSsluMzY2ltjYWP25rXu1IyIi9KQHiYlh2bJlLFu2LMV1GjZsSK1atQC4fPky3333XYqxoaGh1KtXD4Dr168zbdq0FGNr1qxJ48aNgcQO0kmTJqUYW6VKFVq0aAFATEwM48ePTzG2QoUKtG3bFkg8gY8dOzbF2DJlytCxY0f9eWqxxYsXp0uXLvrz8ePHp5hU/f396dmzp/580qRJxMTEJBvr5+dHnz599OdTpkwhPDw82di8efPSr18//fm3337L9evXk4319PRk0KBB+vNZs2Zx6dKlZGNdXFwYOnSo/nzu3LmcO3cu2Vh7e3v+97//6c/nz5/PiRMnko0FGDFihP54yZIlHD58OMXY4cOH64ly2bJl7Nu3L8XYIUOG4OrqCsDy5cvZtWtXirFvvvkmXl5eAKxevZqtW7emGPv666/j4+MDwMaNG1m/fn2Ksb1796ZAgQIAbNu2jVWrVqUY26NHD4oUKQLA7t279WT3IMvnsVixYnh4eKRYlxCPI7PzjKVOyTX3Sa5JJLnmPsk14mkmeUbyDEiekTwjeeZZlqWdedWrV2fWrFmULFmSy5cvM2rUKOrUqcPBgwe5cuUKDg4O+gfJIl++fFy5cgWAK1euWHXkWZZblqVk7NixjBo1yrY784CbN2+m+utEclTk55ivHEl8fNMbaJZybNRkzFf6AmC+5Qm0TLni6O8xXxmQGBvpCrRNOTZmHuYrgxNj7zoCHVJuw93FmK8MS4yNNwKdU4699zfmK+89UNI15djYdZivjHyg4AVSPEzjdmC+Mub+c3N7wCn5euMPYL5S4n6BqQ3glnxswgmrWJXQAvBKvg2mMOvY+KZA7uRjzbes2xDXEMiXfKy6a11vbD2gQPKxYB17rzbgn3Ls1QqY7U3/baYGEJhy7LUamJ3/+0cxpipQIuXY6/Ux34tOfBJdCSiTcuyNFpjNif94qKhyQPkUY9XN9piNtxIfR5YGUv71yXyrG2ana4mxESWAqsnXqRS3bt2SxCcyTWbnGXi0XPPd+7/y0Y7pALjld6R894Ipxv40ZgljW/wAgHNueyq9UjjF2IWT/mbC8z8B4OhhR/BrKZ+D/pixmq86/QqAnbOBagMDUoxd+dNGpnVdDIDBXqPG4KIpxm5YvIPvev6hPw8ZlvK5bcc/e5nd5x/9efVBARgdkp95ZP/GozTp311/XnVAEexdjMnGHt99miaD7sdWfrUwTp72ycaeOxJGE9f7sRV7FcIlT/JXFFw9f8MqtvxLBXDzTT7fhd+ItIoN6uyHZ2HnZGPvRcdaxZZun59cga7JxgJWsSVa5yNPqeTzKEAbnz6Y4xOPz2LN8uJTLuXzbSf//iTcTRwlEdAwD76VPVOM7V76LWIjEkf6+NfLTYFqXinG9q0ynLs3E788F6qVi0K1vFOMfaPuSKKuJOY7v2peFKmXQi4HhjYdQ8SFewDkr+RB0UZ5k42TXCMyU3bNM9++8xMjt3wJgJufMxX7pHwunjNqAZ88NwUAl7yOVO5XPMXYBRN+Z1zTbwFw9LSn6qCSKcb+Pm05X7aaBYCdi5EaQ0unGLti9jqmtJsLJOaZkP8FpRi7YcFWZrwwX39ee0TZFGO3//kvM7st0Z/XHF4m5Tyz/jCNet3vJKw+pBT2rsl//zm28ySNXr0fW+XNEjh5JZ87zh66QCPD/dhKrxfD1Sf53HH13HWr2Aq9i+JewCXZ2PDrEVax5XoE4Fkk+dxxLzrWKrbMi/54l3BPNhawii3VoRB5glLOB63cu+l5pnibAuSrmCvF2A75XiEhJvH7T9HmvvhVTfkc3y2gH7HhibmjSKN8FAxJ/hwP0KfcW8RcT8wdhUN9KFzPJ8XYAdWHE3XpLgAFQvIQ0Cjp1YkWQ+qPJPxc4vcq36reBDb3SzZO8syzTVMZPUNnojt37uDv788XX3yBs7MzL7/8stUvTgDVqlWjfv36fPbZZ/Tt25dz586xfPlyfXlMTAyurq789ddfNGuWfIdYcr9kFSpUiPDwcJt8ECIiIpg4ceJDpWb6vfAH7q53k13HaFAYjYn/yJrNGgmmlKczfDBWKYhPSP5LRUZjDQaFXWbEago7u/tDmePibROraWBvZ3qk2Ph4Iykd+Bpgb/+IsQlGUvtEOTxibEKCAbPSbBJrb2fiv9HgJJgMmM22jzWZDJhsFGtnNGMwqEeI1TCZDURGOzP119YkvluJNE1j0KBBNkt8EREReHp6PtY5xFLH7eNF8XBP+VhOd32RJnKVOG2z85rImMzOM5Y6H841yqzY89154qKTv3RDmRTKcorVwGCX8ufJKpbELzk2iTUrlCkzYhPbYetYFJgTHjHWTnvw1PNkYkH/cpPRWM2ooaUym/Kjx4JmSLkRjxxrSGyHTWITFJZk/yixDq5GKvUubNV2W+YaW+SZB+uxRa6RPJO1sjLP7P76OHFRyV8+q0yJMUA68swDsaSVZzIQm0n5QPLMfdkvz2RSrEFDS+VUmaFYq9yRkdj/8oybHcEDSmRangHbfqepRxvstOR/0EyvBBXPOn6TPJOCLL/M9kFeXl6UKFGCkydP0qhRI+Li4rhz547V6LyrV6/qc+zlz5+fHTt2WNVhudttcvPwWTg6OuLo6Gj7HfiPh4cHzZo1e2A4rJmWoTvI7RWVrvUNBoWDIeVr6B+kadYdOdk9FrJHrH1mxdplTuyDHZw2jTWaIZ3/y2ck1mg0Y8zyWIXRaCK3VxRNa+/kn03V9GUtW7aUhCAyVWbnGUiaa5RZcWr5de7dSecd3ZX1P6FpkdhHiE3IWbHKZN15artY6y+1Nos1W3+5z8rYe3cSOL3qOoGN74/KkFwjMlNW5ZmTyy5x73bK88pZkTyT+bHZIHdkjzyTSbFm6x8rsyb2vzxzO55Tf1+mWIv7o/Qkzzzbsvxutg+Kiori1KlT+Pr6EhwcjL29PatXr9aXHzt2jPPnz1OzZk0gce6EAwcOcO3aNT1m5cqVeHh4UKZMypf4PQkVK1bUH/d74Q8qlTqVdY0R4hkXXPokrettoUGDBrz55psyUax4ajyYa/Z8d55rByKzrjFCPOOu7ovkxJ9XJdeIp8qDeWb318e5uud21jVGiGfcld23OLbkguQZAWTxyLwhQ4bQqlUr/P39uXTpEiNGjMBoNPLiiy/i6enJK6+8wltvvYW3tzceHh4MHDiQmjVrUqNGDQAaN25MmTJleOmll/j888+5cuUK77//Pv3798/0X6oyIqVLa4UQT4bBoKhQ8gyG/LWzuilCZJqULq0VQjwhCq4fiqJ2bck14umU0qW1QognRMH1/eGSZwSQxZ15Fy9e5MUXX+TmzZvkzZuX2rVrs23bNvLmTZxkcuLEiRgMBtq3b09sbCxNmjRh6tSp+vpGo5Fly5bx+uuvU7NmTVxdXenRowcfffRRVu2SEEIIkSUMubxAvmcJIYQQQgjx1MvSzrxffvkl1eVOTk5MmTKFKVOmpBjj7+/PX3/9ZeumCSGeIiaTxsGTAWhX9lKuXDmM6Z14TwghhEgnTYM8xRzYu1dyjRBCCNvTDJC3nJfkGQFksznzhBAiM5jMBn5fV5PffvsNk0kuRRRCCGF7mhECQ90k1wghhMgUmlGjRNuCkmcEIJ15mcbOzo4XX3yRzk3XJt4FVAghhLAxS645ujwSs/xPJ4QQwsYseebQvLMZumupEEKIzJWll9k+zQwGAyVKlMB85VJWN0UIIcRTypJrbkc6gmf2ufGTEM8iJVc7iaeQnmdORGV1U4QQQjxAOvOeFsZAcKiGZl8W7IqCMT9o7iS+xbFgvgOmS5BwAhW/D+K2gvlWFjdaCCFETuHp7UqFqkUpVaEQRYrlw8fXCw8vFxwc7DCZzERF3OXGtQgunr3B8YMX2b/zDBfOXM/qZgshhMghHJwcKFu7FGVrlyKgnD++RX3wzu+Fk6sTSinuRt7l9tVwwk5c5uTeMxzcdJQj205gSpCh6UKIZ4905mUSk8nEgQMHUOFFKVvsDEZjJgxLN+QD545ozq3R7IqkEugChlxgFwCOtdD+K1VxO1F3l8DdZcA927dPCCFEprLkmrz+Bm6cN6NsnGocHO2o16wCjdpWIqiSPwZDyrNzuLo7ka9ALoIq+dPk+WAALp2/yZple/ln8S5uXI2wbeOEEEJkOkue8angxfUDd1CZMHtQpefK0uyVBtRoVQVnN6cU41zcncnt502xSgGEdgoBIOpONBsXb+evGSs5uuOk7RsnhBDZlHTmZRKTycRvv/0G1KR00XMYjTb8xciQH81tIDi3RdPskw1RppugwkElgOYIhtxoBjerGM2hKppDVZT7UFT09xA9G4i1XTuFEEJkKkuuKVbVjpsX41A2SjUOjna07lKTDj1q45XbLdmY6Kh7hN+KJi42AaOdAXcP5ySxfoVz061fA17sW49Vf+zlp6mruX4l3DaNFEIIkekseaZE24LcOByOMtvuV6MaLYPpMeoFilUKSHZ5fFwCty7f5m5U4qADFw9nvPN7YWd//yusm5crzXo9R7Nez3Fg4xFmffAL+zcctlkbhRAiu5LOvBzFCK690NwGoGnOeqlSJojbiYpdB/G7IeE4qLtJ1lYGb7ALQnOoDk4N0OwCAdAMudDch6BcOqPCR0Dcxie1Q0IIIbKZ4JBiDPygDfkLeluVXzhznS1rDrN/5xlOHb3EnZvRSdZ1dLanSLF8lK1chKp1SlC+agAGgwGjnZEmzwdTr1l55n2zhgWzNmE2yc2hhBDiWZS/iA9vTutDlSYVrcrDb0Sw9Y9d/LtyP8d2nuLy6auoh4acG4wGChTLT+kaJajSuALVWwbj4p74vahcndJMWDeKdb9uYcob33PnuowIF0I8vaQzL6cw5EPz+hLNIVgvUuYIiPkJFfMzmK+mXYf5FsRtRMVthKjxKPvyaC7dwakFmmZEMxZE8/4eFT0HFfkpEJ95+yPEE2RnNNO+4UY0r0nY2clpTzydTB7OmM1a2oEpsLMz0Ld/A57vWO1+nSYzG9YeYfH8HRw9/NANnTxdktQRAxw+f4vD528xf+m/5M7jTsu2lWnTPhh3d2ccnex5eVATqjcM4uMPF3P9WuQjt1eI7MakKY7sU3wwup3kGiFSUO+FEAZNfxVXj/s55OiOkyyY8Dtblu4kIT4h1fXNJjMXjl3iwrFLrJi9DkdnB+q9EELHIW3wL1NQ30aF+kF82u0r/l21P1P3R4gnyZygOLLgPB/8+pbkGUHKk9+I7MOuDFruxXpHnlImVPRs1PXnUFFfpq8jLznx+1HhQ1A3WqJit+rFmutLaN4zQfOwQeOFyHoGg6JM4HmCgoJSnfNLiGeVq5sjY7940aojb++/Z3mt53eMGbk0aUdeOt28Ecns79bzUscpLPp1O6b/RuOVKVuQr7/tRYlSvjZpvxDZgtK4ec0guUaIFPQc3Zn3fh6sd+RdO3+DUe3HMbDGcDYs2JpmR15yYu/GsXzWOvqWf5vxr0wl/EbiaLxcPp6M+fs9WvdrYtN9ECJLKbh5OELyjACkMy/7s6+I5v0TmjEvAMp0EXWrCyryE1A2GjpuOoW63QNz+AiUSpwzT3Oohub9I2hettmGEEKIbMnN3Ylxk7pRsXIRAOLiEpj8xT8MfWMuZ210N9roqFi+mbyKwf1mc/nSHQC8c7vx+aSuBJUraJNtCCGEyL76f9WLru+115+v/HE9fcq9xaYlO2xSv9lsZvnMtfQOGsyOv/4FwGg0MPDr3nR+t61NtiGEENmJdOZlZ8ZAtFzf6TeuUHG7UTfaQ/yezNne3Z9Rt7qiTDcA0OzLoOWaDqR8VykhcgKzWePwqcIcOnQIs1nm6RLCwsHBjo8/f4HiJfMDcOd2NEMGzuH3xbszZXtHDl2i/yvfs3/POQBcXR35+PMXKBKQN1O2J8QTpSly+5gl1wjxkB4fvUDbAc2AxE63qYNm8nnPr4mJTDrH9+O6cz2C91t9ys+fLtHLXhnTlZavNrL5toR44jTIXcZD8owAZM687EtzR8s1Hc2QeKmrit2Cuv0acC9ztxu/H3WrK3jPQTP6oDlUAs/RqPChmbtdITJRgsnAolV1gIUMHz4cBweHrG6SEDYX52mf4TnzhrzVXB8Zd+t2NIOG/8y5i7fAM/k7pdvCTUy8/dEiPnn/eaoFB+Dm7sSocZ3o++aPREZlco4TIhMZDIrSFe6xcKHkGiEsQjuF0O39DkBiR964l6ewas6GTN2mUoof/jeP6DvR9P60GwADJr/C+SNhcqdbkaMZ7DRKdywseUYAMjIv09jZ2dGhQwfaN9yInTHjveaax2g0u8IAqPhDqDuvk+kdeRamM6jbvVHmqMS2OLcBp+efzLaFEEKkmyXXHDjhgMpgqmnyXBBNGpQFIOZuHEM/XMC5C7cyoZVJxcUl8MEnSzl64goAfvm9GDKw8RPZthBCiPSz5JkjC85jTlBpr/CA/EV8GDzjVf35N2/PzvSOvAf9+vlvLJjwOwBGOyPD576Jey63J7Z9IYTITNKZl0kMhsQJkMsEnsdgyFjiw7EhmnNzAJT5Dup2P1C2H4aeqoSjqMhx+lPN40Mw5H6ybRBCCJEqS665ftuIIv2j8nJ5uTDw1Qb6888n/cPJ09cyo4kpuhcbz/sfL+FOeAwA9WqXok5I8SfaBiGEEKmz5JmbhyMgg19pBn3TV7/Zxao5G1gy6a9MaGHqvntnLrtXJt7RNk8Bb/qOf+mJt0EIITKDdOZlO/Zo7u/qz1TEKDBffrJN0JzR3N5A83gP9d9QD83giuY2+Mm2QwghRKZ4uWtt3N0S50NdsfYQazcezZJ2XL8RyZdTV+rP+/d+Dns7Y5a0RQghhO3UaBlMcOMKAFy7cIPJA77LknZYLu2N/u+Ho6YvP0fxykWzpC1CCGFL0pmXSczmxAmQD58qnLE5jJyfv395bexWuPdnJrUwBU6t0PKsAtd+aJoDmvbAIeLcHoyFnmx7hBBCpMiSa/LmMqGlc8hEfh8PWjQpD0B0TCxTvl2bmU1M09pNx9j57xkAfPN50rxxuSxtjxBCiPsseSZ3GQ8yMACcHqNe0B9/89bsTLnZRXrdvHSL2SN+1Z93H9kpy9oihBC2IjfAyCQJCQksXLgQqMM7vX7BwWBK13qaay/9sYqakEmtS4ZdOTSPD9EcKqCUWe/EU8qEpiWOktA0I7i8hIoc8+TaJYQQIkWWXFOuOKw87opJpf1Nq02HKtgZE8/xP/+9m2vEgmfWjoabsmgTsyoHANChXRUWbjmAyuDlXEJkNaMmB614+ljyTOmOhdky5hDm+LSP84r1y1KsUuI5/fiuU2xctC2zm5mmZd+soMNbrfApnIcaLYMpVNKPC8cuZXWzhBDikcnIvOzEvgqaXeKwbxW3A+L3Z/42DXnRPD7FkGcR2AcBPNCRZwbzNcx33kGp/26+4dwGyLy7HAohhMg8RqOB5nUTz/WxcQksXLE3axv0n2NnrrHr0HkACvt6U6FkgSxukRBCiEfV7JX7c7LOH/97Frbkvvi4BBZPun/FU5OX62dha4QQ4vFJZ142ojk10x+rmPm234AhNxgL/vfEAVz7ouVdBc6tE7evJQ7UVCoBpWJRUV+irjeGe0vgXuKcRpohFzjUtH3bhMhERoOZ1vW20qZNG4xGmY8rORs2bKBVq1b4+fmhaRpLly5NNX7Tpk3UqlWL3Llz4+zsTKlSpZg4cWKSuLCwMLp166bHlStXjl27dmXSXoi0VAkqhJe7MwDrd50kPAsve3rYH2sP6I8b1CiZhS0R4tGYFRy47Ci5JgWSZ54N9o721GxdBYCIm5FsXrIji1t038of15MQnwBA3Y4hWdwaITJOmRTHl16UPCMAucw2e3GsDYBS8RC72saVO6F5zwejLyryEzTX3mDwtZoTT6mExA69e3+iIseD+er9ZfeWozm3AkBzrIuKe3K3lRficRmNigolT2PIXzGrm5JtRUdHU6FCBXr16kW7du3SjHd1dWXAgAGUL18eV1dXNm3axKuvvoqrqyt9+/YF4Pbt29SqVYv69evz999/kzdvXk6cOEGuXLkye3dECmqUD9Afr9txPAtbktSmf08Rn2DC3s5IjQoBaa8gRDaj0AiLsKdixYpZ3ZRsSfLMs6FsrZI4/3eDpdP7z5HPPw+XT1/DbDZnccsSOxf3rTtMcKPy+Ab4yKW2IsdRZri2747kGQFIZ172YfBGs/vvy0v8flDRj1WdyaTYuP0ul6+a8M1nJLTRMDRjAcCMwWPEf3Ph3b+cVtMMkHAUc8QoiN+XtMK4LffjHCo/VtuEENlPs2bNaNasWdqB/6lUqRKVKlXSnxcpUoTFixezceNG/UvWZ599RqFChZg5c6YeFxAgnTSZJdbdkOaceeXKJF6+ajYrNp+7SKz74w3QV2YzUVdOEx8Tgb2LB275i6IZHq3OWEwcOHOZysULUjCfF24F3LgZEfNY7RNCZB+SZ54NQbVL6Y8r1i/LrOOTibsXz/kjFzm59wxnDpxP/Nt/jjvXI6zWzZXPiy7/a8f6BVs4uCnxLutKKW5znTju4YATuciLpmXgThwP+XfVPoIbJd4EqmztUtKZJ4TIsaQzL7uwu5/4HneuvMV/RjH4g+tcvJw4jLx69epsadvrv867xC9ZlptaKGUC8x3MkZ/Bvd8gpbshqigwnQG7QLAr/l89Wf8LmxDpYTZrnLrgixZxnGLFimF4xM6GnCgiwvofZUdHRxwdHW2+nT179rBlyxY+/vhjvez333+nSZMmdOzYkfXr11OgQAH69etHnz59bL59kTZNg2IF8gBw4fodImNiH6u+O2f2c3HLEuKjw/Uye1dPCoY8j1dA+Ueq8+CZK1QunjgdRPECebgZcf6x2ijEk6Sh8HFM4PjxZyvXSJ4RDypWMWlnqoOTPcUqBVCkbCEMBgOG/27CFHEzktP7z3Fq31nOHDhPwRJ+tB3YjNb9mzD7w1/5auwUjqh/ieX+lBCOOFNSVcRHe7S5VY/uOKk/Dijv/0h1CJFlNMhVzO2ZyzMiefLuZxfGQvpDlXD6katZ/GcUnfpc1jvyHB0dmTNnTpKh7Ynz4sVD9LeoGw3h3lJS7MizSDgDgKY5giHfI7dRiCctwWTgl3/q8/PPP5OQkJDVzXmiChUqhKenp/43duxYm9ZfsGBBHB0dqVKlCv3796d37976stOnTzNt2jSKFy/O8uXLef3113njjTeYPXu2Tdsg0ievpxuO9om/4Z29cuux6rpzZj9nVs6y6sgDiI8O58zKWdw582g/Sp29clt/XDCv1+M0UYgnzqBBjdx3n7lcI3lGPKhAcV8gcUTdw98/7Ozt9I48AI/c7lSoF0Sbfk15+7vX6fxOWxLiEzAYDPQc3ZkJKz/CK5+HVR2x3GU/W7mmwh6pfRcfGInnVzT/I9UhRFYx2GkEdSnyzOUZkTwZmZdJjEYjbdq0QYW/i9GQjhFshtz3Hz8wV11GmEyKwR9cRz3QJzdixAiKFi2aZIJMTbPDHPkVRH+d/g3oN88A7MtD7OVHaqcQ4sm5cOECHh73/xG29WiJjRs3EhUVxbZt23j33XcpVqwYL774IgBms5kqVaowZswYIPGSqYMHD/LNN9/Qo0cPm7bjWWXJNSNmLcecxu8x3u4u+uPrdx59KgdlNnNxy5JUYy5uWYqnf9kMX3JrVvfzZaMqJVi44Qnc1V0I8VgkzzzdLHlm3MtTUKY0Eg3g7u0GQEzkXQ5sOExgxQDyFkz8nqPMioQEE/YO97+CapqG3QPP7f770UnTNOrWrcvBgwfp3Lkzq1dbzyd+jL3kVX4ZvuT29tX7P0JVbyFTBwkhci7pzMskRqORihUrYr6SvlF2mnb/SxbmR/uStXH7XX1EHkCePHkYNmwYmqYRFxeHwWDAzu6B5GkXmNZYPOs22pd64HEZVOzyR2qnEOLJ8fDwsPqSZWuWuYnKlSvH1atXGTlypP4ly9fXlzJlyljFly5dmkWLFmVae541llxz4e7aNGNdnOz1xzGxcY+8zagrp61G5L300ktUrVqVjRs3snHjRq5cuUJ89B2irpzG3a9Yhur2cHHSH1ctWSiVSCFEdiF55ulmyTPX9t1JV7yTa2Jn7o2Lt/ig9WcAuLg74x9UiIByhSla3p/ACkUIKF8YV4/E7z+mBBMKsLOzHnxgZ2dH7ty5WbFiBaGhoWzatElfFstdbnMdb3wytD9KZeTbjxBCZF/SmZcdPeKkrpevmqye37hxg5EjR5InTx7Cw8O5c+cO4eHh9OikUbtqAsQfsUVrhRACSBwhERt7fx62WrVqcezYMauY48eP4+8vc9TYWrxbOmLu95NhdkjfOsm5Z7aeH+uDDz6gePHiDBw4EIBz586xZs0aDt6JZ28EXItI/w9UpocG9DxqG4XICjKTcOaTPJNzPPh1JibyLke2HefINuu7qOf28/6vg68wZWqWpFbbavqyhIQEjEYjmqaxb98+Lly4kGQbcdzLtPYLIUR2J515mcRsNnPy5EnUbT8CC13GYEj9VyClotBznvZo31588xmTlD04SbBF1xYFIM4lSXlaVNxuNIdg/bEQ4ukRFRXFyZP3J4U+c+YMe/fuxdvbm8KFCzN8+HDCwsL48ccfAZgyZQqFCxemVKnEEbsbNmxg/PjxvPHGG3odgwcPJiQkhDFjxtCpUyd27NjBjBkzmDFjxpPduaeYJdfkt4vnaoIdipR/DIp+YDSe22NcBmfnaj0C5+uvv2bixIn6JMz+/v5069YNe3t7tp84T+9v0j9C5nbU/UnOV+w7nkqkECKnkTyTM1nyTK7ibtw+GZXmFNt3I+/h6uGCi0fa3zVuXrrFzUu32LV8LxXqBemdebF3Y1m+cjm///47f/31F5cvJz+1jwNOyZanRm4YIIR4WkhnXiZJSEjg559/BurzTq9fcDCYUl/BfOP+Y8OjTcZap7ozBX3tCLuSQHIjyDUNCvraUae68yPVj/mBic4TjqUcJ4TIcXbt2kX9+vX152+99RYAPXr0YNasWVy+fJnz5+/fWdRsNjN8+HDOnDmDnZ0dgYGBfPbZZ7z66qt6TNWqVVmyZAnDhw/no48+IiAggC+//JKuXbs+uR17yllyTW0XWBLhTmqZ5kbk/RFy+bwefciba4Gi2Ll5khCVmBNmzpzJmDFjcHV11WPs7RMv6d12ImN3o3VyuH8p8NbjcidbIZ4mkmdyJkueCepShC1jDmGOT70379aVO+Qp4E2u/F4Y7YyYEtL4DvSffesOMen1GVw9d529aw+x5t5Sq7vYPswRZ3KRN0P7AuDt66U/3vr7rgyvL4QQ2YV05mUXpvv/vGR0LjsLo1Fj4ui8dOpzGU3DqkPPMtT9i4/yYjQ+2mW82CXOfaTMMWC+9mh1CCGypXr16qU6j8ysWbOsng8cOFC/rDI1LVu2pGXLlo/bPGEDNyNjiImNw8XRgQAf70euRzMY8K3/PBf+mAVAZGQk3333Hf3797eal9VkNtOmahD/7D3OxZvhKdRmregD7Tp3/XYqkUKInEbyzLPh8qkrlAguitFooEBxX84fuZjudZdNX6k/LklF9rM1xdiSVMzwzS8A/Mvcv6Ff2Em5mZ8QIueSccbZRfzR+48dKj5yNe1auDH/W18K5Lfupy3oa8f8b31p1+IRR2NoudDsCic+TjhKmmPshchGjAYzTWvtpFmzZknu7CzEs+TopesAFMztSW63jE+3YOFZvDyFWvXEzs0TgMmTJ+uXLpn/u62u0WCgoLcnvw7uQnDRAumqt7z//ZHpxy/fSCVSiOzHDOy56yS5RjzTTu49oz8uXaP4I9fjoxWgPDVxxPqKIkecKU9NfLT05ZWHlap+v02n9p595PYJkRWUSXHqr0uSZwQgI/OyDxWBij+aeMdYuyDQcoF6tFEJ7Vq40aapKxu33+XyVRO++YzUqe786CPyABxr338s8+WJHMZoVFQtexxD/mppBwuRQ8W7kepltgC7LoZROSDxC1C18v78vv/Rb4TkUqk8RSuU5e7508RERbB2/yEaVCyHWSlQYNA07IwGXB0d+O61Dnz4+0oW7z2cYn1ezk4EFcoHwIlrN7lhuAdyAwyRo2gcxYFq1STXiGfXgQ3380qVxhVZPjPtu62nxEcrQF7lx22uE8c9HHAiF3kfaUTeg23S27pRbgYochZlhss7b0meEYCMzMteYjcAoGkGcGr8WFUZjRr1Qlx48Xl36oW4PF5HHqA5NdMfq7j1j1WXEEKIrLH++Fn9cdOgRx8xYaEZDLgUKYZH2cpM3bafZQeO8vw3PzF/9wE9xmgwYGc0MOb5JgxpVAdDCl/CGpUphvG/0X0bT5xJNkYIIUT2dnTHSSJuRQFQvUVlnFwe/YZLAJqm4a35kF8rjLfm81gdeXkKeFMmpAQA549c5Oq564/VNiGEyErSmZeNqHt/6Y81lxeysCUPMeQDx1AAlOkqxMlksSJnMZs1zl7y4ezZs5jN5qxujhBZZs+FS1wJjwSgbvEA8nvYbujbocvXGLLwb05cu8nIP1bzyV9rMStl9Zl7pVYwU15sjcsDN7qw6BRcTn/85wG5yZLIeTQUPiRIrhHPNFOCiU2LtwHg7OZEvc61srhF9zV95Tl9Soi1v2zO4tYI8Qg08PR3lTwjAOnMy14SDqPiE0czaPZlwSEkixuUSHN9GU3774vX3YUkzgojRM6RYDIw549GzJ49m4SEhKxujhBZxqwUi/YcAsDOaKBnSHCmbWvO9r28+tNS7iWYSDAl5g1N06hbvAi/9O6Mr6e7Hls9oBDlCiTOl3fo0lUOXZabLImcxwA0MMRIrhHPvL++Xa0/7jikNQZj1n/ldHJ1ok3/xCuNTAkmls9al7UNEuIRGOw0yvUMkDwjAJkzL9MYjUaaNWuGivgIoyH9nV8q+ns0ry8B0NzfRt3cSpbebMJYAFy6JLZN3UPFzM26tgghhLBiyTUjV60hzk6h0nH10exDe+hVKxhne3u6VC3PrAP/cjE8IlPat/bKGdr/NI/vOzyPj5sbdgYDRoOBonm8WfRaV/osXsL+y1d4q8n9eVm/+3c3CW5ykyWRAykFd7O6EULYliXPfD3we5QpfefmYztPsn/9YcqHlqFwqQI0ebk+f3+3Ou0VM1HHIa3wyusBwPr5W7l+QW6yJITI2bL+Z5L/fPrpp2iaxqBBg/Sye/fu0b9/f3Lnzo2bmxvt27fn6tWrVuudP3+eFi1a4OLigo+PD0OHDs0WvdRGo5Fq1apRtexxjMYMfCm59w8qPnEyVs2+HLh0y6QWpo/mPgJNc0p8Ej0HzJL4hBAiu7DkmuP2Dqh0ziN0K+Yus3fvAcDBzo5RDRtkZhM5cfMmbX+cy/7LVzD9d0mIndGAp5Mjv7z4AmOaNKaCb+KovGPXb/DnUbnEVgghsgtLnrm88xYqAxfnzPzgZ/1x77Fd8fLxzITWpU+hkn50fqctAAnxCfw4an6WtUUIIWwlW3Tm7dy5k+nTp1O+fHmr8sGDB/PHH3+wYMEC1q9fz6VLl2jXrp2+3GQy0aJFC+Li4tiyZQuzZ89m1qxZfPjhh096F2zIjIoYrT/T3IeCXYmsaYpLNzSnegAo0zVU9NSsaYcQQgib+mb7Dq5EJs6dF1o0gO6VK2Xq9m7dvUu3Xxfw2+H7dw40/jdKr2P5snrZR6vXJN4NVwghRI52cNNR1szbBIBHbneGzRrwWDeveFT2jva8+9ObODg5ALDkq78IO3H5ibdDCCFsLcs786KioujatSvffvstuXLl0svDw8P5/vvv+eKLL3juuecIDg5m5syZbNmyhW3bEidVXbFiBYcPH+ann36iYsWKNGvWjNGjRzNlyhTi4uKyapcAMJvNnD17lrOXfDCbM5i44nehon8CQNOc0LymgcE7E1qZCocaaO7D9acq4n1Q0U+2DUIIIVJlyTX5TAloGegEi4qL473lq/Tn/6sfSoh/4cxooi7OZGLY38v5bP2GxBtjKGV1Z9u5e/ex/cLFTG2DEEKIjLHkGU9/V8jgV5ppg2dy68odAKo2rUjvz57sFUeapvHWt69RIrgoABeOXWL2h78+0TYIIURmyfLOvP79+9OiRQsaNmxoVb57927i4+OtykuVKkXhwoXZunUrAFu3bqVcuXLky5dPj2nSpAkREREcOnQoxW3GxsYSERFh9WdrCQkJzJ49mzl/NCLBlPGXWUV+iopP3AfNrhBarpmg5UpjLRuxr4TmNVW/6YWK/g5i1z2ZbQshxFPgSeQZuJ9rGsfexZjBddefOcO3OxLvTm5nMDCtbWuCC/jZvpEP+XbHLob+9bdV2bHr1xmzdn2mb1sIIZ4WTzrPlOsZgMEuY715d65H8Gm3SZgSTAB0GtKaF4c/nxnNTFb/r3rRsFtdAO5G3/t/e3ceHtPZhgH8PrNln0TIIhoSsUaJ2CK0RYVQVUpVUVsVVWvTamkRqrW0KCpoUaHlo9qilmpjr4otpLWvIZYsFFklmeV8f6RzGJIImcnMJPfvuuZiZp5z5pksc2feec95MfX12ci9Z9kJH0REpmLRBTDWrFmDo0eP4vDhw4/cl5ycDJVKBTc3N6Pbvby8kJycLNU8OJBnuN9wX2GmT5+OKVOmlLB7c8uDeOcdoOKPEOSVISjrAhVXQ7wzBNBdNd/D2r0IwXUOBJkjAEDM2QExY7b5Ho+IqAyyRM5onfXQPuEhTNOP7oGfhxva+deAk0qF6B7dMXr7Fvxx+YKZugR8XVwxrEWINCvvZnYWBvz2C7Ls+QaLbBwXwKBSZBvvZ4BjO09gwajvMHrhYADAW5/3hrqSGkvGfg+9/glOwvcElHZKRCx5RxrI0+n0mPHmfCQcTzTL4xERWYLFZuZdvXoVo0ePxqpVq2Bvb1+qjz1+/HikpaVJl6tXzTg4VhL6FIi3B0DU5S/6ISgCIFT8BbDrYIYHU0Jw/gCyCovvD+Tl7oN49z0AOjM8HlHpkctEtA05irCwMMjlTzp/iejJ2UrO6EURI2I2YU9iAgDAQanEtx27YlzzF6CSmf53pUP1mtjcoy9qVKgIAEjJysQbG9ciKSvD5I9FVNr0AA47KZk1VCpsJWcAYPPiP/Dth99L119772XM+GMiKlUx/WmEfGv7YN5fnxkN5M0aGIX9Gx+dPEJka0QdkBCTzJwhABYczIuLi0NqaioaNWoEhUIBhUKBPXv2YP78+VAoFPDy8kJeXh7u3r1rtF1KSgq8vfNXvfP29n5kdVvDdUNNQezs7KBWq40uVkuXAPF2L4jaiwAAQeYKWYX5ENyiALmJzm+kagmh0kYIzkOkm8R7m/NnBiLHNI9BZEFyuR4tGp5Gy5YtGXxUKmwpZ3J1Ogz+bQM2nDsl3fZOcDNsfb0fXvD1M8lj+Lq4YnH4K1gc3gWudvkf4F288y9eW/8/XLx72ySPQWRpekHACScVs4ZKhS3lDACsm/Urvhr6DbQaLQAg+MVnsfTkV+g2phOUqpIfLGbvZI9+k1/H4mNfomaj/HPk5WTnYkr3L7H9h70l3j+RNRD1Iq7vv8WcIQAWHMxr27Ytjh8/jvj4eOnSpEkT9OnTR/q/UqnEjh07pG3Onj2LxMREhIaGAgBCQ0Nx/PhxpKamSjUxMTFQq9UIDAws9edkNrprEP99DeK9rdJNgn07CJV+g+D6JaBsUMTGhVECduEQ3FdD5r4cgqIGAEAUNdCnz4CYFgGAhzwREZUHeXodxuzYiql/7UKeLn82do0KFbHy5dfwU9deeKl6raeaqdfQ0xuzX+yIXb0HoUP1+yuzb714Dl1/WYWrGWkmew5ERGTdti7Zjg/DPsXNa/8CAJzUjhg2ZwCiz3+N197vDNdKTz4gWamKO/pG9sAPCVHoO6mHtGpt4pnrGNn8Y8T+esSkz4GIyFpY7Jx5Li4uePbZZ41uc3JyQsWKFaXbBw0ahIiICLi7u0OtVmPkyJEIDQ1F8+bNAQDt27dHYGAg+vbtiy+++ALJycmYMGEChg8fDjs7u1J/TmYlZkFMGwMxNwaCy8cQ5B75C1Q4dIHg0AWiNhHI3QNREwdozgK6awBy728vqPNn8inrQVCFAHbPQ5C5Gj9E3t8Q0ycC2jOl+9yIzEyvF5B8qwIE3XVUrlwZMpnF1/4hMj0nLSB7wqUGH7Ls0kHsv5OAaSHhCPaoAgBoUrkKmlSugvS8HOy+fgkHUhJx4nYyLmfcQXre/ZyxkyvwjJMr6lTwQBPPZ9DGJwB+auOFm27ey8RncTuxMeEUoEL+haiMEEQRFXNFXL/OrCEqzPE/T2No0Ad4e2YfvPR2/kKHnr6VMPTLfhg0rTeO7z2NuO3/4NzhC0g8fR23k+9C/G+1dplchoo+7qhWtwrqNK+JJu2CUK9lHaP9azVa/DJvK1ZGruViF1T2CIBzZQfmDAGw8AIYj/PVV19BJpOhe/fuyM3NRXh4OBYuXCjdL5fLsXnzZgwbNgyhoaFwcnJC//798emnn1qwazPL2QIxdzdExwEQnPpBkOW/URIUVQFFXwjoK5WKYg4gagFBBUEo/B2TqL0AMTMKyNkKQDT3MyAqdVqdDMvWdwSwFOPHj4dKxREEosKcvpOKbtu+R6dqdTCifgvUqeAJAFCr7PGKfyBe8b8/812j1yFHq4VSJoO9QlnoPtNyc/DdmcNYdvowMjV8c0Vlk1wEOt/QYOlSZg1RUTLuZOKrId/g14W/o//kngh9pQkAQKFUILhtfQS3rS/V6vV65GTlQhAEODgXfp51nVaH3Wv34/tP1+H6+SSzPwciS5ApBDQcHMCcIQBWNpi3e/duo+v29vaIiopCVFRUodtUq1YNW7duLfR+S5HL5QgLC4OY8QXkMhMPkIlZQFYUxOzvINp3gGDfBVA1gyAYfzsFwR4oZJKGqM8AcndCvLceyNtv2v6IiKhUGLJm+tFd0JdsUp4REcDmK2ew+coZtPCuhtcC6iPsmRpQq4zfSCllcihVBR9+q9XrcTAlERsSTmHT5VPI0WlN1yAREZUKQ84s+egHiCZeE+9i/GVM6joTVWpWRoe3XsQLrzWHT4Dxec9lMhkcXRwK3ceVU9ewe+1f2PbdTty6znOwElH5YVWDeWWJXC5Hy5YtoU8+bb4HEe8B99bnD8gJzhBVTQBFPQiK6oDcGxBcAEEBiHmA/i6guw5Rex7Q/A1ojgPgGysiIltmyJoTl/4022PsT76C/clXoBBkqF/RG408qqCmayVUcVajgsoB9goFNHo90vNykJydgUvpt/HPv8k4knoNGZrcxz8AERFZLUPOTN4/12yPcf18EpaNX4Vl41ehSs3KePa5OggI8oO3nycqeLvBwdkeer0e9zJycCflLm5cTMb5owk4+dcZpCbeMltfRETWjIN5ZYWYCeTuBnJ380BZIiIyOa2ox7FbN3Ds1g1Lt0JERGXU9fNJPEyWiKgYOJhnJnq9HklJSRD/dYd3pTuQmfpQWyIiKvcMWVNFlos7DoBowkNtiejJyPWW7oDI9Aw54+zjgMykezy9NhGRleDyJ2ai1WqxdOlSLFvfEVodv8xERGR6hqxpfwHgZ0ZERGRqhpxpODgAMgU/MSIishYcZSIiIiIiIiIiIrIRHMwjojJPLhPxQuN/0KpVK8jlBa+8SUREVBIigBOeYNYQEZFZiDogcXcqc4YA8Jx5RFQOyOV6tGpyHDLv1pZuhchs3BzvQce/64gs6poL0Lp1a0u3QUREZZCoF5G4J5U5QwA4M4+IiIiIiIiIiMhmcDCPiMo8UQRSb7siNTUVoshVAoiIyAxEwDlbYNYQEZHZOHrYMWcIAAfziKgc0Gjl+Gbdy1i0aBE0Go2l2yEiojJIrgee+9ueWUNERGYhUwpo9G5N5gwB4GCe2cjlcrRq1QovNP4HchlHzYmIyPQMWXPhGQ30gqW7ISKissaQM4m7UyHqLN0NEREZcAEMM5HL5WjdujX0yUMs3QoREZVRhqyZp1wHL0s3Q1TOyXQA4GDpNohMypAzn78YZelWiIjoAZyZR0REREREREREZCM4mGcmoigiNTUVqbddwXNTEhGRORiyxj5TDjBriIjIxAw54+hhZ+lWiIjoARzMMxONRoNFixbhm3UvQ6OVW7odIiIqgwxZU+dARcj0lu6GiIjKGkPONHq3JmRKnpyViMha8Jx5REREZYCPfRqg4PQ8IovRCgA8Ld0FERERlQOcmUdEZZ5cJiK0wSmEhoZCLudMWSIiMgOZiOyA28waIiIyC1EHXNt/kzlDADgzj4jKAblcj7DQY5B5t7d0K0REVFbJgOzAW2jfiFlDRESmJ+pFXI5JQfvfmTPEmXlEREREREREREQ2g4N5RFTmiSJwN8MJd+/ehcjlpQu0d+9edO7cGT4+PhAEARs2bCiyft++fWjZsiUqVqwIBwcH1KlTB1999dUjdVFRUfDz84O9vT1CQkJw6NAhMz0DIiILEwFZtoJZUwjmDBFRydm5KpkzBICH2RJROaDRyvH16q4A5mH8+PFQqVSWbsnqZGVlISgoCG+99Ra6dev22HonJyeMGDECDRo0gJOTE/bt24ehQ4fCyckJQ4YMAQCsXbsWERERWLx4MUJCQjB37lyEh4fj7Nmz8PTkSeJNrarDvxAUXNKWyFJErQzZm5tj3g5mTUGYM0REJSNTCmg6pjbmzWPOEAfzzEYulyM0NBTIWga5jKPmRGTdOnbsiI4dOxa7Pjg4GMHBwdJ1Pz8//PLLL/jzzz+lN1lz5szB4MGDMXDgQADA4sWLsWXLFnz33XcYN26caZ9AOWXImiO3fwIEZg0RWS/mjG0y5My62b9C1Fm6GyIiMuBhtmYil8vRvn17hIUeg1zOmRJEZBnp6elGl9zcXLM8zrFjx7B//360atUKAJCXl4e4uDiEhYVJNTKZDGFhYYiNjTVLD+WRIWtUQVcgyDmYR0SljzlTthly5nJMCkQ9c4aIyFpwMI+IqAzz9fWFq6urdJk+fbpJ9//MM8/Azs4OTZo0wfDhw/H2228DAG7dugWdTgcvLy+jei8vLyQnJ5u0ByIishzmDBERUenjYbZmIooi0tLSoM9wgqtzFgTB0h0RUXl09epVqNVq6bqdnZ1J9//nn38iMzMTBw4cwLhx41CjRg306tXLpI9BhZOyJssOgmMus4aISh1zpmwz5IydqxK5aRpLt0NERP/hYJ6ZaDQazJs3D0BXfPTWGqiUPMkEEZU+tVpt9CbL1Pz9/QEA9evXR0pKCiZPnoxevXqhUqVKkMvlSElJMapPSUmBt7e32fopb+5nTWPUeWMLZApmDZGl6GVynLF0ExbAnCnbDDnTdExt7J92EnoND7UlIrIGPMyWiIhMQq/XS+dKUqlUaNy4MXbs2GF0/44dO/IXByIiInpCzBkiIqJ8nJlHRGWeTCaiSeA5wLE3ZDJ+hlGQzMxMXLhwQbqekJCA+Ph4uLu7o2rVqhg/fjyuX7+OlStXAgCioqJQtWpV1KlTBwCwd+9ezJo1C6NGjZL2ERERgf79+6NJkyZo1qwZ5s6di6ysLGnVQSKiMkUQUaFWAgLUPZg1BWDOEBGVjKgHbhz+F68MC2fOEAfziKjsU8j16Pj8Yci8V1m6Fat15MgRtGnTRroeEREBAOjfvz+io6ORlJSExMRE6X69Xo/x48cjISEBCoUCAQEBmDlzJoYOHSrV9OzZEzdv3sSkSZOQnJyMhg0bYtu2bY+crJyIqCyQyfWo3Ow4OgVEW7oVq8ScISIqGVEn4tLWJHTa3MnSrZAV4GAeERGhdevWEMXCz4MTHR1tdH3kyJEYOXLkY/c7YsQIjBgxoqTtUTH4K25BodRaug0iogIxZ4iIiEyHczOJqMwTRSDrnh2ysrKKfCNBRET0tEQRyM2xZ9YQEZHZKBzlzBkCwME8IioHNFo55qx8DbNmzYJGo7F0O0REVAbptAr88b8+zBoiIjILmVJA87F1mTMEgIN5ZiOTydCkSRM0CTwHmYyj5kREZHqGrPGrcwqCTG/pdoiIqIwx5MyNw/9CZMwQEVkNDuaZiUKhQKdOndDx+cNQyJl8RERkeoasqR8aCzmzhoiITMyQM5e2JkHUcYICEZG1sOgCGIsWLcKiRYtw+fJlAEC9evUwadIkdOzYEQCQk5OD999/H2vWrEFubi7Cw8OxcOFCoxWqEhMTMWzYMOzatQvOzs7o378/pk+fDoWCa3sQEVH5UF3BN1hElqbh+YuIiIiolFh0Zt4zzzyDGTNmIC4uDkeOHMGLL76ILl264OTJkwCA9957D5s2bcK6deuwZ88e3LhxA926dZO21+l06NSpE/Ly8rB//36sWLEC0dHRmDRpkqWekkQURWRlZSHrnh34tx0REZmDIWuy79kza4iIyOQMOaNwlFu6FSIieoBFB/M6d+6Ml156CTVr1kStWrXw+eefw9nZGQcOHEBaWhqWLVuGOXPm4MUXX0Tjxo2xfPly7N+/HwcOHAAA/PHHHzh16hR++OEHNGzYEB07dsTUqVMRFRWFvLw8Sz41aDQazJo1C3NWvgaNluFHRESmZ8iaJT+8Ca2WM9KJiMi0DDnTfGxdyJSCpdshIqL/WM0583Q6HdasWYOsrCyEhoYiLi4OGo0GYWFhUk2dOnVQtWpVxMbGAgBiY2NRv359o8Nuw8PDkZ6eLs3uK0hubi7S09ONLkRERKbCnCEiInNizhARlW8W/xj/+PHjCA0NRU5ODpydnbF+/XoEBgYiPj4eKpUKbm5uRvVeXl5ITk4GACQnJxsN5BnuN9xXmOnTp2PKlCmmfSJEZLVkMhENal2E4NANMpnVfIZBZZglcsZFZg+VTFeqj0lE92kVMmYNlRq+nyEqf0Q9kBJ/B+37t2bOkOVn5tWuXRvx8fE4ePAghg0bhv79++PUqVNmfczx48cjLS1Nuly9etWsj0dElqWQ69GlzQF07dqVi+NQqWDOEJU/zBoqTcwZovJH1Ik4v/E6c4YAWMHMPJVKhRo1agAAGjdujMOHD2PevHno2bMn8vLycPfuXaPZeSkpKfD29gYAeHt749ChQ0b7S0lJke4rjJ2dHezs7Ez8TIiIiPIxZ4iIyJyYM0RE5ZvFZ+Y9TK/XIzc3F40bN4ZSqcSOHTuk+86ePYvExESEhoYCAEJDQ3H8+HGkpqZKNTExMVCr1QgMDCz13onIOokikKeRIy8vDyKX/CQiIjNg1hARkbnJlAJzhgBYeDBv/Pjx2Lt3Ly5fvozjx49j/Pjx2L17N/r06QNXV1cMGjQIERER2LVrF+Li4jBw4ECEhoaiefPmAID27dsjMDAQffv2xd9//43ff/8dEyZMwPDhw/lJFRFJNFo5Zn73BqZPnw6NRmPpdoiIqAxi1hARkTnJlAJafFyPOUMALHyYbWpqKvr164ekpCS4urqiQYMG+P3339GuXTsAwFdffQWZTIbu3bsjNzcX4eHhWLhwobS9XC7H5s2bMWzYMISGhsLJyQn9+/fHp59+aqmnJJHJZAgKCoJ47xfIZBw1JyIi02PWEBGRORly5o8VuyHqLd0NEREZWHQwb9myZUXeb29vj6ioKERFRRVaU61aNWzdutXUrZWYQqFA165doU/+0NKtEBFRGcWsISIiczLkTFS3VZZuhYiIHvBEg3mnT5/GmjVr8Oeff+LKlSvIzs6Gh4cHgoODER4eju7du/PwViIislnMOSIiMifmDBERmUKxzpl39OhRhIWFITg4GPv27UNISAjGjBmDqVOn4s0334Qoivjkk0/g4+ODmTNnIjc319x9Wz1RFJGXl4c8jRw8NyURkXWz1Zxj1hAR2QZbzxmZUrB0K0RE9IBizczr3r07xo4di59++glubm6F1sXGxmLevHmYPXs2Pv74Y1P1aJM0Gg2mT58O4A189NYaqJQ6S7dERESFsNWcY9YQEdkGW8+ZFh/Xw/5pJ6HX8JMjIiJrUKzBvHPnzkGpVD62LjQ0FKGhoVxZhYiIbApzjoiIzIk5Q0REplSswbziBE9J6omIzEkmiKhb/QoE+46QyYp1dgEqZ5hzRFRSzBoqCnOGiEpK1AO3TqbhhR6hzBl6utVsDx8+jF27diE1NRV6vfEa5XPmzDFJY0REpqJQ6PFau32QeX9n6VbIRjDniOhJMWvoSTBniOhJiToRZ366iq9/5GsEPcVg3rRp0zBhwgTUrl0bXl5eEIT7J0N98P9ERES2iDlHRETmxJwhIqKSeuLBvHnz5uG7777DgAEDzNAOERGRZTHniIjInJgzRERUUk98oLVMJkPLli3N0QsRkVnkaeSY+k0fTJkyBXl5eZZuh6wcc46IngazhoqLOUNET0OmFPBc5LPMGQLwFIN57733HqKioszRS5kik8kQGBiIutWvQCZwCXciIlthSznHrCEisj22mDO3TqZB1D++noiISscTH2b7wQcfoFOnTggICEBgYOAjKy398ssvJmvOlikUCvTo0QP65E8s3QoRET0BW8o5Zg0Rke2xxZz5tuePlm6FiIge8MSDeaNGjcKuXbvQpk0bVKxYkSdpJSKiMoU5R0RE5sScISKiknriwbwVK1bg559/RqdOnczRDxERkUUx54iIyJyYM0RE5hMVFYUvv/wSycnJCAoKwtdff41mzZoVWr9u3TpMnDgRly9fRs2aNTFz5ky89NJL0v2iKCIyMhJLlizB3bt30bJlSyxatAg1a9aUam7fvo2RI0di06ZNkMlk6N69O+bNmwdnZ2ezPc8nPmeeu7s7AgICzNFLmZKXl4cpU6Zg6jd9kKeRW7odKoH0TAdcvu6F9EwHS7dCRKXAlnKOWVN2MGuIyg9bzJnnIp+FTMkZhLZM5aKAq58TVC5PPJ+HyGasXbsWERERiIyMxNGjRxEUFITw8HCkpqYWWL9//3706tULgwYNwrFjx9C1a1d07doVJ06ckGq++OILzJ8/H4sXL8bBgwfh5OSE8PBw5OTkSDV9+vTByZMnERMTg82bN2Pv3r0YMmSIWZ/rEw/mTZ48GZGRkcjOzjZHP0RW5diZAMxf/Sq+3xyG+atfxbEztvGHFxE9PeYclTZmDVH5wpyh0uYVXAFNx9RG/f7+aDqmNryCK1i6JSKzmDNnDgYPHoyBAwciMDAQixcvhqOjI7777rsC6+fNm4cOHTpg7NixqFu3LqZOnYpGjRphwYIFAPJn5c2dOxcTJkxAly5d0KBBA6xcuRI3btzAhg0bAACnT5/Gtm3bsHTpUoSEhOC5557D119/jTVr1uDGjRtme65PPCw/f/58XLx4EV5eXvDz83vkhK1Hjx41WXNElpSe6YAte0MgivmfQoqigC17myHgmRtQO9+zcHf0JGSCiBpVr0Owaw2Z7Ik/w6ByhjlHpYlZU3Ywa6i4mDNUmlQuCtR42QeCLD9nBJmAGi/74M6FDORlaC3cHT0JUQ/cPpeBkE6NylXOpKenG123s7ODnZ3dI3V5eXmIi4vD+PHjpdtkMhnCwsIQGxtb4L5jY2MRERFhdFt4eLg0UJeQkIDk5GSEhYVJ97u6uiIkJASxsbF44403EBsbCzc3NzRp0kSqCQsLg0wmw8GDB/Hqq68+8XMujicezOvatasZ2iCyPrfT1NKbKwNRlOF2ugvfYNkYhUKPXh13Q+b9raVbIRvAnKPSxKwpO5g1VFzMGSpNDhXtpIE8A0EmwMHdjoN5NkbUiTj1vyuYt2qWpVspVb6+vkbXIyMjMXny5Efqbt26BZ1OBy8vL6Pbvby8cObMmQL3nZycXGB9cnKydL/htqJqPD09je5XKBRwd3eXaszhiQfzIiMjzdEHkdVxd02HIIhGb7IEQQ93dYYFuyIic2POUWli1hCVP8wZKk33/s2FqBeNBvREvYh7t3Mt2BVR8V29ehVqtVq6XtCsvPKoWHMzRVE0dx9EVkftfA+dXjgIQdADyH9z1emFQ5wpQVQGMefIUpg1ROUDc4YsJS9Diwubb0DU5/8MinoRFzbf4Kw8shlqtdroUthgXqVKlSCXy5GSkmJ0e0pKCry9vQvcxtvbu8h6w7+Pq3l4gQ2tVovbt28X+rimUKzBvHr16mHNmjXIy8srsu78+fMYNmwYZsyYYZLmiCwtuM5FjOq9AX07x2BU7w0IrnPR0i3RU8jTyDFjWU9Mmzbtsa9jVD4x58iSmDVlA7OGisKcIUtKOXYHh+eexfHoBByeexYpx+5YuiV6CjKlgNDxgcyZQqhUKjRu3Bg7duyQbtPr9dixYwdCQ0ML3CY0NNSoHgBiYmKken9/f3h7exvVpKen4+DBg1JNaGgo7t69i7i4OKlm586d0Ov1CAkJMdnze1ixBvO+/vprzJo1C97e3ujZsye+/PJLrFq1Cj///DOWLl2KiIgINGvWDA0bNoRarcawYcPM1rCtkMlkqFmzJmpUvQ6ZwE/ibJna+R78fFI5S8LGabQKaDQaS7dhtfbu3YvOnTvDx8cHgiBIJ30tzC+//IJ27drBw8MDarUaoaGh+P333wutnzFjBgRBwJgxY0zbuInYas4xa8oOZk3ZwKwpHHPGtnPm9rkMiHpLd0MlkZehRdqVLM7Is3FylYw5U4SIiAgsWbIEK1aswOnTpzFs2DBkZWVh4MCBAIB+/foZLZAxevRobNu2DbNnz8aZM2cwefJkHDlyBCNGjAAAKVc+++wz/Prrrzh+/Dj69esHHx8f6fyndevWRYcOHTB48GAcOnQIf/31F0aMGIE33ngDPj4+ZnuuxTpnXtu2bXHkyBHs27cPa9euxapVq3DlyhXcu3cPlSpVQnBwMPr164c+ffqgQgUucw3kn/Cwd+/e0CdPtnQrRESPlZWVhaCgILz11lvo1q3bY+v37t2Ldu3aYdq0aXBzc8Py5cvRuXNnHDx4EMHBwUa1hw8fxjfffIMGDRqYq/0Ss9WcY9YQka1gzth2zix/c72lWyEieqyePXvi5s2bmDRpEpKTk9GwYUNs27ZNWsAiMTHRaCXgFi1aYPXq1ZgwYQI+/vhj1KxZExs2bMCzzz4r1Xz44YfIysrCkCFDcPfuXTz33HPYtm0b7O3tpZpVq1ZhxIgRaNu2LWQyGbp374758+eb9bk+0QIYzz33HJ577jlz9UJERBbSsWNHdOzYsdj1c+fONbo+bdo0bNy4EZs2bTJ6k5WZmYk+ffpgyZIl+Oyzz0zVrtkw54iIzIM5k485Q0RkXiNGjJBm1j1s9+7dj9zWo0cP9OjRo9D9CYKATz/9FJ9++mmhNe7u7li9evUT91oSxTrMloiIbFN6errRJTfXPCuX6fV6ZGRkwN3d3ej24cOHo1OnTggLCzPL4xIRkWUxZ4iIiEofB/PMJC8vD9OmTcOMZT2Rp5Fbuh0iKqd8fX3h6uoqXaZPn26Wx5k1axYyMzPx+uuvS7etWbMGR48eNdtjErOGiCyPOVO2GXImdHwgZErB0u0QEdF/nugwW3oy+Sem5JeYiCzn6tWrUKvV0vXClnIvidWrV2PKlCnYuHEjPD09pccdPXo0YmJijM4nQabHrCEiS2LOlH0ajQZyFeeAEBFZk2L/9X/jxg2zrsRBRGQuggBUq5wCqJpBEMrXp8pqtdroTZaprVmzBm+//TbWrVtndIhTXFwcUlNT0ahRI+k2nU6HvXv3YsGCBcjNzYVcbl0zyZhzRFQS5TVrmDPFx5whohIRgbTLWWjQKrBc5QwVrNgfsdSrV6/UT+hHRGQKSoUO/V7ZjgEDBkCpVFq6nTLjf//7HwYOHIj//e9/6NSpk9F9bdu2xfHjxxEfHy9dmjRpgj59+iA+Pt7q3mABzDkiKhlmjekxZ4iI7tNrRRxfkcCcIQBPMDPv888/x9ChQ7F+/Xp88803j5x8loiIbFdmZiYuXLggXU9ISEB8fDzc3d1RtWpVjB8/HtevX8fKlSsB5B/y1L9/f8ybNw8hISFITk4GADg4OMDV1RUuLi5GS7oDgJOTEypWrPjI7daCOUdEZD7MGeYMERGZTrFn5r377rv4559/8O+//yIwMBCbNm0yZ19ERFSKjhw5guDgYAQHBwMAIiIiEBwcjEmTJgEAkpKSkJiYKNV/++230Gq1GD58OCpXrixdRo8ebZH+TYE5R0RkPswZ5gwREZnOE50x29/fHzt37sSCBQvQrVs31K1bFwqF8S6OHj1q0gaJiEoqTyPH16u7ArIvMXr0aKhUKku3ZHVat24NURQLvT86Otro+u7du5/4MZ5mm9LGnCOip8WsKRpzJh9zhoielkwpoOno2vjyS+YMPcXyd1euXMEvv/yCChUqoEuXLo+ED+UTBAHVqlUD8g6B56YksrzsHHsA2ZZug2yALeUcs4bIujBrqDhsMWf+2XMKKHwslohKidJJgexs5gw94WDekiVL8P777yMsLAwnT56Eh4eHufqyeUqlEgMGDIA+eZqlWyEiomKytZxj1hAR2RZbzZl2b/WwdCtERPSAYg/mdejQAYcOHcKCBQvQr18/c/ZERERU6phzRERkTswZIiIylWIP5ul0Ovzzzz945plnzNkPERGRRTDniIjInJgzRERkKsVezTYmJsbkwTN9+nQ0bdoULi4u8PT0RNeuXXH27FmjmpycHAwfPhwVK1aEs7MzunfvjpSUFKOaxMREdOrUCY6OjvD09MTYsWOh1WpN2uuTysvLw5dffonZK7ojTyO3aC9ERPR45sg5c2PWEBHZDlvOmZAP6kCm5MlZiYisRbEH88xhz549GD58OA4cOICYmBhoNBq0b98eWVlZUs17772HTZs2Yd26ddizZw9u3LiBbt26SffrdDp06tQJeXl52L9/P1asWIHo6GhpmXtLys7O/u9EyERERObBrCEiInPKzs6G0sl6F+kgIiqPLPqqvG3bNqPr0dHR8PT0RFxcHF544QWkpaVh2bJlWL16NV588UUAwPLly1G3bl0cOHAAzZs3xx9//IFTp05h+/bt8PLyQsOGDTF16lR89NFHmDx5MpdrJiIIAlDZ418IyvoQuOQnERGZAbOGiIjMSgQyrmejdtMazBmy7GDew9LS0gAA7u7uAIC4uDhoNBqEhYVJNXXq1EHVqlURGxuL5s2bIzY2FvXr14eXl5dUEx4ejmHDhuHkyZMIDg5+5HFyc3ORm5srXU9PTzfXUyIiK6BU6PB2t22Qec+3dCtUTjBniMofZg2VJuYMUfmj14r4e+klzPp2pqVbIStgNYN5er0eY8aMQcuWLfHss88CAJKTk6FSqeDm5mZU6+XlheTkZKnmwYE8w/2G+woyffp0TJkyxcTPoHAZ+hwo9ZY9hx8RAW6WboDKjdLOGSIiKl+YM0RE5ZtFz5n3oOHDh+PEiRNYs2aN2R9r/PjxSEtLky5Xr141+2MSEVH5wZwhIiJzYs4QEZVvVjGYN2LECGzevBm7du0yWuHJ29sbeXl5uHv3rlF9SkoKvL29pZqHV7c1XDfUPMzOzg5qtdroQkRll0Yrx3f/64m5c+dCo9FYuh0qB5gzROWPRiPH/FVdmDVUKpgzROWPTCGgyehazBkCYOHBPFEUMWLECKxfvx47d+6Ev7+/0f2NGzeGUqnEjh07pNvOnj2LxMREhIaGAgBCQ0Nx/PhxpKamSjUxMTFQq9UIDAwsnSdSAEEQ4OPjA89KNyEIosX6ICIAooCMTBekpaVBFPn7SGWHIWsqe/wLngeZyLJEAGmZzswaKlMMOZNxPTv/h5yILEcA7N1UzBkCYOFz5g0fPhyrV6/Gxo0b4eLiIp3jztXVFQ4ODnB1dcWgQYMQEREBd3d3qNVqjBw5EqGhoWjevDkAoH379ggMDETfvn3xxRdfIDk5GRMmTMDw4cNhZ2dnseemVCoxePBgHE2sikQA0PJdFpGlaPn7R2WUIWv0ybUs3QoREZVBhpxpN7SHpVshIqIHWHQwb9GiRQCA1q1bG92+fPlyDBgwAADw1VdfQSaToXv37sjNzUV4eDgWLlwo1crlcmzevBnDhg1DaGgonJyc0L9/f3z66ael9TSIiIiIiIiIiIhKhUUH84ozNdTe3h5RUVGIiooqtKZatWrYunWrKVsjIiIiIiIiIiKyOlaxAEZZpNFoMHfuXGxf9zq0Wrml2yEiojLIkDXzV3WBRsOsISIi0zLkTJPRtSBT8LQlRETWwqIz88oyURSRlpYGwAUQGXxERGR697PGmeclJyIikzPkjL2bCuBbGiIiq8HBvFKQoK0EGXSWboOo3NJr5bBzTYdaFQCBS34SEZEZCAAqVbgLQVGTWUNERKYnAlmpOfCr58ucIQ7mEVHZJ1PoENB5N3oEzLZ0K0REVEYplToMe30LZN7nLN0KERGVQXqtiGOLLuAL/XRLt0JWgOfMIyIiIiIiIiIishEczCMiIiIiIiIiIrIRPMy2FCTmVYSg11u6DaJyS9TKcG97Ayy0W4jBgwdDqVRauiUiIipjNBo5lq7vAEHBrCEiItOTKQQEDQ7AwoXMGeLMPLMRBAEeHh4Q1NmWboWIAIjpjrh58yZEkWt+UtlhyJpKFe5ykUEiCxMB3LrjxqyhMsWQM1mpOeCy6UQWJgBOnvbMGQLAmXlmo1Qq8e6772LW6XBLt0JERGWUIWv0ybUs3QoREZVBhpxpJ+th6VaIiOgBHMwjIrIi6focQF/ySdPpPLSfiIgKYYqsYc4QERFZDg+zJSIiIiIiIiIishGcmWcmGo0GS5YsQdq9xrj7fCKg4DHtRBajFVDJ0j0QmYEha0RtJ7z96jYolTpLt0RERGWIIWeCh9XA30suQq/lexoiImvAwTwzEUURN2/ehAJ2lm6FiIjKKEPWAG48LzkREZmcIWecPO3BlZaIiKwHD7MlonJB56CBq6srBIF/iRIRkekJAFydM5k1RERkHiKQczePOUMAODOPiMoDhYg7YQn4tNFnlu6EiIjKKKVSh1F9NkLmfc7SrRARURmk14o4Mu8cYvSfW7oVsgKcmUdERERERERERGQjODOvFNzIcYVebukuiMgWXNYKcNaWfNp8pgn2QUREZZMpsoY5Q0REZDmcmUdEZZ6gA2odqoAlS5ZAo9FYuh0iIiqDNFo5lv7SgVlDRERmIVMICHq7OnOGAHAwz2wEQYCrqyvy7HVcYZDIwgQAjulK3LhxA6LI30gqOwxZ4+qcyUUGiSxMFIGkmxWZNVSmGHIm524e+KaGyMIEwKWKI3OGAPAwW7NRKpUYM2YMXv1ruKVbISKiMsqQNfrkWpZuhYiIyiBDzrST9bB0K0RE9AAO5plZcpaLpVsgKvfkOkt3YP327t2LL7/8EnFxcUhKSsL69evRtWvXQuuTkpLw/vvv48iRI7hw4QJGjRqFuXPnPlI3d+5cLFq0CImJiahUqRJee+01TJ8+Hfb29uZ7MkREZHWYM0RERKbDw2yJiAhZWVkICgpCVFRUsepzc3Ph4eGBCRMmICgoqMCa1atXY9y4cYiMjMTp06exbNkyrF27Fh9//LEpWyciIhvAnCEiIjIdzswzE41Gg+joaISm2eFgvVyuZktEVq1jx47o2LFjsev9/Pwwb948AMB3331XYM3+/fvRsmVL9O7dW9qmV69eOHjwYMkbJgD3s0bUdED/V2KgVHAaKhFZJ+aMbTLkTNDb1XE8OgF6Lc/TRURkDTgzz0xEUcSNGzfgmiXjScmJyGLS09ONLrm5uaX22C1atEBcXBwOHToEALh06RK2bt2Kl156qdR6KOsMWZN0syJ4HmQisgTmTNlmyBmXKo7gmxoiIuvBmXlEVC7kKUS4qZws3cZjJWgqwVFT8qm82RodgOvw9fU1uj0yMhKTJ08u8f6Lo3fv3rh16xaee+45iKIIrVaLd955h4c/EVGZ5WifA8jcLd3GY5kia5gzRESlT5OlhauH2tJtkBXgYF4puJvtAB3nQBJZ1C+BwOlXx1q6jVJ39epVqNX3A9/Ozq7UHnv37t2YNm0aFi5ciJCQEFy4cAGjR4/G1KlTMXHixFLrg4ioNKiUOrzf/2fIvM9ZupVSxZwhIiodeo2Ig7POIEa/ztKtkBXgYB4RURmmVquN3mSVpokTJ6Jv3754++23AQD169dHVlYWhgwZgk8++QQyGT/lICKydcwZIiKi0seEIyIis8jOzn7kjZRcnn9Yl8gTvBERUQkxZ4iIqLziYB4RlXlyPfDiRSA6OhoajcbS7VilzMxMxMfHIz4+HgCQkJCA+Ph4JCYmAgDGjx+Pfv36GW1jqM/MzMTNmzcRHx+PU6dOSfd37twZixYtwpo1a5CQkICYmBhMnDgRnTt3lt5sERGVFRqtHCt/DWPWFII5Q0RUMjKFgPr9/ZkzBICH2ZqVo6MjbudkIydTBa2Myz8RWYpCL8IzKw9Xsq7wk/pCHDlyBG3atJGuR0REAAD69++P6OhoJCUlSW+4DIKDg6X/x8XFYfXq1ahWrRouX74MAJgwYQIEQcCECRNw/fp1eHh4oHPnzvj888/N/4TKEUdHR0B/29JtEJV7oghcSfICwKwpCHPGdjk6OiLtZrql2yAiAXD1c8KVK8wZ4mCe2ahUKowdOxZ+38+wdCtERI/VunXrIv8oiI6OfuS2x/0RoVAoEBkZicjIyJK2R4UwZI0+uZalWyEiKhJzxjYZcqadrIelWyEiogfwMFsiIiIiIiIiIiIbwZl5RERW5KqmIuzzSv7SnKPRmqAbIiIqi0yRNcwZIiIiy+HMPDPRaDSIjo5Ghxt5kOt5PDsREZmeIWtW/hoGjZYneyciItMy5Ez9/v6QKXgOcCIia2HRmXl79+7Fl19+ibi4OCQlJWH9+vXo2rWrdL8oioiMjMSSJUtw9+5dtGzZEosWLULNmjWlmtu3b2PkyJHYtGkTZDIZunfvjnnz5sHZ2dkCz+g+URRx5coVVAYgZCkAgeFHZDGiCCDP0l0QmZwhawAv8DzIRERkaoaccfVzAvh2hojIalh0Zl5WVhaCgoIQFRVV4P1ffPEF5s+fj8WLF+PgwYNwcnJCeHg4cnJypJo+ffrg5MmTiImJwebNm7F3714MGTKktJ4CEdkIDQClUmnpNoiIqAxTKrTMGiIiMhtdnp45QwAsPDOvY8eO6NixY4H3iaKIuXPnYsKECejSpQsAYOXKlfDy8sKGDRvwxhtv4PTp09i2bRsOHz6MJk2aAAC+/vprvPTSS5g1axZ8fHxK7bkQkfXSCgJ+8HTC5WEfWLoVIiIqo1RKHcYNWguZ9zlLt0JERGWQXiMidvopxOjXWboVsgJWe868hIQEJCcnIywsTLrN1dUVISEhiI2NBQDExsbCzc1NGsgDgLCwMMhkMhw8eLDQfefm5iI9Pd3oQkREZCrMGSIiMifmDBFR+Wa1q9kmJycDALy8vIxu9/Lyku5LTk6Gp6en0f0KhQLu7u5STUGmT5+OKVOmmLjjwikyZTxnHhFROVLaOUNEROULc4aIqHyz2sE8cxo/fjwiIiKk6+np6fD19bVgR0RkTjJRRKvce1i9ejVef/11KBTW+9J39V5FqOQlPw9G3j2NCbqhp8WcISp/tFoZ1sW8AMGufGQNc8aymDNE5Y8gF1D39ao28Z6GzM9qv/ve3t4AgJSUFFSuXFm6PSUlBQ0bNpRqUlNTjbbTarW4ffu2tH1B7OzsYGdnZ/qmH6JUKnFPwz90iCxNBuAZvQ7nz5+HXq+3dDtUDpRWzgD/Lewi3iuVxyKiwulFARcSqwBg1pD5lXbO5GTllspjEVHhBBngXsuF72kIgBWfM8/f3x/e3t7YsWOHdFt6ejoOHjyI0NBQAEBoaCju3r2LuLg4qWbnzp3Q6/UICQkp9Z4fpFKp8PHHH+N/ji7Q8hBbIiIyA0PWjBu0FiqlztLtEBFRGWPImdjpp6DXiJZuh4iI/mPRmXmZmZm4cOGCdD0hIQHx8fFwd3dH1apVMWbMGHz22WeoWbMm/P39MXHiRPj4+KBr164AgLp166JDhw4YPHgwFi9eDI1GgxEjRuCNN97gSrZERERERERERFTmWHQw78iRI2jTpo103XDeh/79+yM6OhoffvghsrKyMGTIENy9exfPPfcctm3bBnt7e2mbVatWYcSIEWjbti1kMhm6d++O+fPnl/pzKYwik7PyiCxNDljxPGQiIiIiIiKi4rPoYF7r1q0hioVP1xYEAZ9++ik+/fTTQmvc3d2xevVqc7RXIlqtFj/++CNeELKxT3SAHhzUIyIi0zJkjZjbGj3a7YVCwfOnEBGR6RhyJrBXNZz+MRGijofaEhFZA6tdAMPW6fV6nD9/HlUEQGDmERGRGRiyBqgCvcgPjYiIyLQMOeNeywWCDBB5elYiIqvAA8+IiIiIiIiIiIhsBGfmEVGZp4OA/+nVODPlPUu38ljXc1yhlKtKvB9NTp4JuiEiouJSKXWYOHQVZN7nLN3KY5kia5gzRESlS68RsW/KCcTo11m6FbICHMwrBcpMToEkIiIiIiIiIqKS4xgTERERERERERGRjeBgHhGVeTKIaO6QjXXr1kGr1Vq6HSIiKoO0Whl+inmOWUNERGYhyAXUec2XOUMAOJhHROWAAOAZpRanTp2CXq+3dDtERFQG6UUBpy9VY9YQEZFZCDKgUj1X5gwB4DnzzEalUiEyMhKNhn4FGThqSmRJcgGA2tJdEJmeIWv0ybUs3QoREZVBhpxpJ+th6VaIiOgBHMwrRXZKOdwcVRAs3QhROSICyLiXa+k2iIiIiIiIiEyCg3mlQADwUrAvWtbxgVIh52AeUSkSAWi1Oty6noALFy5Yuh0iIiIiIiKiEuFgnplotVqsX78eTSpkw9uvNtoGVUMF94qQKVSWbo2o3NFr81DB0TZe7lKynKGAXYn3o83ibMTywJA1Ys5z6NpmPxQKnj+FiB7PFFnDnCkfDDlT5zVfnF1/DaJOtHRLREQEDuaZjV6vx6lTp1DNRYEmdXxQwb0iFPZOlm6LqFySKRRwl7ujWrVq0Ol0lm6HyGQMWQNUwyutYy3dDhERlTGGnKlUzxXnNl6DyD+jiIisAgfzzMzOzg5KmQxymRICP8kisggBgFKphFwu5zLuREREREREZNM4mFcKBIFnySOyJBFAVp4Mrq6uUCj4skdERKanVOjw0VtrIPP6G0ql0tLtEBFRGaPXiNg/7SQ2ZfzAnCEO5hFR+SACkAkCB9eJiMgsBAFQKXWQqXh+ZCIiMg+9RoSKOUMAZJZugIisx/VrVxEYUBmnT52wdCtEREREREREVAAO5pUCQS9C0MGmLh9/MBojhwx45PbD+/cjMKAyMu6kFXtfYS80xcpl31r8OZWHy4Z1axEYUBmBAZVRr4YP2rRohE/GjsHt1FvF2r6ypw/2/vU3agXUKfZjRn01C906hVn8uRd1kelE2MtFZGdn85x5RERkFlqdDBt3NceGDRuYNUREZHKCXEDNLlWYMwSAh9mSDcnLy+OU4mJwdnbB1t/3QdTrcebMSXwy/j2kpiZj6XdrHrutXC6Hh4dnKXRZ+pSK/J8hvV5v6VaKlJZtDznsS7wfXTYPJyYiKk16vYB/zgUA+BsvvfSSpdspkimyhjlDRFS6BBng1bAC/v7b+nOGzI8z88xEqVRi/PjxOHTSDmV9Ddu4IwfxZq8uaFjfH21eaIzPp05AdnY2AKDfm91w4/o1zJgWibq1KqNurcrF2g4A2rZpioVRc/DR2JFoElwTkRPHAgD++H0zXn6pFRrUq4a2bZpi+bLFRv2kpqZg6OA30bC+P8JebIbNm35B2zZNsSL6W6kmPT0NEz5+Hy1C6qFJcE0M6Pcazpw+Kd2/YP4svPpKGDZuWIe2bZqiaaNaiBjzDrIyM6UavV6PbxfPR9iLzdCwvj+6dm6L37dtNurl0KH9eL17RzSoVw3PtwzC7C8/N/oU5eG+AODVV8KwYP4sAIAoilgwfxZebNUYDepVwwvPNcTnUycU+f0QBAEeHp7w9PLGC63a4s2+gxC7/0/k5NyDXq9H1II5aP18IzSoVw2vvhKGP/fulLa9fu0q6ta6f5jtoYP7UbdWZcTu/xOvdQtHcAN/9OrZGQmXLgAA1v+yFlELZuPMmZPS93f9L2ufqm8ienKGrPnorTVQKnSWboeIiMoYQ87sn3YSek1Zf1dDRGQ7OJhnJoIgQKVSQdSb7lPL7OxMpKRcR3Z25uOLS0li4mUMebs32oV3woZNOzBn7mLExR3EZ59+DACYv2AZvL19MHL0WOz962/s/evvYm1nsHzZYtSpUw+/bIzBsOHv4eSJv/He6KF4qVMXbNy8EyNGfoD582Zi/S9rpW3GfTgKN1NTsOKHnzHv66X4ce0PuP3vLaP9jhk1BLdv38K3S1fhp/W/IzCwPgb274G7d+/cf25XL2PH9m1Y9M33WPTNShw+HIsl334t3f/tN/OxccM6TJ4yE5u27Eb/gUPw4QcjcOjQfgBASnIS3hn8Jp6t3xAbft2OyMkz8PNPq7F44dxif33/+H0LVkR/i8mffoFtMX9hQdRy1KxVp9jbA4CdvT30ej10Wh1WrliC6O8WY+xHk7Bx0w60fL41hg8bgMuXLxW5j7lfzcCH4yKx7pdtkMvl+OTjCABAx5dewcC33kGNmrWl72/Hl14xSd9E9HiGrFEpdeDaLkREZGqGnOFAHhGRdeFhtjbi0sUzOHxwL/LX5BTQNOQFVA8w7+DI7t3b0bhhgNFtOp3xIYrfLv4aL3fuhv4DhgAA/Pyq45MJn6Hfm90QOWUG3NwqQCaXwcnJ2ejwzcdtZ2eXf+hHSPOWGDjoHWm7se+/i+ahz+Hd4fmDSf7+Abhw4RyWLV2IV7v1xKWL5xG7fy/W/fwbnq3fEAAw9fPZ6NCuhbSPuCMHcfyfY/jrwHGoVHYAgA/HRWLH9m34Y9tmvP5GXwCAqNdj+ox5cHJ2BgC80uU1xMbuwxgAeXm5+HbxfCyL/hHBwU0AAL5VqyHuyCH8uOYHNGvWAv9bHQ1vbx9MjJwGQRBQPaAmUlNTMHvWZ3h3RARkssePpSfduIZKHp4IbfEClEolfHyeQYOg4MduZ3D58iWsXfM9nn02CE7Ozli+bDHeHjwcnV7uCgD4YOwEHDrwF1ZGL8GkydML3c+Y98ahWbP8r+HgISPxzpA3kZubA3t7Bzg6OkEhVxh9f0vaNxEREREREREVjDPzzESr1WLDhg2o4ZULQQ8IehEy3dNdcjIyHhjIAwARRw7tRU5GxlPv83EXQQRCmrXAhl9ijC6fTc0//NNQd/bMSaz/5Uc0bhggXQYP6gW9Xo8bVxKlfQl6GO2/uNvVrxdktN2lC+fROLip0W2NGzZB4pUEiHlaXL54AQqFAs/WqS/d7/+MH1xd3aQezp06iezsLIQ2CzR6/GvXEnH1yuX/HltEFR9fuDg4SfvxquiJ2//egkwn4uqlBNy7dw9vD+xptI9fN67D1cTLUq/BDRtD/sBzb9KwCbKzspB6/XqhXxsg//FlOhEd27+M3Jx7aN82BJM+fh87tm2FPldT+PdNLyIjIx2NGwYguIE/Xgp/DpXcK2HWFwuQnZaO1NRkNG5o/PVrFNwUly6el7YHAJleNLpet2bdB74OHgCAO6k3pa8VYNzHk/Zt7oug46fJj7N371507twZPj4+EAQBGzZsKLI+KSkJvXv3Rq1atSCTyTBmzJhHapYsWYLnn38eFSpUQIUKFRAWFoZDhw6Z5wmUU4as2birObQ6RjoRWS/mjG0y5EzNLlUgyDkFnIjIWnBmnpno9Xr8/fffqOjpVOJ9ZWSkAw+deU8URWRkpsPR0bnE+y+Mg6MjqlXzN7otOSXJ6Hp2dhbe6Pkm+r456JHtK1euUui+i7udg4Pjk7b9WFnZWfDw8ML3K3565D4XtVr6v0L50K+HIED8b/GE7OwsAMA3i76Hl5e3UdmTLNIhyGSAaPy91Wrun1OvcuUq2Lb1T+yP/RP79+/FlE/HY9l3C/H9yl+gVCoL3KeTkzPW//w7ZDIZPDw8YW/vAADIzMwodl8PUyjufy2E/47l04uFD5A9Td9kWVlZWQgKCsJbb72Fbt26PbY+NzcXHh4emDBhAr766qsCa3bv3o1evXqhRYsWsLe3x8yZM9G+fXucPHkSVaoU/vpAxWfIGiAAHZ87DMgt3RERUcGYM7bJkDNeDSvg4tYbEHl6ViIiq8DBPBvg4qIGIODBAT1BEODirC50m9ISGFgfFy6ce2TQ70FKpQp6vXHyF2e7glQPqImjRw8b3Xb06GH4VasOuVwOf/8AaLVanDp9As/WawAAuHIlAWlpd6X6eoH1cetWKuQKBZ6p4vtEj28QUKMWVCo73Ei6jmbNQguuCaiJ3//YAlEUpQGwuKOH4eTkDG9vHwCAu3tFpN5MkbbJzMzAteuJRvuxt3fAi23a48U27dG79wB0fOkFnDt3GvX+e34Pk8lkBX5dnZ1d4OnpjaPHDhv1fPTYYTT475Dkp6FUqqDXPbpC7JP2TZbVsWNHdOzYsdj1fn5+mDdvHgDgu+++K7Bm1apVRteXLl2Kn3/+GTt27EC/fv2evlkiIrI5zBkiIiLT4WCeDXB0dEazps/j8JE/pYGhpk2eN+usvOIa/PZw9HzjZXw69WP0eK03HBwcceHiOezfvxeTJk4DAFSp8gwOHzmATi91gVKlgnuFisXariBvDRiK115/CVELv8JLHV9B/N9xWLV6OSIn5Z/vLaB6TbQIfR6TJo3F5MgZUCgUmPHFp7C3t5cG1Fq0eAENGzbG8BEDMfaDCfDzC0BqajL27NmBsLCOqP9s0GOft7OTM94a+A6mz4iEKOrRuFEzZGSk4+ixw3B2dsGrXV9H7179sWLlEkz97BP06TMQCQkX8fWCWRg4YIh0vrzmIS2xfv2PeLFNe7io1Zg//0vIZPen1vyyfi10Oh2CGjSCg4MDfv31F9jb28PH55mn+n4NemsYvl4wC1V9q6FO3Xr45Ze1OHPmJGZ9seCp9gfkf3+vXU/E6dMn4OVdGc5Ozti8ZYNJ+zaFrCxArVaXu5mB6enpRtft7OxgZ2dnkV6ys7Oh0Wjg7u5ukccnIjInpUKHiH4/QeZ5oFxlDXOGiKh06DUiDnx5Gj+lLCtXOUMF42BeKRBEEdCJgPjo7KXiCqhWC5U9qiAjMw0uzq5wdHQCCpgNZTKimD8R8OHHMFzX6QGdHnVq1MH3y3/C3PlfoPebrwKiCF/fanipwytS7ajh72PSlHEIa98CeXm5OHviWrG2k/p44Hq9Os9i7uxFmL9gNhYtmgsPD0+MGv4Bur3SQ6qbOW0uPpn0Afr07QaPSh6IGDMOF86fhZ1SBej0EAB8u3Al5s6bifEfv4c7t2+jUiUPNGkcgkpuFfP3oy/g+RsOK/3vtjEjPoC7WwV88+3XuHY1ES5qNQLrPot3Bo8EdHp4VfLCtwtX4ovZn+HHdavh5uqG17q9gWGDR0n7GDpoOK5dTcTQYf3g4uyC0SPH4tq1xPzH1+mhdnLBt8uiMGPmFOh1OtSqVQeLF0Sjgtqt4O+/3rjHh/XrPRCZ6WmY8cUU3P73XwQE1MTCr7+Dn6+f9D2V9vPg9Yfve+C28LYdEfPHVvQb0APp6WmY/tkcqF3UT9Z3adCLkClk0qCutcrJsoNMX/I3Qfp7+d8nX1/j2aeRkZGYPHlyiff/ND766CP4+PggLCzMIo9PRGROggA4OeRC5lTyU6yYmymyhjlDRFT6tNk6ONlAzpD5CaJYxImvyon09HS4uroiLS0N6gfOmVYSeXl5mD59OpycnNC0UUt4evhALuPYqSUkJ99Aq7BmiF66BqHNn7N0O2QhOr0WUGTD398f9vb2Jt23KV5DDPvw/SYSMoeS96e/l4OrQ6fg6tWrRj0VZ8aEIAhYv349unbtWqzHat26NRo2bIi5c+cWWjNjxgx88cUX2L17Nxo0KH+HWpsjZ4D7WQMAH721BiolT2ZEZGky73Mm36epXkNMmTXMGetSGjmzf9pJ6DXl/q0jkcXF6NeZZb+mfE/TGl2gEEo2e1ArarAbG03+ulZWcHSJypzYg38hOzsLtWrWwc2bqfhyzueoUsUXTRqHWLo1siCVPZCWcQ9arfbxxWWIWq22ePjNmjULM2bMwPbt28vlGywiKh+0Ohli9jcGHLcgPDzcaPGosow5Q0RUOgS5AP9wb2zZUr5yhgoms3QDRKam1Wrw1byZeLnrixgx+m24V3DH98vX8bwC5ZgAQGknIDc3F3q9hQ7zLae++OILTJ06Fdu2bUOTJk0s3Q4Rkdno9QKOnKqFI0eOMGtKEXOGiMoLQQb4NK3InCEAnJlnNkqlEh988AGGvz4fTYIt3U358nzL1ni+ZWtLt0FkUzIzM3HhwgXpekJCAuLj4+Hu7o6qVati/PjxuH79OlauXCnVxMfHS9vevHkT8fHxUKlUCAwMBADMnDkTkyZNwurVq+Hn54fk5GQAgLOzM5ydLb+AT1lgyBp9anMoFTzEloisF3PGNhly5jWvQTzElojIinAwz0wEQYCTkxN0/2ZD0OsBvQ4QrfvE+0RUfh05cgRt2rSRrkdERAAA+vfvj+joaCQlJSExMdFom+Dg+59UxMXFYfXq1ahWrRouX74MAFi0aBHy8vLw2muvGW1nyZOjlzWGrNE75Fq6FSKiIjFnbJMhZ7TZ/MCIiMiacDCPiIjQunVrFLUeUnR09CO3PW79JMObLSIiIuYMERGR6fCceWai1WqxZcsWVAl2sHQrRERURhmy5rc/m0KrY6QTEZFpGXKm+kuVIch5lBERkbXgzDwz0ev1OHLkCCoFOOWffZ+IqDgyFYDOBC/N9/jyXh4YsgaohbbNjwJyS3dERDbBFFnDnCkXDDnj07QiLsckQ+TRtkREVoEpXBp0ekCrBwSmH5El5J+ukqMcREREREREZPvKzDE5UVFR8PPzg729PUJCQnDo0CFLt0RE1kIEsm9roFaroVQqLd0NERGVQUqFDiN7b8Do0aOZNUREZHJ6jYjDc88yZwhAGRnMW7t2LSIiIhAZGYmjR48iKCgI4eHhSE1NtXRr+WQ8zpbI4MWXn0f06u9K/4FFEXq9HllZWaX/2ESlICOL52glsiRBAGSCHnfu3EFGRoal2yEyOZUzD+oisjRRLzJnCEAZOcx2zpw5GDx4MAYOHAgAWLx4MbZs2YLvvvsO48aNs0hP8fHx0v9VznIoHQTocx8qeniBrseN+T1Yb+bacZFjkZ6RjoVzvjEqPXj4APoN7Y3Du+OhVquLtd8XX34e/XoPxIA+bxWvh8f1zNpCa3/59SeMn/yhdJOjgyP8q1XHO4PeRfsXO5RKD9ZYq3SQQe4gx/UbN7FixQq0adMGjRo1KmKnRLbhwaxZuPYVdHjuMIJqXTKqkQkiFAq9dD1PU/gh54KQP7voaWo1Gvkjv45SLQCl8ilrtXIUtaCl6ilrtVoZ9GLhLy5PUqtU6CD8d7dWJ4Neb/panU4GnYlqFXI9ZDLxKWoF6PSFfw78tLV6vVDkAi5ymR5yuTlqRcjl+ieuFcX8n7WH/X2uOrbtawpgJQRBwMsvv8ysIZv3YM40HlELF39LQurfd4xqRD0g6u6/+MqURfzhJgJ67VPWKoTC/yY0Vy3yZ0M9Ta0gFyAUMXXG6mplAoQizkrzRLVaUfob/clqUeRCK09bC+G/710hRJ0IUW+O2vzBtyeuRcG/G55BFRDQsTJWrmTOUBkYzMvLy0NcXBzGjx8v3SaTyRAWFobY2NgCt8nNzUVu7v2RtfT0dJP2lJ6ejt9++83oNpWzEgo34y+3NlePnDsa6bqTpwqCUPAvuC5Pj3u3H6j1UEEoZMafTqPHvX/v1zpWUkFWyAudXisi+1be/dqKKsgUAhT2MijyZHD2srtf+0BIA4CDuxJyZcHpIOpFZKXe36/SUW60L6NaUURWyv1a+wpKKOwe3W9eXh5UKhUyk+9/7+zdFFDYF54OmSm50ou4nasCSofCa7NSc6UXZju1AkrHImpv5kl/tKhcFFA5FV6bfStP+oNB5Swv8lPN7H/zpKBUOslh51J47b3bedDl/VfrKIedWgE7tQIuLi7Yu3cvACAzMxNr167FmHEjsfnH31HdrzoUDjLYuxY+LTvnrgbanPwvhMJeBnu3ImrTNNDey6+V28ngUKHw2tx0LTTZ+W+OZXKh0J8HAMjN0EKT9V+tUoBjRZV0n06ngyAIkMnyf0byMrXIy/yvViHAsZLq0R0ifzU2IP/nbfPmzahRo8bjB6SJnpK5c8awT+OsEbBtXzNs29fMqK5G1evo1XG3dH3Oyteg0Rb82lKtcgr6vbJduv716q7IzrEvsLayx794u9s26fqiH19GWqZzgbWVKtzFsNe3SNeXru+AW3fcCqx1dc7EqD4bpesrfm2HpJsVC6x1tM/B+/1/lq7/b2sbXEnyKrBWqdBi3KC10vV1MS/gQmKVAmsBYOLQVdL/N+xqgdOXqhVa+9Fba6TBvy17m+GfcwGF1kb0+wlODvk/GzH7G+PIqVqF1o7svQFuLvmziXcdCkLsP4GF1g7tsRme7mkAgH3H6mFvXINCawe9+ht8PG8DAA4er40dBwt/I9C3cwz8fPKPdDh6uia2/dW00No3OuxCzWo3AAAnLvjj192hhdZ2D/sTgQGJAIAzCb74efvzhda+0joWQbXzB6kvXq2MNdvaFFrboeVhNH32HAAgMdkD329qV2ht25CjaNHwNAAg+VYFLFvfsdDaFxr/g1ZNjgMAbt5xxTfrXi60FmDWkPlZImcEmYAanXxQo5OPUd3tcxk49b8r0vWQD+pCrir4PULa5SwcX5EgXW86ujaUTgVnUsb1bPy99P4HVI2G14S9W8F/52Wl5uDYogvS9aDBAXDyLDi/cu7m4ci8c9L1+gP84VLFscBaTZYWB2edka7X6+MHVz+nAmt1eXrETj8lXa/7elW413IpsBYA9k05If2/9qvPoFI910Jr9087Kb1HqPGyD7waVii09sCXp6H9729u/3Bv+DQtOEMB4PDcs8hNy3/fWK2tJ55p4VFo7dGF55F9M/9nzvd5D1Rt7VlobfySi8i8cQ8A4NO8IvzbeRdaezw6AWlX8rPOu7E7Al7yKbT25OrLuHM+EwDgUd8Ntbo+U2jt6XWJ+PdU/u9Fxbpq1O1RtdDacxuuIfXvuwCACjWcUa+3X6G1F7feQNLh/Ax1reqE+gP8C61NiEnG9f23AADOlR3QcHDhfx8k7k5F4p78vHX0sEOjd2sWWgswZ6gMHGZ769Yt6HQ6eHkZ//Hu5eWF5OTkAreZPn06XF1dpYuvr69Je/r3338fW6PRaKByUMDv2SrSRafTQaPRSIMOD9Yq7ORGtXpRX2itXCkzqoVQ+DQFlb0StRr5SxeVfeGDMUqVAr61KgMAagRVg71j/mDMoUOH8OqrryIgIABNmjTBxIkTkZuXi1qN/DEkYiCuJ13Hp1OnoEqVKqhS5f4bJ8N2NWrUQNsuL2BB9FeoUtsTTur8Q8VCQkLw1VdfYdSoUahduzY+/DB/xtnxhKN4te/LqB9aB8+1bonFixcb9ZmSkoK+ffsiICAA4d1exJEzsWjfrQ1Wrf1eqklLS8MHH3yA+vXro3bt2ujRowcy9Hekr8OipVFo164dfvrpJ4SEhKBOnToYNmwYMjPzw8O/3jOo0bAafv59DVqFPYeAgACEhYVh8+bNRr3Exsai16AeqB9aB606tcD8xXONvmchISFYsmSJdL1qbR+8/tarWP3rCnhUcYcoipg9ezaaNm0Kf39/NGrUCBMnTgQAPFOzstSvp+/9kBYEAZ6envD09ET16tXx0UcfQSaTIUN3G7Ua+cO7mgfu3r2LUaNGITAwEAEBAXjzzTdx6VL+H0uV/T2x+tcVeP2tV1HZ/35IL1myBCEhIdL1MWPGYPSHI/Drzp/RqlMLNHuhET7++GNoNPcHkm/duoX+/fsjICAAbTq8gMOn90OhUsDN437gfPPNN2jbti1q1KiBJk2aYPz48XBwVUnPbffB7ahbty7++OMPtG7dGv7+/jh06BCqVauG1NRUVKxcQaqdv3QOXn311cJ+hCWiKOL27duPrSN6WubOGaB4WQMAgl1ryLzPSRcIRRyOq2pmXCtzL3y/yvrGtfLCB8YERU2jWkFRxB+o8irGtcr6hdfK3I17UDUrvFZwMN6vXevCawHjWvvCB3kAQOb19/1ah25F13oeuN+vY++iaz123a91GlR0baUt93twHllkrVDx5/u1Lh8WWStz/+F+rXpS0fut8O39WtcZRde6zbtf6zav6FrXGfdrK3xbdK160v3vnfsPRde6fHh/vxV/LrrWeeT9/VbaUmStAbOGzMmaciakUyPE6NdJF3unwj+wbdAq0KjW1aPwQYjaTWsY1XpVK3ygya+er1GtX73Cvx5e1TyMams3rVForauH2qi2QavCP1Sxd7Izqg3pVPSMqQdrX+hR+IcfALAp4weptn3/1kXW/pSyTKp9ZVh4kbU/JCyUanu8/0qRtUuOz5Fq+0b2KLJ2wcHpUu3gmW8WWTtr12SpdsTXRWfdZ5vGS7Vjlw8vsnbi2gipduLaiCJrxy4fLtV+tml8kbUjvh4k1c7aNbnI2sEz35RqFxycXmRt38geUu2S43OKrDVgzpRvgigWdUCK9btx4waqVKmC/fv3IzT0/ovghx9+iD179uDgwYOPbFPQJ1m+vr5IS0szyah2eno65s6dC1EU4eTkhJYtW6JKlSrw8fGRZhNNnTq10O1r1KiBXr16SddnzJhhNEDyoGrVqqFfv37S9dmzZyM7O/uROsMAUEEMPQH5y88DwMCBA3H37l2sX7/eqHbv3r1o06YN7ty5A7VajYsXLyI4OBhTp07FSy+9hJs3b2LUqFFo0KABoqOjcfv2bQQFBWHw4MF4++23AQDe3t6PbPfvv/9ixIgRCAoKwnfffQdRFFG9enXcuXMHEydORJcuXQAAd+/eRfPmzTF58mT07NkTf/31F4YPH44FCxZgwIABAID27dvj33//xcKFC6FSqfD+++/j0KFD+PzzzzF69GipxsHBARMnToSrqyu+/fZbrFixAufOnYO7uzsiIyMxZ84ctGvXDpMnT8adO3fwxhtvYODAgfjss88gCAKmTZuGH374AV999RVq1KiBvXv34t1338Vvv/2GVq1a4fr166hTpw769++PUaNG4cyZMxg8eDDeffddREZGAgCqV6+O0aNHS30JgoDg4GB07doVkZGRWLduHQYPHozVq1ejXr16SE5Oxt9//43BgwdDEARpJqcoihBFEdHR0YiIiJBe1HU6HVauXIlhw4bh9OnTCAgIgCiK6NKlCy5cuIBFixZBrVZj3LhxuHTpEk6cOAGVSoUpU6Zgw4YNOHbsGAwvEfPmzcO8efOkQb+BAwdiw4YN6N27N0aPHo3z58/jjTfekA57B4BOnTohKSlJ+l6MHj0ax44dM/pezJs3Dw0aNIC/vz8uXbqEESNGoE2bNli0aBEAYPny5Rg6dCiaNm2KmTNnomLFivD19UXjxo0xaNAgjB07FoIgQKPRwMfHBzNmzJAOuTf8TKempkKr1eL69ev466+/kJ2djTFjxpjsU6z09HS4urqW6DXEsA/f2VMhcyj4k+Qnob+Xg6vvTzTZ6xo9GXPnjGGfhqx50IgRI+Dicn8mgEwmg0Jxf9ZDXl4eCiMIgtEJlZ+kVqPRPNKLuWsBQKVSPVWtVquVMq+ktUqlUno9NletTqeDTqczSa1CoZCy3xpq9Xr9Ix9OPkgul0Mul1tNrSiKj/xdlpGRgQULFhjdJgiCybLGFDnz4H5MkTXMGctizpROLcCceZpa5kzJai2RM4Bp39O0RhcohJIt0qEVNdiNjcyZQtj8YbaVKlWCXC5HSkqK0e0pKSnw9i54Oq+dnR3s7Ar/xKik1Go1Xn75ZaNZWs7OzkYhV5QHDyEsjuLUFnd/hjpBELBly5ZHfmkefMGUyWSYOXMm+vTpg/feew8AULt2bcyfPx+tWrXC4sWL4e7uDrlcDrVaDR+f+1OmH94OgLTdokWLYG+f/wfmiy++iA8++ECq6dOnD9q2bSsNTtaqVQunT5/G7Nmz8dZbb+HMmTPYsWMHDh8+jCZNmgAAli5dipo1a0pf13379uHw4cNITU2Vfg5mz56NjRs34qeffsKQIUMgCAL0ej1WrFgh/bHSt29f7Ny5EzKZDLm5uZg2bRq2b98uDSLXqFED+/fvx5IlS9CmTRssXrwYvr6+iIqKgiAIqFOnDm7cuIGPPvoIkZGRRl/rgr4/giDg2rVr8Pb2Rvv27aFUKuHn54fmzZsXWGvYz4Mvdvfu3YNSqcS3336LgID8ad0XLlzApk2b8Ndff6FFixYAgNWrV8PX1xe//vorevTo8ch+Df9/+GekQoUKWLBgAeRyOerUqYNOnTph165dGDp0KM6dO4dt27bh0KFDaNo0/7CsZcuWoW7dukbP+cGfgerVq+Ozzz7DO++8Iw3mGQbqFi5ciKCgIKl20KBBiI6OlmZsbtq0CTk5OXjjjTeMvp4ymQyurq7Sp8uG80tYayAosmSQFXHepuLS59j8xGubZu6cAYyzRhRF6We7YsXCD6cBjN88PM6T1D7JqmrWUFvcTLaW2gf/yC9rtTKZrNg/a9ZQKwjCI7UVK1ZE586dH/l9LMtZw5yxLOaM9ddaQ3YwZ/JZQ3aUt5wh87P5wTyVSoXGjRtjx44d6Nq1K4D8Ue8dO3ZgxIgRFuurUaNGqFGjBm7evImcnBw4Ohqfh+HBc/w97OGBnQcHsx728Dn2DLOdTOHB2VEGBw8exJtv3p8q/ffff+Off/7BqlX3zy0k/rdqaEJCAurWrVvgvou7nWFAzuD06dPSLD2Dli1bYu7cudDpdDh79iwUCoXRiUBr1KiBChXun1fi77//RmZm5iN/iNy7dw8XL16Urvv5+Rl96li5cmVpheQLFy4gOzsb7doZn4snLy8PwcHBUq+hoaFG36OWLVsiMzMT165dQ9WqhZ+3waBHjx6YO3cuqlevjg4dOuCll15C586diwxmFxcXHD16FACQnZ2N7du345133pEC4PTp01AoFEaHzFasWBG1a9fG6dOnH9vTg+rVq2cUopUrV8bx48el569QKNC4cWPp/jp16sDNzc1oH9u3b8f06dNx5swZpKenQ6vVIicnB9nZ2dLvjUqlQoMGxud/GjBgACZMmIADBw6gefPmiI6Oxuuvvw4np0fPY2K4LS0tDf3790elSpWe6HkSWStD1ty+fRvu7u78g47Igvj7SGURf66JrAd/H+lBNj+YBwARERHo378/mjRpgmbNmmHu3LnIysoyOtTOEtRqNVQqFRISEh65z1yfWD1J7eM4OTmhRg3jc0hcu3bN6HpmZiaGDh2KUaNGPbJ9UYNVxd2uoIGZksrMzETlypWxe/fuR+57cKDp4U/eDLP1DPsAgC1bthidBxDAE31KKpPJHpmq/+CUal9fX5w9exbbt29HTEwM3n33XXz55ZfYs2dPoZ8MymQyo+9bgwYN8Mcff2DmzJno3LmzSfoyKOprVByXL1/Gyy+/jGHDhuHzzz+Hu7s79u3bh0GDBiEvL08azHNwcHhk4NrT0xOdO3fG8uXL4e/vj99++63A76mBXC6HQqGAs3PBJ+gnslVqtZp/zBFZCf4+UlnEn2si68HfRzIoE4N5PXv2xM2bNzFp0iQkJyejYcOG2LZt2yOLYpDpNWrUCKdOnXpk0O9BKpXqkfMZFGe7gtStWxd//fWX0W1//fUXatWqBblcjtq1a0Or1eLYsWPSjLALFy7gzp07Ro+dnJwMhUIBPz+/J3p8g8DAQNjZ2SExMRGtWrUqtNeff/5ZmgZt6NXFxQXPPJO/8pKHhweSkpKkbdLT0x8Z/HVwcEDnzp3RuXNnDB8+HHXq1MHx48efaBlyuVyOe/fuSX1ptVocPHhQOsz233//xdmzZxEYGCj1lZycbNR7fHx8sR8PyJ+Fp9VqERcXJx1me/bsWdy9e1eqiYuLg16vx+zZs6UZqT/++GOxH+Ptt99Gr1698MwzzyAgIAAtW7Z8oh6JiIiIiIiIbE2ZOdnFiBEjcOXKFeTm5uLgwYNGhxCS+Xz00UfYv38/RowYgfj4eJw/fx4bN240OsTZz88Pe/fuxfXr13Hr1q1ib1eQ999/Hzt27MDUqVNx7tw5rFixAgsWLJAORa5Tpw7CwsIwZMgQHDp0CMeOHcOQIUOMZnaFhYUhNDQUXbt2xR9//IHLly9j//79+OSTT3DkyJFiPW8XFxd88MEHeO+997BixQpcvHgRR48exddff40VK1YAAN59911cvXoVI0eOxJkzZ7Bx40ZERkYiIiJCGrh68cUX8f333+PPP//E8ePH0b9/f6PDVqOjo7Fs2TKcOHECly5dwg8//AAHBwdUq1at0N5EUURycjKSk5ORkJCAb7/9Fr///rt0eHLNmjXRpUsXDB48GPv27cPff/+NN998E1WqVJFqWrdujZs3b+KLL77AxYsXERUVhd9++61YXxuD2rVro0OHDhg6dCgOHjyIuLg4vP3223BwuL+SZo0aNaDRaPD111/j0qVL+P777x9Znbgo4eHhUKvV+Oyzzyw+E5eIiIiIiIioNJSZwTyyjAYNGmDPnj04d+4cnn/+eQQHB2PSpElGi118+umnuHz5MgICAuDh4VHs7QrSqFEj/Pjjj1izZg2effZZTJo0CZ9++qm0ki0ArFy5El5eXnjhhRfw6quvYvDgwXBxcZEW1RAEAVu3bsULL7yAgQMHolatWnjjjTdw5cqVJ5rNOXXqVEycOBHTp09H3bp10aFDB2zZsgX+/v4AgCpVqmDr1q04dOgQgoKC8M4772DQoEGYMGGCtI/x48ejVatWePnll9GpUyd07dpVWqgCyD/sd8mSJWjZsiUaNGiA7du3Y9OmTUWeeDg9PR2VK1dG5cqVUbduXcyePRuffvopPvnkE6lm+fLlaNy4MV5++WWEhoZCFEVs3bpVOmy2bt26WLhwIaKiohAUFIRDhw4Vee7Gwixfvhw+Pj5o1aoVunXrhiFDhsDT01O6PygoCHPmzMHMmTPx7LPPYtWqVZg+vehl2x8kk8kwYMAA6HQ6o1WdiYiIiIiIiMoqQSxqbe1ywhRLMBcmJycHCQkJ8Pf3lwaTqHRdu3YNvr6+2L59O9q2bWvpdsjEBg0ahJs3b+LXX38tss6cv4umXMbd/9PPITNBf/qcHCRM+oRLuVsJc+YMEZV9pnoNMWXWMGesC3OGiErKlO9pWqMLFELxV38uiFbUYDc28nWtEGXinHlED9q5cycyMzNRv359JCUl4cMPP4Sfnx9eeOEFS7dGJpSWlobjx49j9erVjx3IsyXyLAFyrfD4wsfQ5ZZ8H0REVDaZImuYM0RERJbDwTwqczQaDT7++GNcunQJLi4uaNGiBVatWlXo6q9km7p06YJDhw7hnXfeQbt27SzdDhEREREREVGp4GAelTnh4eEIDw+3dBtkZrt377Z0C0RERERERESljgtgEBERERERERER2QgO5pUSrjNCZFn8HSQiIiIiIqKygIN5ZmY4T1t2draFOyEq3wy/gzx3IhEREREREdkynjPPzORyOdzc3JCamgoAcHR0hCBw9S+i0iKKIrKzs5Gamgo3NzfI5XJLt0RERERERET01DiYVwq8vb0BQBrQI6LS5+bmJv0uEhEREREREdkqDuaVAkEQULlyZXh6ekKj0Vi6HaJyR6lU2syMPGUmIDfBy4Qst+T7ICKisskUWcOcISIishwO5pUiuVxuMwMKRERERERERERkfbgABhERERERERERkY3gYB4REREREREREZGN4GAeERERERERERGRjeA58wCIoggASE9Pt3AnRGSLDK8dhtcSoocxZ4ioJJgz9DjMGSIqKWaNbeFgHoCMjAwAgK+vr4U7ISJblpGRAVdXV0u3QVaIOUNEpsCcocIwZ4jIVJg1toGDeQB8fHxw9epVuLi4QBAEk+03PT0dvr6+uHr1KtRqtcn2a27su/TYYs+AbfZtzp5FUURGRgZ8fHxMul8qO8yVMwB/H0sT+y49ttgzYL6+mTP0OMyZR9li37bYM2CbfdtizwDf09B9HMwDIJPJ8Mwzz5ht/2q12qZeIAzYd+mxxZ4B2+zbXD2b6tMrZRYg15R8P7K8ku+DTMfcOQPw97E0se/SY4s9A+bp25SzJEyRNcwZ68KcKZwt9m2LPQO22bct9gxY/3saMj8ugEFERERERERERGQjOJhHRERERERERERkIziYZ0Z2dnaIjIyEnZ2dpVt5Iuy79Nhiz4Bt9m2LPZemvXv3onPnzvDx8YEgCNiwYcNjt9m9ezcaNWoEOzs71KhRA9HR0Y/UXL9+HW+++SYqVqwIBwcH1K9fH0eOHDH9EyjHbPFn2xZ7Bth3abLFngHb7bs0MGdsl63+XNti37bYM2Cbfdtiz4Dt9k2mJ4hcd5iIyOLS09Ph6uqKBgOmQa6yL/H+dHk5+Cf6Y6SlpRXrfBq//fYb/vrrLzRu3BjdunXD+vXr0bVr10LrExIS8Oyzz+Kdd97B22+/jR07dmDMmDHYsmULwsPDAQB37txBcHAw2rRpg2HDhsHDwwPnz59HQEAAAgICSvwciYjoyZgya5gzRET0MEPOtEYXKARlifalFTXYjY3FzpnyhgtgEBEROnbsiI4dOxa7fvHixfD398fs2bMBAHXr1sW+ffvw1VdfSW+yZs6cCV9fXyxfvlzazt/f37SNExGRTWDOEBERmQ4PsyUiKsPS09ONLrm5uSbZb2xsLMLCwoxuCw8PR2xsrHT9119/RZMmTdCjRw94enoiODgYS5YsMcnjExGRdWDOEBERlT4O5hERWRFVph52GSW/qDL1AABfX1+4urpKl+nTp5ukz+TkZHh5eRnd5uXlhfT0dNy7dw8AcOnSJSxatAg1a9bE77//jmHDhmHUqFFYsWKFSXogIqKnY4qsYc4QERFZDg+zJSIqw65evWp0jonSPFmuXq9HkyZNMG3aNABAcHAwTpw4gcWLF6N///6l1gcREZkPc4aIiKj0cWaeGUVFRcHPzw/29vYICQnBoUOHLNbL41YQE0URkyZNQuXKleHg4ICwsDCcP3/eqOb27dvo06cP1Go13NzcMGjQIGRmZpqt5+nTp6Np06ZwcXGBp6cnunbtirNnzxrV5OTkYPjw4ahYsSKcnZ3RvXt3pKSkGNUkJiaiU6dOcHR0hKenJ8aOHQutVmu2vhctWoQGDRpArVZDrVYjNDQUv/32m1X3/LAZM2ZAEASMGTPGqvuePHkyBEEwutSpU8eqey5thp9Dw8VUb7K8vb0f+VqmpKRArVbDwcEBAFC5cmUEBgYa1dStWxeJiYkm6YGsK2cAZk1pvZaUhZwBmDVlJWuYM2WfNWUNc4bvaZ4Ec6Zs5AwVjIN5ZrJ27VpEREQgMjISR48eRVBQEMLDw5GammqRfrKyshAUFISoqKgC7//iiy8wf/58LF68GAcPHoSTkxPCw8ORk5Mj1fTp0wcnT55ETEwMNm/ejL1792LIkCFm63nPnj0YPnw4Dhw4gJiYGGg0GrRv3x5ZWVlSzXvvvYdNmzZh3bp12LNnD27cuIFu3bpJ9+t0OnTq1Al5eXnYv38/VqxYgejoaEyaNMlsfT/zzDOYMWMG4uLicOTIEbz44ovo0qULTp48abU9P+jw4cP45ptv0KBBA6PbrbXvevXqISkpSbrs27fP6nsuC0JDQ7Fjxw6j22JiYhAaGipdb9my5SN/rJ47dw7VqlUrlR7LOmvLGYBZU1qvJbaeMwCzhlnzeMwZ62BtWcOc4Xua4mLOMGfKPJHMolmzZuLw4cOl6zqdTvTx8RGnT59uwa7yARDXr18vXdfr9aK3t7f45ZdfSrfdvXtXtLOzE//3v/+JoiiKp06dEgGIhw8flmp+++03URAE8fr166XSd2pqqghA3LNnj9SjUqkU161bJ9WcPn1aBCDGxsaKoiiKW7duFWUymZicnCzVLFq0SFSr1WJubm6p9C2KolihQgVx6dKlVt9zRkaGWLNmTTEmJkZs1aqVOHr0aFEUrfdrHRkZKQYFBRV4n7X2XJi0tDQRgNjktc/E5r1mlfjS5LXPRABiWlpasR4/IyNDPHbsmHjs2DERgDhnzhzx2LFj4pUrV0RRFMVx48aJffv2leovXbokOjo6imPHjhVPnz4tRkVFiXK5XNy2bZtUc+jQIVGhUIiff/65eP78eXHVqlWio6Oj+MMPP5j2i1dOWXPOiCKzprRfS2wlZ0SRWVMaPRfGlFnDnCkfrDlrmDN8T1MY5ozlc6Y1uohhwmslurRGlyfKmfKGM/PMIC8vD3FxcUYrcMlkMoSFhRmtwGUtEhISkJycbNSvq6srQkJCpH5jY2Ph5uaGJk2aSDVhYWGQyWQ4ePBgqfSZlpYGAHB3dwcAxMXFQaPRGPVdp04dVK1a1ajv+vXrG51AOTw8HOnp6dKnSuak0+mwZs0aZGVlITQ01Op7Hj58ODp16vTI6nHW3Pf58+fh4+OD6tWro0+fPtKhNdbcszU6cuQIgoODERwcDACIiIhAcHCw9IleUlKS0WFL/v7+2LJlC2JiYhAUFITZs2dj6dKlCA8Pl2qaNm2K9evX43//+x+effZZTJ06FXPnzkWfPn1K98mVQbaWMwCzxlxsLWcAZk1p9WxtmDO2x9ayhjljPraWNcyZ8pkz5Q0XwDCDW7duQafTFbgC15kzZyzUVeGSk5MBoMB+DfclJyfD09PT6H6FQgF3d3epxpz0ej3GjBmDli1b4tlnn5V6UqlUcHNzK7Lvgp6X4T5zOX78OEJDQ5GTkwNnZ2esX78egYGBiI+Pt9qe16xZg6NHj+Lw4cOP3GetX+uQkBBER0ejdu3aSEpKwpQpU/D888/jxIkTVtuztWrdujVEUSz0/ujo6AK3OXbsWJH7ffnll/Hyyy+XtD16iK3lDMCsMTVbzBmAWVNaPVsj5oztsbWsYc6Yni1mDXOmdHomy+NgHtmE4cOH48SJE0bnDrBmtWvXRnx8PNLS0vDTTz+hf//+2LNnj6XbKtTVq1cxevRoxMTEwN7e3tLtFFvHjh2l/zdo0AAhISGoVq0afvzxR+nk2ERExWVLWWNrOQMwa4iIbClnANvLGuYMlSc8zNYMKlWqBLlcXuAKXN7e3hbqqnCGnorq19vb+5ET3Wq1Wty+fdvsz2nEiBHYvHkzdu3ahWeeecao77y8PNy9e7fIvgt6Xob7zEWlUqFGjRpo3Lgxpk+fjqCgIMybN89qe46Li0NqaioaNWoEhUIBhUKBPXv2YP78+VAoFPDy8rLKvh/m5uaGWrVq4cKFC1b7tX4cVZrOZBcqu2wtZwBmjanZWs4AzBpL9vww5gwVh61lDXPG9Gwta5gzluuZSh8H88xApVKhcePGRitw6fV67Nixw2gFLmvh7+8Pb29vo37T09Nx8OBBqd/Q0FDcvXsXcXFxUs3OnTuh1+sREhJilr5EUcSIESOwfv167Ny5E/7+/kb3N27cGEql0qjvs2fPIjEx0ajv48ePG4V2TEwM1Go1AgMDzdJ3QfR6PXJzc62257Zt2+L48eOIj4+XLk2aNEGfPn2k/1tj3w/LzMzExYsXUblyZav9WhOZgq3lDMCsMTdrzxmAWcOsIVtja1nDnDE/a88a5gxzpjzhYbZmEhERgf79+6NJkyZo1qwZ5s6di6ysLAwcONAi/WRmZuLChQvS9YSEBMTHx8Pd3R1Vq1bFmDFj8Nlnn6FmzZrw9/fHxIkT4ePjg65duwIA6tatiw4dOmDw4MFYvHgxNBoNRowYgTfeeAM+Pj5m6Xn48OFYvXo1Nm7cCBcXF+l4f1dXVzg4OMDV1RWDBg1CREQE3N3doVarMXLkSISGhqJ58+YAgPbt2yMwMBB9+/bFF198geTkZEyYMAHDhw+HnZ2dWfoeP348OnbsiKpVqyIjIwOrV6/G7t278fvvv1ttzy4uLtJ5OwycnJxQsWJF6XZr7PuDDz5A586dUa1aNdy4cQORkZGQy+Xo1auX1X6tiUzF2nIGYNaU1muJLeYMwKxh1pAtsrasYc7wPU1RmDPMmXLFomvplnFff/21WLVqVVGlUonNmjUTDxw4YLFedu3aJQJ45NK/f39RFPOXcp84caLo5eUl2tnZiW3bthXPnj1rtI9///1X7NWrl+js7Cyq1Wpx4MCBYkZGhtl6LqhfAOLy5culmnv37onvvvuuWKFCBdHR0VF89dVXxaSkJKP9XL58WezYsaPo4OAgVqpUSXz//fdFjUZjtr7feustsVq1aqJKpRI9PDzEtm3bin/88YdV91yQB5dxt9a+e/bsKVauXFlUqVRilSpVxJ49e4oXLlyw6p4LY1jGvUW7KeILL80s8aVFuylcyr0csKacEUVmTWm9lpSVnBFFZk1pM2XWMGfKD2vKGuYM39M8KeZM6TLkTGt0EcOE10p0aY0uzJkiCKJYxLJSRERUKtLT0+Hq6ooW7aZAoSz5CXu1mhzsj4lEWloa1Gq1CTokIiJbZ8qsYc4QEdHDDDnTGl2gEJQl2pdW1GA3NjJnCsFz5hEREREREREREdkIDuYRERERERERERHZCA7mERERERERERER2QiuZktEZEVU6RooFPIS70em1ZigGyIiKotMkTXMGSIiIsvhzDwiIiIiIiIiIiIbwcE8IiIiIiIiIiIiG8HBPCIiIiIiIiIiIhvBwTwiIiIiIiIiIiIbwcE8okKcPXsW3t7eyMjIKNF+mjdvjp9//tlEXRERUVnCrCEiInNizhCVTRzMozJLp9OhRYsW6Natm9HtaWlp8PX1xSeffFLk9uPHj8fIkSPh4uJSoj4mTJiAcePGQa/Xl2g/RERkfZg1RERkTswZIioIB/OozJLL5YiOjsa2bduwatUq6faRI0fC3d0dkZGRhW6bmJiIzZs3Y8CAASXuo2PHjsjIyMBvv/1W4n1R2SdPvwd5WnbJL+n3LP1UiMoFZg3ZIpNkDXOGqFQwZ4ioIBzMozKtVq1amDFjBkaOHImkpCRs3LgRa9aswcqVK6FSqQrd7scff0RQUBCqVKki3RYdHQ03Nzds3rwZtWvXhqOjI1577TVkZ2djxYoV8PPzQ4UKFTBq1CjodDppO7lcjpdeeglr1qwx63MlIiLLYNYQEZE5MWeI6GEKSzdAZG4jR47E+vXr0bdvXxw/fhyTJk1CUFBQkdv8+eefaNKkySO3Z2dnY/78+VizZg0yMjLQrVs3vPrqq3Bzc8PWrVtx6dIldO/eHS1btkTPnj2l7Zo1a4YZM2aY/LkREZF1YNYQEZE5MWeI6EEczKMyTxAELFq0CHXr1kX9+vUxbty4x25z5cqVAoNPo9Fg0aJFCAgIAAC89tpr+P7775GSkgJnZ2cEBgaiTZs22LVrl1Hw+fj44OrVq9Dr9ZDJOCGWiKisYdYQEZE5MWeI6EH8DaRy4bvvvoOjoyMSEhJw7dq1x9bfu3cP9vb2j9zu6OgohR4AeHl5wc/PD87Ozka3paamGm3n4OAAvV6P3NzcEjwLIiKyZswaIiIyJ+YMERlwMI/KvP379+Orr77C5s2b0axZMwwaNAiiKBa5TaVKlXDnzp1HblcqlUbXBUEo8LaHV3m6ffs2nJyc4ODg8JTPgoiIrBmzhoiIzIk5Q0QP4mAelWnZ2dkYMGAAhg0bhjZt2mDZsmU4dOgQFi9eXOR2wcHBOHXqlMn6OHHiBIKDg022PyIish7MGiIiMifmDBE9jIN5VKaNHz8eoihKJ2r18/PDrFmz8OGHH+Ly5cuFbhceHo7Y2FijFZxK4s8//0T79u1Nsi8iIrIuzBoiIjIn5gwRPYyDeVRm7dmzB1FRUVi+fDkcHR2l24cOHYoWLVoUOTW9Y8eOUCgU2L59e4n7uH79Ovbv34+BAweWeF9U9glpmRDumuCSlmnpp0JULjBryBaZJGuYM0SlgjlDRAURxMcdaE9UTkVFReHXX3/F77//XqL9fPTRR7hz5w6+/fZbE3VGZVF6ejpcXV0R5jMUCpldifen1edi+41vkJaWBrVabYIOicgcmDVUmkyZNcwZItvAnKHSZMiZ1ugChaB8/AZF0Ioa7MZG5kwhFJZugMhaDR06FHfv3kVGRgZcXFyeej+enp6IiIgwYWdERFRWMGuIiMicmDNEZRNn5hERWQHOzCMiInPjzDwiIjInzswrPTxnHhERERERERERkY3gYB4REREREREREZGN4GAeERERERERERGRjeBgHhERERERERERkY3garZERFZEf+cu9IKq5PsR80zQDRERlUWmyBrmDBERkeVwZh4REREREREREZGN4GAeERERERERERGRjeBgHhERYe/evejcuTN8fHwgCAI2bNjw2G12796NRo0awc7ODjVq1EB0dPQjNVFRUfDz84O9vT1CQkJw6NAh0zdPRERWjzlDRETW4pVXXkHVqlVhb2+PypUro2/fvrhx40aR21y8eBGvvvoqPDw8oFar8frrryMlJcWo5ujRo2jXrh3c3NxQsWJFDBkyBJmZmdL90dHREAShwEtqauoTPQcO5hEREbKyshAUFISoqKhi1SckJKBTp05o06YN4uPjMWbMGLz99tv4/fffpZq1a9ciIiICkZGROHr0KIKCghAeHv7EQUVERLaPOUNERNaiTZs2+PHHH3H27Fn8/PPPuHjxIl577bVC67OystC+fXsIgoCdO3fir7/+Ql5eHjp37gy9Xg8AuHHjBsLCwlCjRg0cPHgQ27Ztw8mTJzFgwABpPz179kRSUpLRJTw8HK1atYKnp+cTPQdBFEXxqZ49ERGZTHp6OlxdXfGiQ08oTLAAhlbMw857a5GWlga1Wv1E2wqCgPXr16Nr166F1nz00UfYsmULTpw4Id32xhtv4O7du9i2bRsAICQkBE2bNsWCBQsAAHq9Hr6+vhg5ciTGjRv35E+KiIhKxJRZw5whIqKHGXKmNbpAIShLtC+tqMFubHyqnHlSv/76K7p27Yrc3FwolY/2/ccff6Bjx464c+eO1EtaWhoqVKiAP/74A2FhYfj2228xceJEJCUlQSbLnzd3/PhxNGjQAOfPn0eNGjUe2e/NmzdRpUoVLFu2DH379n2injkzj4iInlhsbCzCwsKMbgsPD0dsbCwAIC8vD3FxcUY1MpkMYWFhUg0REVFhmDNERFQabt++jVWrVqFFixYFDuQBQG5uLgRBgJ2dnXSbvb09ZDIZ9u3bJ9WoVCppIA8AHBwcAECqedjKlSvh6OhY5KzAwnAwj4jIimhFDbRingkuGgD5n449eMnNzTVJn8nJyfDy8jK6zcvLC+np6bh37x5u3boFnU5XYE1ycrJJeiAioqdjmqxhzhARUcG00PyXNSW4wLw589FHH8HJyQkVK1ZEYmIiNm7cWGht8+bN4eTkhI8++gjZ2dnIysrCBx98AJ1Oh6SkJADAiy++iOTkZHz55ZfIy8vDnTt3pFnihpqHLVu2DL1795YG/Z6E4om3ICIik1OpVPD29sbe5F9Mtk9nZ2f4+voa3RYZGYnJkyeb7DGIiMh2mDprmDNERPQgQ87sS95qkv09Sc6MGzcOM2fOLHJ/p0+fRp06dQAAY8eOxaBBg3DlyhVMmTIF/fr1w+bNmyEIwiPbeXh4YN26dRg2bBjmz58PmUyGXr16oVGjRtJMvHr16mHFihWIiIjA+PHjIZfLMWrUKHh5eRnN1jOIjY3F6dOn8f333xf3y2GEg3lERFbA3t4eCQkJyMvLM9k+RVF8JIwenBpeEt7e3o+s3pSSkgK1Wg0HBwfI5XLI5fICa7y9vU3SAxERPRlTZw1zhoiIHmTJnHn//feNFpsoSPXq1aX/V6pUCZUqVUKtz7KixgAAAxRJREFUWrVQt25d+Pr64sCBAwgNDS1w2/bt2+PixYu4desWFAoF3Nzc4O3tbbTP3r17o3fv3khJSYGTkxMEQcCcOXOMagyWLl2Khg0bonHjxkX2XBgO5hERWQl7e3vY29tbuo1iCQ0Nxdatxp+4xcTESOGnUqnQuHFj7NixQzrBuV6vx44dOzBixIjSbpeIiP5jK1nDnCEisk2WyhkPDw94eHg81baGFWmLcwhvpUqVAAA7d+5EamoqXnnllUdqDKeA+O6772Bvb4927doZ3Z+ZmYkff/wR06dPf6p+AZ4zj4iIkB8o8fHxiI+PBwAkJCQgPj4eiYmJAIDx48ejX79+Uv0777yDS5cu4cMPP8SZM2ewcOFC/Pjjj3jvvfekmoiICCxZsgQrVqzA6dOnMWzYMGRlZWHgwIGl+tyIiMjymDNERGQNDh48iAULFiA+Ph5XrlzBzp070atXLwQEBEgfGF2/fh116tTBoUOHpO2WL1+OAwcO4OLFi/jhhx/Qo0cPvPfee6hdu7ZUs2DBAhw9ehTnzp1DVFQURowYgenTp8PNzc2oh7Vr10Kr1eLNN998+iciEhFRubdr1y4RwCOX/v37i6Ioiv379xdbtWr1yDYNGzYUVSqVWL16dXH58uWP7Pfrr78Wq1atKqpUKrFZs2bigQMHzP9kiIjI6jBniIjIGvzzzz9imzZtRHd3d9HOzk708/MT33nnHfHatWtSTUJCgghA3LVrl3TbRx99JHp5eYlKpVKsWbOmOHv2bFGv1xvtu2/fvqK7u7uoUqnEBg0aiCtXriywh9DQULF3794leh6CKIri0w8FEhERERERERERUWnhYbZEREREREREREQ2goN5RERERERERERENoKDeURERERERERERDaCg3lEREREREREREQ2goN5RERERERERERENoKDeURERERERERERDaCg3lEREREREREREQ2goN5RERERERERERENoKDeURERERERERERDaCg3lEREREREREREQ2goN5RERERERERERENoKDeURERERERERERDbi/+6O2uX6FTRLAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use the HeterogeneousMap object to plot the speedup map for 3 wd/ws combinations\n", + "fig, axarr = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(15, 5))\n", + "\n", + "\n", + "ax = axarr[0]\n", + "heterogeneous_map.plot_single_speed_multiplier(\n", + " wind_direction=60.0, wind_speed=8.5, ax=ax, vmin=1.0, vmax=1.2\n", + ")\n", + "ax.set_title(\"Wind Direction = 60.0\\nWind Speed = 8.5\")\n", + "ax.legend()\n", + "\n", + "ax = axarr[1]\n", + "heterogeneous_map.plot_single_speed_multiplier(\n", + " wind_direction=130.0, wind_speed=4.0, ax=ax, vmin=1.0, vmax=1.2\n", + ")\n", + "ax.set_title(\"Wind Direction = 130.0\\nWind Speed = 4.0\")\n", + "\n", + "ax = axarr[2]\n", + "heterogeneous_map.plot_single_speed_multiplier(\n", + " wind_direction=280.0, wind_speed=16.0, ax=ax, vmin=1.0, vmax=1.2\n", + ")\n", + "ax.set_title(\"Wind Direction = 280.0\\nWind Speed = 16.0\")\n", + "fig.suptitle(\"Heterogeneous speedup map for several directions and wind speeds\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Applying heterogeneity to a FlorisModel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Applying the HeterogeneousMap to a FlorisModel is done by passing the HeterogeneousMap to a WindData object which is used to set the FlorisModel. The WindData object constructs the appropriate speed up map for each wind direction and wind speed condition." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mDeleting stored wind_data information.\u001b[0m\n", + "\u001b[34mfloris.logging_manager.LoggingManager\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mThe calculated flow field contains points outside of the the user-defined heterogeneous inflow bounds. For these points, the interpolated value has been filled with the freestream wind speed. If this is not the desired behavior, the user will need to expand the heterogeneous inflow bounds to fully cover the calculated flow field area.\u001b[0m\n", + "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mDeleting stored wind_data information.\u001b[0m\n", + "\u001b[34mfloris.logging_manager.LoggingManager\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mThe calculated flow field contains points outside of the the user-defined heterogeneous inflow bounds. For these points, the interpolated value has been filled with the freestream wind speed. If this is not the desired behavior, the user will need to expand the heterogeneous inflow bounds to fully cover the calculated flow field area.\u001b[0m\n", + "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mDeleting stored wind_data information.\u001b[0m\n", + "\u001b[34mfloris.logging_manager.LoggingManager\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mThe calculated flow field contains points outside of the the user-defined heterogeneous inflow bounds. For these points, the interpolated value has been filled with the freestream wind speed. If this is not the desired behavior, the user will need to expand the heterogeneous inflow bounds to fully cover the calculated flow field area.\u001b[0m\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Initialize FlorisModel\n", + "fmodel = FlorisModel(\"gch.yaml\")\n", + "\n", + "# Change the layout to a 2 turbine layout within the heterogeneous domain\n", + "fmodel.set(layout_x=[200, 200.0], layout_y=[50, 450.0])\n", + "\n", + "# Define a TimeSeries object with 3 wind directions and wind speeds\n", + "# and turbulence intensity and using the above HeterogeneousMap object\n", + "time_series = TimeSeries(\n", + " wind_directions=np.array([275.0, 95.0, 75.0]),\n", + " wind_speeds=np.array([7.0, 6.2, 8.0]),\n", + " turbulence_intensities=0.06,\n", + " heterogeneous_map=heterogeneous_map,\n", + ")\n", + "\n", + "# Apply the time series to the FlorisModel\n", + "fmodel.set(wind_data=time_series)\n", + "\n", + "# Run the FLORIS simulation\n", + "fmodel.run()\n", + "\n", + "# Visualize each of the findices\n", + "fig, axarr = plt.subplots(3, 1, sharex=True, sharey=True, figsize=(10, 10))\n", + "\n", + "for findex in range(3):\n", + " ax = axarr[findex]\n", + "\n", + " horizontal_plane = fmodel.calculate_horizontal_plane(\n", + " x_resolution=200, y_resolution=100, height=90.0, findex_for_viz=findex\n", + " )\n", + "\n", + " visualize_heterogeneous_cut_plane(\n", + " cut_plane=horizontal_plane,\n", + " fmodel=fmodel,\n", + " ax=ax,\n", + " title=(\n", + " f\"Wind Direction = {time_series.wind_directions[findex]}\\n\"\n", + " f\"Wind Speed = {time_series.wind_speeds[findex]}\"\n", + " ),\n", + " )\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "floris", + "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.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/examples/examples_heterogeneous/001_heterogeneous_inflow_single.py b/examples/examples_heterogeneous/001_heterogeneous_inflow_single.py index 28f92d238..459d7a4ac 100644 --- a/examples/examples_heterogeneous/001_heterogeneous_inflow_single.py +++ b/examples/examples_heterogeneous/001_heterogeneous_inflow_single.py @@ -17,7 +17,7 @@ import numpy as np from floris import FlorisModel, TimeSeries -from floris.flow_visualization import visualize_cut_plane +from floris.flow_visualization import visualize_heterogeneous_cut_plane from floris.layout_visualization import plot_turbine_labels @@ -65,15 +65,20 @@ x_resolution=200, y_resolution=100, height=90.0 ) -# Plot the horizontal plane +# Plot the horizontal plane using the visualize_heterogeneous_cut_plane. +# Note that this function is not very different than the standard +# visualize_cut_plane except that it accepts the fmodel object in order to +# visualize the boundary of the heterogeneous inflow region. fig, ax = plt.subplots() -visualize_cut_plane( +visualize_heterogeneous_cut_plane( horizontal_plane, + fmodel=fmodel, ax=ax, title="Horizontal plane at hub height", color_bar=True, label_contours=True, ) plot_turbine_labels(fmodel, ax) +ax.legend() plt.show() diff --git a/examples/examples_heterogeneous/002_heterogeneous_inflow_multi.py b/examples/examples_heterogeneous/002_heterogeneous_using_wind_data.py similarity index 63% rename from examples/examples_heterogeneous/002_heterogeneous_inflow_multi.py rename to examples/examples_heterogeneous/002_heterogeneous_using_wind_data.py index fa8b9cfe4..4b5b1ac43 100644 --- a/examples/examples_heterogeneous/002_heterogeneous_inflow_multi.py +++ b/examples/examples_heterogeneous/002_heterogeneous_using_wind_data.py @@ -1,16 +1,14 @@ -"""Example: Heterogeneous Inflow for multiple conditions +"""Example: Heterogeneous Inflow using wind data When multiple cases are considered, the heterogeneous inflow conditions can be defined in two ways: 1. Passing heterogeneous_inflow_config to the set method, with P points, - and speedups of size n_findex X P - 2. Assigning heterogeneous_inflow_config_by_wd to the wind_data object - used to drive FLORIS. This object includes - n_wd wind_directions, and speedups is of size n_wd X P. When applied - to set, the heterogeneous_inflow_config - is automatically generated by using the nearest wind direction - defined in heterogeneous_inflow_config_by_wd - for each findex. + and speed_multipliers of size n_findex X P + 2. More conveniently, building a HeterogeneousMap object that defines the speed_multipliers as a + function of wind direction and/or wind speed and passing that to a WindData object. When + the WindData object is passed to the set method, the heterogeneous_inflow_config is + automatically generated for each findex by finding the nearest wind direction and/or wind + speed in the HeterogeneousMap object. This example: @@ -23,7 +21,11 @@ import matplotlib.pyplot as plt import numpy as np -from floris import FlorisModel, TimeSeries +from floris import ( + FlorisModel, + HeterogeneousMap, + TimeSeries, +) # Initialize FlorisModel @@ -34,7 +36,6 @@ # Define a TimeSeries object with 4 wind directions and constant wind speed # and turbulence intensity - time_series = TimeSeries( wind_directions=np.array([269.0, 270.0, 271.0, 282.0]), wind_speeds=8.0, @@ -51,9 +52,9 @@ # Assume the speed-ups are defined such that they are the same 265-275 degrees and 275-285 degrees -# If defining heterogeneous_inflow_config directly, then the speedups are of size n_findex X P -# where the first 3 rows are identical, and the last row is different -speed_ups = [ +# If defining heterogeneous_inflow_config directly, then the speed_multipliers are of size +# n_findex x P, where the first 3 rows are identical and the last row is different +speed_multipliers = [ [1.0, 1.25, 1.0, 1.25], [1.0, 1.25, 1.0, 1.25], [1.0, 1.25, 1.0, 1.25], @@ -61,7 +62,7 @@ ] heterogeneous_inflow_config = { - "speed_multipliers": speed_ups, + "speed_multipliers": speed_multipliers, "x": x_locs, "y": y_locs, } @@ -75,19 +76,37 @@ # Get the power output of the turbines turbine_powers = fmodel.get_turbine_powers() / 1000.0 -# Now repeat using the wind_data object and heterogeneous_inflow_config_by_wd -# First, create the speedups for the two wind directions -speed_ups = [[1.0, 1.25, 1.0, 1.25], [1.0, 1.35, 1.0, 1.35]] +# Now repeat using the wind_data object and HeterogeneousMap object +# First, create the speed multipliers for the two wind directions +speed_multipliers = [[1.0, 1.25, 1.0, 1.25], [1.0, 1.35, 1.0, 1.35]] + +# Now define the HeterogeneousMap object +heterogeneous_map = HeterogeneousMap( + x=x_locs, + y=y_locs, + speed_multipliers=speed_multipliers, + wind_directions=[270.0, 280.0], +) -# Create the heterogeneous_inflow_config_by_wd dictionary +# Now create a new TimeSeries object including the heterogeneous_inflow_config_by_wd +time_series = TimeSeries( + wind_directions=np.array([269.0, 270.0, 271.0, 282.0]), + wind_speeds=8.0, + turbulence_intensities=0.06, + heterogeneous_map=heterogeneous_map, +) + +# Note that previously, the a heterogeneous_inflow_config_by_wd, which only only +# specification by wind direction was defined, and for backwards compatibility, +# this is still accepted. However, the HeterogeneousMap object is more flexible. +# The following code produces the same results as the previous code block. heterogeneous_inflow_config_by_wd = { - "speed_multipliers": speed_ups, + "speed_multipliers": speed_multipliers, "x": x_locs, "y": y_locs, "wind_directions": [270.0, 280.0], } -# Now create a new TimeSeries object including the heterogeneous_inflow_config_by_wd time_series = TimeSeries( wind_directions=np.array([269.0, 270.0, 271.0, 282.0]), wind_speeds=8.0, @@ -95,6 +114,7 @@ heterogeneous_inflow_config_by_wd=heterogeneous_inflow_config_by_wd, ) + # Apply the time series to the FlorisModel fmodel.set(wind_data=time_series) diff --git a/examples/examples_heterogeneous/003_heterogeneous_speedup_by_wd_and_ws.py b/examples/examples_heterogeneous/003_heterogeneous_speedup_by_wd_and_ws.py new file mode 100644 index 000000000..d0bfe422f --- /dev/null +++ b/examples/examples_heterogeneous/003_heterogeneous_speedup_by_wd_and_ws.py @@ -0,0 +1,113 @@ +"""Example: Heterogeneous Speedup by Wind Direction and Wind Speed + +The HeterogeneousMap object is a flexible way to define speedups as a function of wind direction +and/or wind speed. It also contains methods to plot the speedup map for a given wind direction +and wind speed. + +This example: + + 1) Instantiates a HeterogeneousMap object with speedups defined for two wind directions + and two wind speeds + 2) Visualizes the speedups for two particular combinations of wind direction and wind speed + 3) Runs a FLORIS simulation using the HeterogeneousMap and visualizes the results + +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + HeterogeneousMap, + TimeSeries, +) +from floris.flow_visualization import visualize_heterogeneous_cut_plane + + +# Define a HeterogeneousMap object with speedups defined for two wind directions +# and two wind speeds. The speedups imply no heterogeneity for the first wind direction +# (0 degrees) with heterogeneity for the second wind direction (180 degrees) with the +# specific speedups for this direction depending on the wind speed. +heterogeneous_map = HeterogeneousMap( + x=np.array([0.0, 0.0, 250.0, 500.0, 500.0]), + y=np.array([0.0, 500.0, 250.0, 0.0, 500.0]), + speed_multipliers=np.array( + [ + [1.0, 1.0, 1.0, 1.0, 1.0], + [1.0, 1.0, 1.0, 1.0, 1.0], + [1.5, 1.0, 1.25, 1.5, 1.0], + [1.0, 1.5, 1.25, 1.0, 1.5], + ] + ), + wind_directions=np.array([270.0, 270.0, 90.0, 90.0]), + wind_speeds=np.array([5.0, 10.0, 5.0, 10.0]), +) + +# Use the HeterogeneousMap object to plot the speedup map for 3 wd/ws combinations +fig, axarr = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(15, 5)) + + +ax = axarr[0] +heterogeneous_map.plot_single_speed_multiplier( + wind_direction=60.0, wind_speed=8.5, ax=ax, vmin=1.0, vmax=1.2 +) +ax.set_title("Wind Direction = 60.0\nWind Speed = 8.5") + +ax = axarr[1] +heterogeneous_map.plot_single_speed_multiplier( + wind_direction=130.0, wind_speed=4.0, ax=ax, vmin=1.0, vmax=1.2 +) +ax.set_title("Wind Direction = 130.0\nWind Speed = 4.0") + +ax = axarr[2] +heterogeneous_map.plot_single_speed_multiplier( + wind_direction=280.0, wind_speed=16.0, ax=ax, vmin=1.0, vmax=1.2 +) +ax.set_title("Wind Direction = 280.0\nWind Speed = 16.0") +fig.suptitle("Heterogeneous speedup map for several directions and wind speeds") + + +# Initialize FlorisModel +fmodel = FlorisModel("../inputs/gch.yaml") + +# Change the layout to a 2 turbine layout within the heterogeneous domain +fmodel.set(layout_x=[200, 200.0], layout_y=[50, 450.0]) + +# Define a TimeSeries object with 3 wind directions and wind speeds +# and turbulence intensity and using the above HeterogeneousMap object +time_series = TimeSeries( + wind_directions=np.array([275.0, 95.0, 75.0]), + wind_speeds=np.array([7.0, 6.2, 8.0]), + turbulence_intensities=0.06, + heterogeneous_map=heterogeneous_map, +) + +# Apply the time series to the FlorisModel +fmodel.set(wind_data=time_series) + +# Run the FLORIS simulation +fmodel.run() + +# Visualize each of the findices +fig, axarr = plt.subplots(3, 1, sharex=True, sharey=True, figsize=(10, 10)) + +for findex in range(3): + ax = axarr[findex] + + horizontal_plane = fmodel.calculate_horizontal_plane( + x_resolution=200, y_resolution=100, height=90.0, findex_for_viz=findex + ) + + visualize_heterogeneous_cut_plane( + cut_plane=horizontal_plane, + fmodel=fmodel, + ax=ax, + title=( + f"Wind Direction = {time_series.wind_directions[findex]}\n" + f"Wind Speed = {time_series.wind_speeds[findex]}" + ), + ) + + +plt.show() diff --git a/examples/examples_heterogeneous/003_heterogeneous_2d_and_3d.py b/examples/examples_heterogeneous/004_heterogeneous_2d_and_3d.py similarity index 100% rename from examples/examples_heterogeneous/003_heterogeneous_2d_and_3d.py rename to examples/examples_heterogeneous/004_heterogeneous_2d_and_3d.py diff --git a/floris/__init__.py b/floris/__init__.py index 149d32d6a..f3ef231a7 100644 --- a/floris/__init__.py +++ b/floris/__init__.py @@ -12,6 +12,7 @@ visualize_cut_plane, visualize_quiver, ) +from .heterogeneous_map import HeterogeneousMap from .parallel_floris_model import ParallelFlorisModel from .uncertain_floris_model import ApproxFlorisModel, UncertainFlorisModel from .wind_data import ( diff --git a/floris/core/flow_field.py b/floris/core/flow_field.py index d28c47f27..19b488518 100644 --- a/floris/core/flow_field.py +++ b/floris/core/flow_field.py @@ -291,7 +291,7 @@ def generate_heterogeneous_wind_map(self): # Linear interpolation is used for points within the user-defined area of values, # while the freestream wind speed is used for points outside that region in_region = [ - LinearNDInterpolator(list(zip(x, y, z)), multiplier, fill_value=1.0) + self.interpolate_multiplier_xyz(x, y, z, multiplier, fill_value=1.0) for multiplier in speed_multipliers ] else: @@ -299,8 +299,49 @@ def generate_heterogeneous_wind_map(self): # Linear interpolation is used for points within the user-defined area of values, # while the freestream wind speed is used for points outside that region in_region = [ - LinearNDInterpolator(list(zip(x, y)), multiplier, fill_value=1.0) + self.interpolate_multiplier_xy(x, y, multiplier, fill_value=1.0) for multiplier in speed_multipliers ] self.het_map = in_region + + @staticmethod + def interpolate_multiplier_xy(x: NDArrayFloat, + y: NDArrayFloat, + multiplier: NDArrayFloat, + fill_value: float = 1.0): + """Return an interpolant for a 2D multiplier field. + + Args: + x (NDArrayFloat): x locations + y (NDArrayFloat): y locations + multiplier (NDArrayFloat): multipliers + fill_value (float): fill value for points outside the region + + Returns: + LinearNDInterpolator: interpolant + """ + + return LinearNDInterpolator(list(zip(x, y)), multiplier, fill_value=fill_value) + + + @staticmethod + def interpolate_multiplier_xyz(x: NDArrayFloat, + y: NDArrayFloat, + z: NDArrayFloat, + multiplier: NDArrayFloat, + fill_value: float = 1.0): + """Return an interpolant for a 3D multiplier field. + + Args: + x (NDArrayFloat): x locations + y (NDArrayFloat): y locations + z (NDArrayFloat): z locations + multiplier (NDArrayFloat): multipliers + fill_value (float): fill value for points outside the region + + Returns: + LinearNDInterpolator: interpolant + """ + + return LinearNDInterpolator(list(zip(x, y, z)), multiplier, fill_value=fill_value) diff --git a/floris/floris_model.py b/floris/floris_model.py index 474a211ae..1d05f3d3e 100644 --- a/floris/floris_model.py +++ b/floris/floris_model.py @@ -954,6 +954,22 @@ def set_for_viz(self, findex: int, solver_settings: dict) -> None: findex (int): The findex to set the floris object to. solver_settings (dict): The solver settings to use for visualization. """ + + # If not None, set the heterogeneous inflow configuration + if self.core.flow_field.heterogeneous_inflow_config is not None: + heterogeneous_inflow_config = { + 'x': self.core.flow_field.heterogeneous_inflow_config['x'], + 'y': self.core.flow_field.heterogeneous_inflow_config['y'], + 'speed_multipliers': + self.core.flow_field.heterogeneous_inflow_config['speed_multipliers'][findex:findex+1], + } + if 'z' in self.core.flow_field.heterogeneous_inflow_config: + heterogeneous_inflow_config['z'] = ( + self.core.flow_field.heterogeneous_inflow_config['z'] + ) + else: + heterogeneous_inflow_config = None + self.set( wind_speeds=self.wind_speeds[findex:findex+1], wind_directions=self.wind_directions[findex:findex+1], @@ -962,6 +978,7 @@ def set_for_viz(self, findex: int, solver_settings: dict) -> None: power_setpoints=self.core.farm.power_setpoints[findex:findex+1,:], awc_modes=self.core.farm.awc_modes[findex:findex+1,:], awc_amplitudes=self.core.farm.awc_amplitudes[findex:findex+1,:], + heterogeneous_inflow_config = heterogeneous_inflow_config, solver_settings=solver_settings, ) diff --git a/floris/flow_visualization.py b/floris/flow_visualization.py index 720399d99..57ae105a9 100644 --- a/floris/flow_visualization.py +++ b/floris/flow_visualization.py @@ -19,6 +19,7 @@ from floris.core import Core from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT from floris.cut_plane import CutPlane +from floris.heterogeneous_map import HeterogeneousMap from floris.type_dec import ( floris_array_converter, NDArrayFloat, @@ -124,7 +125,7 @@ def visualize_cut_plane( **kwargs: Additional parameters to pass to line contour plot. Returns: - im (:py:class:`matplotlib.plt.pcolormesh`): Image handle. + ax (:py:class:`matplotlib.pyplot.axes`): Figure axes. """ if not ax: @@ -240,92 +241,31 @@ def visualize_heterogeneous_cut_plane( **kwargs: Additional parameters to pass to line contour plot. Returns: - im (:py:class:`matplotlib.plt.pcolormesh`): Image handle. + ax (:py:class:`matplotlib.pyplot.axes`): Figure axes. """ - if not ax: - fig, ax = plt.subplots() - if vel_component=='u': - # vel_mesh = cut_plane.df.u.values.reshape(cut_plane.resolution[1], cut_plane.resolution[0]) - if min_speed is None: - min_speed = cut_plane.df.u.min() - if max_speed is None: - max_speed = cut_plane.df.u.max() - elif vel_component=='v': - # vel_mesh = cut_plane.df.v.values.reshape(cut_plane.resolution[1], cut_plane.resolution[0]) - if min_speed is None: - min_speed = cut_plane.df.v.min() - if max_speed is None: - max_speed = cut_plane.df.v.max() - elif vel_component=='w': - # vel_mesh = cut_plane.df.w.values.reshape(cut_plane.resolution[1], cut_plane.resolution[0]) - if min_speed is None: - min_speed = cut_plane.df.w.min() - if max_speed is None: - max_speed = cut_plane.df.w.max() - - # Allow separate number of levels for tricontourf and for line_contour - if clevels is None: - clevels = levels - - # Plot the cut-through - im = ax.tricontourf( - cut_plane.df.x1, - cut_plane.df.x2, - cut_plane.df.u, - vmin=min_speed, - vmax=max_speed, - levels=clevels, - cmap=cmap, - extend="both", - ) - - # Add line contour - line_contour_cut_plane( - cut_plane, + ax = visualize_cut_plane( + cut_plane=cut_plane, ax=ax, + vel_component=vel_component, + min_speed=min_speed, + max_speed=max_speed, + cmap=cmap, levels=levels, - colors="b", + clevels=clevels, + color_bar=color_bar, label_contours=label_contours, - linewidths=0.8, - alpha=0.3, + title=title, **kwargs ) - # Plot the user-defined heterogeneous flow area if plot_het_bounds: - points = np.array( - list( - zip( - fmodel.core.flow_field.heterogeneous_inflow_config['x'], - fmodel.core.flow_field.heterogeneous_inflow_config['y'], - ) - ) + HeterogeneousMap.plot_heterogeneous_boundary( + fmodel.core.flow_field.heterogeneous_inflow_config['x'], + fmodel.core.flow_field.heterogeneous_inflow_config['y'], + ax=ax ) - hull = ConvexHull(points) - h = ax.plot( - points[np.append(hull.vertices, hull.vertices[0]),0], - points[np.append(hull.vertices, hull.vertices[0]), 1], - 'k--', - lw=2, - ) - ax.plot(points[hull.vertices,0], points[hull.vertices,1], 'ko') - ax.legend(h, ["defined heterogeneous bounds"], loc=1) - - if cut_plane.normal_vector == "x": - ax.invert_xaxis() - - if color_bar: - cbar = plt.colorbar(im, ax=ax) - cbar.set_label('m/s') - - # Set the title - ax.set_title(title) - - # Make equal axis - ax.set_aspect("equal") - - return im + return ax def visualize_quiver(cut_plane, ax=None, min_speed=None, max_speed=None, downSamp=1, **kwargs): diff --git a/floris/heterogeneous_map.py b/floris/heterogeneous_map.py new file mode 100644 index 000000000..c0aa29de9 --- /dev/null +++ b/floris/heterogeneous_map.py @@ -0,0 +1,421 @@ +from __future__ import annotations + +import matplotlib.cm as cm +import matplotlib.pyplot as plt +import numpy as np +import scipy.spatial._qhull +from scipy.interpolate import LinearNDInterpolator, NearestNDInterpolator +from scipy.spatial import ConvexHull + +from floris.core.flow_field import FlowField +from floris.logging_manager import LoggingManager +from floris.type_dec import NDArrayFloat + + +class HeterogeneousMap(LoggingManager): + """ + Class for handling heterogeneous inflow configurations when defined by wind direction + and wind speed. + Args: + x (NDArrayFloat): A 1D NumPy array (size num_points) of x-coordinates (meters). + y (NDArrayFloat): A 1D NumPy array (size num_points) of y-coordinates (meters). + speed_multipliers (NDArrayFloat): A 2D NumPy array (size num_wd (or num_ws) x num_points) + of speed multipliers. If neither wind_directions nor wind_speeds are defined, then + this should be a single row array + wind_directions (NDArrayFloat, optional): A 1D NumPy array (size num_wd) of wind directions + (degrees). Optional. + wind_speeds (NDArrayFloat, optional): A 1D NumPy array (size num_ws) of wind speeds (m/s). + Optional. + + + Notes: + * If wind_directions and wind_speeds are both defined, then they must be the same length + and equal the length of the 0th dimension of 'speed_multipliers'. + + """ + + def __init__( + self, + x: NDArrayFloat, + y: NDArrayFloat, + speed_multipliers: NDArrayFloat, + wind_directions: NDArrayFloat = None, + wind_speeds: NDArrayFloat = None, + ): + # Check that x, y and speed_multipliers are lists or numpy arrays + if not isinstance(x, (list, np.ndarray)): + raise TypeError("x must be a numpy array or list") + if not isinstance(y, (list, np.ndarray)): + raise TypeError("y must be a numpy array or list") + if not isinstance(speed_multipliers, (list, np.ndarray)): + raise TypeError("speed_multipliers must be a numpy array or list") + + # Save the values + self.x = np.array(x) + self.y = np.array(y) + self.speed_multipliers = np.array(speed_multipliers) + + # Check that the length of the 1st dimension of speed_multipliers is the + # same as the length of both x and y + if (len(self.x) != self.speed_multipliers.shape[1] + or len(self.y) != self.speed_multipliers.shape[1]): + raise ValueError( + "The lengths of x and y must equal the 1th dimension of speed_multipliers " + "within the heterogeneous_inflow_config_by_wd dictionary" + ) + + # If wind_directions is note None, check that it is valid then save it + if wind_directions is not None: + if not isinstance(wind_directions, (list, np.ndarray)): + raise TypeError("wind_directions must be a numpy array or list") + + # Check that length of wind_directions is the same as the length of the 0th + # dimension of speed_multipliers + if len(wind_directions) != self.speed_multipliers.shape[0]: + raise ValueError( + "The length of wind_directions must equal " + "the 0th dimension of speed_multipliers" + "Within the heterogeneous_inflow_config_by_wd dictionary" + ) + + self.wind_directions = np.array(wind_directions) + + else: + self.wind_directions = None + + # If wind_speeds is not None, check that it is valid then save it + if wind_speeds is not None: + if not isinstance(wind_speeds, (list, np.ndarray)): + raise TypeError("wind_speeds must be a numpy array or list") + + # Check that length of wind_speeds is the same as the length of the 0th + # dimension of speed_multipliers + if len(wind_speeds) != self.speed_multipliers.shape[0]: + raise ValueError( + "The length of wind_speeds must equal " + "the 0th dimension of speed_multipliers" + "Within the heterogeneous_inflow_config_by_wd dictionary" + ) + + self.wind_speeds = np.array(wind_speeds) + else: + self.wind_speeds = None + + # If both wind_directions and wind_speeds are None, then speed_multipliers should be + # length 1 in 0th dimension + if self.wind_speeds is None and self.wind_directions is None: + if self.speed_multipliers.shape[0] != 1: + raise ValueError( + "If both wind_speeds and wind_directions are None, then speed_multipliers " + "should be length 1 in 0th dimension." + ) + + # If both wind_directions and wind_speeds are not None, then make sure each row + # of a matrix where wind directions and wind speeds are the columns is unique + if self.wind_speeds is not None and self.wind_directions is not None: + if len( + np.unique(np.column_stack((self.wind_directions, self.wind_speeds)), axis=0) + ) != len(self.wind_directions): + raise ValueError( + "Each row of a matrix where wind directions and wind speeds are the columns " + "should be unique." + ) + + def get_heterogeneous_inflow_config( + self, + wind_directions: NDArrayFloat | list[float], + wind_speeds: NDArrayFloat | list[float], + ): + """ + Get the heterogeneous inflow configuration for the given wind directions and wind speeds. + Args: + wind_directions (NDArrayFloat | list[float]): A 1D NumPy array or + list of wind directions (degrees). + wind_speeds (NDArrayFloat | list[float]): A 1D NumPy array or list of wind speeds (m/s). + Returns: + dict: A dictionary (heterogeneous_inflow_config) containing the x, y, + and speed_multipliers for the given wind directions and wind speeds. + """ + # Check the wind_directions and wind_speeds are either lists or numpy arrays, + # and are the same length + if not isinstance(wind_directions, (list, np.ndarray)): + raise TypeError("wind_directions must be a list or numpy array") + if not isinstance(wind_speeds, (list, np.ndarray)): + raise TypeError("wind_speeds must be a list or numpy array") + if len(wind_directions) != len(wind_speeds): + raise ValueError("wind_directions and wind_speeds must be the same length") + + # Select for wind direction first + if self.wind_directions is not None: + angle_diffs = np.abs(wind_directions[:, None] - self.wind_directions) + min_angle_diffs = np.minimum(angle_diffs, 360 - angle_diffs) + + # If wind_speeds is none, can return the value in each case + if self.wind_speeds is None: + closest_wd_indices = np.argmin(min_angle_diffs, axis=1) + + # Construct the output array using the calculated indices + speed_multipliers_by_findex = self.speed_multipliers[closest_wd_indices] + + # Need to loop over cases and match by wind speed + else: + speed_diffs = np.abs(wind_speeds[:, None] - self.wind_speeds) + + # Initialize the output array + speed_multipliers_by_findex = np.zeros((len(wind_directions), len(self.x))) + + # Loop over each wind direction + for i in range(len(wind_directions)): + # Find all the indices in the ith row of min_angle_diffs + # that are equal to the minimum value + closest_wd_indices = np.where(min_angle_diffs[i] == min_angle_diffs[i].min())[0] + + # Find the index of the minimum value in the ith row of speed_diffs + # conditions on that index being in closest_wd_indices + closest_ws_index = np.argmin(speed_diffs[i, closest_wd_indices]) + + # Construct the output array using the calculated indices + speed_multipliers_by_findex[i] = self.speed_multipliers[ + closest_wd_indices[closest_ws_index] + ] + + # If wind speeds are defined without wind direction + elif self.wind_speeds is not None: + speed_diffs = np.abs(wind_speeds[:, None] - self.wind_speeds) + closest_ws_indices = np.argmin(speed_diffs, axis=1) + + # Construct the output array using the calculated indices + speed_multipliers_by_findex = self.speed_multipliers[closest_ws_indices] + + # Else if both are None, then speed_multipliers should be length 1 in 0th + # dimension and so just 1 row + # repeat this row until length of wind_directions + else: + speed_multipliers_by_findex = np.repeat( + self.speed_multipliers, len(wind_directions), axis=0 + ) + + # Return heterogeneous_inflow_config + return { + "x": self.x, + "y": self.y, + "speed_multipliers": speed_multipliers_by_findex, + } + + @staticmethod + def plot_heterogeneous_boundary(x, y, ax=None): + """ + Plot the boundary of the heterogeneous inflow configuration. + Args: + x (NDArrayFloat): A 1D NumPy array of x-coordinates (meters). + y (NDArrayFloat): A 1D NumPy array of y-coordinates (meters). + ax (matplotlib.axes.Axes, optional): The axes on which to plot the boundary. + If None, a new figure and axes will be created. + """ + + # If not provided create the axis + if ax is None: + _, ax = plt.subplots() + + # Get the x and y coordinates of the het map + points = np.array( + list( + zip( + x, + y, + ) + ) + ) + + # Derive and plot the convex hull surrounding the points + hull = ConvexHull(points) + ax.plot( + points[np.append(hull.vertices, hull.vertices[0]), 0], + points[np.append(hull.vertices, hull.vertices[0]), 1], + "--", + color="gray", + label="Heterogeneity Boundary", + ) + + def plot_wind_direction(self, ax: plt.Axes, wind_direction: float): + """ + Plot the wind direction as an arrow on the plot. + Args: + ax (matplotlib.axes.Axes): The axes on which to plot the wind direction. + wind_direction (float): The wind direction to plot. + """ + + # Get the x and y limits of the axis + xlim = ax.get_xlim() + ylim = ax.get_ylim() + + # Find a point in the top-left corner of the plot + xm = xlim[0] + 0.2 * (xlim[1] - xlim[0]) + ym = ylim[1] - 0.2 * (ylim[1] - ylim[0]) + + # Select a radius for the circle 5% the plot width + radius = 0.075 * (xlim[1] - xlim[0]) + + theta = np.linspace(0.0, 2 * np.pi, 100) + xcirc = np.cos(theta) * radius + xm + ycirc = np.sin(theta) * radius + ym + ax.scatter(xm, ym, color="k", marker="o") + ax.plot(xcirc, ycirc, color="w", linewidth=2) + ax.arrow( + x=xm - np.cos(-(wind_direction - 270.0) * np.pi / 180.0) * radius, + y=ym - np.sin(-(wind_direction - 270.0) * np.pi / 180.0) * radius, + dx=1 * np.cos(-(wind_direction - 270.0) * np.pi / 180.0) * radius, + dy=1 * np.sin(-(wind_direction - 270.0) * np.pi / 180.0) * radius, + width=0.125 * radius, + head_width=0.3 * radius, + head_length=0.3 * radius, + length_includes_head=True, + color="w", + ) + + def plot_single_speed_multiplier( + self, + wind_direction: float, + wind_speed: float, + ax: plt.Axes = None, + vmin: float = None, + vmax: float = None, + cmap: cm = cm.viridis, + show_boundary: bool = True, + show_wind_direction: bool = True, + show_colorbar: bool = True, + ): + """ + Plot the speed multipliers as a heatmap. + Args: + wind_direction (float): The wind direction for which to plot the speed multipliers. + wind_speed (float): The wind speed for which to plot the speed multipliers. + ax (matplotlib.axes.Axes, optional): The axes on which to plot the speed multipliers. + If None, a new figure and axes will be created. + vmin (float, optional): The minimum value for the colorbar. Default is the minimum + value of the speed multipliers. + vmax (float, optional): The maximum value for the colorbar. Default is the maximum + value of the speed multipliers. + cmap (matplotlib.colors.Colormap, optional): The colormap to use for the heatmap. + Default is matplotlib.cm.viridis. + show_boundary (bool, optional): Whether to show the boundary of the heterogeneous + inflow configuration. Default is True. + show_wind_direction (bool, optional): Whether to show the wind direction as an arrow. + Default is True. + show_colorbar (bool, optional): Whether to show the colorbar. Default is True. + + Returns: + matplotlib.axes.Axes: The axes on which the speed multipliers are plotted. + """ + + # Confirm wind_direction and wind_speed are floats + if not isinstance(wind_direction, float): + raise TypeError("wind_direction must be a float") + if not isinstance(wind_speed, float): + raise TypeError("wind_speed must be a float") + + # Get the speed multipliers for the given wind direction and wind speed + speed_multiplier_row = self.get_heterogeneous_inflow_config( + np.array([wind_direction]), np.array([wind_speed]) + )["speed_multipliers"][0] + + # If not provided create the axis + if ax is None: + fig, ax = plt.subplots() + else: + fig = ax.get_figure() + + # Get the x and y coordinates + x = self.x + y = self.y + + # Get some boundary info + min_x = np.min(x) + max_x = np.max(x) + min_y = np.min(y) + max_y = np.max(y) + delta_x = max_x - min_x + delta_y = max_y - min_y + plot_min_x = min_x - 0.1 * delta_x + plot_max_x = max_x + 0.1 * delta_x + plot_min_y = min_y - 0.1 * delta_y + plot_max_y = max_y + 0.1 * delta_y + + # Fill in the plot area + x_plot, y_plot = np.meshgrid( + np.linspace(plot_min_x, plot_max_x, 100), + np.linspace(plot_min_y, plot_max_y, 100), + indexing="ij", + ) + x_plot = x_plot.flatten() + y_plot = y_plot.flatten() + + try: + lin_interpolant = FlowField.interpolate_multiplier_xy(x,y,speed_multiplier_row) + + lin_values = lin_interpolant(x, y) + except scipy.spatial._qhull.QhullError: + self.logger.warning( + "QhullError occurred in computing visualize. Falling back to nearest neighbor. " + "Note this may not represent the exact speed multipliers used within FLORIS." + ) + lin_values = np.nan * np.ones_like(x) + + nearest_interpolant = NearestNDInterpolator( + x=np.vstack([x, y]).T, + y=speed_multiplier_row, + ) + nn_values = nearest_interpolant(x, y) + ids_isnan = np.isnan(lin_values) + + het_map_mesh = np.array(lin_values, copy=True) + het_map_mesh[ids_isnan] = nn_values[ids_isnan] + + # If vmin is not provided, use a value rounded to the nearest 0.01 below the minimum + if vmin is None: + vmin = np.floor(het_map_mesh.min() * 100) / 100 + + # If vmax is not provided, use a value rounded to the nearest 0.01 above the maximum + if vmax is None: + vmax = np.ceil(het_map_mesh.max() * 100) / 100 + + # Produce color plot of the speed multipliers + im = ax.tricontourf( + x, + y, + het_map_mesh, + cmap=cmap, + vmin=vmin, + vmax=vmax, + levels=50, + zorder=-1, + ) + + # Plot the grid coordinates as a scatter plot + ax.scatter(x, y, color="gray", marker=".", label="Heterogeneity Coordinates") + ax.set_xlim + + # Show the boundary + if show_boundary: + self.plot_heterogeneous_boundary(self.x, self.y, ax) + + # Add a colorbar + if show_colorbar: + fig.colorbar(im, ax=ax) + + # Set the x and y limits + ax.set_xlim(plot_min_x, plot_max_x) + ax.set_ylim(plot_min_y, plot_max_y) + + # Make equal axis + ax.set_aspect("equal") + + # Set the x and y labels + ax.set_xlabel("X (m)") + ax.set_ylabel("Y (m)") + + # Add the wind direction arrow + if show_wind_direction: + self.plot_wind_direction(ax, wind_direction) + + return ax diff --git a/floris/wind_data.py b/floris/wind_data.py index 1b0d11d00..926ca9e0e 100644 --- a/floris/wind_data.py +++ b/floris/wind_data.py @@ -11,6 +11,7 @@ from pandas.api.types import CategoricalDtype from scipy.interpolate import LinearNDInterpolator, NearestNDInterpolator +from floris.heterogeneous_map import HeterogeneousMap from floris.type_dec import NDArrayFloat @@ -59,34 +60,6 @@ def unpack_value(self): return self.unpack()[4] - def check_heterogeneous_inflow_config_by_wd(self, heterogeneous_inflow_config_by_wd): - """ - Check that the heterogeneous_inflow_config_by_wd dictionary is properly formatted - - Args: - heterogeneous_inflow_config_by_wd (dict): A dictionary containing the following keys: - * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) - of speed multipliers. - * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). - * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). - * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). - """ - if heterogeneous_inflow_config_by_wd is not None: - if not isinstance(heterogeneous_inflow_config_by_wd, dict): - raise TypeError("heterogeneous_inflow_config_by_wd must be a dictionary") - if "speed_multipliers" not in heterogeneous_inflow_config_by_wd: - raise ValueError( - "heterogeneous_inflow_config_by_wd must contain a key 'speed_multipliers'" - ) - if "wind_directions" not in heterogeneous_inflow_config_by_wd: - raise ValueError( - "heterogeneous_inflow_config_by_wd must contain a key 'wind_directions'" - ) - if "x" not in heterogeneous_inflow_config_by_wd: - raise ValueError("heterogeneous_inflow_config_by_wd must contain a key 'x'") - if "y" not in heterogeneous_inflow_config_by_wd: - raise ValueError("heterogeneous_inflow_config_by_wd must contain a key 'y'") - def check_heterogeneous_inflow_config(self, heterogeneous_inflow_config): """ Check that the heterogeneous_inflow_config dictionary is properly formatted @@ -110,62 +83,6 @@ def check_heterogeneous_inflow_config(self, heterogeneous_inflow_config): if "y" not in heterogeneous_inflow_config: raise ValueError("heterogeneous_inflow_config must contain a key 'y'") - def get_speed_multipliers_by_wd(self, heterogeneous_inflow_config_by_wd, wind_directions): - """ - Processes heterogeneous inflow configuration data to generate a speed multiplier array - aligned with the wind directions. Accounts for the cyclical nature of wind directions. - Args: - heterogeneous_inflow_config_by_wd (dict): A dictionary containing the following keys: - * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) - of speed multipliers. - * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). - * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). - * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). - - wind_directions (np.array): Wind directions to map onto - Returns: - numpy.ndarray: A 2D NumPy array (size n_findex x n) of speed multipliers - Each row corresponds to a wind direction, - with speed multipliers selected - based on the closest matching wind direction in 'het_wd'. - """ - - # Extract data from the configuration dictionary - speed_multipliers = np.array(heterogeneous_inflow_config_by_wd["speed_multipliers"]) - het_wd = np.array(heterogeneous_inflow_config_by_wd["wind_directions"]) - - # Confirm 0th dimension of speed_multipliers == len(het_wd) - if len(het_wd) != speed_multipliers.shape[0]: - raise ValueError( - "The legnth of het_wd must equal the number of rows speed_multipliers" - "Within the heterogeneous_inflow_config_by_wd dictionary" - ) - - # Calculate closest wind direction indices (accounting for angles) - angle_diffs = np.abs(wind_directions[:, None] - het_wd) - min_angle_diffs = np.minimum(angle_diffs, 360 - angle_diffs) - closest_wd_indices = np.argmin(min_angle_diffs, axis=1) - - # Construct the output array using the calculated indices - return speed_multipliers[closest_wd_indices] - - def get_heterogeneous_inflow_config(self, heterogeneous_inflow_config_by_wd, wind_directions): - # If heterogeneous_inflow_config_by_wd is None, return None - if heterogeneous_inflow_config_by_wd is None: - return None - - # If heterogeneous_inflow_config_by_wd is not None, then process it - # Build the n-findex version of the het map - speed_multipliers = self.get_speed_multipliers_by_wd( - heterogeneous_inflow_config_by_wd, wind_directions - ) - # Return heterogeneous_inflow_config - return { - "speed_multipliers": speed_multipliers, - "x": heterogeneous_inflow_config_by_wd["x"], - "y": heterogeneous_inflow_config_by_wd["y"], - } - class WindRose(WindDataBase): """ @@ -193,13 +110,22 @@ class WindRose(WindDataBase): each bin to compute the total value of the energy produced compute_zero_freq_occurrence: Flag indicating whether to compute zero frequency occurrences (bool, optional). Defaults to False. + heterogeneous_map (HeterogeneousMap, optional): A HeterogeneousMap object to define + background heterogeneous inflow condition as a function + of wind direction and wind speed. Alternatively, a dictionary can be + passed in to define a HeterogeneousMap object. Defaults to None. heterogeneous_inflow_config_by_wd (dict, optional): A dictionary containing the following - keys. Defaults to None. - * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) - of speed multipliers. - * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + which can be used to define a heterogeneous_map object (note this parameter is kept + for backwards compatibility and is not recommended for use): * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + * 'speed_multipliers': A 2D NumPy array (size num_wd (or num_ws) x num_points) + of speed multipliers. If neither wind_directions nor wind_speeds are + defined, then this should be a single row array + * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + Optional. + * 'wind_speeds': A 1D NumPy array (size num_ws) of wind speeds (m/s). Optional. + Defaults to None. """ @@ -211,6 +137,7 @@ def __init__( freq_table: NDArrayFloat | None = None, value_table: NDArrayFloat | None = None, compute_zero_freq_occurrence: bool = False, + heterogeneous_map: HeterogeneousMap | dict | None = None, heterogeneous_inflow_config_by_wd: dict | None = None, ): if not isinstance(wind_directions, np.ndarray): @@ -223,6 +150,10 @@ def __init__( self.wind_directions = wind_directions self.wind_speeds = wind_speeds + # Check ti_table is a float or a NumPy array + if not isinstance(ti_table, (float, np.ndarray)): + raise TypeError("ti_table must be a float or a NumPy array") + # Check if ti_table is a single float value if isinstance(ti_table, float): self.ti_table = np.full((len(wind_directions), len(wind_speeds)), ti_table) @@ -271,12 +202,40 @@ def __init__( ) self.compute_zero_freq_occurrence = compute_zero_freq_occurrence - # Check that heterogeneous_inflow_config_by_wd is a dictionary with keys: - # speed_multipliers, wind_directions, x and y - self.check_heterogeneous_inflow_config_by_wd(heterogeneous_inflow_config_by_wd) + # Check that heterogeneous_map and heterogeneous_inflow_config_by_wd are not both defined + if heterogeneous_map is not None and heterogeneous_inflow_config_by_wd is not None: + raise ValueError( + "Only one of heterogeneous_map and heterogeneous_inflow_config_by_wd can be" + +" defined." + ) + + # If heterogeneous_inflow_config_by_wd is not None, then create a HeterogeneousMap object + # using the dictionary + if heterogeneous_inflow_config_by_wd is not None: + # TODO: In future, add deprectation warning for this parameter here + + self.heterogeneous_map = HeterogeneousMap(**heterogeneous_inflow_config_by_wd) + + # Else if heterogeneous_map is not None + elif heterogeneous_map is not None: + # If heterogeneous_map is a dictionary, then create a HeterogeneousMap object + if isinstance(heterogeneous_map, dict): + self.heterogeneous_map = HeterogeneousMap(**heterogeneous_map) + + # Else if heterogeneous_map is a HeterogeneousMap object, then save it + elif isinstance(heterogeneous_map, HeterogeneousMap): + self.heterogeneous_map = heterogeneous_map + + # Else raise an error + else: + raise ValueError( + "heterogeneous_map must be a HeterogeneousMap object or a dictionary." + ) - # Then save - self.heterogeneous_inflow_config_by_wd = heterogeneous_inflow_config_by_wd + # Else if neither heterogeneous_map nor heterogeneous_inflow_config_by_wd are defined, + # then set heterogeneous_map to None + else: + self.heterogeneous_map = None # Build the gridded and flatten versions self._build_gridded_and_flattened_version() @@ -342,11 +301,10 @@ def unpack(self): else: value_table_unpack = None - # If heterogeneous_inflow_config_by_wd is not None, then update - # heterogeneous_inflow_config to match wind_directions_unpack - if self.heterogeneous_inflow_config_by_wd is not None: - heterogeneous_inflow_config = self.get_heterogeneous_inflow_config( - self.heterogeneous_inflow_config_by_wd, wind_directions_unpack + # If heterogeneous_map is not None, then get the heterogeneous_inflow_config + if self.heterogeneous_map is not None: + heterogeneous_inflow_config = self.heterogeneous_map.get_heterogeneous_inflow_config( + wind_directions=wind_directions_unpack, wind_speeds=wind_speeds_unpack ) else: heterogeneous_inflow_config = None @@ -428,7 +386,7 @@ def aggregate(self, wd_step=None, ws_step=None, inplace=False): self.ws_flat, self.ti_table_flat, self.value_table_flat, - self.heterogeneous_inflow_config_by_wd, + self.heterogeneous_map, ) # Now build a new wind rose using the new steps @@ -443,7 +401,7 @@ def aggregate(self, wd_step=None, ws_step=None, inplace=False): aggregated_wind_rose.freq_table, aggregated_wind_rose.value_table, aggregated_wind_rose.compute_zero_freq_occurrence, - aggregated_wind_rose.heterogeneous_inflow_config_by_wd, + aggregated_wind_rose.heterogeneous_map, ) else: return aggregated_wind_rose @@ -593,7 +551,7 @@ def resample_by_interpolation(self, wd_step=None, ws_step=None, method="linear", new_freq_matrix, new_value_matrix, self.compute_zero_freq_occurrence, - self.heterogeneous_inflow_config_by_wd, + self.heterogeneous_map, ) if inplace: @@ -604,7 +562,7 @@ def resample_by_interpolation(self, wd_step=None, ws_step=None, method="linear", resampled_wind_rose.freq_table, resampled_wind_rose.value_table, resampled_wind_rose.compute_zero_freq_occurrence, - resampled_wind_rose.heterogeneous_inflow_config_by_wd, + resampled_wind_rose.heterogeneous_map, ) else: return resampled_wind_rose @@ -976,13 +934,22 @@ class WindTIRose(WindDataBase): to compute the total value of the energy produced. compute_zero_freq_occurrence: Flag indicating whether to compute zero frequency occurrences (bool, optional). Defaults to False. + heterogeneous_map (HeterogeneousMap, optional): A HeterogeneousMap object to define + background heterogeneous inflow condition as a function + of wind direction and wind speed. Alternatively, a dictionary can be + passed in to define a HeterogeneousMap object. Defaults to None. heterogeneous_inflow_config_by_wd (dict, optional): A dictionary containing the following - keys. Defaults to None. - * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) - of speed multipliers. - * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + which can be used to define a heterogeneous_map object (note this parameter is kept + for backwards compatibility and is not recommended for use): * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + * 'speed_multipliers': A 2D NumPy array (size num_wd (or num_ws) x num_points) + of speed multipliers. If neither wind_directions nor wind_speeds are + defined, then this should be a single row array + * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + Optional. + * 'wind_speeds': A 1D NumPy array (size num_ws) of wind speeds (m/s). Optional. + Defaults to None. """ @@ -994,6 +961,7 @@ def __init__( freq_table: NDArrayFloat | None = None, value_table: NDArrayFloat | None = None, compute_zero_freq_occurrence: bool = False, + heterogeneous_map: HeterogeneousMap | dict | None = None, heterogeneous_inflow_config_by_wd: dict | None = None, ): if not isinstance(wind_directions, np.ndarray): @@ -1043,16 +1011,44 @@ def __init__( ) self.value_table = value_table - # Check that heterogeneous_inflow_config_by_wd is a dictionary with keys: - # speed_multipliers, wind_directions, x and y - self.check_heterogeneous_inflow_config_by_wd(heterogeneous_inflow_config_by_wd) - - # Then save - self.heterogeneous_inflow_config_by_wd = heterogeneous_inflow_config_by_wd - # Save whether zero occurrence cases should be computed self.compute_zero_freq_occurrence = compute_zero_freq_occurrence + # Check that heterogeneous_map and heterogeneous_inflow_config_by_wd are not both defined + if heterogeneous_map is not None and heterogeneous_inflow_config_by_wd is not None: + raise ValueError( + "Only one of heterogeneous_map and heterogeneous_inflow_config_by_wd can be" + +" defined." + ) + + # If heterogeneous_inflow_config_by_wd is not None, then create a HeterogeneousMap object + # using the dictionary + if heterogeneous_inflow_config_by_wd is not None: + # TODO: In future, add deprectation warning for this parameter here + + self.heterogeneous_map = HeterogeneousMap(**heterogeneous_inflow_config_by_wd) + + # Else if heterogeneous_map is not None + elif heterogeneous_map is not None: + # If heterogeneous_map is a dictionary, then create a HeterogeneousMap object + if isinstance(heterogeneous_map, dict): + self.heterogeneous_map = HeterogeneousMap(**heterogeneous_map) + + # Else if heterogeneous_map is a HeterogeneousMap object, then save it + elif isinstance(heterogeneous_map, HeterogeneousMap): + self.heterogeneous_map = heterogeneous_map + + # Else raise an error + else: + raise ValueError( + "heterogeneous_map must be a HeterogeneousMap object or a dictionary." + ) + + # Else if neither heterogeneous_map nor heterogeneous_inflow_config_by_wd are defined, + # then set heterogeneous_map to None + else: + self.heterogeneous_map = None + # Build the gridded and flatten versions self._build_gridded_and_flattened_version() @@ -1115,11 +1111,10 @@ def unpack(self): else: value_table_unpack = None - # If heterogeneous_inflow_config_by_wd is not None, then update - # heterogeneous_inflow_config to match wind_directions_unpack - if self.heterogeneous_inflow_config_by_wd is not None: - heterogeneous_inflow_config = self.get_heterogeneous_inflow_config( - self.heterogeneous_inflow_config_by_wd, wind_directions_unpack + # If heterogeneous_map is not None, then get the heterogeneous_inflow_config + if self.heterogeneous_map is not None: + heterogeneous_inflow_config = self.heterogeneous_map.get_heterogeneous_inflow_config( + wind_directions=wind_directions_unpack, wind_speeds=wind_speeds_unpack ) else: heterogeneous_inflow_config = None @@ -1215,7 +1210,7 @@ def aggregate(self, wd_step=None, ws_step=None, ti_step=None, inplace=False): self.ws_flat, self.ti_flat, self.value_table_flat, - self.heterogeneous_inflow_config_by_wd, + self.heterogeneous_map, ) # Now build a new wind rose using the new steps @@ -1231,7 +1226,7 @@ def aggregate(self, wd_step=None, ws_step=None, ti_step=None, inplace=False): aggregated_wind_rose.freq_table, aggregated_wind_rose.value_table, aggregated_wind_rose.compute_zero_freq_occurrence, - aggregated_wind_rose.heterogeneous_inflow_config_by_wd, + aggregated_wind_rose.heterogeneous_map, ) else: return aggregated_wind_rose @@ -1436,7 +1431,7 @@ def resample_by_interpolation( new_freq_matrix, new_value_matrix, self.compute_zero_freq_occurrence, - self.heterogeneous_inflow_config_by_wd, + self.heterogeneous_map, ) if inplace: @@ -1447,7 +1442,7 @@ def resample_by_interpolation( resampled_wind_rose.freq_table, resampled_wind_rose.value_table, resampled_wind_rose.compute_zero_freq_occurrence, - resampled_wind_rose.heterogeneous_inflow_config_by_wd, + resampled_wind_rose.heterogeneous_map, ) else: return resampled_wind_rose @@ -1788,13 +1783,22 @@ class TimeSeries(WindDataBase): a single value or an array of values. values (NDArrayFloat, optional): Values associated with each wind direction, wind speed, and turbulence intensity. Defaults to None. + heterogeneous_map (HeterogeneousMap, optional): A HeterogeneousMap object to define + background heterogeneous inflow condition as a function + of wind direction and wind speed. Alternatively, a dictionary can be + passed in to define a HeterogeneousMap object. Defaults to None. heterogeneous_inflow_config_by_wd (dict, optional): A dictionary containing the following - keys. Defaults to None. - * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) - of speed multipliers. - * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + which can be used to define a heterogeneous_map object (note this parameter is kept + for backwards compatibility and is not recommended for use): * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + * 'speed_multipliers': A 2D NumPy array (size num_wd (or num_ws) x num_points) + of speed multipliers. If neither wind_directions nor wind_speeds are + defined, then this should be a single row array + * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + Optional. + * 'wind_speeds': A 1D NumPy array (size num_ws) of wind speeds (m/s). Optional. + Defaults to None. heterogeneous_inflow_config (dict, optional): A dictionary containing the following keys. Defaults to None. * 'speed_multipliers': A 2D NumPy array (size n_findex x num_points) @@ -1809,9 +1813,19 @@ def __init__( wind_speeds: float | NDArrayFloat, turbulence_intensities: float | NDArrayFloat, values: NDArrayFloat | None = None, + heterogeneous_map: HeterogeneousMap | dict | None = None, heterogeneous_inflow_config_by_wd: dict | None = None, heterogeneous_inflow_config: dict | None = None, ): + # Check that wind_directions, wind_speeds, and turbulence_intensities are either numpy array + # of floats + if not isinstance(wind_directions, (float, np.ndarray)): + raise TypeError("wind_directions must be a float or a NumPy array") + if not isinstance(wind_speeds, (float, np.ndarray)): + raise TypeError("wind_speeds must be a float or a NumPy array") + if not isinstance(turbulence_intensities, (float, np.ndarray)): + raise TypeError("turbulence_intensities must be a float or a NumPy array") + # At least one of wind_directions, wind_speeds, or turbulence_intensities must be an array if ( not isinstance(wind_directions, np.ndarray) @@ -1878,15 +1892,21 @@ def __init__( self.turbulence_intensities = turbulence_intensities self.values = values - # Only one of heterogeneous_inflow_config_by_wd and - # heterogeneous_inflow_config can be not None + # Check that at most one of heterogeneous_inflow_config_by_wd, + # heterogeneous_map and heterogeneous_inflow_config is not None if ( - heterogeneous_inflow_config_by_wd is not None - and heterogeneous_inflow_config is not None + sum( + [ + heterogeneous_inflow_config_by_wd is not None, + heterogeneous_map is not None, + heterogeneous_inflow_config is not None, + ] + ) + > 1 ): raise ValueError( - "Only one of heterogeneous_inflow_config_by_wd and heterogeneous_inflow_config " - "can be not None" + "Only one of heterogeneous_inflow_config_by_wd, " + +"heterogeneous_map, and heterogeneous_inflow_config can be not None." ) # if heterogeneous_inflow_config is not None, then the speed_multipliers @@ -1896,14 +1916,39 @@ def __init__( if len(heterogeneous_inflow_config["speed_multipliers"]) != len(wind_directions): raise ValueError("speed_multipliers must be the same length as wind_directions") - # Check that heterogeneous_inflow_config_by_wd is a dictionary with keys: - # speed_multipliers, wind_directions, x and y - self.check_heterogeneous_inflow_config_by_wd(heterogeneous_inflow_config_by_wd) - self.check_heterogeneous_inflow_config(heterogeneous_inflow_config) + # Check heterogeneous_inflow_config and save + self.check_heterogeneous_inflow_config(heterogeneous_inflow_config) + self.heterogeneous_inflow_config = heterogeneous_inflow_config + else: + self.heterogeneous_inflow_config = None + + # If heterogeneous_inflow_config_by_wd is not None, then create a HeterogeneousMap object + # using the dictionary + if heterogeneous_inflow_config_by_wd is not None: + # TODO: In future, add deprectation warning for this parameter here + + self.heterogeneous_map = HeterogeneousMap(**heterogeneous_inflow_config_by_wd) + + # Else if heterogeneous_map is not None + elif heterogeneous_map is not None: + # If heterogeneous_map is a dictionary, then create a HeterogeneousMap object + if isinstance(heterogeneous_map, dict): + self.heterogeneous_map = HeterogeneousMap(**heterogeneous_map) + + # Else if heterogeneous_map is a HeterogeneousMap object, then save it + elif isinstance(heterogeneous_map, HeterogeneousMap): + self.heterogeneous_map = heterogeneous_map - # Then save - self.heterogeneous_inflow_config_by_wd = heterogeneous_inflow_config_by_wd - self.heterogeneous_inflow_config = heterogeneous_inflow_config + # Else raise an error + else: + raise ValueError( + "heterogeneous_map must be a HeterogeneousMap object or a dictionary." + ) + + # Else if neither heterogeneous_map nor heterogeneous_inflow_config_by_wd are defined, + # then set heterogeneous_map to None + else: + self.heterogeneous_map = None # Record findex self.n_findex = len(self.wind_directions) @@ -1917,11 +1962,11 @@ def unpack(self): uniform_frequency = np.ones_like(self.wind_directions) uniform_frequency = uniform_frequency / uniform_frequency.sum() - # If heterogeneous_inflow_config_by_wd is not None, then update + # If heterogeneous_map is not None, then update # heterogeneous_inflow_config to match wind_directions_unpack - if self.heterogeneous_inflow_config_by_wd is not None: - heterogeneous_inflow_config = self.get_heterogeneous_inflow_config( - self.heterogeneous_inflow_config_by_wd, self.wind_directions + if self.heterogeneous_map is not None: + heterogeneous_inflow_config = self.heterogeneous_map.get_heterogeneous_inflow_config( + wind_directions=self.wind_directions, wind_speeds=self.wind_speeds ) else: heterogeneous_inflow_config = self.heterogeneous_inflow_config @@ -2194,7 +2239,7 @@ def to_WindRose(self, wd_step=2.0, ws_step=1.0, wd_edges=None, ws_edges=None, bi ti_table, freq_table, value_table, - self.heterogeneous_inflow_config_by_wd, + self.heterogeneous_map, ) def to_WindTIRose( @@ -2361,5 +2406,5 @@ def to_WindTIRose( ti_centers, freq_table, value_table, - self.heterogeneous_inflow_config_by_wd, + self.heterogeneous_map, ) diff --git a/tests/heterogeneous_map_integration_test.py b/tests/heterogeneous_map_integration_test.py new file mode 100644 index 000000000..9fd232d58 --- /dev/null +++ b/tests/heterogeneous_map_integration_test.py @@ -0,0 +1,234 @@ +import numpy as np +import pytest + +from floris.heterogeneous_map import HeterogeneousMap + + +def test_declare_by_parameters(): + HeterogeneousMap( + x=np.array([0.0, 0.0, 500.0, 500.0]), + y=np.array([0.0, 500.0, 0.0, 500.0]), + speed_multipliers=np.array( + [ + [1.0, 1.0, 1.0, 1.0], + [1.0, 1.25, 1.0, 1.25], + [1.0, 1.0, 1.0, 1.25], + [1.0, 1.0, 1.0, 1.0], + ] + ), + wind_directions=np.array([0.0, 0.0, 90.0, 90.0]), + wind_speeds=np.array([5.0, 15.0, 5.0, 15.0]), + ) + +def test_heterogeneous_map_no_ws_no_wd(): + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + [1.1, 1.1, 1.1], + [1.3, 1.4, 1.5], + ] + ), + } + + # Should be single value if no wind_directions or wind_speeds + with pytest.raises(ValueError): + HeterogeneousMap(**heterogeneous_map_config) + + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array([[1.0, 1.1, 1.2]]), + } + + HeterogeneousMap(**heterogeneous_map_config) + + +def test_wind_direction_and_wind_speed_sizes(): + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + [1.1, 1.1, 1.1], + [1.3, 1.4, 1.5], + ] + ), + "wind_directions": np.array([0.0, 90.0]), + "wind_speeds": np.array([10.0, 20.0, 30.0]), + } + + # Should raise value error because wind_directions and wind_speeds are not the same size + with pytest.raises(ValueError): + HeterogeneousMap(**heterogeneous_map_config) + + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + [1.1, 1.1, 1.1], + [1.3, 1.4, 1.5], + ] + ), + "wind_directions": np.array([0.0, 90.0]), + "wind_speeds": np.array([10.0, 20.0]), + } + + # Should raise value error because wind_directions and wind_speeds are not = to the + # size of speed_multipliers in the 0th dimension + with pytest.raises(ValueError): + HeterogeneousMap(**heterogeneous_map_config) + + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + [1.1, 1.1, 1.1], + [1.3, 1.4, 1.5], + ] + ), + "wind_directions": np.array([0.0, 90.0, 270.0]), + "wind_speeds": np.array([10.0, 20.0, 15.0]), + } + + HeterogeneousMap(**heterogeneous_map_config) + + +def test_wind_direction_and_wind_speed_unique(): + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + [1.1, 1.1, 1.1], + [1.3, 1.4, 1.5], + ] + ), + "wind_directions": np.array([0.0, 0.0, 270.0]), + "wind_speeds": np.array([10.0, 10.0, 15.0]), + } + + # Raises error because of repeated wd/ws pair + with pytest.raises(ValueError): + HeterogeneousMap(**heterogeneous_map_config) + + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + [1.1, 1.1, 1.1], + [1.3, 1.4, 1.5], + ] + ), + "wind_directions": np.array([0.0, 5.0, 270.0]), + "wind_speeds": np.array([10.0, 10.0, 15.0]), + } + + # Should not raise error + HeterogeneousMap(**heterogeneous_map_config) + + +def test_get_heterogeneous_inflow_config_by_wind_direction(): + # Test the function when only wind_directions is defined + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + [1.1, 1.1, 1.1], + [1.3, 1.4, 1.5], + ] + ), + "wind_directions": np.array([0, 90, 270]), + } + + # Check for correctness + wind_directions = np.array([240, 80, 15]) + wind_speeds = np.array([10.0, 20.0, 15.0]) + expected_output = np.array([[1.3, 1.4, 1.5], [1.1, 1.1, 1.1], [1.0, 1.1, 1.2]]) + + hm = HeterogeneousMap(**heterogeneous_map_config) + output_dict = hm.get_heterogeneous_inflow_config(wind_directions, wind_speeds) + assert np.allclose(output_dict["speed_multipliers"], expected_output) + + +def test_get_heterogeneous_inflow_config_by_wind_speed(): + # Test the function when only wind_directions is defined + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + [1.1, 1.1, 1.1], + [1.3, 1.4, 1.5], + ] + ), + "wind_speeds": np.array([0, 10, 20]), + } + + # Check for correctness + wind_directions = np.array([240, 80, 15]) + wind_speeds = np.array([10.0, 10.0, 18.0]) + expected_output = np.array([[1.1, 1.1, 1.1], [1.1, 1.1, 1.1], [1.3, 1.4, 1.5]]) + + hm = HeterogeneousMap(**heterogeneous_map_config) + output_dict = hm.get_heterogeneous_inflow_config(wind_directions, wind_speeds) + assert np.allclose(output_dict["speed_multipliers"], expected_output) + + +def test_get_heterogeneous_inflow_config_by_wind_direction_and_wind_speed(): + # Test the function when only wind_directions is defined + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [[1.0, 1.1, 1.2], [1.1, 1.1, 1.1], [1.3, 1.4, 1.5], [1.4, 1.5, 1.6]] + ), + "wind_directions": np.array([0, 0, 90, 90]), + "wind_speeds": np.array([5.0, 15.0, 5.0, 15.0]), + } + + hm = HeterogeneousMap(**heterogeneous_map_config) + + # Check for correctness + wind_directions = np.array([91, 89, 350]) + wind_speeds = np.array([4.0, 18.0, 12.0]) + expected_output = np.array([[1.3, 1.4, 1.5], [1.4, 1.5, 1.6], [1.1, 1.1, 1.1]]) + + output_dict = hm.get_heterogeneous_inflow_config(wind_directions, wind_speeds) + assert np.allclose(output_dict["speed_multipliers"], expected_output) + + +def test_get_heterogeneous_inflow_config_no_wind_direction_no_wind_speed(): + # Test the function when only wind_directions is defined + heterogeneous_map_config = { + "x": np.array([0.0, 1.0, 2.0]), + "y": np.array([0.0, 1.0, 2.0]), + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + ] + ), + } + + hm = HeterogeneousMap(**heterogeneous_map_config) + + # Check for correctness + wind_directions = np.array([91, 89, 350]) + wind_speeds = np.array([4.0, 18.0, 12.0]) + expected_output = np.array([[1.0, 1.1, 1.2], [1.0, 1.1, 1.2], [1.0, 1.1, 1.2]]) + + output_dict = hm.get_heterogeneous_inflow_config(wind_directions, wind_speeds) + assert np.allclose(output_dict["speed_multipliers"], expected_output) diff --git a/tests/wind_data_integration_test.py b/tests/wind_data_integration_test.py index b2104abb2..71a0d2cf6 100644 --- a/tests/wind_data_integration_test.py +++ b/tests/wind_data_integration_test.py @@ -663,50 +663,49 @@ def test_time_series_to_WindTIRose(): np.testing.assert_almost_equal(freq_table[0, 1, :], [0, 0]) -def test_get_speed_multipliers_by_wd(): - heterogeneous_inflow_config_by_wd = { + +def test_gen_heterogeneous_inflow_config(): + wind_directions = np.array([259.8, 260.2, 260.3, 260.1, 270.0]) + wind_speeds = 8.0 + turbulence_intensities = 0.06 + + heterogeneous_map_config = { "speed_multipliers": np.array( [ - [1.0, 1.1, 1.2], - [1.1, 1.1, 1.1], - [1.3, 1.4, 1.5], + [0.9, 0.9], + [1.0, 1.0], + [1.1, 1.2], ] ), - "wind_directions": np.array([0, 90, 270]), + "wind_directions": np.array([250, 260, 270]), + "x": np.array([0, 1000]), + "y": np.array([0, 0]), } - # Check for correctness - wind_directions = np.array([240, 80, 15]) - expected_output = np.array([[1.3, 1.4, 1.5], [1.1, 1.1, 1.1], [1.0, 1.1, 1.2]]) - wind_data = WindDataBase() - result = wind_data.get_speed_multipliers_by_wd( - heterogeneous_inflow_config_by_wd, wind_directions + time_series = TimeSeries( + wind_directions, + wind_speeds, + turbulence_intensities=turbulence_intensities, + heterogeneous_map=heterogeneous_map_config, ) - assert np.allclose(result, expected_output) - # Confirm wrapping behavior - wind_directions = np.array([350, 10]) - expected_output = np.array([[1.0, 1.1, 1.2], [1.0, 1.1, 1.2]]) - result = wind_data.get_speed_multipliers_by_wd( - heterogeneous_inflow_config_by_wd, wind_directions - ) - assert np.allclose(result, expected_output) + (_, _, _, _, _, heterogeneous_inflow_config) = time_series.unpack() - # Confirm can expand the result to match wind directions - wind_directions = np.arange(0.0, 360.0, 10.0) - num_wd = len(wind_directions) - result = wind_data.get_speed_multipliers_by_wd( - heterogeneous_inflow_config_by_wd, wind_directions + expected_result = np.array([[1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.1, 1.2]]) + np.testing.assert_allclose(heterogeneous_inflow_config["speed_multipliers"], expected_result) + np.testing.assert_allclose( + heterogeneous_inflow_config["x"], heterogeneous_inflow_config["x"] ) - assert result.shape[0] == num_wd -def test_gen_heterogeneous_inflow_config(): - wind_directions = np.array([259.8, 260.2, 260.3, 260.1, 270.0]) - wind_speeds = 8 - turbulence_intensities = 0.06 +def test_heterogeneous_inflow_config_by_wd(): + # Show that passing the config dict to the old heterogeneous_inflow_config_by_wd input + # is equivalent to passing it to the heterogeneous_map input + + wind_directions = np.array([250.0, 260.0]) + wind_speeds = np.array([8.0]) - heterogeneous_inflow_config_by_wd = { + heterogeneous_map_config = { "speed_multipliers": np.array( [ [0.9, 0.9], @@ -719,21 +718,87 @@ def test_gen_heterogeneous_inflow_config(): "y": np.array([0, 0]), } - time_series = TimeSeries( + # Using heterogeneous_map input + time_series = WindRose( wind_directions, wind_speeds, - turbulence_intensities=turbulence_intensities, - heterogeneous_inflow_config_by_wd=heterogeneous_inflow_config_by_wd, + ti_table=0.06, + heterogeneous_map=heterogeneous_map_config, + ) + + (_, _, _, _, _, heterogeneous_inflow_config_a) = time_series.unpack() + + # Using heterogeneous_inflow_config_by_wd input + time_series = WindRose( + wind_directions, + wind_speeds, + ti_table=0.06, + heterogeneous_inflow_config_by_wd=heterogeneous_map_config, + ) + + (_, _, _, _, _, heterogeneous_inflow_config_b) = time_series.unpack() + + np.testing.assert_allclose( + heterogeneous_inflow_config_a["speed_multipliers"], + heterogeneous_inflow_config_b["speed_multipliers"], + ) + + +def test_gen_heterogeneous_inflow_config_with_wind_directions_and_wind_speeds(): + heterogeneous_map_config = { + "speed_multipliers": np.array( + [ + [0.9, 0.9], + [1.0, 1.0], + [1.1, 1.2], + [1.2, 1.3] + ] + ), + "wind_directions": np.array([250, 260, 250, 260]), + "wind_speeds": np.array([5, 5, 10, 10]), + "x": np.array([0, 1000]), + "y": np.array([0, 0]), + } + + time_series = TimeSeries( + wind_directions = np.array([259.8, 260.2, 260.3, 260.1, 200.0]), + wind_speeds = np.array([4, 9, 4, 9, 4]), + turbulence_intensities=0.06, + heterogeneous_map=heterogeneous_map_config, ) (_, _, _, _, _, heterogeneous_inflow_config) = time_series.unpack() - expected_result = np.array([[1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.1, 1.2]]) + expected_result = np.array([[1.0, 1.0],[1.2, 1.3],[1.0, 1.0],[1.2, 1.3],[0.9, 0.9]]) np.testing.assert_allclose(heterogeneous_inflow_config["speed_multipliers"], expected_result) - np.testing.assert_allclose( - heterogeneous_inflow_config["x"], heterogeneous_inflow_config_by_wd["x"] + +def test_gen_heterogeneous_inflow_config_with_wind_directions_and_wind_speeds_wind_rose(): + heterogeneous_map_config = { + "speed_multipliers": np.array( + [ + [0.9, 0.9], + [1.0, 1.0], + [1.1, 1.2], + [1.2, 1.3] + ] + ), + "wind_directions": np.array([250, 260, 250, 260]), + "wind_speeds": np.array([5, 5, 10, 10]), + "x": np.array([0, 1000]), + "y": np.array([0, 0]), + } + + wind_rose = WindRose( + wind_directions = np.array([250.0, 260.]), + wind_speeds = np.array([9.0]), + ti_table=0.06, + heterogeneous_map=heterogeneous_map_config, ) + (_, _, _, _, _, heterogeneous_inflow_config) = wind_rose.unpack() + + expected_result = np.array([[1.1, 1.2], [1.2, 1.3]]) + np.testing.assert_allclose(heterogeneous_inflow_config["speed_multipliers"], expected_result) def test_read_csv_long(): # Read in the wind rose data from the csv file From 0eb35f9f8c4ee648e23067696d95b60f2500c99b Mon Sep 17 00:00:00 2001 From: jfrederik-nrel <120053750+jfrederik-nrel@users.noreply.github.com> Date: Thu, 16 May 2024 17:27:20 -0600 Subject: [PATCH 07/12] Fix typo in Empirical Gauss Model documentation --- docs/empirical_gauss_model.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/empirical_gauss_model.md b/docs/empirical_gauss_model.md index 1f9091482..daf216288 100644 --- a/docs/empirical_gauss_model.md +++ b/docs/empirical_gauss_model.md @@ -172,7 +172,7 @@ The effect of AWC is represented by updating the wake-induced mixing term as follows: $$ \text{WIM}_j = \sum_{i \in T^{\text{up}}(j)} \frac{A_{ij} a_i} {(x_j - x_i)/D_i} + -\frac{\beta_{j}^{p}{d}$$ +\frac{\beta_{j}^{p}}{d}$$ where $\beta_{j}$ is the AWC amplitude of turbine $j$, and the exponent $p$ and denominator $d$ are tuning parameters that can be set in the `emgauss.yaml` file with From 7fa3bf16b84e6fae70b244b82fdf83a5accb4f59 Mon Sep 17 00:00:00 2001 From: paulf81 Date: Fri, 24 May 2024 11:39:04 -0600 Subject: [PATCH 08/12] Randomized layout optimization (#697) * Add random optimization class * Add temporary example * rename example * Adding support for arbitrary pmf. * Plotting for pmf; update example. * Respecting new examples in develop. * Update base class to handle multiple regions of layout optimization. * geoyaw option added. * Terminology change: particle -> individual. * Adding functionality for plotting the optimization boundary only. * Adding grid. * Adding visualizations. * Allow random seed setting; non-parallel runs; log status. * Updating link to Stanleys published paper. * Enabling geometric yaw option. * WIP; storing for hotfix. * Bug fixed: updating layout when called. * Ruff * fi_subset needed updating rather than fi. * WIP commit to change branch. * runs. * Store initial aep correctly. * Minor update to defualt pmf' * Runs, but freq data not passed correctly. * Pipe through wind_data for freq information. * Move example to subdirectory. * Ruff. * Working on adding tests; still some work to do on value optimization. * Enable value optimization. * Handling TODO items * UserWarning -> ValueError; logger.warnings * Simple documentation added. * White space in docs. * Remove cm.get_cmap in favor of plt.get_cmap * Improve documentation and example. * renable geometric yaw option for v4; fix scipy layoutopt args. * remove self.x and self.y after initialization. * Improve progress plots and add to example. --------- Co-authored-by: misi9170 --- docs/_toc.yml | 1 + docs/layout_optimization.md | 81 ++ docs/plot_complex_docs.png | Bin 0 -> 147382 bytes .../003_genetic_random_search.py | 82 ++ floris/flow_visualization.py | 2 +- .../layout_optimization_base.py | 147 +++- .../layout_optimization_pyoptsparse.py | 6 +- .../layout_optimization_random_search.py | 707 ++++++++++++++++++ .../layout_optimization_scipy.py | 61 +- .../yaw_optimizer_geometric.py | 2 + floris/wind_data.py | 5 +- tests/layout_optimization_integration_test.py | 22 + ...andom_search_layout_opt_regression_test.py | 142 ++++ 13 files changed, 1202 insertions(+), 56 deletions(-) create mode 100644 docs/layout_optimization.md create mode 100644 docs/plot_complex_docs.png create mode 100644 examples/examples_layout_optimization/003_genetic_random_search.py create mode 100644 floris/optimization/layout_optimization/layout_optimization_random_search.py create mode 100644 tests/reg_tests/random_search_layout_opt_regression_test.py diff --git a/docs/_toc.yml b/docs/_toc.yml index 784be504d..4b78b0821 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -18,6 +18,7 @@ parts: - file: floating_wind_turbine - file: turbine_interaction - file: operation_models_user + - file: layout_optimization - file: input_reference_main - file: input_reference_turbine - file: examples diff --git a/docs/layout_optimization.md b/docs/layout_optimization.md new file mode 100644 index 000000000..361856579 --- /dev/null +++ b/docs/layout_optimization.md @@ -0,0 +1,81 @@ + +(layout_optimization)= +# Layout optimization + +The FLORIS package provides layout optimization tools to place turbines within a specified +boundary area to optimize annual energy production (AEP) or wind plant value. Layout +optimizers accept an instantiated `FlorisModel` and alter the turbine layouts in order to +improve the objective function value (AEP or value). + +## Background + +Layout optimization entails placing turbines in a wind farm in a configuration that maximizes +an objective function, usually the AEP. Turbines are moved to minimize their wake interactions +in the most dominant wind directions, while respecting the boundaries of the area for turbine +placement as well as minimum distance requirements between neighboring turbines. + +Mathematically, we represent this as a (nonconvex) optimization problem. +Let $x = \{x_i\}_{i=1,\dots,N}$, $x_i \in \mathbb{R}^2$ represent the set of +coordinates of turbines within a farm (that is, $x_i$ represents the $(X, Y)$ +location of turbine $i$). Further, let $R \subset \mathbb{R}^2$ be a closed +region in which to place turbines. Finally, let $d$ represent the minimum +allowable distance between two turbines. Then, the layout optimization problem +is expressed as + +$$ +\begin{aligned} +\underset{x}{\text{maximize}} & \:\: f(x)\\ +\text{subject to} & \:\: x \subset R \\ +& \:\: ||x_i - x_j|| \geq d \:\: \forall j = 1,\dots,N, j\neq i +\end{aligned} +$$ + +Here, $||\cdot||$ denotes the Euclidean norm, and $f(x)$ is the cost function to be maximized. + +When maximizing the AEP, $f = \sum_w P(w, x)p_W(w)$, where $w$ is the wind condition bin +(e.g., wind speed, wind direction pair); $P(w, x)$ is the power produced by the wind farm in +condition $w$ with layout $x$; and $p_W(w)$ is the annual frequency of occurrence of +condition $w$. + +Layout optimizers take iterative approaches to solving the layout optimization problem +specified above. Optimization routines available in FLORIS are described below. + +## Scipy layout optimization +The `LayoutOptimizationScipy` class is built around `scipy.optimize`s `minimize` +routine, using the `SLSQP` solver by default. Options for adjusting +`minimize`'s behavior are exposed to the user with the `optOptions` argument. +Other options include enabling fast wake steering at each layout optimizer +iteration with the `enable_geometric_yaw` argument, and switch from AEP +optimization to value optimization with the `use_value` argument. + +## Genetic random search layout optimization +The `LayoutOptimizationRandomSearch` class is a custom optimizer designed specifically for +layout optimization via random perturbations of the turbine locations. It is designed to have +the following features: +- Robust to complex wind conditions and complex boundaries, including disjoint regions for +turbine placement +- Easy to parallelize and wrapped in a genetic algorithm for propagating candidate solutions +- Simple to set up and tune for non-optimization experts +- Set up to run cheap constraint checks prior to more expensive objective function evaluations +to accelerate optimization + +The algorithm, described in full in an upcoming paper that will be linked here when it is +publicly available, moves a random turbine and random distance in a random direction; checks +that constraints are satisfied; evaluates the objective function (AEP or value); and then +commits to the move if there is an objective function improvement. The main tuning parameter +is the probability mass function for the random movement distance, which is a dictionary to be +passed to the `distance_pmf` argument. + +The `distance_pmf` dictionary should contain two keys, each containing a 1D array of equal +length: `"d"`, which specifies the perturbation distance _in units of the rotor diameter_, +and `"p"`, which specifies the probability that the corresponding perturbation distance is +chosen at any iteration of the random search algorithm. The `distance_pmf` can therefore be +used to encourage or discourage more aggressive or more conservative movements, and to enable +or disable jumps between disjoint regions for turbine placement. + +The figure below shows an example of the optimized layout of a farm using the GRS algorithm, with +the black dots indicating the initial layout; red dots indicating the final layout; and blue +shading indicating wind speed heterogeneity (lighter shade is lower wind speed, darker shade is +higher wind speed). The progress of each of the genetic individuals in the optimization process is +shown in the right-hand plot. +![](plot_complex_docs.png) diff --git a/docs/plot_complex_docs.png b/docs/plot_complex_docs.png new file mode 100644 index 0000000000000000000000000000000000000000..bd4871298dc5e5e3bf74e6f2e49b47d000e41058 GIT binary patch literal 147382 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

Vb4RMHi&tp=l(H+f*xS(3ev20ugiI5X5eR#p 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 aTGU9`r)EUSzBz{;OG{JlMCS3!zy2Ra?MEg6 literal 0 HcmV?d00001 diff --git a/examples/examples_layout_optimization/003_genetic_random_search.py b/examples/examples_layout_optimization/003_genetic_random_search.py new file mode 100644 index 000000000..0955f151e --- /dev/null +++ b/examples/examples_layout_optimization/003_genetic_random_search.py @@ -0,0 +1,82 @@ +"""Example: Layout optimization with genetic random search +This example shows a layout optimization using the genetic random search +algorithm. It provides options for the users to try different distance +probability mass functions for the random search perturbations. +""" + +import matplotlib.pyplot as plt +import numpy as np +from scipy.stats import gamma + +from floris import FlorisModel, WindRose +from floris.optimization.layout_optimization.layout_optimization_random_search import ( + LayoutOptimizationRandomSearch, +) + + +if __name__ == '__main__': + # Set up FLORIS + fmodel = FlorisModel('../inputs/gch.yaml') + + + # Setup 72 wind directions with a random wind speed and frequency distribution + wind_directions = np.arange(0, 360.0, 5.0) + np.random.seed(1) + wind_speeds = 8.0 + np.random.randn(1) * 0.0 + # Shape frequency distribution to match number of wind directions and wind speeds + freq = ( + np.abs( + np.sort( + np.random.randn(len(wind_directions)) + ) + ) + .reshape( ( len(wind_directions), len(wind_speeds) ) ) + ) + freq = freq / freq.sum() + fmodel.set( + wind_data=WindRose( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + freq_table=freq, + ti_table=0.06 + ) + ) + + # Set the boundaries + # The boundaries for the turbines, specified as vertices + boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] + + # Set turbine locations to 4 turbines in a rectangle + D = 126.0 # rotor diameter for the NREL 5MW + layout_x = [0, 0, 6 * D, 6 * D] + layout_y = [0, 4 * D, 0, 4 * D] + fmodel.set(layout_x=layout_x, layout_y=layout_y) + + # Perform the optimization + distance_pmf = None + + # Other options that users can try + # 1. + # distance_pmf = {"d": [100, 1000], "p": [0.8, 0.2]} + # 2. + # p = gamma.pdf(np.linspace(0, 900, 91), 15, scale=20); p = p/p.sum() + # distance_pmf = {"d": np.linspace(100, 1000, 91), "p": p} + + layout_opt = LayoutOptimizationRandomSearch( + fmodel, + boundaries, + min_dist_D=5., + seconds_per_iteration=10, + total_optimization_seconds=60., + distance_pmf=distance_pmf + ) + layout_opt.describe() + layout_opt.plot_distance_pmf() + + layout_opt.optimize() + + layout_opt.plot_layout_opt_results() + + layout_opt.plot_progress() + + plt.show() diff --git a/floris/flow_visualization.py b/floris/flow_visualization.py index 57ae105a9..b893b172a 100644 --- a/floris/flow_visualization.py +++ b/floris/flow_visualization.py @@ -369,7 +369,7 @@ def plot_rotor_values( plot_rotor_values(floris.flow_field.w, findex=0, n_rows=1, ncols=4, show=True) """ - cmap = plt.cm.get_cmap(name=cmap) + cmap = plt.get_cmap(name=cmap) if t_range is None: t_range = range(values.shape[1]) diff --git a/floris/optimization/layout_optimization/layout_optimization_base.py b/floris/optimization/layout_optimization/layout_optimization_base.py index dd9afaae3..99977c2f5 100644 --- a/floris/optimization/layout_optimization/layout_optimization_base.py +++ b/floris/optimization/layout_optimization/layout_optimization_base.py @@ -1,7 +1,7 @@ import matplotlib.pyplot as plt import numpy as np -from shapely.geometry import LineString, Polygon +from shapely.geometry import MultiPolygon, Polygon from floris import TimeSeries from floris.optimization.yaw_optimization.yaw_optimizer_geometric import ( @@ -45,13 +45,28 @@ def __init__( self.enable_geometric_yaw = enable_geometric_yaw self.use_value = use_value - self._boundary_polygon = Polygon(self.boundaries) - self._boundary_line = LineString(self.boundaries) + # Allow boundaries to be set either as a list of corners or as a + # nested list of corners (for seperable regions) + self.boundaries = boundaries + b_depth = list_depth(boundaries) + + boundary_specification_error_msg = ( + "boundaries should be a list of coordinates (specifed as (x,y) "+\ + "tuples) or as a list of list of tuples (for seperable regions)." + ) - self.xmin = np.min([tup[0] for tup in boundaries]) - self.xmax = np.max([tup[0] for tup in boundaries]) - self.ymin = np.min([tup[1] for tup in boundaries]) - self.ymax = np.max([tup[1] for tup in boundaries]) + if b_depth == 1: + self._boundary_polygon = MultiPolygon([Polygon(self.boundaries)]) + self._boundary_line = self._boundary_polygon.boundary + elif b_depth == 2: + if not isinstance(self.boundaries[0][0], tuple): + raise TypeError(boundary_specification_error_msg) + self._boundary_polygon = MultiPolygon([Polygon(p) for p in self.boundaries]) + self._boundary_line = self._boundary_polygon.boundary + else: + raise TypeError(boundary_specification_error_msg) + + self.xmin, self.ymin, self.xmax, self.ymax = self._boundary_polygon.bounds # If no minimum distance is provided, assume a value of 2 rotor diameters if min_dist is None: @@ -115,36 +130,106 @@ def optimize(self): sol = self._optimize() return sol - def plot_layout_opt_results(self): + def plot_layout_opt_results(self, plot_boundary_dict={}, ax=None, fontsize=16): + x_initial, y_initial, x_opt, y_opt = self._get_initial_and_final_locs() - plt.figure(figsize=(9, 6)) - fontsize = 16 - plt.plot(x_initial, y_initial, "ob") - plt.plot(x_opt, y_opt, "or") - # plt.title('Layout Optimization Results', fontsize=fontsize) - plt.xlabel("x (m)", fontsize=fontsize) - plt.ylabel("y (m)", fontsize=fontsize) - plt.axis("equal") - plt.grid() - plt.tick_params(which="both", labelsize=fontsize) - plt.legend( - ["Old locations", "New locations"], + # Generate axis, if needed + if ax is None: + fig = plt.figure(figsize=(9,6)) + ax = fig.add_subplot(111) + ax.set_aspect("equal") + + default_plot_boundary_dict = { + "color":"None", + "alpha":1, + "edgecolor":"b", + "linewidth":2 + } + plot_boundary_dict = {**default_plot_boundary_dict, **plot_boundary_dict} + + self.plot_layout_opt_boundary(plot_boundary_dict, ax=ax) + ax.plot(x_initial, y_initial, "ob", label="Initial locations") + ax.plot(x_opt, y_opt, "or", label="New locations") + ax.set_xlabel("x (m)", fontsize=fontsize) + ax.set_ylabel("y (m)", fontsize=fontsize) + ax.grid(True) + ax.tick_params(which="both", labelsize=fontsize) + ax.legend( loc="lower center", bbox_to_anchor=(0.5, 1.01), ncol=2, fontsize=fontsize, ) - verts = self.boundaries - for i in range(len(verts)): - if i == len(verts) - 1: - plt.plot([verts[i][0], verts[0][0]], [verts[i][1], verts[0][1]], "b") - else: - plt.plot( - [verts[i][0], verts[i + 1][0]], [verts[i][1], verts[i + 1][1]], "b" + return ax + + def plot_layout_opt_boundary(self, plot_boundary_dict={}, ax=None): + + # Generate axis, if needed + if ax is None: + fig = plt.figure(figsize=(9,6)) + ax = fig.add_subplot(111) + ax.set_aspect("equal") + + default_plot_boundary_dict = { + "color":"k", + "alpha":0.1, + "edgecolor":None + } + + plot_boundary_dict = {**default_plot_boundary_dict, **plot_boundary_dict} + + for line in self._boundary_line.geoms: + xy = np.array(line.coords) + ax.fill(xy[:,0], xy[:,1], **plot_boundary_dict) + ax.grid(True) + + return ax + + def plot_progress(self, ax=None): + + if not hasattr(self, "objective_candidate_log"): + raise NotImplementedError( + "plot_progress not yet configured for "+self.__class__.__name__ + ) + + if ax is None: + _, ax = plt.subplots(1,1) + + objective_log_array = np.array(self.objective_candidate_log) + + if len(objective_log_array.shape) == 1: # Just one AEP candidate per step + ax.plot(np.arange(len(objective_log_array)), objective_log_array, color="k") + elif len(objective_log_array.shape) == 2: # Multiple AEP candidates per step + for i in range(objective_log_array.shape[1]): + ax.plot( + np.arange(len(objective_log_array)), + objective_log_array[:,i], + color="lightgray" ) + ax.scatter( + np.zeros(objective_log_array.shape[1]), + objective_log_array[0,:], + color="b", + label="Initial" + ) + ax.scatter( + objective_log_array.shape[0]-1, + objective_log_array[-1,:].max(), + color="r", + label="Final" + ) + + # Plot aesthetics + ax.grid(True) + ax.set_xlabel("Optimization step [-]") + ax.set_ylabel("Objective function") + ax.legend() + + return ax + ########################################################################### # Properties @@ -165,3 +250,11 @@ def nturbs(self): @property def rotor_diameter(self): return self.fmodel.core.farm.rotor_diameters_sorted[0][0] + +# Helper functions + +def list_depth(x): + if isinstance(x, list) and len(x) > 0: + return 1 + max(list_depth(item) for item in x) + else: + return 0 diff --git a/floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py index 3a87dff70..794795767 100644 --- a/floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py +++ b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py @@ -4,7 +4,7 @@ from scipy.spatial.distance import cdist from shapely.geometry import Point -from .layout_optimization_base import LayoutOptimization +from .layout_optimization_base import LayoutOptimization, list_depth class LayoutOptimizationPyOptSparse(LayoutOptimization): @@ -54,6 +54,10 @@ def __init__( enable_geometric_yaw=False, use_value=False, ): + if list_depth(boundaries) > 1 and hasattr(boundaries[0][0], "__len__"): + raise NotImplementedError( + "LayoutOptimizationPyOptSparse is not configured for multiple regions." + ) super().__init__( fmodel, diff --git a/floris/optimization/layout_optimization/layout_optimization_random_search.py b/floris/optimization/layout_optimization/layout_optimization_random_search.py new file mode 100644 index 000000000..92e5d7f94 --- /dev/null +++ b/floris/optimization/layout_optimization/layout_optimization_random_search.py @@ -0,0 +1,707 @@ +# Copyright 2022 NREL + +# Licensed under the Apache License, Version 2.0 (the "License"); you may not +# use this file except in compliance with the License. You may obtain a copy of +# the License at http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations under +# the License. + +# See https://floris.readthedocs.io for documentation + + +from multiprocessing import Pool +from time import perf_counter as timerpc + +import matplotlib.pyplot as plt +import numpy as np +from numpy import random +from scipy.spatial.distance import cdist, pdist +from shapely.geometry import Point, Polygon + +from floris import FlorisModel +from floris.optimization.yaw_optimization.yaw_optimizer_geometric import ( + YawOptimizationGeometric, +) + +from .layout_optimization_base import LayoutOptimization + + +def _load_local_floris_object( + fmodel_dict, + wind_data=None, +): + # Load local FLORIS object + fmodel = FlorisModel(fmodel_dict) + fmodel.set(wind_data=wind_data) + return fmodel + +def test_min_dist(layout_x, layout_y, min_dist): + coords = np.array([layout_x,layout_y]).T + dist = pdist(coords) + return dist.min() >= min_dist + +def test_point_in_bounds(test_x, test_y, poly_outer): + return poly_outer.contains(Point(test_x, test_y)) + +# Return in MW +def _get_objective( + layout_x, + layout_y, + fmodel, + yaw_angles=None, + use_value=False +): + fmodel.set( + layout_x=layout_x, + layout_y=layout_y, + yaw_angles=yaw_angles + ) + fmodel.run() + + return fmodel.get_farm_AVP() if use_value else fmodel.get_farm_AEP() + +def _gen_dist_based_init( + N, # Number of turbins to place + step_size, #m, courseness of search grid + poly_outer, # Polygon of outer boundary + min_x, + max_x, + min_y, + max_y, + s +): + """ + Generates an initial layout by randomly placing + the first turbine than placing the remaining turbines + as far as possible from the existing turbines. + """ + + # Set random seed + np.random.seed(s) + + # Choose the initial point randomly + init_x = float(random.randint(int(min_x),int(max_x))) + init_y = float(random.randint(int(min_y),int(max_y))) + while not (poly_outer.contains(Point([init_x,init_y]))): + init_x = float(random.randint(int(min_x),int(max_x))) + init_y = float(random.randint(int(min_y),int(max_y))) + + # Intialize the layout arrays + layout_x = np.array([init_x]) + layout_y = np.array([init_y]) + layout = np.array([layout_x, layout_y]).T + + # Now add the remaining points + for i in range(1,N): + + print("Placing turbine {0} of {1}.".format(i, N)) + # Add a new turbine being as far as possible from current + max_dist = 0. + for x in np.arange(min_x, max_x,step_size): + for y in np.arange(min_y, max_y,step_size): + if poly_outer.contains(Point([x,y])): + test_dist = cdist([[x,y]],layout) + min_dist = np.min(test_dist) + if min_dist > max_dist: + max_dist = min_dist + save_x = x + save_y = y + + # Add point to the layout + layout_x = np.append(layout_x,[save_x]) + layout_y = np.append(layout_y,[save_y]) + layout = np.array([layout_x, layout_y]).T + + # Return the layout + return layout_x, layout_y + +class LayoutOptimizationRandomSearch(LayoutOptimization): + def __init__( + self, + fmodel, + boundaries, + min_dist=None, + min_dist_D=None, + distance_pmf=None, + n_individuals=4, + seconds_per_iteration=60., + total_optimization_seconds=600., + interface="multiprocessing", # Options are 'multiprocessing', 'mpi4py', None + max_workers=None, + grid_step_size=100., + relegation_number=1, + enable_geometric_yaw=False, + use_dist_based_init=True, + random_seed=None, + use_value=False, + ): + """ + _summary_ + + Args: + fmodel (_type_): _description_ + boundaries (iterable(float, float)): Pairs of x- and y-coordinates + that represent the boundary's vertices (m). + min_dist (float, optional): The minimum distance to be maintained + between turbines during the optimization (m). If not specified, + initializes to 2 rotor diameters. Defaults to None. + min_dist_D (float, optional): The minimum distance to be maintained + between turbines during the optimization, specified as a multiple + of the rotor diameter. + distance_pmf (dict, optional): Probability mass function describing the + length of steps in the random search. Specified as a dictionary with + keys "d" (array of step distances, specified in meters) and "p" + (array of probability of occurrence, should sum to 1). Defaults to + uniform probability between 0.5D and 2D, with some extra mass + to encourage large changes. + n_individuals (int, optional): The number of individuals to use in the + optimization. Defaults to 4. + seconds_per_iteration (float, optional): The number of seconds to + run each step of the optimization for. Defaults to 60. + total_optimization_seconds (float, optional): The total number of + seconds to run the optimization for. Defaults to 600. + interface (str): Parallel computing interface to leverage. Recommended is 'concurrent' + or 'multiprocessing' for local (single-system) use, and 'mpi4py' for high + performance computing on multiple nodes. Defaults to 'multiprocessing'. + max_workers (int): Number of parallel workers, typically equal to the number of cores + you have on your system or HPC. Defaults to None, which will use all + available cores. + grid_step_size (float): The coarseness of the grid used to generate the initial layout. + Defaults to 100. + relegation_number (int): The number of the lowest performing individuals to be replaced + with new individuals generated from the best performing individual. Must + be less than n_individuals / 2. Defaults to 1. + enable_geometric_yaw (bool): Use geometric yaw code to determine approximate wake + steering yaw angles during layout optimization routine. Defaults to False. + use_dist_based_init (bool): Generate initial layouts automatically by placing turbines + as far apart as possible. + random_seed (int or None): Random seed for reproducibility. Defaults to None. + use_value (bool, optional): If True, the layout optimization objective + is to maximize annual value production using the value array in the + FLORIS model's WindData object. If False, the optimization + objective is to maximize AEP. Defaults to False. + """ + # The parallel computing interface to use + if interface == "mpi4py": + import mpi4py.futures as mp + self._PoolExecutor = mp.MPIPoolExecutor + elif interface == "multiprocessing": + import multiprocessing as mp + self._PoolExecutor = mp.Pool + if max_workers is None: + max_workers = mp.cpu_count() + elif interface is None: + if n_individuals > 1 or (max_workers is not None and max_workers > 1): + print( + "Parallelization not possible with interface=None. " + +"Reducing n_individuals to 1 and ignoring max_workers." + ) + self._PoolExecutor = None + max_workers = None + n_individuals = 1 + + # elif interface == "concurrent": + # from concurrent.futures import ProcessPoolExecutor + # self._PoolExecutor = ProcessPoolExecutor + else: + raise ValueError( + f"Interface '{interface}' not recognized. " + "Please use ' 'multiprocessing' or 'mpi4py'." + ) + + # Store the max_workers + self.max_workers = max_workers + + # Store the interface + self.interface = interface + + # Set and store the random seed + self.random_seed = random_seed + + # Confirm the relegation_number is valid + if relegation_number > n_individuals / 2: + raise ValueError("relegation_number must be less than n_individuals / 2.") + self.relegation_number = relegation_number + + # Store the rotor diameter and number of turbines + self.D = fmodel.core.farm.rotor_diameters.max() + if not all(fmodel.core.farm.rotor_diameters == self.D): + self.logger.warning("Using largest rotor diameter for min_dist_D and distance_pmf.") + self.N_turbines = fmodel.n_turbines + + # Make sure not both min_dist and min_dist_D are defined + if min_dist is not None and min_dist_D is not None: + raise ValueError("Only one of min_dist and min_dist_D can be defined.") + + # If min_dist_D is defined, convert to min_dist + if min_dist_D is not None: + min_dist = min_dist_D * self.D + + super().__init__( + fmodel, + boundaries, + min_dist=min_dist, + enable_geometric_yaw=enable_geometric_yaw, + use_value=use_value, + ) + if use_value: + self._obj_name = "value" + self._obj_unit = "" + else: + self._obj_name = "AEP" + self._obj_unit = "[GWh]" + + # Save min_dist_D + self.min_dist_D = self.min_dist / self.D + + # Process and save the step distribution + self._process_dist_pmf(distance_pmf) + + # Store the Core dictionary + self.fmodel_dict = self.fmodel.core.as_dict() + + # Save the grid step size + self.grid_step_size = grid_step_size + + # Save number of individuals + self.n_individuals = n_individuals + + # Store the initial locations + self.x_initial = self.fmodel.layout_x + self.y_initial = self.fmodel.layout_y + + # Store the total optimization seconds + self.total_optimization_seconds = total_optimization_seconds + + # Store the seconds per iteration + self.seconds_per_iteration = seconds_per_iteration + + # Get the initial objective value + self.x = self.x_initial # Required by _get_geoyaw_angles + self.y = self.y_initial # Required by _get_geoyaw_angles + self.objective_initial = _get_objective( + self.x_initial, + self.y_initial, + self.fmodel, + self._get_geoyaw_angles(), + self.use_value, + ) + + # Initialize the objective statistics + self.objective_mean = self.objective_initial + self.objective_median = self.objective_initial + self.objective_max = self.objective_initial + self.objective_min = self.objective_initial + + # Initialize the numpy arrays which will hold the candidate layouts + # these will have dimensions n_individuals x N_turbines + self.x_candidate = np.zeros((self.n_individuals, self.N_turbines)) + self.y_candidate = np.zeros((self.n_individuals, self.N_turbines)) + + # Initialize the array which will hold the objective function values for each candidate + self.objective_candidate = np.zeros(self.n_individuals) + + # Initialize the iteration step + self.iteration_step = -1 + + # Initialize the optimization time + self.opt_time_start = timerpc() + self.opt_time = 0 + + # Generate the initial layouts + if use_dist_based_init: + self._generate_initial_layouts() + else: + print(f'Using supplied initial layout for {self.n_individuals} individuals.') + for i in range(self.n_individuals): + self.x_candidate[i, :] = self.x_initial + self.y_candidate[i, :] = self.y_initial + self.objective_candidate[i] = self.objective_initial + + # Evaluate the initial optimization step + self._evaluate_opt_step() + + # Delete stored x and y to avoid confusion + del self.x, self.y + + def describe(self): + print("Random Layout Optimization") + print(f"Number of turbines to optimize = {self.N_turbines}") + print(f"Minimum distance between turbines = {self.min_dist_D} [D], {self.min_dist} [m]") + print(f"Number of individuals = {self.n_individuals}") + print(f"Seconds per iteration = {self.seconds_per_iteration}") + print(f"Initial {self._obj_name} = {self.objective_initial/1e9:.1f} {self._obj_unit}") + + def _process_dist_pmf(self, dist_pmf): + """ + Check validity of pmf and assign default if none provided. + """ + if dist_pmf is None: + jump_dist = np.min([self.xmax-self.xmin, self.ymax-self.ymin])/2 + jump_prob = 0.05 + + d = np.append(np.linspace(0.0, 2.0*self.D, 99), jump_dist) + p = np.append((1-jump_prob)/len(d)*np.ones(len(d)-1), jump_prob) + p = p / p.sum() + dist_pmf = {"d":d, "p":p} + + # Check correct keys are provided + if not all(k in dist_pmf for k in ("d", "p")): + raise KeyError("distance_pmf must contains keys \"d\" (step distance)"+\ + " and \"p\" (probability of occurrence).") + + # Check entries are in the correct form + if not hasattr(dist_pmf["d"], "__len__") or not hasattr(dist_pmf["d"], "__len__")\ + or len(dist_pmf["d"]) != len(dist_pmf["p"]): + raise TypeError("distance_pmf entries should be numpy arrays or lists"+\ + " of equal length.") + + if not np.isclose(dist_pmf["p"].sum(), 1): + print("Probability mass function does not sum to 1. Normalizing.") + dist_pmf["p"] = np.array(dist_pmf["p"]) / np.array(dist_pmf["p"]).sum() + + self.distance_pmf = dist_pmf + + def _evaluate_opt_step(self): + + # Sort the candidate layouts by objective function value + sorted_indices = np.argsort(self.objective_candidate)[::-1] # Decreasing order + self.objective_candidate = self.objective_candidate[sorted_indices] + self.x_candidate = self.x_candidate[sorted_indices] + self.y_candidate = self.y_candidate[sorted_indices] + + # Update the optimization time + self.opt_time = timerpc() - self.opt_time_start + + # Update the optimizations step + self.iteration_step += 1 + + # Update the objective statistics + self.objective_mean = np.mean(self.objective_candidate) + self.objective_median = np.median(self.objective_candidate) + self.objective_max = np.max(self.objective_candidate) + self.objective_min = np.min(self.objective_candidate) + + # Report the results + increase_mean = ( + 100 * (self.objective_mean - self.objective_initial) / self.objective_initial + ) + increase_median = ( + 100 * (self.objective_median - self.objective_initial) / self.objective_initial + ) + increase_max = 100 * (self.objective_max - self.objective_initial) / self.objective_initial + increase_min = 100 * (self.objective_min - self.objective_initial) / self.objective_initial + print("=======================================") + print(f"Optimization step {self.iteration_step:+.1f}") + print(f"Optimization time = {self.opt_time:+.1f} [s]") + print( + f"Mean {self._obj_name} = {self.objective_mean/1e9:.1f}" + f" {self._obj_unit} ({increase_mean:+.2f}%)" + ) + print( + f"Median {self._obj_name} = {self.objective_median/1e9:.1f}" + f" {self._obj_unit} ({increase_median:+.2f}%)" + ) + print( + f"Max {self._obj_name} = {self.objective_max/1e9:.1f}" + f" {self._obj_unit} ({increase_max:+.2f}%)" + ) + print( + f"Min {self._obj_name} = {self.objective_min/1e9:.1f}" + f" {self._obj_unit} ({increase_min:+.2f}%)" + ) + print("=======================================") + + # Replace the relegation_number worst performing layouts with relegation_number + # best layouts + if self.relegation_number > 0: + self.objective_candidate[-self.relegation_number:] = ( + self.objective_candidate[:self.relegation_number] + ) + self.x_candidate[-self.relegation_number:] = self.x_candidate[:self.relegation_number] + self.y_candidate[-self.relegation_number:] = self.y_candidate[:self.relegation_number] + + + # Private methods + def _generate_initial_layouts(self): + """ + This method generates n_individuals initial layout of turbines. It does + this by calling the _generate_random_layout method within a multiprocessing + pool. + """ + + # Set random seed for initial layout + if self.random_seed is None: + multi_random_seeds = [None]*self.n_individuals + else: + multi_random_seeds = [23 + i for i in range(self.n_individuals)] + # 23 is just an arbitrary choice to ensure different random seeds + # to the evaluation code + + print(f'Generating {self.n_individuals} initial layouts...') + t1 = timerpc() + # Generate the multiargs for parallel execution + multiargs = [ + (self.N_turbines, + self.grid_step_size, + self._boundary_polygon, + self.xmin, + self.xmax, + self.ymin, + self.ymax, + multi_random_seeds[i]) + for i in range(self.n_individuals) + ] + + if self._PoolExecutor: # Parallelized + with self._PoolExecutor(self.max_workers) as p: + # This code is not currently necessary, but leaving in case implement + # concurrent later, based on parallel_computing_interface.py + if (self.interface == "mpi4py") or (self.interface == "multiprocessing"): + out = p.starmap(_gen_dist_based_init, multiargs) + else: # Parallelization not activated + out = [_gen_dist_based_init(*multiargs[0])] + + # Unpack out into the candidate layouts + for i in range(self.n_individuals): + self.x_candidate[i, :] = out[i][0] + self.y_candidate[i, :] = out[i][1] + + # Get the objective function values for each candidate layout + for i in range(self.n_individuals): + self.objective_candidate[i] = _get_objective( + self.x_candidate[i, :], + self.y_candidate[i, :], + self.fmodel, + self._get_geoyaw_angles(), + self.use_value, + ) + + t2 = timerpc() + print(f" Time to generate initial layouts: {t2-t1:.3f} s") + + def _get_initial_and_final_locs(self): + x_initial = self.x_initial + y_initial = self.y_initial + x_opt = self.x_opt + y_opt = self.y_opt + return x_initial, y_initial, x_opt, y_opt + + + # Public methods + + def optimize(self): + """ + Perform the optimization + """ + print(f'Optimizing using {self.n_individuals} individuals.') + opt_start_time = timerpc() + opt_stop_time = opt_start_time + self.total_optimization_seconds + sim_time = 0 + + self.objective_candidate_log = [self.objective_candidate.copy()] + self.num_objective_calls_log = [] + self._num_objective_calls = [0]*self.n_individuals + + while timerpc() < opt_stop_time: + + # Set random seed for the main loop + if self.random_seed is None: + multi_random_seeds = [None]*self.n_individuals + else: + multi_random_seeds = [55 + self.iteration_step + i + for i in range(self.n_individuals)] + # 55 is just an arbitrary choice to ensure different random seeds + # to the initialization code + + # Update the optimization time + sim_time = timerpc() - opt_start_time + print(f'Optimization time: {sim_time:.1f} s / {self.total_optimization_seconds:.1f} s') + + + # Generate the multiargs for parallel execution of single individual optimization + multiargs = [ + (self.seconds_per_iteration, + self.objective_candidate[i], + self.x_candidate[i, :], + self.y_candidate[i, :], + self.fmodel_dict, + self.fmodel.wind_data, + self.min_dist, + self._boundary_polygon, + self.distance_pmf, + self.enable_geometric_yaw, + multi_random_seeds[i], + self.use_value + ) + for i in range(self.n_individuals) + ] + + # Run the single individual optimization in parallel + if self._PoolExecutor: # Parallelized + with self._PoolExecutor(self.max_workers) as p: + out = p.starmap(_single_individual_opt, multiargs) + else: # Parallelization not activated + out = [_single_individual_opt(*multiargs[0])] + + # Unpack the results + for i in range(self.n_individuals): + self.objective_candidate[i] = out[i][0] + self.x_candidate[i, :] = out[i][1] + self.y_candidate[i, :] = out[i][2] + self._num_objective_calls[i] = out[i][3] + self.objective_candidate_log.append(self.objective_candidate) + self.num_objective_calls_log.append(self._num_objective_calls) + + # Evaluate the individuals for this step + self._evaluate_opt_step() + + # Finalize the result + self.objective_final = self.objective_candidate[0] + self.x_opt = self.x_candidate[0, :] + self.y_opt = self.y_candidate[0, :] + + # Print the final result + increase = 100 * (self.objective_final - self.objective_initial) / self.objective_initial + print( + f"Final {self._obj_name} = {self.objective_final/1e9:.1f}" + f" {self._obj_unit} ({increase:+.2f}%)" + ) + + return self.objective_final, self.x_opt, self.y_opt + + + # Helpful visualizations + def plot_distance_pmf(self, ax=None): + """ + Tool to check the used distance pmf. + """ + + if ax is None: + _, ax = plt.subplots(1,1) + + ax.stem(self.distance_pmf["d"], self.distance_pmf["p"], linefmt="k-") + ax.grid(True) + ax.set_xlabel("Step distance [m]") + ax.set_ylabel("Probability") + + return ax + + + +def _single_individual_opt( + seconds_per_iteration, + initial_objective, + layout_x, + layout_y, + fmodel_dict, + wind_data, + min_dist, + poly_outer, + dist_pmf, + enable_geometric_yaw, + s, + use_value +): + # Set random seed + np.random.seed(s) + + # Initialize the optimization time + single_opt_start_time = timerpc() + stop_time = single_opt_start_time + seconds_per_iteration + + num_objective_calls = 0 + + # Get the fmodel + fmodel_ = _load_local_floris_object(fmodel_dict, wind_data) + + # Initialize local variables + num_turbines = len(layout_x) + get_new_point = True # Will always be true, due to hardcoded use_momentum + current_objective = initial_objective + + # Establish geometric yaw optimizer, if desired + if enable_geometric_yaw: + yaw_opt = YawOptimizationGeometric( + fmodel_, + minimum_yaw_angle=-30.0, + maximum_yaw_angle=30.0, + ) + else: # yaw_angles will always be none + yaw_angles = None + + # We have a beta feature to maintain momentum, i.e., if a move improves + # the objective, we try to keep moving in that direction. This is currently + # disabled. + use_momentum = False + + # Loop as long as we've not hit the stop time + while timerpc() < stop_time: + + if not use_momentum: + get_new_point = True + + if get_new_point: #If the last test wasn't successful + + # Randomly select a turbine to nudge + tr = random.randint(0,num_turbines-1) + + # Randomly select a direction to nudge in (uniform direction) + rand_dir = np.random.uniform(low=0.0, high=2*np.pi) + + # Randomly select a distance to travel according to pmf + rand_dist = np.random.choice(dist_pmf["d"], p=dist_pmf["p"]) + + # Get a new test point + test_x = layout_x[tr] + np.cos(rand_dir) * rand_dist + test_y = layout_y[tr] + np.sin(rand_dir) * rand_dist + + # In bounds? + if not test_point_in_bounds(test_x, test_y, poly_outer): + get_new_point = True + continue + + # Make a new layout + original_x = layout_x[tr] + original_y = layout_y[tr] + layout_x[tr] = test_x + layout_y[tr] = test_y + + # Acceptable distances? + if not test_min_dist(layout_x, layout_y,min_dist): + # Revert and continue + layout_x[tr] = original_x + layout_y[tr] = original_y + get_new_point = True + continue + + # Does it improve the objective? + if enable_geometric_yaw: # Select appropriate yaw angles + yaw_opt.fmodel_subset.set(layout_x=layout_x, layout_y=layout_y) + df_opt = yaw_opt.optimize() + yaw_angles = np.vstack(df_opt['yaw_angles_opt']) + + num_objective_calls += 1 + test_objective = _get_objective(layout_x, layout_y, fmodel_, yaw_angles, use_value) + + if test_objective > current_objective: + # Accept the change + current_objective = test_objective + + # If not a random point this cycle and it did improve things + # try not getting a new point + # Feature is currently disabled by use_momentum flag + get_new_point = False + + else: + # Revert the change + layout_x[tr] = original_x + layout_y[tr] = original_y + get_new_point = True + + # Return the best result from this individual + return current_objective, layout_x, layout_y, num_objective_calls diff --git a/floris/optimization/layout_optimization/layout_optimization_scipy.py b/floris/optimization/layout_optimization/layout_optimization_scipy.py index f7ca643b1..ff0e30015 100644 --- a/floris/optimization/layout_optimization/layout_optimization_scipy.py +++ b/floris/optimization/layout_optimization/layout_optimization_scipy.py @@ -5,7 +5,7 @@ from scipy.spatial.distance import cdist from shapely.geometry import Point -from .layout_optimization_base import LayoutOptimization +from .layout_optimization_base import LayoutOptimization, list_depth class LayoutOptimizationScipy(LayoutOptimization): @@ -13,27 +13,6 @@ class LayoutOptimizationScipy(LayoutOptimization): This class provides an interface for optimizing the layout of wind turbines using the Scipy optimization library. The optimization objective is to maximize annual energy production (AEP) or annual value production (AVP). - - - Args: - fmodel (FlorisModel): A FlorisModel object. - boundaries (iterable(float, float)): Pairs of x- and y-coordinates - that represent the boundary's vertices (m). - bnds (iterable, optional): Bounds for the optimization - variables (pairs of min/max values for each variable (m)). If - none are specified, they are set to 0 and 1. Defaults to None. - min_dist (float, optional): The minimum distance to be maintained - between turbines during the optimization (m). If not specified, - initializes to 2 rotor diameters. Defaults to None. - solver (str, optional): Sets the solver used by Scipy. Defaults to 'SLSQP'. - optOptions (dict, optional): Dictionary for setting the - optimization options. Defaults to None. - enable_geometric_yaw (bool, optional): If True, enables geometric yaw - optimization. Defaults to False. - use_value (bool, optional): If True, the layout optimization objective - is to maximize annual value production using the value array in the - FLORIS model's WindData object. If False, the optimization - objective is to maximize AEP. Defaults to False. """ def __init__( self, @@ -46,6 +25,31 @@ def __init__( enable_geometric_yaw=False, use_value=False, ): + """ + Args: + fmodel (FlorisModel): A FlorisModel object. + boundaries (iterable(float, float)): Pairs of x- and y-coordinates + that represent the boundary's vertices (m). + bnds (iterable, optional): Bounds for the optimization + variables (pairs of min/max values for each variable (m)). If + none are specified, they are set to 0 and 1. Defaults to None. + min_dist (float, optional): The minimum distance to be maintained + between turbines during the optimization (m). If not specified, + initializes to 2 rotor diameters. Defaults to None. + solver (str, optional): Sets the solver used by Scipy. Defaults to 'SLSQP'. + optOptions (dict, optional): Dictionary for setting the + optimization options. Defaults to None. + enable_geometric_yaw (bool, optional): If True, enables geometric yaw + optimization. Defaults to False. + use_value (bool, optional): If True, the layout optimization objective + is to maximize annual value production using the value array in the + FLORIS model's WindData object. If False, the optimization + objective is to maximize AEP. Defaults to False. + """ + if list_depth(boundaries) > 1 and hasattr(boundaries[0][0], "__len__"): + raise NotImplementedError( + "LayoutOptimizationScipy is not configured for multiple regions." + ) super().__init__( fmodel, @@ -88,6 +92,10 @@ def __init__( # Private methods def _optimize(self): + + self._num_aep_calls = 0 + self._aep_record = [] + self.residual_plant = minimize( self._obj_func, self.x0, @@ -112,11 +120,16 @@ def _obj_func(self, locs): yaw_angles = self._get_geoyaw_angles() self.fmodel.set_operation(yaw_angles=yaw_angles) self.fmodel.run() + self._num_aep_calls += 1 if self.use_value: - return -1 * self.fmodel.get_farm_AVP() / self.initial_AEP_or_AVP + val = -1 * self.fmodel.get_farm_AVP() / self.initial_AEP_or_AVP + self._aep_record.append(val) + return val else: - return -1 * self.fmodel.get_farm_AEP() / self.initial_AEP_or_AVP + aep = -1 * self.fmodel.get_farm_AEP() / self.initial_AEP_or_AVP + self._aep_record.append(aep) + return aep def _change_coordinates(self, locs): diff --git a/floris/optimization/yaw_optimization/yaw_optimizer_geometric.py b/floris/optimization/yaw_optimization/yaw_optimizer_geometric.py index e78d48c9d..ea68204b4 100644 --- a/floris/optimization/yaw_optimization/yaw_optimizer_geometric.py +++ b/floris/optimization/yaw_optimization/yaw_optimizer_geometric.py @@ -12,6 +12,8 @@ class YawOptimizationGeometric(YawOptimization): :py:class:`floris.optimization.general_library.YawOptimization` that is used to provide a rough estimate of optimal yaw angles based purely on the wind farm geometry. Main use case is for coupled layout and yaw optimization. + + See Stanely et al. (2023) for details: https://wes.copernicus.org/articles/8/1341/2023/ """ def __init__( diff --git a/floris/wind_data.py b/floris/wind_data.py index 926ca9e0e..5745eca54 100644 --- a/floris/wind_data.py +++ b/floris/wind_data.py @@ -4,7 +4,6 @@ from abc import abstractmethod from pathlib import Path -import matplotlib.cm as cm import matplotlib.pyplot as plt import numpy as np import pandas as pd @@ -614,7 +613,7 @@ def plot( wd_step = wd_bins[1] - wd_bins[0] # Get a color array - color_array = cm.get_cmap(color_map, len(ws_bins)) + color_array = plt.get_cmap(color_map, len(ws_bins)) for wd_idx, wd in enumerate(wd_bins): rects = [] @@ -1514,7 +1513,7 @@ def plot( _, ax = plt.subplots(subplot_kw={"polar": True}) # Get a color array - color_array = cm.get_cmap(color_map, len(var_bins)) + color_array = plt.get_cmap(color_map, len(var_bins)) for wd_idx, wd in enumerate(wd_bins): rects = [] diff --git a/tests/layout_optimization_integration_test.py b/tests/layout_optimization_integration_test.py index 0732b969c..18353a8f5 100644 --- a/tests/layout_optimization_integration_test.py +++ b/tests/layout_optimization_integration_test.py @@ -12,6 +12,9 @@ from floris.optimization.layout_optimization.layout_optimization_base import ( LayoutOptimization, ) +from floris.optimization.layout_optimization.layout_optimization_random_search import ( + LayoutOptimizationRandomSearch, +) from floris.optimization.layout_optimization.layout_optimization_scipy import ( LayoutOptimizationScipy, ) @@ -70,3 +73,22 @@ def test_base_class(caplog): LayoutOptimization(fmodel, boundaries, 5) LayoutOptimization(fmodel=fmodel, boundaries=boundaries, min_dist=5) + +def test_LayoutOptimizationRandomSearch(): + fmodel = FlorisModel(configuration=YAML_INPUT) + fmodel.set(layout_x=[0, 500], layout_y = [0, 0]) + + # Set up a sample boundary + boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] + + layout_opt = LayoutOptimizationRandomSearch( + fmodel=fmodel, + boundaries=boundaries, + min_dist_D=5, + seconds_per_iteration=1, + total_optimization_seconds=1, + use_dist_based_init=False, + ) + + # Check that the optimization runs + layout_opt.optimize() diff --git a/tests/reg_tests/random_search_layout_opt_regression_test.py b/tests/reg_tests/random_search_layout_opt_regression_test.py new file mode 100644 index 000000000..f29b40f28 --- /dev/null +++ b/tests/reg_tests/random_search_layout_opt_regression_test.py @@ -0,0 +1,142 @@ + +import numpy as np +import pandas as pd + +from floris import FlorisModel, WindRose +from floris.optimization.layout_optimization.layout_optimization_random_search import ( + LayoutOptimizationRandomSearch, +) +from tests.conftest import ( + assert_results_arrays, +) + + +DEBUG = False +VELOCITY_MODEL = "gauss" +DEFLECTION_MODEL = "gauss" + +locations_baseline_aep = np.array( + [ + [0.0, 571.5416296, 1260.0], + [0.0, 496.57085993, 0.], + ] +) +baseline_aep = 44787987324.21652 + +locations_baseline_value = np.array( + [ + [387.0, 100.0, 200.0, 300.0], + [192.0, 300.0, 100.0, 300.0], + ] +) +baseline_value = 8780876351.32277 + + +def test_random_search_layout_opt(sample_inputs_fixture): + """ + The SciPy optimization method optimizes turbine layout using SciPy's minimize method. This test + compares the optimization results from the SciPy layout optimization for a simple farm with a + simple wind rose to stored baseline results. + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] + + fmodel = FlorisModel(sample_inputs_fixture.core) + wd_array = np.arange(0, 360.0, 5.0) + ws_array = 8.0 * np.ones_like(wd_array) + + wind_rose = WindRose( + wind_directions=wd_array, + wind_speeds=ws_array, + ti_table=0.1, + ) + D = 126.0 # Rotor diameter for the NREL 5 MW + fmodel.set( + layout_x=[0.0, 5 * D, 10 * D], + layout_y=[0.0, 0.0, 0.0], + wind_data=wind_rose + ) + + layout_opt = LayoutOptimizationRandomSearch( + fmodel=fmodel, + boundaries=boundaries, + min_dist_D=5, + seconds_per_iteration=1, + total_optimization_seconds=1, + use_dist_based_init=False, + random_seed=0, + ) + sol = layout_opt.optimize() + optimized_aep = sol[0] + locations_opt = np.array([sol[1], sol[2]]) + + if DEBUG: + print(locations_opt) + print(optimized_aep) + + assert_results_arrays(locations_opt, locations_baseline_aep) + assert np.isclose(optimized_aep, baseline_aep) + +def test_random_search_layout_opt_value(sample_inputs_fixture): + """ + This test compares the optimization results from the SciPy layout optimization for a simple + farm with a simple wind rose to stored baseline results, optimizing for annual value production + instead of AEP. The value of the energy produced depends on the wind direction, causing the + optimal layout to differ from the case where the objective is maximum AEP. In this case, because + the value is much higher when the wind is from the north or south, the turbines are staggered to + avoid wake interactions for northerly and southerly winds. + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + boundaries = [(0.0, 0.0), (0.0, 400.0), (400.0, 400.0), (400.0, 0.0), (0.0, 0.0)] + + fmodel = FlorisModel(sample_inputs_fixture.core) + + # set wind conditions and values using a WindData object with the default uniform frequency + wd_array = np.arange(0, 360.0, 5.0) + ws_array = np.array([8.0]) + + # Define the value table such that the value of the energy produced is + # significantly higher when the wind direction is close to the north or + # south, and zero when the wind is from the east or west. + value_table = (0.5 + 0.5*np.cos(2*np.radians(wd_array)))**10 + value_table = value_table.reshape((len(wd_array),1)) + + wind_rose = WindRose( + wind_directions=wd_array, + wind_speeds=ws_array, + ti_table=0.1, + value_table=value_table + ) + + # Start with a rectangular 4-turbine array with 2D spacing + D = 126.0 # Rotor diameter for the NREL 5 MW + fmodel.set( + layout_x=200 + np.array([-1 * D, -1 * D, 1 * D, 1 * D]), + layout_y=200 + np.array([-1* D, 1 * D, -1 * D, 1 * D]), + wind_data=wind_rose, + ) + + layout_opt = LayoutOptimizationRandomSearch( + fmodel=fmodel, + boundaries=boundaries, + min_dist_D=5, + seconds_per_iteration=1, + total_optimization_seconds=1, + use_dist_based_init=True, + random_seed=0, + use_value=True, + ) + sol = layout_opt.optimize() + optimized_value = sol[0] + locations_opt = np.array([sol[1], sol[2]]) + + if DEBUG: + print(locations_opt) + print(optimized_value) + + assert_results_arrays(locations_opt, locations_baseline_value) + assert np.isclose(optimized_value, baseline_value) From 97946f9cd4d4e5ce963b97dcf98401381a300a42 Mon Sep 17 00:00:00 2001 From: paulf81 Date: Wed, 5 Jun 2024 15:13:42 -0600 Subject: [PATCH 09/12] Add z/3d to HeterogeneousMap (#915) --- docs/heterogeneous_map.ipynb | 273 +++++++++++++++++- .../002_heterogeneous_using_wind_data.py | 3 + .../004_heterogeneous_2d_and_3d.py | 4 +- floris/floris_model.py | 13 + floris/heterogeneous_map.py | 134 +++++++-- tests/heterogeneous_map_integration_test.py | 162 +++++++++++ 6 files changed, 561 insertions(+), 28 deletions(-) diff --git a/docs/heterogeneous_map.ipynb b/docs/heterogeneous_map.ipynb index e28b8c05d..6ef96e725 100644 --- a/docs/heterogeneous_map.ipynb +++ b/docs/heterogeneous_map.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ " HeterogeneousMap,\n", " TimeSeries,\n", ")\n", - "from floris.flow_visualization import visualize_heterogeneous_cut_plane" + "from floris.flow_visualization import visualize_heterogeneous_cut_plane, visualize_cut_plane" ] }, { @@ -54,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 50, "metadata": {}, "outputs": [], "source": [ @@ -76,6 +76,26 @@ ")" ] }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HeterogeneousMap with 2 dimensions\n", + "Speeds-up defined for 5 points and\n", + "4 wind conditions\n" + ] + } + ], + "source": [ + "# Can print basic information about the map\n", + "print(heterogeneous_map)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -92,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 52, "metadata": {}, "outputs": [ { @@ -101,13 +121,13 @@ "Text(0.5, 0.98, 'Heterogeneous speedup map for several directions and wind speeds')" ] }, - "execution_count": 9, + "execution_count": 52, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "

" ] @@ -158,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 53, "metadata": {}, "outputs": [ { @@ -175,7 +195,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -224,7 +244,242 @@ " f\"Wind Direction = {time_series.wind_directions[findex]}\\n\"\n", " f\"Wind Speed = {time_series.wind_speeds[findex]}\"\n", " ),\n", - " )\n" + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Definining a 3D HeterogeneousMap" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Including a z-dimension in the HetereogeneousMap allows for a 3D heterogeneity. This uses the underlying support in FlorisMode for 3D heterogeneous_inflow_config_by_wd.\n", + "\n", + "Note that when using the 3D version, wind_sheer must be set to 0.0 to avoid an error." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HeterogeneousMap with 3 dimensions\n", + "Speeds-up defined for 12 points and\n", + "4 wind conditions\n" + ] + } + ], + "source": [ + "# Define a 3D heterogeneous map with two z-levels\n", + "\n", + "heterogeneous_map = HeterogeneousMap(\n", + " x=np.array(\n", + " [\n", + " -1000.0,\n", + " -1000.0,\n", + " 1000.0,\n", + " 1000.0,\n", + " -1000.0,\n", + " -1000.0,\n", + " 1000.0,\n", + " 1000.0,\n", + " -1000.0,\n", + " -1000.0,\n", + " 1000.0,\n", + " 1000.0,\n", + " ]\n", + " ),\n", + " y=np.array(\n", + " [-500.0, 500.0, -500.0, 500.0, -500.0, 500.0, -500.0, 500.0, -500.00, 500.0, -500.0, 500.0]\n", + " ),\n", + " z=np.array(\n", + " [100.0, 100.0, 100.0, 100.0, 200.0, 200.0, 200.0, 200.0, 500.0, 500.0, 500.0, 500.0]\n", + " ),\n", + " speed_multipliers=np.array(\n", + " [\n", + " [1.0, 1.0, 1.0, 1.0, 1.1, 1.1, 1.1, 1.1, 1.5, 1.5, 1.5, 1.5],\n", + " [1.0, 1.0, 1.0, 1.0, 1.1, 1.1, 1.1, 1.1, 1.5, 1.5, 1.5, 1.5],\n", + " [1.0, 1.2, 1.2, 1.0, 1.3, 1.1, 1.1, 1.3, 1.5, 1.5, 1.5, 1.5],\n", + " [1.0, 1.0, 1.0, 1.0, 1.1, 1.1, 1.1, 1.1, 1.5, 1.5, 1.5, 1.5],\n", + " ]\n", + " ),\n", + " wind_directions=np.array([270.0, 270.0, 90.0, 90.0]),\n", + " wind_speeds=np.array([5.0, 10.0, 5.0, 10.0]),\n", + ")\n", + "print(heterogeneous_map)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When visualizing the 3D heterogeneity, the z-height to plot must be specified (nearest defined is used)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "heterogeneous_map.plot_single_speed_multiplier(wind_direction=90.0, wind_speed=5.0, z=100.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "heterogeneous_map.plot_single_speed_multiplier(wind_direction=90.0, wind_speed=5.0, z=200.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "## Apply the 3D heterogeneous map to the FlorisModel\n", + "time_series = TimeSeries(\n", + " wind_directions=np.array([275.0, 95.0, 75.0]),\n", + " wind_speeds=np.array([7.0, 6.2, 8.0]),\n", + " turbulence_intensities=0.06,\n", + " heterogeneous_map=heterogeneous_map,\n", + ")\n", + "\n", + "# Apply the time series to the FlorisModel, make sure to set wind_shear to 0.0\n", + "fmodel.set(wind_data=time_series, wind_shear=0.0)\n", + "\n", + "# Run the FLORIS simulation\n", + "fmodel.run()" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mDeleting stored wind_data information.\u001b[0m\n", + "\u001b[34mfloris.logging_manager.LoggingManager\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mThe calculated flow field contains points outside of the the user-defined heterogeneous inflow bounds. For these points, the interpolated value has been filled with the freestream wind speed. If this is not the desired behavior, the user will need to expand the heterogeneous inflow bounds to fully cover the calculated flow field area.\u001b[0m\n", + "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mDeleting stored wind_data information.\u001b[0m\n", + "\u001b[34mfloris.logging_manager.LoggingManager\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mThe calculated flow field contains points outside of the the user-defined heterogeneous inflow bounds. For these points, the interpolated value has been filled with the freestream wind speed. If this is not the desired behavior, the user will need to expand the heterogeneous inflow bounds to fully cover the calculated flow field area.\u001b[0m\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show a horizontal and y plane slice (note that heterogeneity is only defined within the hull of points)\n", + "\n", + "# Visualize each of the findices\n", + "fig, axarr = plt.subplots(2, 1, sharex=True, sharey=False, figsize=(5, 7))\n", + "findex = 0\n", + "\n", + "ax = axarr[0]\n", + "horizontal_plane = fmodel.calculate_horizontal_plane(\n", + " x_resolution=200, y_resolution=100, height=90.0, findex_for_viz=findex\n", + ")\n", + "\n", + "visualize_heterogeneous_cut_plane(\n", + " cut_plane=horizontal_plane,\n", + " fmodel=fmodel,\n", + " ax=ax,\n", + " title=(\n", + " f\"Wind Direction = {time_series.wind_directions[findex]}\\n\"\n", + " f\"Wind Speed = {time_series.wind_speeds[findex]}\"\n", + " ),\n", + ")\n", + "\n", + "ax = axarr[1]\n", + "y_plane = fmodel.calculate_y_plane(\n", + " x_resolution=200,\n", + " z_resolution=100,\n", + " findex_for_viz=findex,\n", + " crossstream_dist=400.0, # x_bounds=[-200,500]\n", + ")\n", + "\n", + "visualize_cut_plane(\n", + " cut_plane=y_plane,\n", + " ax=ax,\n", + " title=(\n", + " f\"Wind Direction = {time_series.wind_directions[findex]}\\n\"\n", + " f\"Wind Speed = {time_series.wind_speeds[findex]}\"\n", + " ),\n", + ")" ] } ], diff --git a/examples/examples_heterogeneous/002_heterogeneous_using_wind_data.py b/examples/examples_heterogeneous/002_heterogeneous_using_wind_data.py index 4b5b1ac43..b136766c0 100644 --- a/examples/examples_heterogeneous/002_heterogeneous_using_wind_data.py +++ b/examples/examples_heterogeneous/002_heterogeneous_using_wind_data.py @@ -88,6 +88,9 @@ wind_directions=[270.0, 280.0], ) +# Print the HeterogeneousMap object +print(heterogeneous_map) + # Now create a new TimeSeries object including the heterogeneous_inflow_config_by_wd time_series = TimeSeries( wind_directions=np.array([269.0, 270.0, 271.0, 282.0]), diff --git a/examples/examples_heterogeneous/004_heterogeneous_2d_and_3d.py b/examples/examples_heterogeneous/004_heterogeneous_2d_and_3d.py index 1d1f3b791..c896f2287 100644 --- a/examples/examples_heterogeneous/004_heterogeneous_2d_and_3d.py +++ b/examples/examples_heterogeneous/004_heterogeneous_2d_and_3d.py @@ -99,11 +99,13 @@ # Note that we initialize FLORIS with a homogenous flow input file, but # then configure the heterogeneous inflow via the reinitialize method. fmodel_3d = FlorisModel("../inputs/gch.yaml") -fmodel_3d.set(heterogeneous_inflow_config=heterogeneous_inflow_config) # Set shear to 0.0 to highlight the heterogeneous inflow fmodel_3d.set(wind_shear=0.0) +# Apply the heterogeneous inflow configuration +fmodel_3d.set(heterogeneous_inflow_config=heterogeneous_inflow_config) + # Using the FlorisModel functions for generating plots, run FLORIS # and extract 2D planes of data. horizontal_plane_3d = fmodel_3d.calculate_horizontal_plane( diff --git a/floris/floris_model.py b/floris/floris_model.py index 1d05f3d3e..b0d14854b 100644 --- a/floris/floris_model.py +++ b/floris/floris_model.py @@ -210,6 +210,19 @@ def _reinitialize( if air_density is not None: flow_field_dict["air_density"] = air_density if heterogeneous_inflow_config is not None: + if ( + "z" in heterogeneous_inflow_config + and flow_field_dict["wind_shear"] != 0.0 + and heterogeneous_inflow_config['z'] is not None + ): + raise ValueError( + "Heterogeneous inflow configuration contains a z term, and " + "flow_field_dict['wind_shear'] is not 0.0. Combining both options " + "is not currently allowed in FLORIS. If using a z term in the " + " heterogeneous inflow configuration, set flow_field_dict['wind_shear'] " + "to 0.0." + ) + flow_field_dict["heterogeneous_inflow_config"] = heterogeneous_inflow_config ## Farm diff --git a/floris/heterogeneous_map.py b/floris/heterogeneous_map.py index c0aa29de9..ea6edb963 100644 --- a/floris/heterogeneous_map.py +++ b/floris/heterogeneous_map.py @@ -22,6 +22,8 @@ class HeterogeneousMap(LoggingManager): speed_multipliers (NDArrayFloat): A 2D NumPy array (size num_wd (or num_ws) x num_points) of speed multipliers. If neither wind_directions nor wind_speeds are defined, then this should be a single row array + z (NDArrayFloat, optional): A 1D NumPy array (size num_points) of z-coordinates (meters). + Optional. wind_directions (NDArrayFloat, optional): A 1D NumPy array (size num_wd) of wind directions (degrees). Optional. wind_speeds (NDArrayFloat, optional): A 1D NumPy array (size num_ws) of wind speeds (m/s). @@ -39,6 +41,7 @@ def __init__( x: NDArrayFloat, y: NDArrayFloat, speed_multipliers: NDArrayFloat, + z: NDArrayFloat = None, wind_directions: NDArrayFloat = None, wind_speeds: NDArrayFloat = None, ): @@ -50,20 +53,39 @@ def __init__( if not isinstance(speed_multipliers, (list, np.ndarray)): raise TypeError("speed_multipliers must be a numpy array or list") + # If z is provided, check that it is a list or numpy array + if (z is not None) and (not isinstance(z, (list, np.ndarray))): + raise TypeError("z must be a numpy array or list") + # Save the values self.x = np.array(x) self.y = np.array(y) self.speed_multipliers = np.array(speed_multipliers) + # If z is provided, save it as an np array + if z is not None: + self.z = np.array(z) + else: + self.z = None + # Check that the length of the 1st dimension of speed_multipliers is the # same as the length of both x and y - if (len(self.x) != self.speed_multipliers.shape[1] - or len(self.y) != self.speed_multipliers.shape[1]): + if ( + len(self.x) != self.speed_multipliers.shape[1] + or len(self.y) != self.speed_multipliers.shape[1] + ): raise ValueError( "The lengths of x and y must equal the 1th dimension of speed_multipliers " - "within the heterogeneous_inflow_config_by_wd dictionary" ) + # If z is provided, check that it is the same length as the 1st + # dimension of speed_multipliers + if self.z is not None: + if len(self.z) != self.speed_multipliers.shape[1]: + raise ValueError( + "The length of z must equal the 1th dimension of speed_multipliers " + ) + # If wind_directions is note None, check that it is valid then save it if wind_directions is not None: if not isinstance(wind_directions, (list, np.ndarray)): @@ -121,6 +143,23 @@ def __init__( "should be unique." ) + def __str__(self) -> str: + """ + Return a string representation of the HeterogeneousMap. + Returns: + str: A string representation of the HeterogeneousMap. + """ + if self.z is None: + num_dim = 2 + else: + num_dim = 3 + + return ( + f"HeterogeneousMap with {num_dim} dimensions\n" + f"Speeds-up defined for {len(self.x)} points and\n" + f"{self.speed_multipliers.shape[0]} wind conditions" + ) + def get_heterogeneous_inflow_config( self, wind_directions: NDArrayFloat | list[float], @@ -195,12 +234,49 @@ def get_heterogeneous_inflow_config( self.speed_multipliers, len(wind_directions), axis=0 ) - # Return heterogeneous_inflow_config - return { - "x": self.x, - "y": self.y, - "speed_multipliers": speed_multipliers_by_findex, - } + # Return heterogeneous_inflow_config with only x and y is z is not defined + if self.z is None: + return { + "x": self.x, + "y": self.y, + "speed_multipliers": speed_multipliers_by_findex, + } + else: + return { + "x": self.x, + "y": self.y, + "z": self.z, + "speed_multipliers": speed_multipliers_by_findex, + } + + def get_heterogeneous_map_2d(self, z: float): + """ + Return a HeterogeneousMap with only x and y coordinates and a constant z value. + Do this by selecting from x, y and speed_multipliers where z is nearest to the given value. + """ + if self.z is None: + raise ValueError("No z values defined in the HeterogeneousMap") + + # Find the value in self.z that is closest to the given z value + closest_z_index = np.argmin(np.abs(self.z - z)) + + # Get the indices of all the values in self.z that are equal to the closest value + closest_z_indices = np.where(self.z == self.z[closest_z_index])[0] + + # Get versions of x, y and speed_multipliers that include only the closest z values + # by selecting the indices in closest_z_indices + x = self.x[closest_z_indices] + y = self.y[closest_z_indices] + speed_multipliers = self.speed_multipliers[:, closest_z_indices] + + # Return a new HeterogeneousMap with the new x, y and speed_multipliers + return HeterogeneousMap( + x=x, + y=y, + speed_multipliers=speed_multipliers, + wind_directions=self.wind_directions, + wind_speeds=self.wind_speeds, + ) @staticmethod def plot_heterogeneous_boundary(x, y, ax=None): @@ -277,6 +353,7 @@ def plot_single_speed_multiplier( self, wind_direction: float, wind_speed: float, + z: float = None, ax: plt.Axes = None, vmin: float = None, vmax: float = None, @@ -290,6 +367,9 @@ def plot_single_speed_multiplier( Args: wind_direction (float): The wind direction for which to plot the speed multipliers. wind_speed (float): The wind speed for which to plot the speed multipliers. + z (float, optional): The z-coordinate for which to plot the speed multipliers. + If None, the z-coordinate is not used. Only for when z is defined in the + HeterogeneousMap. ax (matplotlib.axes.Axes, optional): The axes on which to plot the speed multipliers. If None, a new figure and axes will be created. vmin (float, optional): The minimum value for the colorbar. Default is the minimum @@ -314,10 +394,32 @@ def plot_single_speed_multiplier( if not isinstance(wind_speed, float): raise TypeError("wind_speed must be a float") - # Get the speed multipliers for the given wind direction and wind speed - speed_multiplier_row = self.get_heterogeneous_inflow_config( - np.array([wind_direction]), np.array([wind_speed]) - )["speed_multipliers"][0] + # If self.z is None, then z should be None + if self.z is None and z is not None: + raise ValueError("No z values defined in the HeterogeneousMap") + + # If self.z is defined and has more than one unique value, then z should be defined + if self.z is not None and len(np.unique(self.z)) > 1 and z is None: + raise ValueError( + "Multiple z values defined in the HeterogeneousMap. z must be provided" + ) + + # Get the 2d version at height z if z is defined and get the speed multiplier from there + # as well as x and y + if z is not None: + hm_2d = self.get_heterogeneous_map_2d(z) + x = hm_2d.x + y = hm_2d.y + speed_multiplier_row = hm_2d.get_heterogeneous_inflow_config( + np.array([wind_direction]), np.array([wind_speed]) + )["speed_multipliers"][0] + else: + x = self.x + y = self.y + # Get the speed multipliers for the given wind direction and wind speed + speed_multiplier_row = self.get_heterogeneous_inflow_config( + np.array([wind_direction]), np.array([wind_speed]) + )["speed_multipliers"][0] # If not provided create the axis if ax is None: @@ -325,10 +427,6 @@ def plot_single_speed_multiplier( else: fig = ax.get_figure() - # Get the x and y coordinates - x = self.x - y = self.y - # Get some boundary info min_x = np.min(x) max_x = np.max(x) @@ -351,7 +449,7 @@ def plot_single_speed_multiplier( y_plot = y_plot.flatten() try: - lin_interpolant = FlowField.interpolate_multiplier_xy(x,y,speed_multiplier_row) + lin_interpolant = FlowField.interpolate_multiplier_xy(x, y, speed_multiplier_row) lin_values = lin_interpolant(x, y) except scipy.spatial._qhull.QhullError: diff --git a/tests/heterogeneous_map_integration_test.py b/tests/heterogeneous_map_integration_test.py index 9fd232d58..630e1c72e 100644 --- a/tests/heterogeneous_map_integration_test.py +++ b/tests/heterogeneous_map_integration_test.py @@ -1,9 +1,16 @@ +from pathlib import Path + import numpy as np import pytest +from floris import FlorisModel from floris.heterogeneous_map import HeterogeneousMap +TEST_DATA = Path(__file__).resolve().parent / "data" +YAML_INPUT = TEST_DATA / "input_full.yaml" + + def test_declare_by_parameters(): HeterogeneousMap( x=np.array([0.0, 0.0, 500.0, 500.0]), @@ -20,6 +27,7 @@ def test_declare_by_parameters(): wind_speeds=np.array([5.0, 15.0, 5.0, 15.0]), ) + def test_heterogeneous_map_no_ws_no_wd(): heterogeneous_map_config = { "x": np.array([0.0, 1.0, 2.0]), @@ -232,3 +240,157 @@ def test_get_heterogeneous_inflow_config_no_wind_direction_no_wind_speed(): output_dict = hm.get_heterogeneous_inflow_config(wind_directions, wind_speeds) assert np.allclose(output_dict["speed_multipliers"], expected_output) + + +def test_get_2d_heterogenous_map_from_3d(): + hm_3d = HeterogeneousMap( + x=np.array( + [ + 0.0, + 1.0, + 2.0, + 0.0, + 1.0, + 2.0, + ] + ), + y=np.array( + [ + 0.0, + 1.0, + 2.0, + 0.0, + 1.0, + 2.0, + ] + ), + z=np.array([0.0, 0.0, 0.0, 1.0, 1.0, 1.0]), + speed_multipliers=np.array( + [ + [1.0, 1.1, 1.2, 2.0, 2.1, 2.2], + [1.1, 1.1, 1.1, 2.1, 2.1, 2.1], + [1.3, 1.4, 1.5, 2.3, 2.4, 2.5], + ] + ), + wind_directions=np.array([0, 90, 270]), + ) + + hm_2d_0 = hm_3d.get_heterogeneous_map_2d(0.0) + hm_2d_1 = hm_3d.get_heterogeneous_map_2d(1.0) + + # Test that x values in both cases are 0, 1, 2 + assert np.allclose(hm_2d_0.x, np.array([0.0, 1.0, 2.0])) + assert np.allclose(hm_2d_1.x, np.array([0.0, 1.0, 2.0])) + + # Test that the speed multipliers are correct + assert np.allclose( + hm_2d_0.speed_multipliers, np.array([[1.0, 1.1, 1.2], [1.1, 1.1, 1.1], [1.3, 1.4, 1.5]]) + ) + assert np.allclose( + hm_2d_1.speed_multipliers, np.array([[2.0, 2.1, 2.2], [2.1, 2.1, 2.1], [2.3, 2.4, 2.5]]) + ) + + # Test that wind directions are the same between 2d and 3d + assert np.allclose(hm_2d_0.wind_directions, hm_3d.wind_directions) + + # Test that wind speed is None in all cases + assert hm_3d.wind_speeds is None + assert hm_2d_0.wind_speeds is None + assert hm_2d_1.wind_speeds is None + + +def test_3d_het_and_shear(): + # Define a 3D het map with 4 z locations and a single x and y where + # the speed ups are defined by the usual power low + wind_speed = 8.0 + z_values_array = np.array([0.0, 100.0, 200.0, 300.0]) + reference_wind_height = 90.0 + wind_shear = 0.12 + speed_multipliers_array = (z_values_array / reference_wind_height) ** wind_shear + + # Define the x and y locations to be corners of a square that repeats + # for 4 different z locations + x_values = np.tile(np.array([-500.0, 500.0, -500.0, 500.0]), 4) + y_values = np.tile(np.array([-500.0, -500.0, 500.0, 500.0]), 4) + + # Repeat each of the elements of z_values 4 times + z_values = np.repeat(z_values_array, 4) + speed_multipliers = np.repeat(speed_multipliers_array, 4) + + # Reshape speed_multipliers to be (1,16) + speed_multipliers = speed_multipliers.reshape(1, -1) + + # Build the 3d HeterogeneousMap + hm_3d = HeterogeneousMap( + x=x_values, + y=y_values, + z=z_values, + speed_multipliers=speed_multipliers, + ) + + # Get the FLORIS model + fmodel = FlorisModel(configuration=YAML_INPUT) + + # Set the model to a single wind direction, speed and turbine + fmodel.set( + wind_directions=[270.0], + wind_speeds=[wind_speed], + layout_x=[0], + layout_y=[0], + wind_shear=wind_shear, + ) + + # Run the model + fmodel.run() + + # Get the velocities 100 m in front of the turbine + # Use the calculate_y_plane method because sample_flow_at_points does not currently work + # with heterogeneous inflow + # u_at_points_shear = fmodel.sample_flow_at_points(x= -100.0 * np.ones_like(z_values_array), + # y= 0.0 * np.ones_like(z_values_array), + # z=z_values_array) + y_plane = fmodel.calculate_y_plane( + x_resolution=1, + z_resolution=4, + crossstream_dist=0.0, + x_bounds=[-100.0, -100.0], + z_bounds=[0.0, 300.0], + ) + u_at_points_shear = y_plane.df["u"].values + + # Check that the velocities are as expected, ie the shear exponent of 0.12 + # produces speeds expeted from the power law + assert np.allclose(u_at_points_shear, wind_speed * speed_multipliers_array) + + # Now change the model such that shear is 0, while the 3D het map is applied + fmodel.set( + wind_shear=0.0, + heterogeneous_inflow_config=hm_3d.get_heterogeneous_inflow_config( + wind_directions=[270.0], wind_speeds=[wind_speed] + ), + ) + + # Run the model + fmodel.run() + + # # Get the velocities 100 m in front of the turbine + y_plane_het = fmodel.calculate_y_plane( + x_resolution=1, + z_resolution=4, + crossstream_dist=0.0, + x_bounds=[-100.0, -100.0], + z_bounds=[0.0, 300.0], + ) + u_at_points_het = y_plane_het.df["u"].values + + # Confirm this produces the same results as the shear model + assert np.allclose(u_at_points_het, u_at_points_shear) + + # Finally confirm that applying both shear and het raises a value error + with pytest.raises(ValueError): + fmodel.set( + wind_shear=0.12, + heterogeneous_inflow_config=hm_3d.get_heterogeneous_inflow_config( + wind_directions=[270.0], wind_speeds=[wind_speed] + ), + ) From 894cd42d6621f11374915614a554bdd4d39a8a56 Mon Sep 17 00:00:00 2001 From: misi9170 Date: Tue, 11 Jun 2024 11:41:33 -0600 Subject: [PATCH 10/12] Update version number to 4.1 --- README.md | 4 ++-- floris/version.py | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 7d26cf1bd..961a9bce8 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ FLORIS is a controls-focused wind farm simulation software incorporating steady-state engineering wake models into a performance-focused Python framework. It has been in active development at NREL since 2013 and the latest -release is [FLORIS v4.0.1](https://github.com/NREL/floris/releases/latest). +release is [FLORIS v4.1](https://github.com/NREL/floris/releases/latest). Online documentation is available at https://nrel.github.io/floris. The software is in active development and engagement with the development team @@ -79,7 +79,7 @@ PACKAGE CONTENTS wind_data VERSION - 4 + 4.1 FILE ~/floris/floris/__init__.py diff --git a/floris/version.py b/floris/version.py index 1454f6ed4..7d5c902e7 100644 --- a/floris/version.py +++ b/floris/version.py @@ -1 +1 @@ -4.0.1 +4.1 From 457697051634484c38e538f1a2ef1bcae74c8944 Mon Sep 17 00:00:00 2001 From: Jared Thomas Date: Wed, 12 Jun 2024 14:24:38 -0600 Subject: [PATCH 11/12] Fix typo in error message (#922) Minor typo correction in error message. --- floris/floris_model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/floris/floris_model.py b/floris/floris_model.py index b0d14854b..91b3c4cb1 100644 --- a/floris/floris_model.py +++ b/floris/floris_model.py @@ -94,9 +94,9 @@ def __init__(self, configuration: dict | str | Path): (np.abs(self.core.flow_field.reference_wind_height - unique_heights[0]) > 1.0e-6 )): err_msg = ( - "The only unique hub-height is not the equal to the specified reference " + "The only unique hub-height is not equal to the specified reference " "wind height. If this was unintended use -1 as the reference hub height to " - " indicate use of hub-height as reference wind height." + "indicate use of hub-height as reference wind height." ) self.logger.warning(err_msg, stack_info=True) From ab609351331455a7bc166104aaa0bc2bfd381f9b Mon Sep 17 00:00:00 2001 From: misi9170 Date: Thu, 13 Jun 2024 11:20:02 -0600 Subject: [PATCH 12/12] Remove % sign in debugging incorrectly reported threshold. --- .codecov.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.codecov.yml b/.codecov.yml index f6d274dc5..facace372 100644 --- a/.codecov.yml +++ b/.codecov.yml @@ -10,7 +10,7 @@ coverage: project: default: # allow coverage to drop by this amount and still post success - threshold: 10% + threshold: 10 ignore: - "setup.py"