diff --git a/docs/_config.yml b/docs/_config.yml index 20287c4da..9a3c991d0 100644 --- a/docs/_config.yml +++ b/docs/_config.yml @@ -44,12 +44,8 @@ sphinx: - 'sphinx.ext.viewcode' - 'sphinx_autodoc_typehints' - 'sphinxcontrib.autoyaml' - - 'sphinx.ext.napoleon' # Formats google and numpy docstring styles - 'sphinxcontrib.mermaid' config: - html_theme: sphinx_book_theme - templates_path: - - '_templates' language: 'python' nb_execution_show_tb: true # Shows the stack trace in stdout; its suppressed otherwise. nb_execution_raise_on_error: true # Stops the Sphinx build if there is an error in a notebook. See https://github.com/executablebooks/jupyter-book/issues/2011 @@ -74,3 +70,4 @@ sphinx: # class-doc-from # no-value autodoc_typehints: both + mermaid_version: "10.8" diff --git a/docs/_templates/custom-class-template.rst b/docs/_templates/custom-class-template.rst deleted file mode 100644 index f73eda50e..000000000 --- a/docs/_templates/custom-class-template.rst +++ /dev/null @@ -1,34 +0,0 @@ -{{ fullname | escape | underline}} - -.. currentmodule:: {{ module }} - -.. autoclass:: {{ objname }} - :members: - :show-inheritance: - :inherited-members: - :special-members: __call__, __add__, __mul__ - - {% block methods %} - {% if methods %} - .. rubric:: {{ _('Methods') }} - - .. autosummary:: - :nosignatures: - {% for item in methods %} - {%- if not item.startswith('_') %} - ~{{ name }}.{{ item }} - {%- endif -%} - {%- endfor %} - {% endif %} - {% endblock %} - - {% block attributes %} - {% if attributes %} - .. rubric:: {{ _('Attributes') }} - - .. autosummary:: - {% for item in attributes %} - ~{{ name }}.{{ item }} - {%- endfor %} - {% endif %} - {% endblock %} diff --git a/docs/_templates/custom-module-template.rst b/docs/_templates/custom-module-template.rst deleted file mode 100644 index d066d0e4d..000000000 --- a/docs/_templates/custom-module-template.rst +++ /dev/null @@ -1,66 +0,0 @@ -{{ fullname | escape | underline}} - -.. automodule:: {{ fullname }} - - {% block attributes %} - {% if attributes %} - .. rubric:: Module attributes - - .. autosummary:: - :toctree: - {% for item in attributes %} - {{ item }} - {%- endfor %} - {% endif %} - {% endblock %} - - {% block functions %} - {% if functions %} - .. rubric:: {{ _('Functions') }} - - .. autosummary:: - :toctree: - :nosignatures: - {% for item in functions %} - {{ item }} - {%- endfor %} - {% endif %} - {% endblock %} - - {% block classes %} - {% if classes %} - .. rubric:: {{ _('Classes') }} - - .. autosummary:: - :toctree: - :template: custom-class-template.rst - :nosignatures: - {% for item in classes %} - {{ item }} - {%- endfor %} - {% endif %} - {% endblock %} - - {% block exceptions %} - {% if exceptions %} - .. rubric:: {{ _('Exceptions') }} - - .. autosummary:: - :toctree: - {% for item in exceptions %} - {{ item }} - {%- endfor %} - {% endif %} - {% endblock %} - -{% block modules %} -{% if modules %} -.. autosummary:: - :toctree: - :template: custom-module-template.rst - :recursive: -{% for item in modules %} - {{ item }} -{%- endfor %} -{% endif %} -{% endblock %} diff --git a/docs/_toc.yml b/docs/_toc.yml index 6ed7490ad..91199ffc0 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -10,7 +10,8 @@ parts: - caption: User Reference chapters: - - file: floris_101 + - file: intro_concepts + - file: advanced_concepts - file: floating_wind_turbine - file: turbine_interaction - file: input_reference_main diff --git a/docs/advanced_concepts.ipynb b/docs/advanced_concepts.ipynb new file mode 100644 index 000000000..aae2869fb --- /dev/null +++ b/docs/advanced_concepts.ipynb @@ -0,0 +1,132 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "(concepts_advanced)=\n", + "\n", + "# Advanced Concepts\n", + "\n", + "More information regarding the numerical and computational formulation in FLORIS\n", + "are detailed here. See [](concepts_intro) for a guide on the basics." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a basic FLORIS model for use later\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from floris.tools import FlorisInterface\n", + "fi = FlorisInterface(\"gch.yaml\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data structures\n", + "\n", + "FLORIS adopts a structures of arrays data modeling paradigm (SoA, relative to array of structures {AoS})\n", + "for nearly all of the data in the `floris.simulation` package.\n", + "This data model enables vectorization (SIMD operations) through Numpy array broadcasting\n", + "for many operations.\n", + "In general, there are two types of array shapes:\n", + "- Field quantities have points throughout the computational domain but in context-specific locations\n", + " and have the shape `(N wind directions, n wind speeds, n turbines, n grid, n grid)`.\n", + "- Scalar quantities have a single value for each turbine and typically have the shape\n", + " `(N wind directions, n wind speeds, n turbines, 1, 1)`. For scalar quanities, the arrays\n", + " may be created with the shape `(N wind directions, n wind speeds, n turbines)` and\n", + " then expanded to the 5-dimensional shape prior to running the wake calculation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Grids\n", + "\n", + "FLORIS includes a number of grid-types that create sampling points within the computational\n", + "domain for different contexts. In the typical use case, AEP or some other metric of wind\n", + "farm energy yield is the end result. Since the mathematical models in FLORIS are all\n", + "analytical, we only need to create points on the turbines themselves in order to calculate\n", + "the incoming wind speeds given all of the upstream conditions. In this case, we use\n", + "the {py:meth}`floris.simulation.grid.TurbineGrid` or {py:meth}`floris.simulation.grid.TurbineCubatureGrid`.\n", + "Each of these grid-types put points only on the turbine swept area, so all other\n", + "field-quantities in FLORIS have the same shape." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the grid point locations for TurbineGrid and TurbineCubatureGrid\n", + "\n", + "fi.reinitialize(layout_x=[0.0], layout_y=[0.0])\n", + "rotor_radius = fi.floris.farm.rotor_diameters[0] / 2.0\n", + "hub_height = fi.floris.farm.hub_heights[0]\n", + "theta = np.linspace(0, 2*np.pi, 100)\n", + "circlex = rotor_radius * np.cos(theta)\n", + "circley = rotor_radius * np.sin(theta) + hub_height\n", + "\n", + "# TurbineGrid is the default\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(0, hub_height, marker=\"+\", color=\"r\")\n", + "ax.scatter(fi.floris.grid.y_sorted[0,0,0], fi.floris.grid.z_sorted[0,0,0], marker=\"+\", color=\"r\")\n", + "ax.plot(circlex, circley)\n", + "ax.set_aspect('equal', 'box')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + } + ], + "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.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/api_docs.rst b/docs/api_docs.md similarity index 57% rename from docs/api_docs.rst rename to docs/api_docs.md index add2940c1..e94478f75 100644 --- a/docs/api_docs.rst +++ b/docs/api_docs.md @@ -1,16 +1,15 @@ -API Documentation -================= +# API Documentation FLORIS is divided into two primary packages. -:py:mod:`floris.simulation` is the core code that models the wind turbines -and wind farms. It is low-level code that generally is nto accessed -by typical users. :py:mod:`floris.tools` is the set of analysis routines +{py:mod}`floris.simulation` is the core code that models the wind turbines +and wind farms. It is low-level code that generally is not accessed +by typical users. {py:mod}`floris.tools` is the set of analysis routines that define, drive, and post process a simulation. This is where more users will interface with the software. +```{eval-rst} .. autosummary:: :toctree: _autosummary - :template: custom-module-template.rst :recursive: floris.logging_manager @@ -19,3 +18,4 @@ more users will interface with the software. floris.type_dec floris.turbine_library floris.utilities +``` diff --git a/docs/architecture.md b/docs/architecture.md index 682aa5c8b..cdfa60bb4 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -7,9 +7,10 @@ be violated, and ongoing work should strive to meet these ideas and expand on th as possible. - Modularity in wake model formulation: - - New mathematical formulation should be straightforward to incorporate. - - Requisite solver and grid data structures should not conflict with other existing - wake models. + - New mathematical formulation should be straightforward to incorporate by non-expert + software developers. + - Solver and grid data structures for one wake model should not conflict with the data + structures for other wake models. - Any new feature or work should not affect an existing feature: - Low level code should be reused as much as possible, but high level code should rarely be repurposed. @@ -31,12 +32,12 @@ packages. The internal structure and hierarchy is described below. ```{mermaid} classDiagram - class tools { - +FlorisInterface + class simulation["floris.simulation"] { + +Floris } - class simulation { - +Floris + class tools["floris.tools"] { + +FlorisInterface } class logging_manager @@ -45,9 +46,7 @@ classDiagram tools <-- logging_manager simulation <-- logging_manager - tools <-- type_dec simulation <-- type_dec - tools <-- utilities simulation <-- utilities tools <-- simulation ``` @@ -75,54 +74,61 @@ classDiagram class Farm class FlowField { - array u - array v - array w + u: NDArrayFloat + v: NDArrayFloat + w: NDArrayFloat } class Grid { <> + x: NDArrayFloat + y: NDArrayFloat + z: NDArrayFloat } class TurbineGrid + class TurbineCubatureGrid class FlowFieldPlanarGrid + class PointsGrid class WakeModelManager { <> } class WakeCombination { - dict parameters + parameters: dict function() } class WakeDeflection { - dict parameters + parameters: dict function() } class WakeTurbulence { - dict parameters + parameters: dict function() } class WakeVelocity { - dict parameters + parameters: dict function() } class Solver { <> - dict parameters + parameters: dict } - Floris o-- Farm - Floris o-- FlowField - Floris o-- Grid - Floris o-- WakeModelManager - Floris *-- Solver - WakeModelManager o-- WakeCombination - WakeModelManager o-- WakeDeflection - WakeModelManager o-- WakeTurbulence - WakeModelManager o-- WakeVelocity + Floris *-- Farm + Floris *-- FlowField + Floris *-- Grid + Floris *-- WakeModelManager + Floris --> Solver + WakeModelManager *-- WakeCombination + WakeModelManager *-- WakeDeflection + WakeModelManager *-- WakeTurbulence + WakeModelManager *-- WakeVelocity Grid <|-- TurbineGrid + Grid <|-- TurbineCubatureGrid Grid <|-- FlowFieldPlanarGrid + Grid <|-- PointsGrid Solver --> Farm Solver --> FlowField diff --git a/docs/dev_guide.md b/docs/dev_guide.md index bf2b6f97b..d5ce55d42 100644 --- a/docs/dev_guide.md +++ b/docs/dev_guide.md @@ -293,3 +293,119 @@ Be sure to complete each step in the sequence as described. Generally, only NREL developers will have appropriate permissions to deploy FLORIS updates. When the time comes, here is a great reference on doing it is available [here](https://medium.freecodecamp.org/how-to-publish-a-pyton-package-on-pypi-a89e9522ce24). + +## Extending the models + +The FLORIS architecture is designed to support adding new wake models relatively easily. +Each of the following components have a general API that support plugging in to the rest of the +FLORIS framework: +- Velocity deficit +- Wake deflection +- Added turbulence due to the turbine wake +- Wake combination +- Solver algorithm +- Grid-points + +Initially, it's recommended to copy an existing model as a starting point, and the +[Jensen](https://github.com/NREL/floris/blob/main/floris/simulation/wake_velocity/jensen.py) and +[Jimenez](https://github.com/NREL/floris/blob/main/floris/simulation/wake_deflection/jimenez.py) +models are good choices due to their simplicity. +New models must be registered in +[Wake.model_map](https://github.com/NREL/floris/blob/main/floris/simulation/wake.py#L45) +so that they can be enabled via the input dictionary. + +```{mermaid} +classDiagram + + class Floris + + class Farm + + class FlowField { + u: NDArrayFloat + v: NDArrayFloat + w: NDArrayFloat + } + + class Grid { + <> + x: NDArrayFloat + y: NDArrayFloat + z: NDArrayFloat + } + + class WakeModelManager { + <> + combination_model: BaseModel + deflection_model: BaseModel + velocity_model: BaseModel + turbulence_model: BaseModel + } + + class Solver { + <> + parameters: dict + } + + class BaseModel { + prepare_function() dict + function() None + } + + Floris *-- Farm + Floris *-- FlowField + Floris *-- Grid + Floris *-- WakeModelManager + Floris --> Solver + + Solver --> Farm + Solver --> FlowField + Solver --> Grid + Solver --> WakeModelManager + + WakeModelManager -- BaseModel + + style Grid stroke:#FF496B, stroke-width:2px + style WakeModelManager stroke:#FF496B, stroke-width:2px + style Solver stroke:#FF496B, stroke-width:2px +``` + +All of the models have a `prepare_function` and a `function` method. +The `prepare_function` allows the model classes to extract any information from the `Grid` and +`FlowField` data structures, and this is generally used for sizing the data arrays. +The `prepare_function` should return a dictionary that will ultimately be passed to the +`function`. +The `function` method is where the actual calculation is performed. +The API is dependent on the type of model, but generally it requires some indicationg of +the location of the current turbine in the solve step and some other information about the +atmospheric conditions and operation of the turbine. +Note the `*` in the function signature, which is a Python feature that allows +any number of arguments to be passed to the function after the `*` as keyword arguments. +Typically, these arguments are the ones returned from the `prepare_function`. + +```python +def prepare_function(self, grid: Grid, flow_field: FlowField) -> Dict[str, Any] + +def function( + self, + x_i: np.ndarray, + y_i: np.ndarray, + z_i: np.ndarray, + axial_induction_i: np.ndarray, + deflection_field_i: np.ndarray, + yaw_angle_i: np.ndarray, + turbulence_intensity_i: np.ndarray, + ct_i: np.ndarray, + hub_height_i: np.ndarray, + rotor_diameter_i: np.ndarray, + *, + variables_from_prepare_function: dict +) -> None: +``` + +Some models require a special grid and/or solver, and that mapping happens in +[floris.simulation.Floris](https://github.com/NREL/floris/blob/main/floris/simulation/floris.py#L145). +Generally, a specific kind of solver requires one or a number of specific grid-types. +For example, `full_flow_sequential_solver` requires either `FlowFieldGrid` or +`FlowFieldPlanarGrid`. +So, it is often the case that adding a new solver will require adding a new grid type, as well. diff --git a/docs/examples.md b/docs/examples.md index 22c6daaa6..eebb3c89d 100644 --- a/docs/examples.md +++ b/docs/examples.md @@ -7,7 +7,7 @@ intended to describe most features as well as provide a starting point for various analysis methods. These are generally ordered from simplest to most complex. The examples and their content are described below. Prior to exploring the examples, it is highly recommended to review -[](background_concepts). +[](concepts_intro). ## Basic setup and pre and post processing diff --git a/docs/floris_101.ipynb b/docs/floris_101.ipynb deleted file mode 100644 index 5bf94a4a5..000000000 --- a/docs/floris_101.ipynb +++ /dev/null @@ -1,938 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "86e53920", - "metadata": {}, - "source": [ - "(background_concepts)=\n", - "# Background and Concepts\n", - "\n", - "FLORIS is a command-line program written in Python. There are two primary packages that make up the software:\n", - "- `floris.simulation`: simulation framework including wake model definitions\n", - "- `floris.tools`: utilities for pre and post processing as well as driving the simulation\n", - "\n", - "\n", - "\n", - "Users of FLORIS will develop a Python script with the following sequence of steps:\n", - "\n", - "1. Load inputs and preprocess data\n", - "2. Run the wind farm wake simulation\n", - "3. Extract data and postprocess results\n", - "\n", - "Generally, users will only interact with `floris.tools` and most often through\n", - "the `FlorisInterface` class. Additionally, `floris.tools` contains functionality\n", - "for comparing results, creating visualizations, and developing optimization cases. \n", - "\n", - "**NOTE `floris.tools` is under active design and development. The API's will change and additional functionality from FLORIS v2 will be included in upcoming releases.**\n", - "\n", - "This notebook steps through the basic ideas and operations of FLORIS while showing\n", - "realistic uses and expected behavior." - ] - }, - { - "cell_type": "markdown", - "id": "699c51dd", - "metadata": {}, - "source": [ - "## Initialize FlorisInterface\n", - "\n", - "The `FlorisInterface` provides functionality to build a wind farm representation and drive\n", - "the simulation. This object is created (instantiated) by passing the path to a FLORIS input\n", - "file as the only argument. After this object is created, it can immediately be used to\n", - "inspect the data." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "602f311c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " x y\n", - " 0.0, 0.0\n", - " 630.0, 0.0\n", - "1260.0, 0.0\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from floris.tools import FlorisInterface\n", - "\n", - "fi = FlorisInterface(\"gch.yaml\")\n", - "x, y = fi.get_turbine_layout()\n", - "\n", - "print(\" x y\")\n", - "for _x, _y in zip(x, y):\n", - " print(f\"{_x:6.1f}, {_y:6.1f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "e1eaeb53", - "metadata": {}, - "source": [ - "## Build the model\n", - "\n", - "At this point, FLORIS has been initialized with the data defined in the input file.\n", - "However, it is often simpler to define a basic configuration in the input file as\n", - "a starting point and then make modifications in the Python script. This allows for\n", - "generating data algorithmically or loading data from a data file. Modifications to\n", - "the wind farm representation are handled through the `FlorisInterface.reinitialize()`\n", - "function with keyword arguments. Another way to think of this function is that it\n", - "changes the value of inputs specified in the input file.\n", - "\n", - "Let's change the location of turbines in the wind farm. The code below changes the\n", - "initial 3x1 layout to a 2x2 rectangular layout." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "d040b810", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " x y\n", - " 0.0, 0.0\n", - " 0.0, 400.0\n", - " 800.0, 0.0\n", - " 800.0, 400.0\n" - ] - } - ], - "source": [ - "x_2x2 = [0, 0, 800, 800]\n", - "y_2x2 = [0, 400, 0, 400]\n", - "fi.reinitialize(layout_x=x_2x2, layout_y=y_2x2)\n", - "\n", - "x, y = fi.get_turbine_layout()\n", - "\n", - "print(\" x y\")\n", - "for _x, _y in zip(x, y):\n", - " print(f\"{_x:6.1f}, {_y:6.1f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "63f45e11", - "metadata": {}, - "source": [ - "Additionally, we can change the wind speeds and wind directions.\n", - "These are lists of wind speeds and wind directions that will be\n", - "combined so that a wake calculation will happen for every wind\n", - "direction with each speed.\n", - "\n", - "Notice that we can give `FlorisInterface.reinitialize()` multiple keyword arguments at once." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "6f9d834a", - "metadata": {}, - "outputs": [], - "source": [ - "# One wind direction and one speed -> one atmospheric condition\n", - "fi.reinitialize(wind_directions=[270.0], wind_speeds=[8.0])\n", - "\n", - "# Two wind directions and one speed -> two atmospheric conditions\n", - "fi.reinitialize(wind_directions=[270.0, 280.0], wind_speeds=[8.0])\n", - "\n", - "# Two wind directions and two speeds -> four atmospheric conditions\n", - "fi.reinitialize(wind_directions=[270.0, 280.0], wind_speeds=[8.0, 9.0])" - ] - }, - { - "cell_type": "markdown", - "id": "da4f3309", - "metadata": {}, - "source": [ - "`FlorisInterface.reinitialize()` creates all of the basic data structures required\n", - "for the simulation but it does not do any aerodynamic calculations. The low level\n", - "data structures have a complex shape that enables faster computations. Specifically,\n", - "most data is structured as a many-dimensional Numpy array with the following dimensions:\n", - "\n", - "```python\n", - "np.array(\n", - " (\n", - " wind directions,\n", - " wind speeds,\n", - " turbines,\n", - " grid-1,\n", - " grid-2\n", - " )\n", - ")\n", - "```\n", - "\n", - "For example, we can see the shape of the data structure for the grid point x-coordinates\n", - "for the all turbines and get the x-coordinates of grid points for the third turbine in\n", - "the first wind direction and first wind speed. We can also plot all the grid points in\n", - "space to get an idea of the overall form of our grid." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "01ea3a98", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dimensions of grid x-components\n", - "(2, 2, 4, 3, 3)\n", - "\n", - "Turbine 3 grid x-components for first wind direction and first wind speed\n", - "[[800. 800. 800.]\n", - " [800. 800. 800.]\n", - " [800. 800. 800.]]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "print(\"Dimensions of grid x-components\")\n", - "print(np.shape(fi.floris.grid.x_sorted))\n", - "\n", - "print()\n", - "print(\"Turbine 3 grid x-components for first wind direction and first wind speed\")\n", - "print(fi.floris.grid.x_sorted[0, 0, 2, :, :])\n", - "\n", - "x = fi.floris.grid.x_sorted[0, 0, :, :, :]\n", - "y = fi.floris.grid.y_sorted[0, 0, :, :, :]\n", - "z = fi.floris.grid.z_sorted[0, 0, :, :, :]\n", - "\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot(111, projection=\"3d\")\n", - "ax.scatter(x, y, z, marker=\".\")\n", - "ax.set_zlim([0, 150])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "ebfdc746", - "metadata": {}, - "source": [ - "## Execute wake calculation\n", - "\n", - "Running the wake calculation is a one-liner. This will calculate the velocities\n", - "at each turbine given the wake of other turbines for every wind speed and wind\n", - "direction combination. Since we have not explicitly specified yaw control settings,\n", - "all turbines are aligned with the inflow." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "e3bf1698", - "metadata": {}, - "outputs": [], - "source": [ - "fi.calculate_wake()" - ] - }, - { - "cell_type": "markdown", - "id": "e11352e8", - "metadata": {}, - "source": [ - "## Get turbine power\n", - "\n", - "At this point, the simulation has completed and we can use the `FlorisInterface` to\n", - "extract useful information such as the power produced at each turbine. Remember that\n", - "we have configured the simulation with two wind directions, two wind speeds, and four\n", - "turbines." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "cc05bfe7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dimensions of `powers`\n", - "(2, 2, 4)\n", - "\n", - "Turbine powers for 8 m/s\n", - "Wind direction 0\n", - " Turbine 0 - 1,691.33 kW\n", - " Turbine 1 - 1,691.33 kW\n", - " Turbine 2 - 592.65 kW\n", - " Turbine 3 - 592.98 kW\n", - "\n", - "Wind direction 1\n", - " Turbine 0 - 1,691.33 kW\n", - " Turbine 1 - 1,691.33 kW\n", - " Turbine 2 - 1,631.07 kW\n", - " Turbine 3 - 1,629.76 kW\n", - "\n", - "Turbine powers for all turbines at all wind conditions\n", - "[[[1691.32664838 1691.32664838 592.6531181 592.97842923]\n", - " [2407.84167188 2407.84167188 861.30649817 861.73255027]]\n", - "\n", - " [[1691.32664838 1691.32664838 1631.06554071 1629.75543674]\n", - " [2407.84167188 2407.84167188 2321.40975418 2319.53218301]]]\n" - ] - } - ], - "source": [ - "powers = fi.get_turbine_powers() / 1000.0 # calculated in Watts, so convert to kW\n", - "\n", - "print(\"Dimensions of `powers`\")\n", - "print( np.shape(powers) )\n", - "\n", - "N_TURBINES = fi.floris.farm.n_turbines\n", - "\n", - "print()\n", - "print(\"Turbine powers for 8 m/s\")\n", - "for i in range(2):\n", - " print(f\"Wind direction {i}\")\n", - " for j in range(N_TURBINES):\n", - " print(f\" Turbine {j} - {powers[i, 0, j]:7,.2f} kW\")\n", - " print()\n", - "\n", - "print(\"Turbine powers for all turbines at all wind conditions\")\n", - "print(powers)" - ] - }, - { - "cell_type": "markdown", - "id": "8ab273db", - "metadata": {}, - "source": [ - "## Applying yaw angles\n", - "\n", - "Yaw angles are applied to turbines through the `FlorisInterface.calculate_wake` function.\n", - "In order to fit into the vectorized framework, the yaw settings must be represented as\n", - "a `Numpy.array` with dimensions equal to:\n", - "- 0: number of wind directions\n", - "- 1: number of wind speeds\n", - "- 2: number of turbines\n", - "\n", - "**Unlike the data configured in `FlorisInterface.reinitialize()`, yaw angles are not retained**\n", - "**in memory and must be provided each time `FlorisInterface.calculate_wake` is used.**\n", - "**If no yaw angles are given, all turbines will be aligned with the inflow.**\n", - "\n", - "It is typically easiest to start with an array of 0's and modify individual\n", - "turbine yaw settings, as shown below." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "be78e20d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Yaw angle array initialized with 0's\n", - "[[[0. 0. 0. 0.]\n", - " [0. 0. 0. 0.]]\n", - "\n", - " [[0. 0. 0. 0.]\n", - " [0. 0. 0. 0.]]]\n", - "First turbine yawed 25 degrees for every atmospheric condition\n", - "[[[25. 0. 0. 0.]\n", - " [25. 0. 0. 0.]]\n", - "\n", - " [[25. 0. 0. 0.]\n", - " [25. 0. 0. 0.]]]\n" - ] - } - ], - "source": [ - "yaw_angles = np.zeros((2, 2, 4))\n", - "print(\"Yaw angle array initialized with 0's\")\n", - "print(yaw_angles)\n", - "\n", - "print(\"First turbine yawed 25 degrees for every atmospheric condition\")\n", - "yaw_angles[:, :, 0] = 25\n", - "print(yaw_angles)\n", - "\n", - "fi.calculate_wake(yaw_angles=yaw_angles)" - ] - }, - { - "cell_type": "markdown", - "id": "1ef54dc5", - "metadata": {}, - "source": [ - "## Start to finish\n", - "\n", - "Let's put it all together. The code below outlines these steps:\n", - "1. Load an input file\n", - "2. Modify the inputs with a more complex wind turbine layout and additional atmospheric conditions\n", - "3. Calculate the velocities at each turbine for all atmospheric conditions\n", - "4. Get the total farm power\n", - "5. Develop the yaw control settings\n", - "6. Calculate the velocities at each turbine for all atmospheric conditions with the new yaw settings\n", - "7. Get the total farm power\n", - "8. Compare farm power with and without wake steering" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "205738aa", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Power % difference with yaw\n", - " 270 degrees: 7.39%\n", - " 280 degrees: 0.13%\n" - ] - } - ], - "source": [ - "# 1. Load an input file\n", - "fi = FlorisInterface(\"gch.yaml\")\n", - "\n", - "fi.floris.solver\n", - "\n", - "# 2. Modify the inputs with a more complex wind turbine layout\n", - "D = 126.0 # Design the layout based on turbine diameter\n", - "x = [0, 0, 6 * D, 6 * D]\n", - "y = [0, 3 * D, 0, 3 * D]\n", - "wind_directions = [270.0, 280.0]\n", - "wind_speeds = [8.0]\n", - "\n", - "# Pass the new data to FlorisInterface\n", - "fi.reinitialize(\n", - " layout_x=x,\n", - " layout_y=y,\n", - " wind_directions=wind_directions,\n", - " wind_speeds=wind_speeds\n", - ")\n", - "\n", - "# 3. Calculate the velocities at each turbine for all atmospheric conditions\n", - "# All turbines have 0 degrees yaw\n", - "fi.calculate_wake()\n", - "\n", - "# 4. Get the total farm power\n", - "turbine_powers = fi.get_turbine_powers() / 1000.0 # Given in W, so convert to kW\n", - "farm_power_baseline = np.sum(turbine_powers, 2) # Sum over the third dimension\n", - "\n", - "# 5. Develop the yaw control settings\n", - "yaw_angles = np.zeros( (2, 1, 4) ) # Construct the yaw array with dimensions for two wind directions, one wind speed, and four turbines\n", - "yaw_angles[0, :, 0] = 25 # At 270 degrees, yaw the first turbine 25 degrees\n", - "yaw_angles[0, :, 1] = 25 # At 270 degrees, yaw the second turbine 25 degrees\n", - "yaw_angles[1, :, 0] = 10 # At 265 degrees, yaw the first turbine -25 degrees\n", - "yaw_angles[1, :, 1] = 10 # At 265 degrees, yaw the second turbine -25 degrees\n", - "\n", - "# 6. Calculate the velocities at each turbine for all atmospheric conditions with the new yaw settings\n", - "fi.calculate_wake(yaw_angles=yaw_angles)\n", - "\n", - "# 7. Get the total farm power\n", - "turbine_powers = fi.get_turbine_powers() / 1000.0\n", - "farm_power_yaw = np.sum(turbine_powers, 2)\n", - "\n", - "# 8. Compare farm power with and without wake steering\n", - "difference = 100 * (farm_power_yaw - farm_power_baseline) / farm_power_baseline\n", - "print(\"Power % difference with yaw\")\n", - "print(f\" 270 degrees: {difference[0, 0]:4.2f}%\")\n", - "print(f\" 280 degrees: {difference[1, 0]:4.2f}%\")" - ] - }, - { - "cell_type": "markdown", - "id": "99b7465c", - "metadata": {}, - "source": [ - "## Visualization\n", - "\n", - "While comparing turbine and farm powers is meaningful, a picture is worth at least\n", - "1000 Watts, and the `FlorisInterface` provides powerful routines for visualization.\n", - "\n", - "**NOTE `floris.tools` is under active design and development. The API's will change and additional functionality from FLORIS v2 will be included in upcoming releases.**\n", - "\n", - "The visualization functions require that the user select a single atmospheric condition\n", - "to plot. The internal data structures still have the same shape but the wind speed and\n", - "wind direction dimensions have a size of 1. This means that the yaw angle array used\n", - "for plotting must have the same shape as above but a single atmospheric condition must\n", - "be selected.\n", - "\n", - "Let's create a horizontal slice of each atmospheric condition from above with and without\n", - "yaw settings included. Notice that although we are plotting the conditions for two\n", - "different wind directions, the farm is rotated so that the wind is coming from the\n", - "left (West) in both cases." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "8bb179ff", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from floris.tools.visualization import visualize_cut_plane\n", - "\n", - "fig, axarr = plt.subplots(2, 2, figsize=(15,8))\n", - "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[0]], height=90.0)\n", - "visualize_cut_plane(horizontal_plane, ax=axarr[0,0], title=\"270 - Aligned\")\n", - "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[0]], yaw_angles=yaw_angles[0:1,0:1] , height=90.0)\n", - "visualize_cut_plane(horizontal_plane, ax=axarr[0,1], title=\"270 - Yawed\")\n", - "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[1]], height=90.0)\n", - "visualize_cut_plane(horizontal_plane, ax=axarr[1,0], title=\"280 - Aligned\")\n", - "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[1]], yaw_angles=yaw_angles[1:2,0:1] , height=90.0)\n", - "visualize_cut_plane(horizontal_plane, ax=axarr[1,1], title=\"280 - Yawed\")\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "d84cf194", - "metadata": {}, - "source": [ - "We can also plot the streamwise inflow velocities on the turbine rotor\n", - "grid points located on the rotor plane. The `plot_rotor_values` function\n", - "simply plots any data given as the first argument, so in this case\n", - "`fi.floris.flow_field.u` contains the yawed calculation from above." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "3e517614", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "from floris.tools.visualization import plot_rotor_values\n", - "\n", - "fig, _, _ , _ = plot_rotor_values(fi.floris.flow_field.u, wd_index=0, ws_index=0, n_rows=1, n_cols=4, return_fig_objects=True)\n", - "fig.suptitle(\"Wind direction 270\")\n", - "\n", - "fig, _, _ , _ = plot_rotor_values(fi.floris.flow_field.u, wd_index=1, ws_index=0, n_rows=1, n_cols=4, return_fig_objects=True)\n", - "fig.suptitle(\"Wind direction 280\")\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "4dc966e1", - "metadata": {}, - "source": [ - "## On Grid Points" - ] - }, - { - "cell_type": "markdown", - "id": "e8241714", - "metadata": {}, - "source": [ - "In FLORIS, grid points are the points in space where the wind conditions are calculated.\n", - "In a typical simulation, these are all located on a regular grid on each turbine rotor.\n", - "\n", - "The parameter `turbine_grid_points` specifies the number of rows and columns which define the turbine grid.\n", - "In the example inputs, this value is 3 meaning there are 3 x 3 = 9 total grid points for each turbine.\n", - "Wake steering codes currently require greater values greater than 1 in order to compute gradients.\n", - "However, a single grid point (1 x 1) may be suitable for non wind farm control applications,\n", - "but retuning of some parameters might be required.\n", - "\n", - "We can visualize the locations of the grid points in the current example using `matplotlib.pyplot`." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "774acfea", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "shape of xs: (2, 1, 4, 3, 3)\n", - " 2 wd x 2 ws x 4 turbines x 3 x 3 grid points\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Get the grid points\n", - "xs = fi.floris.grid.x_sorted\n", - "ys = fi.floris.grid.y_sorted\n", - "zs = fi.floris.grid.z_sorted\n", - "\n", - "# Consider the shape\n", - "print(f\"shape of xs: {xs.shape}\")\n", - "print(\" 2 wd x 2 ws x 4 turbines x 3 x 3 grid points\")\n", - "\n", - "# Lets plot just one wd/ws conditions\n", - "xs = xs[1, 0, :, :, :]\n", - "ys = ys[1, 0, :, :, :]\n", - "zs = zs[1, 0, :, :, :]\n", - "\n", - "fig = plt.figure()\n", - "ax = fig.add_subplot(111, projection=\"3d\")\n", - "ax.scatter(xs, ys, zs, marker=\".\")\n", - "ax.set_zlim([0, 150])\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "e91f7a84", - "metadata": {}, - "source": [ - "## Calculating AEP" - ] - }, - { - "cell_type": "markdown", - "id": "34bc7865", - "metadata": {}, - "source": [ - "Calculating AEP in FLORIS v3 leverages the vectorized framework to\n", - "substantially reduce the computation time with respect to v2.4.\n", - "Here, we demonstrate a simple AEP calculation for a 25-turbine farm\n", - "using several different modeling options. We make the assumption\n", - "that every wind speed and direction is equally likely. We also\n", - "report the time required for the computation using the Python\n", - "`time.perf_counter()` function." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "ee1918d6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calculating AEP for 1440 wind direction and speed combinations...\n", - "Number of turbines = 25\n", - "Model AEP (GWh) Compute Time (s)\n", - "Jensen 843.620 1.230 \n", - "GCH 843.905 5.812 \n", - "CC 839.263 8.941 \n" - ] - } - ], - "source": [ - "import time\n", - "from typing import Tuple\n", - "\n", - "wind_directions = np.arange(0.0, 360.0, 5.0)\n", - "wind_speeds = np.arange(5.0, 25.0, 1.0)\n", - "\n", - "num_bins = len(wind_directions) * len(wind_speeds)\n", - "print(f\"Calculating AEP for {num_bins} wind direction and speed combinations...\")\n", - "\n", - "# Set up a square 25 turbine layout\n", - "N = 5 # Number of turbines per row and per column\n", - "D = 126.0\n", - "\n", - "X, Y = np.meshgrid(\n", - " 7.0 * D * np.arange(0, N, 1),\n", - " 7.0 * D * np.arange(0, N, 1),\n", - ")\n", - "X = X.flatten()\n", - "Y = Y.flatten()\n", - "print(f\"Number of turbines = {len(X)}\")\n", - "\n", - "# Define several models\n", - "fi_jensen = FlorisInterface(\"jensen.yaml\")\n", - "fi_gch = FlorisInterface(\"gch.yaml\")\n", - "fi_cc = FlorisInterface(\"cc.yaml\")\n", - "\n", - "# Assign the layouts, wind speeds and directions\n", - "fi_jensen.reinitialize(layout_x=X, layout_y=Y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", - "fi_gch.reinitialize(layout_x=X, layout_y=Y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", - "fi_cc.reinitialize(layout_x=X, layout_y=Y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", - "\n", - "def time_model_calculation(model_fi: FlorisInterface) -> Tuple[float, float]:\n", - " \"\"\"\n", - " This function performs the wake calculation for a given\n", - " FlorisInterface object and computes the AEP while\n", - " tracking the amount of wall-time required for both steps.\n", - "\n", - " Args:\n", - " model_fi (FlorisInterface): _description_\n", - " float (_type_): _description_\n", - "\n", - " Returns:\n", - " tuple(float, float):\n", - " 0: AEP\n", - " 1: Wall-time for the computation\n", - " \"\"\"\n", - " start = time.perf_counter()\n", - " model_fi.calculate_wake()\n", - " aep = model_fi.get_farm_power().sum() / num_bins / 1E9 * 365 * 24\n", - " end = time.perf_counter()\n", - " return aep, end - start\n", - "\n", - "jensen_aep, jensen_compute_time = time_model_calculation(fi_jensen)\n", - "gch_aep, gch_compute_time = time_model_calculation(fi_gch)\n", - "cc_aep, cc_compute_time = time_model_calculation(fi_cc)\n", - "\n", - "print('Model AEP (GWh) Compute Time (s)')\n", - "print('{:8s} {:<10.3f} {:<6.3f}'.format(\"Jensen\", jensen_aep, jensen_compute_time))\n", - "print('{:8s} {:<10.3f} {:<6.3f}'.format(\"GCH\", gch_aep, gch_compute_time))\n", - "print('{:8s} {:<10.3f} {:<6.3f}'.format(\"CC\", cc_aep, cc_compute_time))" - ] - }, - { - "cell_type": "markdown", - "id": "c006ae1e", - "metadata": {}, - "source": [ - "## Wake Steering Design" - ] - }, - { - "cell_type": "markdown", - "id": "f5777dae", - "metadata": {}, - "source": [ - "FLORIS V3 further includes new optimization routines for the design of wake steering controllers. The SerialRefine is a new method for quickly identifying optimum yaw angles." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "32a93c6d", - "metadata": {}, - "outputs": [], - "source": [ - "# Demonstrate on 7-turbine single row farm\n", - "X = np.linspace(0, 6*7*D, 7)\n", - "Y = np.zeros_like(X)\n", - "wind_speeds = [8.]\n", - "wind_directions = np.arange(0., 360., 2.)\n", - "fi_gch.reinitialize(layout_x=X, layout_y=Y, wind_directions=wind_directions, wind_speeds=wind_speeds)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "7d773cdc", - "metadata": {}, - "outputs": [], - "source": [ - "from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR\n", - "\n", - "# Define the SerialRefine optimization\n", - "yaw_opt = YawOptimizationSR(\n", - " fi=fi_gch,\n", - " minimum_yaw_angle=0.0, # Allowable yaw angles lower bound\n", - " maximum_yaw_angle=25.0, # Allowable yaw angles upper bound\n", - " Ny_passes=[5, 4],\n", - " exclude_downstream_turbines=True,\n", - " exploit_layout_symmetry=True,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "1ccb9ab7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[Serial Refine] Processing pass=0, turbine_depth=0 (0.0%)\n", - "[Serial Refine] Processing pass=0, turbine_depth=1 (7.1%)\n", - "[Serial Refine] Processing pass=0, turbine_depth=2 (14.3%)\n", - "[Serial Refine] Processing pass=0, turbine_depth=3 (21.4%)\n", - "[Serial Refine] Processing pass=0, turbine_depth=4 (28.6%)\n", - "[Serial Refine] Processing pass=0, turbine_depth=5 (35.7%)\n", - "[Serial Refine] Processing pass=0, turbine_depth=6 (42.9%)\n", - "[Serial Refine] Processing pass=1, turbine_depth=0 (50.0%)\n", - "[Serial Refine] Processing pass=1, turbine_depth=1 (57.1%)\n", - "[Serial Refine] Processing pass=1, turbine_depth=2 (64.3%)\n", - "[Serial Refine] Processing pass=1, turbine_depth=3 (71.4%)\n", - "[Serial Refine] Processing pass=1, turbine_depth=4 (78.6%)\n", - "[Serial Refine] Processing pass=1, turbine_depth=5 (85.7%)\n", - "[Serial Refine] Processing pass=1, turbine_depth=6 (92.9%)\n", - "Optimization wall time: 2.085 s\n" - ] - } - ], - "source": [ - "start = time.perf_counter()\n", - "\n", - "## Calculate the optimum yaw angles for 25 turbines and 72 wind directions\n", - "df_opt = yaw_opt.optimize()\n", - "\n", - "end = time.perf_counter()\n", - "\n", - "walltime = end - start\n", - "print(f\"Optimization wall time: {walltime:.3f} s\")\n" - ] - }, - { - "cell_type": "markdown", - "id": "fb2e01e8", - "metadata": {}, - "source": [ - "In the results, T0 is the upstream turbine when wind direction is 270, while T6 is upstream at 90 deg" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "686548be", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Show the results\n", - "yaw_angles_opt = np.vstack(df_opt[\"yaw_angles_opt\"])\n", - "fig, axarr = plt.subplots(len(X), 1, sharex=True, sharey=True, figsize=(10, 10))\n", - "for i in range(len(X)):\n", - " axarr[i].plot(wind_directions, yaw_angles_opt[:, i], 'k-', label='T%d' % i)\n", - " axarr[i].set_ylabel('Yaw (Deg)')\n", - " axarr[i].legend()\n", - " axarr[i].grid(True)\n", - "axarr[-1].set_xlabel('Wind Direction (Deg)')\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c8732cd8", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "jekyll": { - "layout": "default", - "nav_order": 1, - "permalink": "/tutorials/index", - "title": "Overview" - }, - "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" - }, - "vscode": { - "interpreter": { - "hash": "853a8652e3619d46ff0e51baac54f380b0862f9ec17aef8c5e0b66472a177ac0" - } - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/docs/index.md b/docs/index.md index b8f9b6cd2..12ce55392 100644 --- a/docs/index.md +++ b/docs/index.md @@ -26,7 +26,7 @@ fi.reinitialize(wind_directions=[i for i in range(10)]) fi.calculate_wake() ``` -Finally, results can be analyzed via post-processing functions avilable within +Finally, results can be analyzed via post-processing functions available within {py:class}`.FlorisInterface` such as {py:meth}`.FlorisInterface.get_turbine_layout`, {py:meth}`.FlorisInterface.get_turbine_powers` and diff --git a/docs/intro_concepts.ipynb b/docs/intro_concepts.ipynb new file mode 100644 index 000000000..f083c6054 --- /dev/null +++ b/docs/intro_concepts.ipynb @@ -0,0 +1,922 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "86e53920", + "metadata": {}, + "source": [ + "(concepts_intro)=\n", + "# Introductory Concepts\n", + "\n", + "FLORIS is a command-line program written in Python. There are two primary packages that make up the software:\n", + "- `floris.simulation`: simulation framework including wake model definitions\n", + "- `floris.tools`: utilities for pre and post processing as well as driving the simulation\n", + "\n", + "\n", + "\n", + "Users of FLORIS will develop a Python script with the following sequence of steps:\n", + "\n", + "1. Load inputs and preprocess data\n", + "2. Run the wind farm wake simulation\n", + "3. Extract data and postprocess results\n", + "\n", + "Generally, users will only interact with `floris.tools` and most often through\n", + "the `FlorisInterface` class. Additionally, `floris.tools` contains functionality\n", + "for comparing results, creating visualizations, and developing optimization cases. \n", + "\n", + "This notebook steps through the basic ideas and operations of FLORIS while showing\n", + "realistic uses and expected behavior." + ] + }, + { + "cell_type": "markdown", + "id": "699c51dd", + "metadata": {}, + "source": [ + "## Initialize FlorisInterface\n", + "\n", + "The `FlorisInterface` provides functionality to build a wind farm representation and drive\n", + "the simulation. This object is created (instantiated) by passing the path to a FLORIS input\n", + "file as the only argument. After this object is created, it can immediately be used to\n", + "inspect the data." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "602f311c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x y\n", + " 0.0, 0.0\n", + " 630.0, 0.0\n", + "1260.0, 0.0\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from floris.tools import FlorisInterface\n", + "\n", + "fi = FlorisInterface(\"gch.yaml\")\n", + "x, y = fi.get_turbine_layout()\n", + "\n", + "print(\" x y\")\n", + "for _x, _y in zip(x, y):\n", + " print(f\"{_x:6.1f}, {_y:6.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "e1eaeb53", + "metadata": {}, + "source": [ + "## Build the model\n", + "\n", + "At this point, FLORIS has been initialized with the data defined in the input file.\n", + "However, it is often simpler to define a basic configuration in the input file as\n", + "a starting point and then make modifications in the Python script. This allows for\n", + "generating data algorithmically or loading data from a data file. Modifications to\n", + "the wind farm representation are handled through the `FlorisInterface.reinitialize()`\n", + "function with keyword arguments. Another way to think of this function is that it\n", + "changes the value of inputs specified in the input file.\n", + "\n", + "Let's change the location of turbines in the wind farm. The code below changes the\n", + "initial 3x1 layout to a 2x2 rectangular layout." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d040b810", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x y\n", + " 0.0, 0.0\n", + " 0.0, 400.0\n", + " 800.0, 0.0\n", + " 800.0, 400.0\n" + ] + } + ], + "source": [ + "x_2x2 = [0, 0, 800, 800]\n", + "y_2x2 = [0, 400, 0, 400]\n", + "fi.reinitialize(layout_x=x_2x2, layout_y=y_2x2)\n", + "\n", + "x, y = fi.get_turbine_layout()\n", + "\n", + "print(\" x y\")\n", + "for _x, _y in zip(x, y):\n", + " print(f\"{_x:6.1f}, {_y:6.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "63f45e11", + "metadata": {}, + "source": [ + "Additionally, we can change the wind speeds and wind directions.\n", + "These are lists of wind speeds and wind directions that will be\n", + "combined so that a wake calculation will happen for every wind\n", + "direction with each speed.\n", + "\n", + "Notice that we can give `FlorisInterface.reinitialize()` multiple keyword arguments at once." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6f9d834a", + "metadata": {}, + "outputs": [], + "source": [ + "# One wind direction and one speed -> one atmospheric condition\n", + "fi.reinitialize(wind_directions=[270.0], wind_speeds=[8.0])\n", + "\n", + "# Two wind directions and one speed -> two atmospheric conditions\n", + "fi.reinitialize(wind_directions=[270.0, 280.0], wind_speeds=[8.0])\n", + "\n", + "# Two wind directions and two speeds -> four atmospheric conditions\n", + "fi.reinitialize(wind_directions=[270.0, 280.0], wind_speeds=[8.0, 9.0])" + ] + }, + { + "cell_type": "markdown", + "id": "da4f3309", + "metadata": {}, + "source": [ + "`FlorisInterface.reinitialize()` creates all of the basic data structures required\n", + "for the simulation but it does not do any aerodynamic calculations. The low level\n", + "data structures have a complex shape that enables faster computations. Specifically,\n", + "most data is structured as a many-dimensional Numpy array with the following dimensions:\n", + "\n", + "```python\n", + "np.array(\n", + " (\n", + " wind directions,\n", + " wind speeds,\n", + " turbines,\n", + " grid-1,\n", + " grid-2\n", + " )\n", + ")\n", + "```\n", + "\n", + "For example, we can see the shape of the data structure for the grid point x-coordinates\n", + "for the all turbines and get the x-coordinates of grid points for the third turbine in\n", + "the first wind direction and first wind speed. We can also plot all the grid points in\n", + "space to get an idea of the overall form of our grid." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "01ea3a98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dimensions of grid x-components\n", + "(2, 2, 4, 3, 3)\n", + "\n", + "Turbine 3 grid x-components for first wind direction and first wind speed\n", + "[[800. 800. 800.]\n", + " [800. 800. 800.]\n", + " [800. 800. 800.]]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Dimensions of grid x-components\")\n", + "print(np.shape(fi.floris.grid.x_sorted))\n", + "\n", + "print()\n", + "print(\"Turbine 3 grid x-components for first wind direction and first wind speed\")\n", + "print(fi.floris.grid.x_sorted[0, 0, 2, :, :])\n", + "\n", + "x = fi.floris.grid.x_sorted[0, 0, :, :, :]\n", + "y = fi.floris.grid.y_sorted[0, 0, :, :, :]\n", + "z = fi.floris.grid.z_sorted[0, 0, :, :, :]\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "ax.scatter(x, y, z, marker=\".\")\n", + "ax.set_zlim([0, 150])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ebfdc746", + "metadata": {}, + "source": [ + "## Execute wake calculation\n", + "\n", + "Running the wake calculation is a one-liner. This will calculate the velocities\n", + "at each turbine given the wake of other turbines for every wind speed and wind\n", + "direction combination. Since we have not explicitly specified yaw control settings,\n", + "all turbines are aligned with the inflow." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e3bf1698", + "metadata": {}, + "outputs": [], + "source": [ + "fi.calculate_wake()" + ] + }, + { + "cell_type": "markdown", + "id": "e11352e8", + "metadata": {}, + "source": [ + "## Get turbine power\n", + "\n", + "At this point, the simulation has completed and we can use the `FlorisInterface` to\n", + "extract useful information such as the power produced at each turbine. Remember that\n", + "we have configured the simulation with two wind directions, two wind speeds, and four\n", + "turbines." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "cc05bfe7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dimensions of `powers`\n", + "(2, 2, 4)\n", + "\n", + "Turbine powers for 8 m/s\n", + "Wind direction 0\n", + " Turbine 0 - 1,691.33 kW\n", + " Turbine 1 - 1,691.33 kW\n", + " Turbine 2 - 592.65 kW\n", + " Turbine 3 - 592.98 kW\n", + "\n", + "Wind direction 1\n", + " Turbine 0 - 1,691.33 kW\n", + " Turbine 1 - 1,691.33 kW\n", + " Turbine 2 - 1,631.07 kW\n", + " Turbine 3 - 1,629.76 kW\n", + "\n", + "Turbine powers for all turbines at all wind conditions\n", + "[[[1691.32664838 1691.32664838 592.6531181 592.97842923]\n", + " [2407.84167188 2407.84167188 861.30649817 861.73255027]]\n", + "\n", + " [[1691.32664838 1691.32664838 1631.06554071 1629.75543674]\n", + " [2407.84167188 2407.84167188 2321.40975418 2319.53218301]]]\n" + ] + } + ], + "source": [ + "powers = fi.get_turbine_powers() / 1000.0 # calculated in Watts, so convert to kW\n", + "\n", + "print(\"Dimensions of `powers`\")\n", + "print( np.shape(powers) )\n", + "\n", + "N_TURBINES = fi.floris.farm.n_turbines\n", + "\n", + "print()\n", + "print(\"Turbine powers for 8 m/s\")\n", + "for i in range(2):\n", + " print(f\"Wind direction {i}\")\n", + " for j in range(N_TURBINES):\n", + " print(f\" Turbine {j} - {powers[i, 0, j]:7,.2f} kW\")\n", + " print()\n", + "\n", + "print(\"Turbine powers for all turbines at all wind conditions\")\n", + "print(powers)" + ] + }, + { + "cell_type": "markdown", + "id": "8ab273db", + "metadata": {}, + "source": [ + "## Applying yaw angles\n", + "\n", + "Yaw angles are applied to turbines through the `FlorisInterface.calculate_wake` function.\n", + "In order to fit into the vectorized framework, the yaw settings must be represented as\n", + "a `Numpy.array` with dimensions equal to:\n", + "- 0: number of wind directions\n", + "- 1: number of wind speeds\n", + "- 2: number of turbines\n", + "\n", + "**Unlike the data configured in `FlorisInterface.reinitialize()`, yaw angles are not retained**\n", + "**in memory and must be provided each time `FlorisInterface.calculate_wake` is used.**\n", + "**If no yaw angles are given, all turbines will be aligned with the inflow.**\n", + "\n", + "It is typically easiest to start with an array of 0's and modify individual\n", + "turbine yaw settings, as shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "be78e20d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Yaw angle array initialized with 0's\n", + "[[[0. 0. 0. 0.]\n", + " [0. 0. 0. 0.]]\n", + "\n", + " [[0. 0. 0. 0.]\n", + " [0. 0. 0. 0.]]]\n", + "First turbine yawed 25 degrees for every atmospheric condition\n", + "[[[25. 0. 0. 0.]\n", + " [25. 0. 0. 0.]]\n", + "\n", + " [[25. 0. 0. 0.]\n", + " [25. 0. 0. 0.]]]\n" + ] + } + ], + "source": [ + "yaw_angles = np.zeros((2, 2, 4))\n", + "print(\"Yaw angle array initialized with 0's\")\n", + "print(yaw_angles)\n", + "\n", + "print(\"First turbine yawed 25 degrees for every atmospheric condition\")\n", + "yaw_angles[:, :, 0] = 25\n", + "print(yaw_angles)\n", + "\n", + "fi.calculate_wake(yaw_angles=yaw_angles)" + ] + }, + { + "cell_type": "markdown", + "id": "1ef54dc5", + "metadata": {}, + "source": [ + "## Start to finish\n", + "\n", + "Let's put it all together. The code below outlines these steps:\n", + "1. Load an input file\n", + "2. Modify the inputs with a more complex wind turbine layout and additional atmospheric conditions\n", + "3. Calculate the velocities at each turbine for all atmospheric conditions\n", + "4. Get the total farm power\n", + "5. Develop the yaw control settings\n", + "6. Calculate the velocities at each turbine for all atmospheric conditions with the new yaw settings\n", + "7. Get the total farm power\n", + "8. Compare farm power with and without wake steering" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "205738aa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Power % difference with yaw\n", + " 270 degrees: 7.39%\n", + " 280 degrees: 0.13%\n" + ] + } + ], + "source": [ + "# 1. Load an input file\n", + "fi = FlorisInterface(\"gch.yaml\")\n", + "\n", + "fi.floris.solver\n", + "\n", + "# 2. Modify the inputs with a more complex wind turbine layout\n", + "D = 126.0 # Design the layout based on turbine diameter\n", + "x = [0, 0, 6 * D, 6 * D]\n", + "y = [0, 3 * D, 0, 3 * D]\n", + "wind_directions = [270.0, 280.0]\n", + "wind_speeds = [8.0]\n", + "\n", + "# Pass the new data to FlorisInterface\n", + "fi.reinitialize(\n", + " layout_x=x,\n", + " layout_y=y,\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds\n", + ")\n", + "\n", + "# 3. Calculate the velocities at each turbine for all atmospheric conditions\n", + "# All turbines have 0 degrees yaw\n", + "fi.calculate_wake()\n", + "\n", + "# 4. Get the total farm power\n", + "turbine_powers = fi.get_turbine_powers() / 1000.0 # Given in W, so convert to kW\n", + "farm_power_baseline = np.sum(turbine_powers, 2) # Sum over the third dimension\n", + "\n", + "# 5. Develop the yaw control settings\n", + "yaw_angles = np.zeros( (2, 1, 4) ) # Construct the yaw array with dimensions for two wind directions, one wind speed, and four turbines\n", + "yaw_angles[0, :, 0] = 25 # At 270 degrees, yaw the first turbine 25 degrees\n", + "yaw_angles[0, :, 1] = 25 # At 270 degrees, yaw the second turbine 25 degrees\n", + "yaw_angles[1, :, 0] = 10 # At 265 degrees, yaw the first turbine -25 degrees\n", + "yaw_angles[1, :, 1] = 10 # At 265 degrees, yaw the second turbine -25 degrees\n", + "\n", + "# 6. Calculate the velocities at each turbine for all atmospheric conditions with the new yaw settings\n", + "fi.calculate_wake(yaw_angles=yaw_angles)\n", + "\n", + "# 7. Get the total farm power\n", + "turbine_powers = fi.get_turbine_powers() / 1000.0\n", + "farm_power_yaw = np.sum(turbine_powers, 2)\n", + "\n", + "# 8. Compare farm power with and without wake steering\n", + "difference = 100 * (farm_power_yaw - farm_power_baseline) / farm_power_baseline\n", + "print(\"Power % difference with yaw\")\n", + "print(f\" 270 degrees: {difference[0, 0]:4.2f}%\")\n", + "print(f\" 280 degrees: {difference[1, 0]:4.2f}%\")" + ] + }, + { + "cell_type": "markdown", + "id": "99b7465c", + "metadata": {}, + "source": [ + "## Visualization\n", + "\n", + "While comparing turbine and farm powers is meaningful, a picture is worth at least\n", + "1000 Watts, and the `FlorisInterface` provides powerful routines for visualization.\n", + "\n", + "The visualization functions require that the user select a single atmospheric condition\n", + "to plot. The internal data structures still have the same shape but the wind speed and\n", + "wind direction dimensions have a size of 1. This means that the yaw angle array used\n", + "for plotting must have the same shape as above but a single atmospheric condition must\n", + "be selected.\n", + "\n", + "Let's create a horizontal slice of each atmospheric condition from above with and without\n", + "yaw settings included. Notice that although we are plotting the conditions for two\n", + "different wind directions, the farm is rotated so that the wind is coming from the\n", + "left (West) in both cases." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "8bb179ff", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from floris.tools.visualization import visualize_cut_plane\n", + "\n", + "fig, axarr = plt.subplots(2, 2, figsize=(15,8))\n", + "\n", + "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[0]], height=90.0)\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[0,0], title=\"270 - Aligned\")\n", + "\n", + "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[0]], yaw_angles=yaw_angles[0:1,0:1] , height=90.0)\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[0,1], title=\"270 - Yawed\")\n", + "\n", + "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[1]], height=90.0)\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[1,0], title=\"280 - Aligned\")\n", + "\n", + "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[1]], yaw_angles=yaw_angles[1:2,0:1] , height=90.0)\n", + "visualize_cut_plane(horizontal_plane, ax=axarr[1,1], title=\"280 - Yawed\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "d84cf194", + "metadata": {}, + "source": [ + "We can also plot the streamwise inflow velocities on the turbine rotor\n", + "grid points located on the rotor plane. The `plot_rotor_values` function\n", + "simply plots any data given as the first argument, so in this case\n", + "`fi.floris.flow_field.u` contains the yawed calculation from above." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3e517614", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from floris.tools.visualization import plot_rotor_values\n", + "\n", + "fig, _, _ , _ = plot_rotor_values(fi.floris.flow_field.u, wd_index=0, ws_index=0, n_rows=1, n_cols=4, return_fig_objects=True)\n", + "fig.suptitle(\"Wind direction 270\")\n", + "\n", + "fig, _, _ , _ = plot_rotor_values(fi.floris.flow_field.u, wd_index=1, ws_index=0, n_rows=1, n_cols=4, return_fig_objects=True)\n", + "fig.suptitle(\"Wind direction 280\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4dc966e1", + "metadata": {}, + "source": [ + "## On grid points" + ] + }, + { + "cell_type": "markdown", + "id": "e8241714", + "metadata": {}, + "source": [ + "In FLORIS, grid points are the points in space where the wind conditions are calculated.\n", + "In a typical simulation, these are all located on a regular grid on each turbine rotor.\n", + "\n", + "The parameter `turbine_grid_points` specifies the number of rows and columns which define the turbine grid.\n", + "In the example inputs, this value is 3 meaning there are 3 x 3 = 9 total grid points for each turbine.\n", + "Wake steering codes currently require greater values greater than 1 in order to compute gradients.\n", + "However, a single grid point (1 x 1) may be suitable for non wind farm control applications,\n", + "but retuning of some parameters might be required.\n", + "\n", + "We can visualize the locations of the grid points in the current example using `matplotlib.pyplot`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "774acfea", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "shape of xs: (2, 1, 4, 3, 3)\n", + " 2 wd x 2 ws x 4 turbines x 3 x 3 grid points\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Get the grid points\n", + "xs = fi.floris.grid.x_sorted\n", + "ys = fi.floris.grid.y_sorted\n", + "zs = fi.floris.grid.z_sorted\n", + "\n", + "# Consider the shape\n", + "print(f\"shape of xs: {xs.shape}\")\n", + "print(\" 2 wd x 2 ws x 4 turbines x 3 x 3 grid points\")\n", + "\n", + "# Lets plot just one wd/ws conditions\n", + "xs = xs[1, 0, :, :, :]\n", + "ys = ys[1, 0, :, :, :]\n", + "zs = zs[1, 0, :, :, :]\n", + "\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection=\"3d\")\n", + "ax.scatter(xs, ys, zs, marker=\".\")\n", + "ax.set_zlim([0, 150])\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e91f7a84", + "metadata": {}, + "source": [ + "## Basic use case: calculating AEP" + ] + }, + { + "cell_type": "markdown", + "id": "34bc7865", + "metadata": {}, + "source": [ + "Calculating AEP in FLORIS v3 leverages the vectorized framework to\n", + "substantially reduce the computation time with respect to v2.4.\n", + "Here, we demonstrate a simple AEP calculation for a 25-turbine farm\n", + "using several different modeling options. We make the assumption\n", + "that every wind speed and direction is equally likely. We also\n", + "report the time required for the computation using the Python\n", + "`time.perf_counter()` function." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ee1918d6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculating AEP for 1440 wind direction and speed combinations...\n", + "Number of turbines = 25\n", + "Model AEP (GWh) Compute Time (s)\n", + "Jensen 843.620 0.336 \n", + "GCH 843.905 1.422 \n", + "CC 839.263 2.798 \n" + ] + } + ], + "source": [ + "import time\n", + "from typing import Tuple\n", + "\n", + "wind_directions = np.arange(0.0, 360.0, 5.0)\n", + "wind_speeds = np.arange(5.0, 25.0, 1.0)\n", + "\n", + "num_bins = len(wind_directions) * len(wind_speeds)\n", + "print(f\"Calculating AEP for {num_bins} wind direction and speed combinations...\")\n", + "\n", + "# Set up a square 25 turbine layout\n", + "N = 5 # Number of turbines per row and per column\n", + "D = 126.0\n", + "\n", + "X, Y = np.meshgrid(\n", + " 7.0 * D * np.arange(0, N, 1),\n", + " 7.0 * D * np.arange(0, N, 1),\n", + ")\n", + "X = X.flatten()\n", + "Y = Y.flatten()\n", + "print(f\"Number of turbines = {len(X)}\")\n", + "\n", + "# Define several models\n", + "fi_jensen = FlorisInterface(\"jensen.yaml\")\n", + "fi_gch = FlorisInterface(\"gch.yaml\")\n", + "fi_cc = FlorisInterface(\"cc.yaml\")\n", + "\n", + "# Assign the layouts, wind speeds and directions\n", + "fi_jensen.reinitialize(layout_x=X, layout_y=Y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", + "fi_gch.reinitialize(layout_x=X, layout_y=Y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", + "fi_cc.reinitialize(layout_x=X, layout_y=Y, wind_directions=wind_directions, wind_speeds=wind_speeds)\n", + "\n", + "def time_model_calculation(model_fi: FlorisInterface) -> Tuple[float, float]:\n", + " \"\"\"\n", + " This function performs the wake calculation for a given\n", + " FlorisInterface object and computes the AEP while\n", + " tracking the amount of wall-time required for both steps.\n", + "\n", + " Args:\n", + " model_fi (FlorisInterface): _description_\n", + " float (_type_): _description_\n", + "\n", + " Returns:\n", + " tuple(float, float):\n", + " 0: AEP\n", + " 1: Wall-time for the computation\n", + " \"\"\"\n", + " start = time.perf_counter()\n", + " model_fi.calculate_wake()\n", + " aep = model_fi.get_farm_power().sum() / num_bins / 1E9 * 365 * 24\n", + " end = time.perf_counter()\n", + " return aep, end - start\n", + "\n", + "jensen_aep, jensen_compute_time = time_model_calculation(fi_jensen)\n", + "gch_aep, gch_compute_time = time_model_calculation(fi_gch)\n", + "cc_aep, cc_compute_time = time_model_calculation(fi_cc)\n", + "\n", + "print('Model AEP (GWh) Compute Time (s)')\n", + "print('{:8s} {:<10.3f} {:<6.3f}'.format(\"Jensen\", jensen_aep, jensen_compute_time))\n", + "print('{:8s} {:<10.3f} {:<6.3f}'.format(\"GCH\", gch_aep, gch_compute_time))\n", + "print('{:8s} {:<10.3f} {:<6.3f}'.format(\"CC\", cc_aep, cc_compute_time))" + ] + }, + { + "cell_type": "markdown", + "id": "c006ae1e", + "metadata": {}, + "source": [ + "## Basic use case: wake steering design" + ] + }, + { + "cell_type": "markdown", + "id": "f5777dae", + "metadata": {}, + "source": [ + "FLORIS V3 further includes new optimization routines for the design of wake steering controllers. The SerialRefine is a new method for quickly identifying optimum yaw angles." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "32a93c6d", + "metadata": {}, + "outputs": [], + "source": [ + "# Demonstrate on 7-turbine single row farm\n", + "X = np.linspace(0, 6*7*D, 7)\n", + "Y = np.zeros_like(X)\n", + "wind_speeds = [8.]\n", + "wind_directions = np.arange(0., 360., 2.)\n", + "fi_gch.reinitialize(layout_x=X, layout_y=Y, wind_directions=wind_directions, wind_speeds=wind_speeds)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "7d773cdc", + "metadata": {}, + "outputs": [], + "source": [ + "from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR\n", + "\n", + "# Define the SerialRefine optimization\n", + "yaw_opt = YawOptimizationSR(\n", + " fi=fi_gch,\n", + " minimum_yaw_angle=0.0, # Allowable yaw angles lower bound\n", + " maximum_yaw_angle=25.0, # Allowable yaw angles upper bound\n", + " Ny_passes=[5, 4],\n", + " exclude_downstream_turbines=True,\n", + " exploit_layout_symmetry=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1ccb9ab7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[Serial Refine] Processing pass=0, turbine_depth=0 (0.0%)\n", + "[Serial Refine] Processing pass=0, turbine_depth=1 (7.1%)\n", + "[Serial Refine] Processing pass=0, turbine_depth=2 (14.3%)\n", + "[Serial Refine] Processing pass=0, turbine_depth=3 (21.4%)\n", + "[Serial Refine] Processing pass=0, turbine_depth=4 (28.6%)\n", + "[Serial Refine] Processing pass=0, turbine_depth=5 (35.7%)\n", + "[Serial Refine] Processing pass=0, turbine_depth=6 (42.9%)\n", + "[Serial Refine] Processing pass=1, turbine_depth=0 (50.0%)\n", + "[Serial Refine] Processing pass=1, turbine_depth=1 (57.1%)\n", + "[Serial Refine] Processing pass=1, turbine_depth=2 (64.3%)\n", + "[Serial Refine] Processing pass=1, turbine_depth=3 (71.4%)\n", + "[Serial Refine] Processing pass=1, turbine_depth=4 (78.6%)\n", + "[Serial Refine] Processing pass=1, turbine_depth=5 (85.7%)\n", + "[Serial Refine] Processing pass=1, turbine_depth=6 (92.9%)\n", + "Optimization wall time: 1.044 s\n" + ] + } + ], + "source": [ + "start = time.perf_counter()\n", + "\n", + "## Calculate the optimum yaw angles for 25 turbines and 72 wind directions\n", + "df_opt = yaw_opt.optimize()\n", + "\n", + "end = time.perf_counter()\n", + "\n", + "walltime = end - start\n", + "print(f\"Optimization wall time: {walltime:.3f} s\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "fb2e01e8", + "metadata": {}, + "source": [ + "In the results, T0 is the upstream turbine when wind direction is 270, while T6 is upstream at 90 deg" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "686548be", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show the results\n", + "yaw_angles_opt = np.vstack(df_opt[\"yaw_angles_opt\"])\n", + "fig, axarr = plt.subplots(len(X), 1, sharex=True, sharey=True, figsize=(10, 10))\n", + "for i in range(len(X)):\n", + " axarr[i].plot(wind_directions, yaw_angles_opt[:, i], 'k-', label='T%d' % i)\n", + " axarr[i].set_ylabel('Yaw (Deg)')\n", + " axarr[i].legend()\n", + " axarr[i].grid(True)\n", + "axarr[-1].set_xlabel('Wind Direction (Deg)')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8732cd8", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "jekyll": { + "layout": "default", + "nav_order": 1, + "permalink": "/tutorials/index", + "title": "Overview" + }, + "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.12.1" + }, + "vscode": { + "interpreter": { + "hash": "853a8652e3619d46ff0e51baac54f380b0862f9ec17aef8c5e0b66472a177ac0" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/wake_models.ipynb b/docs/wake_models.ipynb index c3ad37473..ddaced065 100644 --- a/docs/wake_models.ipynb +++ b/docs/wake_models.ipynb @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": { "tags": [] }, @@ -73,7 +73,7 @@ " height=90.0,\n", " yaw_angles=yaw_angles\n", " )\n", - " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes)\n", + " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes, clevels=100)\n", " wakeviz.plot_turbines_with_fi(fi, ax=axes, yaw_angles=yaw_angles)" ] }, @@ -94,19 +94,17 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAF7CAYAAADsY3vMAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABfIklEQVR4nO3deXwc5YHn/29VXzpb92FZku9LPrAxYIuQhMPBIZ7MZMMvB8sQSFgyeE0mHEMIGwIhbGJgMmGTLIEkmwFeO2EYmE3IhJAQY64BjA0Ggy+MjQ0+REu+dFiypO6u5/eH1K3uVndLstWWZH3er1cjVdVTTz1dyK366nnqKcsYYwQAAAAAiLJHugEAAAAAMNoQlAAAAAAgAUEJAAAAABIQlAAAAAAgAUEJAAAAABIQlAAAAAAgAUEJAAAAABIQlAAAAAAgAUEJAAAAABIQlAAAAAAgQUaD0ve+9z1ZlhX3mj17dnR7Z2enVq1apZKSEuXl5enSSy9VY2NjXB179+7VihUrlJOTo/Lyct18880KhUKZbDYAAACAcc6d6QPMnTtXzz77bN8B3X2HvOGGG/THP/5RTzzxhAoKCnTdddfp85//vF555RVJUjgc1ooVK1RZWalXX31VH330kb7yla/I4/Hohz/84aDb4DiOGhoalJ+fL8uyhu/NAQAAABhTjDFqa2tTVVWVbDtNv5HJoDvuuMOcccYZSbc1Nzcbj8djnnjiiei67du3G0lm3bp1xhhjnn76aWPbtgkEAtEyDzzwgPH7/aarq2vQ7di3b5+RxIsXL168ePHixYsXL15Gktm3b1/aDJHxHqWdO3eqqqpKWVlZqq+v1+rVq1VbW6uNGzcqGAxq2bJl0bKzZ89WbW2t1q1bp6VLl2rdunWaP3++KioqomWWL1+ulStXauvWrVq0aFHSY3Z1damrqyu6bIyRJD1sT1GOxW1ZAAAAwHjVYRxd5exRfn5+2nIZDUpLlizRww8/rFmzZumjjz7SnXfeqY9//OPasmWLAoGAvF6vCgsL4/apqKhQIBCQJAUCgbiQFNke2ZbK6tWrdeedd/Zbn2PZyrFcJ/muAAAAAIx1A92Sk9GgdMkll0S/X7BggZYsWaJJkybp8ccfV3Z2dsaOe+utt+rGG2+MLre2tqqmpiZjxwMAAABwejml49AKCws1c+ZM7dq1S5WVleru7lZzc3NcmcbGRlVWVkqSKisr+82CF1mOlEnG5/PJ7/fHvQAAAABgsE5pUDp27Jjef/99TZgwQYsXL5bH49HatWuj23fs2KG9e/eqvr5eklRfX6/NmzerqakpWmbNmjXy+/2qq6s7lU0HAAAAMI5kdOjdP/zDP+izn/2sJk2apIaGBt1xxx1yuVy67LLLVFBQoKuvvlo33nijiouL5ff79Y1vfEP19fVaunSpJOniiy9WXV2drrjiCt17770KBAK67bbbtGrVKvl8vkw2HQAAAMA4ltGgtH//fl122WU6fPiwysrKdN555+m1115TWVmZJOm+++6Tbdu69NJL1dXVpeXLl+vnP/95dH+Xy6WnnnpKK1euVH19vXJzc3XllVfq+9//fiabDQAAAGCcs0xk7uzTWGtrqwoKCvS4axqz3gEAAADjWIcJ64vh99XS0pJ2LgMeKgQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACU5ZULr77rtlWZauv/766LrOzk6tWrVKJSUlysvL06WXXqrGxsa4/fbu3asVK1YoJydH5eXluvnmmxUKhU5VswEAAACMQ6ckKL3++uv6xS9+oQULFsStv+GGG/SHP/xBTzzxhF588UU1NDTo85//fHR7OBzWihUr1N3drVdffVWPPPKIHn74Yd1+++2notkAAAAAxqmMB6Vjx47p8ssv169+9SsVFRVF17e0tOjXv/61fvzjH+vCCy/U4sWL9dBDD+nVV1/Va6+9Jkn6y1/+om3btulf/uVftHDhQl1yySW66667dP/996u7uzvTTQcAAAAwTmU8KK1atUorVqzQsmXL4tZv3LhRwWAwbv3s2bNVW1urdevWSZLWrVun+fPnq6KiIlpm+fLlam1t1datW1Mes6urS62trXEvAAAAABgsdyYrf+yxx/Tmm2/q9ddf77ctEAjI6/WqsLAwbn1FRYUCgUC0TGxIimyPbEtl9erVuvPOO0+y9QAAAADGq4z1KO3bt0/f/OY39Zvf/EZZWVmZOkxSt956q1paWqKvffv2ndLjAwAAABjbMhaUNm7cqKamJp155plyu91yu9168cUX9dOf/lRut1sVFRXq7u5Wc3Nz3H6NjY2qrKyUJFVWVvabBS+yHCmTjM/nk9/vj3sBAAAAwGBlLChddNFF2rx5szZt2hR9nXXWWbr88suj33s8Hq1duza6z44dO7R3717V19dLkurr67V582Y1NTVFy6xZs0Z+v191dXWZajoAAACAcS5j9yjl5+dr3rx5cetyc3NVUlISXX/11VfrxhtvVHFxsfx+v77xjW+ovr5eS5culSRdfPHFqqur0xVXXKF7771XgUBAt912m1atWiWfz5eppgMAAAAY5zI6mcNA7rvvPtm2rUsvvVRdXV1avny5fv7zn0e3u1wuPfXUU1q5cqXq6+uVm5urK6+8Ut///vdHsNUAAAAATneWMcaMdCMyrbW1VQUFBXrcNU05lmukmwMAAABghHSYsL4Yfl8tLS1p5zLI+HOUAAAAAGCsGdGhdwAAAADGJ8dYp/R4lnoG0g12PB1BCQAAAMApdczka6s5S5IUlktGqUNTJOCciGT7+kxA0vsD7ktQAgAAAMa5buNVi4qHvd5UIadd+SqoCKuurl0fOnOHXK+RpXAwfEJtynbb0gsDlyMoAQAAAONUmylQo6rVYGrkyCVvXkzPToqOnMH18PSVSdZXFLZcys3z6JC7Uktmt2rWwpykQ+IGGiZnZMl0dfeW7X+kZLu3Hc8hKAEAAACjUci41aQqtaoo48dKFWy6TJYOqUKeUq9qpno1u87I44kPG8mGxCWGl3DISXv8ZGHHsqTaiUFNnOKWZbmj65KVS8/I2Cb6/WC4XenbGy03qFIAAADAacgYKSTPkPc70ftmuuVTQNUKmFq1K0/FM3Pk8qRPA8mOler4A7er71jGWFpYFdT8eUbTFvjkdg3/U4NMKJhmq2/YjzecCEoAAAAYd0LGrUOq1D4zNUWvTqogkrg89HBRmN+uKXN8mjgrR/MW2HJnuVPWYkzf0LK+lg08W1xsL06qXiG37aikKl8KhTTY3pjxhKAEAACAU6rVFKpDeUPe72RmP4s7vorUbIrVqmIVzszVkjlGljW4aaOdJBMIJLs3JrotyXbbypUkTalsV2l5gazsgXpWvD1f0vbOnDgiUnIEJQAAAGRc2Ng6rArtN1PUpIny5kqpe21MwnJ/kV6S9OEpda/QpCkdmjKpWJ9c0qbKeZUDtn/IMhRqcOoQlAAAAMaZNlOgj0yNjis3TanBDPDqM9A9M20qkEthOZMn6ow52erMrdHEombNKD+YcNSEVqTorYnr/QmF+m9P0/qefbNkW8dVlNORshzGN4ISAABABgWNR47sU3a8dD0sLSrWATNZDZqkcFGBcspzUwccyyhZX07y8umngo5syHMfU1VNtmbOc+tgVrEqSrI0fcbQJ1KIc9I9N729SUnCFsY3ghIAAECGBI1Hb5rz1KHcmN6bSJQ4uTtDBnO/TrIy1dO79PE6t8JllSqflK0sb5LeGJN6MgAn6bNuLCkcju4bOazp14IyWTIK2lK+l6FpGN0ISgAA4LQSNrYOqmpU9OJ0y6egvJp/nqVQ+QQd7siTyzJywuF++0fvuUkxqYCVZCHdcLe+e3j6IpllSSYUVrevS3mFWZq/yJE/d3DPlElkh7oHLpTG7gaPmltO3f8jYKgISgAA4LRyXHnaZ6aps7Rcx8J56jTZ/cokfy5N6sAQDSlWskkG0ocVx+XTh+EsnTHBpaVn5SmvKslsb+G+Xp3Ee3L6habE5XB8j1Bi+VT3+FjhoPJzOpNuA0BQAgAAGdBqCvWBmaEO5ae8qX7oUz3H3geTet+gfGo3uaqeWaYZ08rk8eepIKezZxhYkt2ckJN2eufo0U3f/iZhvaS4XqLY41SWBzX1nFKVlkaCWP8hZ1b4xO+PscMnOISNWdmAtAhKAACcprqMT45cGas/XVhpVomsCr/yJ03Roc4iBcNuWdEskj4gWZaRBhFcehuRlD/LaMp8txacn6eSWcWybck+gTBiO0MPE1bS4HJiw9sAjByCEgAApxFjpGaVapep014zvfc+ndTBJF0ciR+KlmyoWmqObNmd2Zriy1P9x3I149wSeXxWXM9N0laFkj3MM2E5tg2hxGFnPfXnFbuUX9F/yB0ADBZBCQCAYdRqCtViigYxkcAgplOObh+gB6Z3e0ge7TazdcBMVqi4WBXT/cot8klOTOCJucfGGDuh7t6Q4etUcW6HjJPi+TW9eyVOSJBo2uSQ5l5Yrpyp5TG9Sem5wkObIMB1Aj0+ADAYBCUAAIZRo6rVWDpbTaFyHQvnK2R6ftXG5oSEW/VjVsQHIjsxIMWVM/3qMsaWq8iv6sm5mnV2niZ/coK8+d5oj4xL4b57bPrd8N/ztbXNJac7pDMXDnyTv8skH8oWqSsSjiyH59MAGHsISgCAMe9DM10HzGR1miyZ3p4cKyZMxErs2EjW0zHwJAOpthu1mwJ584tVO61ads0k5eYZuVym99kyVtwzZiynp0fGiYaXfhEqofre7U4ofgib6SlrW9KkWW5VLalQeXlYti1JfSHFpfQ9QJJ0oEE6FBiwWFqD7T0CgNGMoAQAGHaOsdSpnFN2vGZTqqw5VQrlT1FTe6FCpmcCg2TDyvoMbuhbYmiyLCPH6X9jfvQRoo6lsiqPppzrV+355Sqs9MmVZj6FgcKLreQzqSV+7+oNRG63pEEEIgBAegQlAMCw6TZe7TNTtcWcpYNmgqzo3SzpRXp/+vX2JOsRsvqv6zZZym7L1dRJhTr/r0vln1slj7fn1pxIgEjsgYkVOyTNSbgvJ3bZZYJyIvWY2DI9X20TlstllDupWAWFRm7r5ANLbO9Mup6azM1tBwDjE0EJAE4DxkhHTJkOqSJtuZMdEZUu+LSpQLvNHH1kJso7uVKFk8rkcsfuG9PemFosGck4ktVTptzfIds20eFkKVsSDkfrtCxp3jk+lX98qlwFeXGBwm2nn5bZlSbMDLSv2051781Qnw8EABhtCEoAMIaFjFsHTK02O+dop+bL8eerZ2LmZPfmGBn1hBFL6pea4gOQifsaKRoOm96wFM9IcrktlZQanb80X766aTpeWKWiCld0e+yDOl29vUKJEwsE9hnNXWiUnZvQDEluO36f2O+9bkdeX7+3DADACSMoAcAQhI2tt8zHFDDVCsqbsly64WaDGYoWWzZ5+Z51HcpTq4qUPaVEU6dVq2hBtTweI5PkHhoTtqJ72o4THzjUN6GA1BdAbBOOWzaRyQgS22mcaKhpcRsVBS0VllqqrEn+vtwpxokdDkger+RNcmrdaWbbTrcNAIATQVACMOYFjUddGujBksMzFCoor46oXKUfn6U9bTU63JGr7nD89M/Giu1xSZjC2Yr7Io8dkss2Mk7vVGix96PENDvVvSmW5SjLE9S0uizlnDFZBXUlsj39y7mTfNqnCiuJ66NTS9vJn/rpjszopviznOVl+BkAYOwiKAEYs1odv7aas/SmOU/HVBBd338ImekdbpZ8uuhIOrHkJKxNPQX0/E5bdfX52uedqbZwtnLye6Zmlnqnao70yPQOd4u0JLJgW0bdXVJRqVRe2TscLSGIROpxu4xMTNMiPT9uKz6g5OZK7iwpNMwTnkVCmp2i18ZOEbiYIhoAMJYRlAAMi2PGr71mmrocr4K9s4x55JYVc7WcOqikEj/sLPJ9WC4d0gRtN2eqSROUP6NCxbX+FHVYMo4jq/fISS/ejSWpZyhadHvCRALRSQN6w9R+W2r9yChvhpRf1K2CkviQ5fb0TxUed/zBDx2wFXZLod7OsLAkt7t/A0Oy5PH0rY/U7HEnlhOzQgMAMEwISgCGxWGV652ST+lAqEzPH/0bSdK83JdlW31D4kzYiZsEoK8HJ8m00KmGmvWWtV1SzRRbH19SpVZ/tY4e3ydJcnvccffQuN22evp1eu6tccfczGKM5PH2fAxGbulJ3O7uHYcWO+mAy9VXpsOWCvLTz4wGAADGHoISgGHjtTt1zqfy9PzjPcvlF8yX253bb2azuL6aJN9G7s0xTvwzc4wjebOkigmmd0iao3COVFYmdQR6worbk9izE9NFFLfcw5NwH43bk35ZktzuhDJJeoEAAMDYRlACMKxih8p1hF+Tq7dHyeVxR5OQyxMzpZmRPL6+ZTth1oHYHqLuTpfa2rKV4z4e3e4Ku6TAML8JAAAw7hGUAGSMZfUNobOiD++R7IRJC2xX37IrobcmdtkJO7ISZ14DAADIgIw+eeKBBx7QggUL5Pf75ff7VV9frz/96U/R7Z2dnVq1apVKSkqUl5enSy+9VI2NjXF17N27VytWrFBOTo7Ky8t18803KxRK9SR0AAAAADh5GQ1K1dXVuvvuu7Vx40a98cYbuvDCC/U3f/M32rp1qyTphhtu0B/+8Ac98cQTevHFF9XQ0KDPf/7z0f3D4bBWrFih7u5uvfrqq3rkkUf08MMP6/bbb89kswEAAACMcxkdevfZz342bvkHP/iBHnjgAb322muqrq7Wr3/9az366KO68MILJUkPPfSQ5syZo9dee01Lly7VX/7yF23btk3PPvusKioqtHDhQt1111265ZZb9L3vfU/eZI9uBwAAAICTlNEepVjhcFiPPfaY2tvbVV9fr40bNyoYDGrZsmXRMrNnz1Ztba3WrVsnSVq3bp3mz5+vioqKaJnly5ertbU12iuVTFdXl1pbW+NeAAAAADBYGQ9KmzdvVl5ennw+n6699lr97ne/U11dnQKBgLxerwoLC+PKV1RUKBDomcIqEAjEhaTI9si2VFavXq2CgoLoq6amZnjfFAAAAIDTWsaD0qxZs7Rp0yatX79eK1eu1JVXXqlt27Zl9Ji33nqrWlpaoq99+/Zl9HgAAAAATi8Znx7c6/Vq+vTpkqTFixfr9ddf109+8hN96UtfUnd3t5qbm+N6lRobG1VZWSlJqqys1IYNG+Lqi8yKFymTjM/nk8/nG+Z3AgAAAGC8OGX3KEU4jqOuri4tXrxYHo9Ha9eujW7bsWOH9u7dq/r6eklSfX29Nm/erKampmiZNWvWyO/3q66u7lQ3HQAAAMA4kdEepVtvvVWXXHKJamtr1dbWpkcffVQvvPCCnnnmGRUUFOjqq6/WjTfeqOLiYvn9fn3jG99QfX29li5dKkm6+OKLVVdXpyuuuEL33nuvAoGAbrvtNq1atYoeIwAAAAAZk9Gg1NTUpK985Sv66KOPVFBQoAULFuiZZ57Rpz71KUnSfffdJ9u2demll6qrq0vLly/Xz3/+8+j+LpdLTz31lFauXKn6+nrl5ubqyiuv1Pe///1MNhsAAADAOJfRoPTrX/867fasrCzdf//9uv/++1OWmTRpkp5++unhbhoAAAAApHTK71ECAAAAgNGOoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJAgo0Fp9erVOvvss5Wfn6/y8nJ97nOf044dO+LKdHZ2atWqVSopKVFeXp4uvfRSNTY2xpXZu3evVqxYoZycHJWXl+vmm29WKBTKZNMBAAAAjGMZDUovvviiVq1apddee01r1qxRMBjUxRdfrPb29miZG264QX/4wx/0xBNP6MUXX1RDQ4M+//nPR7eHw2GtWLFC3d3devXVV/XII4/o4Ycf1u23357JpgMAAAAYx9yZrPzPf/5z3PLDDz+s8vJybdy4UZ/4xCfU0tKiX//613r00Ud14YUXSpIeeughzZkzR6+99pqWLl2qv/zlL9q2bZueffZZVVRUaOHChbrrrrt0yy236Hvf+568Xm8m3wIAAACAceiU3qPU0tIiSSouLpYkbdy4UcFgUMuWLYuWmT17tmpra7Vu3TpJ0rp16zR//nxVVFREyyxfvlytra3aunVr0uN0dXWptbU17gUAAAAAg3XKgpLjOLr++uv1sY99TPPmzZMkBQIBeb1eFRYWxpWtqKhQIBCIlokNSZHtkW3JrF69WgUFBdFXTU3NML8bAAAAAKezUxaUVq1apS1btuixxx7L+LFuvfVWtbS0RF/79u3L+DEBAAAAnD4yeo9SxHXXXaennnpKL730kqqrq6PrKysr1d3drebm5rhepcbGRlVWVkbLbNiwIa6+yKx4kTKJfD6ffD7fML8LAAPpCmep+Vjfv71jrbmy7WxJUlauo6yc4Eg1DQAAYEgy2qNkjNF1112n3/3ud3ruuec0ZcqUuO2LFy+Wx+PR2rVro+t27NihvXv3qr6+XpJUX1+vzZs3q6mpKVpmzZo18vv9qqury2TzAQxBiRpVfHiX3n66b0hs/rGJqnImaHrNXBWVzR3B1gEAAAxNRnuUVq1apUcffVS///3vlZ+fH72nqKCgQNnZ2SooKNDVV1+tG2+8UcXFxfL7/frGN76h+vp6LV26VJJ08cUXq66uTldccYXuvfdeBQIB3XbbbVq1ahW9RsAokme1abnrt1oQXqt1pmddaNPbyp5XLm+xUbuvSlm+s2UkGUkuy5J6vzfBnq+2LAW7eys0km1bCkcWTU+ZnGypyN+3TpJsy5JxorvJZcdsj6z3dauz60hm3jwAADjtZDQoPfDAA5Kk888/P279Qw89pKuuukqSdN9998m2bV166aXq6urS8uXL9fOf/zxa1uVy6amnntLKlStVX1+v3NxcXXnllfr+97+fyaYDOEFF9lFF0s1f6V/01pbl2rrFkVPYLF+uR1ZvOcuK388YI8uSLPWkHyP1lY0pZ1tG2192ekr0bjCyJMfpV2+kLsdYyi32qfbsUuVOK9LRY4fkcvdsC4djKjfx+0eCWOx2SdFQFll2wn3fR1aHY56J7fFJ9imdYxQAAJysjAYl0+8qo7+srCzdf//9uv/++1OWmTRpkp5++unhbBqADPHJ0r+7pvd+/7bO0BYdcCZpc/M56m7Oipaz1P/zwZKTdH2ycjELsV+S1t9u8tXWVSvXnsnaf2SWPD6fbFuyLEfdMfsY09vL5cQeoyfxGFnR4GRZ4cgOfeUtyTLhaFuM+ooUlrnlrfErrzQkb98pAAAAo9gpmcwBwPhhWZayYmKLS45qXXtUqz0j1qYPzEytO3iR3l9r65iaFZY7poWxwaxnYGCybZb6h7FUZfv2MTKy9IE/X+XTCjRxYamyZ5TraEdYli11tUu5fqmjra/3yt37qZz4dyZ3wqe1MZLHHb8sxQw7dOK3uVw93+fkSdm5/ZoKAAASEJQAnPbKdUD11ho5ViY/8uKTTaRHq1klagjPkL/sLB1qsNTw7jHJqDdCSY43pC5PuF9tPb1SMTHMCcuy+gKRMcmGL1rxFUT3NdHQlpcvzbiwQlZ1hfzFDAkEACAVghKA016O1a7J1q4ROfYhU6HA8RrtWvOhOk1TzJaexNPau5R8KGIsE7M2+fDEyHDB/j1ffb1bTcpVx4EjKplzVFkzJ6qotHdIYeR+KyO57HDfspPYu2X1DUs0fduc6FhDyZYTN7lGZCKOwgKjnNpCFZUmbT4AAKMKQQkAMqhEjbrQ+r1MYvfPEAzmvq3BOKoybTZnK8tTp31vHlfLawfjtvfMPJgksCU0PdVww4GGITrGVuXMQk09t0T+OZUqLOnp0YotHe7fuQYAwIggKAFABlmW5FPXSDdDkuQ3R1WqgFpf71SlXEr2yO7EoJQ+pKWYFjC6b9/+IXnUZKpUVD5BjW/NVMOOrp5gZhnJcaLDCo2RAo3H5HL1TpQRGWooS5YT7j8ToWIm4Yj93kgmHFM+Yb+CvKBqzq+Vq6xYLk+atwgAGLcISgAwTuRY7VpkrRuRY3eabK03F6hhvXTUhBSUN6FE3/i/HRroaejxk2z03PGVeshh4n6WjILKUsXvWzXvzCzN+8wEOVUTkx7GZfcFr2RNiGyXSV4uWQ9dYrksr1FJidOv5w4AMLIISgCAjPPpuOZYmzRdWwc1DDF5T1b6IYj990k1NFA6rApt37JIz2+u0usvtqtmRkPv/ibFHpEajYwTcwOWEoYmxkyokTjhhrFM3PbYds86M0fTLqxUyaQceRMzJABgRBCUAAAZZ1lSuRqSd/uMgAnar1nmHTWYWm3/cJEaPyyTNNj7wRJ7tOK3DVRH4vbjJkftDX4d2NmusjkVKqz0RKeDt8LhvokyIkcwVnSSjEhzjJHs3ud4xQ5FlPqGNCY0XXLC8mZZmrCwSBMnhvpNQQ8A4x0fiwCAccljBTXJel+15v0kQwHjDdeEGsm8ac5TTt5UHfogqP07WuUYV+8shZFjp2qUkQn1znRoJWmflS7Q9awNOy4VTcjVtPnZmnVhhYprfeo8nnpmRQAYTwhKAIBxzbIkr7pH7PglalTrm13KkUc5CdsG6oAbTIBLXcboqClTgbdAHXsn69X/55JtGdmWUVF+lzybW3tLJewVcvrXFNNrleoxzHH3byXUYWRFt2d7gyossjT/U2Xq8vkHfH8AkCkEJQAARtB0a9uIDUncYhbr4LsTtH+7UYcOxW17OTr5hZTufq8+ifd4pSsbu73vgcglU1yau8DW8Vm1mnTMpVA4floPk2TBdlw9i+lvUes5VsL085F9LMvInxdmQg0AcQhKAACMU7V6X2VWIGWayeSQw0QdylPgg4l6bU+tzISD2vJam7y+JPMf9rbVCYfjmp0482HS4YhJqorEwZpa6cxzfSqfXyGPh6GHAAhKAACMW36rWX41j3Qzomq1U0etMn0QmKnGQHXcML5Y6YYTngjH2GqqzNb+3cWasSCsyqk5yvbFdz9FhxYmTq6hmKnhQ6GkrYgbmpgw82FcP1zIke22VVHjUXmVJTv9PPkAMoygBAAARgXbMipRk0qsJoWNK2VQSuVEe8D2WdMUyqpS6xFL69cE1R1ulxR7v1VfvUbJJ7voG7Y38DBFJxQ/TDG23Y4sFRbZmjkvWwvP9alqRrZ83p57uvqFtEj4CicPYMnK9i1bUsjutz3L1/8eNGC8IigBAIBRx5V4Q1EGFZpDCuzNlse8reIBwlmqMHayE2tEBOXTR6ZWz73h1zuvF2jitC758ryJxfrtnWySjf61D2xCaZfm1eerakJQbjdDEDG+EZQAAMC4VmgdUaGOjJrnfM02mxQwNdq9bZZ2bC2QpUgISt3Hli6oJT5MOVVZR7a2lpfq7Tc6NWlmjs5Y7FZ2eX50e2yvlJFkh4Jx+8fPchj/8OVkjh7zymuN3IyTwEAISgAAAKNIltWpydZO1ZjdarZK5KhviFwmJ9hwZOvgwQnad3CqGl7P1863C1RU2pp6B2PFt8cyCgcjz/ZKKJoQ8SL7+b3t2u1rTxoBq0o7VbcoW0VzJp7YGwJOEkEJAABgFHJZYZWo6ZQes9z6SNPMdgVUrQ+3zlAg5mHMyXqzUk8Vn07f9oMp6jKS1sun5/7T1hnzdmvhYrcKq/IHrN2Egv3u10q1T7Jy8dtjvu/u6T3zuUPK81uyi0rS7ovTA0EJAAAAUVnWcU22dmqS2XnKJtRIZGTpiMrU8OFkvfxhrda9YFRY2zfUzwmlv4ftZEJd4hpLRrblqKKwQ0U1RfrMRccGaj5OEwQlAAAA9GNZp/ZZWnHHllGpmlRqNWma2aamjokKvesZ9mMMhiNbR02pAupWw1G/rC5HlRObUvZIJQuXqe7TGmgfJxRWfk5IMxbkKLs4d1DtxfAhKAEAAGDUyrWOaYp2jGgbwrJ1WJU6sNPolZ0VsnVcQ31uV+pglnzK+ejWXJ8mzenQ7NkdOuessLzlJzfsL1locwaYFT5ZkHPZp/+siAQlAAAAIA2X5ahcDSq3GtRmChSMuXfrZA3Us7W7fbaqzDHt2LtQO/ZKlhWKbjOy5ASTp5yBerGGpq8yrx2UN8ercxa0adqC/DT7jH0EJQAAAGCQ8q2WU3q8bHXo7Y2FCml/3AyIEcmC1mCe2dV/n4EZWaqYcExZkwr1wYEiWdmh9OWNJSW0OXHCjZT3wSU01esOqXqq95T2ZBGUAAAAgFGqznpz1Dzjq9NkqyFQq50f5Wnza8f09lTvIO71MnFhyLKGEuz6tgUdjyomhlU3u1tz5nuVndc/NA43ghIAAACAAWVZxzVVO1Sj3TqoCTq+J36CieGf/KOvvjZTJDvLpb27S7X7oF8Fcc/fyurbo3eX2JkRE4chul1tgzo6QQkAAADAoHmsoKq095Qe80NNV8P2CXJtb1S7jstoqB1tfWkpyzQOag+CEgAAAIBRrUofqsA6ErfuRHuwutU5qEkLCUoAAAAARjWPFVShjgxccBA6lP6BxRGZvwsKAAAAAMYYghIAAAAAJCAoAQAAAEACghIAAAAAJCAoAQAAAECCjAall156SZ/97GdVVVUly7L05JNPxm03xuj222/XhAkTlJ2drWXLlmnnzp1xZY4cOaLLL79cfr9fhYWFuvrqq3Xs2LFMNhsAAADAOJfRoNTe3q4zzjhD999/f9Lt9957r37605/qwQcf1Pr165Wbm6vly5ers7MzWubyyy/X1q1btWbNGj311FN66aWX9PWvfz2TzQYAAAAwzlnGmBN7UtNQD2RZ+t3vfqfPfe5zknp6k6qqqnTTTTfpH/7hHyRJLS0tqqio0MMPP6wvf/nL2r59u+rq6vT666/rrLPOkiT9+c9/1mc+8xnt379fVVVVgzp2a2urCgoK9LhrmnIsV0beHwAAAIDRr8OE9cXw+2ppaZHf709ZbsTuUdqzZ48CgYCWLVsWXVdQUKAlS5Zo3bp1kqR169apsLAwGpIkadmyZbJtW+vXr09Zd1dXl1pbW+NeAAAAADBYIxaUAoGAJKmioiJufUVFRXRbIBBQeXl53Ha3263i4uJomWRWr16tgoKC6KumpmaYWw8AAADgdHZaznp36623qqWlJfrat2/fSDcJAAAAwBgyYkGpsrJSktTY2Bi3vrGxMbqtsrJSTU1NcdtDoZCOHDkSLZOMz+eT3++PewEAAADAYI1YUJoyZYoqKyu1du3a6LrW1latX79e9fX1kqT6+no1Nzdr48aN0TLPPfecHMfRkiVLTnmbAQAAAIwP7kxWfuzYMe3atSu6vGfPHm3atEnFxcWqra3V9ddfr//5P/+nZsyYoSlTpui73/2uqqqqojPjzZkzR5/+9Kd1zTXX6MEHH1QwGNR1112nL3/5y4Oe8Q4AAAAAhiqjQemNN97QBRdcEF2+8cYbJUlXXnmlHn74YX3rW99Se3u7vv71r6u5uVnnnXee/vznPysrKyu6z29+8xtdd911uuiii2Tbti699FL99Kc/zWSzAQAAAIxzp+w5SiOJ5ygBAAAAkMbAc5QAAAAAYLQiKAEAAABAAoISAAAAACQgKAEAAABAAoISAAAAACQgKAEAAABAAoISAAAAACQgKAEAAABAAvdINwBI5ogp0y4zV+0mT0ZWv+2WjCwlPit58M9OLtBRzbTeUa7dfpItBQAAwOmIoIRTrsM4etm0qdEEdYWrNGmZVhWqsWqhjuVPVsOxUnWF3IrNS5YlKdwbjCyjyMae8GRkLKsnN1l9u/XtbnSsoV0lplHzzeuab21QiXVQQwlaQ9U/1MVvs/pnQQAAAIwgghJOuUMK6qdOo1yS/toUqsBK/mPosbt0xmJbhQXTdThcIH9Bz3pjJDsmeDi96yTJpZ64Y0xvOcuJbot8DQUltbTKvTdLu7d69O7BRfLpeG9tffUmZhdLTsJyOk6KOiL19wQ6S1KOjmmBtV6T7Z3yWt1pawUAABhuIePWQU1Qi4qTjuRJJd0fgofDidU/8D62aZb0/oDlCEo45Wotn6bJp/fVpZdMmz5rFaUtn51tVFpkqbWzUW6PS5IU7t3m8brjbrRze+Jvu4uUjy67bXV2SDpSKMuqkru7QMFqS12WJFmKyzGWJKc38Fg9QSvS8+OyjXJ8oZ6FhM8T40gy4f6bIgsmfl1DoEO7P5ijKmev5lsbVKYDciuU8sPBkhkopZ0SLjkq1CF6wwAAo0K38Q7pIn8gozMEDC8jS/s1RYdNhXzqVMG8oqS3NyRtq6V+53ug/Qo9Lcp1H9eJOJmzZUx8O0PGJW0YeD+CEkbEhbZf7zsH9ZzTqs/a6YPScPP6pON5jrpqKlU02VZRTI+TkeSyY/5ZG8ntsqK9UWEjOUGps12aeUZfcIpsjy0rSbYdrabvG9O3XpI69nfI/eFuHd7i1YuvlCgkT++HVKKeWixZfRUNINkHmxWtJ/HDrP+xEpdtGbkUUoF1VJXWXp1tvaQccZ8XAGBkdZhcbTbnyJKRkaWwXAPvpGS/J9P9bky339iVXeHWsjnvSyVV2u+Zpon+I/3KJF6VmCRvf6AygbZCVRYc1dyK/QO2KRwMDdzwk9DW5SMoYfT6pJWvX+ugdqpL+023qi3vKTu27ZJyC4PKLexZdrsTe6Hilz3u+H/4wW7pw+22XFmK601xuyMBpnc/T/+PV0+Sf3F+x+hgY5Zc02dq5uSe/Y3Tv5yRZJu+oYRx92yp5wPKMn1lLcdJ2FtyIsHOsSTjJA9jCT1ePat7fiW4FZJXncpr2qIDrxzXO1oir+ns39jo7kP7RTKY8ifyyyl+nzQ9dSdUXx9bjrKs46rR+/JYwaE0EcAYZIzUomK1qXBI+w33RfbJ13fqLvqH873H1nVcOfJXhHX2/CPaY+Yr5AwuKJ2oZEEhIhwMR79PPeoi9R8yI4Ej2b7p/gDad8xkZVKwenqPdmmR7GPZmjCxTfOqm1KVPinvHTTq6hpcWVeyC6Zh5HKSXGglQVDCiCi03DrTytUbpl3PO60pJ3UYF0pzVXzhdBUnrHbFfMZHe6xiMlzkY9BtJ/RYRffvCz2x92m5Xabf57PLjl/R10Nm+nrTwlJXS0gHX9+vPUfm62D1BB21FkT36R9G4oOjFPNBnfCJHbtvvw9zq6+9sRNySJITTuwds3p/sSQJRnHBMv3kGvGTgyTUE1dZb0+bFVa2q0tlvsNq3bFb5VaDPCIoAaersHHpoCboI1OrIyqTf2LkDlmp3+fegCPB0nz+DUJPD0rscvIyAx072b4m6WdhmnqTXKAbWXHlwl2x7zd9b07qdZH9+ziylVWUow81QXWzujVjhiM7pj1OMNRv+FXKszKIcollUu4bCvYLVamGB/Yr168dqX9CUh3DdIeSj1FJ+ua7lO3hXulYBCWMmAus/J6gZFp1uSmRPU5vdrFdPa9E7iT/Ot3JyqX4o9lQ1nsGW7bMrYrJk+WbJy04/JFqKns+UPv9qjO9k2k44X6TaRgT/6vRFQ5GfxkYJfuw7/mPFQ73XYZEykcyUDiccv/oMSNlnXB8/DHx5eL2C4X7lXFiyxgpbCx1dtk6tqdJR3b61GRsHTIVcZN/9M28GHOB0C/QJZPq4iRxeTAXG+kN9K8v/YXW4C5kBl9n+nrT13mix4scM/1+J/7X8NSXOIO9iB14fc/7TzW8duiSX8APvr2D/7kY9IX4APUm1h8/gc6J1ZFsfaey5VOnSufnaWp1tmbXuWT3/sEp3WdKIiPJiel9SFd+MBf1g77wD4XS/+sb4AI9XW9KYvl0Q7ScUDh+fZqy6don9UzeVDsxpKqKzuQ9MXb6z6pMMSM8usBxZXYI2+mOoIQRs9TKU7ZsNSmkbTquecoZ6SZhEFxuqbhUarEqlV3X/5eO2079i8htJ+/qTrVeklxWOOW2gfZ12+l/QbgHqNulAbb37t/VJTXtytJ7a73qzipSd5clY0UuViO/muP/6hv7yz/2oi4yZMKE49+Xz92tPG9Xwh79/3LtJFxApBt2GPfXWCccHcKZuK9JUr5nQ3ztyYZ7JLsuid7bl/CX5tjvnWBYiddCsX2U/f+S3dOe1Ae2krevX83xdRtZMiEnrsbEi7DBBJKkf5mP/L82/XtfYw+S6hxFLhad2J8Vk3y/SPuz3F3K93Sk/ct0X/392z/YmDrQhXSEE0r973f4L2mH749xHknZrk65c12aPbNbcxb4ZCUZKmQGdZ/F0C/FTGioF9+JZzP9sDTTdWp6FYb+PoBTi6CEEeOzbJ1n5WmNadVzTqvmuQhKGJt8PqlmbrYmzpmieR8ZtTb3rLdNMP6vvU5fT1jkQtI2fWHMib0w7b1+NEY6ftyW1w5p4fz4mYISL33shIuO+L9sx5d1OcGEnrXUQ0HscP8hK8nqjLCcYL86U144h+MvJBN7IOO3WUn3STxWsmNaMfsMPLwlRiiUEBgG2Dfy/zWcZLhNmr/8R8uGQr3bk9ebPLwklOt9r4k9G51Bl0IhWx+f/1G//foJDdNfodNcCKf6mUh53sL960pdR4qf59jvg7E/EyfSY9LzOysrVZc8gDGPoIQRdYHl1xrTqpfNMf2dceSz7IF3AkYp25YqJlqqmBhZ45VL6S84B3OJdaDB1qGARx7/AD1cZnD/flxOaFBHdoUjf1X2DKLO2IvY9L9a7LigM3A7bCfxAjl9z4CV5II6PRMXpAbLHvJxep3EX9Ht0In/pb/xaJbe25MruQf+/5myzFDbnmwMsSSFQmmHtqWo7OTbEysr4WfvhOviUgo4XXFVihE1z8pWmdzqkKMNhmmmAQAAMDoQlDCibMvS+ZZfkvScaR3h1gAAAAA9CEoYcRfa+ZKkN027WgyzswAAAGDkEZQw4mosn2bIp7Ckl0zbSDcHAAAAIChhdLjA7h1+5zD8DgAAACOPoIRR4RNWvmxJO9WlfYanQgMAAGBkEZQwKhRabi22ciVJz9OrBAAAgBFGUMKocUHv7HfPm1Y5g32sOwAAAJABBCWMGkusXOXI1kGF9L6OjHRzAAAAMI4RlDBq+Cxb51l5kqQN5sAItwYAAADjGUEJo0pk9ru3zEcKOUzqAAAAgJFBUMKoMlfZKpNbnQppz/GtI90cAAAAjFMEJYwqtmVFJ3V4t/2NEW4NAAAAxiuCEkadyPC7vZ3v6lhn88g2BgAAAOPSmAlK999/vyZPnqysrCwtWbJEGzZsGOkmIUNqLK8mqUBGjjZ98MJINwcAAADj0JgISv/2b/+mG2+8UXfccYfefPNNnXHGGVq+fLmamppGumnIkLOtiZKkN3evHeGWAAAAYDwaE0Hpxz/+sa655hp99atfVV1dnR588EHl5OTon//5n0e6aciQxVaVbNnaf2SnDh/eMdLNAQAAwDgz6oNSd3e3Nm7cqGXLlkXX2batZcuWad26dUn36erqUmtra9wLY0u+5VNt1mxJ0rZtj49wawAAADDejPqgdOjQIYXDYVVUVMStr6ioUCAQSLrP6tWrVVBQEH3V1NSciqZimM3KPUuStG3bv8s4zgi3BgAAAOPJqA9KJ+LWW29VS0tL9LVv376RbhJOwJTsucry5Kqtbb8OfPDSSDcHAAAA48ioD0qlpaVyuVxqbGyMW9/Y2KjKysqk+/h8Pvn9/rgXxh637dWCSR+XJO3Y9H9HuDUAAAAYT0Z9UPJ6vVq8eLHWru2b/cxxHK1du1b19fUj2DKcCmdOuUiStGvLvysUPD7CrQEAAMB4MeqDkiTdeOON+tWvfqVHHnlE27dv18qVK9Xe3q6vfvWrI900ZNjk8rny+2sU7GrTvh3PjHRzAAAAME6MiaD0pS99ST/60Y90++23a+HChdq0aZP+/Oc/95vgAacf27JVV/cFSdLuzf8+wq0BAADAeDEmgpIkXXfddfrwww/V1dWl9evXa8mSJSPdJJwidXVflCQ1vP+Cjh/jIcMAAADIvDETlDB+FRfPUEX1OTImrN2bnxzp5gAAAGAcIChhTJi18G8lSbvefmKEWwIAAIDxgKCEMWHGgi/Lst063PC2jjbtGOnmAAAA4DRHUMKYkJ1bqonTLpQkvU+vEgAAADKMoIQxY+qC/0+S9P47/0/GcUa4NQAAADidEZQwZtTM/JS8WX61txxQ4INXR7o5AAAAOI0RlDBmuNxZmjz3byQxqQMAAAAyi6CEMWX6GT0Pn/1g2x8U6u4Y4dYAAADgdEVQwphSUXuO8gprFew6pr07nhnp5gAAAOA0RVDCmGLZtqad0TOpw65Nj49wawAAAHC6IihhzIkMvzvw/gvqaGsa4dYAAADgdERQwphTUDpNZdWLZZywdr39/0a6OQAAADgNEZQwJkWG3+18i+F3AAAAGH4EJYxJU+d9Tpbt1qEDb+to47sj3RwAAACcZghKGJOycktUM3OZJOk9epUAAAAwzAhKGLOm9U7qsPOtx2UcZ4RbAwAAgNMJQQljVs3MT8mbVaD2lgY17H55pJsDAACA0whBCWOW25OlaQs+J0l6761/G9nGAAAA4LRCUMKYNuPML0mS9mz+g4LdHSPcGgAAAJwu3CPdACCVQ/tcsvZ71GV3qytsyZVbItMtyUhGkstlq6TkU6qZcYkm150nY8Ij3WQAAACcJghKGJUqtU9z9JZef6FAB+RSVlWTsguzZPVuN5bktR2VlRv91SX/JvfEXHWblhFtMwAAAE4fBCWMSllWpxa7XtF887p2OXO0uWGpOhuy1dOXJIXkVfHMXM2eWqN3O2vUvick25WrLiPZvWXUW9pxpLx8o6DfpZyCoFz81AMAAGAAXDJiVPNa3apzva06vR23/m1niT4IXaCX/9isw11vK2RcvVtMtNepj5FjeVVYna8JC0tVOLtEHU5HtJzLJXlzJF9WZt8LAAAAxg6CEsakCdY+mQ9e0EQzmB9ho0OmUlsPn6W33i5T4YwSlUwuVGyi8uW5VLGgRJ2+kIrLJYtpTgAAAMY1ghLGpHKrQeVWw5D2OddZo3fNIr21s14Hd5bEDdE7rmy1bC9R+ewyHZk+QSGPR5Yt2b1hyvQVlROWFJTUKbk8UlGpdKiZiSQAAABOJwQljBt+u1Xn6EUtMq+qXfnR9S0q1lZnsfIrF2t/Q0iN77UqZHq6lKzIFHuSLCuSlix5XGEd2NyhmvqJcs6sOsXvBAAAAJlGUMK447GCKtSR6LLbBJVrtSnwwnsy5gMVDbC/kaX8iW5NnVOjls4aHdt0TLn5RiFJlpyeYGWkcG+u8mYZuScUK+TN1DsCAADAcCMoYdzLs9r0SevpQZffY2Zpl+t8bXy1S0e6tykkr/omkehJR7ETSoSNrYqabM39RJH89TVqsXyyYgqEYu6Hih3i53JLti1lZZ/AmwIAAMBJISgBQ1Skg5q4f4PK9E7MWpOy/H4zRd7KqWrfN1tvfGDJsowsO768pZ6QZFmSHCPLdlRS6Ch/XpXcs4vk5l8qAADAKcXlFzBEhdYRFVpHBi7YK+h4tXNLkZo371BQPkm99z7109cbVTvPrezFFWo9WCb5Q3L1zn7uxOwW97wo09P7VFRi5PYzxg8AAOBkEZSADJtrbdQMa8ugyhpZOmpKtXnrEj2/xShUGlLJxFxJscP5TNzYPpftqDCnWxMXlsvMrVV5HUEJAADgZBGUgAzLsdqVo/ZBly+yDmuyeU9NpkpbDy/WkcNlcdst9eWksGxll3u04JNF6vCVqGnnMbV82BbXX+U4PV977n/qWXBJKihwVDi7VAUTCVYAAACJCErAKGRbRpXWAVXqQNpy+8xU7Xafq7feKNChl/eoO7xfxvROu5cgMtwvN8fRnEU58iyo0dFDlkyW5Ip9wG7vrsZIublSnn+Y3hQAAMAYkrGg9IMf/EB//OMftWnTJnm9XjU3N/crs3fvXq1cuVLPP/+88vLydOWVV2r16tVyx9y5/sILL+jGG2/U1q1bVVNTo9tuu01XXXVVppoNjCmFOqzKjzapSDs0dRDljytXe810vfFBpXK2GBVM7pLLG0lJfc+JknqCks8X1uRzy5Q/o0wVVYreKwUAAHC6y1hQ6u7u1he+8AXV19fr17/+db/t4XBYK1asUGVlpV599VV99NFH+spXviKPx6Mf/vCHkqQ9e/ZoxYoVuvbaa/Wb3/xGa9eu1X/7b/9NEyZM0PLlyzPVdGDMyLdaNMtqGdI+Z5jXtNdM1zs7z1Fg54SYSSH690J1KluHdjRpwswiNZ1RJW9ZgVwuo+5uS26P1N0Sltty4vYM934tKjLqMMxtDgAAxqaMBaU777xTkvTwww8n3f6Xv/xF27Zt07PPPquKigotXLhQd911l2655RZ973vfk9fr1YMPPqgpU6bon/7pnyRJc+bM0csvv6z77rsvbVDq6upSV1dXdLm1tXX43hgwxmVZnZppbdE0a5uOqSBluU7laItZrLLiKTp0dJJ2/KFDIaenS8mSkdsV1nuurvhnP1mOinK7NP3sYmV/epJUQlACAABj04jdo7Ru3TrNnz9fFRUV0XXLly/XypUrtXXrVi1atEjr1q3TsmXL4vZbvny5rr/++rR1r169OhrUACTnshwV6GjK7bmmTX41a/8rAXXrqLJSlOuZXMLIkUtWsUdTP+lXd7BUO9Z3qaRgZ1yQMtH7n/omSLedsIyRPFmWiuZVyluYE/dAXgAAgJEwYkEpEAjEhSRJ0eVAIJC2TGtrq44fP67s7OR/rb711lt14403RpdbW1tVU1MznM0HTntuK6SzrZcGXT5gqrXLtVTvvJWjQ+v3qzvcGP+8KCvZt33bQ8at8ur9WnhurmYur5JVOUGWLcXOM5G4mzGS2+65d8rD5H0AAGAYDSkoffvb39Y999yTtsz27ds1e/bsk2rUyfL5fPL5fCPaBmC88euoKg9tU9GhPaqNrk32YN3k29qNXzsDc/Ufb1So5M9tmjTvI7k9/WOSiZlswmOH5c8Jqvqsck2+sHpY3gcAAIA0xKB00003DTjj3NSpg5l7S6qsrNSGDRvi1jU2Nka3Rb5G1sWW8fv9KXuTAIyMHKtd061tJ1XHArNB+8w0bd15pt57r1SWHCUGKsuSjGzZMlrwMUsVZ1Wqq7tShz483i+WGSO5FIouO05fyIoMA/S6wioolnKKUw0uBAAA49GQglJZWZnKysoGLjgI9fX1+sEPfqCmpiaVl5dLktasWSO/36+6urpomaeffjpuvzVr1qi+vn5Y2gBgdMmyjmuGtUVTzXYdU+oHOHUqRzvNPOV6pmjrW11qenmfZPYllLLihvv1rOlJR8ZIbldQpf6Qas8oVNXSatUSlAAAQIyM3aO0d+9eHTlyRHv37lU4HNamTZskSdOnT1deXp4uvvhi1dXV6YorrtC9996rQCCg2267TatWrYoOm7v22mv1v//3/9a3vvUtfe1rX9Nzzz2nxx9/XH/84x8z1WwAo4DLCqedaCLHHFO22rX7xYMKmyPyJiYiSZGeKCvJ8L+w3DquXB2emCWX6dKxDo8CW1pkpLjJJyRLxkjZvrCqlpSpdKJXHs9JvTUAADBGZCwo3X777XrkkUeiy4sWLZIkPf/88zr//PPlcrn01FNPaeXKlaqvr1dubq6uvPJKff/734/uM2XKFP3xj3/UDTfcoJ/85Ceqrq7W//k//4dnKAHjnMcKarH18gnv7xhLR0yZdh6Ypx37pWNru5Rb1XdfY2K4Csul0v9o0swzcjT3olJ5a8vkcRvZlh03MjBuhr/er7axY7Zbsm2j4mKHmf0AABjlLGNMurutTwutra0qKCjQ465pyrFcI90cAKPIMZOvgKlWSKm7ij7SJBUtKJF78iy1qFS2ZXrvleofqowTMyVfDLfLkT83rKoFJZpxYZkKChxJkiv6iN7UDjS4dShgdObCzrTlXCaUdnu0nDPIcuHuQZXrqTM46LJ2eHDHj5YfQt2SZIWHVr5nn6G1SZLsEziOJCl0gvtJskOD/3+SqPFolt7bk6uPLwiccB0n0/b4eoZ+vpPXM0ztGe66epngML3PxHoz0Na4+rtO/OdsSMfJ8PuI5WTo/8VATPDUvcdknO6Red/JvHewQl1d0tyK/SPdFLV1dWvK3f9XLS0t8vtTD/UfsenBAWA0yLPaNN3anrZMt5OtwDtetbz9vrrV8wFvyxlE7aZ34omwpi/2yj+vQu2tRdqxsVs52b33S0VKxkwwIdPT3WSHg3K7jcJ5PhkzcKACAADDh6AEAAOYYW3WJL3Xb3KIwTCydFRleu/N+dq20ZanxlFeWWPf86EsyQmHI9/GsWQUlq380lwt+phP4QWlctEpDgDAKUFQAoABZFsdylbHCe9fqCOq1S41aYJ276/T8f05g96302RLU/1q8hXrrWCzJk92+vVlxd0bZSyZUF/vkz/fKPvMGUxCAQDAEBGUAOAUcFlhTbD2a4KGNjZ7p5mn4/YM7d3s6J03wzKykszk1/9W00jvlO22NWf+W6r/hK2aj02SXVZ4Qu0HAGC8ISgBwChWqoCa3+9WTtqP69Rz8jSpSu/sm6o3ns/X1Pm7NHlmVtI9TG+0mjbV0fSPlSmrpvQkWw4AwNhGUAKAUazIOqQi69AJ7z9d29VqNmpv53S9v2G2Gjb0PHUq+fOlbK0vytbU549r0ZKPNP28Stl5uUlnhDNJpkX3uI38ZW6mPgcAnBYISgBwmvNbzZpnvaGZ5h11KvX9UYdVoXbfRGW7ZuiNV/L18osNsiyTcg6L2C2R4DVztqWzLvSrdF6FPJ7T/ukTAIDTGEEJAMYJr9Utr1I/H8UYS0cbS3Wo8YCc3hBkpxnWlziAr8Pk6f3WXLUcdVS22aPKks64MNXT8xQfu2J7ppxgWJYl+TxhTaixVDavcrBvDQCAYUdQAgBIkgqsozrTeuWE999iFssVrtTet21t2RiMCUl9aSjdqDyXHdTECSHNW+STnVulolBPaSucEK5iv0/IccZYssK2EmX5BvPcKwAA+hCUAADDolL7dez9Vk0x7yUvkCYlOXLpqClT44EKNe4tUsnWI3rjxb4p2QccxGf6V24kZXmCKp/o09JPZamglF95AIDB47cGAGBYlFqNKlXjCT2YV5KM3lWzSrSvaZr2Nk5ToLei1P1J8ctWTB+WI1vl1V0qWVggp7NKH+4rUEFbX1kTDCXU0tcLZRJCl88TVvWkE3tPAICxi6AEABgVLEsq0mEVWYc102xWUN4Truu4cnTwwAStPzBLXdmHVPpatzzunqCU7FlUPev6uKywfK6gps8wclfVqHpS/+F8AIDTG0EJADDqZFnHlaXjJ7x/vlpUbn2kKWaHGo5PUuDtGkX6kAbq8DKy1CmPOhRWwBTI7ijWM4974suY+L4tJ7bW3g2WJeX6gqqe7tWMOcyZDgBjDUEJAHDayrHaNd3apunaNqT9OkyuPjI12rNhtlrX79N71VmSFd8LFRt9nO5Q3Ja87E5NmJKjMxa71XRokkpbY/qwQokzASb5Pqb2vOyQsn3hIbUfAHDyCEoAACTIsdo1zXpXk8wuHbIq1dWQNeh9O5WjVlOknR+W6aN9fvlrD2vrK66ejVZcGoqXotPJ5bI1/0xLUxfkqjwv9fTuAIDhRVACACAFtxVSpfYPeb+Q3DqkSu15f6YOvH9MlpJPT25Fvyaf18/IUrfx6tD7edr+ZoEmzc5RQYVPbpeT0BuVbgr1nm1dQZcUjp/EAgCQGkEJAIBhFglYFdqvDuXFzaqXXKqgZGubztSsAlsNjZO0YX+Xgk5PXZFwZaKzA/YfGmiMJY8rqCyf0Tlndmn2Qr+k+PutAADJEZQAAMgQy5Jydeyk6shVq95/1adu7ZGkfpErXQQLyqewjKyJWWrI86qy+LiCh1MEpSTPonJC8T1QuTlGRTPKh9B6ABi7CEoAAIxi86yNJ/5sKiM1q1QHDkzS+gNTtPGVkHyFqSaGsFIcpq+nyvZ4dMacPVp0lq3qBeVSVvaJNQwAxgCCEgAAp6meZ1MdUpF1SFPNuzpyvFzm+IlPVb7PTFWwvFuvbp6tCfuaJTXHzdAn9b9fqq8tRhMnhDVlXr7snJwTbgMAnCoEJQAAxoEcq105vcP3TtQhU6n3XnepVY16M2bQX6rJKGIZ2bJyPZo6t0NnLjiq2YvzlFWYG18oHIzfJ82EFdFjW0Zul5Hc3HsFYHgRlAAAwKDUWRsVOsHJIBy5dLCjUvs2TNPODTkqfcVSdk7nSbTGKMfdqdySHH3640dUOK3yJOoCgP4ISgAAYFB8Vpd86jrh/fPVohrt1kFN0MHtE3Q84TJkoEGBsT1XncpWSG3qmD9Zr7/h0uRjqSfNMMaSCSWZGr23OssymjjFq9wCeqUA9CEoAQCAU8ZjBVWlvaqy9p5UPUHjUZMm6sDmbK3dXKL8iZ39pkyXBjks0NjKK+7S/DnHtGChVDql6KTaBuD0QFACAABjjscKaqI+0AR9qCMq0/GGvLTl0wWm48pVyClRW1OWnn1logo2Hkt5T1Ti5BXR9aZ/OUtG55zRrrKpBC9gLCIoAQCAMcu2jErVJKnphOs4akq0M1Cq7YFOtatJTsqp0gfqoerZFpZLc2YfVVb1BB04nKesmEdPJQtgiTWarmDSo3hdYWV7Q7J83nRvB8AwISgBAIBxrVCHNc96fdjqa1OhGt+dqOZ327RtU46Kql0xW+MjkGWlDl6WjGQseV3dyvY5Kqwp1CUfO0RQAk4RghIAABjXLEvKUfuw1ZejdlVYB9RiitR4uFqdh4b2YN7Y8NRlstUqlyZPbVaTVafXN3mVnZOkFyqhpypx8gqTpGxtaavKphUOqW3AeEJQAgAAyIAC66gKdHTg6fzSsaRmU6zGPdUK7D6qhrdt+Qq7TqDKvqg0teyQ7LIqZWX5VXYSTQNOdwQlAACAUazQOqJCHdEk7dSR9jKZdjtm68Cz+sXab6aqvPqggj6/Nm+v1LvvJfQ8GUtSVsr943qmYuJaVq5by+sPypubel9grCEoAQAAjAFZ1nFV6eSmVT+qUr3y2kSFFVS3GiXFd3gNZjr1CEe2JlS26GNnH9X28McVaPXL15V+sgonGO5bb9wxZeL382d1Kj/PGXRbgEwgKAEAAIwTs/W2QtbwPFj3iMrUoilq73CppfmIntnnlhMKJi2bbKhgbCgzsmTLKN/TJk9xkSZOytE5C1I/RBg4FQhKAAAA44TbCsmt0MAFB6HQHNaRxjKtb8yS9MEJ1BDfe9Vu/Ar5j2vi7A4d2DdJrwZzUj7Pqv/eveuSTr8ev862HJ0164i8Wa5+ZYFYGQtKH3zwge666y4999xzCgQCqqqq0t/+7d/qO9/5jrzevmkt33nnHa1atUqvv/66ysrK9I1vfEPf+ta34up64okn9N3vflcffPCBZsyYoXvuuUef+cxnMtV0AAAADCDHatc8bRy2+oLyqLGtWu9tqNJxHdKH5f1DT8Lcfklq6b/OkpGRpdLcVs2YFdYB3yId6+pQvid2GOAgnm+VIrR5XGG57KHdK4axIWNB6d1335XjOPrFL36h6dOna8uWLbrmmmvU3t6uH/3oR5Kk1tZWXXzxxVq2bJkefPBBbd68WV/72tdUWFior3/965KkV199VZdddplWr16tv/qrv9Kjjz6qz33uc3rzzTc1b968TDUfAAAAp5DHCqpae1SlD3REZQoe9A1b3YdUKSvPUlXOQe1tOaZn/zMvbXkzQO4JB8Nye3t6pGon21o67/BwNRWjiGXMQD8Kw+cf//Ef9cADD2j37t2SpAceeEDf+c53FAgEor1M3/72t/Xkk0/q3XfflSR96UtfUnt7u5566qloPUuXLtXChQv14IMPJj1OV1eXurq6osutra2qqanR465pyrHoZgUAABhPDppK7TZzJPUMxYsfjpfwEOAUdSROdHHW2QdVWpuvvfZ8zZ7c/36q2CvsyCQWya66E4cGZrmDmlh6bFh6qZzu4RlmORzeO1ihri5pbsX+kW6K2rq6NeXu/6uWlhb5/f6U5U7pPUotLS0qLi6OLq9bt06f+MQn4obiLV++XPfcc4+OHj2qoqIirVu3TjfeeGNcPcuXL9eTTz6Z8jirV6/WnXfeOeztBwAAwNhTZgVUoCP9QknEUGb7k6QjKtfm12sUft0lb81eHd7Zf4KMwQauHn3ruo1HBaXFmjkjrClV7crxJp8gA5l3yoLSrl279LOf/Sw67E6SAoGApkyZEleuoqIiuq2oqEiBQCC6LrZMIBBIeaxbb701LlxFepQAAAAwPnmt7mGrq1L7VaH9alapmvZPUMf+4ZlJUJKOm1wdkkeHPszWO5V+lVZ6+80Q6AQTnn+VePeWSX43V3FhWOdMT30NjXhDDkrf/va3dc8996Qts337ds2ePTu6fODAAX3605/WF77wBV1zzTVDb+UQ+Xw++XzDN64VAAAAiGVZUpEOqUiHhrXesGwdUbkC79fowK4OtVZKyYYHDtQHFhuuFs8IyFNWrn0ddTra0Zpyn/6BK/32XG+Xsj2nb4/XkIPSTTfdpKuuuiptmalTp0a/b2ho0AUXXKBzzz1Xv/zlL+PKVVZWqrGxMW5dZLmysjJtmch2AAAA4HThshyVKaAyBdSmArU35g95aGCs/WaKXg6Uq2ZamzqLGvVCU3bPBisxfA3yXq3e/Yyx1BXO0aQao+m1HSrJbT/hNo5WQw5KZWVlKisrG1TZAwcO6IILLtDixYv10EMPybbtuO319fX6zne+o2AwKI+np8tyzZo1mjVrloqKiqJl1q5dq+uvvz6635o1a1RfXz/UpgMAAABjRr7Vony1nFQdFdYBtZgiNe6u1lFzcnUlshWWa05Y+z6sVEGZXyWllly2I6l/b9RHbUWqLjgyrMfPtIzdo3TgwAGdf/75mjRpkn70ox/p4MGD0W2R3qD/+l//q+68805dffXVuuWWW7Rlyxb95Cc/0X333Rct+81vflOf/OQn9U//9E9asWKFHnvsMb3xxhv9eqcAAAAA9FdgHVWBjioslxzZacsOpfdqt+bItvJVFtyhwx8Uq3l3zwRtJmk9jQp4WtTmPp60LtsKq2ZCl4qqC5RVlD/oNmRSxoLSmjVrtGvXLu3atUvV1dVx2yIzkhcUFOgvf/mLVq1apcWLF6u0tFS333579BlKknTuuefq0Ucf1W233ab/8T/+h2bMmKEnn3ySZygBAAAAQ+CywnIpPHDBQSo2jTq03dZRuaRB9Hy1SUoVP4LK0ZaKSl08f7v8Vcfl8g5vTHH5PEMOYKf0OUojpbW1VQUFBTxHCQAAABiFuo1X28ovUKFrcMPzEmf2G0hx7jHNm9Wmwiq/nKK80fccJQAAAABI5LW6Vd30lhwNvlNjsMMEjSztMZOUlSNN93SqoyH1zH+xCEoAAAAARlyp1ZSxuttUqE3vVGrTO5JPjQPvIIISAAAAgNPcVG3XZGuHJOm4CQ1QugdBCQAAAMBpzbIkl3qmLrcHOWQv/fyAAAAAADAOEZQAAAAAIAFBCQAAAAASEJQAAAAAIAFBCQAAAAASEJQAAAAAIAFBCQAAAAASEJQAAAAAIAFBCQAAAAASEJQAAAAAIIF7pBtwKhhjJEkdxhnhlgAAAAAYSZFMEMkIqYyLoNTW1iZJusrZM8ItAQAAADAatLW1qaCgIOV2ywwUpU4DjuOooaFB+fn5sixrWOtubW1VTU2N9u3bJ7/fP6x1j3ec28zi/GYW5zezOL+ZxfnNLM5vZnF+M+t0OL/GGLW1tamqqkq2nfpOpHHRo2TbtqqrqzN6DL/fP2Z/WEY7zm1mcX4zi/ObWZzfzOL8ZhbnN7M4v5k11s9vup6kCCZzAAAAAIAEBCUAAAAASEBQOkk+n0933HGHfD7fSDfltMO5zSzOb2ZxfjOL85tZnN/M4vxmFuc3s8bT+R0XkzkAAAAAwFDQowQAAAAACQhKAAAAAJCAoAQAAAAACQhKAAAAAJCAoAQAAAAACQhKg/DBBx/o6quv1pQpU5Sdna1p06bpjjvuUHd3d1y5d955Rx//+MeVlZWlmpoa3Xvvvf3qeuKJJzR79mxlZWVp/vz5evrpp0/V2xhz7r//fk2ePFlZWVlasmSJNmzYMNJNGvVWr16ts88+W/n5+SovL9fnPvc57dixI65MZ2enVq1apZKSEuXl5enSSy9VY2NjXJm9e/dqxYoVysnJUXl5uW6++WaFQqFT+VbGhLvvvluWZen666+PruP8npwDBw7ob//2b1VSUqLs7GzNnz9fb7zxRnS7MUa33367JkyYoOzsbC1btkw7d+6Mq+PIkSO6/PLL5ff7VVhYqKuvvlrHjh071W9l1AmHw/rud78b97vsrrvuUuzkt5zfwXvppZf02c9+VlVVVbIsS08++WTc9uE6l4O5tjgdpTu/wWBQt9xyi+bPn6/c3FxVVVXpK1/5ihoaGuLq4PymNtDPb6xrr71WlmXpf/2v/xW3flycX4MB/elPfzJXXXWVeeaZZ8z7779vfv/735vy8nJz0003Rcu0tLSYiooKc/nll5stW7aYf/3XfzXZ2dnmF7/4RbTMK6+8Ylwul7n33nvNtm3bzG233WY8Ho/ZvHnzSLytUe2xxx4zXq/X/PM//7PZunWrueaaa0xhYaFpbGwc6aaNasuXLzcPPfSQ2bJli9m0aZP5zGc+Y2pra82xY8eiZa699lpTU1Nj1q5da9544w2zdOlSc+6550a3h0IhM2/ePLNs2TLz1ltvmaefftqUlpaaW2+9dSTe0qi1YcMGM3nyZLNgwQLzzW9+M7qe83vijhw5YiZNmmSuuuoqs379erN7927zzDPPmF27dkXL3H333aagoMA8+eST5u233zZ//dd/baZMmWKOHz8eLfPpT3/anHHGGea1114z//mf/2mmT59uLrvsspF4S6PKD37wA1NSUmKeeuops2fPHvPEE0+YvLw885Of/CRahvM7eE8//bT5zne+Y377298aSeZ3v/td3PbhOJeDubY4XaU7v83NzWbZsmXm3/7t38y7775r1q1bZ8455xyzePHiuDo4v6kN9PMb8dvf/tacccYZpqqqytx3331x28bD+SUonaB7773XTJkyJbr885//3BQVFZmurq7oultuucXMmjUruvzFL37RrFixIq6eJUuWmL/7u7/LfIPHmHPOOcesWrUquhwOh01VVZVZvXr1CLZq7GlqajKSzIsvvmiM6fnl4vF4zBNPPBEts337diPJrFu3zhjT8+Fp27YJBALRMg888IDx+/1xP9/jWVtbm5kxY4ZZs2aN+eQnPxkNSpzfk3PLLbeY8847L+V2x3FMZWWl+cd//MfouubmZuPz+cy//uu/GmOM2bZtm5FkXn/99WiZP/3pT8ayLHPgwIHMNX4MWLFihfna174Wt+7zn/+8ufzyy40xnN+TkXihOVzncjDXFuNBugv5iA0bNhhJ5sMPPzTGcH6HItX53b9/v5k4caLZsmWLmTRpUlxQGi/nl6F3J6ilpUXFxcXR5XXr1ukTn/iEvF5vdN3y5cu1Y8cOHT16NFpm2bJlcfUsX75c69atOzWNHiO6u7u1cePGuHNl27aWLVvGuRqilpYWSYr+rG7cuFHBYDDu3M6ePVu1tbXRc7tu3TrNnz9fFRUV0TLLly9Xa2urtm7degpbP3qtWrVKK1as6PfvmfN7cv7jP/5DZ511lr7whS+ovLxcixYt0q9+9avo9j179igQCMSd34KCAi1ZsiTu/BYWFuqss86Kllm2bJls29b69etP3ZsZhc4991ytXbtW7733niTp7bff1ssvv6xLLrlEEud3OA3XuRzMtQV6tLS0yLIsFRYWSuL8nizHcXTFFVfo5ptv1ty5c/ttHy/nl6B0Anbt2qWf/exn+ru/+7voukAgEHfhIym6HAgE0paJbEePQ4cOKRwOc65OkuM4uv766/Wxj31M8+bNk9TzM+j1eqO/SCJiz+1gfpbHs8cee0xvvvmmVq9e3W8b5/fk7N69Ww888IBmzJihZ555RitXrtTf//3f65FHHpHUd37SfTYEAgGVl5fHbXe73SouLh735/fb3/62vvzlL2v27NnyeDxatGiRrr/+el1++eWSOL/DabjOJZ8Xg9PZ2albbrlFl112mfx+vyTO78m655575Ha79fd///dJt4+X8+se6QaMpG9/+9u655570pbZvn27Zs+eHV0+cOCAPv3pT+sLX/iCrrnmmkw3EThhq1at0pYtW/Tyyy+PdFNOG/v27dM3v/lNrVmzRllZWSPdnNOO4zg666yz9MMf/lCStGjRIm3ZskUPPvigrrzyyhFu3dj3+OOP6ze/+Y0effRRzZ07V5s2bdL111+vqqoqzi/GrGAwqC9+8YsyxuiBBx4Y6eacFjZu3Kif/OQnevPNN2VZ1kg3Z0SN6x6lm266Sdu3b0/7mjp1arR8Q0ODLrjgAp177rn65S9/GVdXZWVlv5mtIsuVlZVpy0S2o0dpaalcLhfn6iRcd911euqpp/T888+ruro6ur6yslLd3d1qbm6OKx97bgfzszxebdy4UU1NTTrzzDPldrvldrv14osv6qc//ancbrcqKio4vydhwoQJqquri1s3Z84c7d27V1Lf+Un32VBZWammpqa47aFQSEeOHBn35/fmm2+O9irNnz9fV1xxhW644YZo7yjnd/gM17nk8yK9SEj68MMPtWbNmmhvksT5PRn/+Z//qaamJtXW1kZ/13344Ye66aabNHnyZEnj5/yO66BUVlam2bNnp31FxlUeOHBA559/vhYvXqyHHnpIth1/6urr6/XSSy8pGAxG161Zs0azZs1SUVFRtMzatWvj9luzZo3q6+sz/E7HFq/Xq8WLF8edK8dxtHbtWs7VAIwxuu666/S73/1Ozz33nKZMmRK3ffHixfJ4PHHndseOHdq7d2/03NbX12vz5s1xH4CRX0CJF7HjzUUXXaTNmzdr06ZN0ddZZ52lyy+/PPo95/fEfexjH+s3nf17772nSZMmSZKmTJmiysrKuPPb2tqq9evXx53f5uZmbdy4MVrmueeek+M4WrJkySl4F6NXR0dHv99dLpdLjuNI4vwOp+E6l4O5thivIiFp586devbZZ1VSUhK3nfN74q644gq98847cb/rqqqqdPPNN+uZZ56RNI7O70jPJjEW7N+/30yfPt1cdNFFZv/+/eajjz6KviKam5tNRUWFueKKK8yWLVvMY489ZnJycvpND+52u82PfvQjs337dnPHHXcwPXgKjz32mPH5fObhhx8227ZtM1//+tdNYWFh3Exh6G/lypWmoKDAvPDCC3E/px0dHdEy1157ramtrTXPPfeceeONN0x9fb2pr6+Pbo9MX33xxRebTZs2mT//+c+mrKyM6atTiJ31zhjO78nYsGGDcbvd5gc/+IHZuXOn+c1vfmNycnLMv/zLv0TL3H333aawsND8/ve/N++88475m7/5m6RTLi9atMisX7/evPzyy2bGjBnjcvrqRFdeeaWZOHFidHrw3/72t6a0tNR861vfipbh/A5eW1ubeeutt8xbb71lJJkf//jH5q233orOujYc53Iw1xanq3Tnt7u72/z1X/+1qa6uNps2bYr7fRc7wxrnN7WBfn4TJc56Z8z4OL8EpUF46KGHjKSkr1hvv/22Oe+884zP5zMTJ040d999d7+6Hn/8cTNz5kzj9XrN3LlzzR//+MdT9TbGnJ/97GemtrbWeL1ec84555jXXnttpJs06qX6OX3ooYeiZY4fP27++3//76aoqMjk5OSY//Jf/ktc6DfGmA8++MBccsklJjs725SWlpqbbrrJBIPBU/xuxobEoMT5PTl/+MMfzLx584zP5zOzZ882v/zlL+O2O45jvvvd75qKigrj8/nMRRddZHbs2BFX5vDhw+ayyy4zeXl5xu/3m69+9aumra3tVL6NUam1tdV885vfNLW1tSYrK8tMnTrVfOc734m7sOT8Dt7zzz+f9PP2yiuvNMYM37kczLXF6Sjd+d2zZ0/K33fPP/98tA7Ob2oD/fwmShaUxsP5tYyJeSQ3AAAAAGB836MEAAAAAMkQlAAAAAAgAUEJAAAAABIQlAAAAAAgAUEJAAAAABIQlAAAAAAgAUEJAAAAABIQlAAAAAAgAUEJAAAAABIQlAAAAAAgAUEJAAAAABL8/7Zq8ULa14rFAAAAAElFTkSuQmCC", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -134,19 +132,17 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -170,19 +166,17 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -202,21 +196,19 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 5, "metadata": { "tags": [] }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -299,7 +291,7 @@ " x_bounds=(X0_BOUND, X1_BOUND),\n", " yaw_angles=np.array([[[20.0]]])\n", " )\n", - " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes[0])\n", + " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes[0], clevels=100)\n", " wakeviz.plot_turbines_with_fi(fi, ax=axes[0])\n", " wakeviz.plot_turbines_with_fi(fi, ax=axes[1])\n", "\n", @@ -309,7 +301,7 @@ " x_bounds=(X0_BOUND, X1_BOUND),\n", " yaw_angles=np.array([[[0.0]]])\n", " )\n", - " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes[1])\n", + " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes[1], clevels=100)\n", " wakeviz.plot_turbines_with_fi(fi, ax=axes[0])\n", " wakeviz.plot_turbines_with_fi(fi, ax=axes[1])\n", "\n", @@ -321,7 +313,7 @@ " x_bounds=(X0_BOUND, X1_BOUND),\n", " yaw_angles=np.array([[[20.0, 0.0]]])\n", " )\n", - " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes)\n", + " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes, clevels=100)\n", " wakeviz.plot_turbines_with_fi(fi, ax=axes)" ] }, @@ -345,26 +337,22 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -390,26 +378,22 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -435,26 +419,22 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -485,7 +465,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.12.1" }, "orig_nbformat": 4 }, diff --git a/setup.py b/setup.py index a31e1e0f3..6e08029ae 100644 --- a/setup.py +++ b/setup.py @@ -52,8 +52,8 @@ # pip install "floris[develop]" installs developer packages in non-editable install EXTRAS = { "docs": { - "jupyter-book==0.14", - "sphinx-book-theme==0.4.0rc1", + "jupyter-book", + "sphinx-book-theme", "sphinx-autodoc-typehints", "sphinxcontrib-autoyaml", "sphinxcontrib.mermaid",