diff --git a/.github/workflows/check-working-examples.yaml b/.github/workflows/check-working-examples.yaml index 55ae812fb..032f77fc0 100644 --- a/.github/workflows/check-working-examples.yaml +++ b/.github/workflows/check-working-examples.yaml @@ -36,21 +36,28 @@ jobs: error_found=0 # 0 is false error_results="Error in example:" - # Run each Python script example - for i in *.py; do + # Now run the examples in root and subdirectories + echo "Running examples" + for d in . $(find . -type d -name "*examples*"); do + cd $d + echo "========================= Example directory- $d" + for i in *.py; do + echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Running example- $i" - # Skip these examples since they have additional dependencies - if [[ $i == *15* ]]; then - continue - fi - if [[ $i == *19* ]]; then - continue - fi + # If "convert_examples" is in i, skip this script + if [[ $i == *"convert_examples"* ]]; then + continue + fi - if ! python $i; then - error_results="${error_results}"$'\n'" - ${i}" - error_found=1 + if ! python $i; then + error_results="${error_results}"$'\n'" - ${i}" + error_found=1 + fi + done + if [ "$d" != "." ]; then + cd .. fi + done if [[ $error_found ]]; then diff --git a/.github/workflows/deploy-pages.yaml b/.github/workflows/deploy-pages.yaml index 077487294..3da057988 100644 --- a/.github/workflows/deploy-pages.yaml +++ b/.github/workflows/deploy-pages.yaml @@ -24,6 +24,25 @@ jobs: run: | pip install -e ".[docs]" + # Make a copy of the examples folder within the docs folder + - name: Copy examples to docs + working-directory: ${{runner.workspace}}/floris/ + run: | + rsync -av examples/ docs/examples + ls docs/examples + + # Run the script examples/_convert_examples_to_notebooks.py + - name: Convert examples to notebooks + working-directory: ${{runner.workspace}}/floris/docs/examples/ + run: | + # Print the working directory + pwd + + # Show the contents + ls + + python _convert_examples_to_notebooks.py + # Build the book - name: Build the book working-directory: ${{runner.workspace}}/floris/docs/ diff --git a/.gitignore b/.gitignore index 840e5ab71..33188a17a 100644 --- a/.gitignore +++ b/.gitignore @@ -21,6 +21,12 @@ pip-wheel-metadata .idea .vscode +# Documentation notebooks +!docs/*.ipynb + +# The examples folder within docs +docs/examples + # Documentation output _site/ .jekyll-cache/ diff --git a/LICENSE.txt b/LICENSE.txt index 980a15ac2..833a19186 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,201 +1,26 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ +BSD 3-Clause License - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION +Copyright (c) 2024, Alliance for Sustainable Energy LLC, All rights reserved. - 1. Definitions. +Redistribution and use in source and binary forms, with or without modification, are permitted +provided that the following conditions are met: - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. +* Redistributions of source code must retain the above copyright notice, this list of conditions +and the following disclaimer. - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. +* Redistributions in binary form must reproduce the above copyright notice, this list of +conditions and the following disclaimer in the documentation and/or other materials provided +with the distribution. - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. +* Neither the name of the copyright holder nor the names of its contributors may be used to +endorse or promote products derived from this software without specific prior written permission. - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/README.md b/README.md index 5a30881bd..d694a7dbe 100644 --- a/README.md +++ b/README.md @@ -3,7 +3,7 @@ FLORIS is a controls-focused wind farm simulation software incorporating steady-state engineering wake models into a performance-focused Python framework. It has been in active development at NREL since 2013 and the latest -release is [FLORIS v3.6](https://github.com/NREL/floris/releases/latest). +release is [FLORIS v4.0](https://github.com/NREL/floris/releases/latest). Online documentation is available at https://nrel.github.io/floris. The software is in active development and engagement with the development team @@ -13,8 +13,7 @@ the conversation in [GitHub Discussions](https://github.com/NREL/floris/discussi ## Installation -**If upgrading from v2, it is highly recommended to install FLORIS V3 into a new virtual environment**. -Installing into a Python environment that contains FLORIS v2 may cause conflicts. +**If upgrading from a previous version, it is recommended to install FLORIS v4 into a new virtual environment**. If you intend to use [pyOptSparse](https://mdolab-pyoptsparse.readthedocs-hosted.com/en/latest/) with FLORIS, it is recommended to install that package first before installing FLORIS. @@ -53,28 +52,37 @@ With both methods, the installation can be verified by opening a Python interpre and importing FLORIS: ```python - >>> import floris - >>> help(floris) - - Help on package floris: - - NAME - floris - # Copyright 2021 NREL - - PACKAGE CONTENTS - logging_manager - simulation (package) - tools (package) - turbine_library (package) - type_dec - utilities - version - - VERSION - 3.6 - - FILE - ~/floris/floris/__init__.py +>>> import floris +>>> help(floris) + +Help on package floris: + +NAME + floris - # Copyright 2024 NREL + +PACKAGE CONTENTS + convert_floris_input_v3_to_v4 + convert_turbine_v3_to_v4 + core (package) + cut_plane + floris_model + flow_visualization + layout_visualization + logging_manager + optimization (package) + parallel_floris_model + turbine_library (package) + type_dec + uncertain_floris_model + utilities + version + wind_data + +VERSION + 4 + +FILE + ~/floris/floris/__init__.py ``` It is important to regularly check for new updates and releases as new @@ -86,32 +94,36 @@ FLORIS is a Python package run on the command line typically by providing an input file with an initial configuration. It can be installed with ```pip install floris``` (see [installation](https://github.nrel.io/floris/installation)). The typical entry point is -[FlorisInterface](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface) +[FlorisModel](https://nrel.github.io/floris/_autosummary/floris.floris_model.FlorisModel.html#floris.floris_model.FlorisModel) which accepts the path to the input file as an argument. From there, changes can be made to the initial configuration through the -[FlorisInterface.reinitialize](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface.reinitialize) +[FlorisModel.set](https://nrel.github.io/floris/_autosummary/floris.floris_model.FlorisModel.html#floris.floris_model.FlorisModel.set) routine, and the simulation is executed with -[FlorisInterface.calculate_wake](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface.calculate_wake). +[FlorisModel.run](https://nrel.github.io/floris/_autosummary/floris.floris_model.FlorisModel.html#floris.floris_model.FlorisModel.run). ```python -from floris.tools import FlorisInterface -fi = FlorisInterface("path/to/input.yaml") -fi.reinitialize(wind_directions=[i for i in range(10)]) -fi.calculate_wake() +from floris import FlorisModel +fmodel = FlorisModel("path/to/input.yaml") +fmodel.set( + wind_directions=[i for i in range(10)], + wind_speeds=[8.0]*10, + turbulence_intensities=[0.06]*10 +) +fmodel.run() ``` Finally, results can be analyzed via post-processing functions available within -[FlorisInterface](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface) +[FlorisModel](https://nrel.github.io/floris/_autosummary/floris.floris_model.FlorisModel.html#floris.floris_model.FlorisModel) such as -- [FlorisInterface.get_turbine_layout](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface.get_turbine_layout) -- [FlorisInterface.get_turbine_powers](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface.get_turbine_powers) -- [FlorisInterface.get_farm_AEP](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.floris_interface.FlorisInterface.get_farm_AEP) +- [FlorisModel.get_turbine_layout](https://nrel.github.io/floris/_autosummary/floris.floris_model.FlorisModel.html#floris.floris_model.FlorisModel.get_turbine_layout) +- [FlorisModel.get_turbine_powers](https://nrel.github.io/floris/_autosummary/floris.floris_model.FlorisModel.html#floris.floris_model.FlorisModel.get_turbine_powers) +- [FlorisModel.get_farm_AEP](https://nrel.github.io/floris/_autosummary/floris.floris_model.FlorisModel.html#floris.floris_model.FlorisModel.get_farm_AEP) -and in a visualization package at [floris.tools.visualization](https://nrel.github.io/floris/_autosummary/floris.tools.floris_interface.FlorisInterface.html#floris.tools.visualization). +and in two visualization packages: [layoutviz](https://nrel.github.io/floris/_autosummary/floris.layout_visualization.html) and [flowviz](https://nrel.github.io/floris/_autosummary/floris.flow_visualization.html). A collection of examples describing the creation of simulations as well as analysis and post processing are included in the [repository](https://github.com/NREL/floris/tree/main/examples) -and described in detail in [Examples Index](https://github.nrel.io/floris/examples). +and described in [Examples Index](https://github.nrel.io/floris/examples). ## Engaging on GitHub @@ -132,16 +144,29 @@ space to show off the things you are doing with FLORIS. # License -Copyright 2022 NREL +BSD 3-Clause License + +Copyright (c) 2024, Alliance for Sustainable Energy LLC, All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, are permitted +provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this list of conditions +and the following disclaimer. -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at +* Redistributions in binary form must reproduce the above copyright notice, this list of +conditions and the following disclaimer in the documentation and/or other materials provided +with the distribution. - http://www.apache.org/licenses/LICENSE-2.0 +* Neither the name of the copyright holder nor the names of its contributors may be used to +endorse or promote products derived from this software without specific prior written permission. -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/docs/_config.yml b/docs/_config.yml index 229977898..70c886992 100644 --- a/docs/_config.yml +++ b/docs/_config.yml @@ -11,6 +11,7 @@ only_build_toc_files: false # See https://jupyterbook.org/content/execute.html execute: execute_notebooks: auto + timeout: 360 # Give each notebook cell 6 minutes to execute # Define the name of the latex output file for PDF builds latex: diff --git a/docs/_toc.yml b/docs/_toc.yml index 91199ffc0..d0d63ed72 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -7,13 +7,16 @@ parts: - caption: Getting Started chapters: - file: installation + - file: v3_to_v4 - caption: User Reference chapters: - file: intro_concepts - file: advanced_concepts + - file: wind_data_user - file: floating_wind_turbine - file: turbine_interaction + - file: operation_models_user - file: input_reference_main - file: input_reference_turbine - file: examples diff --git a/docs/advanced_concepts.ipynb b/docs/advanced_concepts.ipynb index aae2869fb..c13513c79 100644 --- a/docs/advanced_concepts.ipynb +++ b/docs/advanced_concepts.ipynb @@ -21,8 +21,8 @@ "# 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\")" + "from floris import FlorisModel\n", + "fmodel = FlorisModel(\"gch.yaml\")" ] }, { @@ -32,16 +32,16 @@ "## 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", + "for nearly all of the data in the `floris.core` 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", + " and have the shape `(n findex, 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." + " `(n findex, n turbines, 1, 1)`. For scalar quanities, the arrays\n", + " may be created with the shape `(n findex, n turbines)` and\n", + " then expanded to the 4-dimensional shape prior to running the wake calculation." ] }, { @@ -55,19 +55,19 @@ "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", + "the {py:meth}`floris.core.grid.TurbineGrid` or {py:meth}`floris.core.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, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -79,9 +79,9 @@ "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", + "fmodel.set(layout_x=[0.0], layout_y=[0.0])\n", + "rotor_radius = fmodel.core.farm.rotor_diameters[0] / 2.0\n", + "hub_height = fmodel.core.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", @@ -89,7 +89,7 @@ "# 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.scatter(fmodel.core.grid.y_sorted[0,0], fmodel.core.grid.z_sorted[0,0], marker=\"+\", color=\"r\")\n", "ax.plot(circlex, circley)\n", "ax.set_aspect('equal', 'box')\n", "plt.show()" diff --git a/docs/api_docs.md b/docs/api_docs.md index e94478f75..2fb249f72 100644 --- a/docs/api_docs.md +++ b/docs/api_docs.md @@ -12,10 +12,19 @@ more users will interface with the software. :toctree: _autosummary :recursive: - floris.logging_manager - floris.simulation - floris.tools - floris.type_dec + floris.flow_visualization + floris.floris_model + floris.wind_data + floris.uncertain_floris_model floris.turbine_library + floris.parallel_floris_model + floris.optimization + floris.layout_visualization + floris.cut_plane + floris.core + floris.convert_turbine_v3_to_v4 + floris.convert_floris_input_v3_to_v4 floris.utilities + floris.type_dec + floris.logging_manager ``` diff --git a/docs/architecture.md b/docs/architecture.md index cdfa60bb4..bd7687404 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -32,12 +32,12 @@ packages. The internal structure and hierarchy is described below. ```{mermaid} classDiagram - class simulation["floris.simulation"] { - +Floris + class core["floris.core"] { + +Core } - class tools["floris.tools"] { - +FlorisInterface + class floris["floris"] { + +FlorisModel } class logging_manager @@ -51,25 +51,25 @@ classDiagram tools <-- simulation ``` -## floris.tools +## floris -This is the user interface. Most operations at the user level will happen through `floris.tools`. +This is the user interface. Most operations at the user level will happen through `floris`. This package contains a wide variety of functionality including but not limited to: -- Initializing and driving a simulation with `tools.floris_interface` -- Wake field visualization through `tools.visualization` -- Yaw and layout optimization in `tools.optimization` -- Parallelizing work load with `tools.parallel_computing_interface` +- Initializing and driving a simulation with `floris_model` +- Wake field visualization through `flow_visualization` +- Yaw and layout optimization in `optimization` +- Wind data handling in `wind_data` -## floris.simulation +## floris.core -This is the core simulation package. This should primarily be used within `floris.simulation` and -`floris.tools`, and user scripts generally won't interact directly with this package. +This is the core simulation package. This should primarily be used within `floris.core` and +`floris`, and user scripts generally won't interact directly with this package. ```{mermaid} classDiagram - class Floris + class Core class Farm @@ -115,11 +115,11 @@ classDiagram parameters: dict } - Floris *-- Farm - Floris *-- FlowField - Floris *-- Grid - Floris *-- WakeModelManager - Floris --> Solver + Core *-- Farm + Core *-- FlowField + Core *-- Grid + Core *-- WakeModelManager + Core --> Solver WakeModelManager *-- WakeCombination WakeModelManager *-- WakeDeflection WakeModelManager *-- WakeTurbulence diff --git a/docs/empirical_gauss_model.md b/docs/empirical_gauss_model.md index c1c9fddf5..5edb7f4af 100644 --- a/docs/empirical_gauss_model.md +++ b/docs/empirical_gauss_model.md @@ -152,7 +152,6 @@ $$ \text{WIM}_j = \sum_{i \in T^{\text{up}}(j)} \frac{A_{ij} a_i (1 + g_\text{YA Note that the second term means that, unlike when `enable_yaw_added_recovery` is `false`, a turbine may affect the recovery of its own wake by yawing. - ## Mirror wakes Mirror wakes are also enabled by default in the empirical model to model the @@ -160,3 +159,23 @@ ground effect. Essentially, turbines are placed below the ground so that the vertical expansion of their (mirror) wakes appears in the above-ground flow some distance downstream, to model the reflection of the true turbine wakes as they bounce off of the ground/sea surface. + +## Added mixing by active wake control + +As the name suggests, active wake control (AWC) aims to enhance mixing to the +wake of the controlled turbine. This effect is activated by setting +`enable_active_wake_mixing` to `true`, and `awc_modes` to `"helix"` (other AWC +strategies are yet to be implemented). The wake can then be controlled by +setting the amplitude of the AWC excitation using `awc_amplitudes` (see the +[AWC operation model](operation_models_user.ipynb#awc-model)). +The effect of AWC is represented by updating the +wake-induced mixing term as follows: + +$$ \text{WIM}_j = \sum_{i \in T^{\text{up}}(j)} \frac{A_{ij} a_i} {(x_j - x_i)/D_i} + +\frac{A_{\text{AWC},j}^{p_\text{AWC}}}{d_\text{AWC}}$$ + +where $A_{\text{AWC},j}$ is the AWC amplitude of turbine $j$, and the exponent $p_\text{AWC}$ and +denominator $d_\text{AWC}$ are tuning parameters that can be set in the `emgauss.yaml` file with +the fields `awc_wake_exp` and `awc_wake_denominator`, respectively. +Note that, in contrast to the yaw added mixing case, a turbine currently affects _only_ its own +wake by applying AWC. diff --git a/docs/examples.md b/docs/examples.md deleted file mode 100644 index eebb3c89d..000000000 --- a/docs/examples.md +++ /dev/null @@ -1,241 +0,0 @@ -(examples)= -# Examples Index - -The FLORIS software repository includes a set of -[examples/](https://github.com/NREL/floris/tree/main/examples) -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 -[](concepts_intro). - - -## Basic setup and pre and post processing - -These examples are primarily for demonstration and explanation purposes. -They build up data for a simulation, execute the calculations, and do various -post processing steps to analyse the results. - -### 01_opening_floris_computing_power.py -This example script loads an input file and makes changes to the turbine layout -and atmospheric conditions. It then configures wind turbine yaw settings and -executes the simulation. Finally, individual turbine powers are reported. -It demonstrates the vectorization capabilities of FLORIS by first creating -a simulation with a single wind condition, and then creating another -simulation with multiple wind conditions. - -### 02_visualizations.py -Create visualizations for x, y, and z planes in the whole farm as well as plots of the grid points -on each turbine rotor. - -### 03_making_adjustments.py -Make various changes to an initial configuration and plot results on a single figure. -- Change atmospheric conditions including wind speed, wind direction, and shear -- Create a new layout -- Configure yaw settings - -### 04_sweep_wind_directions.py -Simulate a wind farm over multiple wind directions and one wind speed. -Evaluate the individual turbine powers. -- Setting up a problem considering the vectorization of the calculations - - Data structures - - Broadcasted mathematical operations - -### 05_sweep_wind_speeds.py -Same as above except multiple wind speeds and one wind direction. -Evaluate the individual turbine powers. -- Setting up a problem considering the vectorization of the calculations - - Data structures - - Broadcasted mathematical operations - -### 06_sweep_wind_conditions.py -Simulate a wind farm with multiple wind speeds and wind directions. -- Setting up a problem considering the vectorization of the calculations - - Data structures - - Broadcasted mathematical operations - -### 07_calc_aep_from_rose.py -Load wind rose information from a .csv file and calculate the AEP of -a wind farm. -- Create a new layout -- Arrange the wind rose data into arrays -- Create the frequency information from the wind condition data - -### 08_calc_aep_from_rose_use_class.py -Do the above but use the included WindRose class. - -### 09_compare_farm_power_with_neighbor.py -Consider the affects of one wind farm on another wind farm's AEP. - -### 20_calculate_farm_power_with_uncertainty.py -Calculate the farm power with a consideration of uncertainty -with the default gaussian probability distribution. - -### 21_demo_time_series.py -Simulate a time-series of wind condition data and generate plots -of turbine power over time. - -### 22_get_wind_speed_at_turbines.py -Similar to the "Getting Started" tutorial. Sets up a simulation and -prints the wind speeds at all turbines. - -### 16_heterogeneous_inflow.py -Define non-uniform (heterogeneous) atmospheric conditions by specifying -speedups at locations throughout the farm. Show plots of the -impact on wind turbine wakes. - -### 16b_heterogeneity_multiple_ws_wd.py -Illustrate usage of heterogeneity with multiple wind speeds and directions. - -## 16c_optimize_layout_with_heterogeneity.py -This example shows a layout optimization using the geometric yaw option. It -combines elements of examples 15 (layout optimization) and 16 (heterogeneous -inflow) for demonstrative purposes. If you haven't yet run those examples, -we recommend you try them first. - -Heterogeneity in the inflow provides the necessary driver for coupled yaw -and layout optimization to be worthwhile. First, a layout optimization is -run without coupled yaw optimization; then a coupled optimization is run to -show the benefits of coupled optimization when flows are heterogeneous. - -### 17_multiple_turbine_types.py -Load an input file that describes a wind farm with two turbines -of different types and plot the wake profiles. - -### 23_visualize_layout.py -Use the visualize_layout function to provide diagram visualization -of a turbine layout within FLORIS. - -### 24_floating_turbine_models.py -Demonstrates the definition of a floating turbine and how to enable the effects of tilt -on Cp and Ct. - -For further examples on floating wind turbines, see also examples -25 (vertical wake deflection by a forced tilt angle) and 29 (comparison between -a fixed-bottom and floating wind farm). - -### 25_tilt_driven_vertical_wake_deflection.py - -This example demonstrates vertical wake deflections due to the tilt angle when running -with the Empirical Gauss model. Note that only the Empirical Gauss model implements -vertical deflections at this time. Also be aware that this example uses a potentially -unrealistic tilt angle, 15 degrees, to highlight the wake deflection. Moreover, the magnitude -of vertical deflections due to tilt has not been validated. - -For further examples on floating wind turbines, see also examples -24 (effects of tilt on turbine power and thrust coefficients) and 29 -(comparison between a fixed-bottom and floating wind farm). - -### 26_empirical_gauss_velocity_deficit_parameters.py - -This example illustrates the main parameters of the Empirical Gaussian -velocity deficit model and their effects on the wind turbine wake. - -### 27_empirical_gauss_deflection_parameters.py -This example illustrates the main parameters of the Empirical Gaussian -deflection model and their effects on the wind turbine wake. - -### 28_extract_wind_speed_at_points.py -This example demonstrates the use of the `FlorisInterface.sample_flow_at_points` method -to extract the wind speed information at user-specified locations in the flow. - -Specifically, this example gets the wind speed at a single x, y location and four different -heights over a sweep of wind directions. This mimics the wind speed measurements of a met -mast across all wind directions (at a fixed free stream wind speed). - -Try different values for met_mast_option to vary the location of the met mast within -the two-turbine farm. - -### 32_plot_velocity_deficit_profiles.py -This example illustrates how to plot velocity deficit profiles at several locations -downstream of a turbine. Here we use the following definition: - - velocity_deficit = (homogeneous_wind_speed - u) / homogeneous_wind_speed - , where u is the wake velocity obtained when the incoming wind speed is the - same at all heights and equal to `homogeneous_wind_speed`. - -### 29_floating_vs_fixedbottom_farm.py - -Compares a fixed-bottom wind farm (with a gridded layout) to a floating -wind farm with the same layout. Includes: -- Turbine-by-turbine power comparison for a single wind speed and direction -- Flow visualizations for a single wind speed and direction -- AEP calculations based on an example wind rose. - -For further examples on floating wind turbines, see also examples -24 (effects of tilt on turbine power and thrust coefficients) and 25 -(vertical wake deflection by a forced tilt angle). - -### 30_multi_dimensional_cp_ct.py - -This example showcases the capability of using multi-dimensional Cp/Ct data in turbine defintions -dependent on external conditions. Specifically, fictional data for varying Cp/Ct values based on -wave period, Ts, and wave height, Hs, is used, showing the user how to setup the turbine -definition and input file. Also demonstrated is the different method for getting turbine -powers when using multi-dimensional Cp/Ct data. - -### 31_multi_dimensional_cp_ct_2Hs.py - -This example builds on example 30. Specifically, fictional data for varying Cp/Ct values based on -wave period, Ts, and wave height, Hs, is used to show the difference in power performance for -different wave heights. - -### 32_specify_turbine_power_curve.py - -This example demonstrates how to generate a turbine dictionary or yaml input file based on -a specified power and thrust curve. The power and thrust curves may be specified as power -and thrust coefficients or as absolute values. - -## Optimization - -These examples demonstrate use of the optimization routines -included in FLORIS through {py:mod}`floris.tools.optimization`. These -focus on yaw settings and wind farm layout, but the concepts -are general and can be used for other optimizations. - -### 10_opt_yaw_single_ws.py -Using included yaw optimization routines, run a yaw optimization for a single wind speed -and plot yaw settings and performance. - -### 11_opt_yaw_multiple_ws.py -Using included yaw optimization routines, run a yaw optimization for multiple wind -conditions including multiple wind speeds and wind directions. -Similar to above but with extra steps for post processing. - -### 12_optimize_yaw.py -Construct wind farm yaw settings for a full wind rose based on the -optimized yaw settings at a single wind speed. Then, compare -results to the baseline no-yaw configuration. - -### 12_optimize_yaw_in_parallel.py -Comparable to the above but perform all the computations using -parallel processing. In the current example, use 16 cores -simultaneously to calculate the AEP and perform a wake steering -yaw angle optimization for multiple wind speeds. - -### 13_optimize_yaw_with_neighboring_farm.py -Same as above but considering the effects of a nearby wind farm. - -### 14_compare_yaw_optimizers.py -Show the difference in optimization results for -- SerialRefine -- SciPy - -### 15_optimize_layout.py -Optimize a wind farm layout for AEP within a square boundary and a -random wind resource using the SciPy optimization routines. - - -## Gallery - -The examples listed here are fun and interesting. If you're doing something -cool with FLORIS and want to share, create a pull request with your example -listed here! - -### 18_check_turbine.py -Plot power and thrust curves for each turbine type included in the -turbine library. Additionally, plot the losses due to yaw. - -### 19_streamlit_demo.py -Creates a Streamlit dashboard to quickly modify the layout and -atmospheric conditions of a wind farm. diff --git a/docs/floating_wind_turbine.md b/docs/floating_wind_turbine.md index e8def2df9..c4dabe90e 100644 --- a/docs/floating_wind_turbine.md +++ b/docs/floating_wind_turbine.md @@ -2,7 +2,8 @@ # Floating Wind Turbine Modeling The FLORIS wind turbine description includes a definition of the performance curves -(Cp and Ct) as a function of wind speed, and this lookup table is used directly in +(`power` and `thrust_coefficient`) as a function of wind speed, and this lookup table is used +directly in the calculation of power production for a steady-state atmospheric condition (wind speed and wind direction). The power curve definition typically assumes a fixed-bottom wind turbine with no active or controllable tilt. However, floating @@ -19,7 +20,5 @@ an additional input, `floating_tilt_table`, in the turbine definition which sets steady tilt angle of the turbine based on wind speed. An interpolation is created and the tilt angle is computed for each turbine based on effective velocity. Taking into account the turbine rotor's built-in tilt, the absolute tilt change can then be used -to correct Cp and Ct. This tilt angle is then used directly in the selected wake models. - -**NOTE** No wake models currently use the tilt for vertical wake deflection, -but it will be available with the inclusion of an upcoming wake model. +to correct the power and thrust coefficient. +This tilt angle is then used directly in the selected wake models. diff --git a/docs/index.md b/docs/index.md index 12ce55392..202627695 100644 --- a/docs/index.md +++ b/docs/index.md @@ -13,25 +13,29 @@ the conversation in [GitHub Discussions](https://github.com/NREL/floris/discussi FLORIS is a Python package run on the command line typically by providing an input file with an initial configuration. It can be installed with ```pip install floris``` (see {ref}`installation`). The typical entry point is -{py:class}`.FlorisInterface` which accepts the path to the +{py:class}`.FlorisModel` which accepts the path to the input file as an argument. From there, changes can be made to the initial -configuration through the {py:meth}`.FlorisInterface.reinitialize` +configuration through the {py:meth}`.FlorisModel.set` routine, and the simulation is executed with -{py:meth}`.FlorisInterface.calculate_wake`. +{py:meth}`.FlorisModel.run`. ```python -from floris.tools import FlorisInterface -fi = FlorisInterface("path/to/input.yaml") -fi.reinitialize(wind_directions=[i for i in range(10)]) -fi.calculate_wake() +from floris import FlorisModel +fmodel = FlorisModel("path/to/input.yaml") +fmodel.set( + wind_directions=[i for i in range(10)], + wind_speeds=[8.0]*10, + turbulence_intensities=[0.06]*10 +) +fmodel.run() ``` 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 -{py:meth}`.FlorisInterface.get_farm_AEP`, and -a visualization package is available in {py:mod}`floris.tools.visualization`. +{py:class}`.FlorisModel` such as +{py:meth}`.FlorisModel.get_turbine_layout`, +{py:meth}`.FlorisModel.get_turbine_powers` and +{py:meth}`.FlorisModel.get_farm_AEP`, and +a visualization package is available in {py:mod}`floris.flow_visualization`. A collection of examples are included in the [repository](https://github.com/NREL/floris/tree/main/examples) and described in detail in {ref}`examples`. diff --git a/docs/installation.md b/docs/installation.md index 2e9fdd0ed..4a06260e6 100644 --- a/docs/installation.md +++ b/docs/installation.md @@ -7,18 +7,18 @@ The following sections detail how download and install FLORIS for each use case. (requirements)= ## Requirements -FLORIS is intended to be used with Python 3.8, 3.9, or 3.10, and it is highly recommended that users +FLORIS is intended to be used with Python 3.8 and up, and it is highly recommended that users work within a virtual environment for both working with and working on FLORIS, to maintain a clean and sandboxed environment. The simplest way to get started with virtual environments is through [conda](https://docs.conda.io/en/latest/miniconda.html). -Installing into a Python environment that contains FLORIS v2 may cause conflicts. +Installing into a Python environment that contains a previous version of FLORIS may cause conflicts. If you intend to use [pyOptSparse](https://mdolab-pyoptsparse.readthedocs-hosted.com/en/latest/) with FLORIS, it is recommended to install that package first before installing FLORIS. ```{note} -If upgrading from v2, it is highly recommended to install FLORIS V3 into a new virtual environment. +If upgrading, it is highly recommended to install FLORIS v4 into a new virtual environment. ``` (pip)= @@ -33,7 +33,7 @@ pip install floris (source)= ## Source Code Installation -Developers and anyone who intends to inspect the source code can install FLORIS by downloading the +Developers and anyone who intends to inspect the source code or wants to run examples can install FLORIS by downloading the git repository from GitHub with ``git`` and use ``pip`` to locally install it. The following commands in a terminal or shell will download and install FLORIS. ```bash @@ -60,22 +60,28 @@ and importing FLORIS: Help on package floris: NAME - floris - # Copyright 2021 NREL + floris - # Copyright 2024 NREL PACKAGE CONTENTS + convert_floris_input_v3_to_v4 + convert_turbine_v3_to_v4 + core (package) + cut_plane + floris_model + flow_visualization + layout_visualization logging_manager - simulation (package) - tools (package) + optimization (package) + parallel_floris_model + turbine_library (package) type_dec + uncertain_floris_model utilities - -DATA - ROOT = PosixPath('/Users/rmudafor/Development/floris') - VERSION = '3.2' - version_file = <_io.TextIOWrapper name='/Users/rmudafor/Development/fl... + version + wind_data VERSION - 3.2 + 4.0 FILE ~/floris/floris/__init__.py @@ -84,7 +90,7 @@ FILE (developers)= ## Developer Installation -For users that will also be contributing to the FLORIS code repoistory, the process is similar to +For users that will also be contributing to the FLORIS code repository, the process is similar to the source code installation, but with a few extra considerations. The steps are laid out in our [developer's guide](dev_guide.md). diff --git a/docs/intro_concepts.ipynb b/docs/intro_concepts.ipynb index f083c6054..439a5032b 100644 --- a/docs/intro_concepts.ipynb +++ b/docs/intro_concepts.ipynb @@ -8,21 +8,27 @@ "(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", + "FLORIS is a Python-based software library for calculating wind farm performance considering\n", + "the effect of turbine-turbine interactions through their wakes.\n", + "There are two primary packages to understand when using FLORIS:\n", + "- `floris.core`: This package contains the core functionality for calculating the wind farm wake\n", + " and turbine-turbine interactions. This package is the computational engine of FLORIS.\n", + " All of the mathematical models and algorithms are implemented here.\n", + "- `floris`: This is the top-level package that provides most of the functionality that the\n", + " majority of users will need. The main entry point is `FlorisModel` which is a high-level\n", + " interface to the computational engine.\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", + "2. Run the wind farm wake calculation\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", + "Generally, users will only interact with `floris` and most often through the `FlorisModel` class.\n", + "Additionally, `floris` contains functionality for comparing results, creating visualizations,\n", + "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." @@ -33,9 +39,9 @@ "id": "699c51dd", "metadata": {}, "source": [ - "## Initialize FlorisInterface\n", + "## Initialize Floris\n", "\n", - "The `FlorisInterface` provides functionality to build a wind farm representation and drive\n", + "The `FlorisModel` class 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." @@ -62,10 +68,10 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "from floris.tools import FlorisInterface\n", + "from floris import FlorisModel\n", "\n", - "fi = FlorisInterface(\"gch.yaml\")\n", - "x, y = fi.get_turbine_layout()\n", + "fmodel = FlorisModel(\"gch.yaml\")\n", + "x, y = fmodel.get_turbine_layout()\n", "\n", "print(\" x y\")\n", "for _x, _y in zip(x, y):\n", @@ -80,10 +86,10 @@ "## 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", + "However, it is often simplest 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", + "the wind farm representation are handled through the `FlorisModel.set()`\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", @@ -112,9 +118,9 @@ "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", + "fmodel.set(layout_x=x_2x2, layout_y=y_2x2)\n", "\n", - "x, y = fi.get_turbine_layout()\n", + "x, y = fmodel.get_turbine_layout()\n", "\n", "print(\" x y\")\n", "for _x, _y in zip(x, y):\n", @@ -126,12 +132,13 @@ "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", + "Additionally, we can change the wind speeds, wind directions, and turbulence intensity.\n", + "The set of wind conditions is given as arrays of wind speeds, wind directions, and turbulence\n", + "intensity combinations that describe the atmospheric conditions to compute.\n", + "This requires that all arrays be the same length.\n", "\n", - "Notice that we can give `FlorisInterface.reinitialize()` multiple keyword arguments at once." + "Notice that we can give `FlorisModel.set()` multiple keyword arguments at once.\n", + "There is no expected output from the `FlorisModel.set()` function." ] }, { @@ -141,14 +148,19 @@ "metadata": {}, "outputs": [], "source": [ - "# One wind direction and one speed -> one atmospheric condition\n", - "fi.reinitialize(wind_directions=[270.0], wind_speeds=[8.0])\n", + "fmodel.set(wind_directions=[270.0], wind_speeds=[8.0], turbulence_intensities=[0.1])\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", + "fmodel.set(\n", + " wind_directions=[270.0, 280.0],\n", + " wind_speeds=[8.0, 8.0],\n", + " turbulence_intensities=[0.1, 0.1],\n", + ")\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])" + "fmodel.set(\n", + " wind_directions=[270.0, 280.0, 270.0, 280.0],\n", + " wind_speeds=[8.0, 8.0, 9.0, 9.0],\n", + " turbulence_intensities=[0.1, 0.1, 0.1, 0.1],\n", + ")" ] }, { @@ -156,16 +168,15 @@ "id": "da4f3309", "metadata": {}, "source": [ - "`FlorisInterface.reinitialize()` creates all of the basic data structures required\n", + "`FlorisModel.set()` 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", + "most data is structured as a 4-dimensional Numpy array with the following dimensions:\n", "\n", "```python\n", "np.array(\n", " (\n", - " wind directions,\n", - " wind speeds,\n", + " findex,\n", " turbines,\n", " grid-1,\n", " grid-2\n", @@ -173,9 +184,13 @@ ")\n", "```\n", "\n", + "The `findex` dimension contains the index to a particular calculation in the overall data\n", + "domain. This typically represents a unique combination of wind direction and wind speed\n", + "making up a wind condition, but it can also be used to represent any other varying quantity.\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", + "the first wind condition. We can also plot all the grid points in\n", "space to get an idea of the overall form of our grid." ] }, @@ -190,9 +205,9 @@ "output_type": "stream", "text": [ "Dimensions of grid x-components\n", - "(2, 2, 4, 3, 3)\n", + "(4, 4, 3, 3)\n", "\n", - "Turbine 3 grid x-components for first wind direction and first wind speed\n", + "3rd turbine x-components for first wind condition (at findex=0)\n", "[[800. 800. 800.]\n", " [800. 800. 800.]\n", " [800. 800. 800.]]\n" @@ -200,7 +215,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -211,15 +226,15 @@ ], "source": [ "print(\"Dimensions of grid x-components\")\n", - "print(np.shape(fi.floris.grid.x_sorted))\n", + "print(np.shape(fmodel.core.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", + "print(\"3rd turbine x-components for first wind condition (at findex=0)\")\n", + "print(fmodel.core.grid.x_sorted[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", + "x = fmodel.core.grid.x_sorted[0, :, :, :]\n", + "y = fmodel.core.grid.y_sorted[0, :, :, :]\n", + "z = fmodel.core.grid.z_sorted[0, :, :, :]\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, projection=\"3d\")\n", @@ -233,12 +248,12 @@ "id": "ebfdc746", "metadata": {}, "source": [ - "## Execute wake calculation\n", + "## Run the Floris 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." + "direction combination. Since we have not explicitly specified yaw control settings\n", + "when creating the `FlorisModel` settings, all turbines are aligned with the inflow." ] }, { @@ -248,7 +263,7 @@ "metadata": {}, "outputs": [], "source": [ - "fi.calculate_wake()" + "fmodel.run()" ] }, { @@ -258,10 +273,9 @@ "source": [ "## Get turbine power\n", "\n", - "At this point, the simulation has completed and we can use the `FlorisInterface` to\n", + "At this point, the simulation has completed and we can use `FlorisModel` 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." + "we have configured the simulation with four wind conditions and four turbines." ] }, { @@ -275,44 +289,43 @@ "output_type": "stream", "text": [ "Dimensions of `powers`\n", - "(2, 2, 4)\n", + "(4, 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", + "Wind condition 0\n", + " Turbine 0 - 1,753.95 kW\n", + " Turbine 1 - 1,753.95 kW\n", + " Turbine 2 - 904.68 kW\n", + " Turbine 3 - 904.85 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", + "Wind condition 1\n", + " Turbine 0 - 1,753.95 kW\n", + " Turbine 1 - 1,753.95 kW\n", + " Turbine 2 - 1,644.86 kW\n", + " Turbine 3 - 1,643.39 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" + "[[1753.95445918 1753.95445918 904.68478734 904.84672946]\n", + " [1753.95445918 1753.95445918 1644.85720431 1643.39012544]\n", + " [2496.42786184 2496.42786184 1276.4580679 1276.67310219]\n", + " [2496.42786184 2496.42786184 2354.40522998 2352.47398836]]\n" ] } ], "source": [ - "powers = fi.get_turbine_powers() / 1000.0 # calculated in Watts, so convert to kW\n", + "powers = fmodel.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_TURBINES = fmodel.core.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", + " print(f\"Wind condition {i}\")\n", " for j in range(N_TURBINES):\n", - " print(f\" Turbine {j} - {powers[i, 0, j]:7,.2f} kW\")\n", + " print(f\" Turbine {j} - {powers[i, j]:7,.2f} kW\")\n", " print()\n", "\n", "print(\"Turbine powers for all turbines at all wind conditions\")\n", @@ -326,16 +339,11 @@ "source": [ "## Applying yaw angles\n", "\n", - "Yaw angles are applied to turbines through the `FlorisInterface.calculate_wake` function.\n", + "Yaw angles are another configuration option through `FlorisModel.set`.\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", + "- 0: findex\n", + "- 1: number of turbines\n", "\n", "It is typically easiest to start with an array of 0's and modify individual\n", "turbine yaw settings, as shown below." @@ -352,30 +360,30 @@ "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", + "[[0. 0. 0. 0.]\n", + " [0. 0. 0. 0.]\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" + "[[25. 0. 0. 0.]\n", + " [25. 0. 0. 0.]\n", + " [25. 0. 0. 0.]\n", + " [25. 0. 0. 0.]]\n" ] } ], "source": [ - "yaw_angles = np.zeros((2, 2, 4))\n", + "# Recall that the previous `fmodel.set()` command set up four atmospheric conditions\n", + "# and there are 4 turbines in the farm. So, the yaw angles array must be 4x4.\n", + "yaw_angles = np.zeros((4, 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", + "yaw_angles[:, 0] = 25\n", "print(yaw_angles)\n", "\n", - "fi.calculate_wake(yaw_angles=yaw_angles)" + "fmodel.set(yaw_angles=yaw_angles)" ] }, { @@ -407,59 +415,60 @@ "output_type": "stream", "text": [ "Power % difference with yaw\n", - " 270 degrees: 7.39%\n", - " 280 degrees: 0.13%\n" + " 270 degrees: 0.16%\n", + " 280 degrees: 0.17%\n" ] } ], "source": [ "# 1. Load an input file\n", - "fi = FlorisInterface(\"gch.yaml\")\n", - "\n", - "fi.floris.solver\n", + "fmodel = FlorisModel(\"gch.yaml\")\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", + "wind_speeds = [8.0, 8.0]\n", + "turbulence_intensities = [0.1, 0.1]\n", "\n", "# Pass the new data to FlorisInterface\n", - "fi.reinitialize(\n", + "fmodel.set(\n", " layout_x=x,\n", " layout_y=y,\n", " wind_directions=wind_directions,\n", - " wind_speeds=wind_speeds\n", + " wind_speeds=wind_speeds,\n", + " turbulence_intensities=turbulence_intensities,\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", + "fmodel.run()\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", + "turbine_powers = fmodel.get_turbine_powers() / 1000.0 # Given in W, so convert to kW\n", + "farm_power_baseline = np.sum(turbine_powers, 1) # Sum over the second 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", + "yaw_angles = np.zeros( (2, 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] = 15 # At 270 degrees, yaw the second turbine 15 degrees\n", + "yaw_angles[1, 0] = 10 # At 280 degrees, yaw the first turbine 10 degrees\n", + "yaw_angles[1, 1] = 0 # At 280 degrees, yaw the second turbine 0 degrees\n", + "fmodel.set(yaw_angles=yaw_angles)\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", + "fmodel.run()\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", + "turbine_powers = fmodel.get_turbine_powers() / 1000.0\n", + "farm_power_yaw = np.sum(turbine_powers, 1)\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}%\")" + "print(f\" 270 degrees: {difference[0]:4.2f}%\")\n", + "print(f\" 280 degrees: {difference[1]:4.2f}%\")" ] }, { @@ -470,7 +479,7 @@ "## 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", + "1000 Watts, and `FlorisModel` 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", @@ -479,9 +488,7 @@ "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." + "yaw settings included." ] }, { @@ -492,7 +499,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -502,21 +509,40 @@ } ], "source": [ - "from floris.tools.visualization import visualize_cut_plane\n", + "from floris.flow_visualization import visualize_cut_plane\n", + "from floris.layout_visualization import plot_turbine_labels\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", + "# Plot the first wind condition\n", + "wd = wind_directions[0]\n", + "ws = wind_speeds[0]\n", + "ti = turbulence_intensities[0]\n", + "\n", + "fmodel.reset_operation()\n", + "horizontal_plane = fmodel.calculate_horizontal_plane(wd=[wd], ws=[ws], ti=[ti], height=90.0)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[0,0], title=\"270 - Aligned\")\n", + "plot_turbine_labels(fmodel, axarr[0,0])\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[0]], yaw_angles=yaw_angles[0:1,0:1] , height=90.0)\n", + "fmodel.set(yaw_angles=yaw_angles[0:1])\n", + "horizontal_plane = fmodel.calculate_horizontal_plane(wd=[wd], ws=[ws], ti=[ti], height=90.0)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[0,1], title=\"270 - Yawed\")\n", + "plot_turbine_labels(fmodel, axarr[0,1])\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[1]], height=90.0)\n", + "# Plot the second wind condition\n", + "wd = wind_directions[1]\n", + "ws = wind_speeds[1]\n", + "ti = turbulence_intensities[1]\n", + "\n", + "fmodel.reset_operation()\n", + "horizontal_plane = fmodel.calculate_horizontal_plane(wd=[wd], ws=[ws], ti=[ti], height=90.0)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[1,0], title=\"280 - Aligned\")\n", + "plot_turbine_labels(fmodel, axarr[1,0])\n", "\n", - "horizontal_plane = fi.calculate_horizontal_plane(wd=[wind_directions[1]], yaw_angles=yaw_angles[1:2,0:1] , height=90.0)\n", + "fmodel.set(yaw_angles=yaw_angles[1:2])\n", + "horizontal_plane = fmodel.calculate_horizontal_plane(wd=[wd], ws=[ws], ti=[ti], height=90.0)\n", "visualize_cut_plane(horizontal_plane, ax=axarr[1,1], title=\"280 - Yawed\")\n", + "plot_turbine_labels(fmodel, axarr[1,1])\n", "\n", "plt.show()" ] @@ -540,7 +566,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgoAAAFyCAYAAACUWPJkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAp7ElEQVR4nO3de3gU1eH/8c9sIDcgEZHcuCQReDAGEMPlawKIWDEFvihWYvGLBbxAFVoEWqzUx4LyBUGlSEVBigJy68PdC1gEC5ZLRPj+8AIIaIEkQhK1BQIhJJCd3x80W5dkSIZZdtnwfj3PPLpn58yczRD2wzlnzhimaZoCAACogivQDQAAAFcvggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggKuOZs3b5ZhGNq8efNVc8wJEybIMAyvsqSkJA0ZMsR543zoamwTgCuLoICgsmzZMhmGodWrV1d675ZbbpFhGNq0aVOl95o3b66MjAx/NDHobd++XRMmTNCJEycC3RSPnTt36le/+pVSU1NVr149NW/eXA888IAOHjxYaV/DMCy3nj17eu3rdrv14osvKjk5WeHh4WrXrp2WLl3qr48FBIU6gW4AYEfXrl0lSVu3btV9993nKS8qKtKePXtUp04dbdu2TT169PC8l5eXp7y8PA0YMECSdPvtt6ukpEShoaH+bbxNBw4ckMvl/yy/fft2PffccxoyZIiuu+66q6JNU6dO1bZt25SVlaV27dqpoKBAM2fOVFpamj755BO1adPGs+/ChQsr1d+1a5dmzJihu+++26v8mWee0ZQpUzR06FB16tRJ77zzjv7nf/5HhmF4/rwA1zqCAoJKQkKCkpOTtXXrVq/y7OxsmaaprKysSu9VvK4IGS6XS+Hh4f5psANhYWHV7lNcXKx69er5oTUX1KRNV8KYMWO0ZMkSr3D385//XG3bttWUKVO0aNEiT/lDDz1UqX7F0NCDDz7oKTt69KimTZumESNGaObMmZKkxx57TN27d9fYsWOVlZWlkJCQK/ipgODA0AOCTteuXbV7926VlJR4yrZt26bU1FT16tVLn3zyidxut9d7hmGoS5cukqqeT3DHHXeoTZs22rdvn3r06KHIyEg1adJEL774YqXzf/vtt+rXr5/q1aunmJgYjR49WqWlpTVu/9atW9WpUyeFh4erRYsWeuONN6rc7+L5APPnz5dhGPr44481fPhwxcTEqGnTpp73P/jgA3Xr1k316tVTgwYN1KdPH+3du7fScffv368HHnhAjRs3VkREhFq3bq1nnnlG0oW5EmPHjpUkJScne7rsjxw5UmWbJOnQoUPKysrS9ddfr8jISN12221au3at1z4VP/Nly5Zp0qRJatq0qcLDw/WTn/xE33zzTbU/s4yMjEo9QK1atVJqaqq++uqrS9YtLS3VypUr1b17d6+f1zvvvKNz585p+PDhnjLDMPTEE0/o22+/VXZ2drXtAq4F9Cgg6HTt2lULFy7Ujh07dMcdd0i6EAYyMjKUkZGhkydPas+ePWrXrp3nvZtuukmNGjW65HGPHz+un/70p/rZz36mBx54QCtWrNDvfvc7tW3bVr169ZIklZSU6Cc/+Ylyc3M1cuRIJSQkaOHChfrb3/5Wo7Z/+eWXuvvuu9W4cWNNmDBB58+f1/jx4xUbG1vjzz98+HA1btxYf/jDH1RcXCzpQnf74MGDlZmZqalTp+rMmTOaNWuWJ1QlJSVJkr744gt169ZNdevW1bBhw5SUlKR//OMfeu+99zRp0iT97Gc/08GDB7V06VJNnz5dN9xwgySpcePGVbalsLBQGRkZOnPmjEaOHKlGjRppwYIFuueee7RixQqv4SFJmjJlilwul37729/q5MmTevHFFzVw4EDt2LGjxp+/gmmaKiwsVGpq6iX3W7dunU6cOKGBAwd6le/evVv16tVTSkqKV3nnzp0971f0QgHXNBMIMnv37jUlmRMnTjRN0zTPnTtn1qtXz1ywYIFpmqYZGxtrvvbaa6ZpmmZRUZEZEhJiDh061FN/06ZNpiRz06ZNnrLu3bubksy3337bU1ZaWmrGxcWZ999/v6fslVdeMSWZy5Yt85QVFxebLVu2rHTMqvTr188MDw83c3JyPGX79u0zQ0JCzIt/HRMTE83Bgwd7Xs+bN8+UZHbt2tU8f/68p/zUqVPmdddd5/UZTdM0CwoKzOjoaK/y22+/3WzQoIHX+U3TNN1ut+f/X3rpJVOSefjw4Urtv7hNo0aNMiWZW7Zs8WpPcnKymZSUZJaXl5um+Z+feUpKillaWurZd8aMGaYk88svv6zqx3VJCxcuNCWZb7755iX3u//++82wsDDz+PHjXuV9+vQxb7zxxkr7FxcXm5LMp59+2nabgNqIoQcEnZSUFDVq1Mgz9+Dzzz9XcXGx566GjIwMbdu2TdKFuQvl5eU1+pdh/fr1vca3Q0ND1blzZx06dMhTtm7dOsXHx6t///6essjISA0bNqza45eXl2v9+vXq16+fmjdv7vV5MjMzq61fYejQoV5j5xs2bNCJEyf04IMP6ocffvBsISEh+q//+i/PXSDff/+9/v73v+uRRx7xOr+kSrdm1tS6devUuXNnr59v/fr1NWzYMB05ckT79u3z2v/hhx/2GkLo1q2bJHn9jGti//79GjFihNLT0zV48GDL/YqKirR27Vr17t270sTMkpKSKudcVMxf+fHQFnAtIygg6BiGoYyMDM9chG3btikmJkYtW7aU5B0UKv5bk6DQtGnTSl+YDRs21PHjxz2vc3Jy1LJly0r7tW7dutrjf//99yopKVGrVq0qvVeT+hWSk5O9Xn/99deSpDvvvFONGzf22j788EN99913kv7zZfzjOwScysnJqbLtFd35OTk5XuUXB5SGDRtKktfPuDoFBQXq06ePoqOjtWLFiktOOFy5cqXOnj1badhBkiIiIqqcW3L27FnP+wCYo4Ag1bVrV7333nv68ssvPfMTKmRkZGjs2LE6evSotm7dqoSEBN14443VHtPqC8c0TZ+12xcu/gKrmLi5cOFCxcXFVdq/Tp2r59fc6c/45MmT6tWrl06cOKEtW7YoISHhkvsvXrxY0dHR+u///u9K78XHx2vTpk0yTdMr+OXn50tStccGrhVXz98ggA0/Xk9h27ZtGjVqlOe9Dh06KCwsTJs3b9aOHTvUu3dvn503MTFRe/bsqfTlcuDAgWrrVtxlUNED8GM1qW+lRYsWkqSYmBjdddddlvtVhKU9e/Zc8nh2hiESExOrbPv+/fs97/vK2bNn1bdvXx08eFAbN27UzTfffMn98/PztWnTJg0ZMqTKIYb27dtr7ty5+uqrr7yOVTGxsn379j5rOxDMGHpAUOrYsaPCw8O1ePFiHT161KtHISwsTGlpaXrttddUXFzs05nrvXv31rFjx7RixQpP2ZkzZzRnzpxq64aEhCgzM1Nr1qxRbm6up/yrr77S+vXrL7tNmZmZioqK0uTJk3Xu3LlK73///feSLgSV22+/XW+99ZbX+SXvf9FXrMtQk5UZe/furU8//dTrVsLi4mLNmTNHSUlJ1X6Z11R5ebl+/vOfKzs7W8uXL1d6enq1df7yl7/I7XZXOewgSffee6/q1q2r119/3VNmmqZmz56tJk2asJIn8G/0KCAohYaGqlOnTtqyZYvCwsLUoUMHr/czMjI0bdo0STWbn1BTQ4cO1cyZMzVo0CD93//9n+Lj47Vw4UJFRkbWqP5zzz2nv/71r+rWrZuGDx+u8+fP69VXX1Vqaqq++OKLy2pTVFSUZs2apV/84hdKS0vTgAED1LhxY+Xm5mrt2rXq0qWLZ0GhP/3pT+ratavS0tI0bNgwJScn68iRI1q7dq0+++wzSfL8LJ955hkNGDBAdevWVd++fatc2Onpp5/W0qVL1atXL40cOVLXX3+9FixYoMOHD2vlypU+W8XxN7/5jd5991317dtX//rXv7wWWJKqXmRp8eLFSkhI8NxCe7GmTZtq1KhReumll3Tu3Dl16tRJa9as0ZYtW7R48WIWWwIqBPKWC8CJcePGmZLMjIyMSu+tWrXKlGQ2aNDA61ZC07S+PTI1NbXScQYPHmwmJiZ6leXk5Jj33HOPGRkZad5www3mk08+af71r3+t0e2RpmmaH3/8sdmhQwczNDTUvPHGG83Zs2eb48ePr/HtkTt37qzyuJs2bTIzMzPN6OhoMzw83GzRooU5ZMgQc9euXV777dmzx7zvvvvM6667zgwPDzdbt25tPvvss177TJw40WzSpInpcrm8bpW8uE2maZr/+Mc/zP79+3uO17lzZ/P999+v1DZJ5vLly73KDx8+bEoy582bd8mfWcXtq1bbxfbv329KMseMGXPJ45aXl5uTJ082ExMTzdDQUDM1NdVctGjRJesA1xrDNK+ymVoAAOCqwRwFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAIAlggIAALBEUAAAAJYICgAAwFKdQDcAAIBgcfbsWZWVlfnkWKGhoQoPD/fJsa4kggIAADVw9uxZJUTU13GV++R4cXFxOnz48FUfFggKAADUQFlZmY6rXAvCb1Skw5H7M3JrcMEhlZWVERQAAKhN6tUJUT0jxNExDNM3vRL+QFAAAMAGo65LhuGsR8EwTR+15sojKAAAYIMrxJDLZTg7httZfX8iKAAAYINR15DhMCgYBAUAAGonVx16FAAAgAV6FAAAgKWQUJdCQpxNZgwpZzIjAAC1kivEkCvE4dCD6FEAAKBWMlw+GHowCQoAANRKRohLhsOhB0MMPQAAUCsx9AAAACwZBnc9AAAAC0aIHPcoGMEz8kBQAADADiPEkOE4KNCjAABArWS4XDJcDiczOqzvTwQFAABs8MntkQ7r+xNBAQAAG3xy1wNDDwAA1E70KAAAAEuG4YM5CgZzFAAAqJXoUQAAAJZ8MkeBBZcAAKidXHVC5KoT4uwYZvCsuBQ8gyQAAFwFKoYenG52lJeX69lnn1VycrIiIiLUokULTZw4UWY1gWPz5s1KS0tTWFiYWrZsqfnz59v+vPQoAABgQyDmKEydOlWzZs3SggULlJqaql27dunhhx9WdHS0Ro4cWWWdw4cPq0+fPnr88ce1ePFiffTRR3rssccUHx+vzMzMGp+boAAAgA2BCArbt2/Xvffeqz59+kiSkpKStHTpUn366aeWdWbPnq3k5GRNmzZNkpSSkqKtW7dq+vTptoICQw8AANhwISi4HG4XgkJRUZHXVlpaWuU5MzIy9NFHH+ngwYOSpM8//1xbt25Vr169LNuZnZ2tu+66y6ssMzNT2dnZtj4vPQoAANhguJzf9WCUX6jfrFkzr/Lx48drwoQJlfZ/+umnVVRUpJtuukkhISEqLy/XpEmTNHDgQMtzFBQUKDY21qssNjZWRUVFKikpUURERI3aSlAAAMAGXw495OXlKSoqylMeFhZW5f7Lli3T4sWLtWTJEqWmpuqzzz7TqFGjlJCQoMGDBztqS3UICgAA2ODLp0dGRUV5BQUrY8eO1dNPP60BAwZIktq2baucnBy98MILlkEhLi5OhYWFXmWFhYWKioqqcW+CRFAAAMCWQExmPHPmjFwXhZOQkBC53W7LOunp6Vq3bp1X2YYNG5Senm7r3ExmBADAhkCso9C3b19NmjRJa9eu1ZEjR7R69Wr98Y9/1H333efZZ9y4cRo0aJDn9eOPP65Dhw7pqaee0v79+/X6669r2bJlGj16tK1z06MAAIANvhx6qKlXX31Vzz77rIYPH67vvvtOCQkJ+uUvf6k//OEPnn3y8/OVm5vreZ2cnKy1a9dq9OjRmjFjhpo2baq5c+faujVSkgyzumWdAACAioqKFB0drb2P9lWD0LqOjnWq7JxS33xPJ0+erNEchUCiRwEAABsC0aMQSAQFAADsMIwLm9NjBAmCAgAANhiGD+56ICgAAFA7+eQx0+XWtzVebQgKAADYwBwFAABgyXDZXzCpqmMEC4ICAAA2BGJlxkAiKAAAYIfLdWFzeowgQVAAAMAGwzAc37XAXQ8AANRSTGYEAACWmKMAAACsGT6YoxBEtz0QFAAAsMMHPQqiRwEAgNrJMFwyHPYIOK3vTwQFAADscBnOewToUQAAoHbirgcAAGCJux4AAIA1w3B+1wILLgEAUDsZdUJkOHzMtNP6/kRQAADAhmttCefgmU1RhYqLVd22efNmT50333xTKSkpCg8PV6tWrfTqq68G7gNc4+xev1mzZikrK0vNmzeXYRgaMmRIQNsPe9cwLy9Pzz33nDp37qyGDRvqhhtu0B133KGNGzcG+mNc0+xcw5KSEj366KNq06aNoqOjVb9+fd1yyy2aMWOGzp07F+iP4j8VCy452bg90j8WLlzo9frtt9/Whg0bKpWnpKRIkt544w09/vjjuv/++zVmzBht2bJFI0eO1JkzZ/S73/3Ob+3GBXav39SpU3Xq1Cl17txZ+fn5fmsnrNm5hsuXL9fUqVPVr18/DR48WOfPn9fbb7+tnj176q233tLDDz/sz6bj3+xcw5KSEu3du1e9e/dWUlKSXC6Xtm/frtGjR2vHjh1asmSJP5seMNfaZEbDNE0z0I3wlV/96ld67bXXVNVHKikpUbNmzXTbbbfp/fff95Q/9NBDWrNmjfLy8tSwYUN/NhcXudT1k6ScnBxPb0L9+vXVv39/zZ8/37+NxCVd6hru3btXsbGxuuGGGzxlpaWlat++vU6fPq28vDx/NhUWqvs9rMqvf/1rzZw5U/n5+YqLi7uCrQusoqIiRUdH6+jLoxQVEebsWCWlavLbV3Ty5ElFRUX5qIVXRvD0fTi0adMm/fOf/9Tw4cO9ykeMGKHi4mKtXbs2QC1DTSUmJgbVuB68paameoUESQoLC1Pv3r317bff6tSpUwFqGZxKSkqSJJ04cSKg7fCbigWXnG5B4poJCrt375YkdezY0au8Q4cOcrlcnvcB+FdBQYEiIyMVGRkZ6KaghsrKyvTDDz8oLy9Pq1ev1ssvv6zExES1bNky0E3zi4olnJ1uwSKo5yjYkZ+fr5CQEMXExHiVh4aGqlGjRjp27FiAWgZcu7755hutWrVKWVlZCgkJntvFrnWrVq3Sgw8+6HndsWNHvfXWW6pT5xr5SmEJ59qppKREoaGhVb4XHh6ukpISP7cIuLadOXNGWVlZioiI0JQpUwLdHNjQo0cPbdiwQSdOnNBHH32kzz//XMXFxYFult+whHMtFRERobKysirfO3v2rCIiIvzcIuDaVV5ergEDBmjfvn364IMPlJCQEOgmwYbY2FjFxsZKkvr376/JkyerZ8+e+vrrr2v1ZEYPw3C+smIQzbcKnkjjUHx8vMrLy/Xdd995lZeVlemf//wnf1EBfjR06FC9//77mj9/vu68885ANwcO9e/fX6dPn9Y777wT6Kb4h8twvo5CEA09XDNBoX379pKkXbt2eZXv2rVLbrfb8z6AK2vs2LGaN2+epk+f7jXOjeBVMXR78uTJALfETyp6FJxuQeKaCQp33nmnrr/+es2aNcurfNasWYqMjFSfPn0C1DLg2vHSSy/p5Zdf1u9//3s9+eSTgW4ObPrhhx+qXF9h7ty5kirfVVZbVcxRcLoFi2tqjsLEiRM1YsQIZWVlKTMzU1u2bNGiRYs0adIkXX/99YFuIqrx3nvv6fPPP5cknTt3Tl988YX+93//V5J0zz33qF27doFsHqqxevVqPfXUU2rVqpVSUlK0aNEir/d79uzpGffG1WnRokWaPXu2+vXrpxtvvFGnTp3S+vXrtWHDBvXt2/faGUYyfLAEM7dHXp2GDx+uunXratq0aXr33XfVrFkzTZ8+nX/ZBImVK1dqwYIFnte7d+/2rH/RtGlTgsJVriLkff311/rFL35R6f1NmzYRFK5yXbt21fbt27V06VIVFhaqTp06at26tf74xz/q17/+daCb5z+GD26PDKKhh1q1hDMAAFdKxRLOhW89p6jIcGfHOnNWsY+MD4olnK+pHgUAABxj6AEAAFhiHQUAAGDJ8RoK/95sSEpKkmEYlbYRI0ZUuf/8+fMr7RsefnnDJfQoAABgRwCGHnbu3Kny8nLP6z179qhnz57KysqyrBMVFaUDBw7855SX2YtBUAAAwI4APBSqcePGXq+nTJmiFi1aqHv37pZ1DMPwyZLaNQoKbrdbx44dU4MGDS47kcA+0zR16tQpJSQkyOVwcQ6uYWD46hpy/QKD38Hg58tr6GEYPuhRuPBnoKioyKs4LCxMYWFhl6xaVlamRYsWacyYMZf8s3T69GklJibK7XYrLS1NkydPVmpqqu2m1igoHDt2TM2aNbN9cPhGXl6emjZt6ugYXMPAcnoNuX6Bxe9g8PPFNfTw4WTGi/9MjB8/XhMmTLhk1TVr1ujEiRMaMmSI5T6tW7fWW2+9pXbt2unkyZN6+eWXlZGRob1799r+OdQoKDRo0ECSNM9IVmQQ3dIR7M6Ybj1sHvb8/J3gGgaGr65hRf39L4xQg/BL/2vjSjjS/Qm/n/PHPvyiUUDOW1pSpClPJPn0d/Cr54apQXjVj7y/kgrv/qXfz/lj6/f76EvaprNnivT8o4k+uYYelzEZscpj6EKA+fE6CtX1JkjSm2++qV69el3yYYbp6elKT0/3vM7IyFBKSoreeOMNTZw40VZTaxQUKro2Ig2XIo0QWyeAQ+blT0D5Ma5hAPngGlbUbxAepqgI/weF+vV9+JfsZQiPDOyCNL78HWwQHqqoAIS9Yl9+UV6G2nANf3Qwn/UoREVF2VpwKScnRxs3btSqVatsna5u3bq69dZb9c0339iqJ3F7JAAA9lTc9eB0uwzz5s1TTEyM7QcZlpeX68svv1R8fLztc3LXAwAAdhg+GHq4jKDgdrs1b948DR48WHXqeH99Dxo0SE2aNNELL7wgSXr++ed12223qWXLljpx4oReeukl5eTk6LHHHrN9XoICAAB2BGhlxo0bNyo3N1ePPPJIpfdyc3O97uo4fvy4hg4dqoKCAjVs2FAdOnTQ9u3bdfPNN9s+L0EBAAA7AvSsh7vvvltWz3HcvHmz1+vp06dr+vTpl9OySggKAADYcY0964GgAACADWZIiMwQZ3ePOa3vTwQFAADs8OHKjMGAoAAAgB0BmqMQKAQFAABsMA1DpsMeAaf1/YmgAACAHfQoAAAAS9z1AAAALPnwoVDBgKAAAIANzFEAAADWmKMAAACsmIZLpsMveqf1/YmgAACAHUxmBAAAVkz5oEdB9CgAAFA70aMAAAAs8awHAABghdsjAQCAJdMIkWk4fMy0w/r+RFAAAMAGbo8EAADWWHAJAABYYY4CAACwxNADAACwxjoKAADAkg96FJijAABALWXKkCmHcxQc1vcnW0Gh1f3Jql+XbOEvp8+dl5b/w6fH5Br6l6+vofuWDLnrR/rseDW1aX+M38/5Y++9/feAnPf8uWKfH9NIy5BRz//XcMuR5n4/54+9v3RXQM57/txpnx+TOQoAAMCaIR/MUfBJS/yCoAAAgA2mXI6f/sjTIwEAqKVYRwEAAFhijgIAALDEXQ8AAMASPQoAAMCS23DJ7fCL3ml9fyIoAABgAz0KAADAEnMUAACAJVM+6FFgHQUAAGqna61HIXgiDQAAV4ELCy65HG72gkJSUpIMw6i0jRgxwrLO8uXLddNNNyk8PFxt27bVunXrLuvzEhQAALChokfB6WbHzp07lZ+f79k2bNggScrKyqpy/+3bt+vBBx/Uo48+qt27d6tfv37q16+f9uzZY/vzEhQAALChYglnp5sdjRs3VlxcnGd7//331aJFC3Xv3r3K/WfMmKGf/vSnGjt2rFJSUjRx4kSlpaVp5syZtj8vQQEAABtM0/DJJklFRUVeW2lpabXnLysr06JFi/TII4/IsAgc2dnZuuuuu7zKMjMzlZ2dbfvzEhQAALDF5XmC5OVuFV+/zZo1U3R0tGd74YUXqj37mjVrdOLECQ0ZMsRyn4KCAsXGxnqVxcbGqqCgwPan5a4HAABs8OVdD3l5eYqKivKUh4WFVVv3zTffVK9evZSQkOCoDTVFUAAAwAZfBoWoqCivoFCdnJwcbdy4UatWrbrkfnFxcSosLPQqKywsVFxcnO22MvQAAIANgbjrocK8efMUExOjPn36XHK/9PR0ffTRR15lGzZsUHp6uu1z0qMAAIANgVpwye12a968eRo8eLDq1PH++h40aJCaNGnimePw5JNPqnv37po2bZr69Omjv/zlL9q1a5fmzJlj+7z0KAAAYIMv73qwY+PGjcrNzdUjjzxS6b3c3Fzl5+d7XmdkZGjJkiWaM2eObrnlFq1YsUJr1qxRmzZtbJ+XHgUAAGxwyyW3w39nX079u+++W6ZpVvne5s2bK5VlZWVZLshkB0EBAAAbrrVnPRAUAACwwdTlDR1cfIxgQVAAAMAGtwy5HX7RO63vTwQFAABsYOgBAABYuty7Fi4+RrAgKAAAYIMp5z0CVd+7cHUiKAAAYAM9CgAAwBJzFAAAgCV6FC4hoedtiooIv1JtwUWKSs5Kyzf69JhcQ//y9TX8oWFLlTZo4LPj1dSZw26/n/PHwiIjAnLekHPlPj/mvxq10rn69X1+3OoUfRXYUfG6YaEBOa9h+P68piSnvxHMUQAAoJaiRwEAAFhijgIAALBEjwIAALBEjwIAALBUbhoqd9gj4LS+PxEUAACwgaEHAABgyTQvbE6PESwICgAA2MBjpgEAgCWGHgAAgCWGHgAAgCVujwQAAJbc5oXN6TGCBUEBAAA7fDBHQcxRAACgdmKOAgAAsMTtkQAAwBI9CgAAwBLrKAAAAEvc9QAAACwx9AAAACyVywePmWYyIwAAtRM9CgAAwBJBAQAAWHKbhtwOhx6c1vcnggIAADbQowAAACwRFAAAgCXTB+soBFNQcAW6AQAABJOKlRmdbnYdPXpUDz30kBo1aqSIiAi1bdtWu3btstx/8+bNMgyj0lZQUGDrvPQoAABgQyCGHo4fP64uXbqoR48e+uCDD9S4cWN9/fXXatiwYbV1Dxw4oKioKM/rmJgYW+cmKAAAYEMglnCeOnWqmjVrpnnz5nnKkpOTa1Q3JiZG1113nb0T/kiNgoL57+hzqqT0sk8E+yp+3qYPBrO4hoHhq2tYUf/06dOO23Q5zp4pCsh5K5w/F5jPff5csSTf/g5es9ewLPivYQVf9igUFXlfl7CwMIWFhVXa/91331VmZqaysrL08ccfq0mTJho+fLiGDh1a7bnat2+v0tJStWnTRhMmTFCXLl1stbVGQeHUqVOSpFZPvmTr4PCNU6dOKTo62vExJK5hoDi9hhXXr1u3rr5qEmzw5e9g+u09fNEk2OSLa1jBl0GhWbNmXuXjx4/XhAkTKu1/6NAhzZo1S2PGjNHvf/977dy5UyNHjlRoaKgGDx5c5Tni4+M1e/ZsdezYUaWlpZo7d67uuOMO7dixQ2lpaTVuq2HWIGa53W4dO3ZMDRo0kGEEzyIRwc40TZ06dUoJCQlyuZzNO+UaBoavriHXLzD4HQx+vryGRUVFio6O1p/eOamIelHVV7iEkuIijbw3Wnl5eV7zB6x6FEJDQ9WxY0dt377dUzZy5Ejt3LlT2dnZNT5v9+7d1bx5cy1cuLDGdWrUo+ByudS0adMaHxS+46sEzDUMHF9cQ65f4PA7GPx8dQ0r+LJHISoqyisoWImPj9fNN9/sVZaSkqKVK1faOm/nzp21detWW3WYzAgAgA1u94XN6THs6NKliw4cOOBVdvDgQSUmJto6zmeffab4+HhbdQgKAADYEIigMHr0aGVkZGjy5Ml64IEH9Omnn2rOnDmaM2eOZ59x48bp6NGjevvttyVJr7zyipKTk5WamqqzZ89q7ty5+tvf/qYPP/zQ1rkJCgAA2OCWD26PtLl/p06dtHr1ao0bN07PP/+8kpOT9corr2jgwIGeffLz85Wbm+t5XVZWpt/85jc6evSoIiMj1a5dO23cuFE9etibUFujyYwAAFzrKiYzvrj8hCIiHU5mPFOkp7Ku08mTJ2s0RyGQ6FEAAMAGHgoFAAAsmT6Yo2A6rO9PBAUAAGygRwEAAFgKxLMeAomgAACADfQoAAAAS6bblOmwS8BpfX8iKAAAYANDDwAAwBJDDwAAwJLbbcrtsEvAaX1/IigAAGADPQoAAMASQQEAAFhym6bcDr/pndb3J4ICAAA2uN2m3OXMUQAAAFXgWQ8AAMCSaZoyHQ4dOK3vTwQFAABsYMElAABgiSWcAQCAJW6PBAAAlliZEQAAWGIyIwAAsGS6nd/eyO2RAADUUqzMCAAALDH0AAAALDGZEQAAWOL2SAAAYMk0fbDgUhAlBYICAAA2mD6YzEhQAACglnKfd8t93tn9jU7r+xNBAQAAG3goFAAAsMRDoQAAgCXWUQAAAJbcbufrILiDZ4oCQQEAADvoUQAAAJaYowAAACwRFAAAgCW3fPD0SAVPUHAFugEAAASTih4Fp5tdR48e1UMPPaRGjRopIiJCbdu21a5duy5ZZ/PmzUpLS1NYWJhatmyp+fPn2z4vQQEAABsqJjM63ew4fvy4unTporp16+qDDz7Qvn37NG3aNDVs2NCyzuHDh9WnTx/16NFDn332mUaNGqXHHntM69evt3Vuhh4AALDB9MFjpu32KEydOlXNmjXTvHnzPGXJycmXrDN79mwlJydr2rRpkqSUlBRt3bpV06dPV2ZmZo3PTY8CAAA2BGLo4d1331XHjh2VlZWlmJgY3Xrrrfrzn/98yTrZ2dm66667vMoyMzOVnZ1t69wEBQAAbPDl0ENRUZHXVlpaWuU5Dx06pFmzZqlVq1Zav369nnjiCY0cOVILFiywbGdBQYFiY2O9ymJjY1VUVKSSkpIaf16CAgAANphut082SWrWrJmio6M92wsvvFDlOd1ut9LS0jR58mTdeuutGjZsmIYOHarZs2df8c/LHAUAAGwoL3fLVe5sDebyf9fPy8tTVFSUpzwsLKzK/ePj43XzzTd7laWkpGjlypWW54iLi1NhYaFXWWFhoaKiohQREVHjthIUAACwwZcLLkVFRXkFBStdunTRgQMHvMoOHjyoxMREyzrp6elat26dV9mGDRuUnp5uq60MPQAAYEMgJjOOHj1an3zyiSZPnqxvvvlGS5Ys0Zw5czRixAjPPuPGjdOgQYM8rx9//HEdOnRITz31lPbv36/XX39dy5Yt0+jRo22dm6AAAIANbrnlNh1usjd00alTJ61evVpLly5VmzZtNHHiRL3yyisaOHCgZ5/8/Hzl5uZ6XicnJ2vt2rXasGGDbrnlFk2bNk1z5861dWukJBlmMD3CCgCAACkqKlJ0dLT6DP1/qhta39GxzpWd1to/p+nkyZM1GnoIJOYoAABgAw+FAgAAli5nCeaqjhEsCAoAANjgdrvldju7PdJpfX8iKAAAYANDDwAAwJJpumWaznoEnNb3J4ICAAA20KMAAACs+SAoiKAAAEDtVLFoktNjBAuCAgAANjD0AAAALJnmfx4T7eQYwYKgAACADe7ycrld5Y6PESwICgAA2OB2S26HQwdBtN4SQQEAADtMtw+GHoIoKRAUAACwgcmMAADAEiszAgAAS/QoAAAAS+fLTjmeY1B+vthHrbnyCAoAANRAaGio4uLitOujB3xyvLi4OIWGhvrkWFeSYZpm8PR/AAAQQGfPnlVZWZlPjhUaGqrw8HCfHOtKIigAAABLrkA3AAAAXL0ICgAAwBJBAQAAWCIoAAAASwQFAABgiaAAAAAsERQAAICl/w9qXVfTzc+0cQAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -550,7 +576,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -560,12 +586,12 @@ } ], "source": [ - "from floris.tools.visualization import plot_rotor_values\n", + "from floris.flow_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, _, _ , _ = plot_rotor_values(fmodel.core.flow_field.u, findex=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, _, _ , _ = plot_rotor_values(fmodel.core.flow_field.u, findex=1, n_rows=1, n_cols=4, return_fig_objects=True)\n", "fig.suptitle(\"Wind direction 280\")\n", "\n", "plt.show()" @@ -606,13 +632,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "shape of xs: (2, 1, 4, 3, 3)\n", + "shape of xs: (2, 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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", + "image/png": "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", "text/plain": [ "
" ] @@ -623,18 +649,18 @@ ], "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", + "xs = fmodel.core.grid.x_sorted\n", + "ys = fmodel.core.grid.y_sorted\n", + "zs = fmodel.core.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", + "xs = xs[1, :, :, :]\n", + "ys = ys[1, :, :, :]\n", + "zs = zs[1, :, :, :]\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, projection=\"3d\")\n", @@ -657,8 +683,9 @@ "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", + "FLORIS leverages vectorized operations on the CPU to reduce the computation\n", + "time for bulk calculations, and this is especially meaningful for calculating\n", + "annual energy production (AEP) on a wind rose.\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", @@ -679,9 +706,9 @@ "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" + "Jensen 661.838 0.347 \n", + "GCH 683.869 1.386 \n", + "CC 661.315 2.655 \n" ] } ], @@ -689,42 +716,71 @@ "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", + "# Using Numpy.meshgrid, we can combine 1D arrays of wind speeds and wind directions to produce\n", + "# combinations of both. Though the input arrays are not the same size, the resulting arrays\n", + "# will be the same size.\n", + "wind_directions, wind_speeds = np.meshgrid(\n", + " np.arange(0.0, 360.0, 5), # wind directions 0 to 360 degrees (exclusive) in 5 degree increments\n", + " np.arange(8.0, 12.0, 0.2), # wind speeds from 8 to 12 m/s in 0.2 m/s increments\n", + " indexing=\"ij\"\n", + ")\n", + "# meshgrid returns arrays with shape (len(wind_speeds), len(wind_directions)), so we \"flatten\" them\n", + "wind_directions = wind_directions.flatten()\n", + "wind_speeds = wind_speeds.flatten()\n", + "turbulence_intensities = 0.1 * np.ones_like(wind_speeds)\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_findex = len(wind_directions)\n", + "print(f\"Calculating AEP for {n_findex} 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", + "# Create the turbine locations using the same method as above\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", + "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", + "fmodel_jensen = FlorisModel(\"jensen.yaml\")\n", + "fmodel_gch = FlorisModel(\"gch.yaml\")\n", + "fmodel_cc = FlorisModel(\"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", + "fmodel_jensen.set(\n", + " layout_x=x,\n", + " layout_y=y,\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " turbulence_intensities=turbulence_intensities\n", + ")\n", + "fmodel_gch.set(\n", + " layout_x=x,\n", + " layout_y=y,\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " turbulence_intensities=turbulence_intensities,\n", + ")\n", + "fmodel_cc.set(\n", + " layout_x=x,\n", + " layout_y=y,\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " turbulence_intensities=turbulence_intensities,\n", + ")\n", "\n", - "def time_model_calculation(model_fi: FlorisInterface) -> Tuple[float, float]:\n", + "def time_model_calculation(model_fmodel: FlorisModel) -> Tuple[float, float]:\n", " \"\"\"\n", " This function performs the wake calculation for a given\n", - " FlorisInterface object and computes the AEP while\n", + " FlorisModel 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", + " model_fmodel (FlorisModel): _description_\n", " float (_type_): _description_\n", "\n", " Returns:\n", @@ -733,14 +789,14 @@ " 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", + " model_fmodel.run()\n", + " aep = model_fmodel.get_farm_power().sum() / n_findex / 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", + "jensen_aep, jensen_compute_time = time_model_calculation(fmodel_jensen)\n", + "gch_aep, gch_compute_time = time_model_calculation(fmodel_gch)\n", + "cc_aep, cc_compute_time = time_model_calculation(fmodel_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", @@ -761,7 +817,8 @@ "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." + "FLORIS includes a set of optimization routines for the design of wake steering controllers.\n", + "`SerialRefine` is a new method for quickly identifying optimum yaw angles." ] }, { @@ -772,11 +829,18 @@ "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)" + "x = np.linspace(0, 6*7*D, 7)\n", + "y = np.zeros_like(x)\n", + "wind_directions = np.arange(0.0, 360.0, 2.0)\n", + "wind_speeds = 8.0 * np.ones_like(wind_directions)\n", + "turbulence_intensities = 0.1 * np.ones_like(wind_directions)\n", + "fmodel_gch.set(\n", + " layout_x=x,\n", + " layout_y=y,\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " turbulence_intensities=turbulence_intensities,\n", + ")" ] }, { @@ -786,16 +850,15 @@ "metadata": {}, "outputs": [], "source": [ - "from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR\n", + "from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR\n", "\n", "# Define the SerialRefine optimization\n", "yaw_opt = YawOptimizationSR(\n", - " fi=fi_gch,\n", + " fmodel=fmodel_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", ")" ] }, @@ -823,7 +886,7 @@ "[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" + "Optimization wall time: 2.209 s\n" ] } ], @@ -855,7 +918,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0kAAANBCAYAAAA1KvUtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAADtzUlEQVR4nOzdeXxTZdr/8U/apvsGAi21BRmHTZRFdkaR4YEiKIvwc2DwcUHAUcGtuAzKgDI44AaIIo6oOI6ijlLUQcR2kEVlr1Q2QR0qLUJZFOjehia/P3gSWmkhaXOa0/T7fr360p4k97no1SS9ct/3dSwOh8OBiIiIiIiIABDg6wBERERERETMREWSiIiIiIhIBSqSREREREREKlCRJCIiIiIiUoGKJBERERERkQpUJImIiIiIiFSgIklERERERKQCFUkiIiIiIiIVBPk6AKPZ7XYOHTpEVFQUFovF1+GIiIiIiIiPOBwO8vPzSUhIICCg+vkivy+SDh06RFJSkq/DEBERERERk8jJySExMbHa2/2+SIqKigLO/CCio6N9GovNZiMtLY3k5GSsVqtPY2nolAtzUB7MQXkwD+XCHJQH81AuzMGf8pCXl0dSUpKrRqiO3xdJziV20dHRpiiSwsPDiY6Orve/YPWdcmEOyoM5KA/moVyYg/JgHsqFOfhjHi60DUeNG0RERERERCpQkSQiIiIiIlKBiiQREREREZEK/H5PkoiIiIhIQ1FeXo7NZvPqmDabjaCgIEpKSigvL/fq2N4WGBhIUFBQrS/949Miafbs2aSmprJ3717CwsLo06cPTz31FG3btnXdp6SkhClTpvDuu+9SWlrKoEGDeOmll4iLi/Nh5CIiIiIi5lJQUMDBgwdxOBxeHdfhcBAfH09OTk69uO5oeHg4zZs3Jzg4uMZj+LRIWrduHZMmTaJ79+6cPn2aRx99lOTkZPbs2UNERAQADzzwAJ988gnvv/8+MTExTJ48mZEjR/LVV1/5MnQREREREdMoLy/n4MGDhIeH07RpU68WM3a7nYKCAiIjI897AVZfczgclJWVcezYMbKysmjdunWN4/VpkbRq1apK37/xxhs0a9aMjIwM+vbty6lTp3jttddYunQp/fv3B2DJkiW0b9+eTZs20atXL1+ELSIiIuITn3/+OXfddRdz587luuuu83U4YiI2mw2Hw0HTpk0JCwvz6th2u52ysjJCQ0NNXSQBhIWFYbVaOXDggCvmmjDVnqRTp04B0LhxYwAyMjKw2WwMGDDAdZ927drRokULNm7cWGWRVFpaSmlpqev7vLw84MwvjrfXZ3rKeX5fxyHKhVkoD+agPJiHcmEOZs7DBx98wHfffcdtt93Gjh07aNKkia9DMpSZc2E2ziLJ4XBgt9u9OrZz+Z4RYxvF4XBgs9kIDAysdNzd3yXTFEl2u53777+f3/3ud1x++eUA5ObmEhwcTGxsbKX7xsXFkZubW+U4s2fP5oknnjjneFpaGuHh4V6PuybS09N9HYL8H+XCHJQHc1AezEO5MAcz5mHv3r0AHD9+nD/+8Y888MADPo6obpgxF2YTFBREfHw8BQUFlJWVGXKO/Px8Q8b1trKyMoqLi1m/fj2nT5+udFtRUZFbY5imSJo0aRK7du3iyy+/rNU4U6dOJSUlxfV9Xl4eSUlJJCcnEx0dXdswa8Vms5Gens7AgQP95mrF9ZVyYQ7KgzkoD+ahXJiDmfPwxhtvuP5/3bp1PPDAAwwZMsR3ARnMzLkwm5KSEnJycoiMjKzxErPqOBwO8vPziYqKqheNG0pKSggLC6Nv377n/Cycq8wuxBRF0uTJk1mxYgXr168nMTHRdTw+Pp6ysjJOnjxZaTbpyJEjxMfHVzlWSEgIISEh5xy3Wq2meXKZKZaGTrkwB+XBHJQH81AuzMGMeSgsLASgVatWZGVlcc8999C/f3+ioqJ8HJmxzJgLsykvL8disRAQEOD1fUPOJXbO8c0uICAAi8VS5e+Nu79HHv0r7XY7a9asYebMmYwfP54//vGP3HvvvSxZsoScnBxPhgLOVKWTJ09m+fLlfP7557Rq1arS7V27dsVqtbJ69WrXsX379pGdnU3v3r09Pp+IiIhIfeZc7vTXv/6V3/zmN+Tk5DB16lQfRyVSMxaL5bxfjz/+OADZ2dlcd911hIeH06xZMx566KFzltF5m1tFUnFxMbNmzSIpKYkhQ4bw6aefcvLkSQIDA/nhhx+YMWMGrVq1YsiQIWzatMntk0+aNIm33nqLpUuXEhUVRW5uLrm5uRQXFwMQExPD+PHjSUlJYc2aNWRkZDBu3Dh69+6tznYiIiLS4BQUFABn9me/8sorALz00ku13q4g4guHDx92fc2fP5/o6OhKxx588EHKy8u57rrrKCsrY8OGDfzjH//gjTfeYPr06YbG5tZyuzZt2tC7d28WL15c7ZrQAwcOsHTpUsaMGcNjjz3GxIkTLzjuokWLAOjXr1+l40uWLOG2224DYN68eQQEBDBq1KhKF5MVERERaWicM0lRUVH07NmT22+/nddff50JEyaQmZnp9b0oUn85HA63mxRciN1up7CwkMDAQLeW24WHh7u1d6ni9pmYmBgsFss5W2o+/fRT9uzZw3/+8x/i4uLo3Lkzf/3rX3nkkUd4/PHHa3XB2PNxq0hKS0ujffv2571Py5YtmTp1Kg8++CDZ2dlundydqwGHhoaycOFCFi5c6NaYIiIiIv6qYpEE8Oyzz7Jy5Ur27dvHrFmzmDVrli/DExMpKioiMjLSJ+cuKCggIiLCK2Nt3LiRK664gri4ONexQYMGcdddd7F79266dOnilfP8mlvL7S5UIFVktVq59NJLaxyQiIiIiFTNudzO+cdvo0aNXB8kP/XUU+zYscNnsYkYITc3t1KBBLi+r+6SQN7gcXe76p58FouF0NBQWrRoUWV3ORERERGpubKyMtf1byp2sxs5ciQjR44kNTWV8ePHs3HjRoKCTNHAWHwoPDzcVVTXlt1uJy8vj+joaLeX29V3Hj+DOnfufN41hlarldGjR/P3v/9d62JFREREvKTihTx/3fL7xRdf5PPPP2fbtm3Mnz+fBx98sK7DE5OxWCxeW/Jmt9spLy8nIiKizluAx8fHs2XLlkrHjhw54rrNKB7/K5cvX07r1q155ZVXyMzMJDMzk1deeYW2bduydOlSXnvtNT7//HOmTZtmRLwiIiIiDZKzSAoNDT1npqh58+Y899xzAEyfPp2srKw6j0/ECL1792bnzp0cPXrUdSw9PZ3o6Gguu+wyw87rcZH05JNP8vzzzzN+/HiuuOIKrrjiCsaPH8+8efN47rnnuOmmm3jhhRdYvny5EfGKiIiINEi/3o/0a+PGjaNv374UFxfzzjvv1GVoIoZJTk7msssu4+abb+abb77hs88+Y9q0aUyaNMnQLT4eF0k7d+6kZcuW5xxv2bIlO3fuBM4syTt8+HDtoxMRERER4NzOdr9msVgYMWIEAJs3b66rsEQMFRgYyIoVKwgMDKR379787//+L7fccgszZ8409LweF0nt2rVjzpw5ro2DADabjTlz5tCuXTsAfvrpp3O6UIiIiIhIzV2oSALo2bMncKZIcudSKyJmcdttt3Hy5Mkqb2vZsiUrV66kqKiIY8eO8eyzzxrenMTj0RcuXMiwYcNITEykY8eOwJnZpfLyclasWAHA/v37ufvuu70bqYiIiEgDdqHldgBdunQhKCiII0eOkJ2dXeXqHxG5MI+LpD59+pCVlcXbb7/Nd999B8CNN97I2LFjXZ9s3Hzzzd6NUkRERKSBc2cmKSwsjE6dOpGRkcHmzZtVJInUUI3mqaKiorjzzju9HYuIiIiIVMOdIgnOLLlzFkl/+MMf6iI0Eb9To0bn//znP7nqqqtISEjgwIEDAMybN4+PPvrIq8GJiIiIyBmeFEmg5g0iteFxkbRo0SJSUlIYPHgwJ06coLy8HIBGjRoxf/58b8cnIiIiIri3JwnOFkkZGRnYbDbD4xJzUcMO7/wMPC6SXnjhBRYvXsxjjz1WqatEt27dXC3ARURERMS73J1Jat26NbGxsZSUlOhvswYkMDAQoFIH6oaqqKgIAKvVWuMxPN6TlJWVRZcuXc45HhISQmFhYY0DEREREZHquVskBQQE0KNHD9LS0ti8eTNXXnllXYQnPhYUFER4eDjHjh3DarUSEFCjXTVVstvtlJWVUVJS4tVxvc3hcFBUVMTRo0eJjY11FY414XGR1KpVKzIzM8/plrJq1Srat29f40BEREREpHruLreDM0vunEXSXXfdZXRoYgIWi4XmzZuTlZXl6hngLQ6Hg+LiYsLCwrBYLF4d2wixsbHEx8fXagyPi6SUlBQmTZpESUkJDoeDLVu28M477zB79mxeffXVWgUjIiIiIlVzdyYJ1LyhoQoODqZ169ZeX3Jns9lYv349ffv2rdUStrpgtVprNYPk5HGRNGHCBMLCwpg2bRpFRUWMHTuWhIQEnn/+ecaMGVPrgERERETkXJ4UST169ABg7969nDhxgkaNGhkam5hHQEAAoaGhXh0zMDCQ06dPExoaavoiyVtqtKjwpptu4vvvv6egoIDc3FwOHjzI+PHjvR2biIiIiPwfT4qkpk2b8pvf/AaArVu3GhqXiD+qUZF0/Phxtm3bxrfffuuV6SwREREROT9P9iSBltyJ1IZHRdLu3bvp27cvcXFx9OzZkx49etCsWTP69+/Pvn37jIpRREREpMHzZCYJoFevXoCKJJGacHtPUm5uLtdccw1NmzZl7ty5tGvXDofDwZ49e1i8eDFXX301u3btolmzZkbGKyIiItIgeVokVZxJcjgc9aIrmYhZuF0kzZs3j5YtW/LVV19V2gx27bXXctddd3HVVVcxb948Zs+ebUigIiIiIg2VzWajtLQUcH+5XefOnQkODub48eNkZWW59iiJyIW5vdwuPT2dRx55pMpuGWFhYTz00EN89tlnXg1ORERERM7uRwL3Z5JCQkLo3LkzAOvXrzciLBG/5XaRtH///vNesblbt27s37/fK0GJiIiIyFnOpXbBwcEEBwe7/bjBgwcDsHz5ckPiEvFXbhdJ+fn5REdHV3t7VFRUpU85RERERMQ7PN2P5DRq1CgAPvvsM/2dJuIBj7rb5efnk5eXV+2Xw+EwKk4RERGRBsvT9t9Ol19+Ob/97W8pLS1l5cqVRoQm4pfcLpIcDgdt2rShUaNGVX61bdvWyDhFREREGqyaziRZLBbXbNKyZcu8HpeIv3K7u92aNWuMjENEREREqlHTIgnOLLl76qmn+OSTTygpKamyCZeIVOZ2kXTNNdd4/eTr16/nmWeeISMjg8OHD7N8+XJGjBjhut3hcDBjxgwWL17MyZMn+d3vfseiRYto3bq112MRERERMauaLreDM821kpKSyMnJIS0tjWHDhnk7PBG/49Zyu8LCQo8Gdff+hYWFdOrUiYULF1Z5+9NPP82CBQt4+eWX2bx5MxEREQwaNIiSkhKP4hERERGpz2ozk2SxWBg5ciSgJXci7nKrSPrtb3/LnDlzOHz4cLX3cTgcpKenM3jwYBYsWODWyQcPHsysWbO44YYbqhxv/vz5TJs2jeHDh9OxY0fefPNNDh06xIcffujW+CIiIiL+oDZFEpztcvfxxx9js9m8FpeIv3Jrud3atWt59NFHefzxx+nUqRPdunUjISGB0NBQTpw4wZ49e9i4cSNBQUFMnTqVP/3pT7UOLCsri9zcXAYMGOA6FhMTQ8+ePdm4cSNjxoyp8nGlpaWuK1ID5OXlAWeuVO3rFwXn+X0dhygXZqE8mIPyYB7KhTmYMQ+nTp0CICIiokZxde/enWbNmnH06FHS09MZOHCgt0M0hBlz0RD5Ux7c/Te4VSS1bduWZcuWkZ2dzfvvv88XX3zBhg0bKC4upkmTJnTp0oXFixczePBgAgMDaxW4U25uLgBxcXGVjsfFxbluq8rs2bN54oknzjmelpZGeHi4V2KrrfT0dF+HIP9HuTAH5cEclAfzUC7MwUx52LlzJwBHjhypcSvvLl268Nlnn/H888/Xuz92zZSLhswf8lBUVOTW/dxu3ADQokULpkyZwpQpU2oUVF2YOnUqKSkpru/z8vJISkoiOTn5vBfDrQs2m8316Y3VavVpLA2dcmEOyoM5KA/moVyYgxnz4Nxq0KlTJ4YMGVKjMaxWK5999hmZmZkMGjTIax9sG8mMuWiI/CkPzlVmF+JRkVSX4uPjgTOfmDRv3tx1/MiRI3Tu3Lnax4WEhBASEnLOcavVapqkmimWhk65MAflwRyUB/NQLszBTHlwNsWKjY2tcUwDBw6kUaNGHD16lC1bttC3b19vhmgoM+WiIfOHPLgbv9sXk61rrVq1Ij4+ntWrV7uO5eXlsXnzZnr37u3DyERERETqVm1agDtZrVZX+291uRM5P58WSQUFBWRmZpKZmQmcadaQmZlJdnY2FouF+++/n1mzZvHxxx+zc+dObrnlFhISEipdS0lERETE39W2u52TsxV4amoqDoej1nGJ+CufLrfbtm0bv//9713fO/cS3Xrrrbzxxhs8/PDDFBYWcscdd3Dy5EmuuuoqVq1apStFi4iISIPirSIpOTmZyMhIDh48yNatW+nRo4c3whPxOz6dSerXrx8Oh+OcrzfeeAM4c/GzmTNnkpubS0lJCf/5z39o06aNL0MWERERqXPO5Xa1LZJCQ0O57rrrAC25Ezkfj4ukvn37Mn36dFavXk1JSYkRMYmIiIhIBc6ZpNrsSXLSkjuRC/O4SEpOTmbTpk0MHz6c2NhYrrrqKqZNm0Z6errbfcdFRERExH3eWm4HMGTIEEJCQvjhhx9c118Skco8LpKmTZtGWloaJ0+eZM2aNVx//fVs27aN6667jsaNGxsRo4iIiEiDdfr0aYqLiwHvFEmRkZEMGjQI0JI7kerUeE/S/v372blzJ9988w07duwgKiqKwYMHezM2ERERkQbPeY0k8E6RBDBq1CjgzJI7ETmXx0XS2LFjufjii+nTpw+rVq2iV69efPrppxw/fpzly5cbEaOIiIhIg+VcahcUFERwcLBXxhw6dChBQUHs2rWL7777zitjivgTj4ukd999F5vNxoQJE7jzzjuZOHEinTp1wmKxGBGfiIiISINWcT+St/7eatSoEf379we05E6kKh4XST///DOvvvoqZWVlTJ06lSZNmtCnTx8effRR0tLSjIhRREREpMHyVvvvX9OSO5HqeVwkNWrUiGHDhjF37lwyMjLYsWMHbdq04ZlnntGeJBEREREv82b774qGDx+OxWJh27Zt5OTkeHVskfouyNMH/Pzzz6xbt461a9eydu1a9uzZQ2xsLEOHDuWaa64xIkYRERGRBsub7b8riouLo3Pnzmzfvp2MjAySkpK8Or5IfeZxkdSsWTOaNGnC1VdfzcSJE+nXrx9XXHGFEbGJiIiINHhGFUkAl112Gdu3b+fbb79lxIgRXh9fpL7yuEjasWMHHTp0MCIWEREREfkVo/YkwZkiCeDbb7/1+tgi9ZnHe5JUIImIiIjUHaP2JAG0b98egD179nh9bJH6zOOZJIAPPviAf/3rX2RnZ1NWVlbptq+//torgYmIiIiIscvtnEXS3r17sdvtBAR4/Pm5iF/y+JmwYMECxo0bR1xcHNu3b6dHjx5cdNFF7N+/X93tRERERLzMyOV2l156KVarlcLCQg4ePOj18UXqK4+LpJdeeolXXnmFF154geDgYB5++GHS09O59957OXXqlBExioiIiDRYRi63s1qttG7dGtCSO5GKPC6SsrOz6dOnDwBhYWGuJ+7NN9/MO++8493oRERERBo4I5fbwdkld2reIHKW20XSoUOHAIiPj+eXX34BoEWLFmzatAmArKwsHA6HASGKiIiINFwqkkTqnttF0uWXX87bb79N//79+fjjjwEYN24cDzzwAAMHDmT06NHccMMNhgUqIiIi0hAZuScJzrYB13I7kbPc7m43a9Ys7rzzTpKTk3nqqacAmDRpEhdddBEbNmxg2LBh/OlPfzIsUBEREZGGyMg9SVB5JsnhcGCxWAw5j0h94vZM0t13382OHTs4ceIEHTp04N///jcAY8aMYcGCBdxzzz0EBwcbFqiIiIhIQ2T0cru2bdtisVj45ZdfOHbsmCHnEKlvPLpOUqtWrfj888958cUXGTlyJO3btycoqPIQuk6SiIiIiPcYvdwuLCyMVq1asX//fvbs2UOzZs0MOY9IfeLxxWQPHDhAamoqjRo1Yvjw4ecUSSIiIiLiPUYvt4MzS+7279/Pt99+S79+/Qw7j0h94VGFs3jxYqZMmcKAAQPYvXs3TZs2NSouERERkQbPbrdTWFgIGDeTBGeKpE8++UQd7kT+j9tF0rXXXsuWLVt48cUXueWWW4yMSUREREQ4u9QOjC2S1OFOpDK3i6Ty8nJ27NhBYmKikfGIiIiIyP9xFkmBgYGEhoYadh5dK0mkMreLpPT0dCPjEBEREZFfqbgfycjW3M4i6dChQ5w6dYqYmBjDziVSH7jdAlxERERE6pbR7b+dYmJiaN68OaDZJBFQkSQiIiJiWka3/67IuS9JRZJIPSmSFi5cyCWXXEJoaCg9e/Zky5Ytvg5JRERExHB10f7bSfuSRM4yfZH03nvvkZKSwowZM/j666/p1KkTgwYN4ujRo74OTURERMRQdbXcDs4WSepwJ1IPiqS5c+cyceJExo0bx2WXXcbLL79MeHg4r7/+uq9DExERETGUltuJ+IbF4XA4fB1EdcrKyggPD+eDDz5gxIgRruO33norJ0+e5KOPPjrnMaWlpZSWlrq+z8vLIykpiePHjxMdHV0XYVdr3Lhx/PDDDzRr1szQDjVyYQ6Hg6NHjyoXPqY8mIPyYB7KhTmYKQ/79+9n165djB07ljfeeMPQcx05coSkpCQsFgtDhw419FzuMlMuGjJv5KFz585MmzbNy5F5Li8vjyZNmnDq1Knz1gZutwD3hePHj1NeXk5cXFyl43Fxcezdu7fKx8yePZsnnnjinONpaWmEh4cbEqe7VqxYwalTp3wag4iIiNQ/ZWVlrFy50tBzOBwOmjRpwvHjx/n4448NPZc0PDk5OVx55ZW+DoOioiK37mfqIqkmpk6dSkpKiut750xScnKyz2eSnn32Wb7++msuu+wyAgMDfRpLQ1deXs6ePXuUCx9THsxBeTAP5cIczJaHsLAwhg0bVidL7tasWcMXX3xh+HncZbZcNFTeyMPFF1/M4MGDvRyZ5/Ly8ty6n6mLpCZNmhAYGMiRI0cqHT9y5Ajx8fFVPiYkJISQkJBzjlutVqxWqyFxuuvWW2+ladOmDBkyxOexNHQ2m42VK1cqFz6mPJiD8mAeyoU5NOQ8XH755Vx++eW+DsOlIefCTPwpD+7Gb+rGDcHBwXTt2pXVq1e7jtntdlavXk3v3r19GJmIiIiIiPgrU88kAaSkpHDrrbfSrVs3evTowfz58yksLGTcuHFuPd7Zl8LdqTUj2Ww2ioqKyMvLq/dVeH2nXJiD8mAOyoN5KBfmoDyYh3JhDv6UB2dNcKHedaYvkkaPHs2xY8eYPn06ubm5dO7cmVWrVp3TzKE6zusLJCUlGRmmiIiIiIjUE/n5+cTExFR7u6lbgHuD3W7n0KFDREVF+bx1pLOJRE5Ojs+bSDR0yoU5KA/moDyYh3JhDsqDeSgX5uBPeXA4HOTn55OQkEBAQPU7j0w/k1RbAQEBJCYm+jqMSqKjo+v9L5i/UC7MQXkwB+XBPJQLc1AezEO5MAd/ycP5ZpCcTN24QUREREREpK6pSBIREREREalARVIdCgkJYcaMGVVex0nqlnJhDsqDOSgP5qFcmIPyYB7KhTk0xDz4feMGERERERERT2gmSUREREREpAIVSSIiIiIiIhWoSBIREREREalARZKIiIiIiEgFKpJEREREREQqUJEkIiIiIiJSgYokERERERGRClQkiYiIiIiIVKAiSUREREREpAIVSSIiIiIiIhUE+ToAo9ntdg4dOkRUVBQWi8XX4YiIiIiIiI84HA7y8/NJSEggIKD6+SK/L5IOHTpEUlKSr8MQERERERGTyMnJITExsdrb/b5IioqKAs78IKKjo30ai81mIy0tjeTkZKxWq09jaeiUC3NQHsxBeTAP5cIclAfzUC7MwZ/ykJeXR1JSkqtGqI7fF0nOJXbR0dGmKJLCw8OJjo6u979g9Z1yYQ7KgzkoD+ahXJiD8mAeyoU5+GMeLrQNR40bREREROqJkpISVq9ezenTp30diohfU5EkIiIiUk+88MILDBgwgDvuuMPXoYj4NRVJIiIiIvXEf//7XwCWLFlCenq6j6MR8V9+vydJRERExF8UFBS4/v+OO+5g165dRERE+DAiMRu73U5ZWZlXx7TZbAQFBVFSUkJ5eblXx/Y2q9VKYGBgrcdRkSQiIiJST1Qskn788Uf+8pe/MHfuXB9GJGZSVlZGVlYWdrvdq+M6HA7i4+PJycmpF9cdjY2NJT4+vlax+rRImj17Nqmpqezdu5ewsDD69OnDU089Rdu2bV33KSkpYcqUKbz77ruUlpYyaNAgXnrpJeLi4nwYuYiIiEjdKywsBOB///d/eeutt3j++ecZM2YMPXr08HFk4msOh4PDhw8TGBhIUlLSeS+U6im73U5BQQGRkZFeHdfbHA4HRUVFHD16FIDmzZvXeCyfFknr1q1j0qRJdO/endOnT/Poo4+SnJzMnj17XFPHDzzwAJ988gnvv/8+MTExTJ48mZEjR/LVV1/5MnQRERGROuecSRo1ahQAb731FuPHjycjI4Pg4GBfhiY+dvr0aYqKikhISCA8PNyrYzuX8IWGhpq6SAIICwsD4OjRozRr1qzGS+98WiStWrWq0vdvvPEGzZo1IyMjg759+3Lq1Clee+01li5dSv/+/YEzGxXbt2/Ppk2b6NWrly/CFhEREfEJZ5EUGRnJvHnzWLVqFbt27eKNN95Qx7sGzrlXSMUyriLRZrPVzyLp106dOgVA48aNAcjIyMBmszFgwADXfdq1a0eLFi3YuHFjlUVSaWkppaWlru/z8vKAMz8km81mZPgX5Dy/r+MQ5cIslAdzUB7MQ7kwBzPnwVkkhYaGEhMTw913383MmTP5/PPPGTdunI+j8z4z58JsbDYbDocDh8NhyJ4k53+9PbYRnD+Hqookd3+XTFMk2e127r//fn73u99x+eWXA5Cbm0twcDCxsbGV7hsXF0dubm6V48yePZsnnnjinONpaWlen3qsKbXsNA/lwhyUB3NQHsxDuTAHM+bhl19+AeDrr7/m559/di19Wrt2LStXrvRlaIYyYy7MJigoiPj4eAoKCrze3c4pPz/fkHG9raysjOLiYtavX3/OhZeLiorcGsM0RdKkSZPYtWsXX375Za3GmTp1KikpKa7v8/LySEpKIjk5mejo6NqGWSs2m4309HQGDhyI1Wr1aSwNnXJhDsqDOSgP5qFcmIOZ8+D8FHzw4MFccskl9OnTh8cff5wjR47QvXt3mjZt6uMIvcvMuTCbkpIScnJyiIyMJDQ01KtjOxwO8vPziYqKqhfd7UpKSggLC6Nv377n/Cycq8wuxBRF0uTJk1mxYgXr168nMTHRdTw+Pp6ysjJOnjxZaTbpyJEjxMfHVzlWSEgIISEh5xy3Wq2meXKZKZaGTrkwB+XBHJQH81AuzMFseSgvL6e4uBiARo0aYbVaadq0Ke3atWPv3r1s376d6667zsdRGsNsuTCj8vJyLBYLAQEBXm+u4Fxi5xzfWy5UcM2YMYPHH3+ce++9l6+++opdu3bRvn17MjMzz/u4gIAALBZLlb837v4eeVQk2e121q1bxxdffMGBAwcoKiqiadOmdOnShQEDBpCUlOTJcDgcDu655x6WL1/O2rVradWqVaXbu3btitVqZfXq1a4uLvv27SM7O5vevXt7dC4RERGR+szZ/huodAHZnj17snfvXjZt2uS3RZL4p8OHD7v+/7333mP69Ons27fPdSwyMtL1/7fffjubN29mx44ddRKbW0VScXExzz33HIsWLeKXX36hc+fOJCQkEBYWxg8//MCHH37IxIkTSU5OZvr06W53nZs0aRJLly7lo48+IioqyrXPKCYmhrCwMGJiYhg/fjwpKSk0btyY6Oho7rnnHnr37q3OdiIiItKgOJs2BAQEVFpC1LNnT/7xj3+wefNmX4UmUiMVV4bFxMRgsViqXC22YMECAI4dO2auIqlNmzb07t2bxYsXV7sm9MCBAyxdupQxY8bw2GOPMXHixAuOu2jRIgD69etX6fiSJUu47bbbAJg3bx4BAQGMGjWq0sVkRURERBqSiu2/Ky5T6tmzJwBbtmzBbreb/jo2UjecF1b1BrvdTmFhIYGBgW79foWHh9eLvUvn41aRlJaWRvv27c97n5YtWzJ16lQefPBBsrOz3Tq5s53g+YSGhrJw4UIWLlzo1pgiIiIi/si53K7iEiSAK664gtDQUE6dOsV3331Hu3btfBGemExRUdE5vyt1paCgoNKS0PrIrY8aLlQgVWS1Wrn00ktrHJCIiIiInKviTFJFVquVbt26AWjJnYiXeNzdrrp1gBaLhdDQUFq0aFFldzkRERERqTlnkVTVJ/Q9e/bkyy+/ZPPmzdx66611HZqYUHh4uOt3prbsdjt5eXlER0e7vdyuvvO4SOrcufN51xharVZGjx7N3//+d6/3aBcRERFpqKqbSYKz+5I0kyROFovFa0ve7HY75eXlRERENJg9bx7/K5cvX07r1q155ZVXyMzMJDMzk1deeYW2bduydOlSXnvtNT7//HOmTZtmRLwiIiIiDZI7RdKOHTtc11IS8Rc//PADmZmZ5ObmUlxc7KpBysrKDDunxzNJTz75JM8//zyDBg1yHbviiitITEzkL3/5C1u2bCEiIoIpU6bw7LPPejVYERERkYaqusYNAElJScTHx5Obm8vXX3/N7373u7oOT8QwEyZMYN26da7vu3TpAkBWVhaXXHKJIef0eCZp586dtGzZ8pzjLVu2ZOfOncCZJXkVLw4lIiIiIrVzvpkki8WiJXdSr912222cPHmyytvWrl2Lw+E458uoAglqUCS1a9eOOXPmVJrestlszJkzx9Vy8qeffiIuLs57UYqIiIg0cOdr3ADalyTiTR4vt1u4cCHDhg0jMTGRjh07Amdml8rLy1mxYgUA+/fv5+677/ZupCIiIiIN2PlmkkBFkog3eVwk9enTh6ysLN5++22+++47AG688UbGjh1LVFQUADfffLN3oxQRERFp4C5UJHXr1g2LxcKBAwfIzc0lPj6+LsMT8SseF0kAUVFR3Hnnnd6ORURERESqcb7GDQDR0dFcdtll7N69m82bNzN8+PC6DE/Er9So0fk///lPrrrqKhISEjhw4AAA8+bN46OPPvJqcCIiIiJyxoVmkkBL7kS8xeMiadGiRaSkpDB48GBOnDhBeXk5AI0aNWL+/Pnejk9EREREcK9I6tWrF6AiqSFzOBy+DsHn7HZ7rcfweLndCy+8wOLFixkxYgRz5sxxHe/WrRsPPvhgrQMSERERkXNdqLsdnJ1J2rp1K+Xl5QQGBtZJbOJ7VqsVi8XCsWPHaNq0KRaLxWtj2+12ysrKKCkpISCgRgvR6oTD4aCsrIxjx44REBBAcHBwjcfyuEjKyspyXcCpopCQENdaWRERERHxLndmkjp06EBERAT5+fns3buXDh061FV44mOBgYEkJiZy8OBBfvzxR6+O7XA4KC4uJiwszKvFl1HCw8Np0aJFrQo6j4ukVq1akZmZec4FZVetWkX79u1rHIiIiIiIVO9CjRvgzB/K3bp1Y926dWzevFlFUgMTGRlJ69atsdlsXh3XZrOxfv16+vbti9Vq9erY3hYYGEhQUFCtizmPi6SUlBQmTZpESUkJDoeDLVu28M477zB79mxeffXVWgUjIiIiIlVzZyYJziy5cxZJt99+e12EJiYSGBjo9WWWgYGBnD59mtDQUNMXSd7icZE0YcIEwsLCmDZtGkVFRYwdO5aEhASef/55xowZY0SMIiIiIg2eJ0USqHmDSG3U6DpJN910EzfddBNFRUUUFBTQrFkzb8clIiIiIv+nrKzMtYTqfI0b4GyRtHPnTgoLCy94fxE5V412Mx0/fpxt27bx7bffqmuKiIiIiMGcs0hw4SLp4osv5uKLL8Zut5ORkWF0aCJ+yaMiaffu3fTt25e4uDh69uxJjx49aNasGf3792ffvn1GxSgiIiLSoDmbNgQHB7vV1lhL7kRqx+0iKTc3l2uuuYZjx44xd+5cVq5cySeffMIzzzzD4cOHufrqqzl69KiRsYqIiIg0SO7uR3JSkSRSO24XSfPmzaNly5Zs376d++67j0GDBnHttdeSkpLC119/TVJSEvPmzTMyVhExmVdffZVbb72V/Px8X4ciIuLXalokbdq0ybCYRPyZ20VSeno6jzzyCKGhoefcFhYWxkMPPcRnn33m1eBExLyKi4u57777ePPNN/nzn//s63BERPyas0hytwlD165dCQgI4KeffuKnn34yMjQRv+R2kbR//36uvPLKam/v1q0b+/fv90pQImJ+n332GUVFRQC89NJLfPnllz6OSETEf3k6kxQZGckVV1wBaMmdSE24XSTl5+cTHR1d7e1RUVGVOq+IiH9btmwZcPYNe8KECZSUlPgyJBERv+VpkQTalyRSGx51t8vPzycvL6/aL4fDYVScImIiZWVl/Pvf/wbgnXfeoXnz5uzbt4+//vWvPo5MRMQ/ObvbqUgSqRtuF0kOh4M2bdrQqFGjKr/atm1rZJwiYiKff/45p06dIj4+niFDhrBw4UIAnn76ab755hsfRyci4n9qM5O0bds2ysvLDYlLxF8FuXvHNWvWGBmHiNQjzqV2I0aMICAggBtuuIFRo0axbNkyxo8fz6ZNmwgKcvvlRURELqAmRVK7du2IiooiPz+f3bt307FjR6PCE/E7bs8kXXPNNW59eWL9+vUMHTqUhIQELBYLH374YaXbHQ4H06dPp3nz5oSFhTFgwAC+//57j84hIt5VXl7ueq6OGjXKdfzFF18kNjaWjIwM5s+f75vgRET8lKfd7QACAwPp06cPAM8995whcYn4K7eKJOc6WHe5e//CwkI6derkWqrza08//TQLFizg5ZdfZvPmzURERDBo0CBtDhfxoS+++ILjx4/TuHHjSh+MxMfHu96Ep0+fzg8//OCrEEVE/E5NZpIAnnjiCSwWC2+++aYu1SLiAbeKpN/+9rfMmTOHw4cPV3sfh8NBeno6gwcPZsGCBW6dfPDgwcyaNYsbbrihyvHmz5/PtGnTGD58OB07duTNN9/k0KFD58w4iUjdcS61GzZsGFartdJt48aN43/+538oLi7mjjvuUDMXEREvqUnjBjizL+m+++4D4I477lAnYhE3ubVpYO3atTz66KM8/vjjdOrUiW7dupGQkEBoaCgnTpxgz549bNy4kaCgIKZOncqf/vSnWgeWlZVFbm4uAwYMcB2LiYmhZ8+ebNy4kTFjxlT5uNLSUkpLS13f5+XlAWCz2bDZbLWOqzac5/d1HKJc1JTdbmf58uUADB8+vMqf38KFC7nyyitZs2YNr7zyCrfffnu14ykP5qA8mIdyYQ5mzIPz75mwsDCP45oxYwYffvghP/74I1OnTmXu3LlGhGgIM+aiIfKnPLj7b3CrSGrbti3Lli0jOzub999/ny+++IINGzZQXFxMkyZN6NKlC4sXL2bw4MEEBgbWKnCn3NxcAOLi4iodj4uLc91WldmzZ/PEE0+cczwtLY3w8HCvxFZb6enpvg5B/o9y4Zl9+/bx008/ud6kV65cWeX9Ro8ezZIlS0hJSSE4OJjGjRufd1zlwRyUB/NQLszBTHn48ccfAfjvf/9b7Wvv+dx666088cQTLFy4kMTERNq1a+flCI1lplw0ZP6Qh6KiIrfu51H7qRYtWjBlyhSmTJlSo6DqwtSpU0lJSXF9n5eXR1JSEsnJyee9GG5dsNlspKenM3DgwHOWKUndUi5qZv369QAMHTqUESNGVHu/QYMGsXPnTrZt28ZHH33E+++/X+X9lAdzUB7MQ7kwBzPm4ZlnngGgd+/eDBkyxOPHDxkyhKysLN58803+8Y9/sGXLFkJCQrwdpteZMRcNkT/lwTkreyGm7dEbHx8PwJEjR2jevLnr+JEjR+jcuXO1jwsJCanySW+1Wk2TVDPF0tApF55Zt24dACNHjjzvz81qtfL6669z5ZVX8tFHH/Hdd9/RoUOH895fefA95cE8lAtzMFMenHuSYmNjaxzTvHnzWLVqFd9++y2rV69m+PDh3gzRUGbKRUPmD3lwN363W4DXtVatWhEfH8/q1atdx/Ly8ti8eTO9e/f2YWQiDVd2djaAW8s0rrjiCq699lrgbLMHERGpmZo2bqiocePGDB06FIBNmzZ5JS4Rf+XTIqmgoIDMzEwyMzOBM80aMjMzyc7OxmKxcP/99zNr1iw+/vhjdu7cyS233EJCQsJ5l/mIiDFKS0s5duwYAImJiW49ZuTIkQCkpqYaFpeISENQ0xbgv9azZ08ANm/eXOuYRPyZT5fbbdu2jd///veu7517iW699VbeeOMNHn74YQoLC7njjjs4efIkV111FatWrSI0NNRXIYs0WIcOHQLOLGm9UCMGp2HDhhEYGMg333zDf//7Xy699FIjQxQR8VveKpJ69eoFwNatWykvL/dawy0Rf+PTmaR+/frhcDjO+XrjjTcAsFgszJw5k9zcXEpKSvjPf/5DmzZtfBmySIP1008/AWdmkSwWi1uPueiii+jXrx+gJXciIjXlcDhcRVJEREStxrrsssuIjIykoKCAb7/91hvhifglj4ukvn37Mn36dFavXk1JSYkRMYmICR08eBCAiy++2KPHjRo1CtCSOxGRmiouLnZdnLu2M0mBgYF069YN0JI7kfPxuEhKTk5m06ZNDB8+nNjYWK666iqmTZtGenq6233HRaT+qTiT5IkRI0ZgsVjYvHmzq9ASERH3OZs2AF655qP2JYlcmMdF0rRp00hLS+PkyZOsWbOG66+/nm3btnHddde5vU9BROqfms4kNW/enD59+gCaTRIRqQnnUrvw8HCv7CFSkSRyYTXek7R//3527tzJN998w44dO4iKimLw4MHejE1ETKSmM0mgJXciIrXhraYNTs4iadeuXa6xRaQyj4uksWPHcvHFF9OnTx9WrVpFr169+PTTTzl+/DjLly83IkYRMYGaziTB2VbgX3zxBUePHvVqXCIi/s7bRVJCQgKJiYnY7XYyMjK8MqaIv/G4SHr33Xex2WxMmDCBO++8k4kTJ9KpUye3u12JSP1Um5mkli1b0rVrV+x2Ox999JG3QxMR8Wve6mxXkZbciZyfx0XSzz//zKuvvkpZWRlTp06lSZMm9OnTh0cffZS0tDQjYhQRHysvL3ddJ6kmM0lwdsmdWoGLiHjG2bjBWzNJcLZI2rRpk9fGFPEnHhdJjRo1YtiwYcydO5eMjAx27NhBmzZteOaZZ7QnScRPHT16lNOnTxMQEEB8fHyNxnAuuVu9ejW7d+/2ZngiIn7N28vtQDNJIhdSo5mk1NRU7r33Xjp27Ei7du1YsWIFQ4cOZe7cuUbEKCI+5lxqFx8fT1BQUI3GaNu2LUOHDuX06dNMmDCB8vJyb4YoIuK3jCiSunbtSmBgIIcOHdLlGUSq4HGR1KxZM+666y4OHTrExIkT2b59O8ePHyc1NZX77rvPiBhFxMecb6A12Y9U0UsvvURUVBSbNm1i4cKF3ghNRMTvGVEkRUREcPnllwOaTRKpisdF0o4dOzhy5AgffPAB99xzD1dccYURcYmIiThnkmq6H8kpMTGRp59+GoBHH32UAwcO1Do2ERF/Z0TjBoBevXoBKpJEquJxkdShQwcj4hARE/PWTBLAHXfcQd++fSksLGTSpEk4HI5ajyki4s+MaNwA2pckcj412lzwwQcf8K9//Yvs7GzKysoq3fb11197JTARMQ9vzSQBBAQEsHjxYjp27EhaWhrt27fnuuuuq/W4IiL+yojldnC2SNq2bRunT5+u8Z5TEX/k8UzSggULGDduHHFxcWzfvp0ePXpw0UUXsX//fnW3E/FT3pxJAmjTpg0zZswA4B//+Ad2u90r44qI+COjiqR27doRHR1NUVGRuo6K/IrHRdJLL73EK6+8wgsvvEBwcDAPP/ww6enp3HvvvZw6dcqIGEXEx7w5k+Q0ZcoUwsLCOHnyJPv27fPauCIi/saoIikgIIDu3bsDWnIn8mseF0nZ2dn06dMHgLCwMPLz8wG4+eabeeedd7wbnYj4nMPh8PpMEkBwcDBXXnklAFu3bvXauCIi/saoxg2gfUki1XG7SDp06BBw5jopv/zyCwAtWrRwXak5KytLG7BF/NCpU6coKioCvDuTBNCjRw8AtmzZ4tVxRUT8iVGNG0BFkkh13C6SLr/8ct5++2369+/Pxx9/DMC4ceN44IEHGDhwIKNHj+aGG24wLFAR8Q3nLFLjxo0JCwvz6tjOZR4qkkREqmfUcjs4WyTt2bOHvLw8r48vUl+5XSTNmjWLO++8kxMnTjB58mQAJk2axOuvv0779u2ZOXMmixYtMixQEfENI5baOTlnknbu3OmarRIRkcqMLJLi4uJo2bIlDodDS59FKnC7SLr77rvZsWMHJ06coEOHDvz73/8GYMyYMSxYsIB77rmH4OBgwwIVEd8wommDU1JSEo0aNaK8vFyXDxARqYaRRRJoyZ1IVTxq3NCqVSs+//xzpk2bxsiRI+nYsSNXXnllpS8R8S9GziRZLBbatGkD6M1ZRKQ6KpJE6p7HVw07cOAAqampNGrUiOHDh+vCYyJ+zsiZJDhzzaTNmzfrzVlEpArl5eUUFxcDxnS3g8pFksPhwGKxGHIekfrEowpn8eLFTJkyhQEDBrB7926aNm1qVFwiYhJGziQBmkkSETmPivs1jZpJuvLKKwkKCuLIkSNkZ2fTsmVLQ84jUp+4vdzu2muv5ZFHHuHFF18kNTVVBZJIA2H0TNJvf/tbLBYL2dnZ5ObmGnIOEZH6yrnULiAggNDQUEPOERYWRqdOnQB9YCXi5HaRVF5ezo4dO7jllluMjEdETMbomaSwsDAuu+wyQG/OIiK/VnE/kpHL4LQvSaQyt4uk9PR0w/5IEhFzKi4udl082qiZJDjbClxvziIilRndtMFJRZJIZR51txORhsW51C48PJzY2FjDzqMiSUSkas4iyaimDU7OIikjIwObzWbouUTqAxVJIlKtivuRjFzm0b17dwC2bt1KeXm5YecREalvCgsLAeNnklq3bk1sbCwlJSXs3LnT0HOJ1Af1okhauHAhl1xyCaGhofTs2ZMtW7b4OiSRBsHo/UhOHTp0ICIigvz8fL799ltDzyUiUp/U1XK7gIAAzeqLVGD6Ium9994jJSWFGTNm8PXXX9OpUycGDRrE0aNHfR2aiN9zFklG7kcCCAwMpFu3boDenEVEKqqrIgnOLrnbtGmT4ecSMTvTXwl27ty5TJw4kXHjxgHw8ssv88knn/D666/z5z//2cfRecbhcFT6Et9RLtzjXG5XF01bevbsybp169i8eTO333674eeTs/R8MA/lwhzMlIf8/Hygbosk50VlzcBMuWjIvJWH+nShYlMXSWVlZWRkZDB16lTXsYCAAAYMGMDGjRurfExpaSmlpaWu7/Py8gCw2Ww+34iYmJjIsWPHfBqDSE3Ex8cb8vxxjmmz2ejatStw5qLVixcv9vq5RETqs7CwMMP/junSpQsA+/btIyDA9IuNpJ5JTk5mxYoVvg7D7eeRqYuk48ePU15eTlxcXKXjcXFx7N27t8rHzJ49myeeeOKc42lpaYSHhxsSp7vKysp8en6RmggJCQFg5cqVhp0jPT0dm81Go0aNOHHihGHnERGpjwICAoiJiTH0ddipU6dOfPPNN4afRxqeY8eO1cnv8IUUFRW5dT9TF0k1MXXqVFJSUlzf5+XlkZSURHJyMtHR0T6MDHbs2MHatWu55pprsFqtPo2lobPZbKxbt065cENkZCRhYWGGjG2z2UhPT2fgwIFYrVZGjBjBqVOnDDmXVE/PB/NQLszBbHkICQmps79hBg8ezPHjx+vkXO4wWy4aKm/kwWq1Gno5EXc5V5ldiKmLpCZNmhAYGMiRI0cqHT9y5Ajx8fFVPiYkJMT1yXdFVqvV50+u5s2bExMTQ0JCgs9jaehsNptyYSLO56fVajX8WiByLj0fzEO5MIeGnoeEhARfh+DS0HNhFv6UB3fjN3WRFBwcTNeuXVm9ejUjRowAwG63s3r1aiZPnuzWGM7NZe5WjUay2WwUFRWRl5dX73/B6jvlwhyUB3NQHsxDuTAH5cE8lAtz8Kc8OGuCCzWgMHWRBJCSksKtt95Kt27d6NGjB/Pnz6ewsNDV7e5CnF1hkpKSjAxTRERERETqifz8fGJiYqq93fRF0ujRozl27BjTp08nNzeXzp07s2rVqnOaOVQnISGBnJwcoqKifN520Lk/Kicnx+f7oxo65cIclAdzUB7MQ7kwB+XBPJQLc/CnPDgcDvLz8y+4rNTiUNP5OpOXl0dMTAynTp2q979g9Z1yYQ7KgzkoD+ahXJiD8mAeyoU5NMQ8qAm+iIiIiIhIBSqSREREREREKlCRVIdCQkKYMWNGlS3KpW4pF+agPJiD8mAeyoU5KA/moVyYQ0PMg/YkiYiIiIiIVKCZJBERERERkQpUJImIiIiIiFSgIklERERERKQCFUkiIiIiIiIVqEgSERERERGpQEWSiIiIiIhIBSqSREREREREKlCRJCIiIiIiUoGKJBERERERkQpUJImIiIiIiFSgIklERERERKSCIF8HYDS73c6hQ4eIiorCYrH4OhwREREREfERh8NBfn4+CQkJBARUP1/k90XSoUOHSEpK8nUYIiIiIiJiEjk5OSQmJlZ7u98XSVFRUcCZH0R0dLRPY7HZbKSlpZGcnIzVavVpLA2dcmEOyoM5KA/moVyYg/JgHsqFOfhTHvLy8khKSnLVCNXx+yLJucQuOjraFEVSeHg40dHR9f4XrL5TLsxBeTAH5cE8lAtzUB7MQ7kwB3/Mw4W24ahxg4iIiIiISAUqkkRERERERCpQkSQiIiIiIlKB3+9JEhERERFpKOx2O2VlZV4d02azERQURElJCeXl5V4d29usViuBgYG1HsenRdLs2bNJTU1l7969hIWF0adPH5566inatm3ruk9JSQlTpkzh3XffpbS0lEGDBvHSSy8RFxfnw8hFRERERMylrKyMrKws7Ha7V8d1OBzEx8eTk5NTL647GhsbS3x8fK1i9WmRtG7dOiZNmkT37t05ffo0jz76KMnJyezZs4eIiAgAHnjgAT755BPef/99YmJimDx5MiNHjuSrr77yZegiIiIiIqbhcDg4fPgwgYGBJCUlnfdCqZ6y2+0UFBQQGRnp1XG9zeFwUFRUxNGjRwFo3rx5jcfyaZG0atWqSt+/8cYbNGvWjIyMDPr27cupU6d47bXXWLp0Kf379wdgyZIltG/fnk2bNtGrVy9fhC0iIiIiYiqnT5+mqKiIhIQEwsPDvTq2cwlfaGioqYskgLCwMACOHj1Ks2bNarz0zlT/ylOnTgHQuHFjADIyMrDZbAwYMMB1n3bt2tGiRQs2btzokxhFRERERMzGuVcoODjYx5H4nrNItNlsNR7DNI0b7HY7999/P7/73e+4/PLLAcjNzSU4OJjY2NhK942LiyM3N7fKcUpLSyktLXV9n5eXB5z5IdXmB+UNzvP7Og5RLsxCeTAH5cE8lAtzUB7MQ7lwn81mw+Fw4HA4DNmT5Pyvt8c2gvPnYLPZzplJcvd3yTRF0qRJk9i1axdffvllrcaZPXs2TzzxxDnH09LSvD71WFPp6em+DkH+j3JhDsqDOSgP5qFcmIPyYB7KxYUFBQURHx9PQUGB17vbOeXn5xsyrreVlZVRXFzM+vXrOX36dKXbioqK3BrDFEXS5MmTWbFiBevXrycxMdF1PD4+nrKyMk6ePFlpNunIkSPEx8dXOdbUqVNJSUlxfZ+Xl0dSUhLJyclER0cb9m9wh81mIz09nYEDB2K1Wn0aS0OnXJiD8mAOyoN5KBfmoDyYh3LhvpKSEnJycoiMjCQ0NNSrYzscDvLz84mKiqoX3e1KSkoICwujb9++5/wsnKvMLsSjIslut7Nu3Tq++OILDhw4QFFREU2bNqVLly4MGDCApKQkT4bD4XBwzz33sHz5ctauXUurVq0q3d61a1esViurV69m1KhRAOzbt4/s7Gx69+5d5ZghISGEhIScc9xqtZrmyWWmWBo65cIclAdzUB7MQ7kwB+XBPJSLCysvL8disRAQEOD15grOJXbO8b3lQgXXjBkzuOGGG5gzZw5ffvklx48f55JLLuHOO+/kvvvuq/ZxAQEBWCyWKn9v3P09cqtIKi4u5rnnnmPRokX88ssvdO7cmYSEBMLCwvjhhx/48MMPmThxIsnJyUyfPt3trnOTJk1i6dKlfPTRR0RFRbn2GcXExBAWFkZMTAzjx48nJSWFxo0bEx0dzT333EPv3r3V2U5EREQanBMnTrB8+XJuvPFGoqKifB2OSK0cPnzY9f/vvfce06dPZ9++fa5jkZGR/Otf/6JZs2a89dZbJCUlsWHDBu644w4CAwOZPHmyYbG5VSS1adOG3r17s3jx4mqnOw8cOMDSpUsZM2YMjz32GBMnTrzguIsWLQKgX79+lY4vWbKE2267DYB58+YREBDAqFGjKl1MVkRERKShWbBgAY8//jjLly/n448/rhdLn0SqU3H7TExMDBaL5ZwtNbfffnul73/zm9+wceNGUlNTfV8kpaWl0b59+/Pep2XLlkydOpUHH3yQ7Oxst07u7JRxPqGhoSxcuJCFCxe6NaaIiIiIvzp48CAAK1as4L333mPMmDE+jkjMynlhVW+w2+0UFhYSGBjo1nK78PBwQwv4U6dOuS4ZZBS3iqQLFUgVWa1WLr300hoHJCIiIiJVq7jp/N5772XgwIFcdNFFPoxIzKqoqIjIyEifnLugoICIiAhDxt6wYQPvvfcen3zyiSHjO3nc3W7Hjh1VHrdYLISGhtKiRYsqGyeIiIiISO04i6SAgACOHTvGAw88wJtvvunjqETqxq5duxg+fDgzZswgOTnZ0HN5XCR17tz5vNNnVquV0aNH8/e//93r7QdFREREGjJnkfTggw/yzDPP8M9//pOxY8dy7bXX+jgyMZvw8HAKCgq8MpbdbicvL4/o6Gi3l9t52549e/if//kf7rjjDqZNm+b18X/N4yJp+fLlPPLIIzz00EP06NEDgC1btvDcc88xY8YMTp8+zZ///GemTZvGs88+6/WARURERBoqZ5E0cOBAysrKmD9/Pn/605/YtWuXut1JJRaLxWtL3ux2O+Xl5URERHi9vbg7du/eTf/+/bn11lt58skn6+ScHhdJTz75JM8//zyDBg1yHbviiitITEzkL3/5C1u2bCEiIoIpU6aoSBIRERHxovz8fACioqKYNWsWH374IT/++COPPfYYCxYs8HF0It63a9cu+vfvz6BBg0hJSXFdMigwMJCmTZsadl6PS8GdO3fSsmXLc463bNmSnTt3AmeW5FXsey4iIiIiteecSYqOjiYiIoLFixcD8OKLL7Jx40ZfhiZiiA8++IBjx47x1ltv0bx5c9dX9+7dDT2vx0VSu3btmDNnDmVlZa5jNpuNOXPm0K5dOwB++ukn4uLivBeliIiISAPncDgqFUkAAwYM4LbbbsPhcDB+/HhKS0t9GaJIjd12222cPHnynOOPP/44DofjnK8ff/zR0Hg8LpIWLlzIihUrSExMZMCAAQwYMIDExERWrFjhujjs/v37ufvuu70erIiIiEhDVVxcTHl5OXC2SAJ47rnniIuL49tvv+Vvf/ubr8IT8Sse70nq06cPWVlZvP3223z33XcA3HjjjYwdO9a1YfDmm2/2bpQiIiIiDZxzPxJQaUN+48aNefHFF7nxxhv529/+xv/7f/+PK664whchivgNj4skOLNZ8M477/R2LCJicvn5+Xz55ZeuTzIBEhMT6dy5s++CEhFpIJxL7aKios7pMDZq1ChGjBjBhx9+yIQJE9iwYQOBgYG+CFPEL9Soh98///lPrrrqKhISEjhw4AAA8+bN46OPPvJqcCJiLjfffDNDhgxh6NChrq8rr7yS9PR0X4cmIuL3fr0fqSKLxcLChQuJiYlhy5Yt/Otf/6rr8ET8isdF0qJFi0hJSWHw4MGcOHHC9Ylyo0aNmD9/vrfjExET2bt3LwDt27ene/fuXHrppTgcDu644w4KCwt9HJ2IiH87X5EEkJCQwIQJEwBYt25dncUl5uJwOHwdgs9542fgcZH0wgsvsHjxYh577DGCgs6u1uvWrZurBbiI+KcTJ04A8O6777Jlyxa2b99OixYt+PHHH+vk6tciIg2Zc09SdUUSQK9evQDYvHlzncQk5uFcXlmxA3VDVVRUBIDVaq3xGB7vScrKyqJLly7nHA8JCdEnySJ+zOFwuFpzNmrUCDizLv7vf/87gwcP5vnnn2fMmDH07NnTh1GKiPivinuSquN8Dd65cydFRUWEh4fXSWzie0FBQYSHh3Ps2DGsVus5+9Zqw263U1ZWRklJiVfH9TaHw0FRURFHjx4lNja2VvvyPC6SWrVqRWZm5jkXlF21ahXt27evcSAiYm7FxcWuT6diY2Ndx6+99lr+93//l7feeosJEyaQkZFBcHCwj6IUEfFfF1puB2ea6TRv3pzDhw+TkZHB1VdfXVfhiY9ZLBaaN29OVlaWq2eAtzgcDoqLiwkLC8NisXh1bCPExsYSHx9fqzE8LpJSUlKYNGkSJSUlOBwOtmzZwjvvvMPs2bN59dVXaxWMiJiXcxYpMDCQyMjISrfNmzePzz77jF27djFnzhymT5/ugwhFRPybO0WSxWKhZ8+efPjhh2zevFlFUgMTHBxM69atvb7kzmazsX79evr27VurJWx1wWq1eqWzo8dF0oQJEwgLC2PatGkUFRUxduxYEhISXEttRMQ/OfcjxcbGnvMpUpMmTViwYAF//OMfmTVrFuPHj+fiiy/2RZgiIn7LnSIJzuxLchZJ0vAEBAQQGhrq1TEDAwM5ffo0oaGhpi+SvKVGiwpvuukmvv/+ewoKCsjNzeXgwYOMHz/e27GJiIk4iyTnfqRfGz16NL169cJms7Fs2bK6DE1EpEFwNm44354kOLsvSUWSSM3VqEg6fvw427Zt49tvv9WFykQaCOdyu4r7kSqyWCz84Q9/ACA1NbWOohIRaTjcnUnq1q0bAQEB5OTkcPjw4boITcTveFQk7d69m759+xIXF0fPnj3p0aMHzZo1o3///uzbt8+oGEXEBC40kwQwcuRIAL744guOHj1aJ3GJiDQU7hZJkZGRdOjQAdBskkhNuV0k5ebmcs0113Ds2DHmzp3LypUr+eSTT3jmmWc4fPgwV199tf4oEvFjF5pJAmjZsiVdu3bFbrfz0Ucf1U1gIiINhLtFEmjJnUhtuV0kzZs3j5YtW7J9+3buu+8+Bg0axLXXXktKSgpff/01SUlJzJs3z8hYRcSH3JlJAhg1ahSA9iWJiHiZOxeTdVKRJFI7bhdJ6enpPPLII1V2ywgLC+Ohhx7is88+82pwImIe7swkwdkld6tXr3YVViIiUnvuXEzWyVkkbd26lfLyckPjEvFHbhdJ+/fv58orr6z29m7durF//36vBCUi5uPuTFLbtm3p0KEDp0+fZsWKFXURmohIg+DJcrvLLruMyMhICgoK+Pbbb40OTcTvuF0k5efnn/dJGRUVRUFBgVeCEhHzcXcmCbTkTkTECJ4USYGBgXTr1g3QkjuRmvCou11+fj55eXnVfjkcDqPiFBEfc3cmCc4uufvss8/04YmIiBeUl5dTWFgIuFckgfYlidRGkLt3dDgctGnT5ry3WywWrwQlIubjyUxSx44dufTSS/nvf//Lp59+yo033mhscCIifq7iB06eFkmbNm0yJCYRf+Z2kbRmzRoj4xARk/NkJslisTBq1Ciefvppli1bpiJJRKSWnEvtrFYrISEhbj3GWSTt3r2bgoICIiMjDYtPxN+4vdzummuucevLE+vXr2fo0KEkJCRgsVj48MMPK93ucDiYPn06zZs3JywsjAEDBvD99997dA4R8Q5PZpLg7JK7Tz75hJKSEoOiEhFpGDzZj+SUkJBAYmIidrudr776yqjQRPySW0WScw2su9y9f2FhIZ06dWLhwoVV3v7000+zYMECXn75ZTZv3kxERASDBg3SH1widay8vNz1Bu3OTBJA9+7dSUxMpKCggPT0dCPDExHxezUpkgCGDBkCwMMPP4zNZvN6XCL+yq0i6be//S1z5szh8OHD1d7H4XCQnp7O4MGDWbBggVsnHzx4MLNmzeKGG26ocrz58+czbdo0hg8fTseOHXnzzTc5dOjQOTNOImKsU6dOuf7f3ZmkgIAA13NbXe5ERGrHkwvJVjRr1iwuuugiduzYwdNPP21EaCJ+ya0iae3atWzdupVWrVrRs2dPJk2axJNPPslzzz3HtGnTGDlyJAkJCdx+++0MHTqUhx9+uNaBZWVlkZuby4ABA1zHYmJi6NmzJxs3bqz1+CLiPud+pIiICKxWq9uPc7YC//jjj/UJpohILXhyIdmKmjZtyvPPPw/AzJkzdc0kETe51bihbdu2LFu2jOzsbN5//32++OILNmzYQHFxMU2aNKFLly4sXryYwYMHExgY6JXAcnNzAYiLi6t0PC4uznVbVUpLSyktLXV973xRsdlsPv8jzXl+X8chyoWnjh07BpyZRfLkZ9azZ0+aNm3KsWPH+M9//lPpQw9QHsxCeTAP5cIczJgH54dVUVFRHsd144038tZbb7Fq1SomTJjA559/TkCAR1eB8Rkz5qIh8qc8uPtvcLu7HUCLFi2YMmUKU6ZMqVFQdWH27Nk88cQT5xxPS0sjPDzcBxGdS/szzEO5cM8333wDnLk44cqVKz16bOfOnUlPT+f555+nrKysyvsoD+agPJiHcmEOZsqDs413QUGBx6/DcGZmf+3atWzYsIF7773XtVepvjBTLhoyf8hDUVGRW/fzqEiqS/Hx8QAcOXKE5s2bu44fOXKEzp07V/u4qVOnkpKS4vo+Ly+PpKQkkpOTPV7H6202m4309HQGDhzo0ZIl8T7lwjPOF5SkpCSP31iDgoJIT08nMzOTQYMGVZptVh7MQXkwD+XCHMyYh+3btwNnVvfUtMApKirivvvuY+nSpTz22GOV/r4yKzPmoiHypzw4V5ldiGmLpFatWhEfH8/q1atdRVFeXh6bN2/mrrvuqvZxISEhVV4/wGq1miapZoqloVMu3OO8iGHjxo09/nkNHDiQ2NhYjhw5wtatW7n66qvPuY/yYA7Kg3koF+Zgpjw4OwfHxsbWOKbJkyezZMkSMjMzWb16NePGjfNmiIYyUy4aMn/Ig7vx+3RBakFBAZmZmWRmZgJnmjVkZmaSnZ2NxWLh/vvvZ9asWXz88cfs3LmTW265hYSEBEaMGOHLsEUaHOdaeHc721UUHBzM0KFDAUhNTfVmWCIiDUZNGzdUFBAQwMCBAwHYvHmzV+IS8Vc+LZK2bdtGly5d6NKlCwApKSl06dKF6dOnA2d6+t9zzz3ccccddO/enYKCAlatWkVoaKgvwxZpcJwXknX3Gkm/5uxyl5qaisPh8FZYIiINRk2vk/RrPXv2BFQkiVyIT5fb9evX77x/MFksFmbOnMnMmTPrMCoR+bXazCQBJCcnExERQXZ2Ntu2baN79+5ejE5ExP/V9DpJv+Ysknbu3ElRUZFpmlqJmI3HM0l9+/Zl+vTprF69mpKSEiNiEhGTqe1MUlhYmGujsZbciYh4zlszSYmJiSQkJFBeXk5GRoY3QhPxSx4XScnJyWzatInhw4cTGxvLVVddxbRp00hPT3e7pZ6I1C+1nUmCs0vuli1bpiV3IiIe8saeJCctuRO5MI+LpGnTppGWlsbJkydZs2YN119/Pdu2beO6666jcePGRsQoIj5W25kkgCFDhhASEsL333/Prl27vBSZiEjD4K2ZJDhbJDmvvSQi56px44b9+/ezc+dOvvnmG3bs2EFUVBSDBw/2ZmwiYhLemEmKiooiOTkZ0JI7ERFPGVEkaSZJpHoeF0ljx47l4osvpk+fPqxatYpevXrx6aefcvz4cZYvX25EjCLiY96YSQIYOXIkcGbJnYiIuM9bjRsAunXrRkBAAAcPHuTQoUO1Hk/EH3lcJL377rvYbDYmTJjAnXfeycSJE+nUqRMWi8WI+ETExxwOh2smqbZF0rBhwwgKCmLnzp18//333ghPRMTvlZaWUlZWBninSIqMjKRDhw6AZpNEquNxkfTzzz/z6quvUlZWxtSpU2nSpAl9+vTh0UcfJS0tzYgYRcSHiouLsdlsQO2W2wE0btyY3//+94CW3ImIuMu51A7OFDje0KtXL0BFkkh1PC6SGjVqxLBhw5g7dy4ZGRns2LGDNm3a8Mwzz2hPkogfcs4iBQYGeuXNWUvuREQ84yySIiIiCAwM9MqY2pckcn4eX0z2559/Zt26daxdu5a1a9eyZ88eYmNjGTp0KNdcc40RMYqID1Vs2uCNZbUjRozg7rvvZuvWrWRnZ9d6PBERf+fN/UhOziJp27ZtlJeXe634EvEXHhdJzZo1o0mTJlx99dVMnDiRfv36ccUVVxgRm4iYgLeaNjjFx8dz1VVX8cUXX/DRRx9x6aWXemVcERF/5c3Odk7t27cnMjKSgoIC9uzZo7/lRH7F4+V2O3bs4MiRI3zwwQfcc889elKJ+DlvtP/+NeeSO3XEFBG5MG9eSNYpMDCQ7t27A1pyJ1IVj4skZzcUEWkYvD2TBGeLpK+++so1voiIVM2ImSTQviSR8/F4uR3ABx98wL/+9S+ys7NdLSmdvv76a68EJiLmYMRMUosWLejWrRvbtm1j8+bNjB071mtji4j4GxVJInXP45mkBQsWMG7cOOLi4ti+fTs9evTgoosuYv/+/epuJ+KHjJhJAhg1ahQAGzdu9Oq4IiL+xojGDXC2SNq9e7frHCJyhsdF0ksvvcQrr7zCCy+8QHBwMA8//DDp6ence++9nDp1yogYRcSHjJhJgrNL7nbu3ElxcbFXxxYR8SdGzSQ1b96cpKQk7HY727Zt8+rYIvWdx0VSdnY2ffr0ASAsLMz1ycPNN9/MO++8493oRMTnjJpJat26Nc2aNaO8vJzMzEyvji0i4k+MaNzgpCV3IlVzu0g6dOgQcKZ97y+//AKc2VewadMmALKysnA4HAaEKCK+ZNRMksVicXVW2rJli1fHFhHxJ0bNJIGKJJHquF0kXX755bz99tv079+fjz/+GIBx48bxwAMPMHDgQEaPHs0NN9xgWKAi4htGzSQB9OjRA1CRJCJyPkbtSYLKRZI+7BY5y+3udrNmzeLOO+8kOTmZp556CoBJkyZx0UUXsWHDBoYNG8af/vQnwwIVEd8waiYJzhZJW7du9frYIiL+wsiZpK5duxIYGMjhw4c5ePAgSUlJXj+HSH3k9kzS3XffzY4dOzhx4gQdOnTg3//+NwBjxoxhwYIF3HPPPQQHBxsWqIj4hpEzSd26dcNisfDjjz9y9OhRr48vIuIPjNyTFB4eTseOHQEtuROpyKPGDa1ateLzzz9n2rRpjBw5ko4dO3LllVdW+hIR/2LkTFJMTAyJiYmA3pxFRKpj5EwSaF+SSFU8vpjsgQMHSE1NpVGjRgwfPpygoBpdj1ZE6oHTp0+71sIbMZME0KZNG3Jycti8eTNDhw415BwiIvWZkXuS4EyR9PLLL6tIEqnAowpn8eLFTJkyhQEDBrB7926aNm1qVFwiYgIVr31mxEwSnCmSVq9erTdnEZFq1NVMUkZGBqdPn9YH4CJ4UCRde+21bNmyhRdffJFbbrnFyJhExCScS+0iIiKwWq2GnKN169bAmQ53drudgACPL98mIuK37Ha74TNJbdu2JSYmhlOnTrFr1y46d+5syHlE6hO3/xopLy9nx44dKpBEGhBn0wajZpEAWrZsSXh4OHl5eezdu9ew84iI1EeFhYWu1txGNG4ACAgIcF23TrP6Ime4XSSlp6e7NliLSMPgnEkyaj8SQGBgoKvpi96cRUQqcy61CwwMJCwszLDzOJfcbdq0ybBziNQnWtciItWqi5kkOHu9JBVJIiKVVVxqZ7FYDDuPOtyJVKYiSUSqVRczSYCWeYiIVMPopg1OziJp7969lZr2iDRUKpJEpFp1PZO0c+dOioqKDD2XiEh9YuSFZCtq1qwZl1xyCQ6Hg61btxp6LpH6oF4USQsXLuSSSy4hNDSUnj17smXLFl+HJNIg1NVMUmJiIs2bN6e8vJyMjAxDzyUiUp/U1UwSaMmdSEWmL5Lee+89UlJSmDFjBl9//TWdOnVi0KBBHD161Nehifi9uppJslgs9OrVC9Cbs4hIRUa3/65Ir8MiZ5n+amFz585l4sSJjBs3DoCXX36ZTz75hNdff50///nPPo7OMytXrmTjxo2UlpbqQm0+dvr0ab7++mvl4gJ2794NGD+TBGc+wVy+fDn//ve/+c1vfmP4+eQsPR/MQ7kwBzPl4csvvwTqdiZp48aNpKamGn4+d5gpFw2ZN/IQFxfH7373Oy9HZhxT/7aVlZWRkZHB1KlTXccCAgIYMGAAGzdurPIxpaWllJaWur53TlPbbDZsNpuxAV/AxIkTOXbsmE9jEKmJ6OhoQ54/zjFtNhtdu3YFYP369axfv97r5xIRqc+Meh2u6PLLL8dqtXL8+HFGjRpl6Lmk4UlOTmbFihW+DsPt55Gpi6Tjx49TXl5OXFxcpeNxcXHVXnRy9uzZPPHEE+ccT0tLIzw83JA43dWyZUuaNGni0xhEPBUbG0twcDArV6407Bzp6emUl5czcOBADh48aNh5RETqo+DgYNq1a2fo67DTLbfcwoYNGww/jzQ8oaGhdfI7fCHuNoiyOJyXcTahQ4cOcfHFF7NhwwZ69+7tOv7www+zbt26KtfMVjWTlJSUxPHjx+tkqvp8bDYb6enpDBw4EKvV6tNYGjrlwhyUB3NQHsxDuTAH5cE8lAtz8Kc85OXl0aRJE06dOnXe2sDUM0lNmjQhMDCQI0eOVDp+5MgR4uPjq3xMSEgIISEh5xy3Wq2mSaqZYmnolAtzUB7MQXkwD+XCHJQH81AuzMEf8uBu/KYukoKDg+natSurV69mxIgRANjtdlavXs3kyZPdGsM5Uebcm+RLNpuNoqIi8vLy6v0vWH2nXJiD8mAOyoN5KBfmoDyYh3JhDv6UB2dNcKHFdKYukgBSUlK49dZb6datGz169GD+/PkUFha6ut1diLN1ZlJSkpFhioiIiIhIPZGfn09MTEy1t5u+SBo9ejTHjh1j+vTp5Obm0rlzZ1atWnVOM4fqJCQkkJOTQ1RUFBaLxeBoz8+5PyonJ8fn+6MaOuXCHJQHc1AezEO5MAflwTyUC3Pwpzw4HA7y8/NJSEg47/1M3bjB3+Tl5RETE3PBjWJiPOXCHJQHc1AezEO5MAflwTyUC3NoiHkI8HUAIiIiIiIiZqIiSUREREREpAIVSXUoJCSEGTNmVNmiXOqWcmEOyoM5KA/moVyYg/JgHsqFOTTEPGhPkoiIiIiISAWaSRIREREREalARZKIiIiIiEgFKpJEREREREQqUJEkIiIiIiJSgYokERERERGRClQkiYiIiIiIVKAiSUREREREpAIVSSIiIiIiIhWoSBIREREREalARZKIiIiIiEgFKpJEREREREQqCPJ1AEaz2+0cOnSIqKgoLBaLr8MREREREREfcTgc5Ofnk5CQQEBA9fNFfl8kHTp0iKSkJF+HISIiIiIiJpGTk0NiYmK1t/t9kRQVFQWc+UFER0f7NBabzUZaWhrJyclYrVafxtLQKRfmoDyYg/JgHsqFOSgP5qFcmIM/5SEvL4+kpCRXjVAdvy+SnEvsoqOjTVEkhYeHEx0dXe9/weo75cIclAdzUB7MQ7kwB+XBPJQLc/DHPFxoG44aN4iIiIiIiFSgIklERERERKQCFUkiIiIiIiIV+P2eJBERERGRhqK8vBybzebVMW02G0FBQZSUlFBeXu7Vsb0tMDCQoKCgWl/6x6dF0uzZs0lNTWXv3r2EhYXRp08fnnrqKdq2beu6T0lJCVOmTOHdd9+ltLSUQYMG8dJLLxEXF+fDyEVEREREzKWgoICDBw/icDi8Oq7D4SA+Pp6cnJx6cd3R8PBwmjdvTnBwcI3H8GmRtG7dOiZNmkT37t05ffo0jz76KMnJyezZs4eIiAgAHnjgAT755BPef/99YmJimDx5MiNHjuSrr77yZegiIiIiIqZRXl7OwYMHCQ8Pp2nTpl4tZux2OwUFBURGRp73Aqy+5nA4KCsr49ixY2RlZdG6desax+vTImnVqlWVvn/jjTdo1qwZGRkZ9O3bl1OnTvHaa6+xdOlS+vfvD8CSJUto3749mzZtolevXr4IW0RERETEVGw2Gw6Hg6ZNmxIWFubVse12O2VlZYSGhpq6SAIICwvDarVy4MABV8w1Yao9SadOnQKgcePGAGRkZGCz2RgwYIDrPu3ataNFixZs3LixyiKptLSU0tJS1/d5eXnAmV8cb6/P9JTz/L6OQ5QLs1AezEF5MA/lwhyUB/NQLtznLJIcDgd2u92rYzuX7xkxtlEcDgc2m43AwMBKx939XbI4vL1osYbsdjvDhg3j5MmTfPnllwAsXbqUcePGVSp6AHr06MHvf/97nnrqqXPGefzxx3niiSfOOb506VLCw8ONCV5ERERExIeCgoKIj48nKSmpVntx/EFZWRk5OTnk5uZy+vTpSrcVFRUxduxYTp06RXR0dLVjmGYmadKkSezatctVINXU1KlTSUlJcX2fl5dHUlISycnJ5/1B1AWbzUZ6ejoDBw70m6sV11fKhTkoD+agPJiHcmEOyoN5KBfuKykpIScnh8jIyBovMauOw+EgPz+fqKioetG4oaSkhLCwMPr27XvOz8K5yuxCTFEkTZ48mRUrVrB+/XoSExNdx+Pj4ykrK+PkyZPExsa6jh85coT4+PgqxwoJCSEkJOSc41ar1TRPLjPF0tApF+agPJiD8mAeyoU5KA/moVxcWHl5ORaLhYCAAK/vG3IusXOOb3YBAQFYLJYqf2/c/T3y6F9pt9tZs2YNM2fOZPz48fzxj3/k3nvvZcmSJeTk5HgyFHCmKp08eTLLly/n888/p1WrVpVu79q1K1arldWrV7uO7du3j+zsbHr37u3x+URERERExBwsFst5vx5//HF+/vlnrr32WhISEggJCSEpKYnJkye7PSNUU27NJBUXF/Pcc8+xaNEifvnlFzp37kxCQgJhYWH88MMPfPjhh0ycOJHk5GSmT5/udte5SZMmsXTpUj766COioqLIzc0FICYmhrCwMGJiYhg/fjwpKSk0btyY6Oho7rnnHnr37q3OdiIiIiIi9djhw4dd///ee+8xffp09u3b5zoWGRmJzWZj+PDhzJo1i6ZNm/LDDz8wadIkfvnlF5YuXWpYbG4VSW3atKF3794sXry42jWhBw4cYOnSpYwZM4bHHnuMiRMnXnDcRYsWAdCvX79Kx5csWcJtt90GwLx58wgICGDUqFGVLiYrIiIiIiJVczgcFBUVeWUsu91OYWEhgYGBbi23Cw8Pd2vvUsXtMzExMVgsliq31Nx1112u/2/ZsiV33303zzzzjJvR14xbRVJaWhrt27c/731atmzJ1KlTefDBB8nOznbr5O401gsNDWXhwoUsXLjQrTFFRERERBq6oqIiIiMjfXLugoICIiIiDBn70KFDpKamcs011xgyvpNbe5IuVCBVZLVaufTSS2sckIiIiIiISEV//OMfCQ8P5+KLLyY6OppXX33V0PN53N1ux44dVR63WCyEhobSokWLKrvLiYiIiIhI3QgPD6egoMArY9ntdvLy8oiOjnZ7uZ23zZs3jxkzZvDdd9+5Lvlj5BYcj4ukzp07n3eNodVqZfTo0fz973/3eo92ERERERG5MIvF4rUlb3a7nfLyciIiInzWAjw+Pp74+HjatWtH48aNufrqq/nLX/5C8+bNDTmfx0XS8uXLeeSRR3jooYfo0aMHAFu2bOG5555jxowZnD59mj//+c9MmzaNZ5991usBi4jvfPrpp7z00kuUl5e7jl1yySXMnz+/wV/dW0SkLnz33XdMmzat0gxBVFQUzzzzDC1atPBhZCJ1x3ndptLSUsPO4XGR9OSTT/L8888zaNAg17ErrriCxMRE/vKXv7BlyxYiIiKYMmWKiiQRPzNjxgy2bt16zvFrrrmG0aNH+yAiEZGG5ZVXXuH9998/53jTpk158cUXfRCRiLFWrlzJkSNH6N69O5GRkezevZuHHnqI3/3ud1xyySWGndfj+bKdO3fSsmXLc463bNmSnTt3AmeW5FXsey4i/uHnn38GYNq0aSxZsoRRo0YBkJqa6suwREQaDOfr8B/+8AeWLFnC1KlTgTMrfZyfrov4k7CwMBYvXsxVV11F+/bteeCBBxg2bBgrVqww9LwezyS1a9eOOXPm8Morr7iW19hsNubMmUO7du0A+Omnn4iLi/NupCLic6dOnQJgzJgxdOjQgcsuu4xly5bxySefUFJSon2IIiIGc74O//73v+e2226jtLSUF198kUOHDrFlyxZ69erl4whFaua2225zXSe1ot///vds2LChzuPxeCZp4cKFrFixgsTERAYMGMCAAQNITExkxYoVrovD7t+/n7vvvtvrwYqI7zgcDk6ePAmcueAbQPfu3UlMTKSwsJC0tDQfRici0jD8+nU4JCSE66+/HoBly5b5KiwRv+NxkdSnTx+ysrKYOXMmHTt2pGPHjsycOZOsrCzXpxc333wzDz30kNeDFRHfKSoqcjVscL45WywWRo4cCejNWUSkLjhnkpyvw0Cl12GHw+GTuET8jcfL7eBMF5U777zT27GIiIk535gDAgIqXcF71KhRLFiwgI8//hibzYbVavVViCIifq+qImnw4MGEhYWRlZXFN998Q+fOnX0UnYj/qFGj83/+859cddVVJCQkcODAAeDMBZ4++ugjrwYnIubhfGOOjo6udK203/3udzRr1oyTJ0+yZs0aX4UnItIgVFUkRUREcO211wKa1RfxFo+LpEWLFpGSksLgwYM5ceKEa/lNo0aNmD9/vrfjExGTqOqNGSAwMJARI0YA6nInImIkh8NR7Wuxlj6Lk5Zceudn4HGR9MILL7B48WIee+wxgoLOrtbr1q2bqwW4iPif6t6YAVcr8OXLl1e60KyIiHhPSUkJNpsNOPe1+Prrr8dqtfLtt9/y7bff+iI88bHAwEAAysrKfByJ7xUVFQHUaguAx3uSsrKy6NKlyznHQ0JCKCwsrHEgImJu5yuS+vXrR2xsLEePHuWrr76ib9++dR2eiIjfc74OWyyWSntDAWJjYxkwYACffvopqampPPbYY74IUXwoKCiI8PBwjh07htVqJSCgRrtqqmS32ykrK6OkpMSr43qbw+GgqKiIo0ePEhsb6yoca8LjIqlVq1ZkZmaec0HZVatW0b59+xoHIiLmdr4iKTg4mGHDhvHmm2+SmpqqIklExAAV94ZW9YfqyJEj+fTTT1m2bJmKpAbIYrHQvHlzsrKyXD0DvMXhcFBcXExYWFilfclmFRsbS3x8fK3G8LhISklJYdKkSZSUlOBwONiyZQvvvPMOs2fP5tVXX61VMCJiXucrkuDMkjtnkTRv3rx68SIqIlKfXOh1ePjw4fzpT39i+/btZGVl0apVq7oMT0wgODiY1q1be33Jnc1mY/369fTt29f0XWytVmutZpCcPC6SJkyYQFhYGNOmTaOoqIixY8eSkJDA888/z5gxY2odkIiY04XenAcOHEhERAQ5OTls3bqVHj161GV4IiJ+70Kvw02bNqVv376sXbuW1NRUpkyZUpfhiUkEBAQQGhrq1TEDAwM5ffo0oaGhpi+SvKVGiwpvuukmvv/+ewoKCsjNzeXgwYOMHz/e27GJiIlc6M05LCyM6667DlCXOxERI1zodRjONtLR67BI7dSoSDp+/Djbtm3j22+/9cp0loiYnztvzrrqu4iIcdx5Hb7hhhsA2LBhA4cOHaqTuET8kUdF0u7du+nbty9xcXH07NmTHj160KxZM/r378++ffuMilFETMCdN+chQ4YQEhLCDz/8wK5du+oqNBGRBsGd1+GLL76YXr16AWcuyyAiNeN2kZSbm8s111zDsWPHmDt3LitXruSTTz7hmWee4fDhw1x99dUcPXrUyFhFxIfceXOOiopi0KBBgC5oKCLibe68DoOW3Il4g9tF0rx582jZsiXbt2/nvvvuY9CgQVx77bWkpKTw9ddfk5SUxLx584yMVUR8yN03Z131XUTEGJ6+Dq9bt47jx48bHpeIP3K7SEpPT+eRRx6psltGWFgYDz30EJ999plXgxMR83D3zXnYsGEEBQWxa9cuvvvuu7oITUSkQXD3dfg3v/kNnTt3pry8nI8++qguQhPxO24XSfv37+fKK6+s9vZu3bqxf/9+rwQlIubj7ptzo0aN6N+/P6ClHiIi3uTu6zBoyZ1IbbldJOXn5xMdHV3t7VFRURQUFHglKBExF4fD4dGbs3Oph96cRUS8pyZFUnp6uutxIuI+j7rb5efnk5eXV+2XWv6K+Kfi4mJOnz4NuPfmPGLECCwWC1u3biU7O9vo8EREGgRPiqT27dvTrl07bDYbn3zyidGhifgdt4skh8NBmzZtaNSoUZVfbdu2NTJOEfEh5xuzxWIhMjLygvePi4vjqquuAjSbJCLiLZ4USXB2NkmNdEQ8F+TuHdesWWNkHCJiYs435ujoaAIC3PtsZdSoUXzxxRekpqZy//33GxidiEjD4GmRNHLkSJ588kk+/fRTCgsLiYiIMDI8Eb/i9kzSNddc49aXJ9avX8/QoUNJSEjAYrHw4YcfVrrd4XAwffp0mjdvTlhYGAMGDOD777/36BwiUnuevjHD2X1JX375Jbm5uYbEJSLSkHj6WtylSxcuueQSiouL1YFYxENuFUmFhYUeDeru/QsLC+nUqRMLFy6s8vann36aBQsW8PLLL7N582YiIiIYNGgQJSUlHsUjIrVTkyIpKSmJ7t2743A41IJWRKSWSkpKKCsrA9x/LbZYLFpyJ1JDbhVJv/3tb5kzZw6HDx+u9j4Oh4P09HQGDx7MggUL3Dr54MGDmTVrFjfccEOV482fP59p06YxfPhwOnbsyJtvvsmhQ4fOmXESEWM5i6TY2FiPHqc3ZxER76i4NzQqKsrtxzln9VesWEFpaakhsYn4I7f2JK1du5ZHH32Uxx9/nE6dOtGtWzcSEhIIDQ3lxIkT7Nmzh40bNxIUFMTUqVP505/+VOvAsrKyyM3NZcCAAa5jMTEx9OzZk40bNzJmzJgqH1daWlrpRSAvLw8Am82GzWardVy14Ty/r+MQ5cJTv/zyC3Cm1b8nP7OhQ4fy5z//mTVr1nDkyBEaN25c6XblwRyUB/NQLszBjHk4fvw4cGZvaHl5OeXl5W49rmvXriQkJHDo0CE+++wzBg8ebGSYXmfGXDRE/pQHd/8NbhVJbdu2ZdmyZWRnZ/P+++/zxRdfsGHDBoqLi2nSpAldunRh8eLFDB48mMDAwFoF7uTcwxAXF1fpeFxc3Hn3N8yePZsnnnjinONpaWmEh4d7JbbaSk9P93UI8n+UC/ds2rQJOLNEduXKlR49tmXLlhw4cIC//e1vrovM/pryYA7Kg3koF+Zgpjw492QHBwd7/DrcuXNnDh06xIIFC+rt5VrMlIuGzB/yUFRU5Nb93O5uB9CiRQumTJnClClTahRUXZg6dSopKSmu7/Py8khKSiI5Ofm8F8OtCzabjfT0dAYOHIjVavVpLA2dcuGZLVu2AGeuuzFkyBCPHpuRkcFf//pX/vvf//Lss89Wuk15MAflwTyUC3MwYx5Wr14NnPmw2NPX4bCwMFauXElmZibJyckEBXn0559PmTEXDZE/5cG5yuxCTPssiY+PB+DIkSM0b97cdfzIkSN07ty52seFhIQQEhJyznGr1WqapJoploZOuXBPQUEBAI0aNfL453XjjTfy17/+lf/85z+UlJRUuZZeeTAH5cE8lAtzMFMenE2xYmNjPY6pf//+XHTRRfz8889s3Lix2ll9MzNTLhoyf8iDu/G73QK8rrVq1Yr4+HjXJydwpvLbvHkzvXv39mFkIg1PTbrbOV1++eW0bt2a0tJSj5eIiIjIGbV5HQ4KCmL48OGAGumIuMunRVJBQQGZmZlkZmYCZ5o1ZGZmkp2djcVi4f7772fWrFl8/PHH7Ny5k1tuuYWEhARGjBjhy7BFGpzavDlbLBZXdyW9OYuI1ExtXofhbLfR5cuXY7fbvRaXiL/yaZG0bds2unTpQpcuXQBISUmhS5cuTJ8+HYCHH36Ye+65hzvuuIPu3btTUFDAqlWrCA0N9WXYIg2Ot96cV65cSXFxsdfiEhFpKGr7Ovw///M/REdHc/jwYVczHhGpnk+LpH79+uFwOM75euONN4Azn0DPnDmT3NxcSkpK+M9//kObNm18GbJIg1TbN+du3bqRlJREYWEhaWlp3gxNRKRBqO3rcEhICNdffz2gWX0Rd3hcJPXt25fp06ezevVqSkpKjIhJREymtm/OWnInIlI7tX0dhrOz+qmpqfW2FbhIXfG4SEpOTmbTpk0MHz6c2NhYrrrqKqZNm0Z6errbfcdFpH7x5pvzv//9b8rKyrwSl4hIQ+GN1+Frr72WsLAwfvzxR7Zv3+6t0ET8ksdF0rRp00hLS+PkyZOsWbOG66+/nm3btnHdddfRuHFjI2IUER9yOBxeeXPu06cPcXFxrtcOERFxnzdeh8PDwxk8eDCgWX2RC6nxnqT9+/ezc+dOvvnmG3bs2EFUVJTriSci/qOkpASbzQbU7s05MDDQ1ZkyNTXVG6GJiDQY3iiSoPKSOxGpnsdF0tixY7n44ovp06cPq1atolevXnz66accP36c5cuXGxGjiPiQ843ZYrEQGRlZq7Gcb84ffvgh5eXltY5NRKSh8FaRdP311xMcHMzevXvZs2ePN0IT8UseF0nvvvsuNpuNCRMmcOeddzJx4kQ6deqExWIxIj4R8THnG3N0dDQBAbVriNmvXz8aNWrE0aNH+fLLL70RnohIg+CtIik6OpoBAwYAWnIncj4e/8Xz888/8+qrr1JWVsbUqVNp0qQJffr04dFHH1VrXxE/5K03ZgCr1cqwYcMALfUQEfGEN1+LteRO5MI8LpIaNWrEsGHDmDt3LhkZGezYsYM2bdrwzDPPaE+SiB/y5hszVH5z1lXfRUQurLS0lNLSUsA7r8XDhg0jMDCQzMxM9u/fX+vxRPxRjWaSUlNTuffee+nYsSPt2rVjxYoVDB06lLlz5xoRo4j4kLeLpIEDBxIZGcnBgwfZtm2bV8YUEfFnFfeGRkVF1Xq8Jk2acM011wCaTRKpjsdFUrNmzbjrrrs4dOgQEydOZPv27Rw/fpzU1FTuu+8+I2IUER86efIk4L0iKTQ0lOuuuw5AzV5ERNzgfB2Oioqq9d5QJ+esvvYliVTN42fajh07OHLkCB988AH33HMPV1xxhRFxiYhJeHsmCWDkyJHAmS53uuq7iMj5GfE67Lwkw6ZNmzh48KDXxhXxFx4XSR06dDAiDhExKSPenIcMGUJoaCj//e9/OXDggNfGFRHxR0a8DickJNCnTx/gzAdWIlJZjeZsP/jgA/7whz/Qq1cvrrzyykpfIuJfjHhzjoyMZNCgQQBs3LjRa+OKiPgjI16HQUvuRM7H4yJpwYIFjBs3jri4OLZv306PHj246KKL2L9/v7rbifgho96cnUvuVCSJiJyfUa/DN9xwAwDr16/n2LFjXh1bpL7zuEh66aWXeOWVV3jhhRcIDg7m4YcfJj09nXvvvdf1JBYR/2HUm/P1118PQHZ2tt6cRUTOw6jX4VatWnHFFVdgt9v54osvvDq2SH3ncZGUnZ3tWsMaFhZGfn4+ADfffDPvvPOOd6MTEZ8z6s25cePGtG3bFoCtW7d6dWwREX9i1OswQO/evQHYvHmz18cWqc/cLpIOHToEQHx8PL/88gsALVq0YNOmTQBkZWWpS5WIHzLyzblHjx4AbNmyxetji4j4CyNfh3v27AmoSBL5NbeLpMsvv5y3336b/v378/HHHwMwbtw4HnjgAQYOHMjo0aNda1tFxH+oSBIR8a26KJK2bt3K6dOnvT6+SH3ldpE0a9Ys7rzzTk6cOMHkyZMBmDRpEq+//jrt27dn5syZLFq0yLBARcQ36qJI2rp1K3a73evji4j4AyNfh9u1a0dUVBRFRUXs3r3b6+OL1FduF0l33303O3bs4MSJE3To0IF///vfAIwZM4YFCxZwzz33EBwcbFigIlL3HA6HoW/Ol19+OcHBwZw6dYrvvvvO6+OLiPgDI1+HAwMD6d69O6AldyIVedS4oVWrVnz++edMmzaNkSNH0rFjR10nScSPlZSUYLPZAGPenK1WK5deeimgN2cRkeoYWSSB9iWJVCXI0wccOHCA1NRUGjVqxPDhwwkK8ngIEaknnG/MFouFqKgoQ87RunVrvv32WzZv3sytt95qyDlEROozFUkidc+jCmfx4sVMmTKFAQMGsHv3bpo2bWpUXCJiAs435qioKAICPL5igFvatGkD6M1ZRKQ6dVUk7dmzh7y8PKKjow05j0h94vZfPddeey2PPPIIL774IqmpqSqQRBoAo9+Y4WyRtGPHDoqLiw07j4hIfWX0a3F8fDwtWrTA4XCwbds2Q84hUt+4XSSVl5ezY8cObrnlFiPjERETqYsiqWnTpsTFxXH69Gm+/vprw84jIlIflZaWUlpaChj7WqwldyKVuV0kpaenk5iYaGQsImIydVEkWSwWVytwvTmLiFTmfB0GDNsbCtCrVy9Ar8MiTsZsMhARv1AXRRKgIklEpBoV94YGBgYadp6KM0kOh8Ow84jUFyqSRKRaKpJERHyrrl6Hr7zySoKCgsjNzSUnJ8fQc4nUB/WiSFq4cCGXXHIJoaGh9OzZky1btvg6JJEGoa7enLt27YrFYuHAgQMcOXLE0HOJiNQndfU6HBYWRseOHQF9YCUC9aBIeu+990hJSWHGjBl8/fXXdOrUiUGDBnH06FFfhybi9+rqzTk6OprLLrsM0JuziEhFdfU6DGreIFKR6YukuXPnMnHiRMaNG8dll13Gyy+/THh4OK+//rqvQxPxe3pzFhHxLb0Oi/iGRxeTrWtlZWVkZGQwdepU17GAgAAGDBjAxo0bq3xMxVaZAHl5eQDYbDZsNpuxAV/A5MmT2bdvH++++65hF+YU99jtdg4fPqxcXMCXX34JnNkwbMTzxzmmzWajW7duvP7667z11lv8+OOPXj+XVE/PB/NQLszBTHn47rvvgDMz7kb/HXPllVcCsHXrVm666SZDz+UuM+WiIfNGHi6//HIefPBBL0fmOXefR6Yuko4fP055eTlxcXGVjsfFxbF3794qHzN79myeeOKJc46npaURHh5uSJzueu+99yq18hSpL3Jzc1m5cqVh46enp1NeXg5AdnY2S5cuNexcIiL1UVlZmaGvw3DmD+HY2FhOnjyp12Hxui5duriW1vtSUVGRW/czdZFUE1OnTiUlJcX1fV5eHklJSSQnJxMdHe3DyGDmzJlkZmbSpk0bQ9t4yoWVl5fz3XffKRduiIuL4w9/+IMhPyebzUZ6ejoDBw7EarWSlJTk+tRU6o6eD+ahXJiD2fIQHh7OjTfeSKNGjQw/V1paGmvXrjX8PO4yWy4aKm/koWXLlgwZMsTLkXnOucrsQkxdJDVp0oTAwMBzul0dOXKE+Pj4Kh8TEhJCSEjIOcetVitWq9WQON111113sXLlSoYMGeLzWBo6m82mXJiI8/k5fPhwX4fSIOn5YB7KhTk05Dx0796d7t27+zoMl4acCzPxpzy4G7+pF3cGBwfTtWtXVq9e7Tpmt9tZvXo1vXv39mFkIiIiIiLir0w9kwSQkpLCrbfeSrdu3ejRowfz58+nsLCQcePGufV451Wj3Z1aM5LNZqOoqIi8vLx6X4XXd8qFOSgP5qA8mIdyYQ7Kg3koF+bgT3lw1gTOGqE6pi+SRo8ezbFjx5g+fTq5ubl07tyZVatWndPMoTr5+fkAJCUlGRmmiIiIiIjUE/n5+edtrW9xXKiMqufsdjuHDh0iKioKi8Xi01icTSRycnJ83kSioVMuzEF5MAflwTyUC3NQHsxDuTAHf8qDw+EgPz+fhISE87YzN/1MUm0FBASQmJjo6zAqiY6Orve/YP5CuTAH5cEclAfzUC7MQXkwD+XCHPwlD+5cnNnUjRtERERERETqmookERERERGRClQk1aGQkBBmzJhR5XWcpG4pF+agPJiD8mAeyoU5KA/moVyYQ0PMg983bhAREREREfGEZpJEREREREQqUJEkIiIiIiJSgYokERERERGRClQkiYiIiIiIVKAiSUREREREpAIVSSIiIiIiIhWoSBIREREREalARZKIiIiIiEgFKpJEREREREQqUJEkIiIiIiJSQZCvAzCa3W7n0KFDREVFYbFYfB2OiIiIiIj4iMPhID8/n4SEBAICqp8v8vsi6dChQyQlJfk6DBERERERMYmcnBwSExOrvd3vi6SoqCjgzA8iOjrap7HYbDbS0tJITk7GarX6NJaGTrkwB+XBHJQH81AuzEF5MA/lwhz8KQ95eXkkJSW5aoTq+H2R5FxiFx0dbYoiKTw8nOjo6Hr/C1bfKRfmoDyYg/JgHsqFOSgP5qFcmIM/5uFC23DUuEFERERERKQCFUkiIiIiIiIVqEgSERERERGpwO/3JImIiIiINBR2u52ysjKvjmmz2QgKCqKkpITy8nKvju1tVquVwMDAWo+jIklERERExA+UlZWRlZWF3W736rgOh4P4+HhycnLqxXVHY2NjiY+Pr1WsPi2SZs+eTWpqKnv37iUsLIw+ffrw1FNP0bZtW9d9SkpKmDJlCu+++y6lpaUMGjSIl156ibi4OB9GLiIiIiJiHg6Hg8OHDxMYGEhSUtJ5L5TqKbvdTkFBAZGRkV4d19scDgdFRUUcPXoUgObNm9d4LJ8WSevWrWPSpEl0796d06dP8+ijj5KcnMyePXuIiIgA4IEHHuCTTz7h/fffJyYmhsmTJzNy5Ei++uorX4YuIiIiImIap0+fpqioiISEBMLDw706tnMJX2hoqKmLJICwsDAAjh49SrNmzWq89M6nRdKqVasqff/GG2/QrFkzMjIy6Nu3L6dOneK1115j6dKl9O/fH4AlS5bQvn17Nm3aRK9evXwRtoiIiIiIqTj3CgUHB/s4Et9zFok2m61+Fkm/durUKQAaN24MQEZGBjabjQEDBrju065dO1q0aMHGjRurLJJKS0spLS11fZ+Xlwec+SHZbDYjw78g5/l9HYcoF2ahPJiD8mAeyoU5KA/moVy4z2az4XA4cDgchuxJcv7X22MbwflzqKpIcvd3yeJw/qt9zG63M2zYME6ePMmXX34JwNKlSxk3blylogegR48e/P73v+epp546Z5zHH3+cJ5544pzjS5cu9frUo4iIiIiIGQQFBREfH09SUlKDn00qKysjJyeH3NxcTp8+Xem2oqIixo4dy6lTp4iOjq52DNPMJE2aNIldu3a5CqSamjp1KikpKa7v8/LySEpKIjk5+bw/iLpgs9lIT09n4MCBWK1Wn8bS0CkX5qA8mIPyYB7KhTkoD+ahXLivpKSEnJwcIiMjCQ0N9erYDoeD/Px8oqKi6kV3u5KSEsLCwujbt+85PwvnKrMLMUWRNHnyZFasWMH69etJTEx0HY+Pj6esrIyTJ08SGxvrOn7kyBHi4+OrHCskJISQkJBzjlutVtM8ucwUS0OnXJiD8mAOyoN5KBfmoDyYh3JxYeXl5VgsFgICArzeXMG5xM45vrdcqOCaMWMGjz/+uOv7n3/+mU6dOvHTTz9x4sSJSvVBRQEBAVgslip/b9z9PfKoSLLb7axbt44vvviCAwcOUFRURNOmTenSpQsDBgwgKSnJk+FwOBzcc889LF++nLVr19KqVatKt3ft2hWr1crq1asZNWoUAPv27SM7O5vevXt7dC4RqT2Hw+H6dEZERESkNg4fPuz6//fee4/p06ezb98+17HIyMhK9x8/fjwdO3bkp59+Mjw2t0rB4uJiZs2aRVJSEkOGDOHTTz/l5MmTBAYG8sMPPzBjxgxatWrFkCFD2LRpk9snnzRpEm+99RZLly4lKiqK3NxccnNzKS4uBiAmJobx48eTkpLCmjVryMjIYNy4cfTu3Vud7UR8YPLkycTFxbFx40ZfhyIiIiL1XHx8vOsrJiYGi8VS6VjFImnRokWcPHmSBx98sE5ic2smqU2bNvTu3ZvFixdXuyb0wIEDLF26lDFjxvDYY48xceLEC467aNEiAPr161fp+JIlS7jtttsAmDdvHgEBAYwaNarSxWRFpO6tX7+e/Px8br/9drZv3+71Nc8iIiLiHc4Lq3qD3W6nsLCQwMBAt5bbhYeHe3Xv0p49e5g5cyabN29m//79Xhv3fNwqktLS0mjfvv1579OyZUumTp3Kgw8+SHZ2tlsnd6exXmhoKAsXLmThwoVujSkixnFudty7dy9PPvkkf/3rX30ckYiIiFSlqKjonOVqdaWgoICIiAivjFVaWsof//hHnnnmGVq0aFFnRZJby+0uVCBVZLVaufTSS2sckIiYV8WOMHPmzGHHjh0+jEZERET83dSpU2nfvj3/+7//W6fn9bi7XXV/FFksFkJDQ2nRokWV3eVEpH5zOByuIqlPnz5s2LCB8ePHs3HjRoKCTNEoU0RERP5PeHg4BQUFXhnLbreTl5dHdHS028vtvOXzzz9n586dfPDBB8DZlWhNmjThscceq/L6qN7g8V82nTt3Pu8aQ6vVyujRo/n73/+u/QoifqS4uNjVAvSNN96ge/fubNu2jeeff54pU6b4ODoRERGpyGKxeG3Jm91up7y8nIiICK+3F7+QZcuWuZq6AWzdupXbb7+dL774wtDVax7/K5cvX07r1q155ZVXyMzMJDMzk1deeYW2bduydOlSXnvtNT7//HOmTZtmRLwi4iPOWaSAgAB++9vf8uyzzwLwl7/8hf/+97++DE1ERET81KWXXsrll1/u+nJeMqh9+/Y0a9bMsPN6PJP05JNP8vzzzzNo0CDXsSuuuILExET+8pe/sGXLFiIiIpgyZYrrjygRqf+cRZLzatvjx49n6dKlrFmzhjvuuIP//Oc/9eIq3CIiIiIX4vFM0s6dO2nZsuU5x1u2bMnOnTuBM0vyKl4cSkTqP2eRFB0dDZyZxl+8eDFhYWF8/vnnLFmyxJfhiYiISD122223cfLkyQver1+/fjgcDmJjYw2Nx+MiqV27dsyZM4eysjLXMZvNxpw5c2jXrh0AP/30E3Fxcd6LUkR87tdFEpyZAp85cyYAU6ZM0YcjIiIi4hc8Xm63cOFChg0bRmJiIh07dgTOzC6Vl5ezYsUKAPbv38/dd9/t3UhFxKfy8/OBM8vtKrr//vt577332LZtG5MnT2bZsmW+CE9ERETEazwukvr06UNWVhZvv/023333HQA33ngjY8eOdf3xdPPNN3s3ShHxuapmkgCCgoJ47bXX6Nq1K6mpqaSmpjJy5EhfhCgiIiLiFTW6uElUVBR33nmnt2MREROrrkgC6NixI4888ghPPvkkkyZNYtCgQV5rOyoiImetWbOGW2+9tdL1byIiInjrrbe45pprfBiZiH+pUaPzf/7zn1x11VUkJCRw4MABAObNm8dHH33k1eBExDzOVyQBTJs2jYsvvpjc3Fw2bNhQl6GJiDQYy5YtIycnhxMnTri+Dh48yG233ea1C4eKSA2KpEWLFpGSksLgwYM5ceIE5eXlADRq1Ij58+d7Oz4RMYnq9iQ5hYaG0rdvXwA2b95cZ3GJiDQkJ06cAODPf/4ze/fuZdeuXbRs2ZIff/xR16gUABwOh69D8Dlv/Aw8LpJeeOEFFi9ezGOPPUZQ0NnVet26dXO1ABcR/3OhmSSAnj17AiqSRESM4myR3KZNG9q2bUuHDh145ZVXAFiwYAGbNm3yYXTiS4GBgQCVOlA3VEVFRQBYrdYaj+HxnqSsrCy6dOlyzvGQkBAKCwtrHIiImJsnRdKmTZtwOBy6uKyIiJc5Z5IqXiMmOTmZW265hTfffJPx48fz9ddfExIS4qMIxVeCgoIIDw/n2LFjWK1WAgJqtKumSna7nbKyMkpKSrw6rrc5HA6Kioo4evQosbGxrsKxJjwuklq1akVmZuY5F5RdtWoV7du3r3EgImJu7hRJnTt3xmq1cvz4cbKysvjNb35TV+GJiDQIzpmkRo0aVTo+d+5cPv30U/bs2cPs2bN5/PHH6z448SmLxULz5s3Jyspy9QzwFofDQXFxMWFhYfXiA9DY2Fji4+NrNYbHRVJKSgqTJk2ipKQEh8PBli1beOedd5g9ezavvvpqrYIREfO60J4kOLMvqXPnzmzdupXNmzerSBIR8bKqZpIALrroIl544QXGjBnD3/72N0aPHq0Prxug4OBgWrdu7fUldzabjfXr19O3b99aLWGrC1artVYzSE4eF0kTJkwgLCyMadOmUVRUxNixY0lISOD5559nzJgxtQ5IRMzJnZkkOLPkzlkk/fGPf6yL0EREGozqZpIA/vCHP/CPf/yDTz/9lFdffZXnnnuujqMTMwgICCA0NNSrYwYGBnL69GlCQ0NNXyR5S40WFd500018//33FBQUkJuby8GDBxk/fry3YxMRE3G3SOrVqxeg5g0iIt5WUlJCSUkJcO5MEpxZbjVx4kTgTKtwdTkTqbkaFUnHjx9n27ZtfPvtt16ZzhIR8/NkJglg+/bt6rAjIuJFzqV2AQEB1S59HjRoEOHh4Rw4cIDt27f///buPC6quu0f+GeAYV8VYSBRScUlFXEBl8IlBLFbMX1Ks1+ZmWWpLZh6Y6bVbbe2qWmmaYt1P2ndJba4kIi7IiqKuJILicYmyr4OzPn9wTMTkyAzcM7MYfi8Xy9eOuec+Z5r5uIA13yXY8rwiCyKUUXS+fPnERoaCm9vb4SEhCA4OBheXl4YOXIk0tLSpIqRiGTA0CKpc+fOaNu2LSorK3HmzBlThEZE1Cpoh9q5ubk1uMKYo6MjIiMjAdT2JhFR0xhcJGVnZ2PYsGG4desWVqxYgZ07d2LHjh344IMPkJWVhYceegi5ublSxkpEZlJTU6O758C9Fm4Aaod7BAcHA+CQOyIiMWl7kuqbj1TXhAkTAHDIHVFzGFwkrVy5Eh07dsTp06fxyiuvICIiAqNHj0Z0dDROnToFPz8/rFy5UspYichMtCvbAY0XSQBvKktEJAVtT1J985Hq+sc//gFbW1ukpaXh4sWL0gdGZIEMLpLi4+OxYMGCelfLcHBwwLx58/Dbb7+JGhwRyYN2qJ2dnZ1BNyhkkUREJD5De5JcXV0xatQoABxyR9RUBhdJ165dQ79+/RrcP2DAAFy7dk2UoIhIXgydj6SlHW53+fJl3LlzR7K4iIhaE0N7kgD9IXdEZDyDi6Ti4uJ7/oHk4uKCkpISUYIiInkx5EaydbVp0wZdu3YFABw/flyyuIiIWhNDe5IAICoqCtbW1jhz5gyuXr0qdWhEFseo1e2Ki4tRVFTU4BcnBxJZJmN7kgAOuSMiEpsxPUlt27bF8OHDAQCxsbHSBUVkoQwukgRBQEBAADw8POr96tatm5RxEpEZsUgiIjI/Y3qSgL+G3LFIIjKejaEH7tu3T8o4iEjGmlskCYIAhUIhSWxERK2FMT1JAPDoo49i9uzZOHbsGG7evIn27dtLFxyRhTG4J2nYsGEGfRnj4MGDGDt2LHx9faFQKPDTTz/p7RcEAYsXL4aPjw8cHBwQFhaGy5cvG3UOImo+Y+ckAUBgYCCcnJxw584dfPvtt1KFRkTUahjbk+Tj44PBgwcDALZt2yZZXESWyKAiqbS01KhGDT2+tLQUgYGBWLt2bb3733//faxevRrr169HUlISnJycEBERgYqKCqPiIaLmaUpPkq2tLRYuXAgAePXVV3Hr1i1JYiMiai20PUmGFkkAMHHiRAAcckdkLIOKpC5dumD58uXIyspq8BhBEBAfH4/IyEisXr3aoJNHRkZi6dKlePTRR+ttb9WqVVi0aBGioqLQp08ffPPNN8jMzLyrx4mIpNWUIgkA5s2bh8DAQNy+fRuvvPKKFKEREbUa2p4kQ4fbAX/NSzp48CA/rCIygkFzkvbv34+FCxfirbfeQmBgIAYMGABfX1/Y29sjPz8fFy5cQGJiImxsbBATE4MXXnih2YGlp6cjOzsbYWFhum1ubm4ICQlBYmIiJk+eXO/zKisrUVlZqXus/eNOrVZDrVY3O67m0J7f3HEQc2Es7aeXTk5ORr9n69evx9ChQ7FlyxY8/vjjeOSRR3T7mAd5YB7kg7mQB7nmQfuz2NnZ2eDY7rvvPgQFBeH06dPYunUrpk+fLmGE4pNrLlobS8qDoa/BoCKpW7du2Lp1KzIyMvDDDz/g0KFDOHr0KMrLy+Hp6YmgoCBs3LgRkZGRsLa2blbgWtnZ2QAAb29vve3e3t66ffVZtmwZ3n777bu27969G46OjqLE1lzx8fHmDoH+D3NhmLS0NADAjRs3sHPnTqOfP27cOPz000947rnnsGbNmruuReZBHpgH+WAu5EFOedBoNCgsLAQAJCcnG3Xvo549e+L06dPYuHEjfHx8pApRUnLKRWtmCXkoKysz6DiFIJObGykUCmzbtg3jx48HABw9ehRDhw5FZmam3gX9+OOPQ6FQ4Pvvv6+3nfp6kvz8/JCXl2f0UCGxqdVqxMfHY9SoUVAqlWaNpbVjLowTFRWFXbt2YePGjZg6darRzy8rK0P//v1x9epVPP/88/jkk08AMA9ywTzIB3MhD3LMQ35+vu6D4+LiYtjZ2Rn83LS0NPTu3RtKpRJ//vmnUcP1zE2OuWiNLCkPRUVF8PT0RGFh4T1rA4OXADc1lUoFAMjJydErknJyctC3b98Gn2dnZ1fvDw6lUimbpMopltaOuTCMdnU7Dw+PJr1fbm5u2LhxI0aOHInPP/8cy5cv15t4zDzIA/MgH8yFPMgpD9pFsRwcHODs7GzUc3v16oWePXviwoUL+O233/D//t//kyJESckpF62ZJeTB0PgNXgLc1Pz9/aFSqZCQkKDbVlRUhKSkJN1ylkRkGk1duKGuESNGoHPnztBoNDhx4oRYoRERtQrGLv/9d9pV7rZu3SpaTESWzKxFUklJCVJSUpCSkgKgdrGGlJQUZGRkQKFQ4NVXX8XSpUvxyy+/4OzZs3j66afh6+urG5JHRKYhRpEE6N9gloiIDGfsjWT/TrvKXVxcHEpKSkSKishymbVIOnnyJIKCghAUFAQAiI6ORlBQEBYvXgwAmD9/PubMmYPnn38eAwcORElJCeLi4mBvb2/OsIlanabcTLY+LJKIiJqmuT1JgYGBuP/++1FRUYG4uDgxQyOySGYtkoYPHw5BEO762rRpE4DaxRzeeecdZGdno6KiAnv27EFAQIA5QyZqdQRBkKQnSSZrxhARtQjN7UlSKBQcckdkBKOLpNDQUCxevBgJCQmoqKiQIiYikpHKykrdPQWaWyT17dsXtra2yMvLQ3p6uhjhERG1Cs3tSQL+GnK3fft2/g1H1Aiji6Tw8HAcO3YMUVFRcHd3x4MPPohFixYhPj7e4HXHiajl0PYiATB6RaW/s7Oz061OySF3RESGa25PEgAEBwfjvvvuQ0lJCfbs2SNOYEQWyugiadGiRdi9ezcKCgqwb98+/OMf/8DJkyfxyCOPoE2bNlLESERmpC2SnJ2dYWXV/BG6nJdERGQ8MXqSrKysdL1JHHJHdG9N/ovn2rVrOHv2LM6cOYPU1FS4uLggMjJSzNiISAa0izaIdTNmFklERMYToycJ+GvI3S+//KIbSk1EdzO6SJoyZQruu+8+DBkyBHFxcRg0aBB27dqFvLw8bNu2TYoYiciMxFq0QUtbJJ06dQqVlZWitElEZOnE6EkCgIceegjt2rXDnTt3cODAATFCI7JIRhdJ3333HdRqNZ577jnMnDkTM2bMQGBgIBQKhRTxEZGZiV0kde7cGW3btkVVVRVSU1NFaZOIyNJpe5KaWyRZW1sjKioKAIfcEd2L0UXS7du38fnnn6OqqgoxMTHw9PTEkCFDsHDhQuzevVuKGInIjLRFUnPvkaSlUCh0vUnHjx8XpU0iIkun7Ulq7nA7ALqlwLdt24aamppmt0dkiYwukjw8PDBu3DisWLECycnJSE1NRUBAAD744APOSSKyQGLPSQLAIomIyEhi9SQBwMiRI+Hm5oacnBwkJiY2uz0iS9SknqTY2Fi8/PLL6NOnD7p3747t27dj7NixWLFihRQxEpEZiT3cDvirSDpx4oRobRIRWTIxe5JsbW0xduxYABxyR9QQo4skLy8vvPjii8jMzMSMGTNw+vRp5OXlITY2Fq+88ooUMRKRGUlRJAUHBwMArly5oncfJiIiult5ebluoRsxepKAv4bcxcbGQhAEUdoksiQ2xj4hNTUVDzzwgBSxEJEMiT0nCaj9JR8QEIDff/8dly9fFq1dIiJLpB1qZ2Vl1eybemtFRETA0dERGRkZSE5OxoABA0Rpl8hSGN2TxAKJqHWRYk4S8NeQu99//13UdomILE3doXZi3NQbABwcHDBmzBgAtb1JRKSvSVfajz/+iMcffxyDBg1Cv3799L6IyLJIMdwO+KtIYk8SEdG9iXUj2b/TDrnbunUrh9wR/Y3RRdLq1asxbdo0eHt74/Tp0wgODkbbtm1x7do1rm5HZIFMUSTxlzMRUcPEupHs340ZMwa2trb4/fffcenSJVHbJmrpjC6SPv30U2zYsAFr1qyBra0t5s+fj/j4eLz88ssoLCyUIkYiMiOpiqQ+ffrAzs4OxcXFuHLliqhtExFZEql6klxdXTFkyBAAwJEjR0Rtm6ilM7pIysjI0F1QDg4OuvkKTz31FLZs2SJudERkdlIs3ADULkEbFBQEAEhKShK1bSIiSyJVTxLwV68+fw4T6TO4SMrMzAQAqFQq3LlzBwDQoUMHHDt2DACQnp7OITNEFkiqhRuAv5YC5/2SiIgaJlVPEsAiiaghBhdJvXr1wrfffouRI0fil19+AQBMmzYNr732GkaNGoVJkybh0UcflSxQIjIPqYbbAcDAgQMBAMePHxe9bSIiS2GKnqTz58+jpKRE9PaJWiqDi6SlS5di5syZyM/Px+zZswEAs2bNwpdffokePXrgnXfewbp16yQLlIhMT6PRmKQnKTU1FRUVFaK3T0RkCaTsSfL19UX79u2h0Whw8uRJ0dsnaqkMLpJeeuklpKamIj8/Hw888AB+/fVXAMDkyZOxevVqzJkzB7a2tpIFSkSmV/dTRbHnJAFAp06d4ObmBrVajdOnT4vePhGRJZCyJwngkDui+hi1cIO/vz/27t2LRYsWYcKECejTpw/vk0RkwbS9SDY2NrC3txe9fYVCgYCAAAD85UxE1BBtTxKLJCLTsTH2CdevX0dsbCw8PDwQFRUFGxujmyCiFqLufCSFQiHJOQICAnDixAn+ciYiaoC2J0mK4XYAMGjQIAAskojqMqrC2bhxI+bOnYuwsDCcP38e7dq1kyouIpIBKRdt0GJPEhHRvUndk9S/f39YW1sjMzMTN2/eRPv27SU5D1FLYvBwu9GjR2PBggX45JNPEBsbywKJqBWQ6h5JdXXp0gUKhQLp6em4deuWZOchImqppO5JcnR0RO/evQHwAysiLYOLpJqaGqSmpuLpp5+WMh4ikhEpV7bTcnJyQrdu3QDwlzMR0d/V1NSgsLAQgHQ9SQDnJRH9ncFFUnx8PLtfiVoZUwy3A/5aCpy/nImI9Gl/DgPS9SQBfxVJx44dk+wcRC2JUavbEVHrwiKJiMi8tEPtHB0dJb3VirZISk5ORnV1tWTnIWopWCQRUYNMMScJAAYOHAigtkjSaDSSnouIqCWR8kaydXXv3h2urq4oKyvDuXPnJD0XUUvQIoqktWvXolOnTrC3t0dISAiOHz9u7pCIWgVT9ST17t0bDg4OKCoqQlpamqTnIiJqSaS+kayWlZWV3gdWRK2d7Iuk77//HtHR0ViyZAlOnTqFwMBAREREIDc319yhEVk8UyzcANTerLZ///4A+MuZiKguU/UkAVy8gagu2RdJK1aswIwZMzBt2jT07NkT69evh6OjI7788ktzh0Zk8UzVkwTwlzMRUX1M1ZME8OcwUV1G3UzW1KqqqpCcnIyYmBjdNisrK4SFhSExMbHe51RWVqKyslL3WPtHnlqthlqtljbgRnTt2hU5OTmwtrY2axxUq6amhrloRHl5OYDaZbqluH60barVagwYMAAAsGHDBvznP/8R/Vx0b7we5IO5kAe55KGqqgpA7YdVUv8d069fPwDAhQsX4OzsLOm5jCGXXLR2zc3DyJEjsXXrVhEjahpDryNZF0l5eXmoqamBt7e33nZvb29cunSp3ucsW7YMb7/99l3bd+/eDUdHR0niNFRBQQEqKirMGgORsWxsbFBaWoqdO3dKdo74+Hio1Wo4OzujpKQEpaWlkp2LiKglcnV1lfTnsFaPHj1w8eJF/hwm0d28edMk38ONKSsrM+g4WRdJTRETE4Po6Gjd46KiIvj5+SE8PNwkQ4bu5dixYzh48CAefPBB2NhY3FvfolRXV+Pw4cPMhQE8PDwkGwuvVqsRHx+PUaNGQalUYuzYsZxvaAa8HuSDuZAHueXBwcEBKpXKJOcKDw/HjRs3THIuQ8gtF62VGHkw5ffxvdS999i9yPq7zdPTE9bW1sjJydHbnpOT0+CbbGdnBzs7u7u2K5VKKJVKSeI0VOfOnZGWloauXbuaPZbWTq1W4/Lly8yFTGivT3d3d5NMTiZ9vB7kg7mQh9acB6VSiYCAAHOHodOacyEnlpQHQ+OXdZFka2uL/v37IyEhAePHjwcAaDQaJCQkYPbs2Qa1IQgCAMOrRimp1WqUlZWhqKioxX+DtXTMhTwwD/LAPMgHcyEPzIN8MBfyYEl50NYE2hqhIbIukgAgOjoaU6dOxYABAxAcHIxVq1ahtLQU06ZNM+j52iWM/fz8pAyTiIiIiIhaiOLiYri5uTW4X/ZF0qRJk3Dr1i0sXrwY2dnZ6Nu3L+Li4u5azKEhvr6+uHHjBlxcXKBQKCSO9t6086Nu3Lhh9vlRrR1zIQ/MgzwwD/LBXMgD8yAfzIU8WFIeBEFAcXExfH1973mcQmisr4lEU1RUBDc3NxQWFrb4b7CWjrmQB+ZBHpgH+WAu5IF5kA/mQh5aYx5kfzNZIiIiIiIiU2KRREREREREVAeLJBOys7PDkiVL6l2inEyLuZAH5kEemAf5YC7kgXmQD+ZCHlpjHjgniYiIiIiIqA72JBEREREREdXBIomIiIiIiKgOFklERERERER1sEgiIiIiIiKqg0USERERERFRHSySiIiIiIiI6mCRREREREREVAeLJCIiIiIiojpYJBEREREREdXBIomIiIiIiKgOFklERERERER12Jg7AKlpNBpkZmbCxcUFCoXC3OEQEREREZGZCIKA4uJi+Pr6wsqq4f4iiy+SMjMz4efnZ+4wiIiIiIhIJm7cuIH27ds3uN/iiyQXFxcAtW+Eq6urWWNRq9XYvXs3wsPDoVQqzRpLa8dcyAPzIA/Mg3wwF/LAPMgHcyEPlpSHoqIi+Pn56WqEhlh8kaQdYufq6iqLIsnR0RGurq4t/huspWMu5IF5kAfmQT6YC3lgHuSDuZAHS8xDY9NwuHADERnsyJEjeOedd1BeXm7uUIiIiIgkY/E9SUQknvnz5+Po0aMoLCzERx99ZO5wiIiIiCTBniQiMtjt27cBAKtWrcLx48fNHA0RERGRNNiTREQGKykpAVC7tP706dORnJwMW1tbM0dFREREWhqNBlVVVaK2qVarYWNjg4qKCtTU1IjattiUSiWsra2b3Q6LJCIymLZIsrW1xblz5/Dee+/hzTffNHNUREREBABVVVVIT0+HRqMRtV1BEKBSqXDjxo0Wcd9Rd3d3qFSqZsVq1iJp2bJliI2NxaVLl+Dg4IAhQ4bgvffeQ7du3XTHVFRUYO7cufjuu+9QWVmJiIgIfPrpp/D29jZj5EStjyAIuiLp3Xffxbx587B06VJMnDgRPXv2NHN0RERErZsgCMjKyoK1tTX8/PzueaNUY2k0GpSUlMDZ2VnUdsUmCALKysqQm5sLAPDx8WlyW2Ytkg4cOIBZs2Zh4MCBqK6uxsKFCxEeHo4LFy7AyckJAPDaa69hx44d+OGHH+Dm5obZs2djwoQJOHLkiDlDJ2p1qqqqdF3sM2bMwP79+7Fjxw4899xzOHz4sKx/aBIREVm66upqlJWVwdfXF46OjqK2rR3CZ29vL/vf9w4ODgCA3NxceHl5NXnonVmLpLi4OL3HmzZtgpeXF5KTkxEaGorCwkJ88cUX2Lx5M0aOHAkA+Oqrr9CjRw8cO3YMgwYNMkfYRK2SthcJAJydnbFu3Tr07NkTiYmJOHz4MEJDQ80YHRERUeum/SCTc4WhKxLVanXLLJL+rrCwEADQpk0bAEBycjLUajXCwsJ0x3Tv3h0dOnRAYmJivUVSZWUlKisrdY+LiooA1L5JarVayvAbpT2/ueMg5qIp8vPzAQD29vbQaDRQqVQIDw9HbGwsDh8+jMGDBxvdJvMgD8yDfDAX8sA8yAdzYTi1Wg1BECAIgiRzkrT/it22FLTvQ31FkqHfS7IpkjQaDV599VUMHToUvXr1AgBkZ2fD1tYW7u7uesd6e3sjOzu73naWLVuGt99++67tu3fvFr3rsani4+PNHQL9H+bCcBkZGQBqP6HauXMnAMDV1RUA8Ouvv+KBBx5octvMgzwwD/LBXMgD8yAfzEXjbGxsoFKpUFJSIvrqdlrFxcWStCu2qqoqlJeX4+DBg6iurtbbV1ZWZlAbsimSZs2ahXPnzuHw4cPNaicmJgbR0dG6x0VFRfDz80N4eLjuDzpzUavViI+Px6hRo6BUKs0aS2vHXBhPe1+kNm3aYMyYMQBqi6RNmzYhIyNDt80YzIM8MA/ywVzIA/MgH8yF4SoqKnDjxg04OzvD3t5e1LYFQUBxcTFcXFxaxOp2FRUVcHBwQGho6F3vhXaUWWOMKpI0Gg0OHDiAQ4cO4fr16ygrK0O7du0QFBSEsLAw+Pn5GdOczuzZs7F9+3YcPHgQ7du3121XqVSoqqpCQUGBXm9STk4OVCpVvW3Z2dnBzs7uru1KpVI2F5ecYmntmAvDaYexOjs7696zkJAQWFtbIzMzEzk5OXrXrzGYB3lgHuSDuZAH5kE+mIvG1dTUQKFQwMrKSvTFFbRD7LTti6WxgmvJkiV466236j1uy5YtmDx5cr3Ps7KygkKhqPf7xtDvI4NeZXl5OZYuXQo/Pz+MGTMGu3btQkFBAaytrXHlyhUsWbIE/v7+GDNmDI4dO2bQiYHaqnT27NnYtm0b9u7dC39/f739/fv3h1KpREJCgm5bWloaMjIymjT/gYiaTrtwg3blSaB2YmTv3r0BAElJSWaJi4iIiFqmrKws3deqVavg6uqqt+3111/XHfvVV1/p7Rs/fryksRnUkxQQEIDBgwdj48aNDXZ3Xr9+HZs3b8bkyZPxxhtvYMaMGY22O2vWLGzevBk///wzXFxcdPOM3Nzc4ODgADc3N0yfPh3R0dFo06YNXF1dMWfOHAwePJgr2xGZmLZIcnZ21tseEhKClJQUJCUlYeLEieYIjYiIiFqguiPD3NzcoFAoGhwtpr1BrKkYVCTt3r0bPXr0uOcxHTt2RExMDF5//XXdBO/GrFu3DgAwfPhwve1fffUVnnnmGQDAypUrYWVlhYkTJ+rdTJaITOteRdJnn33GniQiIiIZ0d5YVQwajQalpaWwtrY2aLido6Oj6HOXZs2aheeeew73338/Zs6ciWnTpkk6P8qgIqmxAqkupVKJzp07G3SsdjnBe7G3t8fatWuxdu1ag2MgIvHdq0gCgJMnT6K6uho2NrJZD4aIiKjVKisru+t3tqmUlJToDc9vrnfeeQcjR46Eo6Mjdu/ejZdeegklJSV4+eWXRTvH3xn910xqamq92xUKBezt7dGhQ4d6F04gopattLQUwN1FUvfu3eHq6oqioiKcO3cOffv2NUN0REREZKnefPNN3f+DgoJQWlqKDz74QF5FUt++fe/ZtaVUKjFp0iR89tlnoi8/SETmU9/CDUDtCjIDBw5EQkICkpKSWCQRERHJgKOjo+53d3NpNBoUFRXB1dXV4OF2UgoJCcG//vUvVFZWStY5Y/Qaftu2bUPXrl2xYcMGpKSkICUlBRs2bEC3bt2wefNmfPHFF9i7dy8WLVokRbxEZCYNDbcDoFtIhfOSiIiI5EGhUMDJycksX1LfSyklJQUeHh6Sjl4zuifp3Xffxccff4yIiAjdtt69e6N9+/Z48803cfz4cTg5OWHu3Ln48MMPRQ2WiMznXkWSdl4SiyQiIiIS06+//oqcnBwMGjQI9vb2iI+Px7///W+95cGlYHSRdPbsWXTs2PGu7R07dsTZs2cB1A7Jy8rKan50RCQbhhRJFy9e1HXHExERETWXUqnE2rVr8dprr0EQBHTp0gUrVqww6HZDzWH0cLvu3btj+fLlqKqq0m1Tq9VYvnw5unfvDgD4888/4e3tLV6URGR2DS3cAABeXl7o1KkTBEHAiRMnTB0aERERtXDPPPMMCgoK7to+evRonD59GsXFxSgpKUFKSgpeeOEFg+ZGNYfRPUlr167FuHHj0L59e/Tp0wdAbe9STU0Ntm/fDgC4du0aXnrpJXEjJSKzamjhBq2QkBD88ccfSEpKwsMPP2zK0IiIiIhEZXSRNGTIEKSnp+Pbb7/F77//DgB47LHHMGXKFLi4uAAAnnrqKXGjJCKzu9dwO6C2SPr+++85L4mIiIhavCbd9dHFxQUzZ84UOxYikjFDiiSgdvEGQRAkX9mGiIiISCpNGsz3n//8Bw8++CB8fX1x/fp1AMDKlSvx888/ixocEclHY0VSUFAQbGxskJOTg4yMDFOGRkRERCQqo4ukdevWITo6GpGRkcjPz0dNTQ0AwMPDA6tWrRI7PiKSiXst3AAADg4OCAwMBMClwImIiMxFEARzh2B2YrwHRhdJa9aswcaNG/HGG2/Axuav0XoDBgzQLQFORJZFo9HoiqSGFm4AeL8kIiIic7G2tgYAvRWoW6uysjIAtcuHN5XRc5LS09MRFBR013Y7OzvdH1FEZFnKy8t1n8o01JME1BZJn376KY4dO2aq0IiIiAiAjY0NHB0dcevWLSiVSlGXyNZoNKiqqkJFRYXkS283hyAIKCsrQ25uLtzd3XWFY1MYXST5+/sjJSXlrhvKxsXFoUePHk0OhIjkSzsfSaFQwMHBocHjtD1Jp06dglqtbtYnOERERGQ4hUIBHx8fpKen69YMEIsgCCgvL4eDg0OLWJjJ3d0dKpWqWW0YXSRFR0dj1qxZqKiogCAIOH78OLZs2YJly5bh888/b1YwRCRPde+RdK9PkLp27Qp3d3cUFBQgNTUV/fv3N1WIRERErZ6trS26du0q+pA7tVqNgwcPIjQ0VPYfgCqVymb1IGkZXSQ999xzcHBwwKJFi1BWVoYpU6bA19cXH3/8MSZPntzsgIhIfhpbtEHLysoKISEh+O2335CUlMQiiYiIyMSsrKxgb28vapvW1taorq6Gvb297IsksTRpUOGTTz6Jy5cvo6SkBNnZ2bh58yamT58udmxEJBN1e5Iaw8UbiIiIqKVr0s1k8/Ly8Mcff0ChUKBTp04ih0REctPYPZLqYpFERERELZ1RPUnnz59HaGgovL29ERISguDgYHh5eWHkyJFIS0uTKkYiMjNjiqTg4GAAQFpaGvLz8yWNi4iIiEgKBhdJ2dnZGDZsGG7duoUVK1Zg586d2LFjBz744ANkZWXhoYceQm5urpSxEpGZGFMkeXp6onPnzgCAEydOSBoXERERkRQMLpJWrlyJjh074vTp03jllVcQERGB0aNHIzo6GqdOnYKfnx9WrlwpZaxEZCaGLtygxSF3RESmo72PHRGJx+AiKT4+HgsWLKh3tQwHBwfMmzcPv/32m6jBEZE8GLNwA8AiiYjIVDZu3AgXFxf89NNP5g6FyKIYXCRdu3YN/fr1a3D/gAEDcO3aNVGCIiJ5MWa4HaBfJPETTiIi6axatQqlpaWYMWMG8vLyzB0OkcUwuEgqLi6Gq6trg/tdXFx0f0gRkWUxtkjq27cvbG1tkZeXxw9PiIgkcunSJVy4cAFA7crDr776qnkDIrIgRq1uV1xcjKKioga/+IkxkWUytkiys7ND3759AXDIHRGRVLZu3QoA6N69O6ysrPDtt99i165dZo6KyDIYXCQJgoCAgAB4eHjU+9WtWzcp4yQiMzJ24QaA85KIiKQWGxsLAHj99dd1vUgvvPACiouLzRgVkWUw+Gay+/btkzIOIpIxYxduAGqLpDVr1rBIIiKSQHp6Ok6dOgUrKyuMGzcOkydPxrZt25Ceno6YmBh88skn5g6RqEUzuEgaNmyYlHEQkYwZO9wOAAYNGgQAOH36NEpKSox6LhER3Zu2F2nYsGFo164dAGDDhg0YNWoUPv30UzzxxBMYOnSoOUMkatEMGm6nHWpjKEOPP3jwIMaOHQtfX18oFIq7lq8UBAGLFy+Gj48PHBwcEBYWhsuXLxsVCxE1X1OKpPvvvx+dO3dGVVUVFi1aJFVoREStkrZImjhxom5bWFgYnn32WQiCgOeeew4VFRXmCo+oxTOoSOrSpQuWL1+OrKysBo8RBAHx8fGIjIzE6tWrDTp5aWkpAgMDsXbt2nr3v//++1i9ejXWr1+PpKQkODk5ISIighc9kYk1pUhSKBT49NNPAQCrV6/GsWPHJImNiKi1yczMxNGjRwEA48eP19v34YcfQqVS4dKlS1i6dKkZoiOyDAYNt9u/fz8WLlyIt956C4GBgRgwYAB8fX1hb2+P/Px8XLhwAYmJibCxsUFMTAxeeOEFg04eGRmJyMjIevcJgoBVq1Zh0aJFiIqKAgB888038Pb2xk8//YTJkycb+BKJqLmaUiQBQHh4OJ5++ml88803mD59Ok6dOgU7OzspQiQiajW2bdsGABg8eDDuu+8+vX0eHh745JNP8D//8z9477338Pjjj6NPnz7mCJOoRTOoSOrWrRu2bt2KjIwM/PDDDzh06BCOHj2K8vJyeHp6IigoCBs3bkRkZCSsra1FCSw9PR3Z2dkICwvTbXNzc0NISAgSExMbLJIqKytRWVmpe1xUVAQAUKvVUKvVosTWVNrzmzsOYi6MpR1Ca2tra/R79t577yEuLg4XLlzA0qVLsXjxYt0+5kEemAf5YC7kQe550C79HRUVVW+M48aNw/jx4/HTTz/h2WefxaFDh2BjY/A0dFmRey5aC0vKg6GvQSHI5OZGCoUC27Zt03UbHz16FEOHDkVmZiZ8fHx0xz3++ONQKBT4/vvv623nrbfewttvv33X9s2bN8PR0VGS2Iks3eOPP46qqips2LABXl5eRj//8OHD+PDDD2FjY4OPPvoIHTt2lCBKIiLLV1RUhGeeeQYajQafffYZvL296z3uzp07mDNnDkpLS/HMM8/cNSyPqLUqKyvDlClTUFhYCFdX1waPa5kfK9xDTEwMoqOjdY+Liorg5+eH8PDwe74RpqBWqxEfH49Ro0ZBqVSaNZbWjrkwXHV1NaqqqgAAY8eORdu2bY1uIzIyEpcuXcL27duxefNmHDx4EAqFgnmQCeZBPpgLeZBzHjZt2gSNRoO+ffti2rRp9zxWrVbjhRdewPfff4+FCxeiU6dOpglSRHLORWtiSXnQjjJrjGyLJJVKBQDIycnR60nKyclB3759G3yenZ1dvXMelEqlbJIqp1haO+aicWVlZbr/e3h4NPn9Wr9+Pfz9/ZGUlITMzEy9X9bMgzwwD/LBXMiDHPNw6tQpALUfPjUW24wZM/C///u/OHToELZs2aI33LmlkWMuWiNLyIOh8Ru0up05+Pv7Q6VSISEhQbetqKgISUlJGDx4sBkjI2pdtIs22NjYwNbWtsnt3HfffQgMDAQArnRHRNREN2/eBFD7d1JjFAoFnn32WQB/zWMiIsOYtUgqKSlBSkoKUlJSANQu1pCSkoKMjAwoFAq8+uqrWLp0KX755RecPXsWTz/9NHx9fTmulsiEtIs2ODk5QaFQNKutkJAQAEBSUlKz4yIiao20RdLfV7VryLhx42BjY4PU1FRcuXJFytCILIpZi6STJ08iKCgIQUFBAIDo6GgEBQXpuoPnz5+POXPm4Pnnn8fAgQNRUlKCuLg42NvbmzNsolalqct/14dFEhFR8/z5558AgPbt2xt0fJs2bTBixAgAf92AlogaZ3SRFBoaisWLFyMhIaHZN3UdPnw4BEG462vTpk0AaruJ33nnHWRnZ6OiogJ79uxBQEBAs85JRMaRokg6deqUbjEIIiIyTGVlJW7dugXA8J4kAJgwYQIADrkjMobRRVJ4eDiOHTuGqKgouLu748EHH8SiRYsQHx+vN8GbiCyDmEVS165d4eHhgcrKSqSmpja7PSKi1iQzMxMAYG9vjzZt2hj8vPHjx0OhUOD48eO4ceOGVOERWRSji6RFixZh9+7dKCgowL59+/CPf/wDJ0+exCOPPGLUBUtELYOYRZJCoeCQOyKiJqo7H8mYOaIqlQpDhw4FAGzbtk2S2IgsTZPnJF27dg1nz57FmTNnkJqaChcXF0RGRooZGxHJQN2FG8TAIomIqGmMnY9U18SJEwFwyB2RoYwukqZMmYL77rsPQ4YMQVxcHAYNGoRdu3YhLy+Pn04QWSAxe5IAFklERE1l7Mp2dT366KMAgEOHDiEnJ0fUuIgskdFF0nfffQe1Wo3nnnsOM2fOxIwZMxAYGNjspYGJSJ7ELpKCg4MBAL///jvy8/NFaZOIqDVoTk9Sx44dMWDAAAiCgJ9//lns0IgsjtFF0u3bt/H555+jqqoKMTEx8PT0xJAhQ7Bw4ULs3r1bihiJyIzELpLatm2LLl26AABOnDghSptERK1Bc3qSAA65IzKG0UWSh4cHxo0bhxUrViA5ORmpqakICAjABx98wDlJRBZI7CIJ+GvI3fHjx0Vrk4jI0jWnJwn4aynwvXv34s6dO6LFRWSJmtSTFBsbi5dffhl9+vRB9+7dsX37dowdOxYrVqyQIkYiMiOxF24A/iqS2JNERGQ4bU9SU4ukgIAA9OnTB9XV1Xj33XfFDI3I4hhdJHl5eeHFF19EZmYmZsyYgdOnTyMvLw+xsbF45ZVXpIiRiMxI6p4kQRBEa5eIyFLV1NQgKysLQNOH2wHA8uXLAQCrVq1ibz7RPdgY+4TU1FQ88MADUsRCRDIkRZEUGBgIW1tb3L59G9nZ2aK1S0RkqXJzc1FdXQ1ra2uoVKomtxMZGYknn3wS3377LaZPn47k5GTY2tqKGCmRZTC6J4kFElHrIkWRZGdnh6CgIAC1q9wREdG9aYfaqVQqWFtbN6utVatWwdPTE+fOncN7770nRnhEFqdJN5P98ccf8fjjj2PQoEHo16+f3hcRWRYpiiTgryF3LJKIiBrX3EUb6vL09MTHH38MAFi6dCkuXrzY7DaJLI3RRdLq1asxbdo0eHt74/Tp0wgODkbbtm1x7do1rm5HZIGkWLgBAAYNGgSARRIRkSGau/z33z3xxBN45JFHUFVVhenTp0Oj0YjSLpGlMLpI+vTTT7FhwwasWbMGtra2mD9/PuLj4/Hyyy+jsLBQihiJyIyk7klKT09HZWWlqG0TEVkaMXuSAEChUGDdunVwdnZGYmIijhw5Ikq7RJbC6CIpIyMDQ4YMAQA4ODiguLgYAPDUU09hy5Yt4kZHRGYnVZHk7+8PT09PVFdX48yZM6K2TURkacTuSQIAPz8/jBo1CgBw7Ngx0dolsgQGF0mZmZkAaicMam9A1qFDB91FlZ6ezqV8iSyMIAiSFUkKhQLBwcEAeFNZIqLGiN2TpKXt1U9KShK1XaKWzuAiqVevXvj2228xcuRI/PLLLwCAadOm4bXXXsOoUaMwadIkPProo5IFSkSmV1VVherqagDiF0kAMHDgQAAskoiIGiNFTxLAIomoIQbfJ2np0qWYOXMmwsPDdctFzpo1C23btsXRo0cxbtw4vPDCC5IFSkSmp120ARB/4QYAup6kEydOiN42EZGlEARBsp6kAQMGwMrKCjdv3sSff/4pehFG1FIZ3JP00ksvITU1Ffn5+XjggQfw66+/AgAmT56M1atXY86cObwZGZGF0Q61s7Ozg42N0feebpS2J+nq1avIy8sTvX0iIktQUFCAsrIyAOL3JDk7O6NXr14A2JtEVJdRCzf4+/tj7969WLRoESZMmIA+ffrwPklEFkyq+Uha7u7uul/4HHJHRFQ/bS9S27ZtYW9vL3r7HHJHdDejPxq+fv06YmNj4eHhgaioKEk+XSYieZC6SAKAgIAA/Pnnn0hKSsKYMWMkOw8RUUulnY8k9lA7rZCQEGzcuJFFElEdRlU4GzduxNy5cxEWFobz58+jXbt2UsVFRDJgiiKpa9eu2LdvH5efJSJqgFSLNmhpe5JOnjyJmpoaWFtbS3IeopbE4CJp9OjROH78OD755BM8/fTTUsZERDKhXbhBikUbtAICAgDUDrfTaDSwsjL69m1ERBZNqkUbtHr06AFnZ2eUlJTg/Pnz6NOnjyTnIWpJDP5rpKamBqmpqSyQiFoRU/QkderUCfb29igoKMDly5clOw8RUUsldU+StbW1biEdDrkjqmVwkRQfHy/ZJxhEJE+mKJJsbGx0i77wlzMR0d2k7kkCuHgD0d9xXAsRNcgURRLw1/2S+MuZiOhuUvckASySiP6ORRIRNchURRKHeRARNcyUPUnnz59HcXGxZOchailYJBFRg0yxcAPwV0/SmTNnUF5eLum5iIhakvLycty5cweAtEWSj48POnToAEEQcPLkScnOQ9RStIgiae3atbrJ3SEhIbzpJJGJmKonqUOHDvD29kZ1dTVOnz4t6bmIiFoSbS+Sk5MTXF1dJT0Xh9wR/UX2RdL333+P6OhoLFmyBKdOnUJgYCAiIiKQm5tr7tCILJ6piiSFQsFfzkRE9ah7I1mFQiHpufhzmOgvRt1M1hxWrFiBGTNmYNq0aQCA9evXY8eOHfjyyy/xz3/+08zRGefgwYNISUmBra0tbGxk/9ZbtOrqaubCANeuXQMgfZEE1P5y/uWXX7Bz50706tVL8vPRX3g9yAdzIQ9yysP+/fsBSLtog5a2SEpMTER8fLzk5zOEnHLRmomRh7Zt2+pWs20JZP3dVlVVheTkZMTExOi2WVlZISwsDImJifU+p7KyEpWVlbrHRUVFAAC1Wg21Wi1twI144okncOvWLbPGQNQUDg4Oklw/2jbVajX69+8PANizZw/27Nkj+rmIiFoyX19fyf+O6d27N2xsbJCTk4Pw8HBJz0WtT3h4OLZv327uMAy+jmRdJOXl5aGmpgbe3t562729vXHp0qV6n7Ns2TK8/fbbd23fvXs3HB0dJYnTUCqVSvIJ8ERi8/DwgLW1NXbu3CnZOeLj41FdXY2HHnoIN27ckOw8REQtkZ2dHXr16iXpz2GtSZMm4ciRI5Kfh1ofKysrk3wPN6asrMyg4xSCIAgSx9JkmZmZuO+++3D06FEMHjxYt33+/Pk4cOBAvWNm6+tJ8vPzQ15enuQTHhujVqsRHx+PUaNGQalUmjWW1o65kAfmQR6YB/lgLuSBeZAP5kIeLCkPRUVF8PT0RGFh4T1rA1n3JHl6esLa2ho5OTl623NycqBSqep9jp2dHezs7O7arlQqZZNUOcXS2jEX8sA8yAPzIB/MhTwwD/LBXMiDJeTB0PhlXSTZ2tqif//+SEhIwPjx4wEAGo0GCQkJmD17tkFtaDvKtHOTzEmtVqOsrAxFRUUt/huspWMu5IF5kAfmQT6YC3lgHuSDuZAHS8qDtiZobDCdrIskAIiOjsbUqVMxYMAABAcHY9WqVSgtLdWtdtcY7V2j/fz8pAyTiIiIiIhaiOLiYri5uTW4X/ZF0qRJk3Dr1i0sXrwY2dnZ6Nu3L+Li4u5azKEhvr6+uHHjBlxcXCS/v0BjtPOjbty4Yfb5Ua0dcyEPzIM8MA/ywVzIA/MgH8yFPFhSHgRBQHFxMXx9fe95nKwXbrA0RUVFcHNza3SiGEmPuZAH5kEemAf5YC7kgXmQD+ZCHlpjHqzMHQAREREREZGcsEgiIiIiIiKqg0WSCdnZ2WHJkiX1LlFOpsVcyAPzIA/Mg3wwF/LAPMgHcyEPrTEPnJNERERERERUB3uSiIiIiIiI6mCRREREREREVAeLJCIiIiIiojpYJBEREREREdXBIomIiIiIiKgOFklERERERER1sEgiIiIiIiKqg0USERERERFRHSySiIiIiIiI6mCRREREREREVAeLJCIiIiIiojpszB2A1DQaDTIzM+Hi4gKFQmHucIiIiIiIyEwEQUBxcTF8fX1hZdVwf5HFF0mZmZnw8/MzdxhERERERCQTN27cQPv27Rvcb/FFkouLC4DaN8LV1dWssajVauzevRvh4eFQKpVmjaW1Yy7kgXmQB+ZBPpgLeWAe5IO5kAdLykNRURH8/Px0NUJDLL5I0g6xc3V1lUWR5OjoCFdX1xb/DdbSMRfywDzIA/MgH8yFPDAP8sFcyIMl5qGxaThcuIGIiIiIiKgOFklERERERER1sEgiIiIiIiKqw+LnJBERERERtRYajQZVVVWitqlWq2FjY4OKigrU1NSI2rbYlEolrK2tm92OWYukZcuWITY2FpcuXYKDgwOGDBmC9957D926ddMdU1FRgblz5+K7775DZWUlIiIi8Omnn8Lb29uMkRMRERERyUtVVRXS09Oh0WhEbVcQBKhUKty4caNF3HfU3d0dKpWqWbGatUg6cOAAZs2ahYEDB6K6uhoLFy5EeHg4Lly4ACcnJwDAa6+9hh07duCHH36Am5sbZs+ejQkTJuDIkSPmDJ2IiIiISDYEQUBWVhasra3h5+d3zxulGkuj0aCkpATOzs6itis2QRBQVlaG3NxcAICPj0+T2zJrkRQXF6f3eNOmTfDy8kJycjJCQ0NRWFiIL774Aps3b8bIkSMBAF999RV69OiBY8eOYdCgQeYIm6jV2rRpE/773//i888/h6+vr7nDISIiov9TXV2NsrIy+Pr6wtHRUdS2tUP47O3tZV0kAYCDgwMAIDc3F15eXk0eeierOUmFhYUAgDZt2gAAkpOToVarERYWpjume/fu6NChAxITE+stkiorK1FZWal7XFRUBKB2LKVarZYy/EZpz2/uOIi5aKpVq1bhzJkzeOGFF7B169Zmd7kzD/LAPMgHcyEPzIN8MBeGq6yshCAIsLGxkWS4nfZfsduWgr29PQRBQHl5Oezs7PT2Gfq9pBC0r9rMNBoNxo0bh4KCAhw+fBgAsHnzZkybNk2v6AGA4OBgjBgxAu+9995d7bz11lt4++2379q+efNm0atqotZm5syZyM7OBgC8/vrrePDBB80cEREREQGAjY0NVCoV/Pz8YGtra+5wzKqqqgo3btxAdnY2qqur9faVlZVhypQpKCwshKura4NtyKYnadasWTh37pyuQGqqmJgYREdH6x4XFRXBz88P4eHh93wjTEGtViM+Ph6jRo2ymLsVt1TMRdPU/fTo66+/xty5c9G2bdsmt8c8yAPzIB/MhTwwD/LBXBiuoqICN27cgLOzM+zt7UVtWxAEFBcXw8XFpUUs3FBRUQEHBweEhobe9V5oR5k1RhZF0uzZs7F9+3YcPHgQ7du3121XqVSoqqpCQUEB3N3dddtzcnKgUqnqbcvOzu6ubjWgdjlAuVxccoqltWMujFNcXAwA8Pb2Rk5ODhYsWICvv/662e0yD/LAPMgHcyEPzIN8MBeNq6mpgUKhgJWVlejzhrQfkmrblzsrKysoFIp6v28M/T4y6lVqNBrs27cP77zzDqZPn44nnngCL7/8Mr766ivcuHHDmKYA1Fals2fPxrZt27B37174+/vr7e/fvz+USiUSEhJ029LS0pCRkYHBgwcbfT4iarqamhqUl5cDAD7//HMoFAp88803+O2338wcGREREbVECoXinl9vvfWW7thNmzahT58+sLe3h5eXF2bNmiVpbAYVSeXl5Vi6dCn8/PwwZswY7Nq1CwUFBbC2tsaVK1ewZMkS+Pv7Y8yYMTh27JjBJ581axb+93//F5s3b4aLiwuys7ORnZ2t+0PMzc0N06dPR3R0NPbt24fk5GRMmzYNgwcP5sp2RCZWUlKi+/+oUaPw8ssvAwBeeOEFvX1EREREhsjKytJ9rVq1Cq6urnrbXn/9dQDAihUr8MYbb+Cf//wnzp8/jz179iAiIkLS2AwabhcQEIDBgwdj48aNDY4JvX79OjZv3ozJkyfjjTfewIwZMxptd926dQCA4cOH623/6quv8MwzzwAAVq5cCSsrK0ycOFHvZrJEZFraoXZKpRJ2dnZYunQpfvrpJ1y/fh2LFi3CqlWrzBsgERER6WjvGSQGjUaD0tJSWFtbGzTcztHR0aC5S3Wnz7i5uUGhUNw1pSY/Px+LFi3Cr7/+iocffli3vU+fPka8AuMZVCTt3r0bPXr0uOcxHTt2RExMDF5//XVkZGQYdHJDFtazt7fH2rVrsXbtWoPaJCJpaHuLnJ2ddf9u2LABERERWL16NSZNmsRhsERERDJRVlam+51taiUlJXBychKlrfj4eGg0Gvz555/o0aMHiouLMWTIEHz00Ufw8/MT5Rz1MWi4XWMFUl1KpRKdO3duckBEJE/aniQXFxfdtvDwcEydOhWCIOC55567a7l+IiIioua4du0aNBoN/v3vf2PVqlX48ccfcefOHYwaNQpVVVWSndfo1e1SU1Pr3a5QKGBvb48OHTrUu7ocEbVs9RVJQO044V27duHChQtYtmyZ3iRLIiIiMg9HR0fR5gxrNBoUFRXB1dXV4OF2YtFoNFCr1Vi9ejXCw8MBAFu2bIFKpcK+ffskm5tkdJHUt2/fe44xVCqVmDRpEj777DPR12gnIvPRFkl/77pv06YN1qxZg0mTJuHf//43/ud//ge9evUyR4hERET0fxQKhWhD3jQaDWpqauDk5GTyJcB9fHwAAD179tRta9euHTw9PQ2e4tMURr/Kbdu2oWvXrtiwYQNSUlKQkpKCDRs2oFu3bti8eTO++OIL7N27F4sWLZIiXiIyE+2nUX/vSQKAxx57DFFRUVCr1Zg+fbreTWeJiIiImmro0KEAam8DpHXnzh3k5eWhY8eOkp3X6J6kd999Fx9//LFe11bv3r3Rvn17vPnmmzh+/DicnJwwd+5cfPjhh6IGS0Tm09BwO6D206pPP/0UCQkJOH78OE6ePIng4GBTh0hEREQWJiAgAFFRUXjllVewYcMGuLq6IiYmBt27d8eIESMkO6/RPUlnz56tt2rr2LEjzp49C6B2SF5WVlbzoyMi2bhXkQQAvr6+CA0NBQCj7pdGREREdC/ffPMNQkJC8Mgjj2DYsGFQKpWIi4ur97ZEYjG6SOrevTuWL1+ut5qEWq3G8uXL0b17dwDAn3/+CW9vb/GiJCKz+/sS4PUJCQkBACQlJZkkJiIiIrIMzzzzDAoKCurd5+rqii+++AL5+fm4ffs2YmNjJV3+G2jCcLu1a9di3LhxaN++ve4mTmfPnkVNTQ22b98OoHapvpdeekncSInIrBrrSQKAQYMGAWCRRERERC2b0UXSkCFDkJ6ejm+//Ra///47gNpJ21OmTNH98fTUU0+JGyURmZ0hRZJ2HtLVq1eRl5cHT09Pk8RGREREJCajiySg9o+kmTNnih0LEclYQ0uA1+Xu7o5u3bohLS0Nx48fx5gxY0wVHhEREZFomrTQ+X/+8x88+OCD8PX1xfXr1wEAK1euxM8//yxqcEQkH/daArwuzksiIiKils7oImndunWIjo5GZGQk8vPzUVNTAwDw8PDAqlWrxI6PiGTCkOF2AIskIiIicxIEwdwhmJ0Y74HRRdKaNWuwceNGvPHGG7Cx+Wu03oABA3RLgBOR5TG2SDp+/DhvKktERGQi1tbWAKC3AnVrVVZWBgDNWiLc6DlJ6enpCAoKumu7nZ0dSktLmxwIEcmbIUuAA0CfPn1gb2+P/Px8XL58Gd26dTNFeERERK2ajY0NHB0dcevWLSiVSlhZNWlWTb00Gg2qqqpQUVEhartiEwQBZWVlyM3Nhbu7u65wbAqjiyR/f3+kpKTcdUPZuLg49OjRo8mBEJG8GdqTpFQq0a9fPxw9ehRJSUkskoiIiExAoVDAx8cH6enpujUDxCIIAsrLy+Hg4ACFQiFq21Jwd3eHSqVqVhtGF0nR0dGYNWsWKioqIAgCjh8/ji1btmDZsmX4/PPPmxUMEcmXoUUSUDvkTlskPf3001KHRkRERABsbW3RtWtX0YfcqdVqHDx4EKGhoc0awmYKSqWyWT1IWkYXSc899xwcHBywaNEilJWVYcqUKfD19cXHH3+MyZMnNzsgIpIfjUajG07b2HA7gIs3EBERmYuVlRXs7e1FbdPa2hrV1dWwt7eXfZEklibdJ+nJJ5/Ek08+ibKyMpSUlMDLy0vsuIhIRurONzS0JwkAzpw5o+ueJyIiImopmjTzKi8vDydPnsTFixdF6c4iInnTDrWztrY26NOpjh07wsvLC9XV1Th9+rTU4RERERGJyqgi6fz58wgNDYW3tzdCQkIQHBwMLy8vjBw5EmlpaVLFSERmpi2SnJ2dDZqwqVAoOOSOiIiIWiyDi6Ts7GwMGzYMt27dwooVK7Bz507s2LEDH3zwAbKysvDQQw8hNzdXyliJyEy0y38bMtROi0USERERtVQGz0lauXIlOnbsiCNHjugNtxk9ejRefPFFPPjgg1i5ciWWLVsmSaBEZD7GrGynxSKJiIiIWiqDe5Li4+OxYMGCeucjODg4YN68efjtt99EDY6I5KEpRdLAgQOhUCjwxx9/4ObNm1KFRkRERCQ6g4uka9euoV+/fg3uHzBgAK5duyZKUEQkL3XnJBnKzc0NgwYNAgD89NNPUoRFREREJAmDi6Ti4mK4uro2uN/FxUU3b4GILEtT5iQBwMSJEwEAsbGxosdEREREJBWjVrcrLi5GUVFRg1+CIEgVJxGZUVOG2wHAhAkTAAAHDhzArVu3RI+LiIiISAoGF0mCICAgIAAeHh71fnXr1k3KOInIjJoy3A4A/P39ERQUBI1Gg19++UWK0IiIiIhEZ/Dqdvv27ZMyDiKSsaYOtwNqh9ydPn0aW7duxfTp08UOjYiIiEh0BhdJw4YNE/3kBw8exAcffIDk5GRkZWVh27ZtGD9+vG6/IAhYsmQJNm7ciIKCAgwdOhTr1q1D165dRY+FiBrW1OF2QO2Qu0WLFmHPnj0oKCiAu7u7yNERERERicug4XalpaVGNWro8aWlpQgMDMTatWvr3f/+++9j9erVWL9+PZKSkuDk5ISIiAhUVFQYFQ8RNU9ziqQePXqgR48eUKvV2LFjh9ihEREREYnOoCKpS5cuWL58ObKysho8RhAExMfHIzIyEqtXrzbo5JGRkVi6dCkeffTRettbtWoVFi1ahKioKPTp0wfffPMNMjMzuZwwkYk1dU6SlnYBh61bt4oWExEREZFUDBput3//fixcuBBvvfUWAgMDMWDAAPj6+sLe3h75+fm4cOECEhMTYWNjg5iYGLzwwgvNDiw9PR3Z2dkICwvTbXNzc0NISAgSExMxefLkep9XWVmJyspK3eOioiIAgFqthlqtbnZczaE9v7njIObCWNoiycHBoUnv2bhx4/Duu+8iLi4OBQUFcHJyAsA8yAXzIB/MhTwwD/LBXMiDJeXB0NdgUJHUrVs3bN26FRkZGfjhhx9w6NAhHD16FOXl5fD09ERQUBA2btyIyMhIWFtbNytwrezsbACAt7e33nZvb2/dvvosW7YMb7/99l3bd+/eDUdHR1Fia674+Hhzh0D/h7kwzM2bNwEAly5dws6dO41+viAI8Pb2Rk5ODpYtW4YhQ4bo7Wce5IF5kA/mQh6YB/lgLuTBEvJQVlZm0HEGL9wAAB06dMDcuXMxd+7cJgVlCjExMYiOjtY9Lioqgp+fH8LDw+95M1xTUKvViI+Px6hRo6BUKs0aS2vHXBhn3rx5AIARI0bgoYcealIbU6ZMwcqVK3H9+nUsXboUAPMgF8yDfDAX8sA8yAdzIQ+WlAftKLPGGFUkmZJKpQIA5OTkwMfHR7c9JycHffv2bfB5dnZ2sLOzu2u7UqmUTVLlFEtrx1wYRrsYi4eHR5Pfr8ceewwrV67Ezp07odFo9K5T5kEemAf5YC7kgXmQD+ZCHiwhD4bGb/DNZE3N398fKpUKCQkJum1FRUVISkrC4MGDzRgZUevTnNXttEJCQuDr64vi4mLs2bNHrNCIiIiIRGfWIqmkpAQpKSlISUkBULtYQ0pKCjIyMqBQKPDqq69i6dKl+OWXX3D27Fk8/fTT8PX11buXEhFJSxAE3c1km7q6HQBYWVnpVrLkKndEREQkZ2Ytkk6ePImgoCAEBQUBAKKjoxEUFITFixcDAObPn485c+bg+eefx8CBA1FSUoK4uDjY29ubM2yiVqWsrAyCIABoXk8SAEycOBEA8PPPP6O6urrZsRERERFJwaxzkoYPH67746s+CoUC77zzDt555x0TRkVEdWmH2llZWTV7hciHHnoIbdu2xe3bt3HgwAGEhoaKESIRERGRqIzuSQoNDcXixYuRkJCAiooKKWIiIhmpeyNZhULRrLZsbGx0w2VjY2ObGxoRERGRJIwuksLDw3Hs2DFERUXB3d0dDz74IBYtWoT4+HiD1x0nopajbpEkBu2Qu23btkGj0YjSJhEREZGYjB5ut2jRIgBAdXU1Tpw4gQMHDmD//v14//33YWVlxd4lIgujXbShufORtEaOHAlXV1dkZWXh2LFjorRJREREJKYmL9xw7do1nD17FmfOnEFqaipcXFwQGRkpZmxEJANiLP9dl52dHcaOHQsA+Omnn0Rpk4iIiEhMRhdJU6ZMwX333YchQ4YgLi4OgwYNwq5du5CXl4dt27ZJESMRmZHYw+0A/SF391q8hYiIiMgcjB5u991338HT0xPPPfccRo4ciQcffLDZK14RkXyJPdwOACIiIuDo6Ijr16/j6tWrorVLREREJAaje5Ju376Nzz//HFVVVYiJiYGnpyeGDBmChQsXYvfu3VLESERmJPZwOwBwdHTUDc/lvCQiIiKSG6OLJA8PD4wbNw4rVqxAcnIyUlNTERAQgA8++IBzkogskBTD7QBgwoQJAFgkERERkfwYPdxOexPI/fv3Y//+/bhw4QLc3d0xduxYDBs2TIoYiciMpOhJAqD7UOXmzZsoLCyEp6enqO0TERERNZXRRZKXlxc8PT3x0EMPYcaMGRg+fDh69+4tRWxEJANSzEkCanulfXx8kJWVhbS0NBZJREREJBtGF0mpqal44IEHpIiFiGRIqp4kAOjRoweysrJw6dIlDB06VPT2iYiIiJrC6DlJLJCIWhep5iQBQPfu3QEAFy5cEL1tIiIioqYyuicJAH788Uf897//RUZGBqqqqvT2nTp1SpTAiEgepBpuB/xVJF26dEn0tomIiIiayuiepNWrV2PatGnw9vbG6dOnERwcjLZt2+LatWtc3Y7IAkk93A4A0tLSRG+biIiIqKmMLpI+/fRTbNiwAWvWrIGtrS3mz5+P+Ph4vPzyyygsLJQiRiIyI1MMt7t27RrKy8tFb5+IiIioKYwukjIyMjBkyBAAgIODg+4PqKeeegpbtmwRNzoiMjspe5K8vLzg7OwMQRDw+++/i94+ERERUVMYXCRlZmYCAFQqFe7cuQMA6NChg+5GkOnp6RAEQYIQicicpJyTpFAo4OfnBwC4ePGi6O0TERERNYXBRVKvXr3w7bffYuTIkfjll18AANOmTcNrr72GUaNGYdKkSXj00UclC5SITE8QBEl7kgCgffv2ALjCHREREcmHwavbLV26FDNnzkR4eDjee+89AMCsWbPQtm1bHD16FOPGjcMLL7wgWaBEZHrl5eXQaDQApJmTBPxVJLEniYiIiOTC4J6kl156CampqcjPz8cDDzyAX3/9FQAwefJkrF69GnPmzIGtra1kgRKR6WmH2gGAk5OTJOfgcDsiIiKSG6Puk+Tv74+9e/fik08+wYQJE9CjRw/Y2Og3wfskEVmOuivbWVkZvc6LQbQ9Sb///juqq6vv+plCREREZGpG/zVy/fp1xMbGwsPDA1FRUfyDhsiCSbn8t5anpyccHR1RVlaGq1evolu3bpKdi4iIiMgQRlU4GzduxNy5cxEWFobz58+jXbt2UsVFRDIg9aINAGBlZYXu3bvj1KlTuHjxIoskIiIiMjuDx8+MHj0aCxYswCeffILY2FgWSEStgJTLf9elvaksV7gjIiIiOTC4J6mmpgapqam6+QNEZPlMMdwO+KtI4uINREREJAcGF0nx8fFSxkFEMmSK4XYA0KNHDwAskoiIiEgepFmuiogsgqmH2128eFF3XyYiIiIic2GRREQNMlVPUufOnaFUKlFWVoYbN25Iei4iIiKixrSIImnt2rXo1KkT7O3tERISguPHj5s7JKJWwVRzkmxsbBAQEACAQ+6IiIjI/GRfJH3//feIjo7GkiVLcOrUKQQGBiIiIgK5ubnmDo3I4pmqJwn4a14SV7gjIiIic5N9kbRixQrMmDED06ZNQ8+ePbF+/Xo4Ojriyy+/NHdoRBbPVHOSAC7eQERERPJh1M1kTa2qqgrJycmIiYnRbbOyskJYWBgSExPrfU5lZSUqKyt1j4uKigAAarUaarVa2oAbsWDBAly8eBE7duyAlZXs61OLptFocOPGDeaiEUeOHAEAODg4SHL9aNtUq9W64XZxcXGYOXOm6OeihvF6kA/mQh6YB/lgLuRBjDz06NEDL730ksiRGc/Qv2dkXSTl5eWhpqYG3t7eetu9vb1x6dKlep+zbNkyvP3223dt3717NxwdHSWJ01BffvklCgsLzRoDUVNkZmZi586dkrUfHx+vuzZu3ryJzz77TLJzERERkekFBQWhU6dO5g4DZWVlBh0n6yKpKWJiYhAdHa17XFRUBD8/P4SHh8PV1dWMkQHz58/H2bNn0blzZ34aYmYajQZXr15lLgygUqnwzDPPQKlUit62Wq1GfHw8Ro0aBaVSCQ8PjwY/ACHp8HqQD+ZCHpgH+WAu5EGMPNx///0YM2aMyJEZTzvKrDGyLpI8PT1hbW2NnJwcve05OTlQqVT1PsfOzg52dnZ3bVcqlZL8kWeMefPmYefOnRgzZozZY2nt1Go1cyEj2utzypQp5g6lVeL1IB/MhTwwD/LBXMiDJeXB0PhlXZLb2tqif//+SEhI0G3TaDRISEjA4MGDzRgZERERERFZKln3JAFAdHQ0pk6digEDBiA4OBirVq1CaWkppk2bZtDzBUEAYHjXmpTUajXKyspQVFTU4qvwlo65kAfmQR6YB/lgLuSBeZAP5kIeLCkP2ppAWyM0RPZF0qRJk3Dr1i0sXrwY2dnZ6Nu3L+Li4u5azKEh2vu8+Pn5SRkmERERERG1EMXFxXBzc2twv0JorIxq4TQaDTIzM+Hi4gKFQmHWWLSLSNy4ccPsi0i0dsyFPDAP8sA8yAdzIQ/Mg3wwF/JgSXkQBAHFxcXw9fW95yIUsu9Jai4rKyu0b9/e3GHocXV1bfHfYJaCuZAH5kEemAf5YC7kgXmQD+ZCHiwlD/fqQdKS9cINREREREREpsYiiYiIiIiIqA4WSSZkZ2eHJUuW1HsfJzIt5kIemAd5YB7kg7mQB+ZBPpgLeWiNebD4hRuIiIiIiIiMwZ4kIiIiIiKiOlgkERERERER1cEiiYiIiIiIqA4WSURERERERHWwSDKhtWvXolOnTrC3t0dISAiOHz9u7pAs2ltvvQWFQqH31b17d93+iooKzJo1C23btoWzszMmTpyInJwcM0ZsGQ4ePIixY8fC19cXCoUCP/30k95+QRCwePFi+Pj4wMHBAWFhYbh8+bLeMXfu3MGTTz4JV1dXuLu7Y/r06SgpKTHhq7AMjeXimWeeuesaGT16tN4xzEXzLVu2DAMHDoSLiwu8vLwwfvx4pKWl6R1jyM+jjIwMPPLII3B0dISXlxfmzZuH6upqU76UFs2QPAwfPvyua2LmzJl6xzAPzbNu3Tr06dNHd1PSwYMHY9euXbr9vBZMp7FctPbrgUWSiXz//feIjo7GkiVLcOrUKQQGBiIiIgK5ubnmDs2iPfDAA8jKytJ9HT58WLfvtddew6+//ooffvgBBw4cQGZmJiZMmGDGaC1DaWkpAgMDsXbt2nr3v//++1i9ejXWr1+PpKQkODk5ISIiAhUVFbpjnnzySZw/fx7x8fHYvn07Dh48iOeff95UL8FiNJYLABg9erTeNbJlyxa9/cxF8x04cACzZs3CsWPHEB8fD7VajfDwcJSWluqOaeznUU1NDR555BFUVVXh6NGj+Prrr7Fp0yYsXrzYHC+pRTIkDwAwY8YMvWvi/fff1+1jHpqvffv2WL58OZKTk3Hy5EmMHDkSUVFROH/+PABeC6bUWC6AVn49CGQSwcHBwqxZs3SPa2pqBF9fX2HZsmVmjMqyLVmyRAgMDKx3X0FBgaBUKoUffvhBt+3ixYsCACExMdFEEVo+AMK2bdt0jzUajaBSqYQPPvhAt62goECws7MTtmzZIgiCIFy4cEEAIJw4cUJ3zK5duwSFQiH8+eefJovd0vw9F4IgCFOnThWioqIafA5zIY3c3FwBgHDgwAFBEAz7ebRz507ByspKyM7O1h2zbt06wdXVVaisrDTtC7AQf8+DIAjCsGHDhFdeeaXB5zAP0vDw8BA+//xzXgsyoM2FIPB6YE+SCVRVVSE5ORlhYWG6bVZWVggLC0NiYqIZI7N8ly9fhq+vL+6//348+eSTyMjIAAAkJydDrVbr5aR79+7o0KEDcyKh9PR0ZGdn673vbm5uCAkJ0b3viYmJcHd3x4ABA3THhIWFwcrKCklJSSaP2dLt378fXl5e6NatG1588UXcvn1bt4+5kEZhYSEAoE2bNgAM+3mUmJiI3r17w9vbW3dMREQEioqK9D71JcP9PQ9a3377LTw9PdGrVy/ExMSgrKxMt495EFdNTQ2+++47lJaWYvDgwbwWzOjvudBqzdeDjbkDaA3y8vJQU1Oj900EAN7e3rh06ZKZorJ8ISEh2LRpE7p164asrCy8/fbbeOihh3Du3DlkZ2fD1tYW7u7ues/x9vZGdna2eQJuBbTvbX3XgnZfdnY2vLy89Pbb2NigTZs2zI3IRo8ejQkTJsDf3x9Xr17FwoULERkZicTERFhbWzMXEtBoNHj11VcxdOhQ9OrVCwAM+nmUnZ1d73Wj3UfGqS8PADBlyhR07NgRvr6+SE1NxYIFC5CWlobY2FgAzINYzp49i8GDB6OiogLOzs7Ytm0bevbsiZSUFF4LJtZQLgBeDyySyGJFRkbq/t+nTx+EhISgY8eO+O9//wsHBwczRkYkD5MnT9b9v3fv3ujTpw86d+6M/fv34+GHHzZjZJZr1qxZOHfunN78SDK9hvJQd75d79694ePjg4cffhhXr15F586dTR2mxerWrRtSUlJQWFiIH3/8EVOnTsWBAwfMHVar1FAuevbs2eqvBw63MwFPT09YW1vftTpLTk4OVCqVmaJqfdzd3REQEIArV65ApVKhqqoKBQUFescwJ9LSvrf3uhZUKtVdC5pUV1fjzp07zI3E7r//fnh6euLKlSsAmAuxzZ49G9u3b8e+ffvQvn173XZDfh6pVKp6rxvtPjJcQ3moT0hICADoXRPMQ/PZ2tqiS5cu6N+/P5YtW4bAwEB8/PHHvBbMoKFc1Ke1XQ8skkzA1tYW/fv3R0JCgm6bRqNBQkKC3rhPklZJSQmuXr0KHx8f9O/fH0qlUi8naWlpyMjIYE4k5O/vD5VKpfe+FxUVISkpSfe+Dx48GAUFBUhOTtYds3fvXmg0Gt0PaJLGzZs3cfv2bfj4+ABgLsQiCAJmz56Nbdu2Ye/evfD399fbb8jPo8GDB+Ps2bN6RWt8fDxcXV11Q2Po3hrLQ31SUlIAQO+aYB7Ep9FoUFlZyWtBBrS5qE+rux7MvXJEa/Hdd98JdnZ2wqZNm4QLFy4Izz//vODu7q63IgiJa+7cucL+/fuF9PR04ciRI0JYWJjg6ekp5ObmCoIgCDNnzhQ6dOgg7N27Vzh58qQwePBgYfDgwWaOuuUrLi4WTp8+LZw+fVoAIKxYsUI4ffq0cP36dUEQBGH58uWCu7u78PPPPwupqalCVFSU4O/vL5SXl+vaGD16tBAUFCQkJSUJhw8fFrp27So88cQT5npJLda9clFcXCy8/vrrQmJiopCeni7s2bNH6Nevn9C1a1ehoqJC1wZz0Xwvvvii4ObmJuzfv1/IysrSfZWVlemOaeznUXV1tdCrVy8hPDxcSElJEeLi4oR27doJMTEx5nhJLVJjebhy5YrwzjvvCCdPnhTS09OFn3/+Wbj//vuF0NBQXRvMQ/P985//FA4cOCCkp6cLqampwj//+U9BoVAIu3fvFgSB14Ip3SsXvB4EgUWSCa1Zs0bo0KGDYGtrKwQHBwvHjh0zd0gWbdKkSYKPj49ga2sr3HfffcKkSZOEK1eu6PaXl5cLL730kuDh4SE4OjoKjz76qJCVlWXGiC3Dvn37BAB3fU2dOlUQhNplwN98803B29tbsLOzEx5++GEhLS1Nr43bt28LTzzxhODs7Cy4uroK06ZNE4qLi83walq2e+WirKxMCA8PF9q1aycolUqhY8eOwowZM+764Ia5aL76cgBA+Oqrr3THGPLz6I8//hAiIyMFBwcHwdPTU5g7d66gVqtN/GparsbykJGRIYSGhgpt2rQR7OzshC5dugjz5s0TCgsL9dphHprn2WefFTp27CjY2toK7dq1Ex5++GFdgSQIvBZM6V654PUgCApBEATT9VsRERERERHJG+ckERERERER1cEiiYiIiIiIqA4WSURERERERHWwSCIiIiIiIqqDRRIREREREVEdLJKIiIiIiIjqYJFERERERERUB4skIqJWbv/+/VAoFCgoKGhWO8888wzGjx8vSkxitiXnc3/xxRcIDw83ybnqs379eowdO9Zs5ycikisWSUREFmL9+vVwcXFBdXW1bltJSQmUSiWGDx+ud6y2MLp69SqGDBmCrKwsuLm5SRqf9pwKhQJWVlZwc3NDUFAQ5s+fj6ysLL1jP/74Y2zatEnSeP744w8oFAqkpKSY/NwAUFFRgTfffBNLlizRbXvrrbd075GNjQ08PT0RGhqKVatWobKyUvQYnn32WZw6dQqHDh0SvW0iopaMRRIRkYUYMWIESkpKcPLkSd22Q4cOQaVSISkpCRUVFbrt+/btQ4cOHdC5c2fY2tpCpVJBoVCYJM60tDRkZmbixIkTWLBgAfbs2YNevXrh7NmzumPc3Nzg7u7eYBtVVVWSxdfYucXy448/wtXVFUOHDtXb/sADDyArKwsZGRnYt28fHnvsMSxbtgxDhgxBcXGxqDHY2tpiypQpWL16tajtEhG1dCySiIgsRLdu3eDj44P9+/frtu3fvx9RUVHw9/fHsWPH9LaPGDFC9/+6w+02bdoEd3d3/Pbbb+jRowecnZ0xevRovd6empoaREdHw93dHW3btsX8+fMhCIJBcXp5eUGlUiEgIACTJ0/GkSNH0K5dO7z44ou6Y/4+5G348OGYPXs2Xn31VXh6eiIiIgIAcO7cOURGRsLZ2Rne3t546qmnkJeXp3ueRqPB+++/jy5dusDOzg4dOnTAu+++CwDw9/cHAAQFBUGhUOh62/5+7srKSrz88svw8vKCvb09HnzwQZw4cULvvVQoFEhISMCAAQPg6OiIIUOGIC0t7Z7vw3fffVfvUDcbGxuoVCr4+vqid+/emDNnDg4cOIBz587hvffe04vr9ddfx3333QcnJyeEhITo5R4ANm7cCD8/Pzg6OuLRRx/FihUr7ioAx44di19++QXl5eX3jJeIqDVhkUREZEFGjBiBffv26R7v27cPw4cPx7Bhw3Tby8vLkZSUpCuS6lNWVoYPP/wQ//nPf3Dw4EFkZGTg9ddf1+3/6KOPsGnTJnz55Zc4fPgw7ty5g23btjUpZgcHB8ycORNHjhxBbm5ug8d9/fXXsLW1xZEjR7B+/XoUFBRg5MiRCAoKwsmTJxEXF4ecnBw8/vjjuufExMRg+fLlePPNN3HhwgVs3rwZ3t7eAIDjx48DAPbs2YOsrCzExsbWe9758+dj69at+Prrr3Hq1Cl06dIFERERuHPnjt5xb7zxBj766COcPHkSNjY2ePbZZ+/5ug8fPowBAwYY9B51794dkZGRejHOnj0biYmJ+O6775CamorHHnsMo0ePxuXLlwEAR44cwcyZM/HKK68gJSUFo0aN0hWIdQ0YMADV1dVISkoyKBYiolZBICIii7Fx40bByclJUKvVQlFRkWBjYyPk5uYKmzdvFkJDQwVBEISEhAQBgHD9+nVBEARh3759AgAhPz9fEARB+OqrrwQAwpUrV3Ttrl27VvD29tY99vHxEd5//33dY7VaLbRv316IiopqMLa/n6euXbt2CQCEpKQkQRAEYerUqXptDRs2TAgKCtJ7zr/+9S8hPDxcb9uNGzcEAEJaWppQVFQk2NnZCRs3bqw3nvT0dAGAcPr0ab3tdc9dUlIiKJVK4dtvv9Xtr6qqEnx9fXWvX/u69uzZoztmx44dAgChvLy83nPn5+cLAISDBw/qbV+yZIkQGBhY73MWLFggODg4CIIgCNevXxesra2FP//8U++Yhx9+WIiJiREEQRAmTZokPPLII3r7n3zyScHNze2utj08PIRNmzbVe14iotbIxlzFGRERiW/48OEoLS3FiRMnkJ+fj4CAALRr1w7Dhg3DtGnTUFFRgf379+P+++9Hhw4dGmzH0dERnTt31j328fHR9fIUFhYiKysLISEhuv02NjYYMGCAwUPu/k77vHvNi+rfv7/e4zNnzmDfvn1wdna+69irV6+ioKAAlZWVePjhh5sUk7YdtVqtN29IqVQiODgYFy9e1Du2T58+uv/7+PgAAHJzc+t9n7VD2+zt7Q2ORRAE3ftz9uxZ1NTUICAgQO+YyspKtG3bFkDt3K9HH31Ub39wcDC2b99+V9sODg4oKyszOBYiIkvHIomIyIJ06dIF7du3x759+5Cfn49hw4YBAHx9feHn54ejR49i3759GDly5D3bUSqVeo8VCkWTCyBDaAuOTp06NXiMk5OT3uOSkhKMHTtWb56Olo+PD65duyZqjI2p+55pixmNRlPvsW3btoVCoUB+fr7B7V+8eFE3j6qkpATW1tZITk6GtbW13nH1FY2NuXPnDtq1a2f084iILBXnJBERWZgRI0Zg//792L9/v97S36Ghodi1axeOHz9+z/lIjXFzc4OPj4/eHJbq6mokJyc3qb3y8nJs2LABoaGhRv2h3q9fP5w/fx6dOnVCly5d9L6cnJzQtWtXODg4ICEhod7n29raAqhdhKIh2tX/jhw5otumVqtx4sQJ9OzZ0+BY6zt3z549ceHCBYOOv3TpEuLi4jBx4kQAtYtN1NTUIDc3967XrlKpANQu5FF3gQkAdz0GanvLKioqEBQU1OTXQ0RkaVgkERFZmBEjRuDw4cNISUnR9SQBwLBhw/DZZ5+hqqqqWUUSALzyyitYvnw5fvrpJ1y6dAkvvfSSwTejzc3NRXZ2Ni5fvozvvvsOQ4cORV5eHtatW2dUDLNmzcKdO3fwxBNP4MSJE7h69Sp+++03TJs2DTU1NbC3t8eCBQswf/58fPPNN7h69SqOHTuGL774AkDtKnsODg66BR8KCwvvOoeTkxNefPFFzJs3D3Fxcbhw4QJmzJiBsrIyTJ8+3ah4/y4iIgKHDx++a3t1dTWys7ORmZmJs2fPYs2aNRg2bBj69u2LefPmAQACAgLw5JNP4umnn0ZsbCzS09Nx/PhxLFu2DDt27AAAzJkzBzt37sSKFStw+fJlfPbZZ9i1a9ddQxoPHTqE+++/X294JRFRa8ciiYjIwowYMQLl5eXo0qWLbiU3oLZIKi4u1i0V3hxz587FU089halTp2Lw4MFwcXG5a/5LQ7p16wZfX1/0798fy5cvR1hYGM6dO2d0z4yvry+OHDmCmpoahIeHo3fv3nj11Vfh7u4OK6vaX29vvvkm5s6di8WLF6NHjx6YNGmSbm6VjY0NVq9ejc8++wy+vr6Iioqq9zzLly/HxIkT8dRTT6Ffv364cuUKfvvtN3h4eBgV799Nnz4dO3fuvKs4O3/+PHx8fNChQwcMHz4c//3vfxETE4NDhw7pDaX76quv8PTTT2Pu3Lno1q0bxo8fjxMnTujmQA0dOhTr16/HihUrEBgYiLi4OLz22mt3zYPasmULZsyY0azXQkRkaRSClIPMiYiIqEGPPfYY+vXrh5iYGJOcb8aMGbh06RIOHToEoLYgGzlyJH7//Xe4ubmZJAYiopaAPUlERERm8sEHHzRpoQVDffjhhzhz5gyuXLmCNWvW4Ouvv8bUqVN1+7OysvDNN9+wQCIi+hv2JBEREVmoxx9/HPv370dxcTHuv/9+zJkzBzNnzjR3WEREssciiYiIiIiIqA4OtyMiIiIiIqqDRRIREREREVEdLJKIiIiIiIjqYJFERERERERUB4skIiIiIiKiOlgkERERERER1cEiiYiIiIiIqA4WSURERERERHWwSCIiIiIiIqrj/wOflxp0OvlYWQAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -867,8 +930,8 @@ "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", + "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", diff --git a/docs/operation_models_user.ipynb b/docs/operation_models_user.ipynb new file mode 100644 index 000000000..aaaae3f87 --- /dev/null +++ b/docs/operation_models_user.ipynb @@ -0,0 +1,523 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "ac224ce9-bd4f-4f5c-88b7-f0e9e49ee498", + "metadata": {}, + "source": [ + "# Turbine Operation Models\n", + "\n", + "Separate from the turbine models, which define the physical characterstics of the turbines, FLORIS\n", + "allows users to specify how the turbine behaves in terms of producing power and thurst. We refer to \n", + "different models for turbine behavior as \"operation models\". A key feature of operation models is\n", + "the ability for users to specify control setpoints at which the operation model will be evaluated. \n", + "For instance, some operation models allow users to specify `yaw_angles`, which alter the power \n", + "being produced by the turbine along with it's thrust force on flow.\n", + "\n", + "Operation models are specified by the `operation_model` key on the turbine yaml file, or by using\n", + "the `set_operation_model()` method on `FlorisModel`. Each operation model available in FLORIS is\n", + "described and demonstrated below. The simplest operation model is the `\"simple\"` operation model,\n", + "which takes no control setpoints and simply evaluates the power and thrust coefficient curves for \n", + "the turbine at the current wind condition. The default operation model is the `\"cosine-loss\"`\n", + "operation model, which models the loss in power of a turbine under yaw misalignment using a cosine\n", + "term with an exponent.\n", + "\n", + "We first provide a quick demonstration of how to switch between different operation models. Then, \n", + "each operation model available in FLORIS is described, along with its relevant control setpoints.\n", + "We also describe the different parameters that must be specified in the turbine \n", + "`\"power_thrust_table\"` dictionary in order to use that operation model." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "71788b47-6641-4080-bb3f-eb799d969e0b", + "metadata": {}, + "source": [ + "## Selecting the operation model\n", + "\n", + "There are two options for selecting the operation model:\n", + "1. Manually changing the `\"operation_model\"` field of the turbine input yaml \n", + "(see [Turbine Input File Reference](input_reference_turbine))\n", + "\n", + "2. Using `set_operation_model()` on an instantiated `FlorisModel` object.\n", + "\n", + "The following code demonstrates the use of the second option." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2275840e-48a3-41d2-ace9-fad05da0dc02", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "simple operation model powers [kW]: [[1753.95445918 436.4427005 506.66815478]]\n", + "cosine-loss operation model powers [kW]: [[1561.31837381 778.04338242 651.77709894]]\n" + ] + }, + { + "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 import FlorisModel\n", + "from floris import layout_visualization as layoutviz\n", + "\n", + "fmodel = FlorisModel(\"../examples/inputs/gch.yaml\")\n", + "\n", + "# Look at layout\n", + "ax = layoutviz.plot_turbine_rotors(fmodel)\n", + "layoutviz.plot_turbine_labels(fmodel, ax=ax)\n", + "ax.set_xlabel(\"x [m]\")\n", + "ax.set_ylabel(\"y [m]\")\n", + "\n", + "# Set simple operation model\n", + "fmodel.set_operation_model(\"simple\")\n", + "\n", + "# Evalaute the model and extract the power output\n", + "fmodel.run()\n", + "print(\"simple operation model powers [kW]: \", fmodel.get_turbine_powers() / 1000)\n", + "\n", + "# Set the yaw angles (which the \"simple\" operation model does not use\n", + "# and change the operation model to \"cosine-loss\"\n", + "fmodel.set(yaw_angles=[[20., 0., 0.]])\n", + "fmodel.set_operation_model(\"cosine-loss\")\n", + "ax = layoutviz.plot_turbine_rotors(fmodel)\n", + "layoutviz.plot_turbine_labels(fmodel, ax=ax)\n", + "ax.set_xlabel(\"x [m]\")\n", + "ax.set_ylabel(\"y [m]\")\n", + "\n", + "# Evaluate again\n", + "fmodel.run()\n", + "powers_cosine_loss = fmodel.get_turbine_powers()\n", + "print(\"cosine-loss operation model powers [kW]: \", fmodel.get_turbine_powers() / 1000)\n" + ] + }, + { + "cell_type": "markdown", + "id": "5d22f376", + "metadata": {}, + "source": [ + "## Operation model library" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "f2576e8a-47ee-48b5-8707-aca0dc76929c", + "metadata": {}, + "source": [ + "### Simple model\n", + "User-level name: `\"simple\"`\n", + "\n", + "Underlying class: `SimpleTurbine`\n", + "\n", + "Required data on `power_thrust_table`:\n", + "- `ref_air_density` (scalar)\n", + "- `ref_tilt` (scalar)\n", + "- `wind_speed` (list)\n", + "- `power` (list)\n", + "- `thrust_coefficient` (list)\n", + "\n", + "The `\"simple\"` operation model describes the \"normal\" function of a wind turbine, as described by\n", + "its power curve and thrust coefficient. It does not respond to any control setpoints, and is most \n", + "often used as a baseline or for users wanting to evaluate wind farms in nominal operation." + ] + }, + { + "cell_type": "markdown", + "id": "ced1e091", + "metadata": {}, + "source": [ + "### Cosine loss model\n", + "User-level name: `\"cosine-loss\"`\n", + "\n", + "Underlying class: `CosineLossTurbine`\n", + "\n", + "Required data on `power_thrust_table`:\n", + "- `ref_air_density` (scalar)\n", + "- `ref_tilt` (scalar)\n", + "- `wind_speed` (list)\n", + "- `power` (list)\n", + "- `thrust_coefficient` (list)\n", + "- `cosine_loss_exponent_yaw` (scalar)\n", + "- `cosine_loss_exponent_tilt` (scalar)\n", + "\n", + "The `\"cosine-loss\"` operation model describes the decrease in power and thrust produced by a \n", + "wind turbine as it yaws (or tilts) away from the incoming wind. The thrust is reduced by a factor of \n", + "$\\cos \\gamma$, where $\\gamma$ is the yaw misalignment angle, while the power is reduced by a factor \n", + "of $(\\cos\\gamma)^{p_P}$, where $p_P$ is the cosine loss exponent, specified by `cosine_loss_exponent_yaw`\n", + "(or `cosine_loss_exponent_tilt` for tilt angles). The power and thrust produced by the turbine\n", + "thus vary as a function of the turbine's yaw angle, set using the `yaw_angles` argument to \n", + "`FlorisModel.set()`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b9a5f00a-0ead-4759-b911-3a1161e55791", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Power [kW]')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from floris import TimeSeries\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Set up the FlorisModel\n", + "fmodel.set_operation_model(\"cosine-loss\")\n", + "fmodel.set(layout_x=[0.0], layout_y=[0.0])\n", + "fmodel.set(\n", + " wind_data=TimeSeries(\n", + " wind_speeds=np.ones(100) * 8.0,\n", + " wind_directions=np.ones(100) * 270.0,\n", + " turbulence_intensities=0.06\n", + " )\n", + ")\n", + "fmodel.reset_operation()\n", + "\n", + "# Sweep the yaw angles\n", + "yaw_angles = np.linspace(-25, 25, 100)\n", + "fmodel.set(yaw_angles=yaw_angles.reshape(-1,1))\n", + "fmodel.run()\n", + "\n", + "powers = fmodel.get_turbine_powers()/1000\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.plot(yaw_angles, powers)\n", + "ax.grid()\n", + "ax.set_xlabel(\"Yaw angle [deg]\")\n", + "ax.set_ylabel(\"Power [kW]\")" + ] + }, + { + "cell_type": "markdown", + "id": "019abca6", + "metadata": {}, + "source": [ + "### Simple derating model\n", + "User-level name: `\"simple-derating\"`\n", + "\n", + "Underlying class: `SimpleDeratingTurbine`\n", + "\n", + "Required data on `power_thrust_table`:\n", + "- `ref_air_density` (scalar)\n", + "- `ref_tilt` (scalar)\n", + "- `wind_speed` (list)\n", + "- `power` (list)\n", + "- `thrust_coefficient` (list)\n", + "\n", + "The `\"simple-derating\"` operation model enables users to derate turbines by setting a new power \n", + "rating. It does not require any extra parameters on the `power_thrust_table`, but adescribes the \n", + "decrease in power and thrust produced by providing the `power_setpoints` argument to\n", + "`FlorisModel.set()`. The default power rating for the turbine can be acheived by setting the\n", + "appropriate entries of `power_setpoints` to `None`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "722be425-9231-451a-bd84-7824db6a5098", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/msinner/floris3/floris/core/turbine/operation_models.py:367: RuntimeWarning: divide by zero encountered in divide\n", + " power_fractions = power_setpoints / base_powers\n", + "/Users/msinner/floris3/floris/core/wake_deflection/gauss.py:323: RuntimeWarning: invalid value encountered in divide\n", + " val = 2 * (avg_v - v_core) / (v_top + v_bottom)\n", + "/Users/msinner/floris3/floris/core/wake_deflection/gauss.py:158: RuntimeWarning: invalid value encountered in divide\n", + " C0 = 1 - u0 / freestream_velocity\n", + "/Users/msinner/floris3/floris/core/wake_velocity/gauss.py:80: RuntimeWarning: invalid value encountered in divide\n", + " sigma_z0 = rotor_diameter_i * 0.5 * np.sqrt(uR / (u_initial + u0))\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Power [kW]')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set up the FlorisModel\n", + "fmodel.set_operation_model(\"simple-derating\")\n", + "fmodel.reset_operation()\n", + "wind_speeds = np.linspace(0, 30, 100)\n", + "fmodel.set(\n", + " wind_data=TimeSeries(\n", + " wind_speeds=wind_speeds,\n", + " wind_directions=np.ones(100) * 270.0,\n", + " turbulence_intensities=0.06\n", + " )\n", + ")\n", + "\n", + "fig, ax = plt.subplots()\n", + "for power_setpoint in [5.0, 4.0, 3.0, 2.0]:\n", + " fmodel.set(power_setpoints=np.array([[power_setpoint*1e6]]*100))\n", + " fmodel.run()\n", + " powers = fmodel.get_turbine_powers()/1000\n", + " ax.plot(wind_speeds, powers[:,0], label=f\"Power setpoint (MW): {power_setpoint}\")\n", + "\n", + "ax.grid()\n", + "ax.legend()\n", + "ax.set_xlabel(\"Wind speed [m/s]\")\n", + "ax.set_ylabel(\"Power [kW]\")" + ] + }, + { + "cell_type": "markdown", + "id": "4caca5fa", + "metadata": {}, + "source": [ + "### Mixed operation model\n", + "User-level name: `\"mixed\"`\n", + "\n", + "Underlying class: `MixedOperationTurbine`\n", + "\n", + "Required data on `power_thrust_table`:\n", + "- `ref_air_density` (scalar)\n", + "- `ref_tilt` (scalar)\n", + "- `wind_speed` (list)\n", + "- `power` (list)\n", + "- `thrust_coefficient` (list)\n", + "- `cosine_loss_exponent_yaw` (scalar)\n", + "- `cosine_loss_exponent_tilt` (scalar)\n", + "\n", + "The `\"mixed\"` operation model allows users to specify _either_ `yaw_angles` (evaluated using the \n", + "`\"cosine-loss\"` operation model) _or_ `power_setpoints` (evaluated using the `\"simple-derating\"`\n", + "operation model). That is, for each turbine, and at each `findex`, a non-zero yaw angle or a \n", + "non-`None` power setpoint may be specified. However, specifying both a non-zero yaw angle and a \n", + "finite power setpoint for the same turbine and at the same `findex` will produce an error." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5e3cda81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Powers [kW]: [[3063.49046772 2000. ]]\n" + ] + } + ], + "source": [ + "fmodel.set_operation_model(\"mixed\")\n", + "fmodel.set(layout_x=[0.0, 0.0], layout_y=[0.0, 500.0])\n", + "fmodel.reset_operation()\n", + "fmodel.set(\n", + " wind_data=TimeSeries(\n", + " wind_speeds=np.array([10.0]),\n", + " wind_directions=np.array([270.0]),\n", + " turbulence_intensities=0.06\n", + " )\n", + ")\n", + "fmodel.set(\n", + " yaw_angles=np.array([[20.0, 0.0]]),\n", + " power_setpoints=np.array([[None, 2e6]])\n", + ")\n", + "fmodel.run()\n", + "print(\"Powers [kW]: \", fmodel.get_turbine_powers()/1000)" + ] + }, + { + "cell_type": "markdown", + "id": "c036feda", + "metadata": {}, + "source": [ + "### AWC model\n", + "\n", + "User-level name: `\"awc\"`\n", + "\n", + "Underlying class: `AWCTurbine`\n", + "\n", + "Required data on `power_thrust_table`:\n", + "- `ref_air_density` (scalar)\n", + "- `ref_tilt` (scalar)\n", + "- `wind_speed` (list)\n", + "- `power` (list)\n", + "- `thrust_coefficient` (list)\n", + "- `helix_a` (scalar)\n", + "- `helix_power_b` (scalar)\n", + "- `helix_power_c` (scalar)\n", + "- `helix_thrust_b` (scalar)\n", + "- `helix_thrust_c` (scalar)\n", + "\n", + "The `\"awc\"` operation model allows for users to define _active wake control_ strategies. These strategies \n", + "use pitch control to actively enhance wake mixing and subsequently decrease wake velocity deficits. As a \n", + "result, downstream turbines can increase their power production, with limited power loss for the controlled \n", + "upstream turbine. The `AWCTurbine` class models this power loss at the turbine applying AWC. For each \n", + "turbine, the user can define an AWC strategy to implement through the `awc_modes` array. Note that currently, \n", + "only `\"baseline\"`, i.e., no AWC, and `\"helix\"`, i.e., the \n", + "[counterclockwise helix method](https://doi.org/10.1002/we.2513) have been implemented. \n", + "\n", + "The user then defines the exact AWC implementation through setting the variable `awc_amplitudes` for \n", + "each turbine. This variable defines the mean-to-peak amplitude of the sinusoidal AWC pitch excitation,\n", + "i.e., for a turbine that under `awc_modes = \"baseline\"` has a constant pitch angle of 0 degrees, setting \n", + "`awc_amplitude = 2` results in a pitch signal varying from -2 to 2 degrees over the desired Strouhal\n", + "frequency. This Strouhal frequency is not used as an input here, since it has minimal influence on turbine \n", + "power production. Note that setting `awc_amplitudes = 0` effectively disables AWC and is therefore the same \n", + "as running a turbine at `awc_modes = \"baseline\"`.\n", + "\n", + "Each example turbine input file `floris/turbine_library/*.yaml` has its own `helix_*` parameter data. These \n", + "parameters are determined by fitting data from `OpenFAST` simulations in region II to the following equation:\n", + "\n", + "$$\n", + " P_\\text{AWC} = P_\\text{baseline} \\cdot (1 - (b + c \\cdot P_\\text{baseline} ) \\cdot A_\\text{AWC}^a)\n", + "$$\n", + "\n", + "where $a$ is `\"helix_a\"`, $b$ is `\"helix_power_b\"`, $c$ is `\"helix_power_c\"`, and $A_\\text{AWC}$ is `awc_amplitudes`. \n", + "The thrust coefficient follows the same equation, but with the respective thrust parameters. When AWC is \n", + "turned on while $P_\\text{baseline} > P_\\text{rated}$, a warning is given as the model is not yet tuned for region III.\n", + "\n", + "The figure below shows the fit between the turbine power and thrust in OpenFAST helix AWC simulations (x) \n", + "and FLORIS simulations (--) at different region II wind speeds for the NREL 5MW reference turbine.\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "40e9bcda", + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'awc'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[5], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[43mfmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset_operation_model\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mawc\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m 2\u001b[0m fmodel\u001b[38;5;241m.\u001b[39mset(layout_x\u001b[38;5;241m=\u001b[39m[\u001b[38;5;241m0.0\u001b[39m, \u001b[38;5;241m0.0\u001b[39m], layout_y\u001b[38;5;241m=\u001b[39m[\u001b[38;5;241m0.0\u001b[39m, \u001b[38;5;241m500.0\u001b[39m])\n\u001b[0;32m 3\u001b[0m fmodel\u001b[38;5;241m.\u001b[39mreset_operation()\n", + "File \u001b[1;32m~\\projects\\floris\\floris\\floris_model.py:1306\u001b[0m, in \u001b[0;36mFlorisModel.set_operation_model\u001b[1;34m(self, operation_model)\u001b[0m\n\u001b[0;32m 1304\u001b[0m turbine_type \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcore\u001b[38;5;241m.\u001b[39mfarm\u001b[38;5;241m.\u001b[39mturbine_definitions[\u001b[38;5;241m0\u001b[39m]\n\u001b[0;32m 1305\u001b[0m turbine_type[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moperation_model\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m operation_model\n\u001b[1;32m-> 1306\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mset\u001b[49m\u001b[43m(\u001b[49m\u001b[43mturbine_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43mturbine_type\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\projects\\floris\\floris\\floris_model.py:347\u001b[0m, in \u001b[0;36mFlorisModel.set\u001b[1;34m(self, wind_speeds, wind_directions, wind_shear, wind_veer, reference_wind_height, turbulence_intensities, air_density, layout_x, layout_y, turbine_type, turbine_library_path, solver_settings, heterogenous_inflow_config, wind_data, yaw_angles, power_setpoints, disable_turbines)\u001b[0m\n\u001b[0;32m 345\u001b[0m _yaw_angles \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcore\u001b[38;5;241m.\u001b[39mfarm\u001b[38;5;241m.\u001b[39myaw_angles\n\u001b[0;32m 346\u001b[0m _power_setpoints \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcore\u001b[38;5;241m.\u001b[39mfarm\u001b[38;5;241m.\u001b[39mpower_setpoints\n\u001b[1;32m--> 347\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_reinitialize\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m 348\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_speeds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_speeds\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 349\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_directions\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_directions\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 350\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_shear\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_shear\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 351\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_veer\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_veer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 352\u001b[0m \u001b[43m \u001b[49m\u001b[43mreference_wind_height\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mreference_wind_height\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 353\u001b[0m \u001b[43m \u001b[49m\u001b[43mturbulence_intensities\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mturbulence_intensities\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 354\u001b[0m \u001b[43m \u001b[49m\u001b[43mair_density\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mair_density\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 355\u001b[0m \u001b[43m \u001b[49m\u001b[43mlayout_x\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlayout_x\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 356\u001b[0m \u001b[43m \u001b[49m\u001b[43mlayout_y\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mlayout_y\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 357\u001b[0m \u001b[43m \u001b[49m\u001b[43mturbine_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mturbine_type\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 358\u001b[0m \u001b[43m \u001b[49m\u001b[43mturbine_library_path\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mturbine_library_path\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 359\u001b[0m \u001b[43m \u001b[49m\u001b[43msolver_settings\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msolver_settings\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 360\u001b[0m \u001b[43m \u001b[49m\u001b[43mheterogenous_inflow_config\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheterogenous_inflow_config\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 361\u001b[0m \u001b[43m \u001b[49m\u001b[43mwind_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwind_data\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m 362\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 364\u001b[0m \u001b[38;5;66;03m# If the yaw angles or power setpoints are not the default, set them back to the\u001b[39;00m\n\u001b[0;32m 365\u001b[0m \u001b[38;5;66;03m# previous setting\u001b[39;00m\n\u001b[0;32m 366\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m (_yaw_angles \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m)\u001b[38;5;241m.\u001b[39mall():\n", + "File \u001b[1;32m~\\projects\\floris\\floris\\floris_model.py:230\u001b[0m, in \u001b[0;36mFlorisModel._reinitialize\u001b[1;34m(self, wind_speeds, wind_directions, wind_shear, wind_veer, reference_wind_height, turbulence_intensities, air_density, layout_x, layout_y, turbine_type, turbine_library_path, solver_settings, heterogenous_inflow_config, wind_data)\u001b[0m\n\u001b[0;32m 227\u001b[0m floris_dict[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfarm\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m farm_dict\n\u001b[0;32m 229\u001b[0m \u001b[38;5;66;03m# Create a new instance of floris and attach to self\u001b[39;00m\n\u001b[1;32m--> 230\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcore \u001b[38;5;241m=\u001b[39m \u001b[43mCore\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfloris_dict\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\projects\\floris\\floris\\type_dec.py:226\u001b[0m, in \u001b[0;36mFromDictMixin.from_dict\u001b[1;34m(cls, data)\u001b[0m\n\u001b[0;32m 221\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m undefined:\n\u001b[0;32m 222\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\n\u001b[0;32m 223\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe class definition for \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 224\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mis missing the following inputs: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mundefined\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 225\u001b[0m )\n\u001b[1;32m--> 226\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m:13\u001b[0m, in \u001b[0;36m__init__\u001b[1;34m(self, logging, solver, wake, farm, flow_field, name, description, floris_version)\u001b[0m\n\u001b[0;32m 11\u001b[0m _setattr(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mdescription\u001b[39m\u001b[38;5;124m'\u001b[39m, __attr_converter_description(description))\n\u001b[0;32m 12\u001b[0m _setattr(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfloris_version\u001b[39m\u001b[38;5;124m'\u001b[39m, __attr_converter_floris_version(floris_version))\n\u001b[1;32m---> 13\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__attrs_post_init__\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\projects\\floris\\floris\\core\\core.py:75\u001b[0m, in \u001b[0;36mCore.__attrs_post_init__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 69\u001b[0m logging_manager\u001b[38;5;241m.\u001b[39mconfigure_file_log(\n\u001b[0;32m 70\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlogging[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfile\u001b[39m\u001b[38;5;124m\"\u001b[39m][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124menable\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[0;32m 71\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlogging[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfile\u001b[39m\u001b[38;5;124m\"\u001b[39m][\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlevel\u001b[39m\u001b[38;5;124m\"\u001b[39m],\n\u001b[0;32m 72\u001b[0m )\n\u001b[0;32m 74\u001b[0m \u001b[38;5;66;03m# Initialize farm quantities that depend on other objects\u001b[39;00m\n\u001b[1;32m---> 75\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfarm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconstruct_turbine_map\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 76\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfarm\u001b[38;5;241m.\u001b[39mconstruct_turbine_thrust_coefficient_functions()\n\u001b[0;32m 77\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfarm\u001b[38;5;241m.\u001b[39mconstruct_turbine_axial_induction_functions()\n", + "File \u001b[1;32m~\\projects\\floris\\floris\\core\\farm.py:262\u001b[0m, in \u001b[0;36mFarm.construct_turbine_map\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 261\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mconstruct_turbine_map\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m--> 262\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mturbine_map \u001b[38;5;241m=\u001b[39m [\u001b[43mTurbine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_dict\u001b[49m\u001b[43m(\u001b[49m\u001b[43mturb\u001b[49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mfor\u001b[39;00m turb \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mturbine_definitions]\n", + "File \u001b[1;32m~\\projects\\floris\\floris\\type_dec.py:226\u001b[0m, in \u001b[0;36mFromDictMixin.from_dict\u001b[1;34m(cls, data)\u001b[0m\n\u001b[0;32m 221\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m undefined:\n\u001b[0;32m 222\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mAttributeError\u001b[39;00m(\n\u001b[0;32m 223\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe class definition for \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 224\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mis missing the following inputs: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mundefined\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m 225\u001b[0m )\n\u001b[1;32m--> 226\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m:24\u001b[0m, in \u001b[0;36m__init__\u001b[1;34m(self, turbine_type, rotor_diameter, hub_height, TSR, power_thrust_table, operation_model, correct_cp_ct_for_tilt, floating_tilt_table, multi_dimensional_cp_ct, power_thrust_data_file, turbine_library_path)\u001b[0m\n\u001b[0;32m 22\u001b[0m __attr_validator_floating_tilt_table(\u001b[38;5;28mself\u001b[39m, __attr_floating_tilt_table, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfloating_tilt_table)\n\u001b[0;32m 23\u001b[0m __attr_validator_turbine_library_path(\u001b[38;5;28mself\u001b[39m, __attr_turbine_library_path, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mturbine_library_path)\n\u001b[1;32m---> 24\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__attrs_post_init__\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[1;32m~\\projects\\floris\\floris\\core\\turbine\\turbine.py:461\u001b[0m, in \u001b[0;36mTurbine.__attrs_post_init__\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 460\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__attrs_post_init__\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m--> 461\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_initialize_power_thrust_functions\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m 462\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__post_init__()\n", + "File \u001b[1;32m~\\projects\\floris\\floris\\core\\turbine\\turbine.py:472\u001b[0m, in \u001b[0;36mTurbine._initialize_power_thrust_functions\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 471\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_initialize_power_thrust_functions\u001b[39m(\u001b[38;5;28mself\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m--> 472\u001b[0m turbine_function_model \u001b[38;5;241m=\u001b[39m \u001b[43mTURBINE_MODEL_MAP\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43moperation_model\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moperation_model\u001b[49m\u001b[43m]\u001b[49m\n\u001b[0;32m 473\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mthrust_coefficient_function \u001b[38;5;241m=\u001b[39m turbine_function_model\u001b[38;5;241m.\u001b[39mthrust_coefficient\n\u001b[0;32m 474\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39maxial_induction_function \u001b[38;5;241m=\u001b[39m turbine_function_model\u001b[38;5;241m.\u001b[39maxial_induction\n", + "\u001b[1;31mKeyError\u001b[0m: 'awc'" + ] + } + ], + "source": [ + "fmodel.set_operation_model(\"awc\")\n", + "fmodel.set(layout_x=[0.0, 0.0], layout_y=[0.0, 500.0])\n", + "fmodel.reset_operation()\n", + "fmodel.set(\n", + " wind_data=TimeSeries(\n", + " wind_speeds=np.array([10.0]),\n", + " wind_directions=np.array([270.0]),\n", + " turbulence_intensities=0.06\n", + " )\n", + ")\n", + "fmodel.set(\n", + " awc_modes=np.array([\"helix\", \"baseline\"]),\n", + " awc_amplitudes=np.array([2.5, 0])\n", + ")\n", + "fmodel.run()\n", + "print(\"Powers [kW]: \", fmodel.get_turbine_powers()/1000)" + ] + }, + { + "cell_type": "markdown", + "id": "25f9c86c", + "metadata": {}, + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/powerthrust_helix.png b/docs/powerthrust_helix.png new file mode 100644 index 000000000..36cf1184b Binary files /dev/null and b/docs/powerthrust_helix.png differ diff --git a/docs/turbine_interaction.ipynb b/docs/turbine_interaction.ipynb index 6df40578e..bbc74fb0a 100644 --- a/docs/turbine_interaction.ipynb +++ b/docs/turbine_interaction.ipynb @@ -89,14 +89,12 @@ "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" } ], @@ -114,19 +112,17 @@ "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" } ], "source": [ - "ti.plot_Ct_curve()" + "ti.plot_thrust_coefficient_curve()" ] }, { @@ -171,14 +167,12 @@ "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" } ], @@ -199,19 +193,17 @@ "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" } ], "source": [ - "ti_md.plot_Ct_curve(\n", + "ti_md.plot_thrust_coefficient_curve(\n", " legend_kwargs={\"fontsize\": 6}, # The labels are quite long, so let's shrink the font\n", ")" ] @@ -234,7 +226,7 @@ "\n", "### Loading the libraries\n", "\n", - "Loading a turbine library is either a 2 or more step process depending on how many turbine libraries\n", + "Loading a turbine library is a 2 or more step process depending on how many turbine libraries\n", "are going to be compared." ] }, @@ -250,7 +242,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "iea_15MW\n", "iea_15MW_multi_dim_cp_ct\n", "nrel_5MW\n", "iea_10MW\n", @@ -262,8 +253,8 @@ "# Initialize the turbine library (no definitions required!)\n", "tl = TurbineLibrary()\n", "\n", - "# Load the internal library, except the 20 MW turbine\n", - "tl.load_internal_library(exclude=[\"x_20MW.yaml\"])\n", + "# Load the internal library, except the IEA 15MW turbine\n", + "tl.load_internal_library(exclude=[\"iea_15MW.yaml\"])\n", "for turbine in tl.turbine_map:\n", " print(turbine)" ] @@ -295,17 +286,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "iea_15MW\n", "iea_15MW_multi_dim_cp_ct\n", "nrel_5MW\n", "iea_10MW\n", "iea_15MW_floating\n", - "x_20MW\n" + "iea_15MW\n" ] } ], "source": [ - "tl.load_internal_library(which=[\"x_20MW.yaml\"])\n", + "tl.load_internal_library(which=[\"iea_15MW.yaml\"])\n", "for turbine in tl.turbine_map:\n", " print(turbine)" ] @@ -316,7 +306,7 @@ "id": "bac88742-33af-44f3-a35b-e178e60a49d3", "metadata": {}, "source": [ - "Notice that the \"x_20MW\" turbine is now loaded.\n", + "Notice that the \"iea_15MW\" turbine is now loaded.\n", "\n", "### Comparing turbines\n", "\n", @@ -338,14 +328,12 @@ "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" } ], @@ -389,26 +377,39 @@ "name": "stdout", "output_type": "stream", "text": [ - " Turbine | Rotor Diameter (m) | Hub Height (m) | Air Density (ρ)\n", - "---------------------------------------------------------------------------------\n", - " iea_15MW | 242.24 | 150.0 | 1.225\n", - " iea_15MW_multi_dim_cp_ct | 242.24 | 150.0 | 1.225\n", - " nrel_5MW | 126.00 | 90.0 | 1.225\n", - " iea_10MW | 198.00 | 119.0 | 1.225\n", - " iea_15MW_floating | 242.24 | 150.0 | 1.225\n", - " x_20MW | 252.00 | 165.0 | 1.225\n" + " Turbine | Rotor Diameter (m) | Hub Height (m) | TSR | Air Density (ρ) | Tilt (º)\n", + "-----------------------------------------------------------------------------------------------------\n", + " iea_15MW_multi_dim_cp_ct | 242.24 | 150.0 | 8.0 | 1.225 | 6.000\n", + " nrel_5MW | 125.88 | 90.0 | 8.0 | 1.225 | 5.000\n", + " iea_10MW | 198.00 | 119.0 | 8.0 | 1.225 | 6.000\n", + " iea_15MW_floating | 242.24 | 150.0 | 8.0 | 1.225 | 6.000\n", + " iea_15MW | 242.24 | 150.0 | 8.0 | 1.225 | 6.000\n" ] } ], "source": [ - "header = f\"{'Turbine':>25} | Rotor Diameter (m) | Hub Height (m) | Air Density (ρ)\"\n", + "header = f\"\\\n", + "{'Turbine':>25} | \\\n", + "{'Rotor Diameter (m)':>18} | \\\n", + "{'Hub Height (m)':>14} | \\\n", + "{'TSR':>6} | \\\n", + "{'Air Density (ρ)':>15} | \\\n", + "{'Tilt (º)':>8}\\\n", + "\"\n", "print(header)\n", "print(\"-\" * len(header))\n", "for name, t in tl.turbine_map.items():\n", " print(f\"{name:>25}\", end=\" | \")\n", " print(f\"{t.turbine.rotor_diameter:>18,.2f}\", end=\" | \")\n", " print(f\"{t.turbine.hub_height:>14,.1f}\", end=\" | \")\n", - " print(f\"{t.turbine.ref_density_cp_ct:>15,.3f}\")" + " print(f\"{t.turbine.TSR:>6,.1f}\", end=\" | \")\n", + " if t.turbine.multi_dimensional_cp_ct:\n", + " condition_keys = list(t.turbine.power_thrust_table.keys())\n", + " print(f\"{t.turbine.power_thrust_table[condition_keys[0]]['ref_air_density']:>15,.3f}\", end=\" | \")\n", + " print(f\"{t.turbine.power_thrust_table[condition_keys[0]]['ref_tilt']:>8,.3f}\")\n", + " else:\n", + " print(f\"{t.turbine.power_thrust_table['ref_air_density']:>15,.3f}\", end=\" | \")\n", + " print(f\"{t.turbine.power_thrust_table['ref_tilt']:>8,.3f}\")" ] } ], diff --git a/docs/v3_to_v4.md b/docs/v3_to_v4.md new file mode 100644 index 000000000..acb2ced0d --- /dev/null +++ b/docs/v3_to_v4.md @@ -0,0 +1,193 @@ +# Switching from FLORIS v3 to v4 + +There are several major changes introduced in FLORIS v4. The largest underlying change is that, +where FLORIS v3 had a "wind directions" and a "wind speeds" dimension to its internal data +structures, FLORIS v4 collapses these into a single dimension, which we refer to as the `findex` +dimension. This dimension contains each "configuration" or "condition" to be run, and is +conceptually similar to running FLORIS v3 in `time_series` mode. At the user interface level, the +largest implication of this change is that users must specify `wind_directions`, `wind_speeds`, and +`turbulence_intensities` (new) as arrays of equal length; and these are "zipped" to create the +conditions for FLORIS to run, rather than creating a grid of all combinations. This is discussed +further in [Setting and Running](#setting-and-running). + +## Setting and running + +In FLORIS v3, users interacted with FLORIS by instantiating a `FlorisInterface` object, nominally +called `fi`. The notion here is that the users "interface" with the underlying FLORIS code using +`fi`. For FLORIS v4, we acknowledge that to most users, this main "interface" object, for all +intents and purposes, _is FLORIS_. We therefore have renamed the `FlorisInterface` the +`FlorisModel`, nominally instantiated as `fmodel`. To instantiate a `FlorisModel`, the code is +very similar to before, i.e. +```python +from floris import FlorisModel + +fmodel = FlorisModel("input_file.yaml") +``` + +Previously, to set the atmospheric conditions on `fi`, users called the `reinitialize()` method; +and to run the calculations, as well as provide any control setpoints such as yaw angles, users +generally called `calculate_wake()`. Some of the other methods on `FlorisInterface` also called +`calculate_wake()` internally, most notably `get_farm_AEP()`. + +For FLORIS v4, we have changed from the (`reinitialize()`, `calculate_wake()`) paradigm to a new +pair of methods (`set()`, `run()`). `set()` is similar to the retired `reinitialize()` method, and +`run()` is similar to the retired `calculate_wake()` method. However, there are some important +differences: +- `FlorisModel.set()` accepts both atmospheric conditions _and_ control setpoints. +- `FlorisModel.run()` accept no arguments. Its sole function is to run the FLORIS calculation. +- Control setpoints are now "remembered". Previously, if control setpoints (`yaw_angles`) were +passed to `calculate_wake()`, they were discarded at the end of the calculation. In FLORIS v4, the +control setpoints passed to `set()` are stored, and invoking `run()` multiple times will continue to +use those control setpoints. +- To "forget" previously provided control setpoints, use the new method +`FlorisModel.reset_operation()`. +- When providing arguments to `set()`, all arguments much have the same length, as they will be +"paired" (rather than gridded) for the computation. For instance, if the user provides `n_findex` +wind directions, they _must_ provide `n_findex` wind speeds and `n_findex` turbulence intensities; +as well as `n_findex`x`n_turbines` yaw angles, if yaw angles are being used. +- Providing varying `turbulence_intensities` is new for FLORIS v4. +- To facilitate "easier" use of the `set()` method (for instance, to run all combinations of +wind directions and wind speeds), we now provide `WindData` objects that can be passed directly to +`set()`'s `wind_data` keyword argument. See [Wind data](#wind-data) as well as +[Wind Data Objects](wind_data_user) for more information. +- `calculate_no_wake()` has been replaced with `run_no_wake()` +- `get_farm_AEP()` no longer calls `run()`; to compute the farm AEP, users should `run()` the +`fmodel` themselves before calling `get_farm_AEP()`. + +An example workflow for using `set` and `run` is: +```python +import numpy as np +from floris import FlorisModel + +fmodel = FlorisModel("input_file.yaml") # Input file with 3 turbines + +# Set up a base case and run +fmodel.set( + wind_directions=np.array([270., 270.]), + wind_speeds=np.array([8.0, 8.0]), + turbulence_intensities=np.array([0.06, 0.06]) +) +fmodel.run() +turbine_powers_base = fmodel.get_turbine_powers() + +# Provide yaw angles +fmodel.set( + yaw_angles=np.array([[10.0, 0.0, 0.0], [20.0, 0.0, 0.0]]) # n_findex x n_turbines +) +fmodel.run() +turbine_powers_yawed = fmodel.get_turbine_powers() + +# If we run again, this time with no wake, the provided yaw angles will still be used +fmodel.run_no_wake() +turbine_powers_yawed_nowake = fmodel.get_turbine_powers() + +# To "forget" the yaw angles, we use the reset_operation method +fmodel.reset_operation() +fmodel.run_no_wake() +turbine_powers_base_nowake = fmodel.get_turbine_powers() +``` + +For more advanced users, it is best to group many conditions into single calls of `set` and `run` +than to step through various conditions individually, as this will make the best use of FLORIS's +vectorization capabilities. + +## Input files +As in FLORIS v3, there are two main input files to FLORIS v4: +1. The "main" FLORIS input yaml, which contains wake model parameters and wind farm data +2. The "turbine" input yaml, which contains data about the wind turbines + +Examples for main FLORIS input yamls are in examples/inputs/. Default turbine yamls, which many +users +may use if they do not have their own turbine models to use, can be found in +floris/turbine_library/. +See also [Turbine Library Interface](input_reference_turbine) and +[Main Input File Reference](input_reference_main). + +Conceptually, both the main FLORIS input yaml and the turbine input yaml is much the same in v4 as +in v3. However, there are a few changes to the fields on each that mean that existing yamls for v3 +will not run in v4 as is. + +#### Main FLORIS input yaml +The only change in fields on the main FLORIS input file is that the `turbulence_intensity` field, +which was specified as a scalar in FLORIS v3, has been changed to `turbulence_intensities`, and +should now contain a list of turbulence intensities that is of the same length as `wind_directions` +and `wind_speeds`. Additionally, the length of the lists for `wind_directions` and `wind_speeds` +_must_ now be of equal length. + +#### Turbine input yaml +To reflect the transition to more flexible [operation models](#operation-model), there are a +number of changes to the fields on the turbine yaml. The changes are mostly regrouping and +renaming of the existing fields. +- The `power_thrust_table` field now has `wind_speed` and `power` fields, as before; however, +the `thrust` field has been renamed `thrust_coefficient` for clarity, and the `power` field now +specifies the turbine _absolute_ power (in kW) rather than the _power coefficient_. +- Additionally, any extra parameters and data required by operation models to evaluate the power +and thrust curves have been moved onto the `power_thrust_table` field. This includes +`ref_density_cp_ct` (renamed `ref_air_density` and moved onto the `power_thrust_table`); +`ref_tilt_cp_ct` (renamed `ref_tilt` and moved onto the `power_thrust_table`); and `pP` and `pT` +(renamed `cosine_loss_exponent_yaw` and `cosine_loss_exponent_tilt`, respectively, and moved onto +the `power_thrust_table`). +- The `generator_efficiency` field has been removed. The `power` field on `power_thrust_table` +should reflect the electrical power produced by the turbine, including any losses. +- A new field `operation_model` has been added, whose value should be a string that selects the +operation model the user would like to evaluate. The default is `"cosine-loss"`, +which recovers FLORIS v3-type turbine operation. See [Operation model](#operation-model) and +[Turbine Operation Models](operation_models_user) for details. + +### Converting v3 yamls to v4 +To aid users in converting their existing v3 main FLORIS input yamls and turbine input, we provide +two utilities: +- floris/tools/convert_floris_input_v3_to_v4.py +- floris/tools/convert_turbine_v3_to_v4.py + +These can be executed from the command line and expect to be passed the exiting v3 yaml as an input; +the will then write a new v4-compatible yaml of the same name but appended _v4. +```bash +python convert_floris_input_v3_to_v4.py your_v3_input_file.yaml +python convert_floris_turbine_v3_to_v4.py your_v3_turbine_file.yaml +``` + +Additionally, a function for building a turbine dictionary that can be passed directly to the +`turbine_type` argument of `FlorisModel.set()` is provided: +```python +from floris.turbine_library.turbine_utilities import build_cosine_loss_turbine_dict +``` + +### Reference turbine updates +The power and thrust curves for the NREL 5MW, IEA 10MW, and IEA 15MW turbines have been updated +slightly do reflect publicly available data. The x_20MW reference turbine has been removed, as data +was not readily available. See [Turbine Library Interface](turbine_interaction). + +## Wind data +To aid users in setting the wind conditions they are interested in running, we provide "wind data" +classes, which can be passed directly to `FlorisModel.set()`'s `wind_data` keyword argument in place +of `wind_directions`, `wind_speeds`, and `turbulence_intensities`. The wind data objects enable, +for example, gridding inputs (`WindRose` and `WindTIRose`) and broadcasting a scalar-valued +turbulence intensity (`TimeSeries`). +```python +import numpy as np +from floris import FlorisModel +from floris import TimeSeries + +fmodel = FlorisModel("input_file.yaml") # Input file with 3 turbines + +time_series = TimeSeries( + wind_directions=np.array([270.0, 270.0]), + wind_speeds=8.0, + turbulence_intensities=0.06 +) +fmodel.set(wind_data=time_series) +fmodel.set(wind_data=time_series)turbine_powers_base = fmodel.get_turbine_powers() +turbine_powers = fmodel.get_turbine_powers() +``` + +More information about the various wind data classes can be found at +[Wind Data Objects](wind_data_user). + +## Operation model +FLORIS v4 allows for significantly more flexible turbine operation via +[Turbine Operation Models](operation_models_user). These allow users to specify how a turbine loses +power when yaw misaligned; how a turbine operates when derated; and how turbines produce power +and thrust when operating with active wake mixing strategies. The default operation model is the +`"cosine-loss"` model, which models a turbine's power loss when in yaw misalignment using the same +cosine model as was hardcoded in FLORIS v3. diff --git a/docs/wake_models.ipynb b/docs/wake_models.ipynb index ddaced065..669d172ad 100644 --- a/docs/wake_models.ipynb +++ b/docs/wake_models.ipynb @@ -58,23 +58,25 @@ "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from floris.tools import FlorisInterface\n", - "import floris.tools.visualization as wakeviz\n", + "from floris import FlorisModel\n", + "import floris.flow_visualization as flowviz\n", + "import floris.layout_visualization as layoutviz\n", "\n", "NREL5MW_D = 126.0\n", "\n", "def model_plot(inputfile):\n", " fig, axes = plt.subplots(1, 1, figsize=(10, 10))\n", - " fi = FlorisInterface(inputfile)\n", - " fi.reinitialize(layout_x=np.array([0.0, 2*NREL5MW_D]), layout_y=np.array([0.0, 2*NREL5MW_D]))\n", - " yaw_angles = np.zeros((1, 1, 2))\n", - " yaw_angles[:,:,0] = 20.0\n", - " horizontal_plane = fi.calculate_horizontal_plane(\n", - " height=90.0,\n", - " yaw_angles=yaw_angles\n", + " yaw_angles = np.zeros((1, 2))\n", + " yaw_angles[:,0] = 20.0\n", + " fmodel = FlorisModel(inputfile)\n", + " fmodel.set(\n", + " layout_x=np.array([0.0, 2*NREL5MW_D]),\n", + " layout_y=np.array([0.0, 2*NREL5MW_D]),\n", + " yaw_angles=yaw_angles,\n", " )\n", - " wakeviz.visualize_cut_plane(horizontal_plane, ax=axes, clevels=100)\n", - " wakeviz.plot_turbines_with_fi(fi, ax=axes, yaw_angles=yaw_angles)" + " horizontal_plane = fmodel.calculate_horizontal_plane(height=90.0)\n", + " flowviz.visualize_cut_plane(horizontal_plane, ax=axes, clevels=100)\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes, yaw_angles=yaw_angles)" ] }, { @@ -99,7 +101,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -137,7 +139,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -171,7 +173,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -203,7 +205,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -278,43 +280,52 @@ " X1_BOUND = 1500\n", "\n", " # Set the combination method\n", - " fi = FlorisInterface(\"../examples/inputs/jensen.yaml\")\n", - " settings = fi.floris.as_dict()\n", + " fmodel = FlorisModel(\"../examples/inputs/jensen.yaml\")\n", + " settings = fmodel.core.as_dict()\n", " settings[\"wake\"][\"model_strings\"][\"combination_model\"] = method\n", - " fi = FlorisInterface(settings)\n", + " fmodel = FlorisModel(settings)\n", "\n", " # Plot two turbines individually\n", " fig, axes = plt.subplots(1, 2, figsize=(10, 10))\n", - " fi.reinitialize(layout_x=np.array([X_UPSTREAM]), layout_y=np.zeros(1))\n", - " horizontal_plane = fi.calculate_horizontal_plane(\n", + " fmodel.set(\n", + " layout_x=np.array([X_UPSTREAM]),\n", + " layout_y=np.zeros(1),\n", + " yaw_angles=np.array([[20.0]]),\n", + " )\n", + " horizontal_plane = fmodel.calculate_horizontal_plane(\n", " height=90.0,\n", " x_bounds=(X0_BOUND, X1_BOUND),\n", - " yaw_angles=np.array([[[20.0]]])\n", " )\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", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes[0])\n", + " flowviz.visualize_cut_plane(horizontal_plane, ax=axes[0], clevels=100)\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes[1])\n", "\n", - " fi.reinitialize(layout_x=np.array([X_DOWNSTREAM]), layout_y=np.zeros(1))\n", - " horizontal_plane = fi.calculate_horizontal_plane(\n", + " fmodel.set(\n", + " layout_x=np.array([X_DOWNSTREAM]),\n", + " layout_y=np.zeros(1),\n", + " yaw_angles=np.array([[0.0]]),\n", + " )\n", + " horizontal_plane = fmodel.calculate_horizontal_plane(\n", " height=90.0,\n", " x_bounds=(X0_BOUND, X1_BOUND),\n", - " yaw_angles=np.array([[[0.0]]])\n", " )\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", + " flowviz.visualize_cut_plane(horizontal_plane, ax=axes[1], clevels=100)\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes[0])\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes[1])\n", "\n", " # Plot the combination of turbines\n", " fig, axes = plt.subplots(1, 1, figsize=(10, 10))\n", - " fi.reinitialize(layout_x=np.array([X_UPSTREAM, X_DOWNSTREAM]), layout_y=np.zeros(2))\n", - " horizontal_plane = fi.calculate_horizontal_plane(\n", + " fmodel.set(\n", + " layout_x=np.array([X_UPSTREAM, X_DOWNSTREAM]),\n", + " layout_y=np.zeros(2),\n", + " yaw_angles=np.array([[20.0, 0.0]]),\n", + " )\n", + " horizontal_plane = fmodel.calculate_horizontal_plane(\n", " height=90.0,\n", " 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, clevels=100)\n", - " wakeviz.plot_turbines_with_fi(fi, ax=axes)" + " flowviz.visualize_cut_plane(horizontal_plane, ax=axes, clevels=100)\n", + " layoutviz.plot_turbine_rotors(fmodel, ax=axes)" ] }, { @@ -337,7 +348,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -347,7 +358,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -378,7 +389,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -388,7 +399,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -419,7 +430,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -429,7 +440,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/wind_data_user.ipynb b/docs/wind_data_user.ipynb new file mode 100644 index 000000000..745c30470 --- /dev/null +++ b/docs/wind_data_user.ipynb @@ -0,0 +1,901 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Wind Data Objects" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "FLORIS v4 introduces WindData objects. These include TimeSeries, WindRose, and WindTIRose. These objects are used to hold inputs to FLORIS simulations, such as the ambient wind data, and to provide high-level methods for working with wind data. This notebook provides an overview of the WindData objects and demonstrates how to use them.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## WindDataBase" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "WindDataBase is the base class for all WindData objects. It provides a common interface for working with wind data. The WindDataBase class is not intended to be used directly, but rather to be subclassed by more specific wind data objects. It is only important to mention that many of the methods in FLORIS that accept wind data as input will accept any WindDataBase object as input. But is not typical to use it directly." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "from floris.wind_data import WindDataBase\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## TimeSeries" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "TimeSeries objects are used to represent data which are in a time-series form, or more generally and data which is represented as a list of conditions without frequency weighting (i.e. not a wind rose). In addition to representing time series input conditions, TimeSeries objects are useful for generating sweep inputs where most values are held constant while one input is swept through a range of values. Also useful can be an input of identical repeated inputs which can be useful if some control setting is going to be swept. TimeSeries represents data most similarly to how data structures within FLORIS are represented in that there are N wind_directions, wind_speeds etc., in the TimeSeries, the n_findex value in FLORIS will be N." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### TimeSeries Instantiation" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from floris import TimeSeries\n", + "import numpy as np\n", + "\n", + "# Like FlorisModel, TimeSeries require wind directions, wind speeds, and turbulence intensities to be of the same length.\n", + "N = 50\n", + "wind_speeds = np.linspace(3, 15, N)\n", + "wind_directions = 270.0 * np.ones(N)\n", + "turbulence_intensities = 0.06 * np.ones(N)\n", + "\n", + "# Create a TimeSeries object\n", + "time_series = TimeSeries(wind_directions=wind_directions, wind_speeds=wind_speeds, turbulence_intensities=turbulence_intensities)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Broadcasting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unlike FlorisModel, TimeSeries objects do allow broadcasting. As long as one of the inputs is a numpy array, the other inputs can be specified as a float, which will be broadcasted to the length of the numpy array.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# Equivalent to the above\n", + "time_series = TimeSeries(wind_directions=270.0, wind_speeds=wind_speeds, turbulence_intensities=0.06)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In addition to wind directions, wind speeds, and turbulence intensities, TimeSeries objects can also hold an array of values. These values can be used for example to represent electricity market prices (e.g., price/MWh). The values are intended to be multiplied by the corresponding wind plant power at each time step or wind condition to determine the total value produced over all conditions. \n", + "\n", + "If values are included in the TimeSeries object, they must be the same length as the wind directions, wind speeds, and turbulence intensities. If included, values enable calculation of Annual Value Production (AVP), in addition to AEP, and certain optimization routines, such as layout, can be configured to maximize value instead of energy production." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# Including value for each indices\n", + "time_series = TimeSeries(wind_directions=wind_directions, wind_speeds=wind_speeds, turbulence_intensities=turbulence_intensities, values=np.linspace(0, 1, N))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generating Turbulence Intensity" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The TimeSeries object also includes functions for generating TI as a function of wind direction and wind speed. This can be accomplished by passing in a custom function, or by taking use of the IEC 61400-1 standard " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Turbulence Intensity')" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Assign TI as a function of wind speed using the IEC method and default parameters.\n", + "time_series.assign_ti_using_IEC_method()\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(time_series.wind_speeds, time_series.turbulence_intensities)\n", + "ax.set_xlabel('Wind Speed (m/s)')\n", + "ax.set_ylabel('Turbulence Intensity')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generating Value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The TimeSeries object also includes functions for generating value as a function of wind direction and wind speed. This can be accomplished by passing in a custom function using the `TimeSeries.assign_value_using_wd_ws_function` method, or by using the `TimeSeries.assign_value_piecewise_linear` method, which approximates value using a two-segment piecewise linear function of wind speed. When using the default parameters, this produces a value vs. wind speed that approximates the normalized mean electricity price vs. wind speed curve for the SPP market in the U.S. for years 2018-2020 from figure 7 in \"The value of wake steering wind farm flow control in US energy markets,\" Wind Energy Science, 2024. https://doi.org/10.5194/wes-9-219-2024. " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Value (normalized price/MWh)')" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Assign value as a function of wind speed using the piecewise linear method and default parameters.\n", + "time_series.assign_value_piecewise_linear()\n", + "\n", + "fig, ax = plt.subplots()\n", + "ax.scatter(time_series.wind_speeds, time_series.values)\n", + "ax.grid()\n", + "ax.set_xlabel('Wind Speed (m/s)')\n", + "ax.set_ylabel('Value (normalized price/MWh)')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## WindRose" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A second wind data object is the WindRose, which represents the data as:\n", + "\n", + " - An array of wind directions\n", + " - An array of wind speeds\n", + " - A table of turbulence intensities of size (n_wind_directions, n_wind_speeds) which represents the TI at each wind direction and wind speed.\n", + " - A table of frequencies of size (n_wind_directions, n_wind_speeds) which represents the frequency of occurance of each wind direction and wind speed.\n", + " - An (optional) table of values of size (n_wind_directions, n_wind_speeds) which represents the value of the wind condition." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.16666667, 0.16666667, 0.16666667],\n", + " [0.16666667, 0.16666667, 0.16666667]])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from floris import WindRose\n", + "\n", + "wind_directions = np.array([270, 280]) # 2 Wind Directions\n", + "wind_speeds = np.array([6.0, 7.0, 8.0]) # 3 Wind Speeds\n", + "\n", + "# Create a WindRose object, not indicating a frequency table indicates uniform frequency\n", + "wind_rose = WindRose(\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " ti_table=0.06 #As in Time Series, a float indicates a constant table\n", + ")\n", + "\n", + "wind_rose.freq_table" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "wind_rose.ti_table\n", + "[[0.09683333 0.0905 0.08575 ]\n", + " [0.09683333 0.0905 0.08575 ]]\n", + "\n", + "wind_rose.value_table\n", + "[[1.2225 1.0875 0.9525]\n", + " [1.2225 1.0875 0.9525]]\n" + ] + } + ], + "source": [ + "# Several of the functions implemented for TimeSeries are likewise implemented for WindRose\n", + "\n", + "wind_rose.assign_ti_using_IEC_method()\n", + "\n", + "print(\"wind_rose.ti_table\")\n", + "print(wind_rose.ti_table)\n", + "\n", + "wind_rose.assign_value_piecewise_linear()\n", + "\n", + "print(\"\\nwind_rose.value_table\")\n", + "print(wind_rose.value_table)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## WindTIRose" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The WindTIRose is similar to the WindRose except that rather than specififying wind directions and wind speeds as arrays, with TI, frequency, adn value as 2D tables, the WindTIRose specificies wind directions, wind speeds, and turbulence intensities as arrays with the frequency and value tables now 3 dimensional, representing the frequency and value of each wind direction, wind speed, and turbulence intensity occurence." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "from floris import WindTIRose\n", + "\n", + "wind_directions = np.array([270, 280]) # 2 Wind Directions\n", + "wind_speeds = np.array([6.0, 7.0, 8.0]) # 3 Wind Speeds\n", + "turbulence_intensities = np.array([0.06, 0.07, 0.08]) # 3 Turbulence Intensities\n", + "\n", + "# The frequency table therefore is 2 x 3 x 3 and the sum over all entries = 1\n", + "freq_table = np.array([\n", + " [[2/18, 0, 1/18], [1/18, 1/18, 1/18], [1/18, 1/18, 1/18]],\n", + " [[1/18, 1/18, 1/18], [1/18, 1/18, 1/18], [1/18, 1/18, 1/18]]\n", + "])\n", + "\n", + "# The value table has the same dimensions as frequency\n", + "value_table = np.ones_like(freq_table)\n", + "\n", + "wind_ti_rose = WindTIRose(\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " turbulence_intensities=turbulence_intensities,\n", + " freq_table=freq_table,\n", + " value_table=value_table\n", + ")\n", + "\n", + "# Demonstrate setting value again\n", + "wind_ti_rose.assign_value_piecewise_linear()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conversions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Several methods for converting between WindData objects and resampling to different bin sizes are provided" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "# Converting from TimeSeries to WindRose/WindTiRose by binning\n", + "wind_rose = time_series.to_WindRose(wd_step=2, ws_step=1)\n", + "wind_ti_rose = time_series.to_WindTIRose(wd_step=2, ws_step=1, ti_step=0.01)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Aggregating and Resampling WindRose" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate a wind rose with a few wind directions and speeds\n", + "wind_directions=np.array([260,265,270, 275, 280, 285, 290])\n", + "wind_speeds=np.array([6.0, 7.0, 8.0, 9.0])\n", + "freq_table = np.random.rand(7, 4)\n", + "freq_table /= freq_table.sum()\n", + "\n", + "wind_rose = WindRose(\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " ti_table=0.06,\n", + " freq_table=freq_table\n", + ")\n", + "\n", + "wind_rose.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# The aggregate functions of WindRose/WindTiRose allows for \n", + "# aggregating the data into larger bin sizes \n", + "wind_rose_aggregated = wind_rose.aggregate(wd_step=10, ws_step=2)\n", + "wind_rose_aggregated.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# For upsampling, the resample_by_interpolation method is available which can\n", + "# interpolate the data via linear or nearest-neighbor interpolation\n", + "wind_rose_resampled = wind_rose.resample_by_interpolation(wd_step=2.5, ws_step=0.5)\n", + "wind_rose_resampled.plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are several plotting methods available to help visualize wind data objects" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "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" + }, + { + "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": [ + "wind_directions=np.arange(0, 360, 10)\n", + "wind_speeds=np.arange(0.0, 30.0, 5.0)\n", + "freq_table=np.random.rand(36, 6)\n", + "freq_table = freq_table / freq_table.sum()\n", + "\n", + "wind_rose = WindRose(\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " ti_table=0.06,\n", + " freq_table=freq_table\n", + ")\n", + "\n", + "# Set value\n", + "wind_rose.assign_value_piecewise_linear()\n", + "\n", + "wind_rose.plot()\n", + "\n", + "# Plot with aggregated wind directions\n", + "wind_rose.plot(wd_step=30)\n", + "\n", + "wind_rose.plot_ti_over_ws()\n", + "\n", + "wind_rose.plot_value_over_ws()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setting FLORIS" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "WindData objects are used to set wind direction, speed, TI, frequency, and value in a FlorisModel (or UncertainFlorisModel)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### TimeSeries" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "# TimeSeries\n", + "\n", + "from floris import FlorisModel\n", + "\n", + "# Create a FlorisModel object\n", + "fmodel = FlorisModel(\"../examples/inputs/gch.yaml\")\n", + "\n", + "# Set a two-turbine layout\n", + "fmodel.set(layout_x=[0, 500], layout_y=[0, 0])\n", + "\n", + "# Make a set of inputs with 5 wind directions, while wind speed and TI are constant\n", + "wind_directions = np.array([270, 280, 290, 300, 310])\n", + "wind_speeds = 8.0 * np.ones(5)\n", + "turbulence_intensities = 0.06 * np.ones(5)\n", + "\n", + "fmodel.set(\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " turbulence_intensities=turbulence_intensities\n", + ")\n", + "\n", + "# Is equivalent to the following (but now we'll include value as well):\n", + "time_series = TimeSeries(wind_directions=wind_directions, wind_speeds=8.0, turbulence_intensities=0.06)\n", + "\n", + "# Scale some of the default parameters to get reasonable values representing USD/MWh\n", + "time_series.assign_value_piecewise_linear(value_zero_ws=25*1.425, slope_2=-25*0.135)\n", + "\n", + "fmodel.set(wind_data = time_series)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mComputing AEP with uniform frequencies. Results results may not reflect annual operation.\u001b[0m\n", + "\u001b[34mfloris.floris_model.FlorisModel\u001b[0m \u001b[1;30mWARNING\u001b[0m \u001b[33mComputing AVP with uniform frequencies. Results results may not reflect annual operation.\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Turbine power have shape (5, 2) and are [[1753954.45917917 354990.76412771]\n", + " [1753954.45917917 1320346.28513924]\n", + " [1753954.45917917 1748551.48278202]\n", + " [1753954.45917917 1753951.95262087]\n", + " [1753954.45917917 1753954.45908051]]\n", + "Farm power has shape (5,) and is [2108945.22330688 3074300.74431841 3502505.94196119 3507906.41180004\n", + " 3507908.91825968]\n", + "Expected farm power has shape () and is 3140313.447929242\n", + "Farm AEP is 27.50914580386016 GWh\n", + "Expected farm value has shape () and is 74778713.97881508\n", + "Farm annual value production (AVP) is 655061.5344544201 USD\n" + ] + } + ], + "source": [ + "# Run the model and get outputs\n", + "fmodel.run()\n", + "\n", + "# Get the power outputs\n", + "turbine_powers = fmodel.get_turbine_powers()\n", + "farm_power = fmodel.get_farm_power()\n", + "expected_farm_power = fmodel.get_expected_farm_power()\n", + "aep = fmodel.get_farm_AEP()\n", + "\n", + "# Get value outputs\n", + "expected_farm_value = fmodel.get_expected_farm_value()\n", + "avp = fmodel.get_farm_AVP()\n", + "\n", + "# Display\n", + "print(f\"Turbine power have shape {turbine_powers.shape} and are {turbine_powers}\")\n", + "print(f\"Farm power has shape {farm_power.shape} and is {farm_power}\")\n", + "print(f\"Expected farm power has shape {expected_farm_power.shape} and is {expected_farm_power}\")\n", + "print(f\"Farm AEP is {aep/1e9} GWh\")\n", + "print(f\"Expected farm value has shape {expected_farm_power.shape} and is {expected_farm_value}\")\n", + "print(f\"Farm annual value production (AVP) is {avp/1e6} USD\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### WindRose" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "WindRose objects set FLORIS as TimeSeries, but there are some additional considerations.\n", + "\n", + " - By default, wind direction/speed combinations with 0 frequency are not run\n", + " - The outputs of the functions get_turbine_powers and get_farm_power will be reshaped to have dimensions num_wind_directions x num_wind_speeds ( x num_turbines)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fmodel has n_findex 4 because two cases have 0 frequency\n" + ] + } + ], + "source": [ + "wind_directions = np.array([270, 280]) # 2 Wind Directions\n", + "wind_speeds = np.array([6.0, 7.0, 8.0]) # 3 Wind Speeds\n", + "\n", + "# Frequency matrix is 2 x 3, include some 0 frequency results\n", + "freq_table = np.array([\n", + " [0, 0, 1/2],\n", + " [1/6, 1/6, 1/6]\n", + "])\n", + "\n", + "# Create a WindRose object, not indicating a frequency table indicates uniform frequency\n", + "wind_rose = WindRose(\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " ti_table=0.06,\n", + " freq_table=freq_table\n", + ")\n", + "\n", + "# Set value and scale some of the default parameters to get reasonable values representing USD/MWh\n", + "wind_rose.assign_value_piecewise_linear(value_zero_ws=25*1.425, slope_2=-25*0.135)\n", + "\n", + "fmodel.set(wind_data=wind_rose)\n", + "\n", + "print(f\"Fmodel has n_findex {fmodel.core.flow_field.n_findex} because two cases have 0 frequency\")" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Turbine power have shape (2, 3, 2) and are [[[ nan nan]\n", + " [ nan nan]\n", + " [1753954.45917917 354990.76412771]]\n", + "\n", + " [[ 731003.41073165 523849.55426108]\n", + " [1176825.66812027 876937.12082426]\n", + " [1753954.45917917 1320346.28513924]]]\n", + "Farm power has shape (2, 3) and is [[ nan nan 2108945.22330688]\n", + " [1254852.96499273 2053762.78894454 3074300.74431841]]\n", + "Expected farm power has shape () and is 2118292.0280293887\n", + "Farm AEP is 18.556238165537444 GWh\n", + "Expected farm value has shape () and is 53008780.071847945\n", + "Farm annual value production (AVP) is 464356.913429388 USD\n" + ] + } + ], + "source": [ + "# Run the model and collect the outputs\n", + "fmodel.run()\n", + "\n", + "# Get the power outputs\n", + "turbine_powers = fmodel.get_turbine_powers()\n", + "farm_power = fmodel.get_farm_power()\n", + "expected_farm_power = fmodel.get_expected_farm_power()\n", + "aep = fmodel.get_farm_AEP()\n", + "\n", + "# Get value outputs\n", + "expected_farm_value = fmodel.get_expected_farm_value()\n", + "avp = fmodel.get_farm_AVP()\n", + "\n", + "# Note that the nan values in the non-computed cases are expected since these are not run\n", + "\n", + "# Display\n", + "print(f\"Turbine power have shape {turbine_powers.shape} and are {turbine_powers}\")\n", + "print(f\"Farm power has shape {farm_power.shape} and is {farm_power}\")\n", + "print(f\"Expected farm power has shape {expected_farm_power.shape} and is {expected_farm_power}\")\n", + "print(f\"Farm AEP is {aep/1e9} GWh\")\n", + "print(f\"Expected farm value has shape {expected_farm_power.shape} and is {expected_farm_value}\")\n", + "print(f\"Farm annual value production (AVP) is {avp/1e6} USD\")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fmodel has n_findex 6\n", + "Turbine powers and farm power are now computed for all cases\n", + "Turbine power have shape (2, 3, 2) and are [[[ 731003.41073165 80999.08780495]\n", + " [1176825.66812027 191637.98384374]\n", + " [1753954.45917917 354990.76412771]]\n", + "\n", + " [[ 731003.41073165 523849.55426108]\n", + " [1176825.66812027 876937.12082426]\n", + " [1753954.45917917 1320346.28513924]]]\n", + "Farm power has shape (2, 3) and is [[ 812002.4985366 1368463.65196401 2108945.22330688]\n", + " [1254852.96499273 2053762.78894454 3074300.74431841]]\n", + "Expected farm power and value, AEP, and AVP are the same as before since the new cases are weighted by 0\n", + "Expected farm power has shape () and is 2118292.0280293887\n", + "Farm AEP is 18.556238165537444 GWh\n", + "Expected farm value has shape () and is 53008780.071847945\n", + "Farm annual value production (AVP) is 464356.913429388 USD\n" + ] + } + ], + "source": [ + "# It's possible however to force the running of 0 frequency cases\n", + "wind_rose = WindRose(\n", + " wind_directions=wind_directions,\n", + " wind_speeds=wind_speeds,\n", + " ti_table=0.06,\n", + " freq_table=freq_table,\n", + " compute_zero_freq_occurrence=True\n", + ")\n", + "\n", + "# Set value and scale some of the default parameters to get reasonable values representing USD/MWh\n", + "wind_rose.assign_value_piecewise_linear(value_zero_ws=25*1.425, slope_2=-25*0.135)\n", + "\n", + "fmodel.set(wind_data=wind_rose)\n", + "\n", + "print(f\"Fmodel has n_findex {fmodel.core.flow_field.n_findex}\")\n", + "\n", + "# Run the model and collect the outputs\n", + "fmodel.run()\n", + "\n", + "# Get the power outputs\n", + "turbine_powers = fmodel.get_turbine_powers()\n", + "farm_power = fmodel.get_farm_power()\n", + "expected_farm_power = fmodel.get_expected_farm_power()\n", + "aep = fmodel.get_farm_AEP()\n", + "\n", + "# Get value outputs\n", + "expected_farm_value = fmodel.get_expected_farm_value()\n", + "avp = fmodel.get_farm_AVP()\n", + "\n", + "# Display\n", + "print(\"Turbine powers and farm power are now computed for all cases\")\n", + "print(f\"Turbine power have shape {turbine_powers.shape} and are {turbine_powers}\")\n", + "print(f\"Farm power has shape {farm_power.shape} and is {farm_power}\")\n", + "\n", + "print(\"Expected farm power and value, AEP, and AVP are the same as before since the new cases are weighted by 0\")\n", + "print(f\"Expected farm power has shape {expected_farm_power.shape} and is {expected_farm_power}\")\n", + "print(f\"Farm AEP is {aep/1e9} GWh\")\n", + "print(f\"Expected farm value has shape {expected_farm_power.shape} and is {expected_farm_value}\")\n", + "print(f\"Farm annual value production (AVP) is {avp/1e6} USD\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "floris", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/001_opening_floris_computing_power.py b/examples/001_opening_floris_computing_power.py new file mode 100644 index 000000000..52950c922 --- /dev/null +++ b/examples/001_opening_floris_computing_power.py @@ -0,0 +1,64 @@ +"""Example 1: Opening FLORIS and Computing Power + +This example illustrates several of the key concepts in FLORIS. It demonstrates: + + 1) Initializing a FLORIS model + 2) Changing the wind farm layout + 3) Changing the incoming wind speed, wind direction and turbulence intensity + 4) Running the FLORIS simulation + 5) Getting the power output of the turbines + +Main concept is introduce FLORIS and illustrate essential structure of most-used FLORIS calls +""" + + +import numpy as np + +from floris import FlorisModel + + +# The FlorisModel class is the entry point for most usage. +# Initialize using an input yaml file +fmodel = FlorisModel("inputs/gch.yaml") + +# Changing the wind farm layout uses FLORIS' set method to a two-turbine layout +fmodel.set(layout_x=[0, 500.0], layout_y=[0.0, 0.0]) + +# Changing wind speed, wind direction, and turbulence intensity uses the set method +# as well. Note that the wind_speeds, wind_directions, and turbulence_intensities +# are all specified as arrays of the same length. +fmodel.set( + wind_directions=np.array([270.0]), wind_speeds=[8.0], turbulence_intensities=np.array([0.06]) +) + +# Note that typically all 3, wind_directions, wind_speeds and turbulence_intensities +# must be supplied to set. However, the exception is if not changing the length +# of the arrays, then only one or two may be supplied. +fmodel.set(turbulence_intensities=np.array([0.07])) + +# The number of elements in the wind_speeds, wind_directions, and turbulence_intensities +# corresponds to the number of conditions to be simulated. In FLORIS, each of these are +# tracked by a simple index called a findex. There is no requirement that the values +# be unique. Internally in FLORIS, most data structures will have the findex as their +# 0th dimension. The value n_findex is the total number of conditions to be simulated. +# This command would simulate 4 conditions (n_findex = 4). +fmodel.set( + wind_directions=np.array([270.0, 270.0, 270.0, 270.0]), + wind_speeds=[8.0, 8.0, 10.0, 10.0], + turbulence_intensities=np.array([0.06, 0.06, 0.06, 0.06]), +) + +# After the set method, the run method is called to perform the simulation +fmodel.run() + +# There are functions to get either the power of each turbine, or the farm power +turbine_powers = fmodel.get_turbine_powers() / 1000.0 +farm_power = fmodel.get_farm_power() / 1000.0 + +print("The turbine power matrix should be of dimensions 4 (n_findex) X 2 (n_turbines)") +print(turbine_powers) +print("Shape: ", turbine_powers.shape) + +print("The farm power should be a 1D array of length 4 (n_findex)") +print(farm_power) +print("Shape: ", farm_power.shape) diff --git a/examples/002_visualizations.py b/examples/002_visualizations.py new file mode 100644 index 000000000..f8c946324 --- /dev/null +++ b/examples/002_visualizations.py @@ -0,0 +1,94 @@ +"""Example 2: Visualizations + +This example demonstrates the use of the flow and layout visualizations in FLORIS. +First, an example wind farm layout is plotted, with the turbine names and the directions +and distances between turbines shown in different configurations by subplot. +Next, the horizontal flow field at hub height is plotted for a single wind condition. + +FLORIS includes two modules for visualization: + 1) flow_visualization: for visualizing the flow field + 2) layout_visualization: for visualizing the layout of the wind farm +The two modules can be used together to visualize the flow field and the layout +of the wind farm. + +""" + + +import matplotlib.pyplot as plt + +import floris.layout_visualization as layoutviz +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane + + +fmodel = FlorisModel("inputs/gch.yaml") + +# Set the farm layout to have 8 turbines irregularly placed +layout_x = [0, 500, 0, 128, 1000, 900, 1500, 1250] +layout_y = [0, 300, 750, 1400, 0, 567, 888, 1450] +fmodel.set(layout_x=layout_x, layout_y=layout_y) + + +# Layout visualization contains the functions for visualizing the layout: +# plot_turbine_points +# plot_turbine_labels +# plot_turbine_rotors +# plot_waking_directions +# Each of which can be overlaid to provide further information about the layout +# This series of 4 subplots shows the different ways to visualize the layout + +# Create the plotting objects using matplotlib +fig, axarr = plt.subplots(2, 2, figsize=(15, 10), sharex=False) +axarr = axarr.flatten() + +ax = axarr[0] +layoutviz.plot_turbine_points(fmodel, ax=ax) +ax.set_title("Turbine Points") + +ax = axarr[1] +layoutviz.plot_turbine_points(fmodel, ax=ax) +layoutviz.plot_turbine_labels(fmodel, ax=ax) +ax.set_title("Turbine Points and Labels") + +ax = axarr[2] +layoutviz.plot_turbine_points(fmodel, ax=ax) +layoutviz.plot_turbine_labels(fmodel, ax=ax) +layoutviz.plot_waking_directions(fmodel, ax=ax, limit_num=2) +ax.set_title("Turbine Points, Labels, and Waking Directions") + +# In the final subplot, use provided turbine names in place of the t_index +ax = axarr[3] +turbine_names = ["T1", "T2", "T3", "T4", "T9", "T10", "T75", "T78"] +layoutviz.plot_turbine_points(fmodel, ax=ax) +layoutviz.plot_turbine_labels(fmodel, ax=ax, turbine_names=turbine_names) +layoutviz.plot_waking_directions(fmodel, ax=ax, limit_num=2) +ax.set_title("Use Provided Turbine Names") + + +# Visualizations of the flow field are made by using calculate plane methods. In this example +# we show the horizontal plane at hub height, further examples are provided within +# the examples_visualizations folder + +# For flow visualizations, the FlorisModel must be set to run a single condition +# (n_findex = 1) +fmodel.set(wind_speeds=[8.0], wind_directions=[290.0], turbulence_intensities=[0.06]) +horizontal_plane = fmodel.calculate_horizontal_plane( + x_resolution=200, + y_resolution=100, + height=90.0, +) + +# Plot the flow field with rotors +fig, ax = plt.subplots() +visualize_cut_plane( + horizontal_plane, + ax=ax, + label_contours=False, + title="Horizontal Flow with Turbine Rotors and labels", +) + +# Plot the turbine rotors +layoutviz.plot_turbine_rotors(fmodel, ax=ax) +layoutviz.plot_turbine_labels(fmodel, ax=ax, turbine_names=turbine_names) + +plt.show() diff --git a/examples/003_wind_data_objects.py b/examples/003_wind_data_objects.py new file mode 100644 index 000000000..d45fb4a3d --- /dev/null +++ b/examples/003_wind_data_objects.py @@ -0,0 +1,256 @@ +"""Example 3: Wind Data Objects + +This example demonstrates the use of wind data objects in FLORIS: + TimeSeries, WindRose, and WindTIRose. + + For each of the WindData objects, examples are shown of: + + 1) Initializing the object + 2) Broadcasting values + 3) Converting between objects + 4) Setting TI and value + 5) Plotting + 6) Setting the FLORIS model using the object + +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, + WindRose, + WindTIRose, +) + + +################################################## +# Initializing +################################################## + +# FLORIS provides a set of wind data objects to hold the ambient wind conditions in a +# convenient classes that include capabilities and methods to manipulate and visualize +# the data. + +# The TimeSeries class is used to hold time series data, such as wind speed, wind direction, +# and turbulence intensity. + +# There is also a "value" wind data variable, which represents the value of the power +# generated at each time step or wind condition (e.g., the price of electricity). This can +# then be used in later optimization methods to optimize for quantities besides AEP. + +# Generate wind speeds, directions, turbulence intensities, and values via random signals +N = 100 +wind_speeds = 8 + 2 * np.random.randn(N) +wind_directions = 270 + 30 * np.random.randn(N) +turbulence_intensities = 0.06 + 0.02 * np.random.randn(N) +values = 25 + 10 * np.random.randn(N) + +time_series = TimeSeries( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + turbulence_intensities=turbulence_intensities, + values=values, +) + +# The WindRose class is used to hold wind rose data, such as wind speed, wind direction, +# and frequency. TI and value are represented as bin averages per wind direction and +# speed bin. +wind_directions = np.arange(0, 360, 3.0) +wind_speeds = np.arange(4, 20, 2.0) + +# Make TI table 6% TI for all wind directions and speeds +ti_table = 0.06 * np.ones((len(wind_directions), len(wind_speeds))) + +# Make value table 25 for all wind directions and speeds +value_table =25 * np.ones((len(wind_directions), len(wind_speeds))) + +# Uniform frequency +freq_table = np.ones((len(wind_directions), len(wind_speeds))) +freq_table = freq_table / np.sum(freq_table) + +wind_rose = WindRose( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + ti_table=ti_table, + freq_table=freq_table, + value_table=value_table, +) + +# The WindTIRose class is similar to the WindRose table except that TI is also binned +# making the frequency table a 3D array. +turbulence_intensities = np.arange(0.05, 0.15, 0.01) + +# Uniform frequency +freq_table = np.ones((len(wind_directions), len(wind_speeds), len(turbulence_intensities))) + +# Uniform value +value_table = 25* np.ones((len(wind_directions), len(wind_speeds), len(turbulence_intensities))) + +wind_ti_rose = WindTIRose( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + turbulence_intensities=turbulence_intensities, + freq_table=freq_table, + value_table=value_table, +) + +################################################## +# Broadcasting +################################################## + +# A convenience method of the wind data objects is that, unlike the lower-level +# FlorisModel.set() method, the wind data objects can broadcast upward data provided +# as a scalar to the full array. This is useful for setting the same wind conditions +# for all turbines in a wind farm. + +# For TimeSeries, as long as one condition is given as an array, the other 2 +# conditions can be given as scalars. The TimeSeries object will broadcast the +# scalars to the full array (uniform) +wind_directions = 270 + 30 * np.random.randn(N) +time_series = TimeSeries( + wind_directions=wind_directions, wind_speeds=8.0, turbulence_intensities=0.06 +) + + +# For WindRose, wind directions and wind speeds must be given as arrays, but the +# ti_table can be supplied as a scalar which will apply uniformly to all wind +# directions and speeds. Not supplying a freq table will similarly generate +# a uniform frequency table. +wind_directions = np.arange(0, 360, 3.0) +wind_speeds = np.arange(4, 20, 2.0) +wind_rose = WindRose(wind_directions=wind_directions, wind_speeds=wind_speeds, ti_table=0.06) + + +################################################## +# Wind Rose from Time Series +################################################## + +# The TimeSeries class has a method to generate a wind rose from a time series based on binning +wind_rose = time_series.to_WindRose(wd_edges=np.arange(0, 360, 3.0), ws_edges=np.arange(2, 20, 2.0)) + +################################################## +# Wind Rose from long CSV FILE +################################################## + +# The WindRose class can also be initialized from a long CSV file. By long what is meant is +# that the file has a column for each wind direction, wind speed combination. The file can +# also specify the mean TI per bin and the frequency of each bin as seperate columns. + +# If the TI is not provided, can specify a fixed TI for all bins using the ti_col_or_value +# input +wind_rose_from_csv = WindRose.read_csv_long( + "inputs/wind_rose.csv", wd_col="wd", ws_col="ws", freq_col="freq_val", ti_col_or_value=0.06 +) + +################################################## +# Aggregating and Resampling the Wind Rose +################################################## + +# The aggregate function allows for aggregation of the wind rose data into +# fewer wind direction and wind speed bins. +# Note it will throw an error if the step sizes passed in are smaller than the +# step sizes of the original data. +wind_rose_aggregate = wind_rose.aggregate(wd_step=10, ws_step=2) + +# For upsampling, the resample_by_interpolation function can be used to interpolate +# the wind rose data to a finer grid. It can use either linear or nearest neighbor +wind_rose_resample = wind_rose.resample_by_interpolation(wd_step=0.5, ws_step=0.25) + +################################################## +# Setting turbulence intensity +################################################## + +# Each of the wind data objects also has the ability to set the turbulence intensity +# according to a function of wind speed and direction. This can be done using a custom +# function by using the assign_ti_using_wd_ws_function method. There is also a method +# called assign_ti_using_IEC_method which assigns TI based on the IEC 61400-1 standard. +wind_rose.assign_ti_using_IEC_method() # Assign using default settings for Iref and offset + +################################################## +# Setting value +################################################## + +# Similarly, each of the wind data objects also has the ability to set the value according to +# a function of wind speed and direction. This can be done using a custom function by using +# the assign_value_using_wd_ws_function method. There is also a method called +# assign_value_piecewise_linear which assigns value based on a linear piecewise function of +# wind speed. + +# Assign value using default settings. This produces a value vs. wind speed that approximates +# the normalized mean electricity price vs. wind speed curve for the SPP market in the U.S. +# for years 2018-2020 from figure 7 in "The value of wake steering wind farm flow control in +# US energy markets," Wind Energy Science, 2024. https://doi.org/10.5194/wes-9-219-2024. +wind_rose.assign_value_piecewise_linear() + +################################################## +# Plotting Wind Data Objects +################################################## + +# Certain plotting methods are included to enable visualization of the wind data objects +# Plotting a wind rose +wind_rose.plot() + +# Plot a wind rose with the wind directions aggregated into 10-deg bins +wind_rose.plot(wd_step=10) + +# Showing TI over wind speed for a WindRose +wind_rose.plot_ti_over_ws() + +# Showing value over wind speed for a WindRose +wind_rose.plot_value_over_ws() + +################################################## +# Setting the FLORIS model via wind data +################################################## + +# Each of the wind data objects can be used to set the FLORIS model by passing +# them in as is to the set method. The FLORIS model will then use the member functions +# of the wind data to extract the wind conditions for the simulation. Frequency tables +# are also extracted for expected power and AEP-like calculations. +# Similarly the value data is extracted and maintained. + +fmodel = FlorisModel("inputs/gch.yaml") + +# Set the wind conditions using the TimeSeries object +fmodel.set(wind_data=time_series) + +# Set the wind conditions using the WindRose object +fmodel.set(wind_data=wind_rose) + +# Note that in the case of the wind_rose, under the default settings, wind direction and wind speed +# bins for which frequency is zero are not simulated. This can be changed by setting the +# compute_zero_freq_occurrence parameter to True. +wind_directions = np.array([200.0, 300.0]) +wind_speeds = np.array([5.0, 1.00]) +freq_table = np.array([[0.5, 0], [0.5, 0]]) +wind_rose = WindRose( + wind_directions=wind_directions, wind_speeds=wind_speeds, ti_table=0.06, freq_table=freq_table +) +fmodel.set(wind_data=wind_rose) + +print( + f"Number of conditions to simulate with compute_zero_freq_occurrence = False: " + f"{fmodel.n_findex}" +) + +wind_rose = WindRose( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + ti_table=0.06, + freq_table=freq_table, + compute_zero_freq_occurrence=True, +) +fmodel.set(wind_data=wind_rose) + +print( + f"Number of conditions to simulate with compute_zero_freq_occurrence = " + f"True: {fmodel.n_findex}" +) + +# Set the wind conditions using the WindTIRose object +fmodel.set(wind_data=wind_ti_rose) + +plt.show() diff --git a/examples/004_set.py b/examples/004_set.py new file mode 100644 index 000000000..ab103098a --- /dev/null +++ b/examples/004_set.py @@ -0,0 +1,105 @@ +"""Example 4: Set + +This example illustrates the use of the set method. The set method is used to +change the wind conditions, the wind farm layout, the turbine type, +and the controls settings. + +This example demonstrates setting each of the following: + 1) Wind conditions + 2) Wind farm layout + 3) Controls settings + +""" + + +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, + WindRose, +) + + +fmodel = FlorisModel("inputs/gch.yaml") + +###################################################### +# Atmospheric Conditions +###################################################### + + +# Change the wind directions, wind speeds, and turbulence intensities using numpy arrays +fmodel.set( + wind_directions=np.array([270.0, 270.0, 270.0]), + wind_speeds=[8.0, 9.0, 10.0], + turbulence_intensities=np.array([0.06, 0.06, 0.06]), +) + +# Set the wind conditions as above using the TimeSeries object +fmodel.set( + wind_data=TimeSeries( + wind_directions=270.0, wind_speeds=np.array([8.0, 9.0, 10.0]), turbulence_intensities=0.06 + ) +) + +# Set the wind conditions as above using the WindRose object +fmodel.set( + wind_data=WindRose( + wind_directions=np.array([270.0]), + wind_speeds=np.array([8.0, 9.0, 10.0]), + ti_table=0.06, + ) +) + +# Set the wind shear +fmodel.set(wind_shear=0.2) + + +# Set the air density +fmodel.set(air_density=1.1) + +# Set the reference wind height (which is the height at which the wind speed is given) +fmodel.set(reference_wind_height=92.0) + + +###################################################### +# Array Settings +###################################################### + +# Changing the wind farm layout uses FLORIS' set method to a two-turbine layout +fmodel.set(layout_x=[0, 500.0], layout_y=[0.0, 0.0]) + +###################################################### +# Controls Settings +###################################################### + +# Changes to controls settings can be made using the set method +# Note the dimension must match (n_findex, n_turbines) or (number of conditions, number of turbines) +# Above we n_findex = 3 and n_turbines = 2 so the matrix of yaw angles must be 3x2 +yaw_angles = np.array([[0.0, 0.0], [25.0, 0.0], [0.0, 0.0]]) +fmodel.set(yaw_angles=yaw_angles) + +# By default for the turbines in the turbine_library, the power +# thrust model is set to "cosine-loss" which adjusts +# power and thrust according to cos^cosine_loss_exponent(yaw | tilt) +# where the default exponent is 1.88. For other +# control capabilities, the power thrust model can be set to "mixed" +# which provides the same cosine loss model, and +# additionally methods for specifying derating levels for power and disabling turbines. + +# Use the reset operation method to clear out control signals +fmodel.reset_operation() + +# Change to the mixed model turbine +fmodel.set_operation_model("mixed") + +# Shut down the front turbine for the first two findex +disable_turbines = np.array([[True, False], [True, False], [False, False]]) +fmodel.set(disable_turbines=disable_turbines) + +# Derate the front turbine for the first two findex +RATED_POWER = 5e6 # 5MW (Anything above true rated power will still result in rated power) +power_setpoints = np.array( + [[RATED_POWER * 0.3, RATED_POWER], [RATED_POWER * 0.3, RATED_POWER], [RATED_POWER, RATED_POWER]] +) +fmodel.set(power_setpoints=power_setpoints) diff --git a/examples/005_getting_power.py b/examples/005_getting_power.py new file mode 100644 index 000000000..2f4ddd9d2 --- /dev/null +++ b/examples/005_getting_power.py @@ -0,0 +1,144 @@ +"""Example 5: Getting Turbine and Farm Power + +After setting the FlorisModel and running, the next step is typically to get the power output +of the turbines. FLORIS has several methods for getting power: + +1. `get_turbine_powers()`: Returns the power output of each turbine in the farm for each findex + (n_findex, n_turbines) +2. `get_farm_power()`: Returns the total power output of the farm for each findex (n_findex) +3. `get_expected_farm_power()`: Returns the combination of the farm power over each findex + with the frequency of each findex to get the expected farm power +4. `get_farm_AEP()`: Multiplies the expected farm power by the number of hours in a year to get + the expected annual energy production (AEP) of the farm + + +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, + WindRose, +) + + +fmodel = FlorisModel("inputs/gch.yaml") + +# Set to a 3-turbine layout +fmodel.set(layout_x=[0, 126 * 5, 126 * 10], layout_y=[0, 0, 0]) + +###################################################### +# Using TimeSeries +###################################################### + +# Set up a time series in which the wind speed and TI are constant but the wind direction +# sweeps the range from 250 to 290 degrees +wind_directions = np.arange(250, 290, 1.0) +time_series = TimeSeries( + wind_directions=wind_directions, wind_speeds=9.9, turbulence_intensities=0.06 +) +fmodel.set(wind_data=time_series) + +# Run the model +fmodel.run() + +# Get the turbine powers +turbine_powers = fmodel.get_turbine_powers() + +# Turbines powers will have shape (n_findex, n_turbines) where n_findex is the number of unique +# wind conditions and n_turbines is the number of turbines in the farm +print(f"Turbine power has shape {turbine_powers.shape}") + +# It is also possible to get the farm power directly +farm_power = fmodel.get_farm_power() + +# Farm power has length n_findex, and is the sum of the turbine powers +print(f"Farm power has shape {farm_power.shape}") + +# It's possible to get these powers with wake losses disabled, this can be useful +# for computing total wake losses +fmodel.run_no_wake() +farm_power_no_wake = fmodel.get_farm_power() + +# Plot the results +fig, axarr = plt.subplots(1, 3, figsize=(15, 5)) + +# Plot the turbine powers +ax = axarr[0] +for i in range(turbine_powers.shape[1]): + ax.plot(wind_directions, turbine_powers[:, i] / 1e3, label=f"Turbine {i+1} ") +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Power (kW)") +ax.grid(True) +ax.legend() +ax.set_title("Turbine Powers") + +# Plot the farm power +ax = axarr[1] +ax.plot(wind_directions, farm_power / 1e3, label="Farm Power With Wakes", color="k") +ax.plot(wind_directions, farm_power_no_wake / 1e3, label="Farm Power No Wakes", color="r") +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Power (kW)") +ax.grid(True) +ax.legend() +ax.set_title("Farm Power") + +# Plot the percent wake losses +ax = axarr[2] +percent_wake_losses = 100 * (farm_power_no_wake - farm_power) / farm_power_no_wake +ax.plot(wind_directions, percent_wake_losses, label="Percent Wake Losses", color="k") +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Percent Wake Losses") +ax.grid(True) +ax.legend() +ax.set_title("Percent Wake Losses") + + +###################################################### +# Using WindRose +###################################################### + +# When running FLORIS using a wind rose, that is when a WindRose or WindTIRose object is +# passed into the set function. The functions get_expected_farm_power and get_farm_AEP +# will operate the same as above, however the functions get_turbine_powers and get_farm_power +# will be reshaped from (n_findex, n_turbines) and +# (n_findex) to (n_wind_dir, n_wind_speed, n_turbines) +# and (n_wind_dir, n_wind_speed) respectively. This is make the powers align more easily with the +# provided wind rose. + +# Declare a WindRose object of 2 wind directions and 3 wind speeds and constant turbulence intensity +wind_rose = WindRose( + wind_directions=np.array([270.0, 280.0]), wind_speeds=np.array([8.0, 9.0, 10.0]), ti_table=0.06 +) + +fmodel.set(wind_data=wind_rose) + +print("==========Wind Rose==========") +print(f"Number of conditions to simulate (2 x 3): {fmodel.n_findex}") + +fmodel.run() + +turbine_powers = fmodel.get_turbine_powers() + +print(f"Shape of turbine powers: {turbine_powers.shape}") + +farm_power = fmodel.get_farm_power() + +print(f"Shape of farm power: {farm_power.shape}") + + +# Plot the farm power +fig, ax = plt.subplots() + +for w_idx, wd in enumerate(wind_rose.wind_directions): + ax.plot(wind_rose.wind_speeds, farm_power[w_idx, :] / 1e3, label=f"WD: {wd}") + +ax.set_xlabel("Wind Speed (m/s)") +ax.set_ylabel("Power (kW)") +ax.grid(True) +ax.legend() +ax.set_title("Farm Power (from Wind Rose)") + +plt.show() diff --git a/examples/006_get_farm_aep.py b/examples/006_get_farm_aep.py new file mode 100644 index 000000000..2d9121be9 --- /dev/null +++ b/examples/006_get_farm_aep.py @@ -0,0 +1,103 @@ +"""Example 6: Getting Expected Power and AEP + +The expected power of a farm is computed by multiplying the power output of the farm by the +frequency of each findex. This is done by the `get_expected_farm_power` method. The expected +AEP is annual energy production is computed by multiplying the expected power by the number of +hours in a year. + +If a wind_data object is provided to the model, the expected power and AEP + can be computed directly by the`get_farm_AEP_with_wind_data` using the frequency table + of the wind data object. If not, a frequency table must be passed into these functions + + +""" + +import numpy as np +import pandas as pd + +from floris import ( + FlorisModel, + TimeSeries, + WindRose, +) + + +fmodel = FlorisModel("inputs/gch.yaml") + + +# Set to a 3-turbine layout +D = 126. +fmodel.set(layout_x=[0.0, 5 * D, 10 * D], + layout_y=[0.0, 0.0, 0.0]) + +# Using TimeSeries + +# Randomly generated a time series with time steps = 365 * 24 +N = 365 * 24 +wind_directions = np.random.uniform(0, 360, N) +wind_speeds = np.random.uniform(5, 25, N) + +# Set up a time series +time_series = TimeSeries( + wind_directions=wind_directions, wind_speeds=wind_speeds, turbulence_intensities=0.06 +) + +# Set the wind data +fmodel.set(wind_data=time_series) + +# Run the model +fmodel.run() + +expected_farm_power = fmodel.get_expected_farm_power() +aep = fmodel.get_farm_AEP() + +# Note this is equivalent to the following +aep_b = fmodel.get_farm_AEP(freq=time_series.unpack_freq()) + +print(f"AEP from time series: {aep}, and re-computed AEP: {aep_b}") + +# Using WindRose============================================== + +# Load the wind rose from csv as in example 003 +wind_rose = WindRose.read_csv_long( + "inputs/wind_rose.csv", wd_col="wd", ws_col="ws", freq_col="freq_val", ti_col_or_value=0.06 +) + + +# Store some values +n_wd = len(wind_rose.wind_directions) +n_ws = len(wind_rose.wind_speeds) + +# Store the number of elements of the freq_table which are 0 +n_zeros = np.sum(wind_rose.freq_table == 0) + +# Set the wind rose +fmodel.set(wind_data=wind_rose) + +# Run the model +fmodel.run() + +# Note that the frequency table contains 0 frequency for some wind directions and wind speeds +# and we've not selected to compute 0 frequency bins, therefore the n_findex will be less than +# the total number of wind directions and wind speed combinations +print(f"Total number of wind direction and wind speed combination: {n_wd * n_ws}") +print(f"Number of 0 frequency bins: {n_zeros}") +print(f"n_findex: {fmodel.n_findex}") + +# Get the AEP +aep = fmodel.get_farm_AEP() + +# Print the AEP +print(f"AEP from wind rose: {aep/1E9:.3f} (GWh)") + +# Run the model again, without wakes, and use the result to compute the wake losses +fmodel.run_no_wake() + +# Get the AEP without wake +aep_no_wake = fmodel.get_farm_AEP() + +# Compute the wake losses +wake_losses = 100 * (aep_no_wake - aep) / aep_no_wake + +# Print the wake losses +print(f"Wake losses: {wake_losses:.2f}%") diff --git a/examples/007_sweeping_variables.py b/examples/007_sweeping_variables.py new file mode 100644 index 000000000..502d961a4 --- /dev/null +++ b/examples/007_sweeping_variables.py @@ -0,0 +1,217 @@ +"""Example 7: Sweeping Variables + +Demonstrate methods for sweeping across variables. Wind directions, wind speeds, +turbulence intensities, as well as control inputs are passed to set() as arrays +and so can be swept and run in one call to run(). + +The example includes demonstrations of sweeping: + + 1) Wind speeds + 2) Wind directions + 3) Turbulence intensities + 4) Yaw angles + 5) Power setpoints + 6) Disabling turbines + +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, +) + + +fmodel = FlorisModel("inputs/gch.yaml") + +# Set to a 2 turbine layout +fmodel.set(layout_x=[0.0, 126 * 5], layout_y=[0.0, 0.0]) + +# Start a figure for the results +fig, axarr = plt.subplots(2, 3, figsize=(15, 10), sharey=True) +axarr = axarr.flatten() + +###################################################### +# Sweep wind speeds +###################################################### + + +# The TimeSeries object is the most convenient for sweeping +# wind speeds while keeping the wind direction and turbulence +# intensity constant +wind_speeds = np.arange(5, 10, 0.1) +fmodel.set( + wind_data=TimeSeries( + wind_speeds=wind_speeds, wind_directions=270.0, turbulence_intensities=0.06 + ) +) +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() / 1e3 + +# Plot the results +ax = axarr[0] +ax.plot(wind_speeds, turbine_powers[:, 0], label="Upstream Turbine", color="k") +ax.plot(wind_speeds, turbine_powers[:, 1], label="Downstream Turbine", color="r") +ax.set_ylabel("Power (kW)") +ax.set_xlabel("Wind Speed (m/s)") +ax.legend() + +###################################################### +# Sweep wind directions +###################################################### + + +wind_directions = np.arange(250, 290, 1.0) +fmodel.set( + wind_data=TimeSeries( + wind_speeds=8.0, wind_directions=wind_directions, turbulence_intensities=0.06 + ) +) +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() / 1e3 + +# Plot the results +ax = axarr[1] +ax.plot(wind_directions, turbine_powers[:, 0], label="Upstream Turbine", color="k") +ax.plot(wind_directions, turbine_powers[:, 1], label="Downstream Turbine", color="r") +ax.set_xlabel("Wind Direction (deg)") + +###################################################### +# Sweep turbulence intensities +###################################################### + +turbulence_intensities = np.arange(0.03, 0.2, 0.01) +fmodel.set( + wind_data=TimeSeries( + wind_speeds=8.0, wind_directions=270.0, turbulence_intensities=turbulence_intensities + ) +) +fmodel.run() + +turbine_powers = fmodel.get_turbine_powers() / 1e3 + +# Plot the results +ax = axarr[2] +ax.plot(turbulence_intensities, turbine_powers[:, 0], label="Upstream Turbine", color="k") +ax.plot(turbulence_intensities, turbine_powers[:, 1], label="Downstream Turbine", color="r") +ax.set_xlabel("Turbulence Intensity") + +###################################################### +# Sweep the upstream yaw angle +###################################################### + +# First set the conditions to uniform for N yaw_angles +n_yaw = 100 +wind_directions = np.ones(n_yaw) * 270.0 +fmodel.set( + wind_data=TimeSeries( + wind_speeds=8.0, wind_directions=wind_directions, turbulence_intensities=0.06 + ) +) + +yaw_angles_upstream = np.linspace(-30, 30, n_yaw) +yaw_angles = np.zeros((n_yaw, 2)) +yaw_angles[:, 0] = yaw_angles_upstream + +fmodel.set(yaw_angles=yaw_angles) +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() / 1e3 + +# Plot the results +ax = axarr[3] +ax.plot(yaw_angles_upstream, turbine_powers[:, 0], label="Upstream Turbine", color="k") +ax.plot(yaw_angles_upstream, turbine_powers[:, 1], label="Downstream Turbine", color="r") +ax.set_xlabel("Upstream Yaw Angle (deg)") +ax.set_ylabel("Power (kW)") + +###################################################### +# Sweep the upstream power rating +###################################################### + +# Since we're changing control modes, need to reset the operation +fmodel.reset_operation() + +# To the de-rating need to change the power_thrust_mode to mixed or simple de-rating +fmodel.set_operation_model("simple-derating") + +# Sweep the de-rating levels +RATED_POWER = 5e6 # For NREL 5MW +n_derating_levels = 150 +upstream_power_setpoint = np.linspace(0.0, RATED_POWER * 0.5, n_derating_levels) +power_setpoints = np.ones((n_derating_levels, 2)) * RATED_POWER +power_setpoints[:, 0] = upstream_power_setpoint + +# Set the wind conditions to fixed +wind_directions = np.ones(n_derating_levels) * 270.0 +fmodel.set( + wind_data=TimeSeries( + wind_speeds=8.0, wind_directions=wind_directions, turbulence_intensities=0.06 + ) +) + +# Set the de-rating levels +fmodel.set(power_setpoints=power_setpoints) +fmodel.run() + +# Get the turbine powers +turbine_powers = fmodel.get_turbine_powers() / 1e3 + +# Plot the results +ax = axarr[4] +ax.plot(upstream_power_setpoint / 1e3, turbine_powers[:, 0], label="Upstream Turbine", color="k") +ax.plot(upstream_power_setpoint / 1e3, turbine_powers[:, 1], label="Downstream Turbine", color="r") +ax.plot( + upstream_power_setpoint / 1e3, + upstream_power_setpoint / 1e3, + label="De-Rating Level", + color="b", + linestyle="--", +) +ax.set_xlabel("Upstream Power Setpoint (kW)") +ax.legend() + +###################################################### +# Sweep through disabling turbine combinations +###################################################### + +# Reset the control settings +fmodel.reset_operation() + +# Make a list of possible turbine disable combinations +disable_combinations = np.array([[False, False], [True, False], [False, True], [True, True]]) +n_combinations = disable_combinations.shape[0] + +# Make a list of strings representing the combinations +disable_combination_strings = ["None", "T0", "T1", "T0 & T1"] + +# Set the wind conditions to fixed +wind_directions = np.ones(n_combinations) * 270.0 +fmodel.set( + wind_data=TimeSeries( + wind_speeds=8.0, wind_directions=wind_directions, turbulence_intensities=0.06 + ) +) + +# Assign the disable settings +fmodel.set(disable_turbines=disable_combinations) + +# Run the model +fmodel.run() + +# Get the turbine powers +turbine_powers = fmodel.get_turbine_powers() / 1e3 + +# Plot the results +ax = axarr[5] +ax.plot(disable_combination_strings, turbine_powers[:, 0], "ks-", label="Upstream Turbine") +ax.plot(disable_combination_strings, turbine_powers[:, 1], "ro-", label="Downstream Turbine") +ax.set_xlabel("Turbine Disable Combination") + + +for ax in axarr: + ax.grid(True) + + +plt.show() diff --git a/examples/008_uncertain_models.py b/examples/008_uncertain_models.py new file mode 100644 index 000000000..9d151d687 --- /dev/null +++ b/examples/008_uncertain_models.py @@ -0,0 +1,160 @@ +"""Example 8: Uncertain Models + +UncertainFlorisModel is a class that adds uncertainty to the inflow wind direction +on the FlorisModel class. The UncertainFlorisModel class is interacted with in the +same manner as the FlorisModel class is. This example demonstrates how the +wind farm power production is calculated with and without uncertainty. +Other use cases of UncertainFlorisModel are, e.g., comparing FLORIS to +historical SCADA data and robust optimization. + +For more details on using uncertain models, see further examples within the +examples_uncertain directory. + +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, + UncertainFlorisModel, +) + + +# Instantiate FLORIS FLORIS and UncertainFLORIS models +fmodel = FlorisModel("inputs/gch.yaml") # GCH model + +# The instantiation of the UncertainFlorisModel class is similar to the FlorisModel class +# with the addition of the wind direction standard deviation (wd_std) parameter +# and certain resolution parameters. Internally, the UncertainFlorisModel class +# expands the wind direction time series to include the uncertainty but then +# only runs the unique cases. The final result is computed via a gaussian weighting +# of the cases according to wd_std. Here we use the default resolution parameters. +# wd_resolution=1.0, # Degree +# ws_resolution=1.0, # m/s +# ti_resolution=0.01, + +ufmodel_3 = UncertainFlorisModel("inputs/gch.yaml", wd_std=3) +ufmodel_5 = UncertainFlorisModel("inputs/gch.yaml", wd_std=5) + +# Define an inflow where wind direction is swept while +# wind speed and turbulence intensity are held constant +wind_directions = np.arange(240.0, 300.0, 1.0) +time_series = TimeSeries( + wind_directions=wind_directions, + wind_speeds=8.0, + turbulence_intensities=0.06, +) + +# Define a two turbine farm and apply the inflow +D = 126.0 +layout_x = np.array([0, D * 6]) +layout_y = [0, 0] + +fmodel.set( + layout_x=layout_x, + layout_y=layout_y, + wind_data=time_series, +) +ufmodel_3.set( + layout_x=layout_x, + layout_y=layout_y, + wind_data=time_series, +) +ufmodel_5.set( + layout_x=layout_x, + layout_y=layout_y, + wind_data=time_series, +) + + +# Run both models +fmodel.run() +ufmodel_3.run() +ufmodel_5.run() + +# Collect the nominal and uncertain farm power +turbine_powers_nom = fmodel.get_turbine_powers() / 1e3 +turbine_powers_unc_3 = ufmodel_3.get_turbine_powers() / 1e3 +turbine_powers_unc_5 = ufmodel_5.get_turbine_powers() / 1e3 +farm_powers_nom = fmodel.get_farm_power() / 1e3 +farm_powers_unc_3 = ufmodel_3.get_farm_power() / 1e3 +farm_powers_unc_5 = ufmodel_5.get_farm_power() / 1e3 + +# Plot results +fig, axarr = plt.subplots(1, 3, figsize=(15, 5)) +ax = axarr[0] +ax.plot(wind_directions, turbine_powers_nom[:, 0].flatten(), color="k", label="Nominal power") +ax.plot( + wind_directions, + turbine_powers_unc_3[:, 0].flatten(), + color="r", + label="Power with uncertainty = 3 deg", +) +ax.plot( + wind_directions, + turbine_powers_unc_5[:, 0].flatten(), + color="m", + label="Power with uncertainty = 5deg", +) +ax.grid(True) +ax.legend() +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Power (kW)") +ax.set_title("Upstream Turbine") + +ax = axarr[1] +ax.plot(wind_directions, turbine_powers_nom[:, 1].flatten(), color="k", label="Nominal power") +ax.plot( + wind_directions, + turbine_powers_unc_3[:, 1].flatten(), + color="r", + label="Power with uncertainty = 3 deg", +) +ax.plot( + wind_directions, + turbine_powers_unc_5[:, 1].flatten(), + color="m", + label="Power with uncertainty = 5 deg", +) +ax.set_title("Downstream Turbine") +ax.grid(True) +ax.legend() +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Power (kW)") + +ax = axarr[2] +ax.plot(wind_directions, farm_powers_nom.flatten(), color="k", label="Nominal farm power") +ax.plot( + wind_directions, + farm_powers_unc_3.flatten(), + color="r", + label="Farm power with uncertainty = 3 deg", +) +ax.plot( + wind_directions, + farm_powers_unc_5.flatten(), + color="m", + label="Farm power with uncertainty = 5 deg", +) +ax.set_title("Farm Power") +ax.grid(True) +ax.legend() +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Power (kW)") + +# Compare the AEP calculation +freq = np.ones_like(wind_directions) +freq = freq / freq.sum() + +aep_nom = fmodel.get_farm_AEP(freq=freq) +aep_unc_3 = ufmodel_3.get_farm_AEP(freq=freq) +aep_unc_5 = ufmodel_5.get_farm_AEP(freq=freq) + +print(f"AEP without uncertainty {aep_nom}") +print(f"AEP without uncertainty (3 deg) {aep_unc_3} ({100*aep_unc_3/aep_nom:.2f}%)") +print(f"AEP without uncertainty (5 deg) {aep_unc_5} ({100*aep_unc_5/aep_nom:.2f}%)") + + +plt.show() diff --git a/examples/009_compare_farm_power_with_neighbor.py b/examples/009_compare_farm_power_with_neighbor.py new file mode 100644 index 000000000..c67465f31 --- /dev/null +++ b/examples/009_compare_farm_power_with_neighbor.py @@ -0,0 +1,76 @@ +"""Example 9: Compare farm power with neighboring farm + +This example demonstrates how to use turbine_weights to define a set of turbines belonging +to a neighboring farm which impacts the power production of the farm under consideration +via wake losses, but whose own power production is not considered in farm power / aep production + +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel + + +# Instantiate FLORIS using either the GCH or CC model +fmodel = FlorisModel("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 + +# Define a 4 turbine farm turbine farm +D = 126.0 +layout_x = np.array([0, D * 6, 0, D * 6]) +layout_y = [0, 0, D * 3, D * 3] +fmodel.set(layout_x=layout_x, layout_y=layout_y) + +# Define a simple inflow with just 1 wind speed +wd_array = np.arange(0, 360, 4.0) +ws_array = 8.0 * np.ones_like(wd_array) +turbulence_intensities = 0.06 * np.ones_like(wd_array) +fmodel.set( + wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=turbulence_intensities +) + + +# Calculate +fmodel.run() + +# Collect the farm power +farm_power_base = fmodel.get_farm_power() / 1e3 # In kW + +# Add a neighbor to the east +layout_x = np.array([0, D * 6, 0, D * 6, D * 12, D * 15, D * 12, D * 15]) +layout_y = np.array([0, 0, D * 3, D * 3, 0, 0, D * 3, D * 3]) +fmodel.set(layout_x=layout_x, layout_y=layout_y) + +# Define the weights to exclude the neighboring farm from calculations of power +turbine_weights = np.zeros(len(layout_x), dtype=int) +turbine_weights[0:4] = 1.0 + +# Calculate +fmodel.run() + +# Collect the farm power with the neighbor +farm_power_neighbor = fmodel.get_farm_power(turbine_weights=turbine_weights) / 1e3 # In kW + +# Show the farms +fig, ax = plt.subplots() +ax.scatter( + layout_x[turbine_weights == 1], layout_y[turbine_weights == 1], color="k", label="Base Farm" +) +ax.scatter( + layout_x[turbine_weights == 0], + layout_y[turbine_weights == 0], + color="r", + label="Neighboring Farm", +) +ax.legend() + +# Plot the power difference +fig, ax = plt.subplots() +ax.plot(wd_array, farm_power_base, color="k", label="Farm Power (no neighbor)") +ax.plot(wd_array, farm_power_neighbor, color="r", label="Farm Power (neighboring farm due east)") +ax.grid(True) +ax.legend() +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Power (kW)") +plt.show() diff --git a/examples/01_opening_floris_computing_power.py b/examples/01_opening_floris_computing_power.py deleted file mode 100644 index b006dfe4d..000000000 --- a/examples/01_opening_floris_computing_power.py +++ /dev/null @@ -1,78 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import numpy as np - -from floris.tools import FlorisInterface - - -""" -This example creates a FLORIS instance -1) Makes a two-turbine layout -2) Demonstrates single ws/wd simulations -3) Demonstrates mulitple ws/wd simulations - -Main concept is introduce FLORIS and illustrate essential structure of most-used FLORIS calls -""" - -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive -# entry point to the simulation routines. -fi = FlorisInterface("inputs/gch.yaml") - -# Convert to a simple two turbine layout -fi.reinitialize(layout_x=[0, 500.], layout_y=[0., 0.]) - -# Single wind speed and wind direction -print('\n========================= Single Wind Direction and Wind Speed =========================') - -# Get the turbine powers assuming 1 wind speed and 1 wind direction -fi.reinitialize(wind_directions=[270.], wind_speeds=[8.0]) - -# Set the yaw angles to 0 -yaw_angles = np.zeros([1,1,2]) # 1 wind direction, 1 wind speed, 2 turbines -fi.calculate_wake(yaw_angles=yaw_angles) - -# Get the turbine powers -turbine_powers = fi.get_turbine_powers()/1000. -print('The turbine power matrix should be of dimensions 1 WD X 1 WS X 2 Turbines') -print(turbine_powers) -print("Shape: ",turbine_powers.shape) - -# Single wind speed and multiple wind directions -print('\n========================= Single Wind Direction and Multiple Wind Speeds ===============') - - -wind_speeds = np.array([8.0, 9.0, 10.0]) -fi.reinitialize(wind_speeds=wind_speeds) -yaw_angles = np.zeros([1,3,2]) # 1 wind direction, 3 wind speeds, 2 turbines -fi.calculate_wake(yaw_angles=yaw_angles) -turbine_powers = fi.get_turbine_powers()/1000. -print('The turbine power matrix should be of dimensions 1 WD X 3 WS X 2 Turbines') -print(turbine_powers) -print("Shape: ",turbine_powers.shape) - -# Multiple wind speeds and multiple wind directions -print('\n========================= Multiple Wind Directions and Multiple Wind Speeds ============') - -wind_directions = np.array([260., 270., 280.]) -wind_speeds = np.array([8.0, 9.0, 10.0]) -fi.reinitialize(wind_directions=wind_directions, wind_speeds=wind_speeds) -yaw_angles = np.zeros([1,3,2]) # 1 wind direction, 3 wind speeds, 2 turbines -fi.calculate_wake(yaw_angles=yaw_angles) -turbine_powers = fi.get_turbine_powers()/1000. -print('The turbine power matrix should be of dimensions 3 WD X 3 WS X 2 Turbines') -print(turbine_powers) -print("Shape: ",turbine_powers.shape) diff --git a/examples/02_visualizations.py b/examples/02_visualizations.py deleted file mode 100644 index 4b65f8e9d..000000000 --- a/examples/02_visualizations.py +++ /dev/null @@ -1,160 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -import floris.tools.visualization as wakeviz -from floris.tools import FlorisInterface - - -""" -This example initializes the FLORIS software, and then uses internal -functions to run a simulation and plot the results. In this case, -we are plotting three slices of the resulting flow field: -1. Horizontal slice parallel to the ground and located at the hub height -2. Vertical slice of parallel with the direction of the wind -3. Veritical slice parallel to to the turbine disc plane - -Additionally, an alternative method of plotting a horizontal slice -is shown. Rather than calculating points in the domain behind a turbine, -this method adds an additional turbine to the farm and moves it to -locations throughout the farm while calculating the velocity at it's -rotor. -""" - -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive -# entry point to the simulation routines. -fi = FlorisInterface("inputs/gch.yaml") - -# The rotor plots show what is happening at each turbine, but we do not -# see what is happening between each turbine. For this, we use a -# grid that has points regularly distributed throughout the fluid domain. -# The FlorisInterface contains functions for configuring the new grid, -# running the simulation, and generating plots of 2D slices of the -# flow field. - -# Note this visualization grid created within the calculate_horizontal_plane function will be reset -# to what existed previously at the end of the function - -# Using the FlorisInterface functions, get 2D slices. -horizontal_plane = fi.calculate_horizontal_plane( - x_resolution=200, - y_resolution=100, - height=90.0, - yaw_angles=np.array([[[25.,0.,0.]]]), -) - -y_plane = fi.calculate_y_plane( - x_resolution=200, - z_resolution=100, - crossstream_dist=0.0, - yaw_angles=np.array([[[25.,0.,0.]]]), -) -cross_plane = fi.calculate_cross_plane( - y_resolution=100, - z_resolution=100, - downstream_dist=630.0, - yaw_angles=np.array([[[25.,0.,0.]]]), -) - -# Create the plots -fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) -ax_list = ax_list.flatten() -wakeviz.visualize_cut_plane( - horizontal_plane, - ax=ax_list[0], - label_contours=True, - title="Horizontal" -) -wakeviz.visualize_cut_plane( - y_plane, - ax=ax_list[1], - label_contours=True, - title="Streamwise profile" -) -wakeviz.visualize_cut_plane( - cross_plane, - ax=ax_list[2], - label_contours=True, - title="Spanwise profile" -) - -# Some wake models may not yet have a visualization method included, for these cases can use -# a slower version which scans a turbine model to produce the horizontal flow -horizontal_plane_scan_turbine = wakeviz.calculate_horizontal_plane_with_turbines( - fi, - x_resolution=20, - y_resolution=10, - yaw_angles=np.array([[[25.,0.,0.]]]), -) - -fig, ax = plt.subplots() -wakeviz.visualize_cut_plane( - horizontal_plane_scan_turbine, - ax=ax, - label_contours=True, - title="Horizontal (coarse turbine scan method)", -) - -# FLORIS further includes visualization methods for visualing the rotor plane of each -# Turbine in the simulation - -# Run the wake calculation to get the turbine-turbine interfactions -# on the turbine grids -fi.calculate_wake() - -# Plot the values at each rotor -fig, axes, _ , _ = wakeviz.plot_rotor_values( - fi.floris.flow_field.u, - wd_index=0, - ws_index=0, - n_rows=1, - n_cols=3, - return_fig_objects=True -) -fig.suptitle("Rotor Plane Visualization, Original Resolution") - -# FLORIS supports multiple types of grids for capturing wind speed -# information. The current input file is configured with a square grid -# placed on each rotor plane with 9 points in a 3x3 layout. For visualization, -# this resolution can be increased. Note this operation, unlike the -# calc_x_plane above operations does not automatically reset the grid to -# the initial status as definied by the input file - -# Increase the resolution of points on each turbien plane -solver_settings = { - "type": "turbine_grid", - "turbine_grid_points": 10 -} -fi.reinitialize(solver_settings=solver_settings) - -# Run the wake calculation to get the turbine-turbine interfactions -# on the turbine grids -fi.calculate_wake() - -# Plot the values at each rotor -fig, axes, _ , _ = wakeviz.plot_rotor_values( - fi.floris.flow_field.u, - wd_index=0, - ws_index=0, - n_rows=1, - n_cols=3, - return_fig_objects=True -) -fig.suptitle("Rotor Plane Visualization, 10x10 Resolution") - -wakeviz.show_plots() diff --git a/examples/03_making_adjustments.py b/examples/03_making_adjustments.py deleted file mode 100644 index 750288d5a..000000000 --- a/examples/03_making_adjustments.py +++ /dev/null @@ -1,128 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -import floris.tools.visualization as wakeviz -from floris.tools import FlorisInterface - - -""" -This example makes changes to the given input file through the script. -First, we plot simulation from the input file as given. Then, we make a series -of changes and generate plots from those simulations. -""" - -# Create the plotting objects using matplotlib -fig, axarr = plt.subplots(2, 3, figsize=(12, 5)) -axarr = axarr.flatten() - -MIN_WS = 1.0 -MAX_WS = 8.0 - -# Initialize FLORIS with the given input file via FlorisInterface -fi = FlorisInterface("inputs/gch.yaml") - - -# Plot a horizatonal slice of the initial configuration -horizontal_plane = fi.calculate_horizontal_plane(height=90.0) -wakeviz.visualize_cut_plane( - horizontal_plane, - ax=axarr[0], - title="Initial setup", - min_speed=MIN_WS, - max_speed=MAX_WS -) - -# Change the wind speed -horizontal_plane = fi.calculate_horizontal_plane(ws=[7.0], height=90.0) -wakeviz.visualize_cut_plane( - horizontal_plane, - ax=axarr[1], - title="Wind speed at 7 m/s", - min_speed=MIN_WS, - max_speed=MAX_WS -) - - -# Change the wind shear, reset the wind speed, and plot a vertical slice -fi.reinitialize( wind_shear=0.2, wind_speeds=[8.0] ) -y_plane = fi.calculate_y_plane(crossstream_dist=0.0) -wakeviz.visualize_cut_plane( - y_plane, - ax=axarr[2], - title="Wind shear at 0.2", - min_speed=MIN_WS, - max_speed=MAX_WS -) - - -# # Change the farm layout -N = 3 # Number of turbines per row and per column -X, Y = np.meshgrid( - 5.0 * fi.floris.farm.rotor_diameters[0][0][0] * np.arange(0, N, 1), - 5.0 * fi.floris.farm.rotor_diameters[0][0][0] * np.arange(0, N, 1), -) -fi.reinitialize(layout_x=X.flatten(), layout_y=Y.flatten(), wind_directions=[270.0]) -horizontal_plane = fi.calculate_horizontal_plane(height=90.0) -wakeviz.visualize_cut_plane( - horizontal_plane, - ax=axarr[3], - title="3x3 Farm", - min_speed=MIN_WS, - max_speed=MAX_WS -) -wakeviz.add_turbine_id_labels(fi, axarr[3], color="w", backgroundcolor="k") -wakeviz.plot_turbines_with_fi(fi, axarr[3]) - -# Change the yaw angles and configure the plot differently -yaw_angles = np.zeros((1, 1, N * N)) - -## First row -yaw_angles[:,:,0] = 30.0 -yaw_angles[:,:,3] = -30.0 -yaw_angles[:,:,6] = 30.0 - -## Second row -yaw_angles[:,:,1] = -30.0 -yaw_angles[:,:,4] = 30.0 -yaw_angles[:,:,7] = -30.0 - -horizontal_plane = fi.calculate_horizontal_plane(yaw_angles=yaw_angles, height=90.0) -wakeviz.visualize_cut_plane( - horizontal_plane, - ax=axarr[4], - title="Yawesome art", - cmap="PuOr", - min_speed=MIN_WS, - max_speed=MAX_WS -) -wakeviz.plot_turbines_with_fi(fi, axarr[4], yaw_angles=yaw_angles, color="c") - - -# Plot the cross-plane of the 3x3 configuration -cross_plane = fi.calculate_cross_plane(yaw_angles=yaw_angles, downstream_dist=610.0) -wakeviz.visualize_cut_plane( - cross_plane, - ax=axarr[5], - title="Cross section at 610 m", - min_speed=MIN_WS, - max_speed=MAX_WS -) -axarr[5].invert_xaxis() - - -wakeviz.show_plots() diff --git a/examples/04_sweep_wind_directions.py b/examples/04_sweep_wind_directions.py deleted file mode 100644 index 384adad8c..000000000 --- a/examples/04_sweep_wind_directions.py +++ /dev/null @@ -1,75 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface - - -""" -04_sweep_wind_directions - -This example demonstrates vectorization of wind direction. -A vector of wind directions is passed to the intialize function -and the powers of the two simulated turbines is computed for all -wind directions in one call - -The power of both turbines for each wind direction is then plotted - -""" - -# Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model - -# Define a two turbine farm -D = 126. -layout_x = np.array([0, D*6]) -layout_y = [0, 0] -fi.reinitialize(layout_x=layout_x, layout_y=layout_y) - -# Sweep wind speeds but keep wind direction fixed -wd_array = np.arange(250,291,1.) -fi.reinitialize(wind_directions=wd_array) - -# Define a matrix of yaw angles to be all 0 -# Note that yaw angles is now specified as a matrix whose dimesions are -# wd/ws/turbine -num_wd = len(wd_array) # Number of wind directions -num_ws = 1 # Number of wind speeds -num_turbine = len(layout_x) # Number of turbines -yaw_angles = np.zeros((num_wd, num_ws, num_turbine)) - -# Calculate -fi.calculate_wake(yaw_angles=yaw_angles) - -# Collect the turbine powers -turbine_powers = fi.get_turbine_powers() / 1E3 # In kW - -# Pull out the power values per turbine -pow_t0 = turbine_powers[:,:,0].flatten() -pow_t1 = turbine_powers[:,:,1].flatten() - -# Plot -fig, ax = plt.subplots() -ax.plot(wd_array,pow_t0,color='k',label='Upstream Turbine') -ax.plot(wd_array,pow_t1,color='r',label='Downstream Turbine') -ax.grid(True) -ax.legend() -ax.set_xlabel('Wind Direction (deg)') -ax.set_ylabel('Power (kW)') - -plt.show() diff --git a/examples/05_sweep_wind_speeds.py b/examples/05_sweep_wind_speeds.py deleted file mode 100644 index 0b5f83b32..000000000 --- a/examples/05_sweep_wind_speeds.py +++ /dev/null @@ -1,75 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface - - -""" -05_sweep_wind_speeds - -This example demonstrates vectorization of wind speed. -A vector of wind speeds is passed to the intialize function -and the powers of the two simulated turbines is computed for all -wind speeds in one call - -The power of both turbines for each wind speed is then plotted - -""" - - -# Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model - -# Define a two turbine farm -D = 126. -layout_x = np.array([0, D*6]) -layout_y = [0, 0] -fi.reinitialize(layout_x=layout_x, layout_y=layout_y) - -# Sweep wind speeds but keep wind direction fixed -ws_array = np.arange(5,25,0.5) -fi.reinitialize(wind_speeds=ws_array) - -# Define a matrix of yaw angles to be all 0 -# Note that yaw angles is now specified as a matrix whose dimesions are -# wd/ws/turbine -num_wd = 1 -num_ws = len(ws_array) -num_turbine = len(layout_x) -yaw_angles = np.zeros((num_wd, num_ws, num_turbine)) - -# Calculate -fi.calculate_wake(yaw_angles=yaw_angles) - -# Collect the turbine powers -turbine_powers = fi.get_turbine_powers() / 1E3 # In kW - -# Pull out the power values per turbine -pow_t0 = turbine_powers[:,:,0].flatten() -pow_t1 = turbine_powers[:,:,1].flatten() - -# Plot -fig, ax = plt.subplots() -ax.plot(ws_array,pow_t0,color='k',label='Upstream Turbine') -ax.plot(ws_array,pow_t1,color='r',label='Downstream Turbine') -ax.grid(True) -ax.legend() -ax.set_xlabel('Wind Speed (m/s)') -ax.set_ylabel('Power (kW)') -plt.show() diff --git a/examples/06_sweep_wind_conditions.py b/examples/06_sweep_wind_conditions.py deleted file mode 100644 index a9ab80d5f..000000000 --- a/examples/06_sweep_wind_conditions.py +++ /dev/null @@ -1,86 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface - - -""" -06_sweep_wind_conditions - -This example demonstrates vectorization of wind speed and wind direction. -When the intialize function is passed an array of wind speeds and an -array of wind directions it automatically expands the vectors to compute -the result of all combinations. - -This calculation is performed for a single-row 5 turbine farm. In addition -to plotting the powers of the individual turbines, an energy by turbine -calculation is made and plotted by summing over the wind speed and wind direction -axes of the power matrix returned by get_turbine_powers() - -""" - -# Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model - -# Define a 5 turbine farm -D = 126. -layout_x = np.array([0, D*6, D*12, D*18,D*24]) -layout_y = [0, 0, 0, 0, 0] -fi.reinitialize(layout_x=layout_x, layout_y=layout_y) - -# Define a ws and wd to sweep -# Note that all combinations will be computed -ws_array = np.arange(6, 9, 1.) -wd_array = np.arange(250,295,1.) -fi.reinitialize(wind_speeds=ws_array, wind_directions=wd_array) - -# Define a matrix of yaw angles to be all 0 -# Note that yaw angles is now specified as a matrix whose dimesions are -# wd/ws/turbine -num_wd = len(wd_array) -num_ws = len(ws_array) -num_turbine = len(layout_x) -yaw_angles = np.zeros((num_wd, num_ws, num_turbine)) - -# Calculate -fi.calculate_wake(yaw_angles=yaw_angles) - -# Collect the turbine powers -turbine_powers = fi.get_turbine_powers() / 1E3 # In kW - -# Show results by ws and wd -fig, axarr = plt.subplots(num_ws, 1, sharex=True,sharey=True,figsize=(6,10)) -for ws_idx, ws in enumerate(ws_array): - ax = axarr[ws_idx] - for t in range(num_turbine): - ax.plot(wd_array, turbine_powers[:,ws_idx,t].flatten(),label='T%d' % t) - ax.legend() - ax.grid(True) - ax.set_title('Wind Speed = %.1f' % ws) - ax.set_ylabel('Power (kW)') -ax.set_xlabel('Wind Direction (deg)') - -# Sum across wind speeds and directions to show energy produced by turbine as bar plot -# Sum over wind direction (0-axis) and wind speed (1-axis) -energy_by_turbine = np.sum(turbine_powers, axis=(0,1)) -fig, ax = plt.subplots() -ax.bar(['T%d' % t for t in range(num_turbine)],energy_by_turbine) -ax.set_title('Energy Produced by Turbine') - -plt.show() diff --git a/examples/07_calc_aep_from_rose.py b/examples/07_calc_aep_from_rose.py deleted file mode 100644 index be0f6fcbe..000000000 --- a/examples/07_calc_aep_from_rose.py +++ /dev/null @@ -1,88 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import numpy as np -import pandas as pd -from scipy.interpolate import NearestNDInterpolator - -from floris.tools import FlorisInterface - - -""" -This example demonstrates how to calculate the Annual Energy Production (AEP) -of a wind farm using wind rose information stored in a .csv file. - -The wind rose information is first loaded, after which we initialize our Floris -Interface. A 3 turbine farm is generated, and then the turbine wakes and powers -are calculated across all the wind directions. Finally, the farm power is -converted to AEP and reported out. -""" - -# Read the windrose information file and display -df_wr = pd.read_csv("inputs/wind_rose.csv") -print("The wind rose dataframe looks as follows: \n\n {} \n".format(df_wr)) - -# Derive the wind directions and speeds we need to evaluate in FLORIS -wd_array = np.array(df_wr["wd"].unique(), dtype=float) -ws_array = np.array(df_wr["ws"].unique(), dtype=float) - -# Format the frequency array into the conventional FLORIS v3 format, which is -# an np.array with shape (n_wind_directions, n_wind_speeds). To avoid having -# to manually derive how the variables are sorted and how to reshape the -# one-dimensional frequency array, we use a nearest neighbor interpolant. This -# ensures the frequency values are mapped appropriately to the new 2D array. -wd_grid, ws_grid = np.meshgrid(wd_array, ws_array, indexing="ij") -freq_interp = NearestNDInterpolator(df_wr[["wd", "ws"]], df_wr["freq_val"]) -freq = freq_interp(wd_grid, ws_grid) - -# Normalize the frequency array to sum to exactly 1.0 -freq = freq / np.sum(freq) - -# Load the FLORIS object -fi = FlorisInterface("inputs/gch.yaml") # GCH model -# fi = FlorisInterface("inputs/cc.yaml") # CumulativeCurl model - -# Assume a three-turbine wind farm with 5D spacing. We reinitialize the -# floris object and assign the layout, wind speed and wind direction arrays. -D = fi.floris.farm.rotor_diameters[0] # Rotor diameter for the NREL 5 MW -fi.reinitialize( - layout_x=[0.0, 5 * D, 10 * D], - layout_y=[0.0, 0.0, 0.0], - wind_directions=wd_array, - wind_speeds=ws_array, -) - -# Compute the AEP using the default settings -aep = fi.get_farm_AEP(freq=freq) -print("Farm AEP (default options): {:.3f} GWh".format(aep / 1.0e9)) - -# Compute the AEP again while specifying a cut-in and cut-out wind speed. -# The wake calculations are skipped for any wind speed below respectively -# above the cut-in and cut-out wind speed. This can speed up computation and -# prevent unexpected behavior for zero/negative and very high wind speeds. -# In this example, the results should not change between this and the default -# call to 'get_farm_AEP()'. -aep = fi.get_farm_AEP( - freq=freq, - cut_in_wind_speed=3.0, # Wakes are not evaluated below this wind speed - cut_out_wind_speed=25.0, # Wakes are not evaluated above this wind speed -) -print("Farm AEP (with cut_in/out specified): {:.3f} GWh".format(aep / 1.0e9)) - -# Finally, we can also compute the AEP while ignoring all wake calculations. -# This can be useful to quantity the annual wake losses in the farm. Such -# calculations can be facilitated by enabling the 'no_wake' handle. -aep_no_wake = fi.get_farm_AEP(freq, no_wake=True) -print("Farm AEP (no_wake=True): {:.3f} GWh".format(aep_no_wake / 1.0e9)) diff --git a/examples/08_calc_aep_from_rose_use_class.py b/examples/08_calc_aep_from_rose_use_class.py deleted file mode 100644 index 064803324..000000000 --- a/examples/08_calc_aep_from_rose_use_class.py +++ /dev/null @@ -1,82 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import numpy as np - -import floris.tools.visualization as wakeviz -from floris.tools import FlorisInterface, WindRose - - -""" -This example demonstrates how to calculate the Annual Energy Production (AEP) -of a wind farm using wind rose information stored in a .csv file. - -The wind rose information is first loaded, after which we initialize our Floris -Interface. A 3 turbine farm is generated, and then the turbine wakes and powers -are calculated across all the wind directions. Finally, the farm power is -converted to AEP and reported out. -""" - -# Read in the wind rose using the class -wind_rose = WindRose() -wind_rose.read_wind_rose_csv("inputs/wind_rose.csv") - -# Show the wind rose -wind_rose.plot_wind_rose() - -# Load the FLORIS object -fi = FlorisInterface("inputs/gch.yaml") # GCH model -# fi = FlorisInterface("inputs/cc.yaml") # CumulativeCurl model - -# Assume a three-turbine wind farm with 5D spacing. We reinitialize the -# floris object and assign the layout, wind speed and wind direction arrays. -D = 126.0 # Rotor diameter for the NREL 5 MW -fi.reinitialize( - layout_x=[0.0, 5* D, 10 * D], - layout_y=[0.0, 0.0, 0.0], -) - -# Compute the AEP using the default settings -aep = fi.get_farm_AEP_wind_rose_class(wind_rose=wind_rose) -print("Farm AEP (default options): {:.3f} GWh".format(aep / 1.0e9)) - -# Compute the AEP again while specifying a cut-in and cut-out wind speed. -# The wake calculations are skipped for any wind speed below respectively -# above the cut-in and cut-out wind speed. This can speed up computation and -# prevent unexpected behavior for zero/negative and very high wind speeds. -# In this example, the results should not change between this and the default -# call to 'get_farm_AEP()'. -aep = fi.get_farm_AEP_wind_rose_class( - wind_rose=wind_rose, - cut_in_wind_speed=3.0, # Wakes are not evaluated below this wind speed - cut_out_wind_speed=25.0, # Wakes are not evaluated above this wind speed -) -print("Farm AEP (with cut_in/out specified): {:.3f} GWh".format(aep / 1.0e9)) - -# Compute the AEP a final time, this time marking one of the turbines as -# belonging to another farm by setting its weight to 0 -turbine_weights = np.array([1.0, 1.0, 0.0]) -aep = fi.get_farm_AEP_wind_rose_class( - wind_rose=wind_rose, - turbine_weights= turbine_weights -) -print("Farm AEP (one turbine removed from power calculation): {:.3f} GWh".format(aep / 1.0e9)) - -# Finally, we can also compute the AEP while ignoring all wake calculations. -# This can be useful to quantity the annual wake losses in the farm. Such -# calculations can be facilitated by enabling the 'no_wake' handle. -aep_no_wake = fi.get_farm_AEP_wind_rose_class(wind_rose=wind_rose, no_wake=True) -print("Farm AEP (no_wake=True): {:.3f} GWh".format(aep_no_wake / 1.0e9)) - -wakeviz.show_plots() diff --git a/examples/09_compare_farm_power_with_neighbor.py b/examples/09_compare_farm_power_with_neighbor.py deleted file mode 100644 index 714e677a8..000000000 --- a/examples/09_compare_farm_power_with_neighbor.py +++ /dev/null @@ -1,93 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface - - -""" -This example demonstrates how to use turbine_wieghts to define a set of turbines belonging -to a neighboring farm which -impacts the power production of the farm under consideration via wake losses, but whose own -power production is not -considered in farm power / aep production - -The use of neighboring farms in the context of wake steering design is considered in example -examples/10_optimize_yaw_with_neighboring_farm.py -""" - - -# Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 - -# Define a 4 turbine farm turbine farm -D = 126. -layout_x = np.array([0, D*6, 0, D*6]) -layout_y = [0, 0, D*3, D*3] -fi.reinitialize(layout_x = layout_x, layout_y = layout_y) - -# Define a simple wind rose with just 1 wind speed -wd_array = np.arange(0,360,4.) -fi.reinitialize(wind_directions=wd_array, wind_speeds=[8.]) - - -# Calculate -fi.calculate_wake() - -# Collect the farm power -farm_power_base = fi.get_farm_power() / 1E3 # In kW - -# Add a neighbor to the east -layout_x = np.array([0, D*6, 0, D*6, D*12, D*15, D*12, D*15]) -layout_y = np.array([0, 0, D*3, D*3, 0, 0, D*3, D*3]) -fi.reinitialize(layout_x = layout_x, layout_y = layout_y) - -# Define the weights to exclude the neighboring farm from calcuations of power -turbine_weights = np.zeros(len(layout_x), dtype=int) -turbine_weights[0:4] = 1.0 - -# Calculate -fi.calculate_wake() - -# Collect the farm power with the neightbor -farm_power_neighbor = fi.get_farm_power(turbine_weights=turbine_weights) / 1E3 # In kW - -# Show the farms -fig, ax = plt.subplots() -ax.scatter( - layout_x[turbine_weights==1], - layout_y[turbine_weights==1], - color='k', - label='Base Farm' -) -ax.scatter( - layout_x[turbine_weights==0], - layout_y[turbine_weights==0], - color='r', - label='Neighboring Farm' -) -ax.legend() - -# Plot the power difference -fig, ax = plt.subplots() -ax.plot(wd_array,farm_power_base,color='k',label='Farm Power (no neighbor)') -ax.plot(wd_array,farm_power_neighbor,color='r',label='Farm Power (neighboring farm due east)') -ax.grid(True) -ax.legend() -ax.set_xlabel('Wind Direction (deg)') -ax.set_ylabel('Power (kW)') -plt.show() diff --git a/examples/10_opt_yaw_single_ws.py b/examples/10_opt_yaw_single_ws.py deleted file mode 100644 index fd874be31..000000000 --- a/examples/10_opt_yaw_single_ws.py +++ /dev/null @@ -1,76 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR - - -""" -This example demonstrates how to perform a yaw optimization for multiple wind directions -and 1 wind speed. - -First, we initialize our Floris Interface, and then generate a 3 turbine wind farm. -Next, we create the yaw optimization object `yaw_opt` and perform the optimization using the -SerialRefine method. Finally, we plot the results. -""" - -# Load the default example floris object -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model - -# Reinitialize as a 3-turbine farm with range of WDs and 1 WS -D = 126.0 # Rotor diameter for the NREL 5 MW -fi.reinitialize( - layout_x=[0.0, 5 * D, 10 * D], - layout_y=[0.0, 0.0, 0.0], - wind_directions=np.arange(0.0, 360.0, 3.0), - wind_speeds=[8.0], -) -print(fi.floris.farm.rotor_diameters) - -# Initialize optimizer object and run optimization using the Serial-Refine method -yaw_opt = YawOptimizationSR(fi)#, exploit_layout_symmetry=False) -df_opt = yaw_opt.optimize() - -print("Optimization results:") -print(df_opt) - -# Split out the turbine results -for t in range(3): - df_opt['t%d' % t] = df_opt.yaw_angles_opt.apply(lambda x: x[t]) - -# Show the results -fig, axarr = plt.subplots(2,1,sharex=True,sharey=False,figsize=(8,8)) - -# Yaw results -ax = axarr[0] -for t in range(3): - ax.plot(df_opt.wind_direction,df_opt['t%d' % t],label='t%d' % t) -ax.set_ylabel('Yaw Offset (deg') -ax.legend() -ax.grid(True) - -# Power results -ax = axarr[1] -ax.plot(df_opt.wind_direction,df_opt.farm_power_baseline,color='k',label='Baseline Farm Power') -ax.plot(df_opt.wind_direction,df_opt.farm_power_opt,color='r',label='Optimized Farm Power') -ax.set_ylabel('Power (W)') -ax.set_xlabel('Wind Direction (deg)') -ax.legend() -ax.grid(True) - -plt.show() diff --git a/examples/12_optimize_yaw.py b/examples/12_optimize_yaw.py deleted file mode 100644 index 42932c6c6..000000000 --- a/examples/12_optimize_yaw.py +++ /dev/null @@ -1,313 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -from time import perf_counter as timerpc - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd - -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR - - -""" -This example demonstrates how to perform a yaw optimization and evaluate the performance -over a full wind rose. - -The beginning of the file contains the definition of several functions used in the main part -of the script. - -Within the main part of the script, we first load the wind rose information. We then initialize -our Floris Interface object. We determine the baseline AEP using the wind rose information, and -then perform the yaw optimization over 72 wind directions with 1 wind speed per direction. The -optimal yaw angles are then used to determine yaw angles across all the wind speeds included in -the wind rose. Lastly, the final AEP is calculated and analysis of the results are -shown in several plots. -""" - -def load_floris(): - # Load the default example floris object - fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 - # fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model - - # Specify wind farm layout and update in the floris object - N = 5 # number of turbines per row and per column - X, Y = np.meshgrid( - 5.0 * fi.floris.farm.rotor_diameters_sorted[0][0][0] * np.arange(0, N, 1), - 5.0 * fi.floris.farm.rotor_diameters_sorted[0][0][0] * np.arange(0, N, 1), - ) - fi.reinitialize(layout_x=X.flatten(), layout_y=Y.flatten()) - - return fi - - -def load_windrose(): - fn = "inputs/wind_rose.csv" - df = pd.read_csv(fn) - df = df[(df["ws"] < 22)].reset_index(drop=True) # Reduce size - df["freq_val"] = df["freq_val"] / df["freq_val"].sum() # Normalize wind rose frequencies - - return df - - -def calculate_aep(fi, df_windrose, column_name="farm_power"): - from scipy.interpolate import NearestNDInterpolator - - # Define columns - nturbs = len(fi.layout_x) - yaw_cols = ["yaw_{:03d}".format(ti) for ti in range(nturbs)] - - if "yaw_000" not in df_windrose.columns: - df_windrose[yaw_cols] = 0.0 # Add zeros - - # Derive the wind directions and speeds we need to evaluate in FLORIS - wd_array = np.array(df_windrose["wd"].unique(), dtype=float) - ws_array = np.array(df_windrose["ws"].unique(), dtype=float) - yaw_angles = np.array(df_windrose[yaw_cols], dtype=float) - fi.reinitialize(wind_directions=wd_array, wind_speeds=ws_array) - - # Map angles from dataframe onto floris wind direction/speed grid - X, Y = np.meshgrid(wd_array, ws_array, indexing='ij') - interpolant = NearestNDInterpolator(df_windrose[["wd", "ws"]], yaw_angles) - yaw_angles_floris = interpolant(X, Y) - - # Calculate FLORIS for every WD and WS combination and get the farm power - fi.calculate_wake(yaw_angles_floris) - farm_power_array = fi.get_farm_power() - - # Now map FLORIS solutions to dataframe - interpolant = NearestNDInterpolator( - np.vstack([X.flatten(), Y.flatten()]).T, - farm_power_array.flatten() - ) - df_windrose[column_name] = interpolant(df_windrose[["wd", "ws"]]) # Save to dataframe - df_windrose[column_name] = df_windrose[column_name].fillna(0.0) # Replace NaNs with 0.0 - - # Calculate AEP in GWh - aep = np.dot(df_windrose["freq_val"], df_windrose[column_name]) * 365 * 24 / 1e9 - - return aep - - -if __name__ == "__main__": - # Load a dataframe containing the wind rose information - df_windrose = load_windrose() - - # Load FLORIS - fi = load_floris() - fi.reinitialize(wind_speeds=8.0) - nturbs = len(fi.layout_x) - - # First, get baseline AEP, without wake steering - start_time = timerpc() - print(" ") - print("===========================================================") - print("Calculating baseline annual energy production (AEP)...") - aep_bl = calculate_aep(fi, df_windrose, "farm_power_baseline") - t = timerpc() - start_time - print("Baseline AEP: {:.3f} GWh. Time spent: {:.1f} s.".format(aep_bl, t)) - print("===========================================================") - print(" ") - - # Now optimize the yaw angles using the Serial Refine method - print("Now starting yaw optimization for the entire wind rose...") - start_time = timerpc() - fi.reinitialize( - wind_directions=np.arange(0.0, 360.0, 5.0), - wind_speeds=[8.0] - ) - yaw_opt = YawOptimizationSR( - fi=fi, - minimum_yaw_angle=0.0, # Allowable yaw angles lower bound - maximum_yaw_angle=20.0, # Allowable yaw angles upper bound - Ny_passes=[5, 4], - exclude_downstream_turbines=True, - exploit_layout_symmetry=True, - ) - - df_opt = yaw_opt.optimize() - end_time = timerpc() - t_tot = end_time - start_time - t_fi = yaw_opt.time_spent_in_floris - - print("Optimization finished in {:.2f} seconds.".format(t_tot)) - print(" ") - print(df_opt) - print(" ") - - # Now define how the optimal yaw angles for 8 m/s are applied over the other wind speeds - yaw_angles_opt = np.vstack(df_opt["yaw_angles_opt"]) - yaw_angles_wind_rose = np.zeros((df_windrose.shape[0], nturbs)) - for ii, idx in enumerate(df_windrose.index): - wind_speed = df_windrose.loc[idx, "ws"] - wind_direction = df_windrose.loc[idx, "wd"] - - # Interpolate the optimal yaw angles for this wind direction from df_opt - id_opt = df_opt["wind_direction"] == wind_direction - yaw_opt_full = np.array(df_opt.loc[id_opt, "yaw_angles_opt"])[0] - - # Now decide what to do for different wind speeds - if (wind_speed < 4.0) | (wind_speed > 14.0): - yaw_opt = np.zeros(nturbs) # do nothing for very low/high speeds - elif wind_speed < 6.0: - yaw_opt = yaw_opt_full * (6.0 - wind_speed) / 2.0 # Linear ramp up - elif wind_speed > 12.0: - yaw_opt = yaw_opt_full * (14.0 - wind_speed) / 2.0 # Linear ramp down - else: - yaw_opt = yaw_opt_full # Apply full offsets between 6.0 and 12.0 m/s - - # Save to collective array - yaw_angles_wind_rose[ii, :] = yaw_opt - - # Add optimal and interpolated angles to the wind rose dataframe - yaw_cols = ["yaw_{:03d}".format(ti) for ti in range(nturbs)] - df_windrose[yaw_cols] = yaw_angles_wind_rose - - # Now get AEP with optimized yaw angles - start_time = timerpc() - print("==================================================================") - print("Calculating annual energy production (AEP) with wake steering...") - aep_opt = calculate_aep(fi, df_windrose, "farm_power_opt") - aep_uplift = 100.0 * (aep_opt / aep_bl - 1) - t = timerpc() - start_time - print("Optimal AEP: {:.3f} GWh. Time spent: {:.1f} s.".format(aep_opt, t)) - print("Relative AEP uplift by wake steering: {:.3f} %.".format(aep_uplift)) - print("==================================================================") - print(" ") - - # Now calculate helpful variables and then plot wind rose information - df = df_windrose.copy() - df["farm_power_relative"] = ( - df["farm_power_opt"] / df["farm_power_baseline"] - ) - df["farm_energy_baseline"] = df["freq_val"] * df["farm_power_baseline"] - df["farm_energy_opt"] = df["freq_val"] * df["farm_power_opt"] - df["energy_uplift"] = df["farm_energy_opt"] - df["farm_energy_baseline"] - df["rel_energy_uplift"] = df["energy_uplift"] / df["energy_uplift"].sum() - - # Plot power and AEP uplift across wind direction - fig, ax = plt.subplots(nrows=3, sharex=True) - - df_8ms = df[df["ws"] == 8.0].reset_index(drop=True) - pow_uplift = 100 * ( - df_8ms["farm_power_opt"] / df_8ms["farm_power_baseline"] - 1 - ) - ax[0].bar( - x=df_8ms["wd"], - height=pow_uplift, - color="darkgray", - edgecolor="black", - width=4.5, - ) - ax[0].set_ylabel("Power uplift \n at 8 m/s (%)") - ax[0].grid(True) - - dist = df.groupby("wd").sum().reset_index() - ax[1].bar( - x=dist["wd"], - height=100 * dist["rel_energy_uplift"], - color="darkgray", - edgecolor="black", - width=4.5, - ) - ax[1].set_ylabel("Contribution to \n AEP uplift (%)") - ax[1].grid(True) - - ax[2].bar( - x=dist["wd"], - height=dist["freq_val"], - color="darkgray", - edgecolor="black", - width=4.5, - ) - ax[2].set_xlabel("Wind direction (deg)") - ax[2].set_ylabel("Frequency of \n occurrence (-)") - ax[2].grid(True) - plt.tight_layout() - - # Plot power and AEP uplift across wind direction - fig, ax = plt.subplots(nrows=3, sharex=True) - - df_avg = df.groupby("ws").mean().reset_index(drop=False) - mean_power_uplift = 100.0 * (df_avg["farm_power_relative"] - 1.0) - ax[0].bar( - x=df_avg["ws"], - height=mean_power_uplift, - color="darkgray", - edgecolor="black", - width=0.95, - ) - ax[0].set_ylabel("Mean power \n uplift (%)") - ax[0].grid(True) - - dist = df.groupby("ws").sum().reset_index() - ax[1].bar( - x=dist["ws"], - height=100 * dist["rel_energy_uplift"], - color="darkgray", - edgecolor="black", - width=0.95, - ) - ax[1].set_ylabel("Contribution to \n AEP uplift (%)") - ax[1].grid(True) - - ax[2].bar( - x=dist["ws"], - height=dist["freq_val"], - color="darkgray", - edgecolor="black", - width=0.95, - ) - ax[2].set_xlabel("Wind speed (m/s)") - ax[2].set_ylabel("Frequency of \n occurrence (-)") - ax[2].grid(True) - plt.tight_layout() - - # Now plot yaw angle distributions over wind direction up to first three turbines - for ti in range(np.min([nturbs, 3])): - fig, ax = plt.subplots(figsize=(6, 3.5)) - ax.plot( - df_opt["wind_direction"], - yaw_angles_opt[:, ti], - "-o", - color="maroon", - markersize=3, - label="For wind speeds between 6 and 12 m/s", - ) - ax.plot( - df_opt["wind_direction"], - 0.5 * yaw_angles_opt[:, ti], - "-v", - color="dodgerblue", - markersize=3, - label="For wind speeds of 5 and 13 m/s", - ) - ax.plot( - df_opt["wind_direction"], - 0.0 * yaw_angles_opt[:, ti], - "-o", - color="grey", - markersize=3, - label="For wind speeds below 4 and above 14 m/s", - ) - ax.set_ylabel("Assigned yaw offsets (deg)") - ax.set_xlabel("Wind direction (deg)") - ax.set_title("Turbine {:d}".format(ti)) - ax.grid(True) - ax.legend() - plt.tight_layout() - - plt.show() diff --git a/examples/12_optimize_yaw_in_parallel.py b/examples/12_optimize_yaw_in_parallel.py deleted file mode 100644 index 33c996dc1..000000000 --- a/examples/12_optimize_yaw_in_parallel.py +++ /dev/null @@ -1,290 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -from scipy.interpolate import LinearNDInterpolator - -from floris.tools import FlorisInterface, ParallelComputingInterface - - -""" -This example demonstrates how to perform a yaw optimization using parallel computing. -... -""" - -def load_floris(): - # Load the default example floris object - fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 - # fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model - - # Specify wind farm layout and update in the floris object - N = 4 # number of turbines per row and per column - X, Y = np.meshgrid( - 5.0 * fi.floris.farm.rotor_diameters_sorted[0][0][0] * np.arange(0, N, 1), - 5.0 * fi.floris.farm.rotor_diameters_sorted[0][0][0] * np.arange(0, N, 1), - ) - fi.reinitialize(layout_x=X.flatten(), layout_y=Y.flatten()) - - return fi - - -def load_windrose(): - # Grab a linear interpolant from this wind rose - df = pd.read_csv("inputs/wind_rose.csv") - interp = LinearNDInterpolator(points=df[["wd", "ws"]], values=df["freq_val"], fill_value=0.0) - return df, interp - - -if __name__ == "__main__": - # Parallel options - max_workers = 16 - - # Load a dataframe containing the wind rose information - df_windrose, windrose_interpolant = load_windrose() - - # Load a FLORIS object for AEP calculations - fi_aep = load_floris() - wind_directions = np.arange(0.0, 360.0, 1.0) - wind_speeds = np.arange(1.0, 25.0, 1.0) - fi_aep.reinitialize( - wind_directions=wind_directions, - wind_speeds=wind_speeds, - turbulence_intensity=0.08 # Assume 8% turbulence intensity - ) - - # Pour this into a parallel computing interface - parallel_interface = "concurrent" - fi_aep_parallel = ParallelComputingInterface( - fi=fi_aep, - max_workers=max_workers, - n_wind_direction_splits=max_workers, - n_wind_speed_splits=1, - interface=parallel_interface, - print_timings=True, - ) - - # Calculate frequency of occurrence for each bin and normalize sum to 1.0 - wd_grid, ws_grid = np.meshgrid(wind_directions, wind_speeds, indexing="ij") - freq_grid = windrose_interpolant(wd_grid, ws_grid) - freq_grid = freq_grid / np.sum(freq_grid) # Normalize to 1.0 - - # Calculate farm power baseline - farm_power_bl = fi_aep_parallel.get_farm_power() - aep_bl = np.sum(24 * 365 * np.multiply(farm_power_bl, freq_grid)) - - # Alternatively to above code, we could calculate AEP using - # 'fi_aep_parallel.get_farm_AEP(...)' but then we would not have the - # farm power productions, which we use later on for plotting. - - # First, get baseline AEP, without wake steering - print(" ") - print("===========================================================") - print("Calculating baseline annual energy production (AEP)...") - print("Baseline AEP: {:.3f} GWh.".format(aep_bl / 1.0e9)) - print("===========================================================") - print(" ") - - # Load a FLORIS object for yaw optimization - fi_opt = load_floris() - wind_directions = np.arange(0.0, 360.0, 3.0) - wind_speeds = np.arange(6.0, 14.0, 2.0) - fi_opt.reinitialize( - wind_directions=wind_directions, - wind_speeds=wind_speeds, - turbulence_intensity=0.08 # Assume 8% turbulence intensity - ) - - # Pour this into a parallel computing interface - fi_opt_parallel = ParallelComputingInterface( - fi=fi_opt, - max_workers=max_workers, - n_wind_direction_splits=max_workers, - n_wind_speed_splits=1, - interface=parallel_interface, - print_timings=True, - ) - - # Now optimize the yaw angles using the Serial Refine method - df_opt = fi_opt_parallel.optimize_yaw_angles( - minimum_yaw_angle=-25.0, - maximum_yaw_angle=25.0, - Ny_passes=[5, 4], - exclude_downstream_turbines=True, - exploit_layout_symmetry=False, - ) - - - - # Assume linear ramp up at 5-6 m/s and ramp down at 13-14 m/s, - # add to table for linear interpolant - df_copy_lb = df_opt[df_opt["wind_speed"] == 6.0].copy() - df_copy_ub = df_opt[df_opt["wind_speed"] == 13.0].copy() - df_copy_lb["wind_speed"] = 5.0 - df_copy_ub["wind_speed"] = 14.0 - df_copy_lb["yaw_angles_opt"] *= 0.0 - df_copy_ub["yaw_angles_opt"] *= 0.0 - df_opt = pd.concat([df_copy_lb, df_opt, df_copy_ub], axis=0).reset_index(drop=True) - - # Deal with 360 deg wrapping: solutions at 0 deg are also solutions at 360 deg - df_copy_360deg = df_opt[df_opt["wind_direction"] == 0.0].copy() - df_copy_360deg["wind_direction"] = 360.0 - df_opt = pd.concat([df_opt, df_copy_360deg], axis=0).reset_index(drop=True) - - # Derive linear interpolant from solution space - yaw_angles_interpolant = LinearNDInterpolator( - points=df_opt[["wind_direction", "wind_speed"]], - values=np.vstack(df_opt["yaw_angles_opt"]), - fill_value=0.0, - ) - - # Get optimized AEP, with wake steering - yaw_grid = yaw_angles_interpolant(wd_grid, ws_grid) - farm_power_opt = fi_aep_parallel.get_farm_power(yaw_angles=yaw_grid) - aep_opt = np.sum(24 * 365 * np.multiply(farm_power_opt, freq_grid)) - aep_uplift = 100.0 * (aep_opt / aep_bl - 1) - - # Alternatively to above code, we could calculate AEP using - # 'fi_aep_parallel.get_farm_AEP(...)' but then we would not have the - # farm power productions, which we use later on for plotting. - - print(" ") - print("===========================================================") - print("Calculating optimized annual energy production (AEP)...") - print("Optimized AEP: {:.3f} GWh.".format(aep_opt / 1.0e9)) - print("Relative AEP uplift by wake steering: {:.3f} %.".format(aep_uplift)) - print("===========================================================") - print(" ") - - # Now calculate helpful variables and then plot wind rose information - farm_energy_bl = np.multiply(freq_grid, farm_power_bl) - farm_energy_opt = np.multiply(freq_grid, farm_power_opt) - df = pd.DataFrame({ - "wd": wd_grid.flatten(), - "ws": ws_grid.flatten(), - "freq_val": freq_grid.flatten(), - "farm_power_baseline": farm_power_bl.flatten(), - "farm_power_opt": farm_power_opt.flatten(), - "farm_power_relative": farm_power_opt.flatten() / farm_power_bl.flatten(), - "farm_energy_baseline": farm_energy_bl.flatten(), - "farm_energy_opt": farm_energy_opt.flatten(), - "energy_uplift": (farm_energy_opt - farm_energy_bl).flatten(), - "rel_energy_uplift": farm_energy_opt.flatten() / np.sum(farm_energy_bl) - }) - - # Plot power and AEP uplift across wind direction - wd_step = np.diff(fi_aep.floris.flow_field.wind_directions)[0] # Useful variable for plotting - fig, ax = plt.subplots(nrows=3, sharex=True) - - df_8ms = df[df["ws"] == 8.0].reset_index(drop=True) - pow_uplift = 100 * ( - df_8ms["farm_power_opt"] / df_8ms["farm_power_baseline"] - 1 - ) - ax[0].bar( - x=df_8ms["wd"], - height=pow_uplift, - color="darkgray", - edgecolor="black", - width=wd_step, - ) - ax[0].set_ylabel("Power uplift \n at 8 m/s (%)") - ax[0].grid(True) - - dist = df.groupby("wd").sum().reset_index() - ax[1].bar( - x=dist["wd"], - height=100 * dist["rel_energy_uplift"], - color="darkgray", - edgecolor="black", - width=wd_step, - ) - ax[1].set_ylabel("Contribution to \n AEP uplift (%)") - ax[1].grid(True) - - ax[2].bar( - x=dist["wd"], - height=dist["freq_val"], - color="darkgray", - edgecolor="black", - width=wd_step, - ) - ax[2].set_xlabel("Wind direction (deg)") - ax[2].set_ylabel("Frequency of \n occurrence (-)") - ax[2].grid(True) - plt.tight_layout() - - # Plot power and AEP uplift across wind direction - fig, ax = plt.subplots(nrows=3, sharex=True) - - df_avg = df.groupby("ws").mean().reset_index(drop=False) - mean_power_uplift = 100.0 * (df_avg["farm_power_relative"] - 1.0) - ax[0].bar( - x=df_avg["ws"], - height=mean_power_uplift, - color="darkgray", - edgecolor="black", - width=0.95, - ) - ax[0].set_ylabel("Mean power \n uplift (%)") - ax[0].grid(True) - - dist = df.groupby("ws").sum().reset_index() - ax[1].bar( - x=dist["ws"], - height=100 * dist["rel_energy_uplift"], - color="darkgray", - edgecolor="black", - width=0.95, - ) - ax[1].set_ylabel("Contribution to \n AEP uplift (%)") - ax[1].grid(True) - - ax[2].bar( - x=dist["ws"], - height=dist["freq_val"], - color="darkgray", - edgecolor="black", - width=0.95, - ) - ax[2].set_xlabel("Wind speed (m/s)") - ax[2].set_ylabel("Frequency of \n occurrence (-)") - ax[2].grid(True) - plt.tight_layout() - - # Now plot yaw angle distributions over wind direction up to first three turbines - wd_plot = np.arange(0.0, 360.001, 1.0) - for ti in range(np.min([fi_aep.floris.farm.n_turbines, 3])): - fig, ax = plt.subplots(figsize=(6, 3.5)) - ws_to_plot = [6.0, 9.0, 12.0] - colors = ["maroon", "dodgerblue", "grey"] - styles = ["-o", "-v", "-o"] - for ii, ws in enumerate(ws_to_plot): - ax.plot( - wd_plot, - yaw_angles_interpolant(wd_plot, ws * np.ones_like(wd_plot))[:, ti], - styles[ii], - color=colors[ii], - markersize=3, - label="For wind speed of {:.1f} m/s".format(ws), - ) - ax.set_ylabel("Assigned yaw offsets (deg)") - ax.set_xlabel("Wind direction (deg)") - ax.set_title("Turbine {:d}".format(ti)) - ax.grid(True) - ax.legend() - plt.tight_layout() - - plt.show() diff --git a/examples/13_optimize_yaw_with_neighboring_farm.py b/examples/13_optimize_yaw_with_neighboring_farm.py deleted file mode 100644 index 8945dcdfc..000000000 --- a/examples/13_optimize_yaw_with_neighboring_farm.py +++ /dev/null @@ -1,323 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -from scipy.interpolate import NearestNDInterpolator - -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR - - -""" -This example demonstrates how to perform a yaw optimization and evaluate the performance over a -full wind rose. - -The beginning of the file contains the definition of several functions used in the main part of -the script. - -Within the main part of the script, we first load the wind rose information. -We then initialize our Floris Interface object. We determine the baseline AEP using the -wind rose information, and then perform the yaw optimization over 72 wind directions with 1 -wind speed per direction. The optimal yaw angles are then used to determine yaw angles across -all the wind speeds included in the wind rose. Lastly, the final AEP is calculated and analysis -of the results are shown in several plots. -""" - -def load_floris(): - # Load the default example floris object - fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 - # fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model - - # Specify the full wind farm layout: nominal and neighboring wind farms - X = np.array( - [ - 0., 756., 1512., 2268., 3024., 0., 756., 1512., - 2268., 3024., 0., 756., 1512., 2268., 3024., 0., - 756., 1512., 2268., 3024., 4500., 5264., 6028., 4878., - 0., 756., 1512., 2268., 3024., - ] - ) / 1.5 - Y = np.array( - [ - 0., 0., 0., 0., 0., 504., 504., 504., - 504., 504., 1008., 1008., 1008., 1008., 1008., 1512., - 1512., 1512., 1512., 1512., 4500., 4059., 3618., 5155., - -504., -504., -504., -504., -504., - ] - ) / 1.5 - - # Turbine weights: we want to only optimize for the first 10 turbines - turbine_weights = np.zeros(len(X), dtype=int) - turbine_weights[0:10] = 1.0 - - # Now reinitialize FLORIS layout - fi.reinitialize(layout_x = X, layout_y = Y) - - # And visualize the floris layout - fig, ax = plt.subplots() - ax.plot(X[turbine_weights == 0], Y[turbine_weights == 0], 'ro', label="Neighboring farms") - ax.plot(X[turbine_weights == 1], Y[turbine_weights == 1], 'go', label='Farm subset') - ax.grid(True) - ax.set_xlabel("x coordinate (m)") - ax.set_ylabel("y coordinate (m)") - ax.legend() - - return fi, turbine_weights - - -def load_windrose(): - # Load the wind rose information from an external file - df = pd.read_csv("inputs/wind_rose.csv") - df = df[(df["ws"] < 22)].reset_index(drop=True) # Reduce size - df["freq_val"] = df["freq_val"] / df["freq_val"].sum() # Normalize wind rose frequencies - - # Now put the wind rose information in FLORIS format - ws_windrose = df["ws"].unique() - wd_windrose = df["wd"].unique() - wd_grid, ws_grid = np.meshgrid(wd_windrose, ws_windrose, indexing="ij") - - # Use an interpolant to shape the 'freq_val' vector appropriately. You can - # also use np.reshape(), but NearestNDInterpolator is more fool-proof. - freq_interpolant = NearestNDInterpolator( - df[["ws", "wd"]], df["freq_val"] - ) - freq = freq_interpolant(wd_grid, ws_grid) - freq_windrose = freq / freq.sum() # Normalize to sum to 1.0 - - return ws_windrose, wd_windrose, freq_windrose - - -def optimize_yaw_angles(fi_opt): - # Specify turbines to optimize - turbs_to_opt = np.zeros(len(fi_opt.layout_x), dtype=bool) - turbs_to_opt[0:10] = True - - # Specify turbine weights - turbine_weights = np.zeros(len(fi_opt.layout_x)) - turbine_weights[turbs_to_opt] = 1.0 - - # Specify minimum and maximum allowable yaw angle limits - minimum_yaw_angle = np.zeros( - ( - fi_opt.floris.flow_field.n_wind_directions, - fi_opt.floris.flow_field.n_wind_speeds, - fi_opt.floris.farm.n_turbines - ) - ) - maximum_yaw_angle = np.zeros( - ( - fi_opt.floris.flow_field.n_wind_directions, - fi_opt.floris.flow_field.n_wind_speeds, - fi_opt.floris.farm.n_turbines - ) - ) - maximum_yaw_angle[:, :, turbs_to_opt] = 30.0 - - yaw_opt = YawOptimizationSR( - fi=fi_opt, - minimum_yaw_angle=minimum_yaw_angle, - maximum_yaw_angle=maximum_yaw_angle, - turbine_weights=turbine_weights, - Ny_passes=[5], - exclude_downstream_turbines=True, - ) - - df_opt = yaw_opt.optimize() - yaw_angles_opt = yaw_opt.yaw_angles_opt - print("Optimization finished.") - print(" ") - print(df_opt) - print(" ") - - # Now create an interpolant from the optimal yaw angles - def yaw_opt_interpolant(wd, ws): - # Format the wind directions and wind speeds accordingly - wd = np.array(wd, dtype=float) - ws = np.array(ws, dtype=float) - - # Interpolate optimal yaw angles - x = yaw_opt.fi.floris.flow_field.wind_directions - nturbs = fi_opt.floris.farm.n_turbines - y = np.stack( - [np.interp(wd, x, yaw_angles_opt[:, 0, ti]) for ti in range(nturbs)], - axis=np.ndim(wd) - ) - - # Now, we want to apply a ramp-up region near cut-in and ramp-down - # region near cut-out wind speed for the yaw offsets. - lim = np.ones(np.shape(wd), dtype=float) # Introduce a multiplication factor - - # Dont do wake steering under 4 m/s or above 14 m/s - lim[(ws <= 4.0) | (ws >= 14.0)] = 0.0 - - # Linear ramp up for the maximum yaw offset between 4.0 and 6.0 m/s - ids = (ws > 4.0) & (ws < 6.0) - lim[ids] = (ws[ids] - 4.0) / 2.0 - - # Linear ramp down for the maximum yaw offset between 12.0 and 14.0 m/s - ids = (ws > 12.0) & (ws < 14.0) - lim[ids] = (ws[ids] - 12.0) / 2.0 - - # Copy over multiplication factor to every turbine - lim = np.expand_dims(lim, axis=np.ndim(wd)).repeat(nturbs, axis=np.ndim(wd)) - lim = lim * 30.0 # These are the limits - - # Finally, Return clipped yaw offsets to the limits - return np.clip(a=y, a_min=0.0, a_max=lim) - - # Return the yaw interpolant - return yaw_opt_interpolant - - -if __name__ == "__main__": - # Load FLORIS: full farm including neighboring wind farms - fi, turbine_weights = load_floris() - nturbs = len(fi.layout_x) - - # Load a dataframe containing the wind rose information - ws_windrose, wd_windrose, freq_windrose = load_windrose() - ws_windrose = ws_windrose + 0.001 # Deal with 0.0 m/s discrepancy - - # Create a FLORIS object for AEP calculations - fi_AEP = fi.copy() - fi_AEP.reinitialize(wind_speeds=ws_windrose, wind_directions=wd_windrose) - - # And create a separate FLORIS object for optimization - fi_opt = fi.copy() - fi_opt.reinitialize( - wind_directions=np.arange(0.0, 360.0, 3.0), - wind_speeds=[8.0] - ) - - # First, get baseline AEP, without wake steering - print(" ") - print("===========================================================") - print("Calculating baseline annual energy production (AEP)...") - aep_bl_subset = 1.0e-9 * fi_AEP.get_farm_AEP( - freq=freq_windrose, - turbine_weights=turbine_weights - ) - print("Baseline AEP for subset farm: {:.3f} GWh.".format(aep_bl_subset)) - print("===========================================================") - print(" ") - - # Now optimize the yaw angles using the Serial Refine method. We first - # create a copy of the floris object for optimization purposes and assign - # it the atmospheric conditions for which we want to optimize. Typically, - # the optimal yaw angles are very insensitive to the actual wind speed, - # and hence we only optimize for a single wind speed of 8.0 m/s. We assume - # that the optimal yaw angles at 8.0 m/s are also optimal at other wind - # speeds between 4 and 12 m/s. - print("Now starting yaw optimization for the entire wind rose for farm subset...") - - # In this hypothetical case, we can only control the yaw angles of the - # turbines of the wind farm subset (i.e., the first 10 wind turbines). - # Hence, we constrain the yaw angles of the neighboring wind farms to 0.0. - turbs_to_opt = (turbine_weights > 0.0001) - - # Optimize yaw angles while including neighboring farm - yaw_opt_interpolant = optimize_yaw_angles(fi_opt=fi_opt) - - # Optimize yaw angles while ignoring neighboring farm - fi_opt_subset = fi_opt.copy() - fi_opt_subset.reinitialize( - layout_x = fi.layout_x[turbs_to_opt], - layout_y = fi.layout_y[turbs_to_opt] - ) - yaw_opt_interpolant_nonb = optimize_yaw_angles(fi_opt=fi_opt_subset) - - # Use interpolant to get optimal yaw angles for fi_AEP object - X, Y = np.meshgrid( - fi_AEP.floris.flow_field.wind_directions, - fi_AEP.floris.flow_field.wind_speeds, - indexing="ij" - ) - yaw_angles_opt_AEP = yaw_opt_interpolant(X, Y) - yaw_angles_opt_nonb_AEP = np.zeros_like(yaw_angles_opt_AEP) # nonb = no neighbor - yaw_angles_opt_nonb_AEP[:, :, turbs_to_opt] = yaw_opt_interpolant_nonb(X, Y) - - # Now get AEP with optimized yaw angles - print(" ") - print("===========================================================") - print("Calculating annual energy production with wake steering (AEP)...") - aep_opt_subset_nonb = 1.0e-9 * fi_AEP.get_farm_AEP( - freq=freq_windrose, - turbine_weights=turbine_weights, - yaw_angles=yaw_angles_opt_nonb_AEP, - ) - aep_opt_subset = 1.0e-9 * fi_AEP.get_farm_AEP( - freq=freq_windrose, - turbine_weights=turbine_weights, - yaw_angles=yaw_angles_opt_AEP, - ) - uplift_subset_nonb = 100.0 * (aep_opt_subset_nonb - aep_bl_subset) / aep_bl_subset - uplift_subset = 100.0 * (aep_opt_subset - aep_bl_subset) / aep_bl_subset - print( - "Optimized AEP for subset farm (including neighbor farms' wakes): " - f"{aep_opt_subset_nonb:.3f} GWh (+{uplift_subset_nonb:.2f}%)." - ) - print( - "Optimized AEP for subset farm (ignoring neighbor farms' wakes): " - f"{aep_opt_subset:.3f} GWh (+{uplift_subset:.2f}%)." - ) - print("===========================================================") - print(" ") - - # Plot power and AEP uplift across wind direction at wind_speed of 8 m/s - X, Y = np.meshgrid( - fi_opt.floris.flow_field.wind_directions, - fi_opt.floris.flow_field.wind_speeds, - indexing="ij", - ) - yaw_angles_opt = yaw_opt_interpolant(X, Y) - - yaw_angles_opt_nonb = np.zeros_like(yaw_angles_opt) # nonb = no neighbor - yaw_angles_opt_nonb[:, :, turbs_to_opt] = yaw_opt_interpolant_nonb(X, Y) - - fi_opt = fi_opt.copy() - fi_opt.calculate_wake(yaw_angles=np.zeros_like(yaw_angles_opt)) - farm_power_bl_subset = fi_opt.get_farm_power(turbine_weights).flatten() - - fi_opt = fi_opt.copy() - fi_opt.calculate_wake(yaw_angles=yaw_angles_opt) - farm_power_opt_subset = fi_opt.get_farm_power(turbine_weights).flatten() - - fi_opt = fi_opt.copy() - fi_opt.calculate_wake(yaw_angles=yaw_angles_opt_nonb) - farm_power_opt_subset_nonb = fi_opt.get_farm_power(turbine_weights).flatten() - - fig, ax = plt.subplots() - ax.bar( - x=fi_opt.floris.flow_field.wind_directions - 0.65, - height=100.0 * (farm_power_opt_subset / farm_power_bl_subset - 1.0), - edgecolor="black", - width=1.3, - label="Including wake effects of neighboring farms" - ) - ax.bar( - x=fi_opt.floris.flow_field.wind_directions + 0.65, - height=100.0 * (farm_power_opt_subset_nonb / farm_power_bl_subset - 1.0), - edgecolor="black", - width=1.3, - label="Ignoring neighboring farms" - ) - ax.set_ylabel("Power uplift \n at 8 m/s (%)") - ax.legend() - ax.grid(True) - ax.set_xlabel("Wind direction (deg)") - - plt.show() diff --git a/examples/15_optimize_layout.py b/examples/15_optimize_layout.py deleted file mode 100644 index 68ff4a895..000000000 --- a/examples/15_optimize_layout.py +++ /dev/null @@ -1,90 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import os - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools.optimization.layout_optimization.layout_optimization_scipy import ( - LayoutOptimizationScipy, -) - - -""" -This example shows a simple layout optimization using the python module Scipy. - -A 4 turbine array is optimized such that the layout of the turbine produces the -highest annual energy production (AEP) based on the given wind resource. The turbines -are constrained to a square boundary and a random wind resource is supplied. The results -of the optimization show that the turbines are pushed to the outer corners of the boundary, -which makes sense in order to maximize the energy production by minimizing wake interactions. -""" - -# Initialize the FLORIS interface fi -file_dir = os.path.dirname(os.path.abspath(__file__)) -fi = FlorisInterface('inputs/gch.yaml') - -# Setup 72 wind directions with a random wind speed and frequency distribution -wind_directions = np.arange(0, 360.0, 5.0) -np.random.seed(1) -wind_speeds = 8.0 + np.random.randn(1) * 0.5 -# Shape frequency distribution to match number of wind directions and wind speeds -freq = ( - np.abs( - np.sort( - np.random.randn(len(wind_directions)) - ) - ) - .reshape( ( len(wind_directions), len(wind_speeds) ) ) -) -freq = freq / freq.sum() - -fi.reinitialize(wind_directions=wind_directions, wind_speeds=wind_speeds) - -# The boundaries for the turbines, specified as vertices -boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] - -# Set turbine locations to 4 turbines in a rectangle -D = 126.0 # rotor diameter for the NREL 5MW -layout_x = [0, 0, 6 * D, 6 * D] -layout_y = [0, 4 * D, 0, 4 * D] -fi.reinitialize(layout_x=layout_x, layout_y=layout_y) - -# Setup the optimization problem -layout_opt = LayoutOptimizationScipy(fi, boundaries, freq=freq) - -# Run the optimization -sol = layout_opt.optimize() - -# Get the resulting improvement in AEP -print('... calcuating improvement in AEP') -fi.calculate_wake() -base_aep = fi.get_farm_AEP(freq=freq) / 1e6 -fi.reinitialize(layout_x=sol[0], layout_y=sol[1]) -fi.calculate_wake() -opt_aep = fi.get_farm_AEP(freq=freq) / 1e6 -percent_gain = 100 * (opt_aep - base_aep) / base_aep - -# Print and plot the results -print(f'Optimal layout: {sol}') -print( - f'Optimal layout improves AEP by {percent_gain:.1f}% ' - f'from {base_aep:.1f} MWh to {opt_aep:.1f} MWh' -) -layout_opt.plot_layout_opt_results() - -plt.show() diff --git a/examples/16_heterogeneous_inflow.py b/examples/16_heterogeneous_inflow.py deleted file mode 100644 index 3dedf05e7..000000000 --- a/examples/16_heterogeneous_inflow.py +++ /dev/null @@ -1,176 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt - -from floris.tools import FlorisInterface -from floris.tools.visualization import visualize_cut_plane - - -""" -This example showcases the heterogeneous inflow capabilities of FLORIS. -Heterogeneous flow can be defined in either 2- or 3-dimensions. - -For the 2-dimensional case, it can be seen that the freestream velocity -only varies in the x direction. For the 3-dimensional case, it can be -seen that the freestream velocity only varies in the z direction. This -is because of how the speed ups for each case were defined. More complex -inflow conditions can be defined. - -For each case, we are plotting three slices of the resulting flow field: -1. Horizontal slice parallel to the ground and located at the hub height -2. Vertical slice parallel with the direction of the wind -3. Veritical slice parallel to to the turbine disc plane -""" - - -# Initialize FLORIS with the given input file via FlorisInterface. -# Note that the heterogeneous flow is defined in the input file. The heterogenous_inflow_config -# dictionary is defined as below. The speed ups are multipliers of the ambient wind speed, -# and the x and y are the locations of the speed ups. -# -# heterogenous_inflow_config = { -# 'speed_multipliers': [[2.0, 1.0, 2.0, 1.0]], -# 'x': [-300.0, -300.0, 2600.0, 2600.0], -# 'y': [ -300.0, 300.0, -300.0, 300.0], -# } - - -fi_2d = FlorisInterface("inputs/gch_heterogeneous_inflow.yaml") - -# Set shear to 0.0 to highlight the heterogeneous inflow -fi_2d.reinitialize(wind_shear=0.0) - -# Using the FlorisInterface functions for generating plots, run FLORIS -# and extract 2D planes of data. -horizontal_plane_2d = fi_2d.calculate_horizontal_plane( - x_resolution=200, - y_resolution=100, - height=90.0 -) -y_plane_2d = fi_2d.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) -cross_plane_2d = fi_2d.calculate_cross_plane( - y_resolution=100, - z_resolution=100, - downstream_dist=500.0 -) - -# Create the plots -fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) -ax_list = ax_list.flatten() -visualize_cut_plane( - horizontal_plane_2d, - ax=ax_list[0], - title="Horizontal", - color_bar=True, - label_contours=True -) -ax_list[0].set_xlabel('x') -ax_list[0].set_ylabel('y') -visualize_cut_plane( - y_plane_2d, - ax=ax_list[1], - title="Streamwise profile", - color_bar=True, - label_contours=True -) -ax_list[1].set_xlabel('x') -ax_list[1].set_ylabel('z') -visualize_cut_plane( - cross_plane_2d, - ax=ax_list[2], - title="Spanwise profile at 500m downstream", - color_bar=True, - label_contours=True -) -ax_list[2].set_xlabel('y') -ax_list[2].set_ylabel('z') - - -# Define the speed ups of the heterogeneous inflow, and their locations. -# For the 3-dimensional case, this requires x, y, and z locations. -# The speed ups are multipliers of the ambient wind speed. -speed_multipliers = [[1.0, 1.0, 2.0, 2.0, 1.0, 1.0, 2.0, 2.0]] -x_locs = [-300.0, -300.0, -300.0, -300.0, 2600.0, 2600.0, 2600.0, 2600.0] -y_locs = [-300.0, 300.0, -300.0, 300.0, -300.0, 300.0, -300.0, 300.0] -z_locs = [540.0, 540.0, 0.0, 0.0, 540.0, 540.0, 0.0, 0.0] - -# Create the configuration dictionary to be used for the heterogeneous inflow. -heterogenous_inflow_config = { - 'speed_multipliers': speed_multipliers, - 'x': x_locs, - 'y': y_locs, - 'z': z_locs, -} - -# Initialize FLORIS with the given input file via FlorisInterface. -# Note that we initialize FLORIS with a homogenous flow input file, but -# then configure the heterogeneous inflow via the reinitialize method. -fi_3d = FlorisInterface("inputs/gch.yaml") -fi_3d.reinitialize(heterogenous_inflow_config=heterogenous_inflow_config) - -# Set shear to 0.0 to highlight the heterogeneous inflow -fi_3d.reinitialize(wind_shear=0.0) - -# Using the FlorisInterface functions for generating plots, run FLORIS -# and extract 2D planes of data. -horizontal_plane_3d = fi_3d.calculate_horizontal_plane( - x_resolution=200, - y_resolution=100, - height=90.0 -) -y_plane_3d = fi_3d.calculate_y_plane( - x_resolution=200, - z_resolution=100, - crossstream_dist=0.0 -) -cross_plane_3d = fi_3d.calculate_cross_plane( - y_resolution=100, - z_resolution=100, - downstream_dist=500.0 -) - -# Create the plots -fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) -ax_list = ax_list.flatten() -visualize_cut_plane( - horizontal_plane_3d, - ax=ax_list[0], - title="Horizontal", - color_bar=True, - label_contours=True -) -ax_list[0].set_xlabel('x') -ax_list[0].set_ylabel('y') -visualize_cut_plane( - y_plane_3d, - ax=ax_list[1], - title="Streamwise profile", - color_bar=True, - label_contours=True -) -ax_list[1].set_xlabel('x') -ax_list[1].set_ylabel('z') -visualize_cut_plane( - cross_plane_3d, - ax=ax_list[2], - title="Spanwise profile at 500m downstream", - color_bar=True, - label_contours=True -) -ax_list[2].set_xlabel('y') -ax_list[2].set_ylabel('z') - -plt.show() diff --git a/examples/16b_heterogeneity_multiple_ws_wd.py b/examples/16b_heterogeneity_multiple_ws_wd.py deleted file mode 100644 index 43ac6f7eb..000000000 --- a/examples/16b_heterogeneity_multiple_ws_wd.py +++ /dev/null @@ -1,98 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools.visualization import visualize_cut_plane - - -""" -This example showcases the heterogeneous inflow capabilities of FLORIS -when multiple wind speeds and direction are considered. -""" - - -# Define the speed ups of the heterogeneous inflow, and their locations. -# For the 2-dimensional case, this requires x and y locations. -# The speed ups are multipliers of the ambient wind speed. -speed_ups = [[2.0, 1.0, 2.0, 1.0]] -x_locs = [-300.0, -300.0, 2600.0, 2600.0] -y_locs = [ -300.0, 300.0, -300.0, 300.0] - -# Initialize FLORIS with the given input file via FlorisInterface. -# Note the heterogeneous inflow is defined in the input file. -fi = FlorisInterface("inputs/gch_heterogeneous_inflow.yaml") - -# Set shear to 0.0 to highlight the heterogeneous inflow -fi.reinitialize( - wind_shear=0.0, - wind_speeds=[8.0], - wind_directions=[270.], - layout_x=[0, 0], - layout_y=[-299., 299.], -) -fi.calculate_wake() -turbine_powers = fi.get_turbine_powers().flatten() / 1000. - -# Show the initial results -print('------------------------------------------') -print('Given the speedups and turbine locations, ') -print(' the first turbine has an inflow wind speed') -print(' twice that of the second') -print(' Wind Speed = 8., Wind Direction = 270.') -print(f'T0: {turbine_powers[0]:.1f} kW') -print(f'T1: {turbine_powers[1]:.1f} kW') -print() - -# Since het maps are assigned for each wind direciton, it's allowable to change -# the number of wind speeds -fi.reinitialize(wind_speeds=[4, 8]) -fi.calculate_wake() -turbine_powers = np.round(fi.get_turbine_powers() / 1000.) -print('With wind speeds now set to 4 and 8 m/s') -print(f'T0: {turbine_powers[:, :, 0].flatten()} kW') -print(f'T1: {turbine_powers[:, :, 1].flatten()} kW') -print() - -# To change the number of wind directions however it is necessary to make a matching -# change to the dimensions of the het map -speed_multipliers = [[2.0, 1.0, 2.0, 1.0], [2.0, 1.0, 2.0, 1.0]] # Expand to two wind directions -heterogenous_inflow_config = { - 'speed_multipliers': speed_multipliers, - 'x': x_locs, - 'y': y_locs, -} -fi.reinitialize( - wind_directions=[270.0, 275.0], - wind_speeds=[8.0], - heterogenous_inflow_config=heterogenous_inflow_config -) -fi.calculate_wake() -turbine_powers = np.round(fi.get_turbine_powers() / 1000.) -print('With wind directions now set to 270 and 275 deg') -print(f'T0: {turbine_powers[:, :, 0].flatten()} kW') -print(f'T1: {turbine_powers[:, :, 1].flatten()} kW') - -# # Uncomment if want to see example of error output -# # Note if we change wind directions to 3 without a matching change to het map we get an error -# print() -# print() -# print('~~ Now forcing an error by not matching wd and het_map') - -# fi.reinitialize(wind_directions=[270, 275, 280], wind_speeds=[8.]) -# fi.calculate_wake() -# turbine_powers = np.round(fi.get_turbine_powers() / 1000.) diff --git a/examples/16c_optimize_layout_with_heterogeneity.py b/examples/16c_optimize_layout_with_heterogeneity.py deleted file mode 100644 index ca27e3d7f..000000000 --- a/examples/16c_optimize_layout_with_heterogeneity.py +++ /dev/null @@ -1,171 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import os - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools.optimization.layout_optimization.layout_optimization_scipy import ( - LayoutOptimizationScipy, -) - - -""" -This example shows a layout optimization using the geometric yaw option. It -combines elements of examples 15 (layout optimization) and 16 (heterogeneous -inflow) for demonstrative purposes. If you haven't yet run those examples, -we recommend you try them first. - -Heterogeneity in the inflow provides the necessary driver for coupled yaw -and layout optimization to be worthwhile. First, a layout optimization is -run without coupled yaw optimization; then a coupled optimization is run to -show the benefits of coupled optimization when flows are heterogeneous. -""" - -# Initialize the FLORIS interface fi -file_dir = os.path.dirname(os.path.abspath(__file__)) -fi = FlorisInterface('inputs/gch.yaml') - -# Setup 2 wind directions (due east and due west) -# and 1 wind speed with uniform probability -wind_directions = [270., 90.] -n_wds = len(wind_directions) -wind_speeds = [8.0] -# Shape frequency distribution to match number of wind directions and wind speeds -freq = np.ones((len(wind_directions), len(wind_speeds))) -freq = freq / freq.sum() - -# The boundaries for the turbines, specified as vertices -D = 126.0 # rotor diameter for the NREL 5MW -size_D = 12 -boundaries = [ - (0.0, 0.0), - (size_D * D, 0.0), - (size_D * D, 0.1), - (0.0, 0.1), - (0.0, 0.0) -] - -# Set turbine locations to 4 turbines at corners of the rectangle -# (optimal without flow heterogeneity) -layout_x = [0.1, 0.3*size_D*D, 0.6*size_D*D] -layout_y = [0, 0, 0] - -# Generate exaggerated heterogeneous inflow (same for all wind directions) -speed_multipliers = np.repeat(np.array([0.5, 1.0, 0.5, 1.0])[None,:], n_wds, axis=0) -x_locs = [0, size_D * D, 0, size_D * D] -y_locs = [-D, -D, D, D] - -# Create the configuration dictionary to be used for the heterogeneous inflow. -heterogenous_inflow_config = { - 'speed_multipliers': speed_multipliers, - 'x': x_locs, - 'y': y_locs, -} - -fi.reinitialize( - layout_x=layout_x, - layout_y=layout_y, - wind_directions=wind_directions, - wind_speeds=wind_speeds, - heterogenous_inflow_config=heterogenous_inflow_config -) - -# Setup and solve the layout optimization problem without heterogeneity -maxiter = 100 -layout_opt = LayoutOptimizationScipy( - fi, - boundaries, - freq=freq, - min_dist=2*D, - optOptions={"maxiter":maxiter} -) - -# Run the optimization -np.random.seed(0) -sol = layout_opt.optimize() - -# Get the resulting improvement in AEP -print('... calcuating improvement in AEP') -fi.calculate_wake() -base_aep = fi.get_farm_AEP(freq=freq) / 1e6 -fi.reinitialize(layout_x=sol[0], layout_y=sol[1]) -fi.calculate_wake() -opt_aep = fi.get_farm_AEP(freq=freq) / 1e6 -percent_gain = 100 * (opt_aep - base_aep) / base_aep - -# Print and plot the results -print(f'Optimal layout: {sol}') -print( - f'Optimal layout improves AEP by {percent_gain:.1f}% ' - f'from {base_aep:.1f} MWh to {opt_aep:.1f} MWh' -) -layout_opt.plot_layout_opt_results() -ax = plt.gca() -fig = plt.gcf() -sm = ax.tricontourf(x_locs, y_locs, speed_multipliers[0], cmap="coolwarm") -fig.colorbar(sm, ax=ax, label="Speed multiplier") -ax.legend(["Initial layout", "Optimized layout", "Optimization boundary"]) -ax.set_title("Geometric yaw disabled") - - -# Rerun the layout optimization with geometric yaw enabled -print("\nReoptimizing with geometric yaw enabled.") -fi.reinitialize(layout_x=layout_x, layout_y=layout_y) -layout_opt = LayoutOptimizationScipy( - fi, - boundaries, - freq=freq, - min_dist=2*D, - enable_geometric_yaw=True, - optOptions={"maxiter":maxiter} -) - -# Run the optimization -np.random.seed(0) -sol = layout_opt.optimize() - -# Get the resulting improvement in AEP -print('... calcuating improvement in AEP') -fi.calculate_wake() -base_aep = fi.get_farm_AEP(freq=freq) / 1e6 -fi.reinitialize(layout_x=sol[0], layout_y=sol[1]) -fi.calculate_wake() -opt_aep = fi.get_farm_AEP(freq=freq, yaw_angles=layout_opt.yaw_angles) / 1e6 -percent_gain = 100 * (opt_aep - base_aep) / base_aep - -# Print and plot the results -print(f'Optimal layout: {sol}') -print( - f'Optimal layout improves AEP by {percent_gain:.1f}% ' - f'from {base_aep:.1f} MWh to {opt_aep:.1f} MWh' -) -layout_opt.plot_layout_opt_results() -ax = plt.gca() -fig = plt.gcf() -sm = ax.tricontourf(x_locs, y_locs, speed_multipliers[0], cmap="coolwarm") -fig.colorbar(sm, ax=ax, label="Speed multiplier") -ax.legend(["Initial layout", "Optimized layout", "Optimization boundary"]) -ax.set_title("Geometric yaw enabled") - -print( - 'Turbine geometric yaw angles for wind direction {0:.2f}'.format(wind_directions[1])\ - +' and wind speed {0:.2f} m/s:'.format(wind_speeds[0]), - f'{layout_opt.yaw_angles[1,0,:]}' -) - -plt.show() diff --git a/examples/17_multiple_turbine_types.py b/examples/17_multiple_turbine_types.py deleted file mode 100644 index 87a2b032d..000000000 --- a/examples/17_multiple_turbine_types.py +++ /dev/null @@ -1,45 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt - -import floris.tools.visualization as wakeviz -from floris.tools import FlorisInterface - - -""" -This example uses an input file where multiple turbine types are defined. -The first two turbines are the NREL 5MW, and the third turbine is the IEA 10MW. -""" - -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive -# entry point to the simulation routines. -fi = FlorisInterface("inputs/gch_multiple_turbine_types.yaml") - -# Using the FlorisInterface functions for generating plots, run FLORIS -# and extract 2D planes of data. -horizontal_plane = fi.calculate_horizontal_plane(x_resolution=200, y_resolution=100, height=90) -y_plane = fi.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) -cross_plane = fi.calculate_cross_plane(y_resolution=100, z_resolution=100, downstream_dist=500.0) - -# Create the plots -fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) -ax_list = ax_list.flatten() -wakeviz.visualize_cut_plane(horizontal_plane, ax=ax_list[0], title="Horizontal") -wakeviz.visualize_cut_plane(y_plane, ax=ax_list[1], title="Streamwise profile") -wakeviz.visualize_cut_plane(cross_plane, ax=ax_list[2], title="Spanwise profile") - -wakeviz.show_plots() diff --git a/examples/18_check_turbine.py b/examples/18_check_turbine.py deleted file mode 100644 index b03cc6e9e..000000000 --- a/examples/18_check_turbine.py +++ /dev/null @@ -1,123 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -from pathlib import Path - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface - - -""" -For each turbine in the turbine library, make a small figure showing that its power -curve and power loss to yaw are reasonable and reasonably smooth -""" -ws_array = np.arange(0.1,30,0.2) -yaw_angles = np.linspace(-30,30,60) -wind_speed_to_test_yaw = 11 - -# Grab the gch model -fi = FlorisInterface("inputs/gch.yaml") - -# Make one turbine sim -fi.reinitialize(layout_x=[0], layout_y=[0]) - -# Apply wind speeds -fi.reinitialize(wind_speeds=ws_array) - -# Get a list of available turbine models provided through FLORIS, and remove -# multi-dimensional Cp/Ct turbine definitions as they require different handling -turbines = [ - t.stem - for t in fi.floris.farm.internal_turbine_library.iterdir() - if t.suffix == ".yaml" and ("multi_dim" not in t.stem) -] - -# Declare a set of figures for comparing cp and ct across models -fig_cp_ct, axarr_cp_ct = plt.subplots(2,1,sharex=True,figsize=(10,10)) - -# For each turbine model available plot the basic info -for t in turbines: - - # Set t as the turbine - fi.reinitialize(turbine_type=[t]) - - # Since we are changing the turbine type, make a matching change to the reference wind height - fi.assign_hub_height_to_ref_height() - - # Plot cp and ct onto the fig_cp_ct plot - axarr_cp_ct[0].plot( - fi.floris.farm.turbine_map[0].power_thrust_table["wind_speed"], - fi.floris.farm.turbine_map[0].power_thrust_table["power"],label=t - ) - axarr_cp_ct[0].grid(True) - axarr_cp_ct[0].legend() - axarr_cp_ct[0].set_ylabel('Cp') - axarr_cp_ct[1].plot( - fi.floris.farm.turbine_map[0].power_thrust_table["wind_speed"], - fi.floris.farm.turbine_map[0].power_thrust_table["thrust"],label=t - ) - axarr_cp_ct[1].grid(True) - axarr_cp_ct[1].legend() - axarr_cp_ct[1].set_ylabel('Ct') - axarr_cp_ct[1].set_xlabel('Wind Speed (m/s)') - - # Create a figure - fig, axarr = plt.subplots(1,2,figsize=(10,5)) - - # Try a few density - for density in [1.15,1.225,1.3]: - - fi.reinitialize(air_density=density) - - # POWER CURVE - ax = axarr[0] - fi.reinitialize(wind_speeds=ws_array) - fi.calculate_wake() - turbine_powers = fi.get_turbine_powers().flatten() / 1e3 - if density == 1.225: - ax.plot(ws_array,turbine_powers,label='Air Density = %.3f' % density, lw=2, color='k') - else: - ax.plot(ws_array,turbine_powers,label='Air Density = %.3f' % density, lw=1) - ax.grid(True) - ax.legend() - ax.set_xlabel('Wind Speed (m/s)') - ax.set_ylabel('Power (kW)') - - # Power loss to yaw, try a range of yaw angles - ax = axarr[1] - - fi.reinitialize(wind_speeds=[wind_speed_to_test_yaw]) - yaw_result = [] - for yaw in yaw_angles: - fi.calculate_wake(yaw_angles=np.array([[[yaw]]])) - turbine_powers = fi.get_turbine_powers().flatten() / 1e3 - yaw_result.append(turbine_powers[0]) - if density == 1.225: - ax.plot(yaw_angles,yaw_result,label='Air Density = %.3f' % density, lw=2, color='k') - else: - ax.plot(yaw_angles,yaw_result,label='Air Density = %.3f' % density, lw=1) - # ax.plot(yaw_angles,yaw_result,label='Air Density = %.3f' % density) - ax.grid(True) - ax.legend() - ax.set_xlabel('Yaw Error (deg)') - ax.set_ylabel('Power (kW)') - ax.set_title('Wind Speed = %.1f' % wind_speed_to_test_yaw ) - - # Give a suptitle - fig.suptitle(t) - -plt.show() diff --git a/examples/19_streamlit_demo.py b/examples/19_streamlit_demo.py deleted file mode 100644 index d40296c19..000000000 --- a/examples/19_streamlit_demo.py +++ /dev/null @@ -1,208 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np -import streamlit as st - -from floris.tools import FlorisInterface -from floris.tools.visualization import visualize_cut_plane - - -# import seaborn as sns - - - -# """ -# This example demonstrates an interactive visual comparison of FLORIS -# wake models using streamlit - -# To run this example: -# (with your FLORIS environment enabled) -# pip install streamlit - -# streamlit run 16_streamlit_demo.py -# """ - - -# Parameters -wind_speed = 8.0 -# ti = 0.06 - -# Set to wide -st.set_page_config(layout="wide") - -# Parameters -D = 126. # Assume for convenience -floris_model_list = ['jensen','gch','cc','turbopark'] -color_dict = { - 'jensen':'k', - 'gch':'b', - 'cc':'r', - 'turbopark':'c' -} - -# Streamlit inputs -n_turbine_per_row = st.sidebar.slider("Turbines per row", 1, 8, 2, step=1) -n_row = st.sidebar.slider("Number of rows", 1, 8,1, step=1) -spacing = st.sidebar.slider("Turbine spacing (D)", 3., 10., 6., step=0.5) -wind_direction = st.sidebar.slider("Wind Direction", 240., 300., 270., step=1.) -wind_speed = st.sidebar.slider("Wind Speed", 4., 15., 8., step=0.25) -turbulence_intensity = st.sidebar.slider("Turbulence Intensity", 0.01, 0.25, 0.06, step=0.01) -floris_models = st.sidebar.multiselect("FLORIS Models", floris_model_list, floris_model_list) -# floris_models_viz = st.sidebar.multiselect( -# "FLORIS Models for Visualization", -# floris_model_list, -# floris_model_list -# ) -desc_yaw = st.sidebar.checkbox("Descending yaw pattern?",value=False) -front_turbine_yaw = st.sidebar.slider("Upstream yaw angle", -30., 30., 0., step=0.5) - -# Define the layout -X = [] -Y = [] - -for x_idx in range(n_turbine_per_row): - for y_idx in range(n_row): - X.append(D * spacing * x_idx) - Y.append(D * spacing * y_idx) - -turbine_labels = ['T%02d' % i for i in range(len(X))] - -# Set up the yaw angle values -yaw_angles_base = np.zeros([1,1,len(X)]) - -yaw_angles_yaw = np.zeros([1,1,len(X)]) -if not desc_yaw: - yaw_angles_yaw[:,:,:n_row] = front_turbine_yaw -else: - decreasing_pattern = np.linspace(front_turbine_yaw,0,n_turbine_per_row) - for i in range(n_turbine_per_row): - yaw_angles_yaw[:,:,i*n_row:(i+1)*n_row] = decreasing_pattern[i] - - - -# Get a few quanitities -num_models = len(floris_models) - -# Determine which models to plot given cant plot cc right now -floris_models_viz = [m for m in floris_models if "cc" not in m] -floris_models_viz = [m for m in floris_models_viz if "turbo" not in m] -num_models_to_viz = len(floris_models_viz) - -# Set up the visualization plot -fig_viz, axarr_viz = plt.subplots(num_models_to_viz,2) - -# Set up the turbine power plot -fig_turb_pow, ax_turb_pow = plt.subplots() - -# Set up a list to save the farm power results -farm_power_results = [] - -# Now complete all these plots in a loop -for fm in floris_models: - - # Analyze the base case================================================== - print('Loading: ',fm) - fi = FlorisInterface("inputs/%s.yaml" % fm) - - # Set the layout, wind direction and wind speed - fi.reinitialize( - layout_x=X, - layout_y=Y, - wind_speeds=[wind_speed], - wind_directions=[wind_direction], - turbulence_intensity=turbulence_intensity - ) - - fi.calculate_wake(yaw_angles=yaw_angles_base) - turbine_powers = fi.get_turbine_powers() / 1000. - ax_turb_pow.plot( - turbine_labels, - turbine_powers.flatten(), - color=color_dict[fm], - ls='-', - marker='s', - label='%s - baseline' % fm - ) - ax_turb_pow.grid(True) - ax_turb_pow.legend() - ax_turb_pow.set_xlabel('Turbine') - ax_turb_pow.set_ylabel('Power (kW)') - - # Save the farm power - farm_power_results.append((fm,'base',np.sum(turbine_powers))) - - # If in viz list also visualize - if fm in floris_models_viz: - ax_idx = floris_models_viz.index(fm) - ax = axarr_viz[ax_idx, 0] - - horizontal_plane_gch = fi.calculate_horizontal_plane( - x_resolution=100, - y_resolution=100, - yaw_angles=yaw_angles_base, - height=90.0 - ) - visualize_cut_plane(horizontal_plane_gch, ax=ax, title='%s - baseline' % fm) - - # Analyze the yawed case================================================== - print('Loading: ',fm) - fi = FlorisInterface("inputs/%s.yaml" % fm) - - # Set the layout, wind direction and wind speed - fi.reinitialize( - layout_x=X, - layout_y=Y, - wind_speeds=[wind_speed], - wind_directions=[wind_direction], - turbulence_intensity=turbulence_intensity - ) - - fi.calculate_wake(yaw_angles=yaw_angles_yaw) - turbine_powers = fi.get_turbine_powers() / 1000. - ax_turb_pow.plot( - turbine_labels, - turbine_powers.flatten(), - color=color_dict[fm], - ls='--', - marker='o', - label='%s - yawed' % fm - ) - ax_turb_pow.grid(True) - ax_turb_pow.legend() - ax_turb_pow.set_xlabel('Turbine') - ax_turb_pow.set_ylabel('Power (kW)') - - # Save the farm power - farm_power_results.append((fm,'yawed',np.sum(turbine_powers))) - - # If in viz list also visualize - if fm in floris_models_viz: - ax_idx = floris_models_viz.index(fm) - ax = axarr_viz[ax_idx, 1] - - horizontal_plane_gch = fi.calculate_horizontal_plane( - x_resolution=100, - y_resolution=100, - yaw_angles=yaw_angles_yaw, - height=90.0 - ) - visualize_cut_plane(horizontal_plane_gch, ax=ax, title='%s - yawed' % fm) - -st.header("Visualizations") -st.write(fig_viz) -st.header("Power Comparison") -st.write(fig_turb_pow) diff --git a/examples/20_calculate_farm_power_with_uncertainty.py b/examples/20_calculate_farm_power_with_uncertainty.py deleted file mode 100644 index 16ea3789d..000000000 --- a/examples/20_calculate_farm_power_with_uncertainty.py +++ /dev/null @@ -1,70 +0,0 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface, UncertaintyInterface - - -""" -This example demonstrates how one can create an "UncertaintyInterface" object, -which adds uncertainty on the inflow wind direction on the FlorisInterface -class. The UncertaintyInterface class is interacted with in the exact same -manner as the FlorisInterface class is. This example demonstrates how the -wind farm power production is calculated with and without uncertainty. -Other use cases of UncertaintyInterface are, e.g., comparing FLORIS to -historical SCADA data and robust optimization. -""" - -# Instantiate FLORIS using either the GCH or CC model -fi = FlorisInterface("inputs/gch.yaml") # GCH model -fi_unc = UncertaintyInterface("inputs/gch.yaml") # Add uncertainty with default settings - -# Define a two turbine farm -D = 126.0 -layout_x = np.array([0, D*6, D*12]) -layout_y = [0, 0, 0] -wd_array = np.arange(0.0, 360.0, 1.0) -fi.reinitialize(layout_x=layout_x, layout_y=layout_y, wind_directions=wd_array) -fi_unc.reinitialize(layout_x=layout_x, layout_y=layout_y, wind_directions=wd_array) - -# Define a matrix of yaw angles to be all 0 -# Note that yaw angles is now specified as a matrix whose dimesions are -# wd/ws/turbine -num_wd = len(wd_array) # Number of wind directions -num_ws = 1 # Number of wind speeds -num_turbine = len(layout_x) # Number of turbines -yaw_angles = np.zeros((num_wd, num_ws, num_turbine)) - -# Calculate the nominal wake solution -fi.calculate_wake(yaw_angles=yaw_angles) - -# Calculate the nominal wind farm power production -farm_powers_nom = fi.get_farm_power() / 1e3 - -# Calculate the wind farm power with uncertainty on the wind direction -fi_unc.calculate_wake(yaw_angles=yaw_angles) -farm_powers_unc = fi_unc.get_farm_power() / 1e3 - -# Plot results -fig, ax = plt.subplots() -ax.plot(wd_array, farm_powers_nom.flatten(), color='k',label='Nominal farm power') -ax.plot(wd_array, farm_powers_unc.flatten(), color='r',label='Farm power with uncertainty') -ax.grid(True) -ax.legend() -ax.set_xlabel('Wind Direction (deg)') -ax.set_ylabel('Power (kW)') -plt.show() diff --git a/examples/21_demo_time_series.py b/examples/21_demo_time_series.py deleted file mode 100644 index 75419c198..000000000 --- a/examples/21_demo_time_series.py +++ /dev/null @@ -1,93 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface - - -""" -This example demonstrates running FLORIS in time series mode. - -Typically when an array of wind directions and wind speeds are passed in FLORIS, -it is assumed these are defining a grid of wd/ws points to consider, as in a wind rose. -All combinations of wind direction and wind speed are therefore computed, and resulting -matrices, for example of turbine power are returned with martrices whose dimensions are -wind direction, wind speed and turbine number. - -In time series mode, specified by setting the time_series flag of the FLORIS interface to True -each wd/ws pair is assumed to constitute a single point in time and each pair is computed. -Results are returned still as a 3 dimensional matrix, however the index of the (wd/ws) pair -is provided in the first dimension, the second dimension is fixed at 1, and the thrid is -turbine number again for consistency. - -Note by not specifying yaw, the assumption is that all turbines are always pointing into the -current wind direction with no offset. -""" - -# Initialize FLORIS to simple 4 turbine farm -fi = FlorisInterface("inputs/gch.yaml") - -# Convert to a simple two turbine layout -fi.reinitialize(layout_x=[0, 500.], layout_y=[0., 0.]) - -# Create a fake time history where wind speed steps in the middle while wind direction -# Walks randomly -time = np.arange(0, 120, 10.) # Each time step represents a 10-minute average -ws = np.ones_like(time) * 8. -ws[int(len(ws) / 2):] = 9. -wd = np.ones_like(time) * 270. - -for idx in range(1, len(time)): - wd[idx] = wd[idx - 1] + np.random.randn() * 2. - - -# Now intiialize FLORIS object to this history using time_series flag -fi.reinitialize(wind_directions=wd, wind_speeds=ws, time_series=True) - -# Collect the powers -fi.calculate_wake() -turbine_powers = fi.get_turbine_powers() / 1000. - -# Show the dimensions -num_turbines = len(fi.layout_x) -print( - f'There are {len(time)} time samples, and {num_turbines} turbines and ' - f'so the resulting turbine power matrix has the shape {turbine_powers.shape}.' -) - - -fig, axarr = plt.subplots(3, 1, sharex=True, figsize=(7,8)) - -ax = axarr[0] -ax.plot(time, ws, 'o-') -ax.set_ylabel('Wind Speed (m/s)') -ax.grid(True) - -ax = axarr[1] -ax.plot(time, wd, 'o-') -ax.set_ylabel('Wind Direction (Deg)') -ax.grid(True) - -ax = axarr[2] -for t in range(num_turbines): - ax.plot(time,turbine_powers[:, 0, t], 'o-', label='Turbine %d' % t) -ax.legend() -ax.set_ylabel('Turbine Power (kW)') -ax.set_xlabel('Time (minutes)') -ax.grid(True) - -plt.show() diff --git a/examples/22_get_wind_speed_at_turbines.py b/examples/22_get_wind_speed_at_turbines.py deleted file mode 100644 index 7887357e0..000000000 --- a/examples/22_get_wind_speed_at_turbines.py +++ /dev/null @@ -1,47 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import numpy as np - -from floris.tools import FlorisInterface - - -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive -# entry point to the simulation routines. -fi = FlorisInterface("inputs/gch.yaml") - -# Create a 4-turbine layouts -fi.reinitialize(layout_x=[0, 0., 500., 500.], layout_y=[0., 300., 0., 300.]) - -# Calculate wake -fi.calculate_wake() - -# Collect the wind speed at all the turbine points -u_points = fi.floris.flow_field.u - -print('U points is 1 wd x 1 ws x 4 turbines x 3 x 3 points (turbine_grid_points=3)') -print(u_points.shape) - -print('turbine_average_velocities is 1 wd x 1 ws x 4 turbines') -print(fi.turbine_average_velocities) - -# Show that one is equivalent to the other following averaging -print( - 'turbine_average_velocities is determined by taking the cube root of mean ' - 'of the cubed value across the points' - f'turbine_average_velocities: {fi.turbine_average_velocities}' - f'Recomputed: {np.cbrt(np.mean(u_points**3, axis=(3,4)))}' -) diff --git a/examples/23_visualize_layout.py b/examples/23_visualize_layout.py deleted file mode 100644 index e880e0a70..000000000 --- a/examples/23_visualize_layout.py +++ /dev/null @@ -1,76 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt - -from floris.tools import FlorisInterface -from floris.tools.layout_functions import visualize_layout - - -""" -This example visualizes a wind turbine layout -using the visualize_layout function -""" - -# Declare a FLORIS interface -fi = FlorisInterface("inputs/gch.yaml") - -# Assign a 6-turbine layout -fi.reinitialize(layout_x=[0, 100, 500, 1000, 1200,500], layout_y=[0, 800, 150, 500, 0,500]) - -# Give turbines specific names -turbine_names = ['T01', 'T02','T03','S01','X01', 'X02'] - -# Declare a 4-pane plot -fig, axarr = plt.subplots(2,2, sharex=True, sharey=True, figsize=(14,10)) - -# Show the layout with all defaults - -# Default visualization -ax = axarr[0,0] -visualize_layout(fi, ax=ax) -ax.set_title('Default visualization') - -# With wake lines -ax = axarr[0,1] -visualize_layout(fi, ax=ax, show_wake_lines=True) -ax.set_title('Show wake lines') - -# Limit wake lines and use provided -ax = axarr[1,0] -visualize_layout( - fi, - ax=ax, - show_wake_lines=True, - lim_lines_per_turbine=2, - turbine_names=turbine_names -) -ax.set_title('Show only nearest 2, use provided names') - -# Show rotors and use black and white -ax = axarr[1,1] -visualize_layout( - fi, - ax=ax, - show_wake_lines=True, - lim_lines_per_turbine=2, - plot_rotor=True, - black_and_white=True -) -ax.set_title('Plot rotors and use black and white option') - - - -plt.show() diff --git a/examples/24_floating_turbine_models.py b/examples/24_floating_turbine_models.py deleted file mode 100644 index 364dca157..000000000 --- a/examples/24_floating_turbine_models.py +++ /dev/null @@ -1,133 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools.layout_functions import visualize_layout - - -""" -This example demonstrates the impact of floating on turbine power and thrust (not wake behavior). -A floating turbine in FLORIS is defined by including a `floating_tilt_table` in the turbine -input yaml which sets the steady tilt angle of the turbine based on wind speed. This tilt angle -is computed for each turbine based on effective velocity. This tilt angle is then passed on -to the respective wake model. - -The value of the parameter ref_tilt_cp_ct is the value of tilt at which the ct/cp curves -have been defined. - -If `correct_cp_ct_for_tilt` is True, then the difference between the current tilt as -interpolated from the floating tilt table is used to scale the turbine power and thrust. - -If `correct_cp_ct_for_tilt` is False, then it is assumed that the Cp/Ct tables provided -already account for the variation in tilt with wind speed (for example they were computed from -a turbine simulator with tilt degree-of-freedom enabled and the floating platform simulated), -and no correction is made. - -In the example below, three single-turbine simulations are run to show the different behaviors. - -fi_fixed: Fixed bottom turbine (no tilt variation with wind speed) -fi_floating: Floating turbine (tilt varies with wind speed) -fi_floating_defined_floating: Floating turbine (tilt varies with wind speed, but - tilt does not scale cp/ct) -""" - -# Declare the Floris Interfaces -fi_fixed = FlorisInterface("inputs_floating/gch_fixed.yaml") -fi_floating = FlorisInterface("inputs_floating/gch_floating.yaml") -fi_floating_defined_floating = FlorisInterface("inputs_floating/gch_floating_defined_floating.yaml") - -# Calculate across wind speeds -ws_array = np.arange(3., 25., 1.) -fi_fixed.reinitialize(wind_speeds=ws_array) -fi_floating.reinitialize(wind_speeds=ws_array) -fi_floating_defined_floating.reinitialize(wind_speeds=ws_array) - -fi_fixed.calculate_wake() -fi_floating.calculate_wake() -fi_floating_defined_floating.calculate_wake() - -# Grab power -power_fixed = fi_fixed.get_turbine_powers().flatten()/1000. -power_floating = fi_floating.get_turbine_powers().flatten()/1000. -power_floating_defined_floating = fi_floating_defined_floating.get_turbine_powers().flatten()/1000. - -# Grab Ct -ct_fixed = fi_fixed.get_turbine_Cts().flatten() -ct_floating = fi_floating.get_turbine_Cts().flatten() -ct_floating_defined_floating = fi_floating_defined_floating.get_turbine_Cts().flatten() - -# Grab turbine tilt angles -eff_vels = fi_fixed.turbine_average_velocities -tilt_angles_fixed = np.squeeze( - fi_fixed.floris.farm.calculate_tilt_for_eff_velocities(eff_vels) - ) - -eff_vels = fi_floating.turbine_average_velocities -tilt_angles_floating = np.squeeze( - fi_floating.floris.farm.calculate_tilt_for_eff_velocities(eff_vels) - ) - -eff_vels = fi_floating_defined_floating.turbine_average_velocities -tilt_angles_floating_defined_floating = np.squeeze( - fi_floating_defined_floating.floris.farm.calculate_tilt_for_eff_velocities(eff_vels) - ) - -# Plot results - -fig, axarr = plt.subplots(4,1, figsize=(8,10), sharex=True) - -ax = axarr[0] -ax.plot(ws_array, tilt_angles_fixed, color='k',lw=2,label='Fixed Bottom') -ax.plot(ws_array, tilt_angles_floating, color='b',label='Floating') -ax.plot(ws_array, tilt_angles_floating_defined_floating, color='m',ls='--', - label='Floating (cp/ct not scaled by tilt)') -ax.grid(True) -ax.legend() -ax.set_title('Tilt angle (deg)') -ax.set_ylabel('Tlit (deg)') - -ax = axarr[1] -ax.plot(ws_array, power_fixed, color='k',lw=2,label='Fixed Bottom') -ax.plot(ws_array, power_floating, color='b',label='Floating') -ax.plot(ws_array, power_floating_defined_floating, color='m',ls='--', - label='Floating (cp/ct not scaled by tilt)') -ax.grid(True) -ax.legend() -ax.set_title('Power') -ax.set_ylabel('Power (kW)') - -ax = axarr[2] -# ax.plot(ws_array, power_fixed, color='k',label='Fixed Bottom') -ax.plot(ws_array, power_floating - power_fixed, color='b',label='Floating') -ax.plot(ws_array, power_floating_defined_floating - power_fixed, color='m',ls='--', - label='Floating (cp/ct not scaled by tilt)') -ax.grid(True) -ax.legend() -ax.set_title('Difference from fixed bottom power') -ax.set_ylabel('Power (kW)') - -ax = axarr[3] -ax.plot(ws_array, ct_fixed, color='k',lw=2,label='Fixed Bottom') -ax.plot(ws_array, ct_floating, color='b',label='Floating') -ax.plot(ws_array, ct_floating_defined_floating, color='m',ls='--', - label='Floating (cp/ct not scaled by tilt)') -ax.grid(True) -ax.legend() -ax.set_title('Coefficient of thrust') -ax.set_ylabel('Ct (-)') - -plt.show() diff --git a/examples/26_empirical_gauss_velocity_deficit_parameters.py b/examples/26_empirical_gauss_velocity_deficit_parameters.py deleted file mode 100644 index f11e9e07f..000000000 --- a/examples/26_empirical_gauss_velocity_deficit_parameters.py +++ /dev/null @@ -1,228 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://nrel.github.io/floris for documentation - - -import copy - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools.visualization import plot_rotor_values, visualize_cut_plane - - -""" -This example illustrates the main parameters of the Empirical Gaussian -velocity deficit model and their effects on the wind turbine wake. -""" - -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive -# entry point to the simulation routines. - -# Options -show_flow_cuts = True -num_in_row = 5 - -yaw_angles = np.zeros((1, 1, num_in_row)) - -# Define function for visualizing wakes -def generate_wake_visualization(fi: FlorisInterface, title=None): - # Using the FlorisInterface functions, get 2D slices. - x_bounds = [-500, 3000] - y_bounds = [-250, 250] - z_bounds = [0.001, 500] - cross_plane_locations = [10, 1200, 2500] - horizontal_plane_location = 90.0 - streamwise_plane_location = 0.0 - # Contour plot colors - min_ws = 4 - max_ws = 10 - - horizontal_plane = fi.calculate_horizontal_plane( - x_resolution=200, - y_resolution=100, - height=horizontal_plane_location, - x_bounds=x_bounds, - y_bounds=y_bounds, - yaw_angles=yaw_angles - ) - y_plane = fi.calculate_y_plane( - x_resolution=200, - z_resolution=100, - crossstream_dist=streamwise_plane_location, - x_bounds=x_bounds, - z_bounds=z_bounds, - yaw_angles=yaw_angles - ) - cross_planes = [] - for cpl in cross_plane_locations: - cross_planes.append( - fi.calculate_cross_plane( - y_resolution=100, - z_resolution=100, - downstream_dist=cpl - ) - ) - - # Create the plots - # Cutplane settings - cp_ls = "solid" # line style - cp_lw = 0.5 # line width - cp_clr = "black" # line color - fig = plt.figure() - fig.set_size_inches(12, 12) - # Horizontal profile - ax = fig.add_subplot(311) - visualize_cut_plane(horizontal_plane, ax=ax, title="Top-down profile", - min_speed=min_ws, max_speed=max_ws) - ax.plot(x_bounds, [streamwise_plane_location]*2, color=cp_clr, - linewidth=cp_lw, linestyle=cp_ls) - for cpl in cross_plane_locations: - ax.plot([cpl]*2, y_bounds, color=cp_clr, linewidth=cp_lw, - linestyle=cp_ls) - - ax = fig.add_subplot(312) - visualize_cut_plane(y_plane, ax=ax, title="Streamwise profile", - min_speed=min_ws, max_speed=max_ws) - ax.plot(x_bounds, [horizontal_plane_location]*2, color=cp_clr, - linewidth=cp_lw, linestyle=cp_ls) - for cpl in cross_plane_locations: - ax.plot([cpl, cpl], z_bounds, color=cp_clr, linewidth=cp_lw, - linestyle=cp_ls) - - # Spanwise profiles - for i, (cp, cpl) in enumerate(zip(cross_planes, cross_plane_locations)): - visualize_cut_plane(cp, ax=fig.add_subplot(3, len(cross_planes), i+7), - title="Loc: {:.0f}m".format(cpl), min_speed=min_ws, - max_speed=max_ws) - - # Add overall figure title - if title is not None: - fig.suptitle(title, fontsize=16) - -## Main script - -# Load input yaml and define farm layout -fi = FlorisInterface("inputs/emgauss.yaml") -D = fi.floris.farm.rotor_diameters[0] -fi.reinitialize( - layout_x=[x*5.0*D for x in range(num_in_row)], - layout_y=[0.0]*num_in_row, - wind_speeds=[8.0], - wind_directions=[270.0] -) - -# Save dictionary to modify later -fi_dict = fi.floris.as_dict() - -# Run wake calculation -fi.calculate_wake() - -# Look at the powers of each turbine -turbine_powers = fi.get_turbine_powers().flatten()/1e6 - -fig0, ax0 = plt.subplots(1,1) -width = 0.1 -nw = -2 -x = np.array(range(num_in_row))+width*nw -nw += 1 - -title = "Original" -ax0.bar(x, turbine_powers, width=width, label=title) -ax0.legend() - -# Visualize wakes -if show_flow_cuts: - generate_wake_visualization(fi, title) - -# Increase the base recovery rate -fi_dict_mod = copy.deepcopy(fi_dict) -fi_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ - ['wake_expansion_rates'] = [0.03, 0.015] -fi = FlorisInterface(fi_dict_mod) -fi.reinitialize( - wind_speeds=[8.0], - wind_directions=[270.0] -) - -fi.calculate_wake() -turbine_powers = fi.get_turbine_powers().flatten()/1e6 - -x = np.array(range(num_in_row))+width*nw -nw += 1 - -title = "Increase base recovery" -ax0.bar(x, turbine_powers, width=width, label=title) - -if show_flow_cuts: - generate_wake_visualization(fi, title) - -# Add new expansion rate -fi_dict_mod = copy.deepcopy(fi_dict) -fi_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ - ['wake_expansion_rates'] = \ - fi_dict['wake']['wake_velocity_parameters']['empirical_gauss']\ - ['wake_expansion_rates'] + [0.0] -fi_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ - ['breakpoints_D'] = [5, 10] - -fi = FlorisInterface(fi_dict_mod) -fi.reinitialize( - wind_speeds=[8.0], - wind_directions=[270.0] -) - -fi.calculate_wake() -turbine_powers = fi.get_turbine_powers().flatten()/1e6 - -x = np.array(range(num_in_row))+width*nw -nw += 1 - -title = "Add rate, change breakpoints" -ax0.bar(x, turbine_powers, width=width, label=title) - -if show_flow_cuts: - generate_wake_visualization(fi, title) - -# Increase the wake-induced mixing gain -fi_dict_mod = copy.deepcopy(fi_dict) -fi_dict_mod['wake']['wake_velocity_parameters']['empirical_gauss']\ - ['mixing_gain_velocity'] = 3.0 -fi = FlorisInterface(fi_dict_mod) -fi.reinitialize( - wind_speeds=[8.0], - wind_directions=[270.0] -) - -fi.calculate_wake() -turbine_powers = fi.get_turbine_powers().flatten()/1e6 - -x = np.array(range(num_in_row))+width*nw -nw += 1 - -title = "Increase mixing gain" -ax0.bar(x, turbine_powers, width=width, label=title) - -if show_flow_cuts: - generate_wake_visualization(fi, title) - -# Power plot aesthetics -ax0.set_xticks(range(num_in_row)) -ax0.set_xticklabels(["T{0}".format(t) for t in range(num_in_row)]) -ax0.legend() -ax0.set_xlabel("Turbine") -ax0.set_ylabel("Power [MW]") - -plt.show() diff --git a/examples/29_floating_vs_fixedbottom_farm.py b/examples/29_floating_vs_fixedbottom_farm.py deleted file mode 100644 index e3c908c1e..000000000 --- a/examples/29_floating_vs_fixedbottom_farm.py +++ /dev/null @@ -1,147 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -from scipy.interpolate import NearestNDInterpolator - -import floris.tools.visualization as wakeviz -from floris.tools import FlorisInterface - - -""" -This example demonstrates the impact of floating on turbine power and thurst -and wake behavior. A floating turbine in FLORIS is defined by including a -`floating_tilt_table` in the turbine input yaml which sets the steady tilt -angle of the turbine based on wind speed. This tilt angle is computed for each -turbine based on effective velocity. This tilt angle is then passed on -to the respective wake model. - -The value of the parameter ref_tilt_cp_ct is the value of tilt at which the -ct/cp curves have been defined. - -With `correct_cp_ct_for_tilt` True, the difference between the current -tilt as interpolated from the floating tilt table is used to scale the turbine -power and thrust. - -In the example below, a 20-turbine, gridded wind farm is simulated using -the Empirical Gaussian wake model to show the effects of floating turbines on -both turbine power and wake development. - -fi_fixed: Fixed bottom turbine (no tilt variation with wind speed) -fi_floating: Floating turbine (tilt varies with wind speed) -""" - -# Declare the Floris Interface for fixed bottom, provide layout -fi_fixed = FlorisInterface("inputs_floating/emgauss_fixed.yaml") -fi_floating = FlorisInterface("inputs_floating/emgauss_floating.yaml") -x, y = np.meshgrid(np.linspace(0, 4*630., 5), np.linspace(0, 3*630., 4)) -for fi in [fi_fixed, fi_floating]: - fi.reinitialize(layout_x=x.flatten(), layout_y=y.flatten()) - -# Compute a single wind speed and direction, power and wakes -for fi in [fi_fixed, fi_floating]: - fi.reinitialize( - layout_x=x.flatten(), - layout_y=y.flatten(), - wind_speeds=[10], - wind_directions=[270] - ) - fi.calculate_wake() - -powers_fixed = fi_fixed.get_turbine_powers() -powers_floating = fi_floating.get_turbine_powers() -power_difference = powers_floating - powers_fixed - -# Show the power differences -fig, ax = plt.subplots() -ax.set_aspect('equal', adjustable='box') -sc = ax.scatter( - x.flatten(), - y.flatten(), - c=power_difference.flatten()/1000, - cmap="PuOr", - vmin=-30, - vmax=30, - s=200, -) -ax.set_xlabel("x coordinate [m]") -ax.set_ylabel("y coordinate [m]") -ax.set_title("Power increase due to floating for each turbine.") -plt.colorbar(sc, label="Increase (kW)") - -print("Power increase from floating over farm (10m/s, 270deg winds): {0:.2f} kW".\ - format(power_difference.sum()/1000)) - -# Visualize flows (see also 02_visualizations.py) -horizontal_planes = [] -y_planes = [] -for fi in [fi_fixed, fi_floating]: - horizontal_planes.append( - fi.calculate_horizontal_plane( - x_resolution=200, - y_resolution=100, - height=90.0, - ) - ) - y_planes.append( - fi.calculate_y_plane( - x_resolution=200, - z_resolution=100, - crossstream_dist=0.0, - ) - ) - -# Create the plots -fig, ax_list = plt.subplots(2, 1, figsize=(10, 8)) -ax_list = ax_list.flatten() -wakeviz.visualize_cut_plane(horizontal_planes[0], ax=ax_list[0], title="Horizontal") -wakeviz.visualize_cut_plane(y_planes[0], ax=ax_list[1], title="Streamwise profile") -fig.suptitle("Fixed-bottom farm") - -fig, ax_list = plt.subplots(2, 1, figsize=(10, 8)) -ax_list = ax_list.flatten() -wakeviz.visualize_cut_plane(horizontal_planes[1], ax=ax_list[0], title="Horizontal") -wakeviz.visualize_cut_plane(y_planes[1], ax=ax_list[1], title="Streamwise profile") -fig.suptitle("Floating farm") - -# Compute AEP (see 07_calc_aep_from_rose.py for details) -df_wr = pd.read_csv("inputs/wind_rose.csv") -wd_array = np.array(df_wr["wd"].unique(), dtype=float) -ws_array = np.array(df_wr["ws"].unique(), dtype=float) - -wd_grid, ws_grid = np.meshgrid(wd_array, ws_array, indexing="ij") -freq_interp = NearestNDInterpolator(df_wr[["wd", "ws"]], df_wr["freq_val"]) -freq = freq_interp(wd_grid, ws_grid) -freq = freq / np.sum(freq) - -for fi in [fi_fixed, fi_floating]: - fi.reinitialize( - wind_directions=wd_array, - wind_speeds=ws_array, - ) - -# Compute the AEP -aep_fixed = fi_fixed.get_farm_AEP(freq=freq) -aep_floating = fi_floating.get_farm_AEP(freq=freq) -print("Farm AEP (fixed bottom): {:.3f} GWh".format(aep_fixed / 1.0e9)) -print("Farm AEP (floating): {:.3f} GWh".format(aep_floating / 1.0e9)) -print("Floating AEP increase: {0:.3f} GWh ({1:.2f}%)".\ - format((aep_floating - aep_fixed) / 1.0e9, - (aep_floating - aep_fixed)/aep_fixed*100 - ) -) - -plt.show() diff --git a/examples/30_multi_dimensional_cp_ct.py b/examples/30_multi_dimensional_cp_ct.py deleted file mode 100644 index 2d2303018..000000000 --- a/examples/30_multi_dimensional_cp_ct.py +++ /dev/null @@ -1,104 +0,0 @@ -# Copyright 2023 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import numpy as np - -from floris.tools import FlorisInterface - - -""" -This example follows the same setup as example 01 to createa a FLORIS instance and: -1) Makes a two-turbine layout -2) Demonstrates single ws/wd simulations -3) Demonstrates mulitple ws/wd simulations - -with the modification of using a turbine definition that has a multi-dimensional Cp/Ct table. - -In the input file `gch_multi_dim_cp_ct.yaml`, the turbine_type points to a turbine definition, -iea_15MW_floating_multi_dim_cp_ct.yaml located in the turbine_library, -that supplies a multi-dimensional Cp/Ct data file in the form of a .csv file. This .csv file -contains two additional conditions to define Cp/Ct values for: Tp for wave period, and Hs for wave -height. For every combination of Tp and Hs defined, a Cp/Ct/Wind speed table of values is also -defined. It is required for this .csv file to have the last 3 columns be ws, Cp, and Ct. In order -for this table to be used, the flag 'multi_dimensional_cp_ct' must be present and set to true in -the turbine definition. Also of note is the 'velocity_model' must be set to 'multidim_cp_ct' in -the main input file. With both of these values provided, the solver will downselect to use the -interpolant defined at the closest conditions. The user must supply these conditions in the -main input file under the 'flow_field' section, e.g.: - -NOTE: The multi-dimensional Cp/Ct data used in this example is fictional for the purposes of -facilitating this example. The Cp/Ct values for the different wave conditions are scaled -values of the original Cp/Ct data for the IEA 15MW turbine. - -flow_field: - multidim_conditions: - Tp: 2.5 - Hs: 3.01 - -The solver will then use the nearest-neighbor interpolant. These conditions are currently global -and used to select the interpolant at each turbine. - -Also note in the example below that there is a specific method for computing powers when -using turbines with multi-dimensional Cp/Ct data under FlorisInterface, called -'get_turbine_powers_multidim'. The normal 'get_turbine_powers' method will not work. -""" - -# Initialize FLORIS with the given input file via FlorisInterface. -fi = FlorisInterface("inputs/gch_multi_dim_cp_ct.yaml") - -# Convert to a simple two turbine layout -fi.reinitialize(layout_x=[0., 500.], layout_y=[0., 0.]) - -# Single wind speed and wind direction -print('\n========================= Single Wind Direction and Wind Speed =========================') - -# Get the turbine powers assuming 1 wind speed and 1 wind direction -fi.reinitialize(wind_directions=[270.], wind_speeds=[8.0]) - -# Set the yaw angles to 0 -yaw_angles = np.zeros([1,1,2]) # 1 wind direction, 1 wind speed, 2 turbines -fi.calculate_wake(yaw_angles=yaw_angles) - -# Get the turbine powers -turbine_powers = fi.get_turbine_powers_multidim()/1000. -print('The turbine power matrix should be of dimensions 1 WD X 1 WS X 2 Turbines') -print(turbine_powers) -print("Shape: ",turbine_powers.shape) - -# Single wind speed and multiple wind directions -print('\n========================= Single Wind Direction and Multiple Wind Speeds ===============') - - -wind_speeds = np.array([8.0, 9.0, 10.0]) -fi.reinitialize(wind_speeds=wind_speeds) -yaw_angles = np.zeros([1,3,2]) # 1 wind direction, 3 wind speeds, 2 turbines -fi.calculate_wake(yaw_angles=yaw_angles) -turbine_powers = fi.get_turbine_powers_multidim()/1000. -print('The turbine power matrix should be of dimensions 1 WD X 3 WS X 2 Turbines') -print(turbine_powers) -print("Shape: ",turbine_powers.shape) - -# Multiple wind speeds and multiple wind directions -print('\n========================= Multiple Wind Directions and Multiple Wind Speeds ============') - -wind_directions = np.array([260., 270., 280.]) -wind_speeds = np.array([8.0, 9.0, 10.0]) -fi.reinitialize(wind_directions=wind_directions, wind_speeds=wind_speeds) -yaw_angles = np.zeros([1,3,2]) # 1 wind direction, 3 wind speeds, 2 turbines -fi.calculate_wake(yaw_angles=yaw_angles) -turbine_powers = fi.get_turbine_powers_multidim()/1000. -print('The turbine power matrix should be of dimensions 3 WD X 3 WS X 2 Turbines') -print(turbine_powers) -print("Shape: ",turbine_powers.shape) diff --git a/examples/31_multi_dimensional_cp_ct_2Hs.py b/examples/31_multi_dimensional_cp_ct_2Hs.py deleted file mode 100644 index 6bbc31d6d..000000000 --- a/examples/31_multi_dimensional_cp_ct_2Hs.py +++ /dev/null @@ -1,76 +0,0 @@ -# Copyright 2023 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface - - -""" -This example follows after example 30 but shows the effect of changing the Hs setting. - -NOTE: The multi-dimensional Cp/Ct data used in this example is fictional for the purposes of -facilitating this example. The Cp/Ct values for the different wave conditions are scaled -values of the original Cp/Ct data for the IEA 15MW turbine. -""" - -# Initialize FLORIS with the given input file via FlorisInterface. -fi = FlorisInterface("inputs/gch_multi_dim_cp_ct.yaml") - -# Make a second FLORIS interface with a different setting for Hs. -# Note the multi-cp-ct file (iea_15MW_multi_dim_Tp_Hs.csv) -# for the turbine model iea_15MW_floating_multi_dim_cp_ct.yaml -# Defines Hs at 1 and 5. -# The value in gch_multi_dim_cp_ct.yaml is 3.01 which will map -# to 5 as the nearer value, so we set the other case to 1 -# for contrast. -fi_dict_mod = fi.floris.as_dict() -fi_dict_mod['flow_field']['multidim_conditions']['Hs'] = 1.0 -fi_hs_1 = FlorisInterface(fi_dict_mod) - -# Set both cases to 3 turbine layout -fi.reinitialize(layout_x=[0., 500., 1000.], layout_y=[0., 0., 0.]) -fi_hs_1.reinitialize(layout_x=[0., 500., 1000.], layout_y=[0., 0., 0.]) - -# Use a sweep of wind speeds -wind_speeds = np.arange(5,20,1.) -fi.reinitialize(wind_directions=[270.], wind_speeds=wind_speeds) -fi_hs_1.reinitialize(wind_directions=[270.], wind_speeds=wind_speeds) - -# Calculate wakes with baseline yaw -fi.calculate_wake() -fi_hs_1.calculate_wake() - -# Collect the turbine powers in kW -turbine_powers = fi.get_turbine_powers_multidim()/1000. -turbine_powers_hs_1 = fi_hs_1.get_turbine_powers_multidim()/1000. - -# Plot the power in each case and the difference in power -fig, axarr = plt.subplots(1,3,sharex=True,figsize=(12,4)) - -for t_idx in range(3): - ax = axarr[t_idx] - ax.plot(wind_speeds, turbine_powers[0,:,t_idx], color='k', label='Hs=3.1 (5)') - ax.plot(wind_speeds, turbine_powers_hs_1[0,:,t_idx], color='r', label='Hs=1.0') - ax.grid(True) - ax.set_xlabel('Wind Speed (m/s)') - ax.set_title(f'Turbine {t_idx}') - -axarr[0].set_ylabel('Power (kW)') -axarr[0].legend() -fig.suptitle('Power of each turbine') - -plt.show() diff --git a/examples/32_specify_turbine_power_curve.py b/examples/32_specify_turbine_power_curve.py deleted file mode 100644 index 03fbf9978..000000000 --- a/examples/32_specify_turbine_power_curve.py +++ /dev/null @@ -1,78 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -import floris.tools.visualization as wakeviz -from floris.tools import FlorisInterface -from floris.turbine_library.turbine_utilities import build_turbine_dict - - -""" -This example demonstrates how to specify a turbine model based on a power -and thrust curve for the wind turbine, as well as possible physical parameters -(which default to the parameters of the NREL 5MW reference turbine). - -Note that it is also possible to have a .yaml created, if the file_path -argument to build_turbine_dict is set. -""" - -# Generate an example turbine power and thrust curve for use in the FLORIS model -turbine_data_dict = { - "wind_speed":[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20], - "power_absolute":[0, 30, 200, 500, 1000, 2000, 4000, 4000, 4000, 4000, 4000], - "thrust_coefficient":[0, 0.9, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.25, 0.2] -} - -turbine_dict = build_turbine_dict( - turbine_data_dict, - "example_turbine", - file_path=None, - generator_efficiency=1, - hub_height=90, - pP=1.88, - pT=1.88, - rotor_diameter=126, - TSR=8, - air_density=1.225, - ref_tilt_cp_ct=5 -) - -fi = FlorisInterface("inputs/gch.yaml") -wind_speeds = np.linspace(1, 15, 100) -# Replace the turbine(s) in the FLORIS model with the created one -fi.reinitialize( - layout_x=[0], - layout_y=[0], - wind_speeds=wind_speeds, - turbine_type=[turbine_dict] -) -fi.calculate_wake() - -powers = fi.get_farm_power() - -fig, ax = plt.subplots(1,1) - -ax.scatter(wind_speeds, powers[0,:]/1000, color="C0", s=5, label="Test points") -ax.scatter(turbine_data_dict["wind_speed"], turbine_data_dict["power_absolute"], - color="red", s=20, label="Specified points") - -ax.grid() -ax.set_xlabel("Wind speed [m/s]") -ax.set_ylabel("Power [kW]") -ax.legend() - -plt.show() diff --git a/examples/_convert_examples_to_notebooks.py b/examples/_convert_examples_to_notebooks.py new file mode 100644 index 000000000..c8bbe2482 --- /dev/null +++ b/examples/_convert_examples_to_notebooks.py @@ -0,0 +1,127 @@ +""" +Utility script to convert all Python scripts in the current directory to + Jupyter notebooks. + +""" + +import os + +import nbformat as nbf + + +def script_to_notebook(script_path, notebook_path): + # Read Python script + with open(script_path, "r") as f: + python_code = f.read() + + # Clear out leading whitespace + python_code = python_code.strip() + + # Append to the bottom of the code suppression of warnings + python_code += """ +import warnings +warnings.filterwarnings('ignore') +""" + + # Create a new Jupyter notebook + nb = nbf.v4.new_notebook() + + # The first line of code it the title, copy it, remove and + # leading quotes or comments and make it a markdown cell with one hash + title = python_code.split("\n")[0].strip().strip("#").strip().strip('"').strip().strip("'") + nb["cells"].append(nbf.v4.new_markdown_cell(f"# {title}")) + + # # Every code block starts with a comment block surrounded by """ and ends with """ + # # Find that block and place it in markdown cell + # code_comments = python_code.split('"""')[1] + + # # Remove the top line + # code_comments = code_comments.split("\n")[1:] + + # # Add the code comments + # nb["cells"].append(nbf.v4.new_markdown_cell(code_comments)) + + # # Add Python code to the notebook + + # # Remove the top commented block ("""...""") but keep everything after it + # python_code = python_code.split('"""')[2] + + # Strip any leading white space + python_code = python_code.strip() + + nb["cells"].append(nbf.v4.new_code_cell(python_code)) + + # Write the notebook to a file + with open(notebook_path, "w") as f: + nbf.write(nb, f) + + +# Traverse the current directory and subdirectories to find +# all python scripts that start with a number +# and end with .py and make a list of all such scripts including relative path +scripts = sorted( + [ + os.path.join(dp, f) + for dp, dn, filenames in os.walk(".") + for f in filenames + if f.endswith(".py") and f[0].isdigit() + ] +) + + +# For each Python script, convert it to a Jupyter notebook +notebook_directories = [] +notebook_filenames = [] +for script_path in scripts: + print(f"Converting {script_path} to Notebook...") + + notebook_path = script_path.replace(".py", ".ipynb") + notebook_directories.append(os.path.dirname(notebook_path)) + notebook_filenames.append(os.path.basename(notebook_path)) + + script_to_notebook(script_path, notebook_path) + + +# Make a dictionary of all the notebooks, whose keys are +# unique entries in the notebook_directories list +# and values are lists of notebook filenames in that directory +notebooks = {k: [] for k in notebook_directories} +for i, directory in enumerate(notebook_directories): + notebooks[directory].append(notebook_filenames[i]) + +print(notebooks) + +# Now read in the _toc.yaml file one level up and add each of the note books to a new chapter +# called examples and re-write the _toc.yaml file +toc_path = "../_toc.yml" + +# Load the toc file as a file +with open(toc_path, "r") as f: + toc = f.read() + +# Append a blank line and then " - caption: Developer Reference" to the toc +toc += "\n - caption: Examples\n chapters:\n" + +# For each entry in the '.' directory, add it to the toc as a file +for nb in notebooks["."]: + toc += f" - file: examples/{nb}\n" + +# For the remaining keys in the notebooks dictionary, first add a section for the directory +# and then add the notebooks in that directory as a file +for directory in notebooks: + if directory == ".": + continue + dir_without_dot_slash = directory[2:] + dir_without_examples_ = dir_without_dot_slash.replace("examples_", "") + dir_without_examples_ = dir_without_examples_.replace("_", " ").capitalize() + toc += f"\n - caption: Examples - {dir_without_examples_}\n chapters:\n" + for nb in notebooks[directory]: + toc += f" - file: examples/{dir_without_dot_slash}/{nb}\n" + +# Print the toc +print("\n\nTOC: FILE:\n") +print(toc) + +# Save the toc +with open(toc_path, "w") as f: + f.write(toc) diff --git a/examples/examples_control_optimization/001_opt_yaw_single_ws.py b/examples/examples_control_optimization/001_opt_yaw_single_ws.py new file mode 100644 index 000000000..533347a78 --- /dev/null +++ b/examples/examples_control_optimization/001_opt_yaw_single_ws.py @@ -0,0 +1,66 @@ + +"""Example: Optimize yaw for a single wind speed and multiple wind directions + +Use the serial-refine method to optimize the yaw angles for a 3-turbine wind farm + +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel, TimeSeries +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR + + +# Load the default example floris object +fmodel = FlorisModel("../inputs/gch.yaml") + +# Define an inflow that +# keeps wind speed and TI constant while sweeping the wind directions +wind_directions = np.arange(0.0, 360.0, 3.0) +time_series = TimeSeries( + wind_directions=wind_directions, + wind_speeds=8.0, + turbulence_intensities=0.06, +) + +# Reinitialize as a 3-turbine using the above inflow +D = 126.0 # Rotor diameter for the NREL 5 MW +fmodel.set( + layout_x=[0.0, 5 * D, 10 * D], + layout_y=[0.0, 0.0, 0.0], + wind_data=time_series, +) + +# Initialize optimizer object and run optimization using the Serial-Refine method +yaw_opt = YawOptimizationSR(fmodel) +df_opt = yaw_opt.optimize() + +print("Optimization results:") +print(df_opt) + +# Split out the turbine results +for t in range(3): + df_opt['t%d' % t] = df_opt.yaw_angles_opt.apply(lambda x: x[t]) + +# Show the results +fig, axarr = plt.subplots(2,1,sharex=True,sharey=False,figsize=(8,8)) + +# Yaw results +ax = axarr[0] +for t in range(3): + ax.plot(df_opt.wind_direction,df_opt['t%d' % t],label='t%d' % t) +ax.set_ylabel('Yaw Offset (deg') +ax.legend() +ax.grid(True) + +# Power results +ax = axarr[1] +ax.plot(df_opt.wind_direction,df_opt.farm_power_baseline,color='k',label='Baseline Farm Power') +ax.plot(df_opt.wind_direction,df_opt.farm_power_opt,color='r',label='Optimized Farm Power') +ax.set_ylabel('Power (W)') +ax.set_xlabel('Wind Direction (deg)') +ax.legend() +ax.grid(True) + +plt.show() diff --git a/examples/examples_control_optimization/002_opt_yaw_single_ws_uncertain.py b/examples/examples_control_optimization/002_opt_yaw_single_ws_uncertain.py new file mode 100644 index 000000000..4b9ceda1e --- /dev/null +++ b/examples/examples_control_optimization/002_opt_yaw_single_ws_uncertain.py @@ -0,0 +1,112 @@ +"""Example: Optimize yaw for a single wind speed and multiple wind directions. +Compare certain and uncertain results. + +Use the serial-refine method to optimize the yaw angles for a 3-turbine wind farm. In one +case use the FlorisModel without uncertainty and in the other use the UncertainFlorisModel +with a wind direction standard deviation of 3 degrees. Compare the results. + +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, + UncertainFlorisModel, +) +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR + + +# Load the floris model and uncertain floris model +fmodel = FlorisModel("../inputs/gch.yaml") +ufmodel = UncertainFlorisModel("../inputs/gch.yaml", wd_std=3) + + +# Define an inflow that +# keeps wind speed and TI constant while sweeping the wind directions +wind_directions = np.arange(250, 290.0, 1.0) +time_series = TimeSeries( + wind_directions=wind_directions, + wind_speeds=8.0, + turbulence_intensities=0.06, +) + +# Reinitialize as a 3-turbine using the above inflow +D = 126.0 # Rotor diameter for the NREL 5 MW +fmodel.set( + layout_x=[0.0, 5 * D, 10 * D], + layout_y=[0.0, 0.0, 0.0], + wind_data=time_series, +) +ufmodel.set( + layout_x=[0.0, 5 * D, 10 * D], + layout_y=[0.0, 0.0, 0.0], + wind_data=time_series, +) + +# Initialize optimizer object and run optimization using the Serial-Refine method +print("++++++++++CERTAIN++++++++++++") +yaw_opt = YawOptimizationSR(fmodel) +df_opt = yaw_opt.optimize() + +# Repeat with uncertain model +print("++++++++++UNCERTAIN++++++++++++") +yaw_opt_u = YawOptimizationSR(ufmodel) +df_opt_uncertain = yaw_opt_u.optimize() + +# Split out the turbine results +for t in range(3): + df_opt["t%d" % t] = df_opt.yaw_angles_opt.apply(lambda x: x[t]) + df_opt_uncertain["t%d" % t] = df_opt_uncertain.yaw_angles_opt.apply(lambda x: x[t]) + +# Show the yaw and turbine results +fig, axarr = plt.subplots(3, sharex=True, sharey=False, figsize=(15, 8)) + +# Yaw results +for tindex in range(3): + ax = axarr[tindex] + ax.plot( + df_opt.wind_direction, df_opt["t%d" % tindex], label="FlorisModel", color="k", marker="o" + ) + ax.plot( + df_opt_uncertain.wind_direction, + df_opt_uncertain["t%d" % tindex], + label="UncertainFlorisModel", + color="r", + marker="x", + ) + ax.set_ylabel("Yaw Offset (deg") + ax.legend() + ax.grid(True) + + +# Power results +fig, axarr = plt.subplots(1, 2, figsize=(15, 5), sharex=True, sharey=True) +ax = axarr[0] +ax.plot(df_opt.wind_direction, df_opt.farm_power_baseline, color="k", label="Baseline Farm Power") +ax.plot(df_opt.wind_direction, df_opt.farm_power_opt, color="r", label="Optimized Farm Power") +ax.set_ylabel("Power (W)") +ax.set_xlabel("Wind Direction (deg)") +ax.legend() +ax.grid(True) +ax.set_title("Certain") +ax = axarr[1] +ax.plot( + df_opt_uncertain.wind_direction, + df_opt_uncertain.farm_power_baseline, + color="k", + label="Baseline Farm Power", +) +ax.plot( + df_opt_uncertain.wind_direction, + df_opt_uncertain.farm_power_opt, + color="r", + label="Optimized Farm Power", +) +ax.set_xlabel("Wind Direction (deg)") +ax.grid(True) +ax.set_title("Uncertain") + + +plt.show() diff --git a/examples/11_opt_yaw_multiple_ws.py b/examples/examples_control_optimization/003_opt_yaw_multiple_ws.py similarity index 72% rename from examples/11_opt_yaw_multiple_ws.py rename to examples/examples_control_optimization/003_opt_yaw_multiple_ws.py index fb7cc8448..1a2d7e0a0 100644 --- a/examples/11_opt_yaw_multiple_ws.py +++ b/examples/examples_control_optimization/003_opt_yaw_multiple_ws.py @@ -1,44 +1,39 @@ -# Copyright 2022 NREL -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. +"""Example: Optimize yaw for multiple wind directions and multiple wind speeds. +This example demonstrates how to perform a yaw optimization for multiple wind directions +and multiple wind speeds using the WindRose object -# See https://floris.readthedocs.io for documentation +First, we initialize our Floris Interface, and then generate a 3 turbine wind farm. +Next, we create the yaw optimization object `yaw_opt` and perform the optimization using +the SerialRefine method. Finally, we plot the results. +""" import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR +from floris import FlorisModel, WindRose +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR -""" -This example demonstrates how to perform a yaw optimization for multiple wind directions -and multiple wind speeds. +# Load the default example floris object +fmodel = FlorisModel("../inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 +# fmodel = FlorisModel("inputs/cc.yaml") # New CumulativeCurl model + +# Define a WindRose object with uniform TI and frequency table +wind_rose = WindRose( + wind_directions=np.arange(0.0, 360.0, 3.0), + wind_speeds=np.arange(2.0, 18.0, 1.0), + ti_table=0.06, +) -First, we initialize our Floris Interface, and then generate a 3 turbine wind farm. -Next, we create the yaw optimization object `yaw_opt` and perform the optimization using -the SerialRefine method. Finally, we plot the results. -""" -# Load the default example floris object -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model -# Reinitialize as a 3-turbine farm with range of WDs and 1 WS +# Reinitialize as a 3-turbine farm with range of WDs and WSs D = 126.0 # Rotor diameter for the NREL 5 MW -fi.reinitialize( +fmodel.set( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], - wind_directions=np.arange(0.0, 360.0, 3.0), - wind_speeds=np.arange(2.0, 18.0, 1.0), + wind_data=wind_rose, ) # Initialize optimizer object and run optimization using the Serial-Refine method @@ -46,13 +41,13 @@ # yaw misalignment that increases the wind farm power production by a negligible # amount. For example, at high wind speeds (e.g., 16 m/s), a turbine might yaw # by a substantial amount to increase the power production by less than 1 W. This -# is typically the result of numerical inprecision of the power coefficient curve, +# is typically the result of numerical imprecision of the power coefficient curve, # which slightly differs for different above-rated wind speeds. The option # verify_convergence therefore refines and validates the yaw angle choices # but has no effect on the predicted power uplift from wake steering. # Hence, it should mostly be used when actually synthesizing a practicable # wind farm controller. -yaw_opt = YawOptimizationSR(fi, verify_convergence=True) +yaw_opt = YawOptimizationSR(fmodel) df_opt = yaw_opt.optimize() print("Optimization results:") @@ -71,7 +66,7 @@ figsize=(10, 8) ) jj = 0 -for ii, ws in enumerate(fi.floris.flow_field.wind_speeds): +for ii, ws in enumerate(np.unique(fmodel.wind_speeds)): xi = np.remainder(ii, 4) if ((ii > 0) & (xi == 0)): jj += 1 @@ -101,7 +96,7 @@ figsize=(10, 8) ) jj = 0 -for ii, ws in enumerate(fi.floris.flow_field.wind_speeds): +for ii, ws in enumerate(np.unique(fmodel.wind_speeds)): xi = np.remainder(ii, 4) if ((ii > 0) & (xi == 0)): jj += 1 diff --git a/examples/examples_control_optimization/004_optimize_yaw_aep.py b/examples/examples_control_optimization/004_optimize_yaw_aep.py new file mode 100644 index 000000000..00269e6fe --- /dev/null +++ b/examples/examples_control_optimization/004_optimize_yaw_aep.py @@ -0,0 +1,156 @@ +"""Example: Optimize yaw and compare AEP + +This example demonstrates how to perform a yaw optimization and evaluate the performance +over a full wind rose. + +The script performs the following steps: + 1. Load a wind rose from a csv file + 2. Calculates the optimal yaw angles for a wind speed of 8 m/s across the directions + 3. Applies the optimal yaw angles to the wind rose and calculates the AEP + +""" + +from time import perf_counter as timerpc + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, + WindRose, +) +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR + + +# Load the wind rose from csv +wind_rose = WindRose.read_csv_long( + "../inputs/wind_rose.csv", wd_col="wd", ws_col="ws", freq_col="freq_val", ti_col_or_value=0.06 +) + +# Load FLORIS +fmodel = FlorisModel("../inputs/gch.yaml") + +# Specify wind farm layout and update in the floris object +N = 2 # number of turbines per row and per column +X, Y = np.meshgrid( + 5.0 * fmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1), + 5.0 * fmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1), +) +fmodel.set(layout_x=X.flatten(), layout_y=Y.flatten()) + +# Get the number of turbines +n_turbines = len(fmodel.layout_x) + +# Optimize the yaw angles. This could be done for every wind direction and wind speed +# but in practice it is much faster to optimize only for one speed and infer the rest +# using a rule of thumb +time_series = TimeSeries( + wind_directions=wind_rose.wind_directions, wind_speeds=8.0, turbulence_intensities=0.06 +) +fmodel.set(wind_data=time_series) + +# Get the optimal angles +start_time = timerpc() +yaw_opt = YawOptimizationSR( + fmodel=fmodel, + minimum_yaw_angle=0.0, # Allowable yaw angles lower bound + maximum_yaw_angle=20.0, # Allowable yaw angles upper bound + Ny_passes=[5, 4], + exclude_downstream_turbines=True, +) +df_opt = yaw_opt.optimize() +end_time = timerpc() +t_tot = end_time - start_time +print("Optimization finished in {:.2f} seconds.".format(t_tot)) + + +# Calculate the AEP in the baseline case +fmodel.set(wind_data=wind_rose) +fmodel.run() +farm_power_baseline = fmodel.get_farm_power() +aep_baseline = fmodel.get_farm_AEP() + + +# Now need to apply the optimal yaw angles to the wind rose to get the optimized AEP +# do this by applying a rule of thumb where the optimal yaw is applied between 6 and 12 m/s +# and ramped down to 0 above and below this range + +# Grab wind speeds and wind directions from the fmodel. Note that we do this because the +# yaw angles will need to be n_findex long, and accounting for the fact that some wind +# directions and wind speeds may not be present in the wind rose (0 frequency) and aren't +# included in the fmodel +wind_directions = fmodel.wind_directions +wind_speeds = fmodel.wind_speeds +n_findex = fmodel.n_findex + + +# Now define how the optimal yaw angles for 8 m/s are applied over the other wind speeds +yaw_angles_opt = np.vstack(df_opt["yaw_angles_opt"]) +yaw_angles_wind_rose = np.zeros((n_findex, n_turbines)) +for i in range(n_findex): + wind_speed = wind_speeds[i] + wind_direction = wind_directions[i] + + # Interpolate the optimal yaw angles for this wind direction from df_opt + id_opt = df_opt["wind_direction"] == wind_direction + yaw_opt_full = np.array(df_opt.loc[id_opt, "yaw_angles_opt"])[0] + + # Now decide what to do for different wind speeds + if (wind_speed < 4.0) | (wind_speed > 14.0): + yaw_opt = np.zeros(n_turbines) # do nothing for very low/high speeds + elif wind_speed < 6.0: + yaw_opt = yaw_opt_full * (6.0 - wind_speed) / 2.0 # Linear ramp up + elif wind_speed > 12.0: + yaw_opt = yaw_opt_full * (14.0 - wind_speed) / 2.0 # Linear ramp down + else: + yaw_opt = yaw_opt_full # Apply full offsets between 6.0 and 12.0 m/s + + # Save to collective array + yaw_angles_wind_rose[i, :] = yaw_opt + + +# Now apply the optimal yaw angles and get the AEP +fmodel.set(yaw_angles=yaw_angles_wind_rose) +fmodel.run() +aep_opt = fmodel.get_farm_AEP() +aep_uplift = 100.0 * (aep_opt / aep_baseline - 1) +farm_power_opt = fmodel.get_farm_power() + +print("Baseline AEP: {:.2f} GWh.".format(aep_baseline/1E9)) +print("Optimal AEP: {:.2f} GWh.".format(aep_opt/1E9)) +print("Relative AEP uplift by wake steering: {:.3f} %.".format(aep_uplift)) + +# Use farm_power_baseline, farm_power_opt and wind_data to make a heat map of uplift by +# wind direction and wind speed +wind_directions = wind_rose.wind_directions +wind_speeds = wind_rose.wind_speeds +relative_gain = farm_power_opt - farm_power_baseline + +# Plot the heatmap with wind speeds on x, wind directions on y and relative gain as the color +fig, ax = plt.subplots(figsize=(10, 12)) +cax = ax.imshow(relative_gain, cmap='viridis', aspect='auto') +fig.colorbar(cax, ax=ax, label="Relative gain (%)") + +ax.set_yticks(np.arange(len(wind_directions))) +ax.set_yticklabels(wind_directions) +ax.set_xticks(np.arange(len(wind_speeds))) +ax.set_xticklabels(wind_speeds) +ax.set_ylabel("Wind direction (deg)") +ax.set_xlabel("Wind speed (m/s)") + +# Reduce x and y tick font size +for tick in ax.yaxis.get_major_ticks(): + tick.label1.set_fontsize(8) + +for tick in ax.xaxis.get_major_ticks(): + tick.label1.set_fontsize(8) + +# Set y ticks to be horizontal +for tick in ax.get_yticklabels(): + tick.set_rotation(0) + +ax.set_title("Uplift in farm power by wind direction and wind speed", fontsize=12) + +plt.tight_layout() +plt.show() diff --git a/examples/examples_control_optimization/005_optimize_yaw_aep_parallel.py b/examples/examples_control_optimization/005_optimize_yaw_aep_parallel.py new file mode 100644 index 000000000..17e02412b --- /dev/null +++ b/examples/examples_control_optimization/005_optimize_yaw_aep_parallel.py @@ -0,0 +1,149 @@ +"""Example: Optimize yaw and compare AEP in parallel + +This example demonstrates how to perform a yaw optimization and evaluate the performance +over a full wind rose. The example repeats the steps in 04 except using parallel +optimization and evaluation. + +Note that constraints on parallelized operations mean that some syntax is different and +not all operations are possible. Also, rather passing the ParallelFlorisModel +object to a YawOptimizationSR object, the optimization is performed +directly by member functions + +""" + +from time import perf_counter as timerpc + +import numpy as np + +from floris import ( + FlorisModel, + ParallelFlorisModel, + TimeSeries, + WindRose, +) + + +# When using parallel optimization it is importat the "root" script include this +# if __name__ == "__main__": block to avoid problems +if __name__ == "__main__": + + # Load the wind rose from csv + wind_rose = WindRose.read_csv_long( + "../inputs/wind_rose.csv", wd_col="wd", ws_col="ws", freq_col="freq_val", + ti_col_or_value=0.06 + ) + + # Load FLORIS + fmodel = FlorisModel("../inputs/gch.yaml") + + # Specify wind farm layout and update in the floris object + N = 2 # number of turbines per row and per column + X, Y = np.meshgrid( + 5.0 * fmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1), + 5.0 * fmodel.core.farm.rotor_diameters_sorted[0][0] * np.arange(0, N, 1), + ) + fmodel.set(layout_x=X.flatten(), layout_y=Y.flatten()) + + # Get the number of turbines + n_turbines = len(fmodel.layout_x) + + # Optimize the yaw angles. This could be done for every wind direction and wind speed + # but in practice it is much faster to optimize only for one speed and infer the rest + # using a rule of thumb + time_series = TimeSeries( + wind_directions=wind_rose.wind_directions, wind_speeds=8.0, turbulence_intensities=0.06 + ) + fmodel.set(wind_data=time_series) + + # Set up the parallel model + parallel_interface = "concurrent" + max_workers = 16 + pfmodel = ParallelFlorisModel( + fmodel=fmodel, + max_workers=max_workers, + n_wind_condition_splits=max_workers, + interface=parallel_interface, + print_timings=True, + ) + + # Get the optimal angles using the parallel interface + start_time = timerpc() + # Now optimize the yaw angles using the Serial Refine method + df_opt = pfmodel.optimize_yaw_angles( + minimum_yaw_angle=0.0, + maximum_yaw_angle=20.0, + Ny_passes=[5, 4], + exclude_downstream_turbines=False, + ) + end_time = timerpc() + t_tot = end_time - start_time + print("Optimization finished in {:.2f} seconds.".format(t_tot)) + + + # Calculate the AEP in the baseline case, using the parallel interface + fmodel.set(wind_data=wind_rose) + pfmodel = ParallelFlorisModel( + fmodel=fmodel, + max_workers=max_workers, + n_wind_condition_splits=max_workers, + interface=parallel_interface, + print_timings=True, + ) + + # Note the pfmodel does not use run() but instead uses the get_farm_power() and get_farm_AEP() + # directly, this is necessary for the parallel interface + aep_baseline = pfmodel.get_farm_AEP(freq=wind_rose.unpack_freq()) + + # Now need to apply the optimal yaw angles to the wind rose to get the optimized AEP + # do this by applying a rule of thumb where the optimal yaw is applied between 6 and 12 m/s + # and ramped down to 0 above and below this range + + # Grab wind speeds and wind directions from the fmodel. Note that we do this because the + # yaw angles will need to be n_findex long, and accounting for the fact that some wind + # directions and wind speeds may not be present in the wind rose (0 frequency) and aren't + # included in the fmodel + wind_directions = fmodel.wind_directions + wind_speeds = fmodel.wind_speeds + n_findex = fmodel.n_findex + + + # Now define how the optimal yaw angles for 8 m/s are applied over the other wind speeds + yaw_angles_opt = np.vstack(df_opt["yaw_angles_opt"]) + yaw_angles_wind_rose = np.zeros((n_findex, n_turbines)) + for i in range(n_findex): + wind_speed = wind_speeds[i] + wind_direction = wind_directions[i] + + # Interpolate the optimal yaw angles for this wind direction from df_opt + id_opt = df_opt["wind_direction"] == wind_direction + yaw_opt_full = np.array(df_opt.loc[id_opt, "yaw_angles_opt"])[0] + + # Now decide what to do for different wind speeds + if (wind_speed < 4.0) | (wind_speed > 14.0): + yaw_opt = np.zeros(n_turbines) # do nothing for very low/high speeds + elif wind_speed < 6.0: + yaw_opt = yaw_opt_full * (6.0 - wind_speed) / 2.0 # Linear ramp up + elif wind_speed > 12.0: + yaw_opt = yaw_opt_full * (14.0 - wind_speed) / 2.0 # Linear ramp down + else: + yaw_opt = yaw_opt_full # Apply full offsets between 6.0 and 12.0 m/s + + # Save to collective array + yaw_angles_wind_rose[i, :] = yaw_opt + + + # Now apply the optimal yaw angles and get the AEP + fmodel.set(yaw_angles=yaw_angles_wind_rose) + pfmodel = ParallelFlorisModel( + fmodel=fmodel, + max_workers=max_workers, + n_wind_condition_splits=max_workers, + interface=parallel_interface, + print_timings=True, + ) + aep_opt = pfmodel.get_farm_AEP(freq=wind_rose.unpack_freq(), yaw_angles=yaw_angles_wind_rose) + aep_uplift = 100.0 * (aep_opt / aep_baseline - 1) + + print("Baseline AEP: {:.2f} GWh.".format(aep_baseline/1E9)) + print("Optimal AEP: {:.2f} GWh.".format(aep_opt/1E9)) + print("Relative AEP uplift by wake steering: {:.3f} %.".format(aep_uplift)) diff --git a/examples/14_compare_yaw_optimizers.py b/examples/examples_control_optimization/006_compare_yaw_optimizers.py similarity index 74% rename from examples/14_compare_yaw_optimizers.py rename to examples/examples_control_optimization/006_compare_yaw_optimizers.py index 1c4e29c31..e0c39bbba 100644 --- a/examples/14_compare_yaw_optimizers.py +++ b/examples/examples_control_optimization/006_compare_yaw_optimizers.py @@ -1,34 +1,9 @@ -# Copyright 2022 NREL -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 +"""Example: Compare yaw optimizers +This example compares the SciPy-based yaw optimizer with the Serial-Refine optimizer +and geometric optimizer. -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -from time import perf_counter as timerpc - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools.optimization.yaw_optimization.yaw_optimizer_geometric import ( - YawOptimizationGeometric, -) -from floris.tools.optimization.yaw_optimization.yaw_optimizer_scipy import YawOptimizationScipy -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR - - -""" -This example compares the SciPy-based yaw optimizer with the new Serial-Refine optimizer. - -First, we initialize our Floris Interface, and then generate a 3 turbine wind farm. +First, we initialize Floris, and then generate a 3 turbine wind farm. Next, we create two yaw optimization objects, `yaw_opt_sr` and `yaw_opt_scipy` for the Serial-Refine and SciPy methods, respectively. We then perform the optimization using both methods. @@ -38,39 +13,55 @@ The example now also compares the Geometric Yaw optimizer, which is fast a method to find approximately optimal yaw angles based on the wind farm geometry. Its main use case is for coupled layout and yaw optimization. -see floris.tools.optimization.yaw_optimization.yaw_optimizer_geometric.py and the paper online +see floris.optimization.yaw_optimization.yaw_optimizer_geometric.py and the paper online at https://wes.copernicus.org/preprints/wes-2023-1/. See also example 16c. """ +from time import perf_counter as timerpc + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel +from floris.optimization.yaw_optimization.yaw_optimizer_geometric import ( + YawOptimizationGeometric, +) +from floris.optimization.yaw_optimization.yaw_optimizer_scipy import YawOptimizationScipy +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR + + # Load the default example floris object -fi = FlorisInterface("inputs/gch.yaml") # GCH model matched to the default "legacy_gauss" of V2 -# fi = FlorisInterface("inputs/cc.yaml") # New CumulativeCurl model +fmodel = FlorisModel("../inputs/gch.yaml") # Reinitialize as a 3-turbine farm with range of WDs and 1 WS D = 126.0 # Rotor diameter for the NREL 5 MW -fi.reinitialize( +wd_array = np.arange(0.0, 360.0, 3.0) +ws_array = 8.0 * np.ones_like(wd_array) +turbulence_intensities = 0.06 * np.ones_like(wd_array) +fmodel.set( layout_x=[0.0, 5 * D, 10 * D], layout_y=[0.0, 0.0, 0.0], - wind_directions=np.arange(0.0, 360.0, 3.0), - wind_speeds=[8.0], + wind_directions=wd_array, + wind_speeds=ws_array, + turbulence_intensities=turbulence_intensities, ) print("Performing optimizations with SciPy...") start_time = timerpc() -yaw_opt_scipy = YawOptimizationScipy(fi) +yaw_opt_scipy = YawOptimizationScipy(fmodel) df_opt_scipy = yaw_opt_scipy.optimize() time_scipy = timerpc() - start_time print("Performing optimizations with Serial Refine...") start_time = timerpc() -yaw_opt_sr = YawOptimizationSR(fi) +yaw_opt_sr = YawOptimizationSR(fmodel) df_opt_sr = yaw_opt_sr.optimize() time_sr = timerpc() - start_time print("Performing optimizations with Geometric Yaw...") start_time = timerpc() -yaw_opt_geo = YawOptimizationGeometric(fi) +yaw_opt_geo = YawOptimizationGeometric(fmodel) df_opt_geo = yaw_opt_geo.optimize() time_geo = timerpc() - start_time @@ -103,9 +94,9 @@ # Before plotting results, need to compute values for GEOOPT since it doesn't compute # power within the optimization -yaw_angles_opt_geo_3d = np.expand_dims(yaw_angles_opt_geo, axis=1) -fi.calculate_wake(yaw_angles=yaw_angles_opt_geo_3d) -geo_farm_power = fi.get_farm_power().squeeze() +fmodel.set(yaw_angles=yaw_angles_opt_geo) +fmodel.run() +geo_farm_power = fmodel.get_farm_power().squeeze() fig, ax = plt.subplots() diff --git a/examples/examples_control_optimization/007_optimize_yaw_with_neighbor_farms.py b/examples/examples_control_optimization/007_optimize_yaw_with_neighbor_farms.py new file mode 100644 index 000000000..04b6b65ba --- /dev/null +++ b/examples/examples_control_optimization/007_optimize_yaw_with_neighbor_farms.py @@ -0,0 +1,317 @@ +"""Example: Optimize yaw with neighbor farm + +This example demonstrates how to optimize the yaw angles of a subset of turbines +in order to maximize the annual energy production (AEP) of a wind farm. In this +case, the wind farm is part of a larger collection of turbines, some of which are +part of a neighboring farm. The optimization is performed in two ways: first by +accounting for the wakes of the neighboring farm (while not including those turbines) +in the optimization as a target of yaw angle changes or including their power +in the objective function. In th second method the neighboring farms are removed +from FLORIS for the optimization. The AEP is then calculated for the optimized +yaw angles (accounting for and not accounting for the neighboring farm) and compared +to the baseline AEP. +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, + WindRose, +) +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR + + +# Load the wind rose from csv +wind_rose = WindRose.read_csv_long( + "../inputs/wind_rose.csv", wd_col="wd", ws_col="ws", freq_col="freq_val", ti_col_or_value=0.06 +) + +# Load FLORIS +fmodel = FlorisModel("../inputs/gch.yaml") + +# Specify a layout of turbines in which only the first 10 turbines are part +# of the farm to be optimized, while the others belong to a neighboring farm +X = ( + np.array( + [ + 0.0, + 756.0, + 1512.0, + 2268.0, + 3024.0, + 0.0, + 756.0, + 1512.0, + 2268.0, + 3024.0, + 0.0, + 756.0, + 1512.0, + 2268.0, + 3024.0, + 0.0, + 756.0, + 1512.0, + 2268.0, + 3024.0, + 4500.0, + 5264.0, + 6028.0, + 4878.0, + 0.0, + 756.0, + 1512.0, + 2268.0, + 3024.0, + ] + ) + / 1.5 +) +Y = ( + np.array( + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 504.0, + 504.0, + 504.0, + 504.0, + 504.0, + 1008.0, + 1008.0, + 1008.0, + 1008.0, + 1008.0, + 1512.0, + 1512.0, + 1512.0, + 1512.0, + 1512.0, + 4500.0, + 4059.0, + 3618.0, + 5155.0, + -504.0, + -504.0, + -504.0, + -504.0, + -504.0, + ] + ) + / 1.5 +) + +# Turbine weights: we want to only optimize for the first 10 turbines +turbine_weights = np.zeros(len(X), dtype=int) +turbine_weights[0:10] = 1.0 + +# Now reinitialize FLORIS layout +fmodel.set(layout_x=X, layout_y=Y) + +# And visualize the floris layout +fig, ax = plt.subplots() +ax.plot(X[turbine_weights == 0], Y[turbine_weights == 0], "ro", label="Neighboring farms") +ax.plot(X[turbine_weights == 1], Y[turbine_weights == 1], "go", label="Farm subset") +ax.grid(True) +ax.set_xlabel("x coordinate (m)") +ax.set_ylabel("y coordinate (m)") +ax.legend() + +# Indicate turbine 0 in the plot above with an annotation arrow +ax.annotate( + "Turbine 0", + (X[0], Y[0]), + xytext=(X[0] + 100, Y[0] + 100), + arrowprops={'facecolor':"black", 'shrink':0.05}, +) + + +# Optimize the yaw angles. This could be done for every wind direction and wind speed +# but in practice it is much faster to optimize only for one speed and infer the rest +# using a rule of thumb +time_series = TimeSeries( + wind_directions=wind_rose.wind_directions, wind_speeds=8.0, turbulence_intensities=0.06 +) +fmodel.set(wind_data=time_series) + +# CASE 1: Optimize the yaw angles of the included farm while accounting for the +# wake effects of the neighboring farm by using turbine weights + +# It's important here to do two things: +# 1. Exclude the downstream turbines from the power optimization goal via +# turbine_weights +# 2. Prevent the optimizer from changing the yaw angles of the turbines in the +# neighboring farm by limiting the yaw angles min max both to 0 + +# Set the yaw angles max min according to point(2) above +minimum_yaw_angle = np.zeros( + ( + fmodel.n_findex, + fmodel.n_turbines, + ) +) +maximum_yaw_angle = np.zeros( + ( + fmodel.n_findex, + fmodel.n_turbines, + ) +) +maximum_yaw_angle[:, :10] = 30.0 + + +yaw_opt = YawOptimizationSR( + fmodel=fmodel, + minimum_yaw_angle=minimum_yaw_angle, # Allowable yaw angles lower bound + maximum_yaw_angle=maximum_yaw_angle, # Allowable yaw angles upper bound + Ny_passes=[5, 4], + exclude_downstream_turbines=True, + turbine_weights=turbine_weights, +) +df_opt_with_neighbor = yaw_opt.optimize() + +# CASE 2: Repeat the optimization, this time ignoring the wakes of the neighboring farm +# by limiting the FLORIS model to only the turbines in the farm to be optimized +f_model_subset = fmodel.copy() +f_model_subset.set( + layout_x=X[:10], + layout_y=Y[:10], +) +yaw_opt = YawOptimizationSR( + fmodel=f_model_subset, + minimum_yaw_angle=0, # Allowable yaw angles lower bound + maximum_yaw_angle=30, # Allowable yaw angles upper bound + Ny_passes=[5, 4], + exclude_downstream_turbines=True, +) +df_opt_without_neighbor = yaw_opt.optimize() + + +# Calculate the AEP in the baseline case +# Use turbine weights again to only consider the first 10 turbines power +fmodel.set(wind_data=wind_rose) +fmodel.run() +farm_power_baseline = fmodel.get_farm_power(turbine_weights=turbine_weights) +aep_baseline = fmodel.get_farm_AEP(turbine_weights=turbine_weights) + + +# Now need to apply the optimal yaw angles to the wind rose to get the optimized AEP +# do this by applying a rule of thumb where the optimal yaw is applied between 6 and 12 m/s +# and ramped down to 0 above and below this range + +# Grab wind speeds and wind directions from the fmodel. Note that we do this because the +# yaw angles will need to be n_findex long, and accounting for the fact that some wind +# directions and wind speeds may not be present in the wind rose (0 frequency) and aren't +# included in the fmodel +wind_directions = fmodel.wind_directions +wind_speeds = fmodel.wind_speeds +n_findex = fmodel.n_findex + +yaw_angles_wind_rose_with_neighbor = np.zeros((n_findex, fmodel.n_turbines)) +yaw_angles_wind_rose_without_neighbor = np.zeros((n_findex, fmodel.n_turbines)) +for i in range(n_findex): + wind_speed = wind_speeds[i] + wind_direction = wind_directions[i] + + # Interpolate the optimal yaw angles for this wind direction from df_opt + id_opt_with_neighbor = df_opt_with_neighbor["wind_direction"] == wind_direction + id_opt_without_neighbor = df_opt_without_neighbor["wind_direction"] == wind_direction + + # Get the yaw angles for this wind direction + yaw_opt_full_with_neighbor = np.array( + df_opt_with_neighbor.loc[id_opt_with_neighbor, "yaw_angles_opt"] + )[0] + yaw_opt_full_without_neighbor = np.array( + df_opt_without_neighbor.loc[id_opt_without_neighbor, "yaw_angles_opt"] + )[0] + + # Extend the yaw angles from 10 turbine to n_turbine by filling with 0s + # in the case of the removed neighboring farms + yaw_opt_full_without_neighbor = np.concatenate( + (yaw_opt_full_without_neighbor, np.zeros(fmodel.n_turbines - 10)) + ) + + # Now decide what to do for different wind speeds + if (wind_speed < 4.0) | (wind_speed > 14.0): + yaw_opt_with_neighbor = np.zeros(fmodel.n_turbines) # do nothing for very low/high speeds + yaw_opt_without_neighbor = np.zeros( + fmodel.n_turbines + ) # do nothing for very low/high speeds + elif wind_speed < 6.0: + yaw_opt_with_neighbor = ( + yaw_opt_full_with_neighbor * (6.0 - wind_speed) / 2.0 + ) # Linear ramp up + yaw_opt_without_neighbor = ( + yaw_opt_full_without_neighbor * (6.0 - wind_speed) / 2.0 + ) # Linear ramp up + elif wind_speed > 12.0: + yaw_opt_with_neighbor = ( + yaw_opt_full_with_neighbor * (14.0 - wind_speed) / 2.0 + ) # Linear ramp down + yaw_opt_without_neighbor = ( + yaw_opt_full_without_neighbor * (14.0 - wind_speed) / 2.0 + ) # Linear ramp down + else: + yaw_opt_with_neighbor = ( + yaw_opt_full_with_neighbor # Apply full offsets between 6.0 and 12.0 m/s + ) + yaw_opt_without_neighbor = ( + yaw_opt_full_without_neighbor # Apply full offsets between 6.0 and 12.0 m/s + ) + + # Save to collective array + yaw_angles_wind_rose_with_neighbor[i, :] = yaw_opt_with_neighbor + yaw_angles_wind_rose_without_neighbor[i, :] = yaw_opt_without_neighbor + + +# Now apply the optimal yaw angles and get the AEP, first accounting for the neighboring farm +fmodel.set(yaw_angles=yaw_angles_wind_rose_with_neighbor) +fmodel.run() +aep_opt_with_neighbor = fmodel.get_farm_AEP(turbine_weights=turbine_weights) +aep_uplift_with_neighbor = 100.0 * (aep_opt_with_neighbor / aep_baseline - 1) +farm_power_opt_with_neighbor = fmodel.get_farm_power(turbine_weights=turbine_weights) + +# Repeat without accounting for neighboring farm +fmodel.set(yaw_angles=yaw_angles_wind_rose_without_neighbor) +fmodel.run() +aep_opt_without_neighbor = fmodel.get_farm_AEP(turbine_weights=turbine_weights) +aep_uplift_without_neighbor = 100.0 * (aep_opt_without_neighbor / aep_baseline - 1) +farm_power_opt_without_neighbor = fmodel.get_farm_power(turbine_weights=turbine_weights) + +print("Baseline AEP: {:.2f} GWh.".format(aep_baseline / 1e9)) +print( + "Optimal AEP (Not accounting for neighboring farm): {:.2f} GWh.".format( + aep_opt_without_neighbor / 1e9 + ) +) +print( + "Optimal AEP (Accounting for neighboring farm): {:.2f} GWh.".format(aep_opt_with_neighbor / 1e9) +) + +# Plot the optimal yaw angles for turbine 0 with and without accounting for the neighboring farm +yaw_angles_0_with_neighbor = np.vstack(df_opt_with_neighbor["yaw_angles_opt"])[:, 0] +yaw_angles_0_without_neighbor = np.vstack(df_opt_without_neighbor["yaw_angles_opt"])[:, 0] + +fig, ax = plt.subplots() +ax.plot( + df_opt_with_neighbor["wind_direction"], + yaw_angles_0_with_neighbor, + label="Accounting for neighboring farm", +) +ax.plot( + df_opt_without_neighbor["wind_direction"], + yaw_angles_0_without_neighbor, + label="Not accounting for neighboring farm", +) +ax.set_xlabel("Wind direction (deg)") +ax.set_ylabel("Yaw angle (deg)") +ax.legend() +ax.grid(True) +ax.set_title("Optimal yaw angles for turbine 0") + +plt.show() diff --git a/examples/examples_control_types/001_derating_control.py b/examples/examples_control_types/001_derating_control.py new file mode 100644 index 000000000..41bf3ea2a --- /dev/null +++ b/examples/examples_control_types/001_derating_control.py @@ -0,0 +1,95 @@ +"""Example of using the simple-derating control model in FLORIS. + +This example demonstrates how to use the simple-derating control model in FLORIS. +The simple-derating control model allows the user to specify a power setpoint for each turbine +in the farm. The power setpoint is used to derate the turbine power output to be at most the +power setpoint. + +In this example: + +1. A simple two-turbine layout is created. +2. The wind conditions are set to be constant. +3. The power setpoint is varied, and set the same for each turbine +4. The power produced by each turbine is computed and plotted +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel + + +fmodel = FlorisModel("../inputs/gch.yaml") + +# Change to the simple-derating model turbine +# (Note this could also be done with the mixed model) +fmodel.set_operation_model("simple-derating") + +# Convert to a simple two turbine layout with derating turbines +fmodel.set(layout_x=[0, 1000.0], layout_y=[0.0, 0.0]) + +# For reference, load the turbine type +turbine_type = fmodel.core.farm.turbine_definitions[0] + +# Set the wind directions and speeds to be constant over n_findex = N time steps +N = 50 +fmodel.set( + wind_directions=270 * np.ones(N), + wind_speeds=10.0 * np.ones(N), + turbulence_intensities=0.06 * np.ones(N), +) +fmodel.run() +turbine_powers_orig = fmodel.get_turbine_powers() + +# Add derating level to both turbines +power_setpoints = np.tile(np.linspace(1, 6e6, N), 2).reshape(2, N).T +fmodel.set(power_setpoints=power_setpoints) +fmodel.run() +turbine_powers_derated = fmodel.get_turbine_powers() + +# Compute available power at downstream turbine +power_setpoints_2 = np.array([np.linspace(1, 6e6, N), np.full(N, None)]).T +fmodel.set(power_setpoints=power_setpoints_2) +fmodel.run() +turbine_powers_avail_ds = fmodel.get_turbine_powers()[:, 1] + +# Plot the results +fig, ax = plt.subplots(1, 1) +ax.plot( + power_setpoints[:, 0] / 1000, turbine_powers_derated[:, 0] / 1000, color="C0", label="Upstream" +) +ax.plot( + power_setpoints[:, 1] / 1000, + turbine_powers_derated[:, 1] / 1000, + color="C1", + label="Downstream", +) +ax.plot( + power_setpoints[:, 0] / 1000, + turbine_powers_orig[:, 0] / 1000, + color="C0", + linestyle="dotted", + label="Upstream available", +) +ax.plot( + power_setpoints[:, 1] / 1000, + turbine_powers_avail_ds / 1000, + color="C1", + linestyle="dotted", + label="Downstream available", +) +ax.plot( + power_setpoints[:, 1] / 1000, + np.ones(N) * np.max(turbine_type["power_thrust_table"]["power"]), + color="k", + linestyle="dashed", + label="Rated power", +) +ax.grid() +ax.legend() +ax.set_xlim([0, 6e3]) +ax.set_xlabel("Power setpoint (kW) [Applied to both turbines]") +ax.set_ylabel("Power produced (kW)") + + +plt.show() diff --git a/examples/examples_control_types/002_disable_turbines.py b/examples/examples_control_types/002_disable_turbines.py new file mode 100644 index 000000000..e8cd4b94c --- /dev/null +++ b/examples/examples_control_types/002_disable_turbines.py @@ -0,0 +1,79 @@ +"""Example 001: Disable turbines + +This example is adapted from https://github.com/NREL/floris/pull/693 +contributed by Elie Kadoche. + +This example demonstrates the ability of FLORIS to shut down some turbines +during a simulation. +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel + + +# Initialize FLORIS +fmodel = FlorisModel("../inputs/gch.yaml") + +# Change to the mixed model turbine +# (Note this could also be done with the simple-derating model) +fmodel.set_operation_model("mixed") + +# Consider a wind farm of 3 aligned wind turbines +layout = np.array([[0.0, 0.0], [500.0, 0.0], [1000.0, 0.0]]) + +# Run the computations for 2 identical wind data +# (n_findex = 2) +wind_directions = np.array([270.0, 270.0]) +wind_speeds = np.array([8.0, 8.0]) +turbulence_intensities = np.array([0.06, 0.06]) + +# Shut down the first 2 turbines for the second findex +# 2 findex x 3 turbines +disable_turbines = np.array([[False, False, False], [True, True, False]]) + +# Simulation +# ------------------------------------------ + +# Reinitialize flow field +fmodel.set( + layout_x=layout[:, 0], + layout_y=layout[:, 1], + wind_directions=wind_directions, + wind_speeds=wind_speeds, + turbulence_intensities=turbulence_intensities, + disable_turbines=disable_turbines, +) + +# # Compute wakes +fmodel.run() + +# Results +# ------------------------------------------ + +# Get powers and effective wind speeds +turbine_powers = fmodel.get_turbine_powers() +turbine_powers = np.round(turbine_powers * 1e-3, decimals=2) +effective_wind_speeds = fmodel.turbine_average_velocities + + +# Plot the results +fig, axarr = plt.subplots(2, 1, sharex=True) + +# Plot the power +ax = axarr[0] +ax.plot(["T0", "T1", "T2"], turbine_powers[0, :], "ks-", label="All on") +ax.plot(["T0", "T1", "T2"], turbine_powers[1, :], "ro-", label="T0 & T1 disabled") +ax.set_ylabel("Power (kW)") +ax.grid(True) +ax.legend() + +ax = axarr[1] +ax.plot(["T0", "T1", "T2"], effective_wind_speeds[0, :], "ks-", label="All on") +ax.plot(["T0", "T1", "T2"], effective_wind_speeds[1, :], "ro-", label="T0 & T1 disabled") +ax.set_ylabel("Effective wind speeds (m/s)") +ax.grid(True) +ax.legend() + +plt.show() diff --git a/examples/examples_control_types/003_setting_yaw_and_disabling.py b/examples/examples_control_types/003_setting_yaw_and_disabling.py new file mode 100644 index 000000000..fb526009f --- /dev/null +++ b/examples/examples_control_types/003_setting_yaw_and_disabling.py @@ -0,0 +1,83 @@ +"""Example: Setting yaw angles and disabling turbine + +This example demonstrates how to set yaw angles and disable turbines in FLORIS. +The yaw angles are set to sweep from -20 to 20 degrees for the upstream-most turbine +and to 0 degrees for the downstream-most turbine(s). A two-turbine case is compared +to a three-turbine case where the middle turbine is disabled making the two cases +functionally equivalent. +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel, TimeSeries + + +# Initialize 2 FLORIS models, a two-turbine layout +# and three-turbine layout +fmodel_2 = FlorisModel("../inputs/gch.yaml") +fmodel_3 = FlorisModel("../inputs/gch.yaml") + +# Change to the mixed model turbine +# This example sets both yaw angle and power setpoints +fmodel_2.set_operation_model("mixed") +fmodel_3.set_operation_model("mixed") + +# Set the layouts, f_model_3 has an extra turbine in-between the two +# turbines of f_model_2 +fmodel_2.set(layout_x=[0, 1000.0], layout_y=[0.0, 0.0]) +fmodel_3.set(layout_x=[0, 500.0, 1000.0], layout_y=[0.0, 0.0, 0.0]) + +# Set bo + +# Set both to have constant wind conditions +N = 50 +time_series = TimeSeries( + wind_directions=270.0 * np.ones(N), + wind_speeds = 8., + turbulence_intensities=0.06 + ) +fmodel_2.set(wind_data=time_series) +fmodel_3.set(wind_data=time_series) + +# In both cases, set the yaw angles of the upstream-most turbine +# to sweep from -20 to 20 degrees, while other turbines are set to 0 +upstream_yaw_angles = np.linspace(-20, 20, N) +yaw_angles_2 = np.array([upstream_yaw_angles, np.zeros(N)]).T +yaw_angles_3 = np.array([upstream_yaw_angles, np.zeros(N), np.zeros(N)]).T + +# In the three turbine case, also disable the middle turbine +# Declare a np array of booleans that is Nx3 and whose middle column is True +disable_turbines = np.array([np.zeros(N), np.ones(N), np.zeros(N)]).T.astype(bool) + +# Set the yaw angles for both and disable the middle turbine for the +# three turbine case +fmodel_2.set(yaw_angles=yaw_angles_2) +fmodel_3.set(yaw_angles=yaw_angles_3, disable_turbines=disable_turbines) + +# Run both models +fmodel_2.run() +fmodel_3.run() + +# Collect the turbine powers from both +turbine_powers_2 = fmodel_2.get_turbine_powers() +turbine_powers_3 = fmodel_3.get_turbine_powers() + +# Make a 2-panel plot of the turbine powers. For the three-turbine case, +# only plot the first and last turbine +fig, axarr = plt.subplots(2, 1, sharex=True) +axarr[0].plot(upstream_yaw_angles, turbine_powers_2[:, 0] / 1000, label="Two-Turbine", marker='s') +axarr[0].plot(upstream_yaw_angles, turbine_powers_3[:, 0] / 1000, label="Three-Turbine", marker='.') +axarr[0].set_ylabel("Power (kW)") +axarr[0].legend() +axarr[0].grid(True) +axarr[0].set_title("Upstream Turbine") + +axarr[1].plot(upstream_yaw_angles, turbine_powers_2[:, 1] / 1000, label="Two-Turbine", marker='s') +axarr[1].plot(upstream_yaw_angles, turbine_powers_3[:, 2] / 1000, label="Three-Turbine", marker='.') +axarr[1].set_ylabel("Power (kW)") +axarr[1].legend() +axarr[1].grid(True) +axarr[1].set_title("Downstream-most Turbine") + +plt.show() diff --git a/examples/examples_control_types/004_helix_active_wake_mixing.py b/examples/examples_control_types/004_helix_active_wake_mixing.py new file mode 100644 index 000000000..7738c079c --- /dev/null +++ b/examples/examples_control_types/004_helix_active_wake_mixing.py @@ -0,0 +1,139 @@ +"""Example: Helix active wake mixing + +Example to test out using helix wake mixing of upstream turbines. +Helix wake mixing is turned on at turbine 1, off at turbines 2 to 4; +Turbine 2 is in wake turbine 1, turbine 4 in wake of turbine 3. +""" + +import matplotlib.pyplot as plt +import numpy as np +import yaml + +import floris.flow_visualization as flowviz +from floris import FlorisModel + + +# Grab model of FLORIS and update to awc-enabled turbines +fmodel = FlorisModel("../inputs/emgauss_helix.yaml") +fmodel.set_operation_model("awc") + +# Set the wind directions and speeds to be constant over N different helix amplitudes +N = 1 +awc_modes = np.array(["helix", "baseline", "baseline", "baseline"]).reshape(4, N).T +awc_amplitudes = np.array([2.5, 0, 0, 0]).reshape(4, N).T + +# Create 4 WT WF layout with lateral offset of 3D and streamwise offset of 4D +D = 240 +fmodel.set( + layout_x=[0.0, 4*D, 0.0, 4*D], + layout_y=[0.0, 0.0, -3*D, -3*D], + wind_directions=270 * np.ones(N), + wind_speeds=8.0 * np.ones(N), + turbulence_intensities=0.06*np.ones(N), + awc_modes=awc_modes, + awc_amplitudes=awc_amplitudes +) +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() + +# Plot the flow fields for T1 awc_amplitude = 2.5 +horizontal_plane = fmodel.calculate_horizontal_plane( + x_resolution=200, + y_resolution=100, + height=150.0, +) + +y_plane_baseline = fmodel.calculate_y_plane( + x_resolution=200, + z_resolution=100, + crossstream_dist=0.0, +) +y_plane_helix = fmodel.calculate_y_plane( + x_resolution=200, + z_resolution=100, + crossstream_dist=-3*D, +) + +cross_plane = fmodel.calculate_cross_plane( + y_resolution=100, + z_resolution=100, + downstream_dist=720.0, +) + +# Create the plots +fig, ax_list = plt.subplots(2, 2, figsize=(10, 8), tight_layout=True) +ax_list = ax_list.flatten() +flowviz.visualize_cut_plane( + horizontal_plane, + ax=ax_list[0], + label_contours=True, + title="Horizontal" +) +flowviz.visualize_cut_plane( + cross_plane, + ax=ax_list[2], + label_contours=True, + title="Spanwise profile at 3D" +) + +# fig2, ax_list2 = plt.subplots(2, 1, figsize=(10, 8), tight_layout=True) +# ax_list2 = ax_list2.flatten() +flowviz.visualize_cut_plane( + y_plane_baseline, + ax=ax_list[1], + label_contours=True, + title="Streamwise profile, helix" +) +flowviz.visualize_cut_plane( + y_plane_helix, + ax=ax_list[3], + label_contours=True, + title="Streamwise profile, baseline" +) + +# Calculate the effect of changing awc_amplitudes +N = 50 +awc_amplitudes = np.array([ + np.linspace(0, 5, N), + np.zeros(N), np.zeros(N), np.zeros(N) + ]).reshape(4, N).T + +# Reset FlorisModel for different helix amplitudes +fmodel.set( + wind_directions=270 * np.ones(N), + wind_speeds=8 * np.ones(N), + turbulence_intensities=0.06*np.ones(N), + awc_modes=awc_modes, + awc_amplitudes=awc_amplitudes + ) +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() + +# Plot the power as a function of helix amplitude +fig_power, ax_power = plt.subplots() +ax_power.fill_between( + awc_amplitudes[:, 0], + 0, + turbine_powers[:, 0]/1000, + color='C0', + label='Turbine 1' + ) +ax_power.fill_between( + awc_amplitudes[:, 0], + turbine_powers[:, 0]/1000, + turbine_powers[:, :2].sum(axis=1)/1000, + color='C1', + label='Turbine 2' + ) +ax_power.plot( + awc_amplitudes[:, 0], + turbine_powers[:,:2].sum(axis=1)/1000, + color='k', + label='Farm' + ) + +ax_power.set_xlabel("Upstream turbine helix amplitude [deg]") +ax_power.set_ylabel("Power [kW]") +ax_power.legend() + +flowviz.show() diff --git a/examples/examples_emgauss/001_empirical_gauss_velocity_deficit_parameters.py b/examples/examples_emgauss/001_empirical_gauss_velocity_deficit_parameters.py new file mode 100644 index 000000000..0baf2fac1 --- /dev/null +++ b/examples/examples_emgauss/001_empirical_gauss_velocity_deficit_parameters.py @@ -0,0 +1,199 @@ +"""Example: Empirical Gaussian velocity deficit parameters +This example illustrates the main parameters of the Empirical Gaussian +velocity deficit model and their effects on the wind turbine wake. +""" + +import copy + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane + + +# Options +show_flow_cuts = True +num_in_row = 5 + +# Define function for visualizing wakes +def generate_wake_visualization(fmodel: FlorisModel, title=None): + # Using the FlorisModel functions, get 2D slices. + x_bounds = [-500, 3000] + y_bounds = [-250, 250] + z_bounds = [0.001, 500] + cross_plane_locations = [10, 1200, 2500] + horizontal_plane_location = 90.0 + streamwise_plane_location = 0.0 + # Contour plot colors + min_ws = 4 + max_ws = 10 + + horizontal_plane = fmodel.calculate_horizontal_plane( + x_resolution=200, + y_resolution=100, + height=horizontal_plane_location, + x_bounds=x_bounds, + y_bounds=y_bounds, + ) + y_plane = fmodel.calculate_y_plane( + x_resolution=200, + z_resolution=100, + crossstream_dist=streamwise_plane_location, + x_bounds=x_bounds, + z_bounds=z_bounds, + ) + cross_planes = [] + for cpl in cross_plane_locations: + cross_planes.append( + fmodel.calculate_cross_plane(y_resolution=100, z_resolution=100, downstream_dist=cpl) + ) + + # Create the plots + # Cutplane settings + cp_ls = "solid" # line style + cp_lw = 0.5 # line width + cp_clr = "black" # line color + fig = plt.figure() + fig.set_size_inches(12, 12) + # Horizontal profile + ax = fig.add_subplot(311) + visualize_cut_plane( + horizontal_plane, ax=ax, title="Top-down profile", min_speed=min_ws, max_speed=max_ws + ) + ax.plot( + x_bounds, [streamwise_plane_location] * 2, color=cp_clr, linewidth=cp_lw, linestyle=cp_ls + ) + for cpl in cross_plane_locations: + ax.plot([cpl] * 2, y_bounds, color=cp_clr, linewidth=cp_lw, linestyle=cp_ls) + + ax = fig.add_subplot(312) + visualize_cut_plane( + y_plane, ax=ax, title="Streamwise profile", min_speed=min_ws, max_speed=max_ws + ) + ax.plot( + x_bounds, [horizontal_plane_location] * 2, color=cp_clr, linewidth=cp_lw, linestyle=cp_ls + ) + for cpl in cross_plane_locations: + ax.plot([cpl, cpl], z_bounds, color=cp_clr, linewidth=cp_lw, linestyle=cp_ls) + + # Spanwise profiles + for i, (cp, cpl) in enumerate(zip(cross_planes, cross_plane_locations)): + visualize_cut_plane( + cp, + ax=fig.add_subplot(3, len(cross_planes), i + 7), + title="Loc: {:.0f}m".format(cpl), + min_speed=min_ws, + max_speed=max_ws, + ) + + # Add overall figure title + if title is not None: + fig.suptitle(title, fontsize=16) + + +## Main script + +# Load input yaml and define farm layout +fmodel = FlorisModel("../inputs/emgauss.yaml") +D = fmodel.core.farm.rotor_diameters[0] +fmodel.set( + layout_x=[x * 5.0 * D for x in range(num_in_row)], + layout_y=[0.0] * num_in_row, + wind_speeds=[8.0], + wind_directions=[270.0], +) + +# Save dictionary to modify later +fmodel_dict = fmodel.core.as_dict() + +# Run wake calculation +fmodel.run() + +# Look at the powers of each turbine +turbine_powers = fmodel.get_turbine_powers().flatten() / 1e6 + +fig0, ax0 = plt.subplots(1, 1) +width = 0.1 +nw = -2 +x = np.array(range(num_in_row)) + width * nw +nw += 1 + +title = "Original" +ax0.bar(x, turbine_powers, width=width, label=title) +ax0.legend() + +# Visualize wakes +if show_flow_cuts: + generate_wake_visualization(fmodel, title) + +# Increase the base recovery rate +fmodel_dict_mod = copy.deepcopy(fmodel_dict) +fmodel_dict_mod["wake"]["wake_velocity_parameters"]["empirical_gauss"]["wake_expansion_rates"] = [ + 0.03, + 0.015, +] +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set(wind_speeds=[8.0], wind_directions=[270.0]) + +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten() / 1e6 + +x = np.array(range(num_in_row)) + width * nw +nw += 1 + +title = "Increase base recovery" +ax0.bar(x, turbine_powers, width=width, label=title) + +if show_flow_cuts: + generate_wake_visualization(fmodel, title) + +# Add new expansion rate +fmodel_dict_mod = copy.deepcopy(fmodel_dict) +fmodel_dict_mod["wake"]["wake_velocity_parameters"]["empirical_gauss"]["wake_expansion_rates"] = ( + fmodel_dict["wake"]["wake_velocity_parameters"]["empirical_gauss"]["wake_expansion_rates"] + + [0.0] +) +fmodel_dict_mod["wake"]["wake_velocity_parameters"]["empirical_gauss"]["breakpoints_D"] = [5, 10] + +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set(wind_speeds=[8.0], wind_directions=[270.0]) + +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten() / 1e6 + +x = np.array(range(num_in_row)) + width * nw +nw += 1 + +title = "Add rate, change breakpoints" +ax0.bar(x, turbine_powers, width=width, label=title) + +if show_flow_cuts: + generate_wake_visualization(fmodel, title) + +# Increase the wake-induced mixing gain +fmodel_dict_mod = copy.deepcopy(fmodel_dict) +fmodel_dict_mod["wake"]["wake_velocity_parameters"]["empirical_gauss"]["mixing_gain_velocity"] = 3.0 +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set(wind_speeds=[8.0], wind_directions=[270.0]) + +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten() / 1e6 + +x = np.array(range(num_in_row)) + width * nw +nw += 1 + +title = "Increase mixing gain" +ax0.bar(x, turbine_powers, width=width, label=title) + +if show_flow_cuts: + generate_wake_visualization(fmodel, title) + +# Power plot aesthetics +ax0.set_xticks(range(num_in_row)) +ax0.set_xticklabels(["T{0}".format(t) for t in range(num_in_row)]) +ax0.legend() +ax0.set_xlabel("Turbine") +ax0.set_ylabel("Power [MW]") + +plt.show() diff --git a/examples/27_empirical_gauss_deflection_parameters.py b/examples/examples_emgauss/002_empirical_gauss_deflection_parameters.py similarity index 61% rename from examples/27_empirical_gauss_deflection_parameters.py rename to examples/examples_emgauss/002_empirical_gauss_deflection_parameters.py index 2137999a4..5d74fa9ee 100644 --- a/examples/27_empirical_gauss_deflection_parameters.py +++ b/examples/examples_emgauss/002_empirical_gauss_deflection_parameters.py @@ -1,16 +1,8 @@ -# Copyright 2021 NREL +"""Example: Empirical Gaussian deflection parameters -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://nrel.github.io/floris for documentation +This example illustrates the main parameters of the Empirical Gaussian +deflection model and their effects on the wind turbine wake. +""" import copy @@ -18,17 +10,12 @@ import matplotlib.pyplot as plt import numpy as np -from floris.tools import FlorisInterface -from floris.tools.visualization import plot_rotor_values, visualize_cut_plane +from floris import FlorisModel +from floris.flow_visualization import plot_rotor_values, visualize_cut_plane -""" -This example illustrates the main parameters of the Empirical Gaussian -deflection model and their effects on the wind turbine wake. -""" - -# Initialize FLORIS with the given input file via FlorisInterface. -# For basic usage, FlorisInterface provides a simplified and expressive +# Initialize FLORIS with the given input file. +# For basic usage, FlorisModel provides a simplified and expressive # entry point to the simulation routines. # Options @@ -36,14 +23,13 @@ num_in_row = 5 # Should be at least 3 first_three_yaw_angles = [20., 20., 10.] -yaw_angles = np.array(first_three_yaw_angles + [0.]*(num_in_row-3))\ - [None, None, :] +yaw_angles = np.array(first_three_yaw_angles + [0.0]*(num_in_row-3))[None, :] -print("Turbine yaw angles (degrees): ", yaw_angles[0,0,:]) +print("Turbine yaw angles (degrees): ", yaw_angles[0]) # Define function for visualizing wakes -def generate_wake_visualization(fi, title=None): - # Using the FlorisInterface functions, get 2D slices. +def generate_wake_visualization(fmodel, title=None): + # Using the FlorisModel functions, get 2D slices. x_bounds = [-500, 3000] y_bounds = [-250, 250] z_bounds = [0.001, 500] @@ -54,26 +40,24 @@ def generate_wake_visualization(fi, title=None): min_ws = 4 max_ws = 10 - horizontal_plane = fi.calculate_horizontal_plane( + horizontal_plane = fmodel.calculate_horizontal_plane( x_resolution=200, y_resolution=100, height=horizontal_plane_location, x_bounds=x_bounds, y_bounds=y_bounds, - yaw_angles=yaw_angles ) - y_plane = fi.calculate_y_plane( + y_plane = fmodel.calculate_y_plane( x_resolution=200, z_resolution=100, crossstream_dist=streamwise_plane_location, x_bounds=x_bounds, z_bounds=z_bounds, - yaw_angles=yaw_angles ) cross_planes = [] for cpl in cross_plane_locations: cross_planes.append( - fi.calculate_cross_plane( + fmodel.calculate_cross_plane( y_resolution=100, z_resolution=100, downstream_dist=cpl @@ -120,23 +104,24 @@ def generate_wake_visualization(fi, title=None): ## Main script # Load input yaml and define farm layout -fi = FlorisInterface("inputs/emgauss.yaml") -D = fi.floris.farm.rotor_diameters[0] -fi.reinitialize( +fmodel = FlorisModel("../inputs/emgauss.yaml") +D = fmodel.core.farm.rotor_diameters[0] +fmodel.set( layout_x=[x*5.0*D for x in range(num_in_row)], layout_y=[0.0]*num_in_row, wind_speeds=[8.0], - wind_directions=[270.0] + wind_directions=[270.0], + yaw_angles=yaw_angles, ) # Save dictionary to modify later -fi_dict = fi.floris.as_dict() +fmodel_dict = fmodel.core.as_dict() # Run wake calculation -fi.calculate_wake(yaw_angles=yaw_angles) +fmodel.run() # Look at the powers of each turbine -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 fig0, ax0 = plt.subplots(1,1) width = 0.1 @@ -150,22 +135,23 @@ def generate_wake_visualization(fi, title=None): # Visualize wakes if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Increase the maximum deflection attained -fi_dict_mod = copy.deepcopy(fi_dict) +fmodel_dict_mod = copy.deepcopy(fmodel_dict) -fi_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ +fmodel_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ ['horizontal_deflection_gain_D'] = 5.0 -fi = FlorisInterface(fi_dict_mod) -fi.reinitialize( +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set( wind_speeds=[8.0], - wind_directions=[270.0] + wind_directions=[270.0], + yaw_angles=yaw_angles, ) -fi.calculate_wake(yaw_angles=yaw_angles) -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 x = np.array(range(num_in_row))+width*nw nw += 1 @@ -174,21 +160,22 @@ def generate_wake_visualization(fi, title=None): ax0.bar(x, turbine_powers, width=width, label=title) if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Add (increase) influence of wake added mixing -fi_dict_mod = copy.deepcopy(fi_dict) -fi_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ +fmodel_dict_mod = copy.deepcopy(fmodel_dict) +fmodel_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ ['mixing_gain_deflection'] = 100.0 -fi = FlorisInterface(fi_dict_mod) -fi.reinitialize( +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set( wind_speeds=[8.0], - wind_directions=[270.0] + wind_directions=[270.0], + yaw_angles=yaw_angles, ) -fi.calculate_wake(yaw_angles=yaw_angles) -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 x = np.array(range(num_in_row))+width*nw nw += 1 @@ -197,24 +184,25 @@ def generate_wake_visualization(fi, title=None): ax0.bar(x, turbine_powers, width=width, label=title) if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Add (increase) the yaw-added mixing contribution -fi_dict_mod = copy.deepcopy(fi_dict) +fmodel_dict_mod = copy.deepcopy(fmodel_dict) # Include a WIM gain so that YAM is reflected in deflection as well # as deficit -fi_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ +fmodel_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ ['mixing_gain_deflection'] = 100.0 -fi_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ +fmodel_dict_mod['wake']['wake_deflection_parameters']['empirical_gauss']\ ['yaw_added_mixing_gain'] = 1.0 -fi = FlorisInterface(fi_dict_mod) -fi.reinitialize( +fmodel = FlorisModel(fmodel_dict_mod) +fmodel.set( wind_speeds=[8.0], - wind_directions=[270.0] + wind_directions=[270.0], + yaw_angles=yaw_angles, ) -fi.calculate_wake(yaw_angles=yaw_angles) -turbine_powers = fi.get_turbine_powers().flatten()/1e6 +fmodel.run() +turbine_powers = fmodel.get_turbine_powers().flatten()/1e6 x = np.array(range(num_in_row))+width*nw nw += 1 @@ -223,7 +211,7 @@ def generate_wake_visualization(fi, title=None): ax0.bar(x, turbine_powers, width=width, label=title) if show_flow_cuts: - generate_wake_visualization(fi, title) + generate_wake_visualization(fmodel, title) # Power plot aesthetics ax0.set_xticks(range(num_in_row)) diff --git a/examples/examples_floating/001_floating_turbine_models.py b/examples/examples_floating/001_floating_turbine_models.py new file mode 100644 index 000000000..75936b09a --- /dev/null +++ b/examples/examples_floating/001_floating_turbine_models.py @@ -0,0 +1,144 @@ +"""Example: Floating turbines +This example demonstrates the impact of floating on turbine power and thrust (not wake behavior). +A floating turbine in FLORIS is defined by including a `floating_tilt_table` in the turbine +input yaml which sets the steady tilt angle of the turbine based on wind speed. This tilt angle +is computed for each turbine based on effective velocity. This tilt angle is then passed on +to the respective wake model. + +The value of the parameter ref_tilt is the value of tilt at which the ct/cp curves +have been defined. + +If `correct_cp_ct_for_tilt` is True, then the difference between the current tilt as +interpolated from the floating tilt table is used to scale the turbine power and thrust. + +If `correct_cp_ct_for_tilt` is False, then it is assumed that the Cp/Ct tables provided +already account for the variation in tilt with wind speed (for example they were computed from +a turbine simulator with tilt degree-of-freedom enabled and the floating platform simulated), +and no correction is made. + +In the example below, three single-turbine simulations are run to show the different behaviors. + +fmodel_fixed: Fixed bottom turbine (no tilt variation with wind speed) +fmodel_floating: Floating turbine (tilt varies with wind speed) +fmodel_floating_defined_floating: Floating turbine (tilt varies with wind speed, but + tilt does not scale cp/ct) +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel, TimeSeries + + +# Create the Floris instances +fmodel_fixed = FlorisModel("../inputs_floating/gch_fixed.yaml") +fmodel_floating = FlorisModel("../inputs_floating/gch_floating.yaml") +fmodel_floating_defined_floating = FlorisModel( + "../inputs_floating/gch_floating_defined_floating.yaml" +) + +# Calculate across wind speeds, while holding win directions constant +ws_array = np.arange(3.0, 25.0, 1.0) +time_series = TimeSeries(wind_directions=270.0, wind_speeds=ws_array, turbulence_intensities=0.06) +fmodel_fixed.set(wind_data=time_series) +fmodel_floating.set(wind_data=time_series) +fmodel_floating_defined_floating.set(wind_data=time_series) + +fmodel_fixed.run() +fmodel_floating.run() +fmodel_floating_defined_floating.run() + +# Grab power +power_fixed = fmodel_fixed.get_turbine_powers().flatten() / 1000.0 +power_floating = fmodel_floating.get_turbine_powers().flatten() / 1000.0 +power_floating_defined_floating = ( + fmodel_floating_defined_floating.get_turbine_powers().flatten() / 1000.0 +) + +# Grab Ct +ct_fixed = fmodel_fixed.get_turbine_thrust_coefficients().flatten() +ct_floating = fmodel_floating.get_turbine_thrust_coefficients().flatten() +ct_floating_defined_floating = ( + fmodel_floating_defined_floating.get_turbine_thrust_coefficients().flatten() +) + +# Grab turbine tilt angles +eff_vels = fmodel_fixed.turbine_average_velocities +tilt_angles_fixed = np.squeeze(fmodel_fixed.core.farm.calculate_tilt_for_eff_velocities(eff_vels)) + +eff_vels = fmodel_floating.turbine_average_velocities +tilt_angles_floating = np.squeeze( + fmodel_floating.core.farm.calculate_tilt_for_eff_velocities(eff_vels) +) + +eff_vels = fmodel_floating_defined_floating.turbine_average_velocities +tilt_angles_floating_defined_floating = np.squeeze( + fmodel_floating_defined_floating.core.farm.calculate_tilt_for_eff_velocities(eff_vels) +) + +# Plot results + +fig, axarr = plt.subplots(4, 1, figsize=(8, 10), sharex=True) + +ax = axarr[0] +ax.plot(ws_array, tilt_angles_fixed, color="k", lw=2, label="Fixed Bottom") +ax.plot(ws_array, tilt_angles_floating, color="b", label="Floating") +ax.plot( + ws_array, + tilt_angles_floating_defined_floating, + color="m", + ls="--", + label="Floating (cp/ct not scaled by tilt)", +) +ax.grid(True) +ax.legend() +ax.set_title("Tilt angle (deg)") +ax.set_ylabel("Tlit (deg)") + +ax = axarr[1] +ax.plot(ws_array, power_fixed, color="k", lw=2, label="Fixed Bottom") +ax.plot(ws_array, power_floating, color="b", label="Floating") +ax.plot( + ws_array, + power_floating_defined_floating, + color="m", + ls="--", + label="Floating (cp/ct not scaled by tilt)", +) +ax.grid(True) +ax.legend() +ax.set_title("Power") +ax.set_ylabel("Power (kW)") + +ax = axarr[2] +# ax.plot(ws_array, power_fixed, color='k',label='Fixed Bottom') +ax.plot(ws_array, power_floating - power_fixed, color="b", label="Floating") +ax.plot( + ws_array, + power_floating_defined_floating - power_fixed, + color="m", + ls="--", + label="Floating (cp/ct not scaled by tilt)", +) +ax.grid(True) +ax.legend() +ax.set_title("Difference from fixed bottom power") +ax.set_ylabel("Power (kW)") + +ax = axarr[3] +ax.plot(ws_array, ct_fixed, color="k", lw=2, label="Fixed Bottom") +ax.plot(ws_array, ct_floating, color="b", label="Floating") +ax.plot( + ws_array, + ct_floating_defined_floating, + color="m", + ls="--", + label="Floating (cp/ct not scaled by tilt)", +) +ax.grid(True) +ax.legend() +ax.set_title("Coefficient of thrust") +ax.set_ylabel("Ct (-)") + +plt.show() diff --git a/examples/examples_floating/002_floating_vs_fixedbottom_farm.py b/examples/examples_floating/002_floating_vs_fixedbottom_farm.py new file mode 100644 index 000000000..0400ac7f1 --- /dev/null +++ b/examples/examples_floating/002_floating_vs_fixedbottom_farm.py @@ -0,0 +1,133 @@ +"""Example: Floating vs fixed-bottom farm +This example demonstrates the impact of floating on turbine power and thrust +and wake behavior. A floating turbine in FLORIS is defined by including a +`floating_tilt_table` in the turbine input yaml which sets the steady tilt +angle of the turbine based on wind speed. This tilt angle is computed for each +turbine based on effective velocity. This tilt angle is then passed on +to the respective wake model. + +The value of the parameter ref_tilt is the value of tilt at which the +ct/cp curves have been defined. + +With `correct_cp_ct_for_tilt` True, the difference between the current +tilt as interpolated from the floating tilt table is used to scale the turbine +power and thrust. + +In the example below, a 20-turbine, gridded wind farm is simulated using +the Empirical Gaussian wake model to show the effects of floating turbines on +both turbine power and wake development. + +fmodel_fixed: Fixed bottom turbine (no tilt variation with wind speed) +fmodel_floating: Floating turbine (tilt varies with wind speed) +""" + + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from scipy.interpolate import NearestNDInterpolator + +import floris.flow_visualization as flowviz +from floris import FlorisModel, WindRose + + +# Declare the Floris Interface for fixed bottom, provide layout +fmodel_fixed = FlorisModel("../inputs_floating/emgauss_fixed.yaml") +fmodel_floating = FlorisModel("../inputs_floating/emgauss_floating.yaml") +x, y = np.meshgrid(np.linspace(0, 4*630., 5), np.linspace(0, 3*630., 4)) +x = x.flatten() +y = y.flatten() +for fmodel in [fmodel_fixed, fmodel_floating]: + fmodel.set(layout_x=x, layout_y=y) + +# Compute a single wind speed and direction, power and wakes +for fmodel in [fmodel_fixed, fmodel_floating]: + fmodel.set( + layout_x=x, + layout_y=y, + wind_speeds=[10], + wind_directions=[270], + turbulence_intensities=[0.06], + ) + fmodel.run() + +powers_fixed = fmodel_fixed.get_turbine_powers() +powers_floating = fmodel_floating.get_turbine_powers() +power_difference = powers_floating - powers_fixed + +# Show the power differences +fig, ax = plt.subplots() +ax.set_aspect('equal', adjustable='box') +sc = ax.scatter( + x, + y, + c=power_difference.flatten()/1000, + cmap="PuOr", + vmin=-30, + vmax=30, + s=200, +) +ax.set_xlabel("x coordinate [m]") +ax.set_ylabel("y coordinate [m]") +ax.set_title("Power increase due to floating for each turbine.") +plt.colorbar(sc, label="Increase (kW)") + +print("Power increase from floating over farm (10m/s, 270deg winds): {0:.2f} kW".\ + format(power_difference.sum()/1000)) + +# Visualize flows (see also 02_visualizations.py) +horizontal_planes = [] +y_planes = [] +for fmodel in [fmodel_fixed, fmodel_floating]: + horizontal_planes.append( + fmodel.calculate_horizontal_plane( + x_resolution=200, + y_resolution=100, + height=90.0, + ) + ) + y_planes.append( + fmodel.calculate_y_plane( + x_resolution=200, + z_resolution=100, + crossstream_dist=0.0, + ) + ) + +# Create the plots +fig, ax_list = plt.subplots(2, 1, figsize=(10, 8)) +ax_list = ax_list.flatten() +flowviz.visualize_cut_plane(horizontal_planes[0], ax=ax_list[0], title="Horizontal") +flowviz.visualize_cut_plane(y_planes[0], ax=ax_list[1], title="Streamwise profile") +fig.suptitle("Fixed-bottom farm") + +fig, ax_list = plt.subplots(2, 1, figsize=(10, 8)) +ax_list = ax_list.flatten() +flowviz.visualize_cut_plane(horizontal_planes[1], ax=ax_list[0], title="Horizontal") +flowviz.visualize_cut_plane(y_planes[1], ax=ax_list[1], title="Streamwise profile") +fig.suptitle("Floating farm") + +# Compute AEP +# Load the wind rose from csv as in example 003 +wind_rose = WindRose.read_csv_long( + "../inputs/wind_rose.csv", wd_col="wd", ws_col="ws", freq_col="freq_val", ti_col_or_value=0.06 +) + + +for fmodel in [fmodel_fixed, fmodel_floating]: + fmodel.set( + wind_data=wind_rose, + ) + fmodel.run() + +# Compute the AEP +aep_fixed = fmodel_fixed.get_farm_AEP() +aep_floating = fmodel_floating.get_farm_AEP() +print("Farm AEP (fixed bottom): {:.3f} GWh".format(aep_fixed / 1.0e9)) +print("Farm AEP (floating): {:.3f} GWh".format(aep_floating / 1.0e9)) +print( + "Floating AEP increase: {0:.3f} GWh ({1:.2f}%)".\ + format((aep_floating - aep_fixed) / 1.0e9, (aep_floating - aep_fixed)/aep_fixed*100) +) + +plt.show() diff --git a/examples/25_tilt_driven_vertical_wake_deflection.py b/examples/examples_floating/003_tilt_driven_vertical_wake_deflection.py similarity index 51% rename from examples/25_tilt_driven_vertical_wake_deflection.py rename to examples/examples_floating/003_tilt_driven_vertical_wake_deflection.py index 1725e4134..88049cc7f 100644 --- a/examples/25_tilt_driven_vertical_wake_deflection.py +++ b/examples/examples_floating/003_tilt_driven_vertical_wake_deflection.py @@ -1,26 +1,4 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface -from floris.tools.visualization import visualize_cut_plane - - -""" +"""Example: Tilt-driven vertical wake deflection This example demonstrates vertical wake deflections due to the tilt angle when running with the Empirical Gauss model. Note that only the Empirical Gauss model implements vertical deflections at this time. Also be aware that this example uses a potentially @@ -28,13 +6,20 @@ of vertical deflections due to tilt has not been validated. """ +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane + + # Initialize two FLORIS objects: one with 5 degrees of tilt (fixed across all # wind speeds) and one with 15 degrees of tilt (fixed across all wind speeds). -fi_5 = FlorisInterface("inputs_floating/emgauss_floating_fixedtilt5.yaml") -fi_15 = FlorisInterface("inputs_floating/emgauss_floating_fixedtilt15.yaml") +fmodel_5 = FlorisModel("../inputs_floating/emgauss_floating_fixedtilt5.yaml") +fmodel_15 = FlorisModel("../inputs_floating/emgauss_floating_fixedtilt15.yaml") -D = fi_5.floris.farm.rotor_diameters[0] +D = fmodel_5.core.farm.rotor_diameters[0] num_in_row = 5 @@ -44,14 +29,14 @@ z_bounds = [0.001, 500] cross_plane_locations = [10, 1200, 2500] -horizontal_plane_location=90.0 -streamwise_plane_location=0.0 +horizontal_plane_location = 90.0 +streamwise_plane_location = 0.0 # Create the plots # Cutplane settings -cp_ls = "solid" # line style -cp_lw = 0.5 # line width -cp_clr = "black" # line color +cp_ls = "solid" # line style +cp_lw = 0.5 # line width +cp_clr = "black" # line color min_ws = 4 max_ws = 10 fig = plt.figure() @@ -60,33 +45,34 @@ powers = np.zeros((2, num_in_row)) # Calculate wakes, powers, plot -for i, (fi, tilt) in enumerate(zip([fi_5, fi_15], [5, 15])): - +for i, (fmodel, tilt) in enumerate(zip([fmodel_5, fmodel_15], [5, 15])): # Farm layout and wind conditions - fi.reinitialize( + fmodel.set( layout_x=[x * 5.0 * D for x in range(num_in_row)], - layout_y=[0.0]*num_in_row, + layout_y=[0.0] * num_in_row, wind_speeds=[8.0], - wind_directions=[270.0] + wind_directions=[270.0], ) # Flow solve and power computation - fi.calculate_wake() - powers[i,:] = fi.get_turbine_powers().flatten() + fmodel.run() + powers[i, :] = fmodel.get_turbine_powers().flatten() # Compute flow slices - y_plane = fi.calculate_y_plane( + y_plane = fmodel.calculate_y_plane( x_resolution=200, z_resolution=100, crossstream_dist=streamwise_plane_location, x_bounds=x_bounds, - z_bounds=z_bounds + z_bounds=z_bounds, ) # Horizontal profile - ax = fig.add_subplot(2, 1, i+1) + ax = fig.add_subplot(2, 1, i + 1) visualize_cut_plane(y_plane, ax=ax, min_speed=min_ws, max_speed=max_ws) - ax.plot(x_bounds, [horizontal_plane_location]*2, color=cp_clr, linewidth=cp_lw, linestyle=cp_ls) + ax.plot( + x_bounds, [horizontal_plane_location] * 2, color=cp_clr, linewidth=cp_lw, linestyle=cp_ls + ) ax.set_title("Tilt angle: {0} degrees".format(tilt)) fig = plt.figure() @@ -94,8 +80,8 @@ ax = fig.add_subplot(1, 1, 1) x_locs = np.arange(num_in_row) width = 0.25 -ax.bar(x_locs-width/2, powers[0,:]/1000, width=width, label="5 degree tilt") -ax.bar(x_locs+width/2, powers[1,:]/1000, width=width, label="15 degree tilt") +ax.bar(x_locs - width / 2, powers[0, :] / 1000, width=width, label="5 degree tilt") +ax.bar(x_locs + width / 2, powers[1, :] / 1000, width=width, label="15 degree tilt") ax.set_xticks(x_locs) ax.set_xticklabels(["T{0}".format(i) for i in range(num_in_row)]) ax.set_xlabel("Turbine number in row") diff --git a/examples/examples_get_flow/001_extract_wind_speed_at_turbines.py b/examples/examples_get_flow/001_extract_wind_speed_at_turbines.py new file mode 100644 index 000000000..1eed14e75 --- /dev/null +++ b/examples/examples_get_flow/001_extract_wind_speed_at_turbines.py @@ -0,0 +1,39 @@ +"""Example: Extract wind speed at turbines + +This example demonstrates how to extract the wind speed at the turbine points +from the FLORIS model. Both the u velocities and the turbine average +velocities are grabbed from the model, then the turbine average is +recalculated from the u velocities to show that they are equivalent. +""" + + +import numpy as np + +from floris import FlorisModel + + +# Initialize the FLORIS model +fmodel = FlorisModel("../inputs/gch.yaml") + +# Create a 4-turbine layouts +fmodel.set(layout_x=[0, 0.0, 500.0, 500.0], layout_y=[0.0, 300.0, 0.0, 300.0]) + +# Calculate wake +fmodel.run() + +# Collect the wind speed at all the turbine points +u_points = fmodel.core.flow_field.u + +print("U points is 1 findex x 4 turbines x 3 x 3 points (turbine_grid_points=3)") +print(u_points.shape) + +print("turbine_average_velocities is 1 findex x 4 turbines") +print(fmodel.turbine_average_velocities) + +# Show that one is equivalent to the other following averaging +print( + "turbine_average_velocities is determined by taking the cube root of mean " + "of the cubed value across the points " +) +print(f"turbine_average_velocities: {fmodel.turbine_average_velocities}") +print(f"Recomputed: {np.cbrt(np.mean(u_points**3, axis=(2,3)))}") diff --git a/examples/28_extract_wind_speed_at_points.py b/examples/examples_get_flow/002_extract_wind_speed_at_points.py similarity index 52% rename from examples/28_extract_wind_speed_at_points.py rename to examples/examples_get_flow/002_extract_wind_speed_at_points.py index 9ef59b5b1..aaf086f4b 100644 --- a/examples/28_extract_wind_speed_at_points.py +++ b/examples/examples_get_flow/002_extract_wind_speed_at_points.py @@ -1,27 +1,6 @@ -# Copyright 2023 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - -from floris.tools import FlorisInterface - - -""" +"""Example: Extract wind speed at points This example demonstrates the use of the sample_flow_at_points method of -FlorisInterface. sample_flow_at_points extracts the wind speed +FlorisModel. sample_flow_at_points extracts the wind speed information at user-specified locations in the flow. Specifically, this example returns the wind speed at a single x, y @@ -33,30 +12,39 @@ met mast within the two-turbine farm. """ + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel + + # User options # FLORIS model to use (limited to Gauss/GCH, Jensen, and empirical Gauss) -floris_model = "gch" # Try "gch", "jensen", "emgauss" +floris_model = "gch" # Try "gch", "jensen", "emgauss" # Option to try different met mast locations -met_mast_option = 0 # Try 0, 1, 2, 3 +met_mast_option = 0 # Try 0, 1, 2, 3 # Instantiate FLORIS model -fi = FlorisInterface("inputs/"+floris_model+".yaml") +fmodel = FlorisModel("../inputs/" + floris_model + ".yaml") # Set up a two-turbine farm D = 126 -fi.reinitialize(layout_x=[0, 3 * D], layout_y=[0, 3 * D]) +fmodel.set(layout_x=[0, 3 * D], layout_y=[0, 3 * D]) -fig, ax = plt.subplots(1,2) -fig.set_size_inches(10,4) -ax[0].scatter(fi.layout_x, fi.layout_y, color="black", label="Turbine") +fig, ax = plt.subplots(1, 2) +fig.set_size_inches(10, 4) +ax[0].scatter(fmodel.layout_x, fmodel.layout_y, color="black", label="Turbine") # Set the wind direction to run 360 degrees wd_array = np.arange(0, 360, 1) -fi.reinitialize(wind_directions=wd_array) +ws_array = 8.0 * np.ones_like(wd_array) +ti_array = 0.06 * np.ones_like(wd_array) +fmodel.set(wind_directions=wd_array, wind_speeds=ws_array, turbulence_intensities=ti_array) # Simulate a met mast in between the turbines if met_mast_option == 0: - points_x = 4 * [3*D] + points_x = 4 * [3 * D] points_y = 4 * [0] elif met_mast_option == 1: points_x = 4 * [200.0] @@ -71,7 +59,7 @@ points_z = [30, 90, 150, 250] # Collect the points -u_at_points = fi.sample_flow_at_points(points_x, points_y, points_z) +u_at_points = fmodel.sample_flow_at_points(points_x, points_y, points_z) ax[0].scatter(points_x, points_y, color="red", marker="x", label="Met mast") ax[0].grid() @@ -81,10 +69,10 @@ # Plot the velocities for z_idx, z in enumerate(points_z): - ax[1].plot(wd_array, u_at_points[:, :, z_idx].flatten(), label=f'Speed at z={z} m') + ax[1].plot(wd_array, u_at_points[:, z_idx].flatten(), label=f"Speed at z={z} m") ax[1].grid() ax[1].legend() -ax[1].set_xlabel('Wind Direction (deg)') -ax[1].set_ylabel('Wind Speed (m/s)') +ax[1].set_xlabel("Wind Direction (deg)") +ax[1].set_ylabel("Wind Speed (m/s)") plt.show() diff --git a/examples/32_plot_velocity_deficit_profiles.py b/examples/examples_get_flow/003_plot_velocity_deficit_profiles.py similarity index 60% rename from examples/32_plot_velocity_deficit_profiles.py rename to examples/examples_get_flow/003_plot_velocity_deficit_profiles.py index 9b12dcc4e..1b8cabc77 100644 --- a/examples/32_plot_velocity_deficit_profiles.py +++ b/examples/examples_get_flow/003_plot_velocity_deficit_profiles.py @@ -1,36 +1,23 @@ -# Copyright 2021 NREL +"""Example: Plot velocity deficit profiles -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation +This example illustrates how to plot velocity deficit profiles at several locations +downstream of a turbine. Here we use the following definition: + velocity_deficit = (homogeneous_wind_speed - u) / homogeneous_wind_speed + , where u is the wake velocity obtained when the incoming wind speed is the + same at all heights and equal to `homogeneous_wind_speed`. +""" import matplotlib.pyplot as plt import numpy as np from matplotlib import ticker -import floris.tools.visualization as wakeviz -from floris.tools import cut_plane, FlorisInterface -from floris.tools.visualization import VelocityProfilesFigure +import floris.flow_visualization as flowviz +from floris import FlorisModel +from floris.flow_visualization import VelocityProfilesFigure from floris.utilities import reverse_rotate_coordinates_rel_west -""" -This example illustrates how to plot velocity deficit profiles at several locations -downstream of a turbine. Here we use the following definition: - velocity_deficit = (homogeneous_wind_speed - u) / homogeneous_wind_speed - , where u is the wake velocity obtained when the incoming wind speed is the - same at all heights and equal to `homogeneous_wind_speed`. -""" - # The first two functions are just used to plot the coordinate system in which the # profiles are sampled. Please go to the main function to begin the example. def plot_coordinate_system(x_origin, y_origin, wind_direction): @@ -41,35 +28,37 @@ def plot_coordinate_system(x_origin, y_origin, wind_direction): [quiver_length, quiver_length], [0, 0], angles=[270 - wind_direction, 360 - wind_direction], - scale_units='x', + scale_units="x", scale=1, ) annotate_coordinate_system(x_origin, y_origin, quiver_length) + def annotate_coordinate_system(x_origin, y_origin, quiver_length): x1 = np.array([quiver_length + 0.35 * D, 0.0]) x2 = np.array([0.0, quiver_length + 0.35 * D]) x3 = np.array([90.0, 90.0]) x, y, _ = reverse_rotate_coordinates_rel_west( - fi.floris.flow_field.wind_directions, - x1[None, :], - x2[None, :], - x3[None, :], - x_center_of_rotation=0.0, - y_center_of_rotation=0.0, + fmodel.wind_directions, + x1[None, :], + x2[None, :], + x3[None, :], + x_center_of_rotation=0.0, + y_center_of_rotation=0.0, ) x = np.squeeze(x, axis=0) + x_origin y = np.squeeze(y, axis=0) + y_origin - plt.text(x[0], y[0], '$x_1$', bbox={'facecolor': 'white'}) - plt.text(x[1], y[1], '$x_2$', bbox={'facecolor': 'white'}) + plt.text(x[0], y[0], "$x_1$", bbox={"facecolor": "white"}) + plt.text(x[1], y[1], "$x_2$", bbox={"facecolor": "white"}) + -if __name__ == '__main__': - D = 126.0 # Turbine diameter +if __name__ == "__main__": + D = 125.88 # Turbine diameter hub_height = 90.0 homogeneous_wind_speed = 8.0 - fi = FlorisInterface("inputs/gch.yaml") - fi.reinitialize(layout_x=[0.0], layout_y=[0.0]) + fmodel = FlorisModel("../inputs/gch.yaml") + fmodel.set(layout_x=[0.0], layout_y=[0.0]) # ------------------------------ Single-turbine layout ------------------------------ # We first show how to sample and plot velocity deficit profiles on a single-turbine layout. @@ -77,22 +66,22 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): downstream_dists = D * np.array([3, 5, 7]) # Sample three profiles along three corresponding lines that are all parallel to the y-axis # (cross-stream direction). The streamwise location of each line is given in `downstream_dists`. - profiles = fi.sample_velocity_deficit_profiles( - direction='cross-stream', + profiles = fmodel.sample_velocity_deficit_profiles( + direction="cross-stream", downstream_dists=downstream_dists, homogeneous_wind_speed=homogeneous_wind_speed, ) - horizontal_plane = fi.calculate_horizontal_plane(height=hub_height) + horizontal_plane = fmodel.calculate_horizontal_plane(height=hub_height) fig, ax = plt.subplots(figsize=(6.4, 3)) - wakeviz.visualize_cut_plane(horizontal_plane, ax) - colors = ['b', 'g', 'c'] + flowviz.visualize_cut_plane(horizontal_plane, ax) + colors = ["b", "g", "c"] for i, profile in enumerate(profiles): # Plot profile coordinates on the horizontal plane - ax.plot(profile['x'], profile['y'], colors[i], label=f'x/D={downstream_dists[i] / D:.1f}') - ax.set_xlabel('x [m]') - ax.set_ylabel('y [m]') - ax.set_title('Streamwise velocity in a horizontal plane: gauss velocity model') + ax.plot(profile["x"], profile["y"], colors[i], label=f"x/D={downstream_dists[i] / D:.1f}") + ax.set_xlabel("x [m]") + ax.set_ylabel("y [m]") + ax.set_title("Streamwise velocity in a horizontal plane: gauss velocity model") fig.tight_layout(rect=[0, 0, 0.82, 1]) ax.legend(bbox_to_anchor=[1.29, 1.04]) @@ -100,34 +89,34 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): # Initialize it, plot data, and then customize it further if needed. profiles_fig = VelocityProfilesFigure( downstream_dists_D=downstream_dists / D, - layout=['cross-stream'], - coordinate_labels=['x/D', 'y/D'], + layout=["cross-stream"], + coordinate_labels=["x/D", "y/D"], ) # Add profiles to the VelocityProfilesFigure. This method automatically matches the supplied # profiles to the initialized axes in the figure. - profiles_fig.add_profiles(profiles, color='k') + profiles_fig.add_profiles(profiles, color="k") # Change velocity model to jensen, get the velocity deficit profiles, # and add them to the figure. - floris_dict = fi.floris.as_dict() - floris_dict['wake']['model_strings']['velocity_model'] = 'jensen' - fi = FlorisInterface(floris_dict) - profiles = fi.sample_velocity_deficit_profiles( - direction='cross-stream', + floris_dict = fmodel.core.as_dict() + floris_dict["wake"]["model_strings"]["velocity_model"] = "jensen" + fmodel = FlorisModel(floris_dict) + profiles = fmodel.sample_velocity_deficit_profiles( + direction="cross-stream", downstream_dists=downstream_dists, homogeneous_wind_speed=homogeneous_wind_speed, resolution=400, ) - profiles_fig.add_profiles(profiles, color='r') + profiles_fig.add_profiles(profiles, color="r") # The dashed reference lines show the extent of the rotor profiles_fig.add_ref_lines_x2([-0.5, 0.5]) for ax in profiles_fig.axs[0]: ax.xaxis.set_major_locator(ticker.MultipleLocator(0.2)) - profiles_fig.axs[0,0].legend(['gauss', 'jensen'], fontsize=11) + profiles_fig.axs[0, 0].legend(["gauss", "jensen"], fontsize=11) profiles_fig.fig.suptitle( - 'Velocity deficit profiles from different velocity models', + "Velocity deficit profiles from different velocity models", fontsize=14, ) @@ -137,38 +126,40 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): # sampling-coordinate-system (x1, x2, x3) that is rotated such that x1 is always in the # streamwise direction. The user may define the origin of this coordinate system # (i.e. where to start sampling the profiles). - wind_direction = 315.0 # Try to change this + wind_direction = 315.0 # Try to change this downstream_dists = D * np.array([3, 5]) - floris_dict = fi.floris.as_dict() - floris_dict['wake']['model_strings']['velocity_model'] = 'gauss' - fi = FlorisInterface(floris_dict) + floris_dict = fmodel.core.as_dict() + floris_dict["wake"]["model_strings"]["velocity_model"] = "gauss" + fmodel = FlorisModel(floris_dict) # Let (x_t1, y_t1) be the location of the second turbine - x_t1 = 2 * D + x_t1 = 2 * D y_t1 = -2 * D - fi.reinitialize(wind_directions=[wind_direction], layout_x=[0.0, x_t1], layout_y=[0.0, y_t1]) + fmodel.set(wind_directions=[wind_direction], layout_x=[0.0, x_t1], layout_y=[0.0, y_t1]) # Extract profiles at a set of downstream distances from the starting point (x_start, y_start) - cross_profiles = fi.sample_velocity_deficit_profiles( - direction='cross-stream', + cross_profiles = fmodel.sample_velocity_deficit_profiles( + direction="cross-stream", downstream_dists=downstream_dists, homogeneous_wind_speed=homogeneous_wind_speed, x_start=x_t1, y_start=y_t1, ) - horizontal_plane = fi.calculate_horizontal_plane(height=hub_height, x_bounds=[-2 * D, 9 * D]) - ax = wakeviz.visualize_cut_plane(horizontal_plane) - colors = ['b', 'g', 'c'] + horizontal_plane = fmodel.calculate_horizontal_plane( + height=hub_height, x_bounds=[-2 * D, 9 * D] + ) + ax = flowviz.visualize_cut_plane(horizontal_plane) + colors = ["b", "g", "c"] for i, profile in enumerate(cross_profiles): ax.plot( - profile['x'], - profile['y'], + profile["x"], + profile["y"], colors[i], - label=f'$x_1/D={downstream_dists[i] / D:.1f}$', + label=f"$x_1/D={downstream_dists[i] / D:.1f}$", ) - ax.set_xlabel('x [m]') - ax.set_ylabel('y [m]') - ax.set_title('Streamwise velocity in a horizontal plane') + ax.set_xlabel("x [m]") + ax.set_ylabel("y [m]") + ax.set_title("Streamwise velocity in a horizontal plane") ax.legend() plot_coordinate_system(x_origin=x_t1, y_origin=y_t1, wind_direction=wind_direction) @@ -176,8 +167,8 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): # locations as before. We stay directly downstream of the turbine (i.e. x2 = 0). These # profiles are almost identical to the cross-stream profiles. However, we now explicitly # set the profile range. The default range is [-2 * D, 2 * D]. - vertical_profiles = fi.sample_velocity_deficit_profiles( - direction='vertical', + vertical_profiles = fmodel.sample_velocity_deficit_profiles( + direction="vertical", profile_range=[-1.5 * D, 1.5 * D], downstream_dists=downstream_dists, homogeneous_wind_speed=homogeneous_wind_speed, @@ -187,19 +178,18 @@ def annotate_coordinate_system(x_origin, y_origin, quiver_length): profiles_fig = VelocityProfilesFigure( downstream_dists_D=downstream_dists / D, - layout=['cross-stream', 'vertical'], + layout=["cross-stream", "vertical"], ) - profiles_fig.add_profiles(cross_profiles + vertical_profiles, color='k') + profiles_fig.add_profiles(cross_profiles + vertical_profiles, color="k") profiles_fig.set_xlim([-0.05, 0.85]) - profiles_fig.axs[1,0].set_ylim([-2.2, 2.2]) + profiles_fig.axs[1, 0].set_ylim([-2.2, 2.2]) for ax in profiles_fig.axs[0]: ax.xaxis.set_major_locator(ticker.MultipleLocator(0.4)) profiles_fig.fig.suptitle( - 'Cross-stream profiles at hub-height, and\nvertical profiles at $x_2 = 0$', + "Cross-stream profiles at hub-height, and\nvertical profiles at $x_2 = 0$", fontsize=14, ) - plt.show() diff --git a/examples/examples_heterogeneous/001_heterogeneous_inflow_single.py b/examples/examples_heterogeneous/001_heterogeneous_inflow_single.py new file mode 100644 index 000000000..28f92d238 --- /dev/null +++ b/examples/examples_heterogeneous/001_heterogeneous_inflow_single.py @@ -0,0 +1,79 @@ +"""Example: Heterogeneous Inflow for single case + +This example illustrates how to set up a heterogeneous inflow condition in FLORIS. It: + + 1) Initializes FLORIS + 2) Changes the wind farm layout + 3) Changes the incoming wind speed, wind direction and turbulence intensity + to a single condition + 4) Sets up a heterogeneous inflow condition for that single condition + 5) Runs the FLORIS simulation + 6) Gets the power output of the turbines + 7) Visualizes the horizontal plane at hub height + +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel, TimeSeries +from floris.flow_visualization import visualize_cut_plane +from floris.layout_visualization import plot_turbine_labels + + +# Initialize FlorisModel +fmodel = FlorisModel("../inputs/gch.yaml") + +# Change the layout to a 4 turbine layout in a box +fmodel.set(layout_x=[0, 0, 500.0, 500.0], layout_y=[0, 500.0, 0, 500.0]) + +# Set FLORIS to run for a single condition +fmodel.set(wind_speeds=[8.0], wind_directions=[270.0], turbulence_intensities=[0.06]) + +# Define the speed-ups of the heterogeneous inflow, and their locations. +# Note that heterogeneity is only applied within the bounds of the points defined in the +# heterogeneous_inflow_config dictionary. In this case, set the inflow to be 1.25x the ambient +# wind speed for the upper turbines at y = 500m. +speed_ups = [[1.0, 1.25, 1.0, 1.25]] # Note speed-ups has dimensions of n_findex X n_points +x_locs = [-500.0, -500.0, 1000.0, 1000.0] +y_locs = [-500.0, 1000.0, -500.0, 1000.0] + +# Create the configuration dictionary to be used for the heterogeneous inflow. +heterogeneous_inflow_config = { + "speed_multipliers": speed_ups, + "x": x_locs, + "y": y_locs, +} + +# Set the heterogeneous inflow configuration +fmodel.set(heterogeneous_inflow_config=heterogeneous_inflow_config) + +# Run the FLORIS simulation +fmodel.run() + +# Get the power output of the turbines +turbine_powers = fmodel.get_turbine_powers() / 1000.0 + +# Print the turbine powers +print(f"Turbine 0 power = {turbine_powers[0, 0]:.1f} kW") +print(f"Turbine 1 power = {turbine_powers[0, 1]:.1f} kW") +print(f"Turbine 2 power = {turbine_powers[0, 2]:.1f} kW") +print(f"Turbine 3 power = {turbine_powers[0, 3]:.1f} kW") + +# Extract the horizontal plane at hub height +horizontal_plane = fmodel.calculate_horizontal_plane( + x_resolution=200, y_resolution=100, height=90.0 +) + +# Plot the horizontal plane +fig, ax = plt.subplots() +visualize_cut_plane( + horizontal_plane, + ax=ax, + title="Horizontal plane at hub height", + color_bar=True, + label_contours=True, +) +plot_turbine_labels(fmodel, ax) + +plt.show() diff --git a/examples/examples_heterogeneous/002_heterogeneous_inflow_multi.py b/examples/examples_heterogeneous/002_heterogeneous_inflow_multi.py new file mode 100644 index 000000000..fa8b9cfe4 --- /dev/null +++ b/examples/examples_heterogeneous/002_heterogeneous_inflow_multi.py @@ -0,0 +1,123 @@ +"""Example: Heterogeneous Inflow for multiple conditions + +When multiple cases are considered, the heterogeneous inflow conditions can be defined in two ways: + + 1. Passing heterogeneous_inflow_config to the set method, with P points, + and speedups of size n_findex X P + 2. Assigning heterogeneous_inflow_config_by_wd to the wind_data object + used to drive FLORIS. This object includes + n_wd wind_directions, and speedups is of size n_wd X P. When applied + to set, the heterogeneous_inflow_config + is automatically generated by using the nearest wind direction + defined in heterogeneous_inflow_config_by_wd + for each findex. + +This example: + + 1) Implements heterogeneous inflow for a 4 turbine layout using both of the above methods + 2) Compares the results of the two methods and shows that they are equivalent + +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel, TimeSeries + + +# Initialize FlorisModel +fmodel = FlorisModel("../inputs/gch.yaml") + +# Change the layout to a 4 turbine layout in a box +fmodel.set(layout_x=[0, 0, 500.0, 500.0], layout_y=[0, 500.0, 0, 500.0]) + +# Define a TimeSeries object with 4 wind directions and constant wind speed +# and turbulence intensity + +time_series = TimeSeries( + wind_directions=np.array([269.0, 270.0, 271.0, 282.0]), + wind_speeds=8.0, + turbulence_intensities=0.06, +) + +# Apply the time series to the FlorisModel +fmodel.set(wind_data=time_series) + +# Define the x_locs to be used in the heterogeneous inflow configuration that form +# a box around the turbines +x_locs = [-500.0, -500.0, 1000.0, 1000.0] +y_locs = [-500.0, 1000.0, -500.0, 1000.0] + +# Assume the speed-ups are defined such that they are the same 265-275 degrees and 275-285 degrees + +# If defining heterogeneous_inflow_config directly, then the speedups are of size n_findex X P +# where the first 3 rows are identical, and the last row is different +speed_ups = [ + [1.0, 1.25, 1.0, 1.25], + [1.0, 1.25, 1.0, 1.25], + [1.0, 1.25, 1.0, 1.25], + [1.0, 1.35, 1.0, 1.35], +] + +heterogeneous_inflow_config = { + "speed_multipliers": speed_ups, + "x": x_locs, + "y": y_locs, +} + +# Set the heterogeneous inflow configuration +fmodel.set(heterogeneous_inflow_config=heterogeneous_inflow_config) + +# Run the FLORIS simulation +fmodel.run() + +# Get the power output of the turbines +turbine_powers = fmodel.get_turbine_powers() / 1000.0 + +# Now repeat using the wind_data object and heterogeneous_inflow_config_by_wd +# First, create the speedups for the two wind directions +speed_ups = [[1.0, 1.25, 1.0, 1.25], [1.0, 1.35, 1.0, 1.35]] + +# Create the heterogeneous_inflow_config_by_wd dictionary +heterogeneous_inflow_config_by_wd = { + "speed_multipliers": speed_ups, + "x": x_locs, + "y": y_locs, + "wind_directions": [270.0, 280.0], +} + +# Now create a new TimeSeries object including the heterogeneous_inflow_config_by_wd +time_series = TimeSeries( + wind_directions=np.array([269.0, 270.0, 271.0, 282.0]), + wind_speeds=8.0, + turbulence_intensities=0.06, + heterogeneous_inflow_config_by_wd=heterogeneous_inflow_config_by_wd, +) + +# Apply the time series to the FlorisModel +fmodel.set(wind_data=time_series) + +# Run the FLORIS simulation +fmodel.run() + +# Get the power output of the turbines +turbine_powers_by_wd = fmodel.get_turbine_powers() / 1000.0 + +# Plot the results +wind_directions = fmodel.wind_directions +fig, axarr = plt.subplots(2, 2, sharex=True, sharey=True, figsize=(10, 10)) +axarr = axarr.flatten() + +for tindex in range(4): + ax = axarr[tindex] + ax.plot(wind_directions, turbine_powers[:, tindex], "ks-", label="Heterogeneous Inflow") + ax.plot( + wind_directions, turbine_powers_by_wd[:, tindex], ".--", label="Heterogeneous Inflow by WD" + ) + ax.set_title(f"Turbine {tindex}") + ax.set_xlabel("Wind Direction (deg)") + ax.set_ylabel("Power (kW)") + ax.legend() + +plt.show() diff --git a/examples/examples_heterogeneous/003_heterogeneous_2d_and_3d.py b/examples/examples_heterogeneous/003_heterogeneous_2d_and_3d.py new file mode 100644 index 000000000..1d1f3b791 --- /dev/null +++ b/examples/examples_heterogeneous/003_heterogeneous_2d_and_3d.py @@ -0,0 +1,140 @@ +"""Example: Heterogeneous Inflow in 2D and 3D + +This example showcases the heterogeneous inflow capabilities of FLORIS. +Heterogeneous flow can be defined in either 2- or 3-dimensions for a single +condition. + +For the 2-dimensional case, it can be seen that the freestream velocity +only varies in the x direction. For the 3-dimensional case, it can be +seen that the freestream velocity only varies in the z direction. This +is because of how the speed ups for each case were defined. More complex +inflow conditions can be defined. + +For each case, we are plotting three slices of the resulting flow field: +1. Horizontal slice parallel to the ground and located at the hub height +2. Vertical slice parallel with the direction of the wind +3. Vertical slice parallel to to the turbine disc plane + +Since the intention is for plotting, only a single condition is run and in +this case the heterogeneous_inflow_config is more convenient to use than +heterogeneous_inflow_config_by_wd. However, the latter is more convenient +when running multiple conditions. +""" + + +import matplotlib.pyplot as plt + +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane + + +# Initialize FLORIS with the given input file via FlorisModel. +# Note that the heterogeneous flow is defined in the input file. The heterogeneous_inflow_config +# dictionary is defined as below. The speed ups are multipliers of the ambient wind speed, +# and the x and y are the locations of the speed ups. +# +# heterogeneous_inflow_config = { +# 'speed_multipliers': [[2.0, 1.0, 2.0, 1.0]], +# 'x': [-300.0, -300.0, 2600.0, 2600.0], +# 'y': [ -300.0, 300.0, -300.0, 300.0], +# } + + +fmodel_2d = FlorisModel("../inputs/gch_heterogeneous_inflow.yaml") + +# Set shear to 0.0 to highlight the heterogeneous inflow +fmodel_2d.set(wind_shear=0.0) + +# Using the FlorisModel functions for generating plots, run FLORIS +# and extract 2D planes of data. +horizontal_plane_2d = fmodel_2d.calculate_horizontal_plane( + x_resolution=200, y_resolution=100, height=90.0 +) +y_plane_2d = fmodel_2d.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) +cross_plane_2d = fmodel_2d.calculate_cross_plane( + y_resolution=100, z_resolution=100, downstream_dist=500.0 +) + +# Create the plots +fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) +ax_list = ax_list.flatten() +visualize_cut_plane( + horizontal_plane_2d, ax=ax_list[0], title="Horizontal", color_bar=True, label_contours=True +) +ax_list[0].set_xlabel("x") +ax_list[0].set_ylabel("y") +visualize_cut_plane( + y_plane_2d, ax=ax_list[1], title="Streamwise profile", color_bar=True, label_contours=True +) +ax_list[1].set_xlabel("x") +ax_list[1].set_ylabel("z") +visualize_cut_plane( + cross_plane_2d, + ax=ax_list[2], + title="Spanwise profile at 500m downstream", + color_bar=True, + label_contours=True, +) +ax_list[2].set_xlabel("y") +ax_list[2].set_ylabel("z") + + +# Define the speed ups of the heterogeneous inflow, and their locations. +# For the 3-dimensional case, this requires x, y, and z locations. +# The speed ups are multipliers of the ambient wind speed. +speed_multipliers = [[1.0, 1.0, 2.0, 2.0, 1.0, 1.0, 2.0, 2.0]] +x_locs = [-300.0, -300.0, -300.0, -300.0, 2600.0, 2600.0, 2600.0, 2600.0] +y_locs = [-300.0, 300.0, -300.0, 300.0, -300.0, 300.0, -300.0, 300.0] +z_locs = [540.0, 540.0, 0.0, 0.0, 540.0, 540.0, 0.0, 0.0] + +# Create the configuration dictionary to be used for the heterogeneous inflow. +heterogeneous_inflow_config = { + "speed_multipliers": speed_multipliers, + "x": x_locs, + "y": y_locs, + "z": z_locs, +} + +# Initialize FLORIS with the given input file. +# Note that we initialize FLORIS with a homogenous flow input file, but +# then configure the heterogeneous inflow via the reinitialize method. +fmodel_3d = FlorisModel("../inputs/gch.yaml") +fmodel_3d.set(heterogeneous_inflow_config=heterogeneous_inflow_config) + +# Set shear to 0.0 to highlight the heterogeneous inflow +fmodel_3d.set(wind_shear=0.0) + +# Using the FlorisModel functions for generating plots, run FLORIS +# and extract 2D planes of data. +horizontal_plane_3d = fmodel_3d.calculate_horizontal_plane( + x_resolution=200, y_resolution=100, height=90.0 +) +y_plane_3d = fmodel_3d.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) +cross_plane_3d = fmodel_3d.calculate_cross_plane( + y_resolution=100, z_resolution=100, downstream_dist=500.0 +) + +# Create the plots +fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) +ax_list = ax_list.flatten() +visualize_cut_plane( + horizontal_plane_3d, ax=ax_list[0], title="Horizontal", color_bar=True, label_contours=True +) +ax_list[0].set_xlabel("x") +ax_list[0].set_ylabel("y") +visualize_cut_plane( + y_plane_3d, ax=ax_list[1], title="Streamwise profile", color_bar=True, label_contours=True +) +ax_list[1].set_xlabel("x") +ax_list[1].set_ylabel("z") +visualize_cut_plane( + cross_plane_3d, + ax=ax_list[2], + title="Spanwise profile at 500m downstream", + color_bar=True, + label_contours=True, +) +ax_list[2].set_xlabel("y") +ax_list[2].set_ylabel("z") + +plt.show() diff --git a/examples/examples_layout_optimization/001_optimize_layout.py b/examples/examples_layout_optimization/001_optimize_layout.py new file mode 100644 index 000000000..e7cf43c67 --- /dev/null +++ b/examples/examples_layout_optimization/001_optimize_layout.py @@ -0,0 +1,138 @@ + +"""Example: Optimize Layout +This example shows a simple layout optimization using the python module Scipy, optimizing for both +annual energy production (AEP) and annual value production (AVP). + +First, a 4 turbine array is optimized such that the layout of the turbine produces the +highest AEP based on the given wind resource. The turbines +are constrained to a square boundary and a random wind resource is supplied. The results +of the optimization show that the turbines are pushed to near the outer corners of the boundary, +which, given the generally uniform wind rose, makes sense in order to maximize the energy +production by minimizing wake interactions. + +Next, with the same boundary, the same 4 turbine array is optimized to maximize AVP instead of AEP, +using the value table defined in the WindRose object, where value represents the value of the +energy produced for a given wind condition (e.g., the price of electricity). In this example, value +is defined to be significantly higher for northerly and southerly wind directions, and zero when +the wind is from the east or west. Because the value is much higher when the wind is from the north +or south, the turbines are spaced apart roughly evenly in the x direction while being relatively +close in the y direction to avoid wake interactions for northerly and southerly winds. Although the +layout results in large wake losses when the wind is from the east or west, these losses do not +significantly impact the objective function because of the low value for those wind directions. +""" + + +import os + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel, WindRose +from floris.optimization.layout_optimization.layout_optimization_scipy import ( + LayoutOptimizationScipy, +) + + +# Define scipy optimization parameters +opt_options = { + "maxiter": 20, + "disp": True, + "iprint": 2, + "ftol": 1e-12, + "eps": 0.05, +} + +# Initialize the FLORIS interface fi +fmodel = FlorisModel('../inputs/gch.yaml') + +# Setup 72 wind directions with a 1 wind speed and frequency distribution +wind_directions = np.arange(0, 360.0, 5.0) +wind_speeds = np.array([8.0]) + +# Shape random frequency distribution to match number of wind directions and wind speeds +freq_table = np.zeros((len(wind_directions), len(wind_speeds))) +np.random.seed(1) +freq_table[:,0] = (np.abs(np.sort(np.random.randn(len(wind_directions))))) +freq_table = freq_table / freq_table.sum() + +# Define the value table such that the value of the energy produced is +# significantly higher when the wind direction is close to the north or +# south, and zero when the wind is from the east or west. Here, value is +# given a mean value of 25 USD/MWh. +value_table = (0.5 + 0.5*np.cos(2*np.radians(wind_directions)))**10 +value_table = 25*value_table/np.mean(value_table) +value_table = value_table.reshape((len(wind_directions),1)) + +# Establish a WindRose object +wind_rose = WindRose( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + freq_table=freq_table, + ti_table=0.06, + value_table=value_table +) + +fmodel.set(wind_data=wind_rose) + +# The boundaries for the turbines, specified as vertices +boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] + +# Set turbine locations to 4 turbines in a rectangle +D = 126.0 # rotor diameter for the NREL 5MW +layout_x = [0, 0, 6 * D, 6 * D] +layout_y = [0, 4 * D, 0, 4 * D] +fmodel.set(layout_x=layout_x, layout_y=layout_y) + +# Setup the optimization problem to maximize AEP instead of value +layout_opt = LayoutOptimizationScipy(fmodel, boundaries, optOptions=opt_options) + +# Run the optimization +sol = layout_opt.optimize() + +# Get the resulting improvement in AEP +print('... calculating improvement in AEP') +fmodel.run() +base_aep = fmodel.get_farm_AEP() / 1e6 +fmodel.set(layout_x=sol[0], layout_y=sol[1]) +fmodel.run() +opt_aep = fmodel.get_farm_AEP() / 1e6 + +percent_gain = 100 * (opt_aep - base_aep) / base_aep + +# Print and plot the results +print(f'Optimal layout: {sol}') +print( + f'Optimal layout improves AEP by {percent_gain:.1f}% ' + f'from {base_aep:.1f} MWh to {opt_aep:.1f} MWh' +) +layout_opt.plot_layout_opt_results() + +# reset to the original layout +fmodel.set(layout_x=layout_x, layout_y=layout_y) + +# Now set up the optimization problem to maximize annual value production (AVP) +# using the value table provided in the WindRose object. +layout_opt = LayoutOptimizationScipy(fmodel, boundaries, optOptions=opt_options, use_value=True) + +# Run the optimization +sol = layout_opt.optimize() + +# Get the resulting improvement in AVP +print('... calculating improvement in annual value production (AVP)') +fmodel.run() +base_avp = fmodel.get_farm_AVP() / 1e6 +fmodel.set(layout_x=sol[0], layout_y=sol[1]) +fmodel.run() +opt_avp = fmodel.get_farm_AVP() / 1e6 + +percent_gain = 100 * (opt_avp - base_avp) / base_avp + +# Print and plot the results +print(f'Optimal layout: {sol}') +print( + f'Optimal layout improves AVP by {percent_gain:.1f}% ' + f'from {base_avp:.1f} dollars to {opt_avp:.1f} dollars' +) +layout_opt.plot_layout_opt_results() + +plt.show() diff --git a/examples/examples_layout_optimization/002_optimize_layout_with_heterogeneity.py b/examples/examples_layout_optimization/002_optimize_layout_with_heterogeneity.py new file mode 100644 index 000000000..a8cc4044b --- /dev/null +++ b/examples/examples_layout_optimization/002_optimize_layout_with_heterogeneity.py @@ -0,0 +1,156 @@ +"""Example: Layout optimization with heterogeneous inflow +This example shows a layout optimization using the geometric yaw option. It +combines elements of layout optimization and heterogeneous +inflow for demonstrative purposes. + +Heterogeneity in the inflow provides the necessary driver for coupled yaw +and layout optimization to be worthwhile. First, a layout optimization is +run without coupled yaw optimization; then a coupled optimization is run to +show the benefits of coupled optimization when flows are heterogeneous. +""" + + +import os + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel, WindRose +from floris.optimization.layout_optimization.layout_optimization_scipy import ( + LayoutOptimizationScipy, +) + + +# Initialize FLORIS +fmodel = FlorisModel("../inputs/gch.yaml") + +# Setup 2 wind directions (due east and due west) +# and 1 wind speed with uniform probability +wind_directions = np.array([270.0, 90.0]) +n_wds = len(wind_directions) +wind_speeds = [8.0] * np.ones_like(wind_directions) +turbulence_intensities = 0.06 * np.ones_like(wind_directions) +# Shape frequency distribution to match number of wind directions and wind speeds +freq_table = np.ones((len(wind_directions), len(wind_speeds))) +freq_table = freq_table / freq_table.sum() + + +# The boundaries for the turbines, specified as vertices +D = 126.0 # rotor diameter for the NREL 5MW +size_D = 12 +boundaries = [(0.0, 0.0), (size_D * D, 0.0), (size_D * D, 0.1), (0.0, 0.1), (0.0, 0.0)] + +# Set turbine locations to 4 turbines at corners of the rectangle +# (optimal without flow heterogeneity) +layout_x = [0.1, 0.3 * size_D * D, 0.6 * size_D * D] +layout_y = [0, 0, 0] + +# Generate exaggerated heterogeneous inflow (same for all wind directions) +speed_multipliers = np.repeat(np.array([0.5, 1.0, 0.5, 1.0])[None, :], n_wds, axis=0) +x_locs = [0, size_D * D, 0, size_D * D] +y_locs = [-D, -D, D, D] + +# Create the configuration dictionary to be used for the heterogeneous inflow. +heterogeneous_inflow_config_by_wd = { + "speed_multipliers": speed_multipliers, + "wind_directions": wind_directions, + "x": x_locs, + "y": y_locs, +} + +# Establish a WindRose object +wind_rose = WindRose( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + freq_table=freq_table, + ti_table=0.06, + heterogeneous_inflow_config_by_wd=heterogeneous_inflow_config_by_wd, +) + + +fmodel.set( + layout_x=layout_x, + layout_y=layout_y, + wind_data=wind_rose, +) + +# Setup and solve the layout optimization problem without heterogeneity +maxiter = 100 +layout_opt = LayoutOptimizationScipy( + fmodel, boundaries, min_dist=2 * D, optOptions={"maxiter": maxiter} +) + +# Run the optimization +np.random.seed(0) +sol = layout_opt.optimize() + +# Get the resulting improvement in AEP +print("... calcuating improvement in AEP") + +fmodel.run() +base_aep = fmodel.get_farm_AEP() / 1e6 +fmodel.set(layout_x=sol[0], layout_y=sol[1]) +fmodel.run() +opt_aep = fmodel.get_farm_AEP() / 1e6 + +percent_gain = 100 * (opt_aep - base_aep) / base_aep + +# Print and plot the results +print(f"Optimal layout: {sol}") +print( + f"Optimal layout improves AEP by {percent_gain:.1f}% " + f"from {base_aep:.1f} MWh to {opt_aep:.1f} MWh" +) +layout_opt.plot_layout_opt_results() +ax = plt.gca() +fig = plt.gcf() +sm = ax.tricontourf(x_locs, y_locs, speed_multipliers[0], cmap="coolwarm") +fig.colorbar(sm, ax=ax, label="Speed multiplier") +ax.legend(["Initial layout", "Optimized layout", "Optimization boundary"]) +ax.set_title("Geometric yaw disabled") + + +# Rerun the layout optimization with geometric yaw enabled +print("\nReoptimizing with geometric yaw enabled.") +fmodel.set(layout_x=layout_x, layout_y=layout_y) +layout_opt = LayoutOptimizationScipy( + fmodel, boundaries, min_dist=2 * D, enable_geometric_yaw=True, optOptions={"maxiter": maxiter} +) + +# Run the optimization +np.random.seed(0) +sol = layout_opt.optimize() + +# Get the resulting improvement in AEP +print("... calcuating improvement in AEP") + +fmodel.set(yaw_angles=np.zeros_like(layout_opt.yaw_angles)) +fmodel.run() +base_aep = fmodel.get_farm_AEP() / 1e6 +fmodel.set(layout_x=sol[0], layout_y=sol[1], yaw_angles=layout_opt.yaw_angles) +fmodel.run() +opt_aep = fmodel.get_farm_AEP() / 1e6 + +percent_gain = 100 * (opt_aep - base_aep) / base_aep + +# Print and plot the results +print(f"Optimal layout: {sol}") +print( + f"Optimal layout improves AEP by {percent_gain:.1f}% " + f"from {base_aep:.1f} MWh to {opt_aep:.1f} MWh" +) +layout_opt.plot_layout_opt_results() +ax = plt.gca() +fig = plt.gcf() +sm = ax.tricontourf(x_locs, y_locs, speed_multipliers[0], cmap="coolwarm") +fig.colorbar(sm, ax=ax, label="Speed multiplier") +ax.legend(["Initial layout", "Optimized layout", "Optimization boundary"]) +ax.set_title("Geometric yaw enabled") + +print( + "Turbine geometric yaw angles for wind direction {0:.2f}".format(wind_directions[1]) + + " and wind speed {0:.2f} m/s:".format(wind_speeds[0]), + f"{layout_opt.yaw_angles[1, :]}", +) + +plt.show() diff --git a/examples/examples_multidim/001_multi_dimensional_cp_ct.py b/examples/examples_multidim/001_multi_dimensional_cp_ct.py new file mode 100644 index 000000000..b1bf0441b --- /dev/null +++ b/examples/examples_multidim/001_multi_dimensional_cp_ct.py @@ -0,0 +1,105 @@ +"""Example: Multi-dimensional Cp/Ct data +This example creates a FLORIS instance and: +1) Makes a two-turbine layout +2) Demonstrates single ws/wd simulations +3) Demonstrates multiple ws/wd simulations + +with the modification of using a turbine definition that has a multi-dimensional Cp/Ct table. + +In the input file `gch_multi_dim_cp_ct.yaml`, the turbine_type points to a turbine definition, +iea_15MW_floating_multi_dim_cp_ct.yaml located in the turbine_library, +that supplies a multi-dimensional Cp/Ct data file in the form of a .csv file. This .csv file +contains two additional conditions to define Cp/Ct values for: Tp for wave period, and Hs for wave +height. For every combination of Tp and Hs defined, a Cp/Ct/Wind speed table of values is also +defined. It is required for this .csv file to have the last 3 columns be ws, Cp, and Ct. In order +for this table to be used, the flag 'multi_dimensional_cp_ct' must be present and set to true in +the turbine definition. With this flag enabled, the solver will down-select to use the +interpolant defined at the closest conditions. The user must supply these conditions in the +main input file under the 'flow_field' section, e.g.: + +NOTE: The multi-dimensional Cp/Ct data used in this example is fictional for the purposes of +facilitating this example. The Cp/Ct values for the different wave conditions are scaled +values of the original Cp/Ct data for the IEA 15MW turbine. + +flow_field: + multidim_conditions: + Tp: 2.5 + Hs: 3.01 + +The solver will then use the nearest-neighbor interpolant. These conditions are currently global +and used to select the interpolant at each turbine. + +Also note in the example below that there is a specific method for computing powers when +using turbines with multi-dimensional Cp/Ct data under FlorisModel, called +'get_turbine_powers_multidim'. The normal 'get_turbine_powers' method will not work. +""" + +import numpy as np + +from floris import FlorisModel + + +# Initialize FLORIS with the given input file. +fmodel = FlorisModel("../inputs/gch_multi_dim_cp_ct.yaml") + +# Convert to a simple two turbine layout +fmodel.set(layout_x=[0.0, 500.0], layout_y=[0.0, 0.0]) + +# Single wind speed and wind direction +print("\n========================= Single Wind Direction and Wind Speed =========================") + +# Get the turbine powers assuming 1 wind speed and 1 wind direction +fmodel.set(wind_directions=[270.0], wind_speeds=[8.0], turbulence_intensities=[0.06]) + +# Set the yaw angles to 0 +yaw_angles = np.zeros([1, 2]) # 1 wind direction and wind speed, 2 turbines +fmodel.set(yaw_angles=yaw_angles) + +# Calculate +fmodel.run() + +# Get the turbine powers +turbine_powers = fmodel.get_turbine_powers() / 1000.0 +print("The turbine power matrix should be of dimensions 1 findex X 2 Turbines") +print(turbine_powers) +print("Shape: ", turbine_powers.shape) + +# Single wind speed and multiple wind directions +print("\n========================= Single Wind Direction and Multiple Wind Speeds ===============") + +wind_speeds = np.array([8.0, 9.0, 10.0]) +wind_directions = np.array([270.0, 270.0, 270.0]) +turbulence_intensities = np.array([0.06, 0.06, 0.06]) + +yaw_angles = np.zeros([3, 2]) # 3 wind directions/ speeds, 2 turbines +fmodel.set( + wind_speeds=wind_speeds, + wind_directions=wind_directions, + turbulence_intensities=turbulence_intensities, + yaw_angles=yaw_angles, +) +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() / 1000.0 +print("The turbine power matrix should be of dimensions 3 findex X 2 Turbines") +print(turbine_powers) +print("Shape: ", turbine_powers.shape) + +# Multiple wind speeds and multiple wind directions +print("\n========================= Multiple Wind Directions and Multiple Wind Speeds ============") + +wind_speeds = np.tile([8.0, 9.0, 10.0], 3) +wind_directions = np.repeat([260.0, 270.0, 280.0], 3) +turbulence_intensities = 0.06 * np.ones_like(wind_speeds) + +yaw_angles = np.zeros([9, 2]) # 9 wind directions/ speeds, 2 turbines +fmodel.set( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + turbulence_intensities=turbulence_intensities, + yaw_angles=yaw_angles, +) +fmodel.run() +turbine_powers = fmodel.get_turbine_powers() / 1000.0 +print("The turbine power matrix should be of dimensions 9 WD/WS X 2 Turbines") +print(turbine_powers) +print("Shape: ", turbine_powers.shape) diff --git a/examples/examples_multidim/002_multi_dimensional_cp_ct_2Hs.py b/examples/examples_multidim/002_multi_dimensional_cp_ct_2Hs.py new file mode 100644 index 000000000..8cf206f07 --- /dev/null +++ b/examples/examples_multidim/002_multi_dimensional_cp_ct_2Hs.py @@ -0,0 +1,65 @@ +"""Example: Multi-dimensional Cp/Ct with 2 Hs values +This example follows the previous example but shows the effect of changing the Hs setting. + +NOTE: The multi-dimensional Cp/Ct data used in this example is fictional for the purposes of +facilitating this example. The Cp/Ct values for the different wave conditions are scaled +values of the original Cp/Ct data for the IEA 15MW turbine. +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel, TimeSeries + + +# Initialize FLORIS with the given input file. +fmodel = FlorisModel("../inputs/gch_multi_dim_cp_ct.yaml") + +# Make a second Floris instance with a different setting for Hs. +# Note the multi-cp-ct file (iea_15MW_multi_dim_Tp_Hs.csv) +# for the turbine model iea_15MW_floating_multi_dim_cp_ct.yaml +# Defines Hs at 1 and 5. +# The value in gch_multi_dim_cp_ct.yaml is 3.01 which will map +# to 5 as the nearer value, so we set the other case to 1 +# for contrast. +fmodel_dict_mod = fmodel.core.as_dict() +fmodel_dict_mod["flow_field"]["multidim_conditions"]["Hs"] = 1.0 +fmodel_hs_1 = FlorisModel(fmodel_dict_mod) + +# Set both cases to 3 turbine layout +fmodel.set(layout_x=[0.0, 500.0, 1000.0], layout_y=[0.0, 0.0, 0.0]) +fmodel_hs_1.set(layout_x=[0.0, 500.0, 1000.0], layout_y=[0.0, 0.0, 0.0]) + +# Use a sweep of wind speeds +wind_speeds = np.arange(5, 20, 1.0) +time_series = TimeSeries( + wind_directions=270.0, wind_speeds=wind_speeds, turbulence_intensities=0.06 +) +fmodel.set(wind_data=time_series) +fmodel_hs_1.set(wind_data=time_series) + +# Calculate wakes with baseline yaw +fmodel.run() +fmodel_hs_1.run() + +# Collect the turbine powers in kW +turbine_powers = fmodel.get_turbine_powers() / 1000.0 +turbine_powers_hs_1 = fmodel_hs_1.get_turbine_powers() / 1000.0 + +# Plot the power in each case and the difference in power +fig, axarr = plt.subplots(1, 3, sharex=True, figsize=(12, 4)) + +for t_idx in range(3): + ax = axarr[t_idx] + ax.plot(wind_speeds, turbine_powers[:, t_idx], color="k", label="Hs=3.1 (5)") + ax.plot(wind_speeds, turbine_powers_hs_1[:, t_idx], color="r", label="Hs=1.0") + ax.grid(True) + ax.set_xlabel("Wind Speed (m/s)") + ax.set_title(f"Turbine {t_idx}") + +axarr[0].set_ylabel("Power (kW)") +axarr[0].legend() +fig.suptitle("Power of each turbine") + +plt.show() diff --git a/examples/examples_turbine/001_check_turbine.py b/examples/examples_turbine/001_check_turbine.py new file mode 100644 index 000000000..7291ca60c --- /dev/null +++ b/examples/examples_turbine/001_check_turbine.py @@ -0,0 +1,122 @@ +"""Example: Check turbine power curves + +For each turbine in the turbine library, make a small figure showing that its power +curve and power loss to yaw are reasonable and reasonably smooth +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel + + +ws_array = np.arange(0.1, 30, 0.2) +wd_array = 270.0 * np.ones_like(ws_array) +turbulence_intensities = 0.06 * np.ones_like(ws_array) +yaw_angles = np.linspace(-30, 30, 60) +wind_speed_to_test_yaw = 11 + +# Grab the gch model +fmodel = FlorisModel("../inputs/gch.yaml") + +# Make one turbine simulation +fmodel.set(layout_x=[0], layout_y=[0]) + +# Apply wind directions and wind speeds +fmodel.set( + wind_speeds=ws_array, wind_directions=wd_array, turbulence_intensities=turbulence_intensities +) + +# Get a list of available turbine models provided through FLORIS, and remove +# multi-dimensional Cp/Ct turbine definitions as they require different handling +turbines = [ + t.stem + for t in fmodel.core.farm.internal_turbine_library.iterdir() + if t.suffix == ".yaml" and ("multi_dim" not in t.stem) +] + +# Declare a set of figures for comparing cp and ct across models +fig_pow_ct, axarr_pow_ct = plt.subplots(2, 1, sharex=True, figsize=(10, 10)) + +# For each turbine model available plot the basic info +for t in turbines: + # Set t as the turbine + fmodel.set(turbine_type=[t]) + + # Since we are changing the turbine type, make a matching change to the reference wind height + fmodel.assign_hub_height_to_ref_height() + + # Plot power and ct onto the fig_pow_ct plot + axarr_pow_ct[0].plot( + fmodel.core.farm.turbine_map[0].power_thrust_table["wind_speed"], + fmodel.core.farm.turbine_map[0].power_thrust_table["power"], + label=t, + ) + axarr_pow_ct[0].grid(True) + axarr_pow_ct[0].legend() + axarr_pow_ct[0].set_ylabel("Power (kW)") + axarr_pow_ct[1].plot( + fmodel.core.farm.turbine_map[0].power_thrust_table["wind_speed"], + fmodel.core.farm.turbine_map[0].power_thrust_table["thrust_coefficient"], + label=t, + ) + axarr_pow_ct[1].grid(True) + axarr_pow_ct[1].legend() + axarr_pow_ct[1].set_ylabel("Ct (-)") + axarr_pow_ct[1].set_xlabel("Wind Speed (m/s)") + + # Create a figure + fig, axarr = plt.subplots(1, 2, figsize=(10, 5)) + + # Try a few density + for density in [1.15, 1.225, 1.3]: + fmodel.set(air_density=density) + + # POWER CURVE + ax = axarr[0] + fmodel.set( + wind_speeds=ws_array, + wind_directions=wd_array, + turbulence_intensities=turbulence_intensities, + ) + fmodel.run() + turbine_powers = fmodel.get_turbine_powers().flatten() / 1e3 + if density == 1.225: + ax.plot(ws_array, turbine_powers, label="Air Density = %.3f" % density, lw=2, color="k") + else: + ax.plot(ws_array, turbine_powers, label="Air Density = %.3f" % density, lw=1) + ax.grid(True) + ax.legend() + ax.set_xlabel("Wind Speed (m/s)") + ax.set_ylabel("Power (kW)") + + # Power loss to yaw, try a range of yaw angles + ax = axarr[1] + + fmodel.set( + wind_speeds=[wind_speed_to_test_yaw], + wind_directions=[270.0], + turbulence_intensities=[0.06], + ) + yaw_result = [] + for yaw in yaw_angles: + fmodel.set(yaw_angles=np.array([[yaw]])) + fmodel.run() + turbine_powers = fmodel.get_turbine_powers().flatten() / 1e3 + yaw_result.append(turbine_powers[0]) + if density == 1.225: + ax.plot(yaw_angles, yaw_result, label="Air Density = %.3f" % density, lw=2, color="k") + else: + ax.plot(yaw_angles, yaw_result, label="Air Density = %.3f" % density, lw=1) + # ax.plot(yaw_angles,yaw_result,label='Air Density = %.3f' % density) + ax.grid(True) + ax.legend() + ax.set_xlabel("Yaw Error (deg)") + ax.set_ylabel("Power (kW)") + ax.set_title("Wind Speed = %.1f" % wind_speed_to_test_yaw) + + # Give a suptitle + fig.suptitle(t) + +plt.show() diff --git a/examples/examples_turbine/002_multiple_turbine_types.py b/examples/examples_turbine/002_multiple_turbine_types.py new file mode 100644 index 000000000..b945d5a0a --- /dev/null +++ b/examples/examples_turbine/002_multiple_turbine_types.py @@ -0,0 +1,34 @@ +"""Example: Multiple turbine types + +This example uses an input file where multiple turbine types are defined. +The first two turbines are the NREL 5MW, and the third turbine is the IEA 10MW. +""" + + +import matplotlib.pyplot as plt + +import floris.flow_visualization as flowviz +from floris import FlorisModel + + +# Initialize FLORIS with the given input file. +# For basic usage, FlorisModel provides a simplified and expressive +# entry point to the simulation routines. +fmodel = FlorisModel("../inputs/gch_multiple_turbine_types.yaml") + +# Using the FlorisModel functions for generating plots, run FLORIS +# and extract 2D planes of data. +horizontal_plane = fmodel.calculate_horizontal_plane(x_resolution=200, y_resolution=100, height=90) +y_plane = fmodel.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) +cross_plane = fmodel.calculate_cross_plane( + y_resolution=100, z_resolution=100, downstream_dist=500.0 +) + +# Create the plots +fig, ax_list = plt.subplots(3, 1, figsize=(10, 8)) +ax_list = ax_list.flatten() +flowviz.visualize_cut_plane(horizontal_plane, ax=ax_list[0], title="Horizontal") +flowviz.visualize_cut_plane(y_plane, ax=ax_list[1], title="Streamwise profile") +flowviz.visualize_cut_plane(cross_plane, ax=ax_list[2], title="Spanwise profile") + +plt.show() diff --git a/examples/examples_turbine/003_specify_turbine_power_curve.py b/examples/examples_turbine/003_specify_turbine_power_curve.py new file mode 100644 index 000000000..1c1b59707 --- /dev/null +++ b/examples/examples_turbine/003_specify_turbine_power_curve.py @@ -0,0 +1,81 @@ +"""Example: Specify turbine power curve + +This example demonstrates how to specify a turbine model based on a power +and thrust curve for the wind turbine, as well as possible physical parameters +(which default to the parameters of the NREL 5MW reference turbine). + +Note that it is also possible to have a .yaml created, if the file_path +argument to build_turbine_dict is set. +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import FlorisModel +from floris.turbine_library import build_cosine_loss_turbine_dict + + +# Generate an example turbine power and thrust curve for use in the FLORIS model +powers_orig = np.array([0, 30, 200, 500, 1000, 2000, 4000, 4000, 4000, 4000, 4000]) +wind_speeds = np.array([0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]) +power_coeffs = powers_orig[1:] / (0.5 * 126.0**2 * np.pi / 4 * 1.225 * wind_speeds[1:] ** 3) +turbine_data_dict = { + "wind_speed": list(wind_speeds), + "power_coefficient": [0] + list(power_coeffs), + "thrust_coefficient": [0, 0.9, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.25, 0.2], +} + +turbine_dict = build_cosine_loss_turbine_dict( + turbine_data_dict, + "example_turbine", + file_name=None, + generator_efficiency=1, + hub_height=90, + cosine_loss_exponent_yaw=1.88, + cosine_loss_exponent_tilt=1.88, + rotor_diameter=126, + TSR=8, + ref_air_density=1.225, + ref_tilt=5, +) + +fmodel = FlorisModel("../inputs/gch.yaml") +wind_speeds = np.linspace(1, 15, 100) +wind_directions = 270 * np.ones_like(wind_speeds) +turbulence_intensities = 0.06 * np.ones_like(wind_speeds) +# Replace the turbine(s) in the FLORIS model with the created one +fmodel.set( + layout_x=[0], + layout_y=[0], + wind_directions=wind_directions, + wind_speeds=wind_speeds, + turbulence_intensities=turbulence_intensities, + turbine_type=[turbine_dict], +) +fmodel.run() + +powers = fmodel.get_farm_power() + +specified_powers = ( + np.array(turbine_data_dict["power_coefficient"]) + * 0.5 + * turbine_dict["power_thrust_table"]["ref_air_density"] + * turbine_dict["rotor_diameter"] ** 2 + * np.pi + / 4 + * np.array(turbine_data_dict["wind_speed"]) ** 3 +) / 1000 + +fig, ax = plt.subplots(1, 1, sharex=True) + +ax.scatter(wind_speeds, powers / 1000, color="C0", s=5, label="Test points") +ax.scatter( + turbine_data_dict["wind_speed"], specified_powers, color="red", s=20, label="Specified points" +) + +ax.grid() +ax.set_xlabel("Wind speed [m/s]") +ax.set_ylabel("Power [kW]") +ax.legend() + +plt.show() diff --git a/examples/examples_uncertain/001_uncertain_model_params.py b/examples/examples_uncertain/001_uncertain_model_params.py new file mode 100644 index 000000000..a542db49e --- /dev/null +++ b/examples/examples_uncertain/001_uncertain_model_params.py @@ -0,0 +1,172 @@ +"""Example: Uncertain Model Parameters + +This example demonstrates how to use the UncertainFlorisModel class to +analyze the impact of uncertain wind direction on power results. +""" + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, + UncertainFlorisModel, +) + + +# Instantiate FlorisModel for comparison +fmodel = FlorisModel("../inputs/gch.yaml") # GCH model + +################################################ +# Resolution parameters +################################################ + +# The resolution parameters are used to define the precision of the wind direction, +# wind speed, and turbulence intensity and control parameters. All the inputs +# passed into the UncertainFlorisModel class are rounded to this resolution. Then +# following expansion, non-unique cases are removed. Here we apply the default +# resolution parameters. +wd_resolution = 1.0 # Degree +ws_resolution = 1.0 # m/s +ti_resolution = 0.01 # Decimal fraction +yaw_resolution = 1.0 # Degree +power_setpoint_resolution = 100.0 # kW + +################################################ +# wd_sample_points +################################################ + +# The wind direction sample points (wd_sample_points) parameter is used to define +# the number of points to sample the wind direction uncertainty. For example, +# if the the single condition to analyze is 270 degrees, and the wd_sample_points +# is [-2, -1, 0, 1 ,2], then the cases to be run and weighted +# will be 268, 269, 270, 271, 272. If not supplied default is +# [-2 * wd_std, -1 * wd_std, 0, wd_std, 2 * wd_std] +wd_sample_points = [-6, -3, 0, 3, 6] + + +################################################ +# WT_STD +################################################ + +# The wind direction standard deviation (wd_std) parameter is the primary input +# to the UncertainFlorisModel class. This parameter is used to weight the points +# following expansion by the wd_sample_points. The smaller the value, the closer +# the weighting will be to the nominal case. +wd_std = 3 # Default is 3 degrees + +################################################ +# Verbosity +################################################ + +# Setting verbose = True will print out the sizes of teh cases run +verbose = True + +################################################ +# Define the UncertainFlorisModel +################################################ +print('*** Instantiating UncertainFlorisModel ***') +ufmodel = UncertainFlorisModel("../inputs/gch.yaml", + wd_resolution=wd_resolution, + ws_resolution=ws_resolution, + ti_resolution=ti_resolution, + yaw_resolution=yaw_resolution, + power_setpoint_resolution=power_setpoint_resolution, + wd_std=wd_std, + wd_sample_points=wd_sample_points, + verbose=verbose) + + +################################################ +# Run the models +################################################ + +# Define an inflow where wind direction is swept while +# wind speed and turbulence intensity are held constant +wind_directions = np.arange(240.0, 300.0, 1.0) +time_series = TimeSeries( + wind_directions=wind_directions, + wind_speeds=8.0, + turbulence_intensities=0.06, +) + +# Define a two turbine farm and apply the inflow +D = 126.0 +layout_x = np.array([0, D * 6]) +layout_y = [0, 0] + +fmodel.set( + layout_x=layout_x, + layout_y=layout_y, + wind_data=time_series, +) +print('*** Setting UncertainFlorisModel to 60 Wind Direction Inflow ***') +ufmodel.set( + layout_x=layout_x, + layout_y=layout_y, + wind_data=time_series, +) + +# Run both models +fmodel.run() +ufmodel.run() + + +# Collect the nominal and uncertain farm power +turbine_powers_nom = fmodel.get_turbine_powers() / 1e3 +turbine_powers_unc = ufmodel.get_turbine_powers() / 1e3 + +farm_powers_nom = fmodel.get_farm_power() / 1e3 +farm_powers_unc_3 = ufmodel.get_farm_power() / 1e3 + + +# Plot results +fig, axarr = plt.subplots(1, 3, figsize=(15, 5)) +ax = axarr[0] +ax.plot(wind_directions, turbine_powers_nom[:, 0].flatten(), color="k", label="Nominal power") +ax.plot( + wind_directions, + turbine_powers_unc[:, 0].flatten(), + color="r", + label="Power with uncertainty", +) + +ax.grid(True) +ax.legend() +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Power (kW)") +ax.set_title("Upstream Turbine") + +ax = axarr[1] +ax.plot(wind_directions, turbine_powers_nom[:, 1].flatten(), color="k", label="Nominal power") +ax.plot( + wind_directions, + turbine_powers_unc[:, 1].flatten(), + color="r", + label="Power with uncertainty", +) + +ax.set_title("Downstream Turbine") +ax.grid(True) +ax.legend() +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Power (kW)") + +ax = axarr[2] +ax.plot(wind_directions, farm_powers_nom.flatten(), color="k", label="Nominal farm power") +ax.plot( + wind_directions, + farm_powers_unc_3.flatten(), + color="r", + label="Farm power with uncertainty", +) + + +ax.set_title("Farm Power") +ax.grid(True) +ax.legend() +ax.set_xlabel("Wind Direction (deg)") +ax.set_ylabel("Power (kW)") + + +plt.show() diff --git a/examples/examples_uncertain/002_approx_floris_model.py b/examples/examples_uncertain/002_approx_floris_model.py new file mode 100644 index 000000000..f876d8fa5 --- /dev/null +++ b/examples/examples_uncertain/002_approx_floris_model.py @@ -0,0 +1,73 @@ +"""Example: Approximate Model Parameters + +This example demonstrates how to use the UncertainFlorisModel class to +analyze the impact of uncertain wind direction on power results. +""" + +from time import perf_counter as timerpc + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + ApproxFlorisModel, + FlorisModel, + TimeSeries, +) + + +# Generate time series data using a random walk on wind speeds with constant wind direction +N = 5000 +n_turbines = 25 + +# Random walk on wind speed with values between 5 and 20 m/s +ws = np.ones(N) * 10 +for i in range(1, N): + ws[i] = ws[i - 1] + np.random.normal(0, 0.25) + if ws[i] < 5: + ws[i] = 5 + if ws[i] > 20: + ws[i] = 20 + +time_series = TimeSeries( + wind_directions=270., + wind_speeds=ws, + turbulence_intensities=0.06) + +# Instantiate a FlorisModel and an ApproxFlorisModel +fmodel = FlorisModel("../inputs/gch.yaml") +afmodel = ApproxFlorisModel("../inputs/gch.yaml", ws_resolution=0.5) + + +# Set both models to an n_turbine layout and use the above time series +layout_x = np.array([i*500 for i in range(n_turbines)]) +layout_y = np.zeros(n_turbines) +fmodel.set(layout_x=layout_x, layout_y=layout_y, wind_data=time_series) +afmodel.set(layout_x=layout_x, layout_y=layout_y, wind_data=time_series) + +# Now time both runs to show the speedup from approximating the wind speed +start = timerpc() +fmodel.run() +end = timerpc() +print(f"FlorisModel run time: {end - start} s") + +start = timerpc() +afmodel.run() +end = timerpc() +print(f"ApproxFlorisModel run time: {end - start} s") + +# Plot the power output from both models +fig, ax = plt.subplots() +ax.plot(fmodel.get_farm_power(), label="FlorisModel") +ax.plot(afmodel.get_farm_power(), label="ApproxFlorisModel") +ax.set_xlabel("Time Step") +ax.set_ylabel("Farm Power [W]") +ax.legend() +ax.grid(True) + + +# Compare the expected power results +print(f"Expected power from FlorisModel: {fmodel.get_expected_farm_power()/1E6:0.2f} MW") +print(f"Expected power from ApproxFlorisModel: {afmodel.get_expected_farm_power()/1E6:0.2f} MW") + +plt.show() diff --git a/examples/examples_visualizations/001_layout_visualizations.py b/examples/examples_visualizations/001_layout_visualizations.py new file mode 100644 index 000000000..9c2641e76 --- /dev/null +++ b/examples/examples_visualizations/001_layout_visualizations.py @@ -0,0 +1,89 @@ +"""Example: Layout Visualizations + +Demonstrate the use of all the functions within the layout_visualization module + +""" + +import matplotlib.pyplot as plt +import numpy as np + +import floris.layout_visualization as layoutviz +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane + + +# Create the plotting objects using matplotlib +fig, axarr = plt.subplots(3, 3, figsize=(16, 10), sharex=False) +axarr = axarr.flatten() + +MIN_WS = 1.0 +MAX_WS = 8.0 + +# Initialize FLORIS with the given input file. +fmodel = FlorisModel("../inputs/gch.yaml") + +# Change to 5-turbine layout with a wind direction from northwest +fmodel.set( + layout_x=[0, 0, 1000, 1000, 1000], layout_y=[0, 500, 0, 500, 1000], wind_directions=[300] +) + +# Plot 1: Visualize the flow +ax = axarr[0] +# Plot a horizatonal slice of the initial configuration +horizontal_plane = fmodel.calculate_horizontal_plane(height=90.0) +visualize_cut_plane( + horizontal_plane, + ax=ax, + min_speed=MIN_WS, + max_speed=MAX_WS, +) +# Plot the turbine points, setting the color to white +layoutviz.plot_turbine_points(fmodel, ax=ax, plotting_dict={"color": "w"}) +ax.set_title("Flow visualization and turbine points") + +# Plot 2: Show a particular flow case +ax = axarr[1] +turbine_names = [f"T{i}" for i in [10, 11, 12, 13, 22]] +layoutviz.plot_turbine_points(fmodel, ax=ax) +layoutviz.plot_turbine_labels( + fmodel, ax=ax, turbine_names=turbine_names, show_bbox=True, bbox_dict={"facecolor": "r"} +) +ax.set_title("Show turbine names with a red bounding box") + + +# Plot 2: Show turbine rotors on flow +ax = axarr[2] +fmodel.set(yaw_angles=np.array([[0., 30., 0., 0., 0.]])) +horizontal_plane = fmodel.calculate_horizontal_plane(height=90.0) +visualize_cut_plane(horizontal_plane, ax=ax, min_speed=MIN_WS, max_speed=MAX_WS) +layoutviz.plot_turbine_rotors(fmodel, ax=ax, yaw_angles=np.array([[0.0, 30.0, 0.0, 0.0, 0.0]])) +ax.set_title("Flow visualization with yawed turbine") + +# Plot 3: Show the layout, including wake directions +ax = axarr[3] +layoutviz.plot_turbine_points(fmodel, ax=ax) +layoutviz.plot_turbine_labels(fmodel, ax=ax, turbine_names=turbine_names) +layoutviz.plot_waking_directions(fmodel, ax=ax) +ax.set_title("Show turbine names and wake direction") + +# Plot 4: Plot a subset of the layout, and limit directions less than 7D +ax = axarr[4] +layoutviz.plot_turbine_points(fmodel, ax=ax, turbine_indices=[0, 1, 2, 3]) +layoutviz.plot_turbine_labels( + fmodel, ax=ax, turbine_names=turbine_names, turbine_indices=[0, 1, 2, 3] +) +layoutviz.plot_waking_directions(fmodel, ax=ax, turbine_indices=[0, 1, 2, 3], limit_dist_D=7) +ax.set_title("Plot a subset and limit wake line distance") + +# Plot with a shaded region +ax = axarr[5] +layoutviz.plot_turbine_points(fmodel, ax=ax) +layoutviz.shade_region(np.array([[0, 0], [300, 0], [300, 1000], [0, 700]]), ax=ax) +ax.set_title("Plot with a shaded region") + +# Change hub heights and plot as a proxy for terrain +ax = axarr[6] +fmodel.core.farm.hub_heights = np.array([110, 90, 100, 100, 95]) +layoutviz.plot_farm_terrain(fmodel, ax=ax) + +plt.show() diff --git a/examples/examples_visualizations/002_visualize_y_cut_plane.py b/examples/examples_visualizations/002_visualize_y_cut_plane.py new file mode 100644 index 000000000..7e9ef8cd4 --- /dev/null +++ b/examples/examples_visualizations/002_visualize_y_cut_plane.py @@ -0,0 +1,33 @@ +"""Example: Visualize y cut plane + +Demonstrate visualizing a plane cut vertically through the flow field along the wind direction. + +""" + +import matplotlib.pyplot as plt + +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane + + +fmodel = FlorisModel("../inputs/gch.yaml") + +# Set a 3 turbine layout with wind direction along the row +fmodel.set( + layout_x=[0, 500, 1000], + layout_y=[0, 0, 0], + wind_directions=[270], + wind_speeds=[8], + turbulence_intensities=[0.06], +) + +# Collect the yplane +y_plane = fmodel.calculate_y_plane(x_resolution=200, z_resolution=100, crossstream_dist=0.0) + +# Plot the flow field +fig, ax = plt.subplots(figsize=(10, 4)) +visualize_cut_plane( + y_plane, ax=ax, min_speed=3, max_speed=9, label_contours=True, title="Y Cut Plane" +) + +plt.show() diff --git a/examples/examples_visualizations/003_visualize_cross_plane.py b/examples/examples_visualizations/003_visualize_cross_plane.py new file mode 100644 index 000000000..1aa00006e --- /dev/null +++ b/examples/examples_visualizations/003_visualize_cross_plane.py @@ -0,0 +1,37 @@ +"""Example: Visualize cross plane + +Demonstrate visualizing a plane cut vertically through the flow field across the wind direction. + +""" + +import matplotlib.pyplot as plt + +from floris import FlorisModel +from floris.flow_visualization import visualize_cut_plane + + +fmodel = FlorisModel("../inputs/gch.yaml") + +# Set a 1 turbine layout +fmodel.set( + layout_x=[0], + layout_y=[0], + wind_directions=[270], + wind_speeds=[8], + turbulence_intensities=[0.06], +) + +# Collect the cross plane downstream of the turbine +cross_plane = fmodel.calculate_cross_plane( + y_resolution=100, + z_resolution=100, + downstream_dist=500.0, +) + +# Plot the flow field +fig, ax = plt.subplots(figsize=(4, 6)) +visualize_cut_plane( + cross_plane, ax=ax, min_speed=3, max_speed=9, label_contours=True, title="Cross Plane" +) + +plt.show() diff --git a/examples/examples_visualizations/004_visualize_rotor_values.py b/examples/examples_visualizations/004_visualize_rotor_values.py new file mode 100644 index 000000000..e1d40c14b --- /dev/null +++ b/examples/examples_visualizations/004_visualize_rotor_values.py @@ -0,0 +1,33 @@ +"""Example: Visualize rotor velocities + +Demonstrate visualizing the flow velocities at the rotor using plot_rotor_values + +""" + +import matplotlib.pyplot as plt + +import floris.flow_visualization as flowviz +from floris import FlorisModel + + +fmodel = FlorisModel("../inputs/gch.yaml") + +# Set a 2 turbine layout +fmodel.set( + layout_x=[0, 500], + layout_y=[0, 0], + wind_directions=[270], + wind_speeds=[8], + turbulence_intensities=[0.06], +) + +# Run the model +fmodel.run() + +# Plot the values at each rotor +fig, axes, _, _ = flowviz.plot_rotor_values( + fmodel.core.flow_field.u, findex=0, n_rows=1, n_cols=2, return_fig_objects=True +) +fig.suptitle("Rotor Plane Visualization, Original Resolution") + +plt.show() diff --git a/examples/examples_visualizations/005_visualize_flow_by_sweeping_turbines.py b/examples/examples_visualizations/005_visualize_flow_by_sweeping_turbines.py new file mode 100644 index 000000000..3614e74bc --- /dev/null +++ b/examples/examples_visualizations/005_visualize_flow_by_sweeping_turbines.py @@ -0,0 +1,43 @@ +"""Example: Visualize flow by sweeping turbines + +Demonstrate the use calculate_horizontal_plane_with_turbines + +""" + +import matplotlib.pyplot as plt + +import floris.flow_visualization as flowviz +from floris import FlorisModel + + +fmodel = FlorisModel("../inputs/gch.yaml") + +# # Some wake models may not yet have a visualization method included, for these cases can use +# # a slower version which scans a turbine model to produce the horizontal flow + + +# Set a 2 turbine layout +fmodel.set( + layout_x=[0, 500], + layout_y=[0, 0], + wind_directions=[270], + wind_speeds=[8], + turbulence_intensities=[0.06], +) + +horizontal_plane_scan_turbine = flowviz.calculate_horizontal_plane_with_turbines( + fmodel, + x_resolution=20, + y_resolution=10, +) + +fig, ax = plt.subplots(figsize=(10, 4)) +flowviz.visualize_cut_plane( + horizontal_plane_scan_turbine, + ax=ax, + label_contours=True, + title="Horizontal (coarse turbine scan method)", +) + + +plt.show() diff --git a/examples/examples_wind_data/001_wind_data_comparisons.py b/examples/examples_wind_data/001_wind_data_comparisons.py new file mode 100644 index 000000000..34009eade --- /dev/null +++ b/examples/examples_wind_data/001_wind_data_comparisons.py @@ -0,0 +1,114 @@ +"""Example: Wind Data Comparisons + +In this example, a random time series of wind speeds, wind directions, turbulence +intensities, and values is generated. Value represents the value of the power +generated at each time step or wind condition (e.g., the price of electricity). This +can then be used in later optimization methods to optimize for total value instead of +energy. This time series is then used to instantiate a TimeSeries object. The TimeSeries +object is then used to instantiate a WindRose object and WindTIRose object based on the +same data. The three objects are then each used to drive a FLORIS model of a simple +two-turbine wind farm. The annual energy production (AEP) and annual value production +(AVP) outputs are then compared and printed to the console. + +""" + + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + FlorisModel, + TimeSeries, + WindRose, +) +from floris.utilities import wrap_360 + + +# Generate a random time series of wind speeds, wind directions, turbulence +# intensities, and values. In this case let's treat value as the dollars per MWh. +N = 500 +wd_array = wrap_360(270 * np.ones(N) + np.random.randn(N) * 20) +ws_array = np.clip(8 * np.ones(N) + np.random.randn(N) * 8, 3, 50) +ti_array = np.clip(0.1 * np.ones(N) + np.random.randn(N) * 0.05, 0, 0.25) +value_array = np.clip(25 * np.ones(N) + np.random.randn(N) * 10, 0, 100) + +fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(7, 6)) +ax = axarr[0] +ax.plot(wd_array, marker=".", ls="None") +ax.set_ylabel("Wind Direction") +ax = axarr[1] +ax.plot(ws_array, marker=".", ls="None") +ax.set_ylabel("Wind Speed") +ax = axarr[2] +ax.plot(ti_array, marker=".", ls="None") +ax.set_ylabel("Turbulence Intensity") +ax = axarr[3] +ax.plot(value_array, marker=".", ls="None") +ax.set_ylabel("Value") + + +# Build the time series +time_series = TimeSeries(wd_array, ws_array, turbulence_intensities=ti_array, values=value_array) + +# Now build the wind rose +wind_rose = time_series.to_WindRose() + +# Plot the wind rose +fig, ax = plt.subplots(subplot_kw={"polar": True}) +wind_rose.plot(ax=ax,legend_kwargs={"title": "WS"}) +fig.suptitle("WindRose Plot") + +# Now build a wind rose with turbulence intensity +wind_ti_rose = time_series.to_WindTIRose() + +# Plot the wind rose with TI +fig, axs = plt.subplots(2, 1, figsize=(6,8), subplot_kw={"polar": True}) +wind_ti_rose.plot(ax=axs[0], wind_rose_var="ws",legend_kwargs={"title": "WS"}) +axs[0].set_title("Wind Direction and Wind Speed Frequencies") +wind_ti_rose.plot(ax=axs[1], wind_rose_var="ti",legend_kwargs={"title": "TI"}) +axs[1].set_title("Wind Direction and Turbulence Intensity Frequencies") +fig.suptitle("WindTIRose Plots") +plt.tight_layout() + +# Now set up a FLORIS model and initialize it using the time series and wind rose +fmodel = FlorisModel("../inputs/gch.yaml") +fmodel.set(layout_x=[0, 500.0], layout_y=[0.0, 0.0]) + +fmodel_time_series = fmodel.copy() +fmodel_wind_rose = fmodel.copy() +fmodel_wind_ti_rose = fmodel.copy() + +fmodel_time_series.set(wind_data=time_series) +fmodel_wind_rose.set(wind_data=wind_rose) +fmodel_wind_ti_rose.set(wind_data=wind_ti_rose) + +fmodel_time_series.run() +fmodel_wind_rose.run() +fmodel_wind_ti_rose.run() + +# Now, compute AEP using the FLORIS models initialized with the three types of +# WindData objects. The AEP values are very similar but not exactly the same +# because of the effects of binning in the wind roses. + +time_series_aep = fmodel_time_series.get_farm_AEP() +wind_rose_aep = fmodel_wind_rose.get_farm_AEP() +wind_ti_rose_aep = fmodel_wind_ti_rose.get_farm_AEP() + +print(f"AEP from TimeSeries {time_series_aep / 1e9:.2f} GWh") +print(f"AEP from WindRose {wind_rose_aep / 1e9:.2f} GWh") +print(f"AEP from WindTIRose {wind_ti_rose_aep / 1e9:.2f} GWh") + +# Now, compute annual value production (AVP) using the FLORIS models initialized +# with the three types of WindData objects. The AVP values are very similar but +# not exactly the same because of the effects of binning in the wind roses. + +time_series_avp = fmodel_time_series.get_farm_AVP() +wind_rose_avp = fmodel_wind_rose.get_farm_AVP() +wind_ti_rose_avp = fmodel_wind_ti_rose.get_farm_AVP() + +print(f"Annual Value Production (AVP) from TimeSeries {time_series_avp / 1e6:.2f} dollars") +print(f"AVP from WindRose {wind_rose_avp / 1e6:.2f} dollars") +print(f"AVP from WindTIRose {wind_ti_rose_avp / 1e6:.2f} dollars") + +plt.show() diff --git a/examples/examples_wind_data/002_generate_ti.py b/examples/examples_wind_data/002_generate_ti.py new file mode 100644 index 000000000..55bf09e4d --- /dev/null +++ b/examples/examples_wind_data/002_generate_ti.py @@ -0,0 +1,74 @@ +"""Example: Generate TI + +Demonstrate usage of TI generating and plotting functionality in the WindRose +and TimeSeries classes + +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + TimeSeries, + WindRose, +) + + +# Generate a random time series of wind speeds, wind directions and turbulence intensities +wind_directions = np.array([250, 260, 270]) +wind_speeds = np.array([5, 6, 7, 8, 9, 10]) +ti_table = 0.06 + +# Declare a WindRose object +wind_rose = WindRose(wind_directions=wind_directions, wind_speeds=wind_speeds, ti_table=ti_table) + + +# Define a custom function where TI = 1 / wind_speed +def custom_ti_func(wind_directions, wind_speeds): + return 1 / wind_speeds + + +wind_rose.assign_ti_using_wd_ws_function(custom_ti_func) + +fig, ax = plt.subplots() +wind_rose.plot_ti_over_ws(ax) +ax.set_title("Turbulence Intensity defined by custom function") + +# Now use the normal turbulence model approach from the IEC 61400-1 standard, +# wherein TI is defined as a function of wind speed: +# Iref is defined as the TI value at 15 m/s. Note that Iref = 0.07 is lower +# than the values of Iref used in the IEC standard, but produces TI values more +# in line with those typically used in FLORIS (TI=8.6% at 8 m/s). +Iref = 0.07 +wind_rose.assign_ti_using_IEC_method(Iref) +fig, ax = plt.subplots() +wind_rose.plot_ti_over_ws(ax) +ax.set_title(f"Turbulence Intensity defined by Iref = {Iref:0.2}") + + +# Demonstrate equivalent usage in time series +N = 100 +wind_directions = 270 * np.ones(N) +wind_speeds = np.linspace(5, 15, N) +turbulence_intensities = 0.06 * np.ones(N) +time_series = TimeSeries( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + turbulence_intensities=turbulence_intensities +) +time_series.assign_ti_using_IEC_method(Iref=Iref) + +fig, axarr = plt.subplots(2, 1, sharex=True, figsize=(7, 8)) +ax = axarr[0] +ax.plot(wind_speeds) +ax.set_ylabel("Wind Speeds (m/s)") +ax.grid(True) +ax = axarr[1] +ax.plot(time_series.turbulence_intensities) +ax.set_ylabel("Turbulence Intensity (-)") +ax.grid(True) +fig.suptitle("Generating TI in TimeSeries") + + +plt.show() diff --git a/examples/examples_wind_data/003_generate_value.py b/examples/examples_wind_data/003_generate_value.py new file mode 100644 index 000000000..af23c5522 --- /dev/null +++ b/examples/examples_wind_data/003_generate_value.py @@ -0,0 +1,81 @@ +"""Example: Generate value + +Demonstrate usage of value generating and plotting functionality in the WindRose +and TimeSeries classes. Value represents the value of the power or energy generated +at each time step or wind condition (e.g., the price of electricity in dollars/MWh). +This can then be used to compute the annual value production (AVP) instead of AEP, +or in later optimization methods to optimize for total value instead of energy. + +""" + + +import matplotlib.pyplot as plt +import numpy as np + +from floris import ( + TimeSeries, + WindRose, +) + + +# Generate a random time series of wind speeds, wind directions and turbulence intensities +wind_directions = np.array([250, 260, 270]) +wind_speeds = np.arange(3.0, 11.0, 1.0) +ti_table = 0.06 + +# Declare a WindRose object +wind_rose = WindRose(wind_directions=wind_directions, wind_speeds=wind_speeds, ti_table=ti_table) + + +# Define a custom function where value = 100 / wind_speed +def custom_value_func(wind_directions, wind_speeds): + return 100 / wind_speeds + + +wind_rose.assign_value_using_wd_ws_function(custom_value_func) + +fig, ax = plt.subplots() +wind_rose.plot_value_over_ws(ax) +ax.set_title("Value defined by custom function") + +# Now assign value using the provided assign_value_piecewise_linear method with the default +# settings. This method assigns value based on a linear piecewise function of wind speed +# (with two line segments). The default arguments produce a value vs. wind speed that +# approximates the normalized mean electricity price vs. wind speed curve for the SPP market +# in the U.S. for years 2018-2020 from figure 7 in "The value of wake steering wind farm flow +# control in US energy markets," Wind Energy Science, 2024. https://doi.org/10.5194/wes-9-219-2024. +wind_rose.assign_value_piecewise_linear( + value_zero_ws=1.425, + ws_knee=4.5, + slope_1=0.0, + slope_2=-0.135 +) +fig, ax = plt.subplots() +wind_rose.plot_value_over_ws(ax) +ax.set_title("Value defined by default piecewise linear function") + +# Demonstrate equivalent usage in time series +N = 100 +wind_directions = 270 * np.ones(N) +wind_speeds = np.linspace(3, 15, N) +turbulence_intensities = 0.06 * np.ones(N) +time_series = TimeSeries( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + turbulence_intensities=turbulence_intensities +) +time_series.assign_value_piecewise_linear() + +fig, axarr = plt.subplots(2, 1, sharex=True, figsize=(7, 8)) +ax = axarr[0] +ax.plot(wind_speeds) +ax.set_ylabel("Wind Speeds (m/s)") +ax.grid(True) +ax = axarr[1] +ax.plot(time_series.values) +ax.set_ylabel("Value (normalized price/MWh)") +ax.grid(True) +fig.suptitle("Generating value in TimeSeries") + + +plt.show() diff --git a/examples/inputs/cc.yaml b/examples/inputs/cc.yaml index 922fadd05..1935c004f 100644 --- a/examples/inputs/cc.yaml +++ b/examples/inputs/cc.yaml @@ -1,7 +1,7 @@ name: CC description: Three turbines using Cumulative Gauss Curl model -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -30,7 +30,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 # -1 is code for use the hub height - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -48,6 +49,7 @@ wake: enable_secondary_steering: true enable_yaw_added_recovery: true enable_transverse_velocities: true + enable_active_wake_mixing: false wake_deflection_parameters: gauss: diff --git a/examples/inputs/emgauss.yaml b/examples/inputs/emgauss.yaml index f984f421d..40f8fab8e 100644 --- a/examples/inputs/emgauss.yaml +++ b/examples/inputs/emgauss.yaml @@ -1,7 +1,7 @@ name: Emperical Gaussian description: Three turbines using emperical Gaussian model -floris_version: v3.x +floris_version: v4 logging: console: @@ -30,7 +30,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 # -1 is code for use the hub height - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -47,6 +48,7 @@ wake: enable_secondary_steering: false enable_yaw_added_recovery: true + enable_active_wake_mixing: false enable_transverse_velocities: false wake_deflection_parameters: @@ -65,7 +67,7 @@ wake: empirical_gauss: horizontal_deflection_gain_D: 3.0 vertical_deflection_gain_D: -1 - deflection_rate: 30 + deflection_rate: 22 mixing_gain_deflection: 0.0 yaw_added_mixing_gain: 0.0 diff --git a/examples/inputs/emgauss_helix.yaml b/examples/inputs/emgauss_helix.yaml new file mode 100644 index 000000000..48a6add0d --- /dev/null +++ b/examples/inputs/emgauss_helix.yaml @@ -0,0 +1,109 @@ + +name: Emperical Gaussian +description: Three turbines using empirical Gaussian model +floris_version: v4.0 + +logging: + console: + enable: true + level: WARNING + file: + enable: false + level: WARNING + +solver: + type: turbine_grid + turbine_grid_points: 3 + +farm: + layout_x: + - 0.0 + - 630.0 + - 1260.0 + layout_y: + - 0.0 + - 0.0 + - 0.0 + turbine_type: + - iea_15MW + +flow_field: + air_density: 1.225 + reference_wind_height: -1 # -1 is code for use the hub height + turbulence_intensities: + - 0.06 + wind_directions: + - 270.0 + wind_shear: 0.12 + wind_speeds: + - 8.0 + wind_veer: 0.0 + +wake: + model_strings: + combination_model: sosfs + deflection_model: empirical_gauss + turbulence_model: wake_induced_mixing + velocity_model: empirical_gauss + + enable_secondary_steering: false + enable_yaw_added_recovery: false + enable_active_wake_mixing: true + enable_transverse_velocities: false + + wake_deflection_parameters: + gauss: + ad: 0.0 + alpha: 0.58 + bd: 0.0 + beta: 0.077 + dm: 1.0 + ka: 0.38 + kb: 0.004 + jimenez: + ad: 0.0 + bd: 0.0 + kd: 0.05 + empirical_gauss: + horizontal_deflection_gain_D: 3.0 + vertical_deflection_gain_D: -1 + deflection_rate: 30 + mixing_gain_deflection: 0.0 + yaw_added_mixing_gain: 0.0 + + wake_velocity_parameters: + cc: + a_s: 0.179367259 + b_s: 0.0118889215 + c_s1: 0.0563691592 + c_s2: 0.13290157 + a_f: 3.11 + b_f: -0.68 + c_f: 2.41 + alpha_mod: 1.0 + gauss: + alpha: 0.58 + beta: 0.077 + ka: 0.38 + kb: 0.004 + jensen: + we: 0.05 + empirical_gauss: + wake_expansion_rates: + - 0.023 + - 0.008 + breakpoints_D: + - 10 + sigma_0_D: 0.28 + smoothing_length_D: 2.0 + mixing_gain_velocity: 2.0 + awc_wake_exp: 1.2 + awc_wake_denominator: 400 + wake_turbulence_parameters: + crespo_hernandez: + initial: 0.1 + constant: 0.5 + ai: 0.8 + downstream: -0.32 + wake_induced_mixing: + atmospheric_ti_gain: 0.0 diff --git a/examples/inputs/gch.yaml b/examples/inputs/gch.yaml index 220fafeac..5c0ea8eb2 100644 --- a/examples/inputs/gch.yaml +++ b/examples/inputs/gch.yaml @@ -12,7 +12,7 @@ description: Three turbines using Gauss Curl Hybrid model ### # The earliest verion of FLORIS this input file supports. # This is not currently only for the user's reference. -floris_version: v3.0.0 +floris_version: v4 ### # Configure the logging level and where to show the logs. @@ -111,8 +111,9 @@ flow_field: reference_wind_height: -1 ### - # The level of turbulence intensity level in the wind. - turbulence_intensity: 0.06 + # The turbulence intensities to include in the simulation, specified as a decimal. + turbulence_intensities: + - 0.06 ### # The wind directions to include in the simulation. @@ -138,7 +139,7 @@ flow_field: # The conditions that are specified for use with the multi-dimensional Cp/Ct capbility. # These conditions are external to FLORIS and specified by the user. They are used internally # through a nearest-neighbor selection process to choose the correct Cp/Ct interpolants - # to use. These conditions are only used with the ``multidim_cp_ct`` velocity deficit model. + # to use. multidim_conditions: Tp: 2.5 Hs: 3.01 @@ -177,6 +178,10 @@ wake: # Can be "true" or "false". enable_yaw_added_recovery: true + ### + # Can be "true" or "false". + enable_active_wake_mixing: false + ### # Can be "true" or "false". enable_transverse_velocities: true diff --git a/examples/inputs/gch_heterogeneous_inflow.yaml b/examples/inputs/gch_heterogeneous_inflow.yaml index d7cffa0d5..28f9bf6f5 100644 --- a/examples/inputs/gch_heterogeneous_inflow.yaml +++ b/examples/inputs/gch_heterogeneous_inflow.yaml @@ -1,6 +1,6 @@ name: GCH description: Three turbines using Gauss Curl Hybrid model -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -27,7 +27,7 @@ farm: flow_field: air_density: 1.225 - heterogenous_inflow_config: + heterogeneous_inflow_config: speed_multipliers: - - 2.0 - 1.0 @@ -44,7 +44,8 @@ flow_field: - -300. - 300. reference_wind_height: -1 - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -61,6 +62,7 @@ wake: enable_secondary_steering: true enable_yaw_added_recovery: true enable_transverse_velocities: true + enable_active_wake_mixing: false wake_deflection_parameters: gauss: diff --git a/examples/inputs/gch_multi_dim_cp_ct.yaml b/examples/inputs/gch_multi_dim_cp_ct.yaml index 8709fbcc7..d1c788431 100644 --- a/examples/inputs/gch_multi_dim_cp_ct.yaml +++ b/examples/inputs/gch_multi_dim_cp_ct.yaml @@ -1,7 +1,7 @@ name: GCH multi dimensional Cp/Ct description: Three turbines using GCH model -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -33,7 +33,8 @@ flow_field: Hs: 3.01 air_density: 1.225 reference_wind_height: -1 # -1 is code for use the hub height - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -46,11 +47,12 @@ wake: combination_model: sosfs deflection_model: gauss turbulence_model: crespo_hernandez - velocity_model: multidim_cp_ct + velocity_model: gauss enable_secondary_steering: true enable_yaw_added_recovery: true enable_transverse_velocities: true + enable_active_wake_mixing: false wake_deflection_parameters: gauss: @@ -65,6 +67,12 @@ wake: ad: 0.0 bd: 0.0 kd: 0.05 + empirical_gauss: + horizontal_deflection_gain_D: 3.0 + vertical_deflection_gain_D: -1 + deflection_rate: 22 + mixing_gain_deflection: 0.0 + yaw_added_mixing_gain: 0.0 wake_velocity_parameters: cc: @@ -76,13 +84,25 @@ wake: b_f: -0.68 c_f: 2.41 alpha_mod: 1.0 - multidim_cp_ct: + gauss: alpha: 0.58 beta: 0.077 ka: 0.38 kb: 0.004 jensen: we: 0.05 + turbopark: + A: 0.04 + sigma_max_rel: 4.0 + empirical_gauss: + wake_expansion_rates: + - 0.023 + - 0.008 + breakpoints_D: + - 10 + sigma_0_D: 0.28 + smoothing_length_D: 2.0 + mixing_gain_velocity: 2.0 wake_turbulence_parameters: crespo_hernandez: @@ -90,3 +110,5 @@ wake: constant: 0.9 ai: 0.83 downstream: -0.25 + wake_induced_mixing: + atmospheric_ti_gain: 0.0 diff --git a/examples/inputs/gch_multiple_turbine_types.yaml b/examples/inputs/gch_multiple_turbine_types.yaml index ca2d86ea5..80682aa28 100644 --- a/examples/inputs/gch_multiple_turbine_types.yaml +++ b/examples/inputs/gch_multiple_turbine_types.yaml @@ -1,7 +1,7 @@ name: GCH description: Three turbines using Gauss Curl Hybrid model -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -29,7 +29,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: 90.0 # Since multiple defined turbines, must specify explicitly the reference wind height - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -47,6 +48,7 @@ wake: enable_secondary_steering: false enable_yaw_added_recovery: false enable_transverse_velocities: false + enable_active_wake_mixing: false wake_deflection_parameters: gauss: diff --git a/examples/inputs/jensen.yaml b/examples/inputs/jensen.yaml index abb889e0a..f3b81747d 100644 --- a/examples/inputs/jensen.yaml +++ b/examples/inputs/jensen.yaml @@ -1,7 +1,7 @@ name: Jensen-Jimenez description: Three turbines using Jensen / Jimenez models -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -30,7 +30,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 # -1 is code for use the hub height - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -48,6 +49,7 @@ wake: enable_secondary_steering: false enable_yaw_added_recovery: false enable_transverse_velocities: false + enable_active_wake_mixing: false wake_deflection_parameters: gauss: diff --git a/examples/inputs/turbopark.yaml b/examples/inputs/turbopark.yaml index 85bda5fef..c4ffbfa43 100644 --- a/examples/inputs/turbopark.yaml +++ b/examples/inputs/turbopark.yaml @@ -1,7 +1,7 @@ name: TurbOPark description: Three turbines using TurbOPark model -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -30,7 +30,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: 90.0 - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -48,6 +49,7 @@ wake: enable_secondary_steering: false enable_yaw_added_recovery: false enable_transverse_velocities: false + enable_active_wake_mixing: false wake_deflection_parameters: gauss: diff --git a/examples/inputs_floating/emgauss_fixed.yaml b/examples/inputs_floating/emgauss_fixed.yaml index 9d0b23960..cc7292180 100644 --- a/examples/inputs_floating/emgauss_fixed.yaml +++ b/examples/inputs_floating/emgauss_fixed.yaml @@ -1,7 +1,7 @@ name: Emperical Gaussian description: Example of single fixed-bottom turbine -floris_version: v3.x +floris_version: v4 logging: console: @@ -30,7 +30,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 # -1 is code for use the hub height - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -48,6 +49,7 @@ wake: enable_secondary_steering: false enable_yaw_added_recovery: true enable_transverse_velocities: false + enable_active_wake_mixing: false wake_deflection_parameters: gauss: @@ -65,7 +67,7 @@ wake: empirical_gauss: horizontal_deflection_gain_D: 3.0 vertical_deflection_gain_D: -1 - deflection_rate: 30 + deflection_rate: 22 mixing_gain_deflection: 0.0 yaw_added_mixing_gain: 0.0 diff --git a/examples/inputs_floating/emgauss_floating.yaml b/examples/inputs_floating/emgauss_floating.yaml index 1fd66d217..9a078adb7 100644 --- a/examples/inputs_floating/emgauss_floating.yaml +++ b/examples/inputs_floating/emgauss_floating.yaml @@ -1,7 +1,7 @@ name: Emperical Gaussian description: Example of single floating turbine -floris_version: v3.x +floris_version: v4 logging: console: @@ -30,7 +30,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 # -1 is code for use the hub height - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -48,6 +49,7 @@ wake: enable_secondary_steering: false enable_yaw_added_recovery: true enable_transverse_velocities: false + enable_active_wake_mixing: false wake_deflection_parameters: gauss: @@ -65,7 +67,7 @@ wake: empirical_gauss: horizontal_deflection_gain_D: 3.0 vertical_deflection_gain_D: -1 - deflection_rate: 30 + deflection_rate: 22 mixing_gain_deflection: 0.0 yaw_added_mixing_gain: 0.0 diff --git a/examples/inputs_floating/emgauss_floating_fixedtilt15.yaml b/examples/inputs_floating/emgauss_floating_fixedtilt15.yaml index dfb4e3155..ad8ac5dce 100644 --- a/examples/inputs_floating/emgauss_floating_fixedtilt15.yaml +++ b/examples/inputs_floating/emgauss_floating_fixedtilt15.yaml @@ -1,7 +1,7 @@ name: Emperical Gaussian floating description: Single turbine using emperical Gaussian model for floating -floris_version: v3.x +floris_version: v4 logging: console: @@ -26,7 +26,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 # -1 is code for use the hub height - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -44,6 +45,7 @@ wake: enable_secondary_steering: false enable_yaw_added_recovery: true enable_transverse_velocities: false + enable_active_wake_mixing: false wake_deflection_parameters: gauss: @@ -61,7 +63,7 @@ wake: empirical_gauss: horizontal_deflection_gain_D: 3.0 vertical_deflection_gain_D: -1 - deflection_rate: 30 + deflection_rate: 22 mixing_gain_deflection: 0.0 yaw_added_mixing_gain: 0.0 diff --git a/examples/inputs_floating/emgauss_floating_fixedtilt5.yaml b/examples/inputs_floating/emgauss_floating_fixedtilt5.yaml index 67be5dfd3..8f9d10fd2 100644 --- a/examples/inputs_floating/emgauss_floating_fixedtilt5.yaml +++ b/examples/inputs_floating/emgauss_floating_fixedtilt5.yaml @@ -1,7 +1,7 @@ name: Emperical Gaussian floating description: Single turbine using emperical Gaussian model for floating -floris_version: v3.x +floris_version: v4 logging: console: @@ -26,7 +26,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 # -1 is code for use the hub height - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -44,6 +45,7 @@ wake: enable_secondary_steering: false enable_yaw_added_recovery: true enable_transverse_velocities: false + enable_active_wake_mixing: false wake_deflection_parameters: gauss: @@ -61,7 +63,7 @@ wake: empirical_gauss: horizontal_deflection_gain_D: 3.0 vertical_deflection_gain_D: -1 - deflection_rate: 30 + deflection_rate: 22 mixing_gain_deflection: 0.0 yaw_added_mixing_gain: 0.0 diff --git a/examples/inputs_floating/gch_fixed.yaml b/examples/inputs_floating/gch_fixed.yaml index 497cecc95..d9f961701 100644 --- a/examples/inputs_floating/gch_fixed.yaml +++ b/examples/inputs_floating/gch_fixed.yaml @@ -1,7 +1,7 @@ name: GCH description: Example of single fixed-bottom turbine -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -26,7 +26,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -44,6 +45,7 @@ wake: enable_secondary_steering: true enable_yaw_added_recovery: true enable_transverse_velocities: true + enable_active_wake_mixing: false wake_deflection_parameters: gauss: diff --git a/examples/inputs_floating/gch_floating.yaml b/examples/inputs_floating/gch_floating.yaml index 31ff7c606..4af183aca 100644 --- a/examples/inputs_floating/gch_floating.yaml +++ b/examples/inputs_floating/gch_floating.yaml @@ -2,7 +2,7 @@ name: GCH description: Example of single floating turbine -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -27,7 +27,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -45,6 +46,7 @@ wake: enable_secondary_steering: true enable_yaw_added_recovery: true enable_transverse_velocities: true + enable_active_wake_mixing: false wake_deflection_parameters: gauss: diff --git a/examples/inputs_floating/gch_floating_defined_floating.yaml b/examples/inputs_floating/gch_floating_defined_floating.yaml index 3096e4c2a..ecb5b3b0a 100644 --- a/examples/inputs_floating/gch_floating_defined_floating.yaml +++ b/examples/inputs_floating/gch_floating_defined_floating.yaml @@ -1,7 +1,7 @@ name: GCH description: Example of single floating turbine where the cp/ct is calculated with floating tilt included -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -26,7 +26,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: -1 - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -44,6 +45,7 @@ wake: enable_secondary_steering: true enable_yaw_added_recovery: true enable_transverse_velocities: true + enable_active_wake_mixing: false wake_deflection_parameters: gauss: diff --git a/examples/inputs_floating/turbine_files/nrel_5MW_fixed.yaml b/examples/inputs_floating/turbine_files/nrel_5MW_fixed.yaml index b1755ab6c..a39a94357 100644 --- a/examples/inputs_floating/turbine_files/nrel_5MW_fixed.yaml +++ b/examples/inputs_floating/turbine_files/nrel_5MW_fixed.yaml @@ -1,169 +1,177 @@ turbine_type: 'nrel_5MW_floating' -generator_efficiency: 1.0 hub_height: 90.0 -pP: 1.88 -pT: 1.88 -rotor_diameter: 126.0 +rotor_diameter: 125.88 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 5.0 correct_cp_ct_for_tilt: True # Apply tilt correction to cp/ct power_thrust_table: + ref_air_density: 1.225 + ref_tilt: 5.0 + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 power: - 0.0 - - 0.000000 - - 0.000000 - - 0.178085 - - 0.289075 - - 0.349022 - - 0.384728 - - 0.406059 - - 0.420228 - - 0.428823 - - 0.433873 - - 0.436223 - - 0.436845 - - 0.436575 - - 0.436511 - - 0.436561 - - 0.436517 - - 0.435903 - - 0.434673 - - 0.433230 - - 0.430466 - - 0.378869 - - 0.335199 - - 0.297991 - - 0.266092 - - 0.238588 - - 0.214748 - - 0.193981 - - 0.175808 - - 0.159835 - - 0.145741 - - 0.133256 - - 0.122157 - - 0.112257 - - 0.103399 - - 0.095449 - - 0.088294 - - 0.081836 - - 0.075993 - - 0.070692 - - 0.065875 - - 0.061484 - - 0.057476 - - 0.053809 - - 0.050447 - - 0.047358 - - 0.044518 - - 0.041900 - - 0.039483 - 0.0 + - 40.518011517569214 + - 177.67162506419703 + - 403.900880943964 + - 737.5889584824021 + - 1187.1774030611875 + - 1239.245945375778 + - 1292.5184293723503 + - 1347.3213147477102 + - 1403.2573725578948 + - 1460.7011898730707 + - 1519.6419125979983 + - 1580.174365096404 + - 1642.1103166918167 + - 1705.758292831 + - 1771.1659528893977 + - 2518.553107505315 + - 3448.381605840943 + - 3552.140809000129 + - 3657.9545431794127 + - 3765.121299313842 + - 3873.928844315059 + - 3984.4800226955504 + - 4096.582833096852 + - 4210.721306623712 + - 4326.154305853405 + - 4443.395565353604 + - 4562.497934188341 + - 4683.419890251577 + - 4806.164748311019 + - 4929.931918769215 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 - 0.0 - thrust: - 0.0 + thrust_coefficient: - 0.0 - 0.0 - - 0.99 - - 0.99 - - 0.97373036 - - 0.92826162 - - 0.89210543 - - 0.86100905 - - 0.835423 - - 0.81237673 - - 0.79225789 - - 0.77584769 - - 0.7629228 - - 0.76156073 - - 0.76261984 - - 0.76169723 - - 0.75232027 - - 0.74026851 - - 0.72987175 - - 0.70701647 - - 0.54054532 - - 0.45509459 - - 0.39343381 - - 0.34250785 - - 0.30487242 - - 0.27164979 - - 0.24361964 - - 0.21973831 - - 0.19918151 - - 0.18131868 - - 0.16537679 - - 0.15103727 - - 0.13998636 - - 0.1289037 - - 0.11970413 - - 0.11087113 - - 0.10339901 - - 0.09617888 - - 0.09009926 - - 0.08395078 - - 0.0791188 - - 0.07448356 - - 0.07050731 - - 0.06684119 - - 0.06345518 - - 0.06032267 - - 0.05741999 - - 0.05472609 + - 1.132034888 + - 0.999470963 + - 0.917697381 + - 0.860849503 + - 0.815371198 + - 0.811614904 + - 0.807939328 + - 0.80443352 + - 0.800993851 + - 0.79768116 + - 0.794529244 + - 0.791495834 + - 0.788560434 + - 0.787217182 + - 0.787127977 + - 0.785839257 + - 0.783812219 + - 0.783568108 + - 0.783328285 + - 0.781194418 + - 0.777292539 + - 0.773464375 + - 0.769690236 + - 0.766001924 + - 0.762348072 + - 0.758760824 + - 0.755242872 + - 0.751792927 + - 0.748434131 + - 0.745113997 + - 0.717806682 + - 0.672204789 + - 0.63831272 + - 0.610176496 + - 0.585456847 + - 0.563222111 + - 0.542912273 + - 0.399312061 + - 0.310517829 + - 0.248633226 + - 0.203543725 + - 0.169616419 + - 0.143478955 + - 0.122938861 + - 0.106515296 + - 0.093026095 + - 0.081648606 + - 0.072197368 + - 0.064388275 + - 0.057782745 - 0.0 - 0.0 wind_speed: - 0.0 - - 2.0 - - 2.5 + - 2.9 - 3.0 - - 3.5 - 4.0 - - 4.5 - 5.0 - - 5.5 - 6.0 - - 6.5 - 7.0 + - 7.1 + - 7.2 + - 7.3 + - 7.4 - 7.5 + - 7.6 + - 7.7 + - 7.8 + - 7.9 - 8.0 - - 8.5 - 9.0 - - 9.5 - 10.0 + - 10.1 + - 10.2 + - 10.3 + - 10.4 - 10.5 + - 10.6 + - 10.7 + - 10.8 + - 10.9 - 11.0 + - 11.1 + - 11.2 + - 11.3 + - 11.4 - 11.5 + - 11.6 + - 11.7 + - 11.8 + - 11.9 - 12.0 - - 12.5 - 13.0 - - 13.5 - 14.0 - - 14.5 - 15.0 - - 15.5 - 16.0 - - 16.5 - 17.0 - - 17.5 - 18.0 - - 18.5 - 19.0 - - 19.5 - 20.0 - - 20.5 - 21.0 - - 21.5 - 22.0 - - 22.5 - 23.0 - - 23.5 - 24.0 - - 24.5 - 25.0 - - 25.01 - - 25.02 + - 25.1 - 50.0 floating_tilt_table: tilt: diff --git a/examples/inputs_floating/turbine_files/nrel_5MW_floating.yaml b/examples/inputs_floating/turbine_files/nrel_5MW_floating.yaml index cf3bc3049..165da6a33 100644 --- a/examples/inputs_floating/turbine_files/nrel_5MW_floating.yaml +++ b/examples/inputs_floating/turbine_files/nrel_5MW_floating.yaml @@ -1,169 +1,177 @@ turbine_type: 'nrel_5MW_floating' -generator_efficiency: 1.0 hub_height: 90.0 -pP: 1.88 -pT: 1.88 -rotor_diameter: 126.0 +rotor_diameter: 125.88 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 5.0 correct_cp_ct_for_tilt: True # Apply tilt correction to cp/ct power_thrust_table: + ref_air_density: 1.225 + ref_tilt: 5.0 + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 power: - 0.0 - - 0.000000 - - 0.000000 - - 0.178085 - - 0.289075 - - 0.349022 - - 0.384728 - - 0.406059 - - 0.420228 - - 0.428823 - - 0.433873 - - 0.436223 - - 0.436845 - - 0.436575 - - 0.436511 - - 0.436561 - - 0.436517 - - 0.435903 - - 0.434673 - - 0.433230 - - 0.430466 - - 0.378869 - - 0.335199 - - 0.297991 - - 0.266092 - - 0.238588 - - 0.214748 - - 0.193981 - - 0.175808 - - 0.159835 - - 0.145741 - - 0.133256 - - 0.122157 - - 0.112257 - - 0.103399 - - 0.095449 - - 0.088294 - - 0.081836 - - 0.075993 - - 0.070692 - - 0.065875 - - 0.061484 - - 0.057476 - - 0.053809 - - 0.050447 - - 0.047358 - - 0.044518 - - 0.041900 - - 0.039483 - 0.0 + - 40.518011517569214 + - 177.67162506419703 + - 403.900880943964 + - 737.5889584824021 + - 1187.1774030611875 + - 1239.245945375778 + - 1292.5184293723503 + - 1347.3213147477102 + - 1403.2573725578948 + - 1460.7011898730707 + - 1519.6419125979983 + - 1580.174365096404 + - 1642.1103166918167 + - 1705.758292831 + - 1771.1659528893977 + - 2518.553107505315 + - 3448.381605840943 + - 3552.140809000129 + - 3657.9545431794127 + - 3765.121299313842 + - 3873.928844315059 + - 3984.4800226955504 + - 4096.582833096852 + - 4210.721306623712 + - 4326.154305853405 + - 4443.395565353604 + - 4562.497934188341 + - 4683.419890251577 + - 4806.164748311019 + - 4929.931918769215 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 - 0.0 - thrust: - 0.0 + thrust_coefficient: - 0.0 - 0.0 - - 0.99 - - 0.99 - - 0.97373036 - - 0.92826162 - - 0.89210543 - - 0.86100905 - - 0.835423 - - 0.81237673 - - 0.79225789 - - 0.77584769 - - 0.7629228 - - 0.76156073 - - 0.76261984 - - 0.76169723 - - 0.75232027 - - 0.74026851 - - 0.72987175 - - 0.70701647 - - 0.54054532 - - 0.45509459 - - 0.39343381 - - 0.34250785 - - 0.30487242 - - 0.27164979 - - 0.24361964 - - 0.21973831 - - 0.19918151 - - 0.18131868 - - 0.16537679 - - 0.15103727 - - 0.13998636 - - 0.1289037 - - 0.11970413 - - 0.11087113 - - 0.10339901 - - 0.09617888 - - 0.09009926 - - 0.08395078 - - 0.0791188 - - 0.07448356 - - 0.07050731 - - 0.06684119 - - 0.06345518 - - 0.06032267 - - 0.05741999 - - 0.05472609 + - 1.132034888 + - 0.999470963 + - 0.917697381 + - 0.860849503 + - 0.815371198 + - 0.811614904 + - 0.807939328 + - 0.80443352 + - 0.800993851 + - 0.79768116 + - 0.794529244 + - 0.791495834 + - 0.788560434 + - 0.787217182 + - 0.787127977 + - 0.785839257 + - 0.783812219 + - 0.783568108 + - 0.783328285 + - 0.781194418 + - 0.777292539 + - 0.773464375 + - 0.769690236 + - 0.766001924 + - 0.762348072 + - 0.758760824 + - 0.755242872 + - 0.751792927 + - 0.748434131 + - 0.745113997 + - 0.717806682 + - 0.672204789 + - 0.63831272 + - 0.610176496 + - 0.585456847 + - 0.563222111 + - 0.542912273 + - 0.399312061 + - 0.310517829 + - 0.248633226 + - 0.203543725 + - 0.169616419 + - 0.143478955 + - 0.122938861 + - 0.106515296 + - 0.093026095 + - 0.081648606 + - 0.072197368 + - 0.064388275 + - 0.057782745 - 0.0 - 0.0 wind_speed: - 0.0 - - 2.0 - - 2.5 + - 2.9 - 3.0 - - 3.5 - 4.0 - - 4.5 - 5.0 - - 5.5 - 6.0 - - 6.5 - 7.0 + - 7.1 + - 7.2 + - 7.3 + - 7.4 - 7.5 + - 7.6 + - 7.7 + - 7.8 + - 7.9 - 8.0 - - 8.5 - 9.0 - - 9.5 - 10.0 + - 10.1 + - 10.2 + - 10.3 + - 10.4 - 10.5 + - 10.6 + - 10.7 + - 10.8 + - 10.9 - 11.0 + - 11.1 + - 11.2 + - 11.3 + - 11.4 - 11.5 + - 11.6 + - 11.7 + - 11.8 + - 11.9 - 12.0 - - 12.5 - 13.0 - - 13.5 - 14.0 - - 14.5 - 15.0 - - 15.5 - 16.0 - - 16.5 - 17.0 - - 17.5 - 18.0 - - 18.5 - 19.0 - - 19.5 - 20.0 - - 20.5 - 21.0 - - 21.5 - 22.0 - - 22.5 - 23.0 - - 23.5 - 24.0 - - 24.5 - 25.0 - - 25.01 - - 25.02 + - 25.1 - 50.0 floating_tilt_table: tilt: diff --git a/examples/inputs_floating/turbine_files/nrel_5MW_floating_defined_floating.yaml b/examples/inputs_floating/turbine_files/nrel_5MW_floating_defined_floating.yaml index 4fa506e25..dbfd9c1a5 100644 --- a/examples/inputs_floating/turbine_files/nrel_5MW_floating_defined_floating.yaml +++ b/examples/inputs_floating/turbine_files/nrel_5MW_floating_defined_floating.yaml @@ -1,169 +1,177 @@ turbine_type: 'nrel_5MW_floating' -generator_efficiency: 1.0 hub_height: 90.0 -pP: 1.88 -pT: 1.88 -rotor_diameter: 126.0 +rotor_diameter: 125.88 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 5.0 correct_cp_ct_for_tilt: False # Do not apply tilt correction to cp/ct power_thrust_table: + ref_air_density: 1.225 + ref_tilt: 5.0 + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 power: - 0.0 - - 0.000000 - - 0.000000 - - 0.178085 - - 0.289075 - - 0.349022 - - 0.384728 - - 0.406059 - - 0.420228 - - 0.428823 - - 0.433873 - - 0.436223 - - 0.436845 - - 0.436575 - - 0.436511 - - 0.436561 - - 0.436517 - - 0.435903 - - 0.434673 - - 0.433230 - - 0.430466 - - 0.378869 - - 0.335199 - - 0.297991 - - 0.266092 - - 0.238588 - - 0.214748 - - 0.193981 - - 0.175808 - - 0.159835 - - 0.145741 - - 0.133256 - - 0.122157 - - 0.112257 - - 0.103399 - - 0.095449 - - 0.088294 - - 0.081836 - - 0.075993 - - 0.070692 - - 0.065875 - - 0.061484 - - 0.057476 - - 0.053809 - - 0.050447 - - 0.047358 - - 0.044518 - - 0.041900 - - 0.039483 - 0.0 + - 40.518011517569214 + - 177.67162506419703 + - 403.900880943964 + - 737.5889584824021 + - 1187.1774030611875 + - 1239.245945375778 + - 1292.5184293723503 + - 1347.3213147477102 + - 1403.2573725578948 + - 1460.7011898730707 + - 1519.6419125979983 + - 1580.174365096404 + - 1642.1103166918167 + - 1705.758292831 + - 1771.1659528893977 + - 2518.553107505315 + - 3448.381605840943 + - 3552.140809000129 + - 3657.9545431794127 + - 3765.121299313842 + - 3873.928844315059 + - 3984.4800226955504 + - 4096.582833096852 + - 4210.721306623712 + - 4326.154305853405 + - 4443.395565353604 + - 4562.497934188341 + - 4683.419890251577 + - 4806.164748311019 + - 4929.931918769215 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 - 0.0 - thrust: - 0.0 + thrust_coefficient: - 0.0 - 0.0 - - 0.99 - - 0.99 - - 0.97373036 - - 0.92826162 - - 0.89210543 - - 0.86100905 - - 0.835423 - - 0.81237673 - - 0.79225789 - - 0.77584769 - - 0.7629228 - - 0.76156073 - - 0.76261984 - - 0.76169723 - - 0.75232027 - - 0.74026851 - - 0.72987175 - - 0.70701647 - - 0.54054532 - - 0.45509459 - - 0.39343381 - - 0.34250785 - - 0.30487242 - - 0.27164979 - - 0.24361964 - - 0.21973831 - - 0.19918151 - - 0.18131868 - - 0.16537679 - - 0.15103727 - - 0.13998636 - - 0.1289037 - - 0.11970413 - - 0.11087113 - - 0.10339901 - - 0.09617888 - - 0.09009926 - - 0.08395078 - - 0.0791188 - - 0.07448356 - - 0.07050731 - - 0.06684119 - - 0.06345518 - - 0.06032267 - - 0.05741999 - - 0.05472609 + - 1.132034888 + - 0.999470963 + - 0.917697381 + - 0.860849503 + - 0.815371198 + - 0.811614904 + - 0.807939328 + - 0.80443352 + - 0.800993851 + - 0.79768116 + - 0.794529244 + - 0.791495834 + - 0.788560434 + - 0.787217182 + - 0.787127977 + - 0.785839257 + - 0.783812219 + - 0.783568108 + - 0.783328285 + - 0.781194418 + - 0.777292539 + - 0.773464375 + - 0.769690236 + - 0.766001924 + - 0.762348072 + - 0.758760824 + - 0.755242872 + - 0.751792927 + - 0.748434131 + - 0.745113997 + - 0.717806682 + - 0.672204789 + - 0.63831272 + - 0.610176496 + - 0.585456847 + - 0.563222111 + - 0.542912273 + - 0.399312061 + - 0.310517829 + - 0.248633226 + - 0.203543725 + - 0.169616419 + - 0.143478955 + - 0.122938861 + - 0.106515296 + - 0.093026095 + - 0.081648606 + - 0.072197368 + - 0.064388275 + - 0.057782745 - 0.0 - 0.0 wind_speed: - 0.0 - - 2.0 - - 2.5 + - 2.9 - 3.0 - - 3.5 - 4.0 - - 4.5 - 5.0 - - 5.5 - 6.0 - - 6.5 - 7.0 + - 7.1 + - 7.2 + - 7.3 + - 7.4 - 7.5 + - 7.6 + - 7.7 + - 7.8 + - 7.9 - 8.0 - - 8.5 - 9.0 - - 9.5 - 10.0 + - 10.1 + - 10.2 + - 10.3 + - 10.4 - 10.5 + - 10.6 + - 10.7 + - 10.8 + - 10.9 - 11.0 + - 11.1 + - 11.2 + - 11.3 + - 11.4 - 11.5 + - 11.6 + - 11.7 + - 11.8 + - 11.9 - 12.0 - - 12.5 - 13.0 - - 13.5 - 14.0 - - 14.5 - 15.0 - - 15.5 - 16.0 - - 16.5 - 17.0 - - 17.5 - 18.0 - - 18.5 - 19.0 - - 19.5 - 20.0 - - 20.5 - 21.0 - - 21.5 - 22.0 - - 22.5 - 23.0 - - 23.5 - 24.0 - - 24.5 - 25.0 - - 25.01 - - 25.02 + - 25.1 - 50.0 floating_tilt_table: tilt: diff --git a/examples/inputs_floating/turbine_files/nrel_5MW_floating_fixedtilt15.yaml b/examples/inputs_floating/turbine_files/nrel_5MW_floating_fixedtilt15.yaml index da0d15a37..e7186ca9f 100644 --- a/examples/inputs_floating/turbine_files/nrel_5MW_floating_fixedtilt15.yaml +++ b/examples/inputs_floating/turbine_files/nrel_5MW_floating_fixedtilt15.yaml @@ -1,169 +1,177 @@ turbine_type: 'nrel_5MW_floating' -generator_efficiency: 1.0 hub_height: 90.0 -pP: 1.88 -pT: 1.88 -rotor_diameter: 126.0 +rotor_diameter: 125.88 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 5.0 correct_cp_ct_for_tilt: True # Apply tilt correction to cp/ct power_thrust_table: + ref_air_density: 1.225 + ref_tilt: 5.0 + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 power: - 0.0 - - 0.000000 - - 0.000000 - - 0.178085 - - 0.289075 - - 0.349022 - - 0.384728 - - 0.406059 - - 0.420228 - - 0.428823 - - 0.433873 - - 0.436223 - - 0.436845 - - 0.436575 - - 0.436511 - - 0.436561 - - 0.436517 - - 0.435903 - - 0.434673 - - 0.433230 - - 0.430466 - - 0.378869 - - 0.335199 - - 0.297991 - - 0.266092 - - 0.238588 - - 0.214748 - - 0.193981 - - 0.175808 - - 0.159835 - - 0.145741 - - 0.133256 - - 0.122157 - - 0.112257 - - 0.103399 - - 0.095449 - - 0.088294 - - 0.081836 - - 0.075993 - - 0.070692 - - 0.065875 - - 0.061484 - - 0.057476 - - 0.053809 - - 0.050447 - - 0.047358 - - 0.044518 - - 0.041900 - - 0.039483 - 0.0 + - 40.518011517569214 + - 177.67162506419703 + - 403.900880943964 + - 737.5889584824021 + - 1187.1774030611875 + - 1239.245945375778 + - 1292.5184293723503 + - 1347.3213147477102 + - 1403.2573725578948 + - 1460.7011898730707 + - 1519.6419125979983 + - 1580.174365096404 + - 1642.1103166918167 + - 1705.758292831 + - 1771.1659528893977 + - 2518.553107505315 + - 3448.381605840943 + - 3552.140809000129 + - 3657.9545431794127 + - 3765.121299313842 + - 3873.928844315059 + - 3984.4800226955504 + - 4096.582833096852 + - 4210.721306623712 + - 4326.154305853405 + - 4443.395565353604 + - 4562.497934188341 + - 4683.419890251577 + - 4806.164748311019 + - 4929.931918769215 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 - 0.0 - thrust: - 0.0 + thrust_coefficient: - 0.0 - 0.0 - - 0.99 - - 0.99 - - 0.97373036 - - 0.92826162 - - 0.89210543 - - 0.86100905 - - 0.835423 - - 0.81237673 - - 0.79225789 - - 0.77584769 - - 0.7629228 - - 0.76156073 - - 0.76261984 - - 0.76169723 - - 0.75232027 - - 0.74026851 - - 0.72987175 - - 0.70701647 - - 0.54054532 - - 0.45509459 - - 0.39343381 - - 0.34250785 - - 0.30487242 - - 0.27164979 - - 0.24361964 - - 0.21973831 - - 0.19918151 - - 0.18131868 - - 0.16537679 - - 0.15103727 - - 0.13998636 - - 0.1289037 - - 0.11970413 - - 0.11087113 - - 0.10339901 - - 0.09617888 - - 0.09009926 - - 0.08395078 - - 0.0791188 - - 0.07448356 - - 0.07050731 - - 0.06684119 - - 0.06345518 - - 0.06032267 - - 0.05741999 - - 0.05472609 + - 1.132034888 + - 0.999470963 + - 0.917697381 + - 0.860849503 + - 0.815371198 + - 0.811614904 + - 0.807939328 + - 0.80443352 + - 0.800993851 + - 0.79768116 + - 0.794529244 + - 0.791495834 + - 0.788560434 + - 0.787217182 + - 0.787127977 + - 0.785839257 + - 0.783812219 + - 0.783568108 + - 0.783328285 + - 0.781194418 + - 0.777292539 + - 0.773464375 + - 0.769690236 + - 0.766001924 + - 0.762348072 + - 0.758760824 + - 0.755242872 + - 0.751792927 + - 0.748434131 + - 0.745113997 + - 0.717806682 + - 0.672204789 + - 0.63831272 + - 0.610176496 + - 0.585456847 + - 0.563222111 + - 0.542912273 + - 0.399312061 + - 0.310517829 + - 0.248633226 + - 0.203543725 + - 0.169616419 + - 0.143478955 + - 0.122938861 + - 0.106515296 + - 0.093026095 + - 0.081648606 + - 0.072197368 + - 0.064388275 + - 0.057782745 - 0.0 - 0.0 wind_speed: - 0.0 - - 2.0 - - 2.5 + - 2.9 - 3.0 - - 3.5 - 4.0 - - 4.5 - 5.0 - - 5.5 - 6.0 - - 6.5 - 7.0 + - 7.1 + - 7.2 + - 7.3 + - 7.4 - 7.5 + - 7.6 + - 7.7 + - 7.8 + - 7.9 - 8.0 - - 8.5 - 9.0 - - 9.5 - 10.0 + - 10.1 + - 10.2 + - 10.3 + - 10.4 - 10.5 + - 10.6 + - 10.7 + - 10.8 + - 10.9 - 11.0 + - 11.1 + - 11.2 + - 11.3 + - 11.4 - 11.5 + - 11.6 + - 11.7 + - 11.8 + - 11.9 - 12.0 - - 12.5 - 13.0 - - 13.5 - 14.0 - - 14.5 - 15.0 - - 15.5 - 16.0 - - 16.5 - 17.0 - - 17.5 - 18.0 - - 18.5 - 19.0 - - 19.5 - 20.0 - - 20.5 - 21.0 - - 21.5 - 22.0 - - 22.5 - 23.0 - - 23.5 - 24.0 - - 24.5 - 25.0 - - 25.01 - - 25.02 + - 25.1 - 50.0 floating_tilt_table: tilt: diff --git a/examples/inputs_floating/turbine_files/nrel_5MW_floating_fixedtilt5.yaml b/examples/inputs_floating/turbine_files/nrel_5MW_floating_fixedtilt5.yaml index b1755ab6c..a39a94357 100644 --- a/examples/inputs_floating/turbine_files/nrel_5MW_floating_fixedtilt5.yaml +++ b/examples/inputs_floating/turbine_files/nrel_5MW_floating_fixedtilt5.yaml @@ -1,169 +1,177 @@ turbine_type: 'nrel_5MW_floating' -generator_efficiency: 1.0 hub_height: 90.0 -pP: 1.88 -pT: 1.88 -rotor_diameter: 126.0 +rotor_diameter: 125.88 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 5.0 correct_cp_ct_for_tilt: True # Apply tilt correction to cp/ct power_thrust_table: + ref_air_density: 1.225 + ref_tilt: 5.0 + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 power: - 0.0 - - 0.000000 - - 0.000000 - - 0.178085 - - 0.289075 - - 0.349022 - - 0.384728 - - 0.406059 - - 0.420228 - - 0.428823 - - 0.433873 - - 0.436223 - - 0.436845 - - 0.436575 - - 0.436511 - - 0.436561 - - 0.436517 - - 0.435903 - - 0.434673 - - 0.433230 - - 0.430466 - - 0.378869 - - 0.335199 - - 0.297991 - - 0.266092 - - 0.238588 - - 0.214748 - - 0.193981 - - 0.175808 - - 0.159835 - - 0.145741 - - 0.133256 - - 0.122157 - - 0.112257 - - 0.103399 - - 0.095449 - - 0.088294 - - 0.081836 - - 0.075993 - - 0.070692 - - 0.065875 - - 0.061484 - - 0.057476 - - 0.053809 - - 0.050447 - - 0.047358 - - 0.044518 - - 0.041900 - - 0.039483 - 0.0 + - 40.518011517569214 + - 177.67162506419703 + - 403.900880943964 + - 737.5889584824021 + - 1187.1774030611875 + - 1239.245945375778 + - 1292.5184293723503 + - 1347.3213147477102 + - 1403.2573725578948 + - 1460.7011898730707 + - 1519.6419125979983 + - 1580.174365096404 + - 1642.1103166918167 + - 1705.758292831 + - 1771.1659528893977 + - 2518.553107505315 + - 3448.381605840943 + - 3552.140809000129 + - 3657.9545431794127 + - 3765.121299313842 + - 3873.928844315059 + - 3984.4800226955504 + - 4096.582833096852 + - 4210.721306623712 + - 4326.154305853405 + - 4443.395565353604 + - 4562.497934188341 + - 4683.419890251577 + - 4806.164748311019 + - 4929.931918769215 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 - 0.0 - thrust: - 0.0 + thrust_coefficient: - 0.0 - 0.0 - - 0.99 - - 0.99 - - 0.97373036 - - 0.92826162 - - 0.89210543 - - 0.86100905 - - 0.835423 - - 0.81237673 - - 0.79225789 - - 0.77584769 - - 0.7629228 - - 0.76156073 - - 0.76261984 - - 0.76169723 - - 0.75232027 - - 0.74026851 - - 0.72987175 - - 0.70701647 - - 0.54054532 - - 0.45509459 - - 0.39343381 - - 0.34250785 - - 0.30487242 - - 0.27164979 - - 0.24361964 - - 0.21973831 - - 0.19918151 - - 0.18131868 - - 0.16537679 - - 0.15103727 - - 0.13998636 - - 0.1289037 - - 0.11970413 - - 0.11087113 - - 0.10339901 - - 0.09617888 - - 0.09009926 - - 0.08395078 - - 0.0791188 - - 0.07448356 - - 0.07050731 - - 0.06684119 - - 0.06345518 - - 0.06032267 - - 0.05741999 - - 0.05472609 + - 1.132034888 + - 0.999470963 + - 0.917697381 + - 0.860849503 + - 0.815371198 + - 0.811614904 + - 0.807939328 + - 0.80443352 + - 0.800993851 + - 0.79768116 + - 0.794529244 + - 0.791495834 + - 0.788560434 + - 0.787217182 + - 0.787127977 + - 0.785839257 + - 0.783812219 + - 0.783568108 + - 0.783328285 + - 0.781194418 + - 0.777292539 + - 0.773464375 + - 0.769690236 + - 0.766001924 + - 0.762348072 + - 0.758760824 + - 0.755242872 + - 0.751792927 + - 0.748434131 + - 0.745113997 + - 0.717806682 + - 0.672204789 + - 0.63831272 + - 0.610176496 + - 0.585456847 + - 0.563222111 + - 0.542912273 + - 0.399312061 + - 0.310517829 + - 0.248633226 + - 0.203543725 + - 0.169616419 + - 0.143478955 + - 0.122938861 + - 0.106515296 + - 0.093026095 + - 0.081648606 + - 0.072197368 + - 0.064388275 + - 0.057782745 - 0.0 - 0.0 wind_speed: - 0.0 - - 2.0 - - 2.5 + - 2.9 - 3.0 - - 3.5 - 4.0 - - 4.5 - 5.0 - - 5.5 - 6.0 - - 6.5 - 7.0 + - 7.1 + - 7.2 + - 7.3 + - 7.4 - 7.5 + - 7.6 + - 7.7 + - 7.8 + - 7.9 - 8.0 - - 8.5 - 9.0 - - 9.5 - 10.0 + - 10.1 + - 10.2 + - 10.3 + - 10.4 - 10.5 + - 10.6 + - 10.7 + - 10.8 + - 10.9 - 11.0 + - 11.1 + - 11.2 + - 11.3 + - 11.4 - 11.5 + - 11.6 + - 11.7 + - 11.8 + - 11.9 - 12.0 - - 12.5 - 13.0 - - 13.5 - 14.0 - - 14.5 - 15.0 - - 15.5 - 16.0 - - 16.5 - 17.0 - - 17.5 - 18.0 - - 18.5 - 19.0 - - 19.5 - 20.0 - - 20.5 - 21.0 - - 21.5 - 22.0 - - 22.5 - 23.0 - - 23.5 - 24.0 - - 24.5 - 25.0 - - 25.01 - - 25.02 + - 25.1 - 50.0 floating_tilt_table: tilt: diff --git a/floris/__init__.py b/floris/__init__.py index 0a5387707..149d32d6a 100644 --- a/floris/__init__.py +++ b/floris/__init__.py @@ -1,19 +1,21 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from pathlib import Path with open(Path(__file__).parent / "version.py") as _version_file: __version__ = _version_file.read().strip() + + +from .floris_model import FlorisModel +from .flow_visualization import ( + plot_rotor_values, + visualize_cut_plane, + visualize_quiver, +) +from .parallel_floris_model import ParallelFlorisModel +from .uncertain_floris_model import ApproxFlorisModel, UncertainFlorisModel +from .wind_data import ( + TimeSeries, + WindRose, + WindTIRose, +) diff --git a/floris/convert_floris_input_v3_to_v4.py b/floris/convert_floris_input_v3_to_v4.py new file mode 100644 index 000000000..36415e1d2 --- /dev/null +++ b/floris/convert_floris_input_v3_to_v4.py @@ -0,0 +1,70 @@ + +import sys +from pathlib import Path + +import yaml + +from floris.utilities import load_yaml + + +""" +This script is intended to be called with an argument and converts a floris input +yaml file specified for FLORIS v3 to one specified for FLORIS v4. + +Usage: +python convert_floris_input_v3_to_v4.py .yaml + +The resulting floris input file is placed in the same directory as the original yaml, +and is appended _v4. +""" + + +if __name__ == "__main__": + if len(sys.argv) != 2: + raise Exception( + "Usage: python convert_floris_input_v3_to_v4.py .yaml" + ) + + input_yaml = sys.argv[1] + + # Handling the path and new filename + input_path = Path(input_yaml) + split_input = input_path.parts + [filename_v3, extension] = split_input[-1].split(".") + filename_v4 = filename_v3 + "_v4" + split_output = list(split_input[:-1]) + [filename_v4+"."+extension] + output_path = Path(*split_output) + + # Load existing v3 model + v3_floris_input_dict = load_yaml(input_yaml) + v4_floris_input_dict = v3_floris_input_dict.copy() + + # Change turbulence_intensity field to turbulence_intensities as list + if "turbulence_intensities" in v3_floris_input_dict["flow_field"]: + if "turbulence_intensity" in v3_floris_input_dict["flow_field"]: + del v4_floris_input_dict["flow_field"]["turbulence_intensity"] + elif "turbulence_intensity" in v3_floris_input_dict["flow_field"]: + v4_floris_input_dict["flow_field"]["turbulence_intensities"] = ( + [v3_floris_input_dict["flow_field"]["turbulence_intensity"]] + ) + del v4_floris_input_dict["flow_field"]["turbulence_intensity"] + + # Change multidim_cp_ct velocity model to gauss + if v3_floris_input_dict["wake"]["model_strings"]["velocity_model"] == "multidim_cp_ct": + print( + "multidim_cp_ct velocity model specified. Changing to gauss, " + + "but note that other velocity models are also compatible with multidimensional " + + "turbines in FLORIS v4. " + + "You will also need to convert your multidimensional turbine yaml files and their " + + "corresponding power/thrust csv files to be compatible with FLORIS v4 and to reflect " + + " the absolute power curve, rather than the power coefficient curve." + ) + v4_floris_input_dict["wake"]["model_strings"]["velocity_model"] = "gauss" + + yaml.dump( + v4_floris_input_dict, + open(output_path, "w"), + sort_keys=False + ) + + print(output_path, "created.") diff --git a/floris/convert_turbine_v3_to_v4.py b/floris/convert_turbine_v3_to_v4.py new file mode 100644 index 000000000..5cf55f3d5 --- /dev/null +++ b/floris/convert_turbine_v3_to_v4.py @@ -0,0 +1,86 @@ + +import sys +from pathlib import Path + +from floris.turbine_library import build_cosine_loss_turbine_dict, check_smooth_power_curve +from floris.utilities import load_yaml + + +""" +This script is intended to be called with an argument and converts a turbine +yaml file specified for FLORIS v3 to one specified for FLORIS v4. + +Usage: +python convert_turbine_v3_to_v4.py .yaml + +The resulting turbine is placed in the same directory as the original yaml, +and is appended _v4. +""" + + +if __name__ == "__main__": + if len(sys.argv) != 2: + raise Exception("Usage: python convert_turbine_v3_to_v4.py .yaml") + + input_yaml = sys.argv[1] + + # Handling the path and new filename + input_path = Path(input_yaml) + split_input = input_path.parts + [filename_v3, extension] = split_input[-1].split(".") + filename_v4 = filename_v3 + "_v4" + split_output = list(split_input[:-1]) + [filename_v4+"."+extension] + output_path = Path(*split_output) + + # Load existing v3 model + v3_turbine_dict = load_yaml(input_yaml) + + # Split into components expected by build_turbine_dict + power_thrust_table = v3_turbine_dict["power_thrust_table"] + if "power_thrust_data_file" in power_thrust_table: + raise ValueError( + "Cannot convert multidimensional turbine model. Please manually update your " + + "turbine yaml. Note that the power_thrust_data_file csv needs to be updated to " + + "reflect the absolute power curve, rather than the power coefficient curve," + + "and that `thrust` has been replaced by `thrust_coefficient`." + ) + power_thrust_table["power_coefficient"] = power_thrust_table["power"] + power_thrust_table["thrust_coefficient"] = power_thrust_table["thrust"] + power_thrust_table.pop("power") + power_thrust_table.pop("thrust") + + valid_properties = [ + "generator_efficiency", + "hub_height", + "cosine_loss_exponent_yaw", + "cosine_loss_exponent_tilt", + "rotor_diameter", + "TSR", + "ref_air_density", + "ref_tilt" + ] + + turbine_properties = {k:v for k,v in v3_turbine_dict.items() if k in valid_properties} + turbine_properties["ref_air_density"] = v3_turbine_dict["ref_density_cp_ct"] + turbine_properties["cosine_loss_exponent_yaw"] = v3_turbine_dict["pP"] + if "ref_tilt_cp_ct" in v3_turbine_dict: + turbine_properties["ref_tilt"] = v3_turbine_dict["ref_tilt_cp_ct"] + if "pT" in v3_turbine_dict: + turbine_properties["cosine_loss_exponent_tilt"] = v3_turbine_dict["pT"] + + # Convert to v4 and print new yaml + v4_turbine_dict = build_cosine_loss_turbine_dict( + power_thrust_table, + v3_turbine_dict["turbine_type"], + output_path, + **turbine_properties + ) + + if not check_smooth_power_curve( + v4_turbine_dict["power_thrust_table"]["power"], + tolerance=0.001 + ): + print( + "Non-smoothness detected in output power curve. ", + "Check above-rated power in generated v4 yaml file." + ) diff --git a/floris/simulation/__init__.py b/floris/core/__init__.py similarity index 63% rename from floris/simulation/__init__.py rename to floris/core/__init__.py index b7b41ed16..e37f9c113 100644 --- a/floris/simulation/__init__.py +++ b/floris/core/__init__.py @@ -1,17 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - """ The :py:obj:`floris` package contains :py:obj:`floris.utilities` module @@ -37,19 +23,16 @@ import floris.logging_manager from .base import BaseClass, BaseModel, State -from .turbine import ( - average_velocity, +from .turbine.turbine import ( axial_induction, - compute_tilt_angles_for_floating_turbines, - Ct, power, - rotor_effective_velocity, + thrust_coefficient, Turbine ) -from .turbine_multi_dim import ( - axial_induction_multidim, - Ct_multidim, - TurbineMultiDimensional +from .rotor_velocity import ( + average_velocity, + rotor_effective_velocity, + compute_tilt_angles_for_floating_turbines, ) from .farm import Farm from .grid import ( @@ -70,10 +53,9 @@ full_flow_sequential_solver, full_flow_turbopark_solver, sequential_solver, - sequential_multidim_solver, turbopark_solver, ) -from .floris import Floris +from .core import Core # initialize the logger floris.logging_manager._setup_logger() diff --git a/floris/simulation/base.py b/floris/core/base.py similarity index 71% rename from floris/simulation/base.py rename to floris/core/base.py index 4edd11d6f..76c131597 100644 --- a/floris/simulation/base.py +++ b/floris/core/base.py @@ -1,21 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -""" -Defines the BaseClass parent class for all models to be based upon. -""" from abc import abstractmethod from enum import Enum @@ -37,6 +19,11 @@ from floris.type_dec import FromDictMixin +""" +Defines the BaseClass parent class for all models to be based upon. +""" + + class State(Enum): UNINITIALIZED = 0 INITIALIZED = 1 diff --git a/floris/simulation/floris.py b/floris/core/core.py similarity index 72% rename from floris/simulation/floris.py rename to floris/core/core.py index a24a33939..89af93bcf 100644 --- a/floris/simulation/floris.py +++ b/floris/core/core.py @@ -1,16 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from __future__ import annotations @@ -22,7 +9,7 @@ from attrs import define, field from floris import logging_manager -from floris.simulation import ( +from floris.core import ( BaseClass, cc_solver, empirical_gauss_solver, @@ -36,7 +23,6 @@ full_flow_turbopark_solver, Grid, PointsGrid, - sequential_multidim_solver, sequential_solver, State, TurbineCubatureGrid, @@ -52,7 +38,7 @@ @define -class Floris(BaseClass): +class Core(BaseClass): """ Top-level class that describes a Floris model and initializes the simulation. Use the :py:class:`~.simulation.farm.Farm` attribute to @@ -85,47 +71,37 @@ def __attrs_post_init__(self) -> None: self.logging["file"]["level"], ) - self.check_deprecated_inputs() - # Initialize farm quantities that depend on other objects self.farm.construct_turbine_map() - if self.wake.model_strings['velocity_model'] == 'multidim_cp_ct': - self.farm.construct_multidim_turbine_fCts() - self.farm.construct_multidim_turbine_power_interps() - else: - self.farm.construct_turbine_fCts() - self.farm.construct_turbine_power_interps() + self.farm.construct_turbine_thrust_coefficient_functions() + self.farm.construct_turbine_axial_induction_functions() + self.farm.construct_turbine_power_functions() + self.farm.construct_turbine_power_thrust_tables() self.farm.construct_hub_heights() self.farm.construct_rotor_diameters() self.farm.construct_turbine_TSRs() - self.farm.construct_turbine_pPs() - self.farm.construct_turbine_pTs() - self.farm.construct_turbine_ref_density_cp_cts() - self.farm.construct_turbine_ref_tilt_cp_cts() + self.farm.construct_turbine_ref_tilts() self.farm.construct_turbine_tilt_interps() self.farm.construct_turbine_correct_cp_ct_for_tilt() - self.farm.set_yaw_angles(self.flow_field.n_wind_directions, self.flow_field.n_wind_speeds) - self.farm.set_tilt_to_ref_tilt( - self.flow_field.n_wind_directions, - self.flow_field.n_wind_speeds, - ) + self.farm.set_yaw_angles_to_ref_yaw(self.flow_field.n_findex) + self.farm.set_tilt_to_ref_tilt(self.flow_field.n_findex) + self.farm.set_power_setpoints_to_ref_power(self.flow_field.n_findex) + self.farm.set_awc_modes_to_ref_mode(self.flow_field.n_findex) + self.farm.set_awc_amplitudes_to_ref_amp(self.flow_field.n_findex) + self.farm.set_awc_frequencies_to_ref_freq(self.flow_field.n_findex) if self.solver["type"] == "turbine_grid": self.grid = TurbineGrid( turbine_coordinates=self.farm.coordinates, turbine_diameters=self.farm.rotor_diameters, wind_directions=self.flow_field.wind_directions, - wind_speeds=self.flow_field.wind_speeds, grid_resolution=self.solver["turbine_grid_points"], - time_series=self.flow_field.time_series, ) elif self.solver["type"] == "turbine_cubature_grid": self.grid = TurbineCubatureGrid( turbine_coordinates=self.farm.coordinates, turbine_diameters=self.farm.rotor_diameters, wind_directions=self.flow_field.wind_directions, - wind_speeds=self.flow_field.wind_speeds, - time_series=self.flow_field.time_series, grid_resolution=self.solver["turbine_grid_points"], ) elif self.solver["type"] == "flow_field_grid": @@ -133,20 +109,16 @@ def __attrs_post_init__(self) -> None: turbine_coordinates=self.farm.coordinates, turbine_diameters=self.farm.rotor_diameters, wind_directions=self.flow_field.wind_directions, - wind_speeds=self.flow_field.wind_speeds, grid_resolution=self.solver["flow_field_grid_points"], - time_series=self.flow_field.time_series, ) elif self.solver["type"] == "flow_field_planar_grid": self.grid = FlowFieldPlanarGrid( turbine_coordinates=self.farm.coordinates, turbine_diameters=self.farm.rotor_diameters, wind_directions=self.flow_field.wind_directions, - wind_speeds=self.flow_field.wind_speeds, normal_vector=self.solver["normal_vector"], planar_coordinate=self.solver["planar_coordinate"], grid_resolution=self.solver["flow_field_grid_points"], - time_series=self.flow_field.time_series, x1_bounds=self.solver["flow_field_bounds"][0], x2_bounds=self.solver["flow_field_bounds"][1], ) @@ -159,48 +131,10 @@ def __attrs_post_init__(self) -> None: if isinstance(self.grid, (TurbineGrid, TurbineCubatureGrid)): self.farm.expand_farm_properties( - self.flow_field.n_wind_directions, - self.flow_field.n_wind_speeds, + self.flow_field.n_findex, self.grid.sorted_coord_indices ) - def check_deprecated_inputs(self): - """ - This function should used when the FLORIS input file changes in order to provide - an informative error and suggest a fix. - """ - - error_messages = [] - # Check for missing values add in version 3.2 and 3.4 - for turbine in self.farm.turbine_definitions: - - if "ref_density_cp_ct" not in turbine.keys(): - error_messages.append( - "From FLORIS v3.2, the turbine definition must include 'ref_density_cp_ct'. " - "This value represents the air density at which the provided Cp and Ct " - "curves are defined. Previously, this was assumed to be 1.225 kg/m^3, " - "and other air density values applied were assumed to be a deviation " - "from the defined level. FLORIS now requires the user to explicitly " - "define the reference density. Add 'ref_density_cp_ct' to your " - "turbine definition and try again. For a description of the turbine inputs, " - "see https://nrel.github.io/floris/input_reference_turbine.html." - ) - - if "ref_tilt_cp_ct" not in turbine.keys(): - error_messages.append( - "From FLORIS v3.4, the turbine definition must include 'ref_tilt_cp_ct'. " - "This value represents the tilt angle at which the provided Cp and Ct " - "curves are defined. Add 'ref_tilt_cp_ct' to your turbine definition and " - "try again. For a description of the turbine inputs, " - "see https://nrel.github.io/floris/input_reference_turbine.html." - ) - - if len(error_messages) > 0: - raise ValueError( - f"{turbine['turbine_type']} turbine model\n" + - "\n\n".join(error_messages) - ) - def initialize_domain(self): """Initialize solution space prior to wake calculations""" @@ -224,8 +158,19 @@ def steady_state_atmospheric_condition(self): self.farm.correct_cp_ct_for_tilt.any(): self.logger.warning( "The current model does not account for vertical wake deflection due to " + - "tilt. Corrections to Cp and Ct can be included, but no vertical wake " + - "deflection will occur." + "tilt. Corrections to power and thrust coefficient can be included, but no " + + "vertical wake deflection will occur." + ) + + operation_model_awc = False + for td in self.farm.turbine_definitions: + if "operation_model" in td and td["operation_model"] == "awc": + operation_model_awc = True + if vel_model != "empirical_gauss" and operation_model_awc: + self.logger.warning( + f"The current model `{vel_model}` does not account for additional wake mixing " + + "due to active wake control. Corrections to power and thrust coefficient can " + + "be included, but no enhanced wake recovery will occur." ) if vel_model=="cc": @@ -249,13 +194,6 @@ def steady_state_atmospheric_condition(self): self.grid, self.wake ) - elif vel_model=="multidim_cp_ct": - sequential_multidim_solver( - self.farm, - self.flow_field, - self.grid, - self.wake - ) else: sequential_solver( self.farm, @@ -301,9 +239,7 @@ def solve_for_points(self, x, y, z): turbine_coordinates=self.farm.coordinates, turbine_diameters=self.farm.rotor_diameters, wind_directions=self.flow_field.wind_directions, - wind_speeds=self.flow_field.wind_speeds, grid_resolution=1, - time_series=self.flow_field.time_series, x_center_of_rotation=self.grid.x_center_of_rotation, y_center_of_rotation=self.grid.y_center_of_rotation ) @@ -322,7 +258,7 @@ def solve_for_points(self, x, y, z): else: full_flow_sequential_solver(self.farm, self.flow_field, field_grid, self.wake) - return self.flow_field.u_sorted[:,:,:,0,0] # Remove turbine grid dimensions + return self.flow_field.u_sorted[:,:,0,0] # Remove turbine grid dimensions def solve_for_velocity_deficit_profiles( self, @@ -338,7 +274,7 @@ def solve_for_velocity_deficit_profiles( ) -> list[pd.DataFrame]: """ Extract velocity deficit profiles. See - :py:meth:`~floris.tools.floris_interface.FlorisInterface.sample_velocity_deficit_profiles` + :py:meth:`~floris.floris_model.FlorisModel.sample_velocity_deficit_profiles` for more details. """ @@ -378,7 +314,7 @@ def solve_for_velocity_deficit_profiles( z = np.squeeze(z, axis=0) + reference_height u = self.solve_for_points(x.flatten(), y.flatten(), z.flatten()) - u = np.reshape(u[0, 0, :], (n_lines, resolution)) + u = np.reshape(u[0, :], (n_lines, resolution)) velocity_deficit = (homogeneous_wind_speed - u) / homogeneous_wind_speed velocity_deficit_profiles = [] @@ -409,7 +345,7 @@ def finalize(self): ## I/O @classmethod - def from_file(cls, input_file_path: str | Path) -> Floris: + def from_file(cls, input_file_path: str | Path) -> Core: """Creates a `Floris` instance from an input file. Must be filetype YAML. Args: @@ -420,7 +356,8 @@ def from_file(cls, input_file_path: str | Path) -> Floris: Floris: The class object instance. """ input_dict = load_yaml(Path(input_file_path).resolve()) - return Floris.from_dict(input_dict) + check_input_file_for_v3_keys(input_dict) + return Core.from_dict(input_dict) def to_file(self, output_file_path: str) -> None: """Converts the `Floris` object to an input-ready YAML file at `output_file_path`. @@ -435,3 +372,36 @@ def to_file(self, output_file_path: str) -> None: sort_keys=False, default_flow_style=False ) + +def check_input_file_for_v3_keys(input_dict) -> None: + """ + Checks if any FLORIS v3 keys are present in the input file and raises special errors if + the extra keys belong to a v3 definition of the input_dct. + and raises special errors if the extra arguments belong to a v3 definition of the class. + + Args: + input_dict (dict): The input dictionary to be checked for v3 keys. + """ + v3_deprecation_msg = ( + "Consider using the convert_floris_input_v3_to_v4.py utility in floris/tools " + + "to convert from a FLORIS v3 input file to FLORIS v4. " + "See https://nrel.github.io/floris/upgrade_guides/v3_to_v4.html for more information." + ) + if "turbulence_intensity" in input_dict["flow_field"]: + raise AttributeError( + "turbulence_intensity has been updated to turbulence_intensities in FLORIS v4. " + + v3_deprecation_msg + ) + elif not hasattr(input_dict["flow_field"]["turbulence_intensities"], "__len__"): + raise AttributeError( + "turbulence_intensities must be a list of floats in FLORIS v4. " + + v3_deprecation_msg + ) + + if input_dict["wake"]["model_strings"]["velocity_model"] == "multidim_cp_ct": + raise AttributeError( + "Dedicated 'multidim_cp_ct' velocity model has been removed in FLORIS v4 in favor of " + + "supporting all available wake models. To recover previous operation, set " + + "velocity_model to gauss. " + + v3_deprecation_msg + ) diff --git a/floris/simulation/farm.py b/floris/core/farm.py similarity index 60% rename from floris/simulation/farm.py rename to floris/core/farm.py index ce289ace2..6ab28d2a0 100644 --- a/floris/simulation/farm.py +++ b/floris/core/farm.py @@ -1,18 +1,8 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from __future__ import annotations import copy +from collections.abc import Callable from pathlib import Path from typing import ( Any, @@ -25,19 +15,20 @@ from attrs import define, field from scipy.interpolate import interp1d -from floris.simulation import ( +from floris.core import ( BaseClass, State, Turbine, - TurbineMultiDimensional, ) -from floris.simulation.turbine import compute_tilt_angles_for_floating_turbines +from floris.core.rotor_velocity import compute_tilt_angles_for_floating_turbines_map +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT from floris.type_dec import ( convert_to_path, floris_array_converter, iter_validator, NDArrayFloat, NDArrayObject, + NDArrayStr, ) from floris.utilities import load_yaml @@ -48,7 +39,7 @@ @define class Farm(BaseClass): """Farm is where wind power plants should be instantiated from a YAML configuration - file. The Farm will create a heterogenous set of turbines that compose a wind farm, + file. The Farm will create a heterogeneous set of turbines that compose a wind farm, validate the inputs, and then create a vectorized representation of the the turbine data. @@ -81,8 +72,8 @@ class Farm(BaseClass): turbine_definitions: list = field(init=False, validator=iter_validator(list, dict)) - turbine_fCts: Dict[str, interp1d] | List[interp1d] = field(init=False, factory=list) - turbine_fCts_sorted: NDArrayFloat = field(init=False, factory=list) + turbine_thrust_coefficient_functions: Dict[str, Callable] = field(init=False, factory=list) + turbine_axial_induction_functions: Dict[str, Callable] = field(init=False, factory=list) turbine_tilt_interps: dict[str, interp1d] = field(init=False, factory=dict) @@ -92,16 +83,28 @@ class Farm(BaseClass): tilt_angles: NDArrayFloat = field(init=False) tilt_angles_sorted: NDArrayFloat = field(init=False) + power_setpoints: NDArrayFloat = field(init=False) + power_setpoints_sorted: NDArrayFloat = field(init=False) + + awc_modes: NDArrayStr = field(init=False) + awc_modes_sorted: NDArrayStr = field(init=False) + + awc_amplitudes: NDArrayFloat = field(init=False) + awc_amplitudes_sorted: NDArrayFloat = field(init=False) + + awc_frequencies: NDArrayFloat = field(init=False) + awc_frequencies_sorted: NDArrayFloat = field(init=False) + hub_heights: NDArrayFloat = field(init=False) hub_heights_sorted: NDArrayFloat = field(init=False, factory=list) - turbine_map: List[Turbine | TurbineMultiDimensional] = field(init=False, factory=list) + turbine_map: List[Turbine] = field(init=False, factory=list) turbine_type_map: NDArrayObject = field(init=False, factory=list) turbine_type_map_sorted: NDArrayObject = field(init=False, factory=list) - turbine_power_interps: Dict[str, interp1d] | List[interp1d] = field(init=False, factory=list) - turbine_power_interps_sorted: NDArrayFloat = field(init=False, factory=list) + turbine_power_functions: Dict[str, Callable] = field(init=False, factory=list) + turbine_power_thrust_tables: Dict[str, dict] = field(init=False, factory=list) rotor_diameters: NDArrayFloat = field(init=False, factory=list) rotor_diameters_sorted: NDArrayFloat = field(init=False, factory=list) @@ -109,17 +112,8 @@ class Farm(BaseClass): TSRs: NDArrayFloat = field(init=False, factory=list) TSRs_sorted: NDArrayFloat = field(init=False, factory=list) - pPs: NDArrayFloat = field(init=False, factory=list) - pPs_sorted: NDArrayFloat = field(init=False, factory=list) - - pTs: NDArrayFloat = field(init=False, factory=list) - pTs_sorted: NDArrayFloat = field(init=False, factory=list) - - ref_density_cp_cts: NDArrayFloat = field(init=False, factory=list) - ref_density_cp_cts_sorted: NDArrayFloat = field(init=False, factory=list) - - ref_tilt_cp_cts: NDArrayFloat = field(init=False, factory=list) - ref_tilt_cp_cts_sorted: NDArrayFloat = field(init=False, factory=list) + ref_tilts: NDArrayFloat = field(init=False, factory=list) + ref_tilts_sorted: NDArrayFloat = field(init=False, factory=list) correct_cp_ct_for_tilt: NDArrayFloat = field(init=False, factory=list) correct_cp_ct_for_tilt_sorted: NDArrayFloat = field(init=False, factory=list) @@ -200,6 +194,10 @@ def __attrs_post_init__(self) -> None: if len(_turbine_types) == 1: _turbine_types *= self.n_turbines + # Check that turbine definitions contain any v3 keys + for t in _turbine_types: + check_turbine_definition_for_v3_keys(turbine_definition_cache[t]) + # Map each turbine definition to its index in this list self.turbine_definitions = [ copy.deepcopy(turbine_definition_cache[t]) for t in _turbine_types @@ -221,7 +219,8 @@ def check_turbine_type(self, attribute: attrs.Attribute, value: Any) -> None: if len(value) != 1 and len(value) != self.n_turbines: raise ValueError( "turbine_type must have the same number of entries as layout_x/layout_y or have " - "a single turbine_type value." + "a single turbine_type value. This error can arise if you set the turbine_type or " + "alter the operation model before setting the layout." ) @turbine_library_path.validator @@ -234,13 +233,33 @@ def initialize(self, sorted_indices): # Sort yaw angles from most upstream to most downstream wind turbine self.yaw_angles_sorted = np.take_along_axis( self.yaw_angles, - sorted_indices[:, :, :, 0, 0], - axis=2, + sorted_indices[:, :, 0, 0], + axis=1, ) self.tilt_angles_sorted = np.take_along_axis( self.tilt_angles, - sorted_indices[:, :, :, 0, 0], - axis=2, + sorted_indices[:, :, 0, 0], + axis=1, + ) + self.power_setpoints_sorted = np.take_along_axis( + self.power_setpoints, + sorted_indices[:, :, 0, 0], + axis=1, + ) + self.awc_modes_sorted = np.take_along_axis( + self.awc_modes, + sorted_indices[:, :, 0, 0], + axis=1, + ) + self.awc_amplitudes_sorted = np.take_along_axis( + self.awc_amplitudes, + sorted_indices[:, :, 0, 0], + axis=1, + ) + self.awc_frequencies_sorted = np.take_along_axis( + self.awc_frequencies, + sorted_indices[:, :, 0, 0], + axis=1, ) self.state = State.INITIALIZED @@ -255,20 +274,9 @@ def construct_rotor_diameters(self): def construct_turbine_TSRs(self): self.TSRs = np.array([turb['TSR'] for turb in self.turbine_definitions]) - def construct_turbine_pPs(self): - self.pPs = np.array([turb['pP'] for turb in self.turbine_definitions]) - - def construct_turbine_pTs(self): - self.pTs = np.array([turb['pT'] for turb in self.turbine_definitions]) - - def construct_turbine_ref_density_cp_cts(self): - self.ref_density_cp_cts = np.array([ - turb['ref_density_cp_ct'] for turb in self.turbine_definitions - ]) - - def construct_turbine_ref_tilt_cp_cts(self): - self.ref_tilt_cp_cts = np.array( - [turb['ref_tilt_cp_ct'] for turb in self.turbine_definitions] + def construct_turbine_ref_tilts(self): + self.ref_tilts = np.array( + [turb['power_thrust_table']['ref_tilt'] for turb in self.turbine_definitions] ) def construct_turbine_correct_cp_ct_for_tilt(self): @@ -277,152 +285,130 @@ def construct_turbine_correct_cp_ct_for_tilt(self): ) def construct_turbine_map(self): - multi_key = "multi_dimensional_cp_ct" - if multi_key in self.turbine_definitions[0] and self.turbine_definitions[0][multi_key]: - self.turbine_map = [] - for turb in self.turbine_definitions: - _turb = {**turb, **{"turbine_library_path": self.internal_turbine_library}} - try: - self.turbine_map.append(TurbineMultiDimensional.from_dict(_turb)) - except FileNotFoundError: - _turb["turbine_library_path"] = self.turbine_library_path - self.turbine_map.append(TurbineMultiDimensional.from_dict(_turb)) - else: - self.turbine_map = [Turbine.from_dict(turb) for turb in self.turbine_definitions] - - def construct_turbine_fCts(self): - self.turbine_fCts = { - turb.turbine_type: turb.fCt_interp for turb in self.turbine_map + self.turbine_map = [Turbine.from_dict(turb) for turb in self.turbine_definitions] + + def construct_turbine_thrust_coefficient_functions(self): + self.turbine_thrust_coefficient_functions = { + turb.turbine_type: turb.thrust_coefficient_function for turb in self.turbine_map } - def construct_multidim_turbine_fCts(self): - self.turbine_fCts = [turb.fCt_interp for turb in self.turbine_map] + def construct_turbine_axial_induction_functions(self): + self.turbine_axial_induction_functions = { + turb.turbine_type: turb.axial_induction_function for turb in self.turbine_map + } def construct_turbine_tilt_interps(self): self.turbine_tilt_interps = { turb.turbine_type: turb.tilt_interp for turb in self.turbine_map } - def construct_turbine_power_interps(self): - self.turbine_power_interps = { - turb.turbine_type: turb.power_interp for turb in self.turbine_map + def construct_turbine_power_functions(self): + self.turbine_power_functions = { + turb.turbine_type: turb.power_function for turb in self.turbine_map } - def construct_multidim_turbine_power_interps(self): - self.turbine_power_interps = [turb.power_interp for turb in self.turbine_map] + def construct_turbine_power_thrust_tables(self): + self.turbine_power_thrust_tables = { + turb.turbine_type: turb.power_thrust_table for turb in self.turbine_map + } - def expand_farm_properties( - self, - n_wind_directions: int, - n_wind_speeds: int, - sorted_coord_indices - ): + def expand_farm_properties(self, n_findex: int, sorted_coord_indices): template_shape = np.ones_like(sorted_coord_indices) self.hub_heights_sorted = np.take_along_axis( self.hub_heights * template_shape, sorted_coord_indices, - axis=2 + axis=1 ) - if 'multi_dimensional_cp_ct' in self.turbine_definitions[0].keys() \ - and self.turbine_definitions[0]['multi_dimensional_cp_ct'] is True: - wd_dim = np.shape(template_shape)[0] - ws_dim = np.shape(template_shape)[1] - if wd_dim != 1 | ws_dim != 0: - self.turbine_fCts_sorted = np.take_along_axis( - np.reshape( - np.repeat(self.turbine_fCts, wd_dim * ws_dim), - np.shape(template_shape) - ), - sorted_coord_indices, - axis=2 - ) - self.turbine_power_interps_sorted = np.take_along_axis( - np.reshape( - np.repeat(self.turbine_power_interps, wd_dim * ws_dim), - np.shape(template_shape) - ), - sorted_coord_indices, - axis=2 - ) - else: - self.turbine_fCts_sorted = np.take_along_axis( - np.reshape(self.turbine_fCts, np.shape(template_shape)), - sorted_coord_indices, - axis=2 - ) - self.turbine_power_interps_sorted = np.take_along_axis( - np.reshape(self.turbine_power_interps, np.shape(template_shape)), - sorted_coord_indices, - axis=2 - ) self.rotor_diameters_sorted = np.take_along_axis( self.rotor_diameters * template_shape, sorted_coord_indices, - axis=2 + axis=1 ) self.TSRs_sorted = np.take_along_axis( self.TSRs * template_shape, sorted_coord_indices, - axis=2 - ) - self.ref_density_cp_cts_sorted = np.take_along_axis( - self.ref_density_cp_cts * template_shape, - sorted_coord_indices, - axis=2 + axis=1 ) - self.ref_tilt_cp_cts_sorted = np.take_along_axis( - self.ref_tilt_cp_cts * template_shape, + self.ref_tilts_sorted = np.take_along_axis( + self.ref_tilts * template_shape, sorted_coord_indices, - axis=2 + axis=1 ) self.correct_cp_ct_for_tilt_sorted = np.take_along_axis( self.correct_cp_ct_for_tilt * template_shape, sorted_coord_indices, - axis=2 - ) - self.pPs_sorted = np.take_along_axis( - self.pPs * template_shape, - sorted_coord_indices, - axis=2 - ) - self.pTs_sorted = np.take_along_axis( - self.pTs * template_shape, - sorted_coord_indices, - axis=2 + axis=1 ) # NOTE: Tilt angles are sorted twice - here and in initialize() self.tilt_angles_sorted = np.take_along_axis( self.tilt_angles * template_shape, sorted_coord_indices, - axis=2 + axis=1 ) self.turbine_type_map_sorted = np.take_along_axis( np.reshape( - [turb["turbine_type"] for turb in self.turbine_definitions] * n_wind_directions, + [turb["turbine_type"] for turb in self.turbine_definitions] * n_findex, np.shape(sorted_coord_indices) ), sorted_coord_indices, - axis=2 + axis=1 ) - def set_yaw_angles(self, n_wind_directions: int, n_wind_speeds: int): - # TODO Is this just for initializing yaw angles to zero? - self.yaw_angles = np.zeros((n_wind_directions, n_wind_speeds, self.n_turbines)) - self.yaw_angles_sorted = np.zeros((n_wind_directions, n_wind_speeds, self.n_turbines)) + def set_yaw_angles(self, yaw_angles: NDArrayFloat | list[float]): + self.yaw_angles = np.array(yaw_angles) + + def set_yaw_angles_to_ref_yaw(self, n_findex: int): + yaw_angles = np.zeros((n_findex, self.n_turbines)) + self.set_yaw_angles(yaw_angles) + self.yaw_angles_sorted = np.zeros((n_findex, self.n_turbines)) - def set_tilt_to_ref_tilt(self, n_wind_directions: int, n_wind_speeds: int): + def set_tilt_to_ref_tilt(self, n_findex: int): self.tilt_angles = ( - np.ones((n_wind_directions, n_wind_speeds, self.n_turbines)) - * self.ref_tilt_cp_cts + np.ones((n_findex, self.n_turbines)) + * self.ref_tilts ) self.tilt_angles_sorted = ( - np.ones((n_wind_directions, n_wind_speeds, self.n_turbines)) - * self.ref_tilt_cp_cts + np.ones((n_findex, self.n_turbines)) + * self.ref_tilts ) + def set_power_setpoints(self, power_setpoints: NDArrayFloat): + self.power_setpoints = np.array(power_setpoints) + + def set_power_setpoints_to_ref_power(self, n_findex: int): + power_setpoints = POWER_SETPOINT_DEFAULT * np.ones((n_findex, self.n_turbines)) + self.set_power_setpoints(power_setpoints) + self.power_setpoints_sorted = POWER_SETPOINT_DEFAULT * np.ones((n_findex, self.n_turbines)) + + def set_awc_modes(self, awc_modes: NDArrayStr): + self.awc_modes = np.array(awc_modes) + + def set_awc_modes_to_ref_mode(self, n_findex: int): + # awc_modes = np.empty((n_findex, self.n_turbines))\ + awc_modes = np.array([["baseline"]*self.n_turbines]*n_findex) + self.set_awc_modes(awc_modes) + # self.awc_modes_sorted = np.empty((n_findex, self.n_turbines)) + self.awc_modes_sorted = np.array([["baseline"]*self.n_turbines]*n_findex) + + def set_awc_amplitudes(self, awc_amplitudes: NDArrayFloat): + self.awc_amplitudes = np.array(awc_amplitudes) + + def set_awc_amplitudes_to_ref_amp(self, n_findex: int): + awc_amplitudes = np.zeros((n_findex, self.n_turbines)) + self.set_awc_amplitudes(awc_amplitudes) + self.awc_amplitudes_sorted = np.zeros((n_findex, self.n_turbines)) + + def set_awc_frequencies(self, awc_frequencies: NDArrayFloat): + self.awc_frequencies = np.array(awc_frequencies) + + def set_awc_frequencies_to_ref_freq(self, n_findex: int): + awc_frequencies = np.zeros((n_findex, self.n_turbines)) + self.set_awc_frequencies(awc_frequencies) + self.awc_frequencies_sorted = np.zeros((n_findex, self.n_turbines)) + def calculate_tilt_for_eff_velocities(self, rotor_effective_velocities): - tilt_angles = compute_tilt_angles_for_floating_turbines( + tilt_angles = compute_tilt_angles_for_floating_turbines_map( self.turbine_type_map_sorted, self.tilt_angles_sorted, self.turbine_tilt_interps, @@ -431,72 +417,45 @@ def calculate_tilt_for_eff_velocities(self, rotor_effective_velocities): return tilt_angles def finalize(self, unsorted_indices): - if 'multi_dimensional_cp_ct' in self.turbine_definitions[0].keys() \ - and self.turbine_definitions[0]['multi_dimensional_cp_ct'] is True: - self.turbine_fCts = np.take_along_axis( - self.turbine_fCts_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 - ) - self.turbine_power_interps = np.take_along_axis( - self.turbine_power_interps_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 - ) self.yaw_angles = np.take_along_axis( self.yaw_angles_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 + unsorted_indices[:,:,0,0], + axis=1 ) self.tilt_angles = np.take_along_axis( self.tilt_angles_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 + unsorted_indices[:,:,0,0], + axis=1 ) self.hub_heights = np.take_along_axis( self.hub_heights_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 + unsorted_indices[:,:,0,0], + axis=1 ) self.rotor_diameters = np.take_along_axis( self.rotor_diameters_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 + unsorted_indices[:,:,0,0], + axis=1 ) self.TSRs = np.take_along_axis( self.TSRs_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 - ) - self.ref_density_cp_cts = np.take_along_axis( - self.ref_density_cp_cts_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 + unsorted_indices[:,:,0,0], + axis=1 ) - self.ref_tilt_cp_cts = np.take_along_axis( - self.ref_tilt_cp_cts_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 + self.ref_tilts = np.take_along_axis( + self.ref_tilts_sorted, + unsorted_indices[:,:,0,0], + axis=1 ) self.correct_cp_ct_for_tilt = np.take_along_axis( self.correct_cp_ct_for_tilt_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 - ) - self.pPs = np.take_along_axis( - self.pPs_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 - ) - self.pTs = np.take_along_axis( - self.pTs_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 + unsorted_indices[:,:,0,0], + axis=1 ) self.turbine_type_map = np.take_along_axis( self.turbine_type_map_sorted, - unsorted_indices[:,:,:,0,0], - axis=2 + unsorted_indices[:,:,0,0], + axis=1 ) self.state.USED @@ -513,3 +472,38 @@ def coordinates(self): @property def n_turbines(self): return len(self.layout_x) + +def check_turbine_definition_for_v3_keys(turbine_definition: dict): + """Check that the turbine definition does not contain any v3 keys.""" + v3_deprecation_msg = ( + "Consider using the convert_turbine_v3_to_v4.py utility in floris/tools " + + "to convert from a FLORIS v3 turbine definition to FLORIS v4. " + + "See https://nrel.github.io/floris/v3_to_v4.html for more information." + ) + if "generator_efficiency" in turbine_definition: + raise ValueError( + "generator_efficiency is no longer supported as power is specified in absolute terms " + + "in FLORIS v4. " + + v3_deprecation_msg + ) + + v3_renamed_keys = ["pP", "pT", "ref_density_cp_ct", "ref_tilt_cp_ct"] + if any(k in turbine_definition for k in v3_renamed_keys): + v3_list_keys = ", ".join(map(str,v3_renamed_keys[:-1]))+", and "+v3_renamed_keys[-1] + v4_versions = ( + "cosine_loss_exponent_yaw, cosine_loss_exponent_tilt, ref_air_density, and ref_tilt" + ) + raise ValueError( + v3_list_keys + + " have been renamed to " + + v4_versions + + ", respectively, and placed under the power_thrust_table field in FLORIS v4. " + + v3_deprecation_msg + ) + + if "thrust" in turbine_definition["power_thrust_table"]: + raise ValueError( + "thrust has been renamed thrust_coefficient in FLORIS v4 (and power is now specified " + "in absolute terms with units kW, rather than as a coefficient). " + + v3_deprecation_msg + ) diff --git a/floris/simulation/flow_field.py b/floris/core/flow_field.py similarity index 77% rename from floris/simulation/flow_field.py rename to floris/core/flow_field.py index 305260c92..d28c47f27 100644 --- a/floris/simulation/flow_field.py +++ b/floris/core/flow_field.py @@ -1,16 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from __future__ import annotations @@ -22,7 +9,7 @@ from scipy.spatial import ConvexHull from shapely.geometry import Polygon -from floris.simulation import ( +from floris.core import ( BaseClass, Grid, ) @@ -39,15 +26,12 @@ class FlowField(BaseClass): wind_veer: float = field(converter=float) wind_shear: float = field(converter=float) air_density: float = field(converter=float) - turbulence_intensity: float = field(converter=float) + turbulence_intensities: NDArrayFloat = field(converter=floris_array_converter) reference_wind_height: float = field(converter=float) - time_series: bool = field(default=False) - heterogenous_inflow_config: dict = field(default=None) + heterogeneous_inflow_config: dict = field(default=None) multidim_conditions: dict = field(default=None) - n_wind_speeds: int = field(init=False) - n_wind_directions: int = field(init=False) - + n_findex: int = field(init=False) u_initial_sorted: NDArrayFloat = field(init=False, factory=lambda: np.array([])) v_initial_sorted: NDArrayFloat = field(init=False, factory=lambda: np.array([])) w_initial_sorted: NDArrayFloat = field(init=False, factory=lambda: np.array([])) @@ -68,32 +52,63 @@ class FlowField(BaseClass): init=False, factory=lambda: np.array([]) ) - @wind_speeds.validator - def wind_speeds_validator(self, instance: attrs.Attribute, value: NDArrayFloat) -> None: - """Using the validator method to keep the `n_wind_speeds` attribute up to date.""" - if self.time_series: - self.n_wind_speeds = 1 - else: - self.n_wind_speeds = value.size + @turbulence_intensities.validator + def turbulence_intensities_validator( + self, instance: attrs.Attribute, value: NDArrayFloat + ) -> None: + + # Check that the array is 1-dimensional + if value.ndim != 1: + raise ValueError( + "turbulence_intensities must have 1-dimension" + ) + + # Check the turbulence intensity is length n_findex + if len(value) != self.n_findex: + raise ValueError("turbulence_intensities must be length n_findex") + + @wind_directions.validator def wind_directions_validator(self, instance: attrs.Attribute, value: NDArrayFloat) -> None: - """Using the validator method to keep the `n_wind_directions` attribute up to date.""" - self.n_wind_directions = value.size + # Check that the array is 1-dimensional + if self.wind_directions.ndim != 1: + raise ValueError( + "wind_directions must have 1-dimension" + ) - @heterogenous_inflow_config.validator - def heterogenous_config_validator(self, instance: attrs.Attribute, value: dict | None) -> None: - """Using the validator method to check that the heterogenous_inflow_config dictionary has + """Using the validator method to keep the `n_findex` attribute up to date.""" + self.n_findex = value.size + + @wind_speeds.validator + def wind_speeds_validator(self, instance: attrs.Attribute, value: NDArrayFloat) -> None: + + # Check that the array is 1-dimensional + if self.wind_speeds.ndim != 1: + raise ValueError( + "wind_speeds must have 1-dimension" + ) + + """Confirm wind speeds and wind directions have the same length""" + if len(self.wind_directions) != len(self.wind_speeds): + raise ValueError( + f"wind_directions (length = {len(self.wind_directions)}) and " + f"wind_speeds (length = {len(self.wind_speeds)}) must have the same length" + ) + + @heterogeneous_inflow_config.validator + def heterogeneous_config_validator(self, instance: attrs.Attribute, value: dict | None) -> None: + """Using the validator method to check that the heterogeneous_inflow_config dictionary has the correct key-value pairs. """ if value is None: return - # Check that the correct keys are supplied for the heterogenous_inflow_config dict + # Check that the correct keys are supplied for the heterogeneous_inflow_config dict for k in ["speed_multipliers", "x", "y"]: if k not in value.keys(): raise ValueError( - "heterogenous_inflow_config must contain entries for 'speed_multipliers'," + "heterogeneous_inflow_config must contain entries for 'speed_multipliers'," f"'x', and 'y', with 'z' optional. Missing '{k}'." ) if "z" not in value: @@ -103,19 +118,19 @@ def heterogenous_config_validator(self, instance: attrs.Attribute, value: dict | @het_map.validator def het_map_validator(self, instance: attrs.Attribute, value: list | None) -> None: """Using this validator to make sure that the het_map has an interpolant defined for - each wind direction. + each findex. """ if value is None: return - if self.n_wind_directions!= np.array(value).shape[0]: + if self.n_findex != np.array(value).shape[0]: raise ValueError( - "The het_map's wind direction dimension not equal to number of wind directions." + "The het_map's first dimension not equal to the FLORIS first dimension." ) def __attrs_post_init__(self) -> None: - if self.heterogenous_inflow_config is not None: + if self.heterogeneous_inflow_config is not None: self.generate_heterogeneous_wind_map() @@ -149,8 +164,8 @@ def initialize_velocity_field(self, grid: Grid) -> None: # grid locations are determined in either 2 or 3 dimensions. else: bounds = np.array(list(zip( - self.heterogenous_inflow_config['x'], - self.heterogenous_inflow_config['y'] + self.heterogeneous_inflow_config['x'], + self.heterogeneous_inflow_config['y'] ))) hull = ConvexHull(bounds) polygon = Polygon(bounds[hull.vertices]) @@ -191,24 +206,9 @@ def initialize_velocity_field(self, grid: Grid) -> None: # here to do broadcasting from left to right (transposed), and then transpose back. # The result is an array the wind speed and wind direction dimensions on the left side # of the shape and the grid.template array on the right - if self.time_series: - self.u_initial_sorted = ( - (self.wind_speeds[:].T * wind_profile_plane.T).T - * speed_ups - ) - self.dudz_initial_sorted = ( - (self.wind_speeds[:].T * dwind_profile_plane.T).T - * speed_ups - ) - else: - self.u_initial_sorted = ( - (self.wind_speeds[None, :].T * wind_profile_plane.T).T - * speed_ups - ) - self.dudz_initial_sorted = ( - (self.wind_speeds[None, :].T * dwind_profile_plane.T).T - * speed_ups - ) + self.u_initial_sorted = (self.wind_speeds.T * wind_profile_plane.T).T * speed_ups + self.dudz_initial_sorted = (self.wind_speeds.T * dwind_profile_plane.T).T * speed_ups + self.v_initial_sorted = np.zeros( np.shape(self.u_initial_sorted), dtype=self.u_initial_sorted.dtype @@ -222,29 +222,27 @@ def initialize_velocity_field(self, grid: Grid) -> None: self.v_sorted = self.v_initial_sorted.copy() self.w_sorted = self.w_initial_sorted.copy() - self.turbulence_intensity_field = self.turbulence_intensity * np.ones( - ( - self.n_wind_directions, - self.n_wind_speeds, - grid.n_turbines, - 1, - 1, - ) + self.turbulence_intensity_field = self.turbulence_intensities[:, None, None, None] + self.turbulence_intensity_field = np.repeat( + self.turbulence_intensity_field, + grid.n_turbines, + axis=1 ) + self.turbulence_intensity_field_sorted = self.turbulence_intensity_field.copy() def finalize(self, unsorted_indices): - self.u = np.take_along_axis(self.u_sorted, unsorted_indices, axis=2) - self.v = np.take_along_axis(self.v_sorted, unsorted_indices, axis=2) - self.w = np.take_along_axis(self.w_sorted, unsorted_indices, axis=2) + self.u = np.take_along_axis(self.u_sorted, unsorted_indices, axis=1) + self.v = np.take_along_axis(self.v_sorted, unsorted_indices, axis=1) + self.w = np.take_along_axis(self.w_sorted, unsorted_indices, axis=1) self.turbulence_intensity_field = np.mean( np.take_along_axis( self.turbulence_intensity_field_sorted, unsorted_indices, - axis=2 + axis=1 ), - axis=(3,4) + axis=(2,3) ) def calculate_speed_ups(self, het_map, x, y, z=None): @@ -274,7 +272,7 @@ def generate_heterogeneous_wind_map(self): map bounds. Args: - heterogenous_inflow_config (dict): The heterogeneous inflow configuration dictionary. + heterogeneous_inflow_config (dict): The heterogeneous inflow configuration dictionary. The configuration should have the following inputs specified. - **speed_multipliers** (list): A list of speed up factors that will multiply the specified freestream wind speed. This 2-dimensional array should have an @@ -283,10 +281,10 @@ def generate_heterogeneous_wind_map(self): - **y**: A list of y locations at which the speed up factors are defined. - **z** (optional): A list of z locations at which the speed up factors are defined. """ - speed_multipliers = self.heterogenous_inflow_config['speed_multipliers'] - x = self.heterogenous_inflow_config['x'] - y = self.heterogenous_inflow_config['y'] - z = self.heterogenous_inflow_config['z'] + speed_multipliers = self.heterogeneous_inflow_config['speed_multipliers'] + x = self.heterogeneous_inflow_config['x'] + y = self.heterogeneous_inflow_config['y'] + z = self.heterogeneous_inflow_config['z'] if z is not None: # Compute the 3-dimensional interpolants for each wind direction diff --git a/floris/simulation/grid.py b/floris/core/grid.py similarity index 89% rename from floris/simulation/grid.py rename to floris/core/grid.py index 42e70289d..9076e01e2 100644 --- a/floris/simulation/grid.py +++ b/floris/core/grid.py @@ -1,17 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - from __future__ import annotations @@ -22,7 +8,7 @@ import numpy as np from attrs import define, field -from floris.simulation import BaseClass +from floris.core import BaseClass from floris.type_dec import ( floris_array_converter, floris_float_type, @@ -59,22 +45,16 @@ class Grid(ABC, BaseClass): arrays with shape (N coordinates, 3). turbine_diameters (:py:obj:`NDArrayFloat`): The rotor diameters of each turbine. wind_directions (:py:obj:`NDArrayFloat`): Wind directions supplied by the user. - wind_speeds (:py:obj:`NDArrayFloat`): Wind speeds supplied by the user. - time_series (:py:obj:`bool`): Flag to indicate whether the supplied wind data is a time - series. grid_resolution (:py:obj:`int` | :py:obj:`Iterable(int,)`): Grid resolution with values specific to each grid type. """ turbine_coordinates: NDArrayFloat = field(converter=floris_array_converter) turbine_diameters: NDArrayFloat = field(converter=floris_array_converter) wind_directions: NDArrayFloat = field(converter=floris_array_converter) - wind_speeds: NDArrayFloat = field(converter=floris_array_converter) - time_series: bool = field() grid_resolution: int | Iterable = field() n_turbines: int = field(init=False) - n_wind_speeds: int = field(init=False) - n_wind_directions: int = field(init=False) + n_findex: int = field(init=False) x_sorted: NDArrayFloat = field(init=False) y_sorted: NDArrayFloat = field(init=False) z_sorted: NDArrayFloat = field(init=False) @@ -98,18 +78,10 @@ def check_coordinates(self, instance: attrs.Attribute, value: np.ndarray) -> Non self.n_turbines = len(value) - @wind_speeds.validator - def wind_speeds_validator(self, instance: attrs.Attribute, value: NDArrayFloat) -> None: - """Using the validator method to keep the `n_wind_speeds` attribute up to date.""" - if self.time_series: - self.n_wind_speeds = 1 - else: - self.n_wind_speeds = value.size - @wind_directions.validator def wind_directions_validator(self, instance: attrs.Attribute, value: NDArrayFloat) -> None: - """Using the validator method to keep the `n_wind_directions` attribute up to date.""" - self.n_wind_directions = value.size + """Using the validator method to keep the `n_findex` attribute up to date.""" + self.n_findex = value.size @grid_resolution.validator def grid_resolution_validator(self, instance: attrs.Attribute, value: int | Iterable) -> None: @@ -141,9 +113,6 @@ class TurbineGrid(Grid): arrays with shape (N coordinates, 3). turbine_diameters (:py:obj:`NDArrayFloat`): The rotor diameters of each turbine. wind_directions (:py:obj:`NDArrayFloat`): Wind directions supplied by the user. - wind_speeds (:py:obj:`NDArrayFloat`): Wind speeds supplied by the user. - time_series (:py:obj:`bool`): Flag to indicate whether the supplied wind data is a time - series. grid_resolution (:py:obj:`int`): The number of points in each direction of the square grid on the rotor plane. For example, grid_resolution=3 creates a 3x3 grid within the rotor swept area. @@ -228,8 +197,7 @@ def set_grid(self) -> None: disc_area_radius = radius_ratio * self.turbine_diameters / 2 template_grid = np.ones( ( - self.n_wind_directions, - self.n_wind_speeds, + self.n_findex, self.n_turbines, self.grid_resolution, self.grid_resolution, @@ -252,30 +220,30 @@ def set_grid(self) -> None: ) # Construct the turbine grids # Here, they are already rotated to the correct orientation for each wind direction - _x = x[:, :, :, None, None] * template_grid + _x = x[:, :, None, None] * template_grid ones_grid = np.ones( (self.n_turbines, self.grid_resolution, self.grid_resolution), dtype=floris_float_type ) - _y = y[:, :, :, None, None] + template_grid * ( disc_grid[None, None, :, :, None]) - _z = z[:, :, :, None, None] + template_grid * ( disc_grid[:, None, :] * ones_grid ) + _y = y[:, :, None, None] + template_grid * ( disc_grid[None, :, :, None]) + _z = z[:, :, None, None] + template_grid * ( disc_grid[:, None, :] * ones_grid ) # Sort the turbines at each wind direction # Get the sorted indices for the x coordinates. These are the indices # to sort the turbines from upstream to downstream for all wind directions. # Also, store the indices to sort them back for when the calculation finishes. - self.sorted_indices = _x.argsort(axis=2) - self.sorted_coord_indices = x.argsort(axis=2) - self.unsorted_indices = self.sorted_indices.argsort(axis=2) + self.sorted_indices = _x.argsort(axis=1) + self.sorted_coord_indices = x.argsort(axis=1) + self.unsorted_indices = self.sorted_indices.argsort(axis=1) # Put the turbine coordinates into the final arrays in their sorted order # These are the coordinates that should be used within the internal calculations # such as the wake models and the solvers. - self.x_sorted = np.take_along_axis(_x, self.sorted_indices, axis=2) - self.y_sorted = np.take_along_axis(_y, self.sorted_indices, axis=2) - self.z_sorted = np.take_along_axis(_z, self.sorted_indices, axis=2) + self.x_sorted = np.take_along_axis(_x, self.sorted_indices, axis=1) + self.y_sorted = np.take_along_axis(_y, self.sorted_indices, axis=1) + self.z_sorted = np.take_along_axis(_z, self.sorted_indices, axis=1) # Now calculate grid coordinates in original frame (from 270 deg perspective) self.x_sorted_inertial_frame, self.y_sorted_inertial_frame, self.z_sorted_inertial_frame = \ @@ -302,9 +270,6 @@ class TurbineCubatureGrid(Grid): arrays with shape (N coordinates, 3). turbine_diameters (:py:obj:`NDArrayFloat`): The rotor diameters of each turbine. wind_directions (:py:obj:`NDArrayFloat`): Wind directions supplied by the user. - wind_speeds (:py:obj:`NDArrayFloat`): Wind speeds supplied by the user. - time_series (:py:obj:`bool`): Flag to indicate whether the supplied wind data is a time - series. grid_resolution (:py:obj:`int`): The number of points to include in the cubature method. This value must be in the range [1, 10], and the corresponding cubature weights are set automatically. @@ -345,8 +310,7 @@ def set_grid(self) -> None: # wind direction template_grid = np.ones( ( - self.n_wind_directions, - self.n_wind_speeds, + self.n_findex, self.n_turbines, len(yv), # Number of coordinates 1, @@ -372,13 +336,13 @@ def set_grid(self) -> None: # Put the turbine coordinates into the final arrays in their sorted order # These are the coordinates that should be used within the internal calculations # such as the wake models and the solvers. - self.x_sorted = np.take_along_axis(_x, self.sorted_indices, axis=2) - self.y_sorted = np.take_along_axis(_y, self.sorted_indices, axis=2) - self.z_sorted = np.take_along_axis(_z, self.sorted_indices, axis=2) + self.x_sorted = np.take_along_axis(_x, self.sorted_indices, axis=1) + self.y_sorted = np.take_along_axis(_y, self.sorted_indices, axis=1) + self.z_sorted = np.take_along_axis(_z, self.sorted_indices, axis=1) - self.x = np.take_along_axis(self.x_sorted, self.unsorted_indices, axis=2) - self.y = np.take_along_axis(self.y_sorted, self.unsorted_indices, axis=2) - self.z = np.take_along_axis(self.z_sorted, self.unsorted_indices, axis=2) + self.x = np.take_along_axis(self.x_sorted, self.unsorted_indices, axis=1) + self.y = np.take_along_axis(self.y_sorted, self.unsorted_indices, axis=1) + self.z = np.take_along_axis(self.z_sorted, self.unsorted_indices, axis=1) @classmethod def get_cubature_coefficients(cls, N: int): @@ -467,9 +431,6 @@ class FlowFieldGrid(Grid): arrays with shape (N coordinates, 3). turbine_diameters (:py:obj:`NDArrayFloat`): The rotor diameters of each turbine. wind_directions (:py:obj:`NDArrayFloat`): Wind directions supplied by the user. - wind_speeds (:py:obj:`NDArrayFloat`): Wind speeds supplied by the user. - time_series (:py:obj:`bool`): Flag to indicate whether the supplied wind data is a time - series. grid_resolution (:py:obj:`Iterable(int,)`): The number of grid points to create in each planar direction. Must be 3 components for resolution in the x, y, and z directions. """ @@ -539,9 +500,6 @@ class FlowFieldPlanarGrid(Grid): arrays with shape (N coordinates, 3). turbine_diameters (:py:obj:`NDArrayFloat`): The rotor diameters of each turbine. wind_directions (:py:obj:`NDArrayFloat`): Wind directions supplied by the user. - wind_speeds (:py:obj:`NDArrayFloat`): Wind speeds supplied by the user. - time_series (:py:obj:`bool`): Flag to indicate whether the supplied wind data is a time - series. grid_resolution (:py:obj:`Iterable(int,)`): The number of grid points to create in each planar direction. Must be 2 components for resolution in the x and y directions. The z direction is set to 3 planes at -10.0, 0.0, and +10.0 relative to the @@ -597,9 +555,9 @@ def set_grid(self) -> None: indexing="ij" ) - self.x_sorted = x_points[None, None, :, :, :] - self.y_sorted = y_points[None, None, :, :, :] - self.z_sorted = z_points[None, None, :, :, :] + self.x_sorted = x_points[None, :, :, :] + self.y_sorted = y_points[None, :, :, :] + self.z_sorted = z_points[None, :, :, :] elif self.normal_vector == "x": # Rules of thumb for cross plane if self.x1_bounds is None: @@ -615,9 +573,9 @@ def set_grid(self) -> None: indexing="ij" ) - self.x_sorted = x_points[None, None, :, :, :] - self.y_sorted = y_points[None, None, :, :, :] - self.z_sorted = z_points[None, None, :, :, :] + self.x_sorted = x_points[None, :, :, :] + self.y_sorted = y_points[None, :, :, :] + self.z_sorted = z_points[None, :, :, :] elif self.normal_vector == "y": # Rules of thumb for y plane if self.x1_bounds is None: @@ -633,9 +591,9 @@ def set_grid(self) -> None: indexing="ij" ) - self.x_sorted = x_points[None, None, :, :, :] - self.y_sorted = y_points[None, None, :, :, :] - self.z_sorted = z_points[None, None, :, :, :] + self.x_sorted = x_points[None, :, :, :] + self.y_sorted = y_points[None, :, :, :] + self.z_sorted = z_points[None, :, :, :] # Now calculate grid coordinates in original frame (from 270 deg perspective) self.x_sorted_inertial_frame, self.y_sorted_inertial_frame, self.z_sorted_inertial_frame = \ @@ -657,10 +615,6 @@ class PointsGrid(Grid): turbine_diameters (:py:obj:`NDArrayFloat`): Not used for PointsGrid, but required for the `Grid` super-class. wind_directions (:py:obj:`NDArrayFloat`): Wind directions supplied by the user. - wind_speeds (:py:obj:`NDArrayFloat`): Not used for PointsGrid, but - required for the `Grid` super-class. - time_series (:py:obj:`bool`): Not used for PointsGrid, but - required for the `Grid` super-class. grid_resolution (:py:obj:`int` | :py:obj:`Iterable(int,)`): Not used for PointsGrid, but required for the `Grid` super-class. @@ -698,6 +652,6 @@ def set_grid(self) -> None: x_center_of_rotation=self.x_center_of_rotation, y_center_of_rotation=self.y_center_of_rotation ) - self.x_sorted = x[:,:,:,None,None] - self.y_sorted = y[:,:,:,None,None] - self.z_sorted = z[:,:,:,None,None] + self.x_sorted = x[:,:,None,None] + self.y_sorted = y[:,:,None,None] + self.z_sorted = z[:,:,None,None] diff --git a/floris/core/rotor_velocity.py b/floris/core/rotor_velocity.py new file mode 100644 index 000000000..43d4e3077 --- /dev/null +++ b/floris/core/rotor_velocity.py @@ -0,0 +1,241 @@ + +from __future__ import annotations + +import copy +from collections.abc import Iterable + +import numpy as np +from scipy.interpolate import interp1d + +from floris.type_dec import ( + NDArrayBool, + NDArrayFilter, + NDArrayFloat, + NDArrayInt, + NDArrayObject, +) +from floris.utilities import cosd + + +def rotor_velocity_yaw_cosine_correction( + cosine_loss_exponent_yaw: float, + yaw_angles: NDArrayFloat, + rotor_effective_velocities: NDArrayFloat, +) -> NDArrayFloat: + # Compute the rotor effective velocity adjusting for yaw settings + pW = cosine_loss_exponent_yaw / 3.0 # Convert from cosine_loss_exponent_yaw to w + rotor_effective_velocities = rotor_effective_velocities * cosd(yaw_angles) ** pW + + return rotor_effective_velocities + +def rotor_velocity_tilt_cosine_correction( + tilt_angles: NDArrayFloat, + ref_tilt: NDArrayFloat, + cosine_loss_exponent_tilt: float, + tilt_interp: NDArrayObject, + correct_cp_ct_for_tilt: NDArrayBool, + rotor_effective_velocities: NDArrayFloat, +) -> NDArrayFloat: + # Compute the tilt, if using floating turbines + old_tilt_angle = copy.deepcopy(tilt_angles) + tilt_angles = compute_tilt_angles_for_floating_turbines( + tilt_angles, + tilt_interp, + rotor_effective_velocities, + ) + # Only update tilt angle if requested (if the tilt isn't accounted for in the Cp curve) + tilt_angles = np.where(correct_cp_ct_for_tilt, tilt_angles, old_tilt_angle) + + # Compute the rotor effective velocity adjusting for tilt + relative_tilt = tilt_angles - ref_tilt + rotor_effective_velocities = ( + rotor_effective_velocities + * cosd(relative_tilt) ** (cosine_loss_exponent_tilt / 3.0) + ) + return rotor_effective_velocities + +def simple_mean(array, axis=0): + return np.mean(array, axis=axis) + +def cubic_mean(array, axis=0): + return np.cbrt(np.mean(array ** 3.0, axis=axis)) + +def simple_cubature(array, cubature_weights, axis=0): + weights = cubature_weights.flatten() + weights = weights * len(weights) / np.sum(weights) + product = (array * weights[None, None, :, None]) + return simple_mean(product, axis) + +def cubic_cubature(array, cubature_weights, axis=0): + weights = cubature_weights.flatten() + weights = weights * len(weights) / np.sum(weights) + return np.cbrt(np.mean((array**3.0 * weights[None, None, :, None]), axis=axis)) + +def average_velocity( + velocities: NDArrayFloat, + ix_filter: NDArrayFilter | Iterable[int] | None = None, + method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None +) -> NDArrayFloat: + """This property calculates and returns the average of the velocity field + in turbine's rotor swept area. The average is calculated using the + user-specified method. This is a vectorized function, so it can be used + to calculate the average velocity for multiple turbines at once or + a single turbine. + + **Note:** The velocity is scaled to an effective velocity by the yaw. + + Args: + velocities (NDArrayFloat): The velocity field at each turbine; should be shape: + (number of turbines, ngrid, ngrid), or (ngrid, ngrid) for a single turbine. + ix_filter (NDArrayFilter | Iterable[int] | None], optional): The boolean array, or + integer indices (as an iterable or array) to filter out before calculation. + Defaults to None. + method (str, optional): The method to use for averaging. Options are: + - "simple-mean": The simple mean of the velocities + - "cubic-mean": The cubic mean of the velocities + - "simple-cubature": A cubature integration of the velocities + - "cubic-cubature": A cubature integration of the cube of the velocities + Defaults to "cubic-mean". + cubature_weights (NDArrayFloat, optional): The cubature weights to use for the + cubature integration methods. Defaults to None. + + Returns: + NDArrayFloat: The average velocity across the rotor(s). + """ + + # The input velocities are expected to be a 4 dimensional array with shape: + # (# findex, # turbines, grid resolution, grid resolution) + + if ix_filter is not None: + velocities = velocities[:, ix_filter] + + axis = tuple([2 + i for i in range(velocities.ndim - 2)]) + if method == "simple-mean": + return simple_mean(velocities, axis) + + elif method == "cubic-mean": + return cubic_mean(velocities, axis) + + elif method == "simple-cubature": + if cubature_weights is None: + raise ValueError("cubature_weights is required for 'simple-cubature' method.") + return simple_cubature(velocities, cubature_weights, axis) + + elif method == "cubic-cubature": + if cubature_weights is None: + raise ValueError("cubature_weights is required for 'cubic-cubature' method.") + return cubic_cubature(velocities, cubature_weights, axis) + + else: + raise ValueError("Incorrect method given.") + +def compute_tilt_angles_for_floating_turbines_map( + turbine_type_map: NDArrayObject, + tilt_angles: NDArrayFloat, + tilt_interps: dict[str, interp1d], + rotor_effective_velocities: NDArrayFloat, +) -> NDArrayFloat: + # Loop over each turbine type given to get tilt angles for all turbines + old_tilt_angles = copy.deepcopy(tilt_angles) + tilt_angles = np.zeros(np.shape(rotor_effective_velocities)) + turb_types = np.unique(turbine_type_map) + for turb_type in turb_types: + # If no tilt interpolation is specified, assume no modification to tilt + if tilt_interps[turb_type] is None: # Use passed tilt angles + tilt_angles += old_tilt_angles * (turbine_type_map == turb_type) + else: # Apply interpolated tilt angle + tilt_angles += compute_tilt_angles_for_floating_turbines( + tilt_angles, + tilt_interps[turb_type], + rotor_effective_velocities + ) * (turbine_type_map == turb_type) + + return tilt_angles + +def compute_tilt_angles_for_floating_turbines( + tilt_angles: NDArrayFloat, + tilt_interp: dict[str, interp1d], + rotor_effective_velocities: NDArrayFloat, +) -> NDArrayFloat: + # Loop over each turbine type given to get tilt angles for all turbines + # If no tilt interpolation is specified, assume no modification to tilt + if tilt_interp is None: + # TODO should this be break? Should it be continue? Do we want to support mixed + # fixed-bottom and floating? Or non-tilting floating? + pass + # Using a masked array, apply the tilt angle for all turbines of the current + # type to the main tilt angle array + else: + tilt_angles = tilt_interp(rotor_effective_velocities) + + return tilt_angles + +def rotor_effective_velocity( + air_density: float, + ref_air_density: float, + velocities: NDArrayFloat, + yaw_angle: NDArrayFloat, + tilt_angle: NDArrayFloat, + ref_tilt: NDArrayFloat, + cosine_loss_exponent_yaw: float, + cosine_loss_exponent_tilt: float, + tilt_interp: NDArrayObject, + correct_cp_ct_for_tilt: NDArrayBool, + turbine_type_map: NDArrayObject, + ix_filter: NDArrayInt | Iterable[int] | None = None, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None +) -> NDArrayFloat: + + if isinstance(yaw_angle, list): + yaw_angle = np.array(yaw_angle) + if isinstance(tilt_angle, list): + tilt_angle = np.array(tilt_angle) + + # Down-select inputs if ix_filter is given + if ix_filter is not None: + velocities = velocities[:, ix_filter] + yaw_angle = yaw_angle[:, ix_filter] + tilt_angle = tilt_angle[:, ix_filter] + ref_tilt = ref_tilt[:, ix_filter] + cosine_loss_exponent_yaw = cosine_loss_exponent_yaw[:, ix_filter] + cosine_loss_exponent_tilt = cosine_loss_exponent_tilt[:, ix_filter] + turbine_type_map = turbine_type_map[:, ix_filter] + + # Compute the rotor effective velocity adjusting for air density + average_velocities = average_velocity( + velocities, + method=average_method, + cubature_weights=cubature_weights + ) + rotor_effective_velocities = (air_density/ref_air_density)**(1/3) * average_velocities + + # Compute the rotor effective velocity adjusting for yaw settings + rotor_effective_velocities = rotor_velocity_yaw_cosine_correction( + cosine_loss_exponent_yaw, + yaw_angle, + rotor_effective_velocities + ) + + # Compute the tilt, if using floating turbines + rotor_effective_velocities = rotor_velocity_tilt_cosine_correction( + turbine_type_map, + tilt_angle, + ref_tilt, + cosine_loss_exponent_tilt, + tilt_interp, + correct_cp_ct_for_tilt, + rotor_effective_velocities, + ) + + return rotor_effective_velocities + +def rotor_velocity_air_density_correction( + velocities: NDArrayFloat, + air_density: float, + ref_air_density: float, +) -> NDArrayFloat: + # Produce equivalent velocities at the reference air density + + return (air_density/ref_air_density)**(1/3) * velocities diff --git a/floris/simulation/solver.py b/floris/core/solver.py similarity index 56% rename from floris/simulation/solver.py rename to floris/core/solver.py index f173a96e7..8307b27c8 100644 --- a/floris/simulation/solver.py +++ b/floris/core/solver.py @@ -1,14 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from __future__ import annotations @@ -16,29 +5,25 @@ import numpy as np -from floris.simulation import ( +from floris.core import ( axial_induction, - Ct, Farm, FlowField, FlowFieldGrid, FlowFieldPlanarGrid, PointsGrid, + thrust_coefficient, TurbineGrid, ) -from floris.simulation.turbine import average_velocity -from floris.simulation.turbine_multi_dim import ( - axial_induction_multidim, - Ct_multidim, - multidim_Ct_down_select, -) -from floris.simulation.wake import WakeModelManager -from floris.simulation.wake_deflection.empirical_gauss import yaw_added_wake_mixing -from floris.simulation.wake_deflection.gauss import ( +from floris.core.rotor_velocity import average_velocity +from floris.core.wake import WakeModelManager +from floris.core.wake_deflection.empirical_gauss import yaw_added_wake_mixing +from floris.core.wake_deflection.gauss import ( calculate_transverse_velocity, wake_added_yaw, yaw_added_turbulence_mixing, ) +from floris.core.wake_velocity.empirical_gauss import awc_added_wake_mixing from floris.type_dec import NDArrayFloat from floris.utilities import cosd @@ -81,63 +66,76 @@ def sequential_solver( v_wake = np.zeros_like(flow_field.v_initial_sorted) w_wake = np.zeros_like(flow_field.w_initial_sorted) - turbine_turbulence_intensity = ( - flow_field.turbulence_intensity - * np.ones((flow_field.n_wind_directions, flow_field.n_wind_speeds, farm.n_turbines, 1, 1)) - ) - ambient_turbulence_intensity = flow_field.turbulence_intensity + # Expand input turbulence intensity to 4d for (n_turbines, grid, grid) + turbine_turbulence_intensity = flow_field.turbulence_intensities[:, None, None, None] + turbine_turbulence_intensity = np.repeat(turbine_turbulence_intensity, farm.n_turbines, axis=1) + + # Ambient turbulent intensity should be a copy of n_findex-long turbulence_intensity + # with dimensions expanded for (n_turbines, grid, grid) + ambient_turbulence_intensities = flow_field.turbulence_intensities.copy() + ambient_turbulence_intensities = ambient_turbulence_intensities[:, None, None, None] # Calculate the velocity deficit sequentially from upstream to downstream turbines for i in range(grid.n_turbines): # Get the current turbine quantities - x_i = np.mean(grid.x_sorted[:, :, i:i+1], axis=(3, 4)) - x_i = x_i[:, :, :, None, None] - y_i = np.mean(grid.y_sorted[:, :, i:i+1], axis=(3, 4)) - y_i = y_i[:, :, :, None, None] - z_i = np.mean(grid.z_sorted[:, :, i:i+1], axis=(3, 4)) - z_i = z_i[:, :, :, None, None] + x_i = np.mean(grid.x_sorted[:, i:i+1], axis=(2, 3)) + x_i = x_i[:, :, None, None] + y_i = np.mean(grid.y_sorted[:, i:i+1], axis=(2, 3)) + y_i = y_i[:, :, None, None] + z_i = np.mean(grid.z_sorted[:, i:i+1], axis=(2, 3)) + z_i = z_i[:, :, None, None] - u_i = flow_field.u_sorted[:, :, i:i+1] - v_i = flow_field.v_sorted[:, :, i:i+1] + u_i = flow_field.u_sorted[:, i:i+1] + v_i = flow_field.v_sorted[:, i:i+1] - ct_i = Ct( + ct_i = thrust_coefficient( velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + air_density=flow_field.air_density, + yaw_angles=farm.yaw_angles_sorted, + tilt_angles=farm.tilt_angles_sorted, + power_setpoints=farm.power_setpoints_sorted, + awc_modes=farm.awc_modes_sorted, + awc_amplitudes=farm.awc_amplitudes_sorted, + thrust_coefficient_functions=farm.turbine_thrust_coefficient_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, ix_filter=[i], average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions ) - # Since we are filtering for the i'th turbine in the Ct function, + # Since we are filtering for the i'th turbine in the thrust coefficient function, # get the first index here (0:1) - ct_i = ct_i[:, :, 0:1, None, None] + ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + air_density=flow_field.air_density, + yaw_angles=farm.yaw_angles_sorted, + tilt_angles=farm.tilt_angles_sorted, + power_setpoints=farm.power_setpoints_sorted, + awc_modes=farm.awc_modes_sorted, + awc_amplitudes=farm.awc_amplitudes_sorted, + axial_induction_functions=farm.turbine_axial_induction_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, ix_filter=[i], average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions ) # Since we are filtering for the i'th turbine in the axial induction function, # get the first index here (0:1) - axial_induction_i = axial_induction_i[:, :, 0:1, None, None] - turbulence_intensity_i = turbine_turbulence_intensity[:, :, i:i+1] - yaw_angle_i = farm.yaw_angles_sorted[:, :, i:i+1, None, None] - hub_height_i = farm.hub_heights_sorted[:, :, i:i+1, None, None] - rotor_diameter_i = farm.rotor_diameters_sorted[:, :, i:i+1, None, None] - TSR_i = farm.TSRs_sorted[:, :, i:i+1, None, None] + axial_induction_i = axial_induction_i[:, 0:1, None, None] + turbulence_intensity_i = turbine_turbulence_intensity[:, i:i+1] + yaw_angle_i = farm.yaw_angles_sorted[:, i:i+1, None, None] + hub_height_i = farm.hub_heights_sorted[:, i:i+1, None, None] + rotor_diameter_i = farm.rotor_diameters_sorted[:, i:i+1, None, None] + TSR_i = farm.TSRs_sorted[:, i:i+1, None, None] effective_yaw_i = np.zeros_like(yaw_angle_i) effective_yaw_i += yaw_angle_i @@ -147,8 +145,8 @@ def sequential_solver( u_i, v_i, flow_field.u_initial_sorted, - grid.y_sorted[:, :, i:i+1] - y_i, - grid.z_sorted[:, :, i:i+1], + grid.y_sorted[:, i:i+1] - y_i, + grid.z_sorted[:, i:i+1], rotor_diameter_i, hub_height_i, ct_i, @@ -192,12 +190,12 @@ def sequential_solver( u_i, turbulence_intensity_i, v_i, - flow_field.w_sorted[:, :, i:i+1], - v_wake[:, :, i:i+1], - w_wake[:, :, i:i+1], + flow_field.w_sorted[:, i:i+1], + v_wake[:, i:i+1], + w_wake[:, i:i+1], ) gch_gain = 2 - turbine_turbulence_intensity[:, :, i:i+1] = turbulence_intensity_i + gch_gain * I_mixing + turbine_turbulence_intensity[:, i:i+1] = turbulence_intensity_i + gch_gain * I_mixing # NOTE: exponential velocity_deficit = model_manager.velocity_model.function( @@ -220,7 +218,7 @@ def sequential_solver( ) wake_added_turbulence_intensity = model_manager.turbulence_model.function( - ambient_turbulence_intensity, + ambient_turbulence_intensities, grid.x_sorted, x_i, rotor_diameter_i, @@ -229,10 +227,10 @@ def sequential_solver( # Calculate wake overlap for wake-added turbulence (WAT) area_overlap = ( - np.sum(velocity_deficit * flow_field.u_initial_sorted > 0.05, axis=(3, 4)) + np.sum(velocity_deficit * flow_field.u_initial_sorted > 0.05, axis=(2, 3)) / (grid.grid_resolution * grid.grid_resolution) ) - area_overlap = area_overlap[:, :, :, None, None] + area_overlap = area_overlap[:, :, None, None] # Modify wake added turbulence by wake area overlap downstream_influence_length = 15 * rotor_diameter_i @@ -246,8 +244,7 @@ def sequential_solver( # Combine turbine TIs with WAT turbine_turbulence_intensity = np.maximum( - np.sqrt( ti_added ** 2 + ambient_turbulence_intensity ** 2 ), - turbine_turbulence_intensity + np.sqrt(ti_added**2 + ambient_turbulence_intensities**2), turbine_turbulence_intensity ) flow_field.u_sorted = flow_field.u_initial_sorted - wake_field @@ -257,8 +254,8 @@ def sequential_solver( flow_field.turbulence_intensity_field_sorted = turbine_turbulence_intensity flow_field.turbulence_intensity_field_sorted_avg = np.mean( turbine_turbulence_intensity, - axis=(3,4) - )[:, :, :, None, None] + axis=(2,3) + )[:, :, None, None] def full_flow_sequential_solver( @@ -273,30 +270,25 @@ def full_flow_sequential_solver( turbine_grid_flow_field = copy.deepcopy(flow_field) turbine_grid_farm.construct_turbine_map() - turbine_grid_farm.construct_turbine_fCts() - turbine_grid_farm.construct_turbine_power_interps() + turbine_grid_farm.construct_turbine_thrust_coefficient_functions() + turbine_grid_farm.construct_turbine_axial_induction_functions() + turbine_grid_farm.construct_turbine_power_functions() turbine_grid_farm.construct_hub_heights() turbine_grid_farm.construct_rotor_diameters() turbine_grid_farm.construct_turbine_TSRs() - turbine_grid_farm.construct_turbine_pPs() - turbine_grid_farm.construct_turbine_pTs() - turbine_grid_farm.construct_turbine_ref_density_cp_cts() - turbine_grid_farm.construct_turbine_ref_tilt_cp_cts() + turbine_grid_farm.construct_turbine_ref_tilts() turbine_grid_farm.construct_turbine_tilt_interps() turbine_grid_farm.construct_turbine_correct_cp_ct_for_tilt() - turbine_grid_farm.set_tilt_to_ref_tilt(flow_field.n_wind_directions, flow_field.n_wind_speeds) + turbine_grid_farm.set_tilt_to_ref_tilt(flow_field.n_findex) turbine_grid = TurbineGrid( turbine_coordinates=turbine_grid_farm.coordinates, turbine_diameters=turbine_grid_farm.rotor_diameters, wind_directions=turbine_grid_flow_field.wind_directions, - wind_speeds=turbine_grid_flow_field.wind_speeds, grid_resolution=3, - time_series=turbine_grid_flow_field.time_series, ) turbine_grid_farm.expand_farm_properties( - turbine_grid_flow_field.n_wind_directions, - turbine_grid_flow_field.n_wind_speeds, + turbine_grid_flow_field.n_findex, turbine_grid.sorted_coord_indices, ) turbine_grid_flow_field.initialize_velocity_field(turbine_grid) @@ -323,50 +315,64 @@ def full_flow_sequential_solver( for i in range(flow_field_grid.n_turbines): # Get the current turbine quantities - x_i = np.mean(turbine_grid.x_sorted[:, :, i:i+1], axis=(3, 4)) - x_i = x_i[:, :, :, None, None] - y_i = np.mean(turbine_grid.y_sorted[:, :, i:i+1], axis=(3, 4)) - y_i = y_i[:, :, :, None, None] - z_i = np.mean(turbine_grid.z_sorted[:, :, i:i+1], axis=(3, 4)) - z_i = z_i[:, :, :, None, None] + x_i = np.mean(turbine_grid.x_sorted[:, i:i+1], axis=(2, 3)) + x_i = x_i[:, :, None, None] + y_i = np.mean(turbine_grid.y_sorted[:, i:i+1], axis=(2, 3)) + y_i = y_i[:, :, None, None] + z_i = np.mean(turbine_grid.z_sorted[:, i:i+1], axis=(2, 3)) + z_i = z_i[:, :, None, None] - u_i = turbine_grid_flow_field.u_sorted[:, :, i:i+1] - v_i = turbine_grid_flow_field.v_sorted[:, :, i:i+1] + u_i = turbine_grid_flow_field.u_sorted[:, i:i+1] + v_i = turbine_grid_flow_field.v_sorted[:, i:i+1] - ct_i = Ct( + ct_i = thrust_coefficient( velocities=turbine_grid_flow_field.u_sorted, - yaw_angle=turbine_grid_farm.yaw_angles_sorted, - tilt_angle=turbine_grid_farm.tilt_angles_sorted, - ref_tilt_cp_ct=turbine_grid_farm.ref_tilt_cp_cts_sorted, - fCt=turbine_grid_farm.turbine_fCts, - tilt_interp=turbine_grid_farm.turbine_tilt_interps, + air_density=turbine_grid_flow_field.air_density, + yaw_angles=turbine_grid_farm.yaw_angles_sorted, + tilt_angles=turbine_grid_farm.tilt_angles_sorted, + power_setpoints=turbine_grid_farm.power_setpoints_sorted, + awc_modes=turbine_grid_farm.awc_modes_sorted, + awc_amplitudes=turbine_grid_farm.awc_amplitudes_sorted, + thrust_coefficient_functions=turbine_grid_farm.turbine_thrust_coefficient_functions, + tilt_interps=turbine_grid_farm.turbine_tilt_interps, correct_cp_ct_for_tilt=turbine_grid_farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=turbine_grid_farm.turbine_type_map_sorted, + turbine_power_thrust_tables=turbine_grid_farm.turbine_power_thrust_tables, ix_filter=[i], + average_method=turbine_grid.average_method, + cubature_weights=turbine_grid.cubature_weights, + multidim_condition=turbine_grid_flow_field.multidim_conditions, ) - # Since we are filtering for the i'th turbine in the Ct function, + # Since we are filtering for the i'th turbine in the thrust_coefficient function, # get the first index here (0:1) - ct_i = ct_i[:, :, 0:1, None, None] + ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=turbine_grid_flow_field.u_sorted, - yaw_angle=turbine_grid_farm.yaw_angles_sorted, - tilt_angle=turbine_grid_farm.tilt_angles_sorted, - ref_tilt_cp_ct=turbine_grid_farm.ref_tilt_cp_cts_sorted, - fCt=turbine_grid_farm.turbine_fCts, - tilt_interp=turbine_grid_farm.turbine_tilt_interps, + air_density=turbine_grid_flow_field.air_density, + yaw_angles=turbine_grid_farm.yaw_angles_sorted, + tilt_angles=turbine_grid_farm.tilt_angles_sorted, + power_setpoints=turbine_grid_farm.power_setpoints_sorted, + awc_modes=turbine_grid_farm.awc_modes_sorted, + awc_amplitudes=turbine_grid_farm.awc_amplitudes_sorted, + axial_induction_functions=turbine_grid_farm.turbine_axial_induction_functions, + tilt_interps=turbine_grid_farm.turbine_tilt_interps, correct_cp_ct_for_tilt=turbine_grid_farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=turbine_grid_farm.turbine_type_map_sorted, + turbine_power_thrust_tables=turbine_grid_farm.turbine_power_thrust_tables, ix_filter=[i], + average_method=turbine_grid.average_method, + cubature_weights=turbine_grid.cubature_weights, + multidim_condition=turbine_grid_flow_field.multidim_conditions, ) # Since we are filtering for the i'th turbine in the axial induction function, # get the first index here (0:1) - axial_induction_i = axial_induction_i[:, :, 0:1, None, None] + axial_induction_i = axial_induction_i[:, 0:1, None, None] turbulence_intensity_i = \ - turbine_grid_flow_field.turbulence_intensity_field_sorted_avg[:, :, i:i+1] - yaw_angle_i = turbine_grid_farm.yaw_angles_sorted[:, :, i:i+1, None, None] - hub_height_i = turbine_grid_farm.hub_heights_sorted[:, :, i:i+1, None, None] - rotor_diameter_i = turbine_grid_farm.rotor_diameters_sorted[:, :, i:i+1, None, None] - TSR_i = turbine_grid_farm.TSRs_sorted[:, :, i:i+1, None, None] + turbine_grid_flow_field.turbulence_intensity_field_sorted_avg[:, i:i+1] + yaw_angle_i = turbine_grid_farm.yaw_angles_sorted[:, i:i+1, None, None] + hub_height_i = turbine_grid_farm.hub_heights_sorted[:, i:i+1, None, None] + rotor_diameter_i = turbine_grid_farm.rotor_diameters_sorted[:, i:i+1, None, None] + TSR_i = turbine_grid_farm.TSRs_sorted[:, i:i+1, None, None] effective_yaw_i = np.zeros_like(yaw_angle_i) effective_yaw_i += yaw_angle_i @@ -376,8 +382,8 @@ def full_flow_sequential_solver( u_i, v_i, turbine_grid_flow_field.u_initial_sorted, - turbine_grid.y_sorted[:, :, i:i+1] - y_i, - turbine_grid.z_sorted[:, :, i:i+1], + turbine_grid.y_sorted[:, i:i+1] - y_i, + turbine_grid.z_sorted[:, i:i+1], rotor_diameter_i, hub_height_i, ct_i, @@ -457,11 +463,14 @@ def cc_solver( turb_u_wake = np.zeros_like(flow_field.u_initial_sorted) turb_inflow_field = copy.deepcopy(flow_field.u_initial_sorted) - turbine_turbulence_intensity = ( - flow_field.turbulence_intensity - * np.ones((flow_field.n_wind_directions, flow_field.n_wind_speeds, farm.n_turbines, 1, 1)) - ) - ambient_turbulence_intensity = flow_field.turbulence_intensity + # Set up turbulence arrays + turbine_turbulence_intensity = flow_field.turbulence_intensities[:, None, None, None] + turbine_turbulence_intensity = np.repeat(turbine_turbulence_intensity, farm.n_turbines, axis=1) + + # Ambient turbulent intensity should be a copy of n_findex-long turbulence_intensities + # with extra dimension to reach 4d + ambient_turbulence_intensities = flow_field.turbulence_intensities.copy() + ambient_turbulence_intensities = ambient_turbulence_intensities[:, None, None, None] shape = (farm.n_turbines,) + np.shape(flow_field.u_initial_sorted) Ctmp = np.zeros((shape)) @@ -474,14 +483,14 @@ def cc_solver( for i in range(grid.n_turbines): # Get the current turbine quantities - x_i = np.mean(grid.x_sorted[:, :, i:i+1], axis=(3, 4)) - x_i = x_i[:, :, :, None, None] - y_i = np.mean(grid.y_sorted[:, :, i:i+1], axis=(3, 4)) - y_i = y_i[:, :, :, None, None] - z_i = np.mean(grid.z_sorted[:, :, i:i+1], axis=(3, 4)) - z_i = z_i[:, :, :, None, None] + x_i = np.mean(grid.x_sorted[:, i:i+1], axis=(2, 3)) + x_i = x_i[:, :, None, None] + y_i = np.mean(grid.y_sorted[:, i:i+1], axis=(2, 3)) + y_i = y_i[:, :, None, None] + z_i = np.mean(grid.z_sorted[:, i:i+1], axis=(2, 3)) + z_i = z_i[:, :, None, None] - rotor_diameter_i = farm.rotor_diameters_sorted[: ,:, i:i+1, None, None] + rotor_diameter_i = farm.rotor_diameters_sorted[:, i:i+1, None, None] mask2 = ( (grid.x_sorted < x_i + 0.01) @@ -495,57 +504,72 @@ def cc_solver( ) turb_avg_vels = average_velocity(turb_inflow_field) - turb_Cts = Ct( + turb_Cts = thrust_coefficient( turb_avg_vels, + flow_field.air_density, farm.yaw_angles_sorted, farm.tilt_angles_sorted, - farm.ref_tilt_cp_cts_sorted, - farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + farm.power_setpoints_sorted, + farm.awc_modes_sorted, + farm.awc_amplitudes_sorted, + farm.turbine_thrust_coefficient_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions, ) - turb_Cts = turb_Cts[:, :, :, None, None] + turb_Cts = turb_Cts[:, :, None, None] turb_aIs = axial_induction( turb_avg_vels, + flow_field.air_density, farm.yaw_angles_sorted, farm.tilt_angles_sorted, - farm.ref_tilt_cp_cts_sorted, - farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + farm.power_setpoints_sorted, + farm.awc_modes_sorted, + farm.awc_amplitudes_sorted, + farm.turbine_axial_induction_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, ix_filter=[i], average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions, ) - turb_aIs = turb_aIs[:, :, :, None, None] + turb_aIs = turb_aIs[:, :, None, None] - u_i = turb_inflow_field[:, :, i:i+1] - v_i = flow_field.v_sorted[:, :, i:i+1] + u_i = turb_inflow_field[:, i:i+1] + v_i = flow_field.v_sorted[:, i:i+1] axial_induction_i = axial_induction( velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + air_density=flow_field.air_density, + yaw_angles=farm.yaw_angles_sorted, + tilt_angles=farm.tilt_angles_sorted, + power_setpoints=farm.power_setpoints_sorted, + awc_modes=farm.awc_modes_sorted, + awc_amplitudes=farm.awc_amplitudes_sorted, + axial_induction_functions=farm.turbine_axial_induction_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, ix_filter=[i], average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions, ) - axial_induction_i = axial_induction_i[:, :, :, None, None] + axial_induction_i = axial_induction_i[:, :, None, None] - turbulence_intensity_i = turbine_turbulence_intensity[:, :, i:i+1] - yaw_angle_i = farm.yaw_angles_sorted[:, :, i:i+1, None, None] - hub_height_i = farm.hub_heights_sorted[:, :, i:i+1, None, None] - TSR_i = farm.TSRs_sorted[:, :, i:i+1, None, None] + turbulence_intensity_i = turbine_turbulence_intensity[:, i:i+1] + yaw_angle_i = farm.yaw_angles_sorted[:, i:i+1, None, None] + hub_height_i = farm.hub_heights_sorted[:, i:i+1, None, None] + TSR_i = farm.TSRs_sorted[:, i:i+1, None, None] effective_yaw_i = np.zeros_like(yaw_angle_i) effective_yaw_i += yaw_angle_i @@ -555,11 +579,11 @@ def cc_solver( u_i, v_i, flow_field.u_initial_sorted, - grid.y_sorted[:, :, i:i+1] - y_i, - grid.z_sorted[:, :, i:i+1], + grid.y_sorted[:, i:i+1] - y_i, + grid.z_sorted[:, i:i+1], rotor_diameter_i, hub_height_i, - turb_Cts[:, :, i:i+1], + turb_Cts[:, i:i+1], TSR_i, axial_induction_i, flow_field.wind_shear, @@ -574,7 +598,7 @@ def cc_solver( y_i, effective_yaw_i, turbulence_intensity_i, - turb_Cts[:, :, i:i+1], + turb_Cts[:, i:i+1], rotor_diameter_i, **deflection_model_args, ) @@ -590,7 +614,7 @@ def cc_solver( rotor_diameter_i, hub_height_i, yaw_angle_i, - turb_Cts[:, :, i:i+1], + turb_Cts[:, i:i+1], TSR_i, axial_induction_i, flow_field.wind_shear, @@ -602,12 +626,12 @@ def cc_solver( u_i, turbulence_intensity_i, v_i, - flow_field.w_sorted[:, :, i:i+1], - v_wake[:, :, i:i+1], - w_wake[:, :, i:i+1], + flow_field.w_sorted[:, i:i+1], + v_wake[:, i:i+1], + w_wake[:, i:i+1], ) gch_gain = 1.0 - turbine_turbulence_intensity[:, :, i:i+1] = turbulence_intensity_i + gch_gain * I_mixing + turbine_turbulence_intensity[:, i:i+1] = turbulence_intensity_i + gch_gain * I_mixing turb_u_wake, Ctmp = model_manager.velocity_model.function( i, @@ -619,14 +643,14 @@ def cc_solver( yaw_angle_i, turbine_turbulence_intensity, turb_Cts, - farm.rotor_diameters_sorted[:, :, :, None, None], + farm.rotor_diameters_sorted[:, :, None, None], turb_u_wake, Ctmp, **deficit_model_args, ) wake_added_turbulence_intensity = model_manager.turbulence_model.function( - ambient_turbulence_intensity, + ambient_turbulence_intensities, grid.x_sorted, x_i, rotor_diameter_i, @@ -635,10 +659,10 @@ def cc_solver( # Calculate wake overlap for wake-added turbulence (WAT) area_overlap = 1 - ( - np.sum(turb_u_wake <= 0.05, axis=(3, 4)) + np.sum(turb_u_wake <= 0.05, axis=(2, 3)) / (grid.grid_resolution * grid.grid_resolution) ) - area_overlap = area_overlap[:, :, :, None, None] + area_overlap = area_overlap[:, :, None, None] # Modify wake added turbulence by wake area overlap downstream_influence_length = 15 * rotor_diameter_i @@ -652,8 +676,7 @@ def cc_solver( # Combine turbine TIs with WAT turbine_turbulence_intensity = np.maximum( - np.sqrt(ti_added ** 2 + ambient_turbulence_intensity ** 2), - turbine_turbulence_intensity + np.sqrt(ti_added**2 + ambient_turbulence_intensities**2), turbine_turbulence_intensity ) flow_field.v_sorted += v_wake @@ -663,14 +686,14 @@ def cc_solver( flow_field.turbulence_intensity_field_sorted = turbine_turbulence_intensity flow_field.turbulence_intensity_field_sorted_avg = np.mean( turbine_turbulence_intensity, - axis=(3,4) + axis=(2,3) ) def full_flow_cc_solver( farm: Farm, flow_field: FlowField, - flow_field_grid: FlowFieldGrid, + flow_field_grid: FlowFieldGrid | FlowFieldPlanarGrid | PointsGrid, model_manager: WakeModelManager, ) -> None: # Get the flow quantities and turbine performance @@ -678,30 +701,25 @@ def full_flow_cc_solver( turbine_grid_flow_field = copy.deepcopy(flow_field) turbine_grid_farm.construct_turbine_map() - turbine_grid_farm.construct_turbine_fCts() - turbine_grid_farm.construct_turbine_power_interps() + turbine_grid_farm.construct_turbine_thrust_coefficient_functions() + turbine_grid_farm.construct_turbine_axial_induction_functions() + turbine_grid_farm.construct_turbine_power_functions() turbine_grid_farm.construct_hub_heights() turbine_grid_farm.construct_rotor_diameters() turbine_grid_farm.construct_turbine_TSRs() - turbine_grid_farm.construct_turbine_pPs() - turbine_grid_farm.construct_turbine_pTs() - turbine_grid_farm.construct_turbine_ref_density_cp_cts() - turbine_grid_farm.construct_turbine_ref_tilt_cp_cts() + turbine_grid_farm.construct_turbine_ref_tilts() turbine_grid_farm.construct_turbine_tilt_interps() turbine_grid_farm.construct_turbine_correct_cp_ct_for_tilt() - turbine_grid_farm.set_tilt_to_ref_tilt(flow_field.n_wind_directions, flow_field.n_wind_speeds) + turbine_grid_farm.set_tilt_to_ref_tilt(flow_field.n_findex) turbine_grid = TurbineGrid( turbine_coordinates=turbine_grid_farm.coordinates, turbine_diameters=turbine_grid_farm.rotor_diameters, wind_directions=turbine_grid_flow_field.wind_directions, - wind_speeds=turbine_grid_flow_field.wind_speeds, grid_resolution=3, - time_series=turbine_grid_flow_field.time_series, ) turbine_grid_farm.expand_farm_properties( - turbine_grid_flow_field.n_wind_directions, - turbine_grid_flow_field.n_wind_speeds, + turbine_grid_flow_field.n_findex, turbine_grid.sorted_coord_indices, ) turbine_grid_flow_field.initialize_velocity_field(turbine_grid) @@ -731,52 +749,62 @@ def full_flow_cc_solver( for i in range(flow_field_grid.n_turbines): # Get the current turbine quantities - x_i = np.mean(turbine_grid.x_sorted[:, :, i:i+1], axis=(3, 4)) - x_i = x_i[:, :, :, None, None] - y_i = np.mean(turbine_grid.y_sorted[:, :, i:i+1], axis=(3, 4)) - y_i = y_i[:, :, :, None, None] - z_i = np.mean(turbine_grid.z_sorted[:, :, i:i+1], axis=(3, 4)) - z_i = z_i[:, :, :, None, None] + x_i = np.mean(turbine_grid.x_sorted[:, i:i+1], axis=(2, 3)) + x_i = x_i[:, :, None, None] + y_i = np.mean(turbine_grid.y_sorted[:, i:i+1], axis=(2, 3)) + y_i = y_i[:, :, None, None] + z_i = np.mean(turbine_grid.z_sorted[:, i:i+1], axis=(2, 3)) + z_i = z_i[:, :, None, None] - u_i = turbine_grid_flow_field.u_sorted[:, :, i:i+1] - v_i = turbine_grid_flow_field.v_sorted[:, :, i:i+1] + u_i = turbine_grid_flow_field.u_sorted[:, i:i+1] + v_i = turbine_grid_flow_field.v_sorted[:, i:i+1] turb_avg_vels = average_velocity(turbine_grid_flow_field.u_sorted) - turb_Cts = Ct( + turb_Cts = thrust_coefficient( velocities=turb_avg_vels, - yaw_angle=turbine_grid_farm.yaw_angles_sorted, - tilt_angle=turbine_grid_farm.tilt_angles_sorted, - ref_tilt_cp_ct=turbine_grid_farm.ref_tilt_cp_cts_sorted, - fCt=turbine_grid_farm.turbine_fCts, - tilt_interp=turbine_grid_farm.turbine_tilt_interps, + air_density=turbine_grid_flow_field.air_density, + yaw_angles=turbine_grid_farm.yaw_angles_sorted, + tilt_angles=turbine_grid_farm.tilt_angles_sorted, + power_setpoints=turbine_grid_farm.power_setpoints_sorted, + awc_modes=turbine_grid_farm.awc_modes, + awc_amplitudes=turbine_grid_farm.awc_amplitudes_sorted, + thrust_coefficient_functions=turbine_grid_farm.turbine_thrust_coefficient_functions, + tilt_interps=turbine_grid_farm.turbine_tilt_interps, correct_cp_ct_for_tilt=turbine_grid_farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=turbine_grid_farm.turbine_type_map_sorted, + turbine_power_thrust_tables=turbine_grid_farm.turbine_power_thrust_tables, average_method=turbine_grid.average_method, - cubature_weights=turbine_grid.cubature_weights + cubature_weights=turbine_grid.cubature_weights, + multidim_condition=turbine_grid_flow_field.multidim_conditions, ) - turb_Cts = turb_Cts[:, :, :, None, None] + turb_Cts = turb_Cts[:, :, None, None] axial_induction_i = axial_induction( velocities=turbine_grid_flow_field.u_sorted, - yaw_angle=turbine_grid_farm.yaw_angles_sorted, - tilt_angle=turbine_grid_farm.tilt_angles_sorted, - ref_tilt_cp_ct=turbine_grid_farm.ref_tilt_cp_cts_sorted, - fCt=turbine_grid_farm.turbine_fCts, - tilt_interp=turbine_grid_farm.turbine_tilt_interps, + air_density=turbine_grid_flow_field.air_density, + yaw_angles=turbine_grid_farm.yaw_angles_sorted, + tilt_angles=turbine_grid_farm.tilt_angles_sorted, + power_setpoints=turbine_grid_farm.power_setpoints_sorted, + awc_modes=turbine_grid_farm.awc_modes, + awc_amplitudes=turbine_grid_farm.awc_amplitudes_sorted, + axial_induction_functions=turbine_grid_farm.turbine_axial_induction_functions, + tilt_interps=turbine_grid_farm.turbine_tilt_interps, correct_cp_ct_for_tilt=turbine_grid_farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=turbine_grid_farm.turbine_type_map_sorted, + turbine_power_thrust_tables=turbine_grid_farm.turbine_power_thrust_tables, ix_filter=[i], average_method=turbine_grid.average_method, - cubature_weights=turbine_grid.cubature_weights + cubature_weights=turbine_grid.cubature_weights, + multidim_condition=turbine_grid_flow_field.multidim_conditions, ) - axial_induction_i = axial_induction_i[:, :, :, None, None] + axial_induction_i = axial_induction_i[:, :, None, None] turbulence_intensity_i = \ - turbine_grid_flow_field.turbulence_intensity_field_sorted_avg[:, :, i:i+1] - yaw_angle_i = turbine_grid_farm.yaw_angles_sorted[:, :, i:i+1, None, None] - hub_height_i = turbine_grid_farm.hub_heights_sorted[:, :, i:i+1, None, None] - rotor_diameter_i = turbine_grid_farm.rotor_diameters_sorted[:, :, i:i+1, None, None] - TSR_i = turbine_grid_farm.TSRs_sorted[:, :, i:i+1, None, None] + turbine_grid_flow_field.turbulence_intensity_field_sorted_avg[:, i:i+1] + yaw_angle_i = turbine_grid_farm.yaw_angles_sorted[:, i:i+1, None, None] + hub_height_i = turbine_grid_farm.hub_heights_sorted[:, i:i+1, None, None] + rotor_diameter_i = turbine_grid_farm.rotor_diameters_sorted[:, i:i+1, None, None] + TSR_i = turbine_grid_farm.TSRs_sorted[:, i:i+1, None, None] effective_yaw_i = np.zeros_like(yaw_angle_i) effective_yaw_i += yaw_angle_i @@ -786,11 +814,11 @@ def full_flow_cc_solver( u_i, v_i, turbine_grid_flow_field.u_initial_sorted, - turbine_grid.y_sorted[:, :, i:i+1] - y_i, - turbine_grid.z_sorted[:, :, i:i+1], + turbine_grid.y_sorted[:, i:i+1] - y_i, + turbine_grid.z_sorted[:, i:i+1], rotor_diameter_i, hub_height_i, - turb_Cts[:, :, i:i+1], + turb_Cts[:, i:i+1], TSR_i, axial_induction_i, flow_field.wind_shear, @@ -805,7 +833,7 @@ def full_flow_cc_solver( y_i, effective_yaw_i, turbulence_intensity_i, - turb_Cts[:, :, i:i+1], + turb_Cts[:, i:i+1], rotor_diameter_i, **deflection_model_args, ) @@ -821,7 +849,7 @@ def full_flow_cc_solver( rotor_diameter_i, hub_height_i, yaw_angle_i, - turb_Cts[:, :, i:i+1], + turb_Cts[:, i:i+1], TSR_i, axial_induction_i, flow_field.wind_shear, @@ -839,7 +867,7 @@ def full_flow_cc_solver( yaw_angle_i, turbine_grid_flow_field.turbulence_intensity_field_sorted_avg, turb_Cts, - turbine_grid_farm.rotor_diameters_sorted[:, :, :, None, None], + turbine_grid_farm.rotor_diameters_sorted[:, :, None, None], turb_u_wake, Ctmp, **deficit_model_args, @@ -874,126 +902,132 @@ def turbopark_solver( velocity_deficit = np.zeros(shape) deflection_field = np.zeros_like(flow_field.u_initial_sorted) - turbine_turbulence_intensity = ( - flow_field.turbulence_intensity - * np.ones((flow_field.n_wind_directions, flow_field.n_wind_speeds, farm.n_turbines, 1, 1)) - ) - ambient_turbulence_intensity = flow_field.turbulence_intensity + # Set up turbulence arrays + turbine_turbulence_intensity = flow_field.turbulence_intensities[:, None, None, None] + turbine_turbulence_intensity = np.repeat(turbine_turbulence_intensity, farm.n_turbines, axis=1) + + # Ambient turbulent intensity should be a copy of n_findex-long turbulence_intensities + # with extra dimension to reach 4d + ambient_turbulence_intensities = flow_field.turbulence_intensities.copy() + ambient_turbulence_intensities = ambient_turbulence_intensities[:, None, None, None] # Calculate the velocity deficit sequentially from upstream to downstream turbines for i in range(grid.n_turbines): # Get the current turbine quantities - x_i = np.mean(grid.x_sorted[:, :, i:i+1], axis=(3, 4)) - x_i = x_i[:, :, :, None, None] - y_i = np.mean(grid.y_sorted[:, :, i:i+1], axis=(3, 4)) - y_i = y_i[:, :, :, None, None] - z_i = np.mean(grid.z_sorted[:, :, i:i+1], axis=(3, 4)) - z_i = z_i[:, :, :, None, None] - - u_i = flow_field.u_sorted[:, :, i:i+1] - v_i = flow_field.v_sorted[:, :, i:i+1] - - Cts = Ct( + x_i = np.mean(grid.x_sorted[:, i:i+1], axis=(2, 3)) + x_i = x_i[:, :, None, None] + y_i = np.mean(grid.y_sorted[:, i:i+1], axis=(2, 3)) + y_i = y_i[:, :, None, None] + z_i = np.mean(grid.z_sorted[:, i:i+1], axis=(2, 3)) + z_i = z_i[:, :, None, None] + + Cts = thrust_coefficient( velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + air_density=flow_field.air_density, + yaw_angles=farm.yaw_angles_sorted, + tilt_angles=farm.tilt_angles_sorted, + power_setpoints=farm.power_setpoints_sorted, + awc_modes=farm.awc_modes, + awc_amplitudes=farm.awc_amplitudes_sorted, + thrust_coefficient_functions=farm.turbine_thrust_coefficient_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions, ) - ct_i = Ct( + ct_i = thrust_coefficient( velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + air_density=flow_field.air_density, + yaw_angles=farm.yaw_angles_sorted, + tilt_angles=farm.tilt_angles_sorted, + power_setpoints=farm.power_setpoints_sorted, + awc_modes=farm.awc_modes, + awc_amplitudes=farm.awc_amplitudes_sorted, + thrust_coefficient_functions=farm.turbine_thrust_coefficient_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, ix_filter=[i], average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions, ) - # Since we are filtering for the i'th turbine in the Ct function, + # Since we are filtering for the i'th turbine in the thrust coefficient function, # get the first index here (0:1) - ct_i = ct_i[:, :, 0:1, None, None] + ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + air_density=flow_field.air_density, + yaw_angles=farm.yaw_angles_sorted, + tilt_angles=farm.tilt_angles_sorted, + power_setpoints=farm.power_setpoints_sorted, + awc_modes=farm.awc_modes, + awc_amplitudes=farm.awc_amplitudes_sorted, + axial_induction_functions=farm.turbine_axial_induction_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, ix_filter=[i], average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions, ) # Since we are filtering for the i'th turbine in the axial induction function, # get the first index here (0:1) - axial_induction_i = axial_induction_i[:, :, 0:1, None, None] - turbulence_intensity_i = turbine_turbulence_intensity[:, :, i:i+1] - yaw_angle_i = farm.yaw_angles_sorted[:, :, i:i+1, None, None] - hub_height_i = farm.hub_heights_sorted[:, :, i:i+1, None, None] - rotor_diameter_i = farm.rotor_diameters_sorted[:, :, i:i+1, None, None] - TSR_i = farm.TSRs_sorted[:, :, i:i+1, None, None] + axial_induction_i = axial_induction_i[:, 0:1, None, None] + yaw_angle_i = farm.yaw_angles_sorted[:, i:i+1, None, None] + rotor_diameter_i = farm.rotor_diameters_sorted[:, i:i+1, None, None] effective_yaw_i = np.zeros_like(yaw_angle_i) effective_yaw_i += yaw_angle_i + if model_manager.enable_secondary_steering: - added_yaw = wake_added_yaw( - u_i, - v_i, - flow_field.u_initial_sorted, - grid.y_sorted[:, :, i:i+1] - y_i, - grid.z_sorted[:, :, i:i+1], - rotor_diameter_i, - hub_height_i, - ct_i, - TSR_i, - axial_induction_i, - flow_field.wind_shear, - ) - effective_yaw_i += added_yaw + raise NotImplementedError( + "Secondary steering not available for this model.") # Model calculations # NOTE: exponential if np.any(farm.yaw_angles_sorted): model_manager.deflection_model.logger.warning( - "WARNING: Deflection with the TurbOPark model has not been fully validated." - "This is an initial implementation, and we advise you use at your own risk" + "WARNING: Deflection with the TurbOPark model has not been fully validated. " + "This is an initial implementation, and we advise you use at your own risk " "and perform a thorough examination of the results." ) for ii in range(i): - x_ii = np.mean(grid.x_sorted[:, :, ii:ii+1], axis=(3, 4)) - x_ii = x_ii[:, :, :, None, None] - y_ii = np.mean(grid.y_sorted[:, :, ii:ii+1], axis=(3, 4)) - y_ii = y_ii[:, :, :, None, None] - - yaw_ii = farm.yaw_angles_sorted[:, :, ii:ii+1, None, None] - turbulence_intensity_ii = turbine_turbulence_intensity[:, :, ii:ii+1] - ct_ii = Ct( + x_ii = np.mean(grid.x_sorted[:, ii:ii+1], axis=(2, 3)) + x_ii = x_ii[:, :, None, None] + y_ii = np.mean(grid.y_sorted[:, ii:ii+1], axis=(2, 3)) + y_ii = y_ii[:, :, None, None] + + yaw_ii = farm.yaw_angles_sorted[:, ii:ii+1, None, None] + turbulence_intensity_ii = turbine_turbulence_intensity[:, ii:ii+1] + ct_ii = thrust_coefficient( velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + air_density=flow_field.air_density, + yaw_angles=farm.yaw_angles_sorted, + tilt_angles=farm.tilt_angles_sorted, + power_setpoints=farm.power_setpoints_sorted, + awc_modes=farm.awc_modes, + awc_amplitudes=farm.awc_amplitudes_sorted, + thrust_coefficient_functions=farm.turbine_thrust_coefficient_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, ix_filter=[ii], average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions, ) - ct_ii = ct_ii[:, :, 0:1, None, None] - rotor_diameter_ii = farm.rotor_diameters_sorted[:, :, ii:ii+1, None, None] + ct_ii = ct_ii[:, 0:1, None, None] + rotor_diameter_ii = farm.rotor_diameters_sorted[:, ii:ii+1, None, None] deflection_field_ii = model_manager.deflection_model.function( x_ii, @@ -1005,36 +1039,15 @@ def turbopark_solver( **deflection_model_args, ) - deflection_field[:, :, ii:ii+1, :, :] = deflection_field_ii[:, :, i:i+1, :, :] + deflection_field[:, ii:ii+1, :, :] = deflection_field_ii[:, i:i+1, :, :] if model_manager.enable_transverse_velocities: - v_wake, w_wake = calculate_transverse_velocity( - u_i, - flow_field.u_initial_sorted, - flow_field.dudz_initial_sorted, - grid.x_sorted - x_i, - grid.y_sorted - y_i, - grid.z_sorted, - rotor_diameter_i, - hub_height_i, - yaw_angle_i, - ct_i, - TSR_i, - axial_induction_i, - flow_field.wind_shear, - ) + raise NotImplementedError( + "Transverse velocities not used in this model.") if model_manager.enable_yaw_added_recovery: - I_mixing = yaw_added_turbulence_mixing( - u_i, - turbulence_intensity_i, - v_i, - flow_field.w_sorted[:, :, i:i+1], - v_wake[:, :, i:i+1], - w_wake[:, :, i:i+1], - ) - gch_gain = 2 - turbine_turbulence_intensity[:, :, i:i+1] = turbulence_intensity_i + gch_gain * I_mixing + raise NotImplementedError( + "Yaw added recovery not used in this model.") # NOTE: exponential velocity_deficit = model_manager.velocity_model.function( @@ -1042,9 +1055,9 @@ def turbopark_solver( y_i, z_i, turbine_turbulence_intensity, - Cts[:, :, :, None, None], + Cts[:, :, None, None], rotor_diameter_i, - farm.rotor_diameters_sorted[:, :, :, None, None], + farm.rotor_diameters_sorted[:, :, None, None], i, deflection_field, **deficit_model_args, @@ -1056,7 +1069,7 @@ def turbopark_solver( ) wake_added_turbulence_intensity = model_manager.turbulence_model.function( - ambient_turbulence_intensity, + ambient_turbulence_intensities, grid.x_sorted, x_i, rotor_diameter_i, @@ -1068,10 +1081,10 @@ def turbopark_solver( # turbines; could use WAT_upstream # Calculate wake overlap for wake-added turbulence (WAT) area_overlap = ( - np.sum(velocity_deficit * flow_field.u_initial_sorted > 0.05, axis=(3, 4)) + np.sum(velocity_deficit * flow_field.u_initial_sorted > 0.05, axis=(2, 3)) / (grid.grid_resolution * grid.grid_resolution) ) - area_overlap = area_overlap[:, :, :, None, None] + area_overlap = area_overlap[:, :, None, None] # Modify wake added turbulence by wake area overlap downstream_influence_length = 15 * rotor_diameter_i @@ -1085,8 +1098,7 @@ def turbopark_solver( # Combine turbine TIs with WAT turbine_turbulence_intensity = np.maximum( - np.sqrt( ti_added ** 2 + ambient_turbulence_intensity ** 2 ), - turbine_turbulence_intensity + np.sqrt(ti_added**2 + ambient_turbulence_intensities**2), turbine_turbulence_intensity ) flow_field.u_sorted = flow_field.u_initial_sorted - wake_field @@ -1096,7 +1108,7 @@ def turbopark_solver( flow_field.turbulence_intensity_field_sorted = turbine_turbulence_intensity flow_field.turbulence_intensity_field_sorted_avg = np.mean( turbine_turbulence_intensity, - axis=(3,4) + axis=(2, 3) ) @@ -1108,48 +1120,6 @@ def full_flow_turbopark_solver( ) -> None: raise NotImplementedError("Plotting for the TurbOPark model is not currently implemented.") - # TODO: Below is a first attempt at plotting, and uses just the values on the rotor. - # The current TurbOPark model requires that points to be calculated are only at turbine - # locations. Modification will be required to allow for full flow field calculations. - - # # Get the flow quantities and turbine performance - # turbine_grid_farm = copy.deepcopy(farm) - # turbine_grid_flow_field = copy.deepcopy(flow_field) - - # turbine_grid_farm.construct_turbine_map() - # turbine_grid_farm.construct_turbine_fCts() - # turbine_grid_farm.construct_turbine_power_interps() - # turbine_grid_farm.construct_hub_heights() - # turbine_grid_farm.construct_rotor_diameters() - # turbine_grid_farm.construct_turbine_TSRs() - # turbine_grid_farm.construc_turbine_pPs() - - # turbine_grid = TurbineGrid( - # turbine_coordinates=turbine_grid_farm.coordinates, - # turbine_diameters=turbine_grid_farm.rotor_diameters, - # wind_directions=turbine_grid_flow_field.wind_directions, - # wind_speeds=turbine_grid_flow_field.wind_speeds, - # grid_resolution=11, - # ) - # turbine_grid_farm.expand_farm_properties( - # turbine_grid_flow_field.n_wind_directions, - # turbine_grid_flow_field.n_wind_speeds, - # turbine_grid.sorted_coord_indices - # ) - # turbine_grid_flow_field.initialize_velocity_field(turbine_grid) - # turbine_grid_farm.initialize(turbine_grid.sorted_indices) - # turbopark_solver(turbine_grid_farm, turbine_grid_flow_field, turbine_grid, model_manager) - - - - # flow_field.u = copy.deepcopy(turbine_grid_flow_field.u) - # flow_field.v = copy.deepcopy(turbine_grid_flow_field.v) - # flow_field.w = copy.deepcopy(turbine_grid_flow_field.w) - - # flow_field_grid.x = copy.deepcopy(turbine_grid.x) - # flow_field_grid.y = copy.deepcopy(turbine_grid.y) - # flow_field_grid.z = copy.deepcopy(turbine_grid.z) - def empirical_gauss_solver( farm: Farm, @@ -1188,67 +1158,85 @@ def empirical_gauss_solver( v_wake = np.zeros_like(flow_field.v_initial_sorted) w_wake = np.zeros_like(flow_field.w_initial_sorted) - x_locs = np.mean(grid.x_sorted, axis=(3, 4))[:,:,:,None] - downstream_distance_D = x_locs - np.transpose(x_locs, axes=(0,1,3,2)) + x_locs = np.mean(grid.x_sorted, axis=(2, 3))[:,:,None] + downstream_distance_D = x_locs - np.transpose(x_locs, axes=(0,2,1)) downstream_distance_D = downstream_distance_D / \ - np.repeat(farm.rotor_diameters_sorted[:,:,:,None], grid.n_turbines, axis=-1) + np.repeat(farm.rotor_diameters_sorted[:,:,None], grid.n_turbines, axis=-1) downstream_distance_D = np.maximum(downstream_distance_D, 0.1) # For ease - mixing_factor = np.zeros_like(downstream_distance_D) - mixing_factor[:,:,:,:] = model_manager.turbulence_model.atmospheric_ti_gain*\ - flow_field.turbulence_intensity*np.eye(grid.n_turbines) + # Initialize the mixing factor model using TI if specified + initial_mixing_factor = model_manager.turbulence_model.atmospheric_ti_gain * np.eye( + grid.n_turbines + ) + mixing_factor = np.repeat( + initial_mixing_factor[None, :, :], + flow_field.n_findex, + axis=0 + ) + mixing_factor = mixing_factor * flow_field.turbulence_intensities[:, None, None] # Calculate the velocity deficit sequentially from upstream to downstream turbines for i in range(grid.n_turbines): # Get the current turbine quantities - x_i = np.mean(grid.x_sorted[:, :, i:i+1], axis=(3, 4)) - x_i = x_i[:, :, :, None, None] - y_i = np.mean(grid.y_sorted[:, :, i:i+1], axis=(3, 4)) - y_i = y_i[:, :, :, None, None] - z_i = np.mean(grid.z_sorted[:, :, i:i+1], axis=(3, 4)) - z_i = z_i[:, :, :, None, None] - - flow_field.u_sorted[:, :, i:i+1] - flow_field.v_sorted[:, :, i:i+1] - - ct_i = Ct( + x_i = np.mean(grid.x_sorted[:, i:i+1], axis=(2, 3)) + x_i = x_i[:, :, None, None] + y_i = np.mean(grid.y_sorted[:, i:i+1], axis=(2, 3)) + y_i = y_i[:, :, None, None] + z_i = np.mean(grid.z_sorted[:, i:i+1], axis=(2, 3)) + z_i = z_i[:, :, None, None] + + ct_i = thrust_coefficient( velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + air_density=flow_field.air_density, + yaw_angles=farm.yaw_angles_sorted, + tilt_angles=farm.tilt_angles_sorted, + power_setpoints=farm.power_setpoints_sorted, + awc_modes=farm.awc_modes_sorted, + awc_amplitudes=farm.awc_amplitudes_sorted, + thrust_coefficient_functions=farm.turbine_thrust_coefficient_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, ix_filter=[i], average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions, ) - # Since we are filtering for the i'th turbine in the Ct function, + # Since we are filtering for the i'th turbine in the thrust coefficient function, # get the first index here (0:1) - ct_i = ct_i[:, :, 0:1, None, None] + ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=farm.turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, + air_density=flow_field.air_density, + yaw_angles=farm.yaw_angles_sorted, + tilt_angles=farm.tilt_angles_sorted, + power_setpoints=farm.power_setpoints_sorted, + awc_modes=farm.awc_modes_sorted, + awc_amplitudes=farm.awc_amplitudes_sorted, + axial_induction_functions=farm.turbine_axial_induction_functions, + tilt_interps=farm.turbine_tilt_interps, correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=farm.turbine_type_map_sorted, + turbine_power_thrust_tables=farm.turbine_power_thrust_tables, ix_filter=[i], average_method=grid.average_method, - cubature_weights=grid.cubature_weights + cubature_weights=grid.cubature_weights, + multidim_condition=flow_field.multidim_conditions, ) # Since we are filtering for the i'th turbine in the axial induction function, # get the first index here (0:1) - axial_induction_i = axial_induction_i[:, :, 0:1, None, None] - yaw_angle_i = farm.yaw_angles_sorted[:, :, i:i+1, None, None] - hub_height_i = farm.hub_heights_sorted[: ,:, i:i+1, None, None] - rotor_diameter_i = farm.rotor_diameters_sorted[: ,:, i:i+1, None, None] - - effective_yaw_i = np.zeros_like(yaw_angle_i) - effective_yaw_i += yaw_angle_i + axial_induction_i = axial_induction_i[:, 0:1, None, None] + yaw_angle_i = farm.yaw_angles_sorted[:, i:i+1, None, None] + awc_mode_i = farm.awc_modes_sorted[:, i:i+1, None, None] + awc_amplitude_i = farm.awc_amplitudes_sorted[:, i:i+1, None, None] + awc_frequency_i = farm.awc_frequencies_sorted[:, i:i+1, None, None] + hub_height_i = farm.hub_heights_sorted[:, i:i+1, None, None] + rotor_diameter_i = farm.rotor_diameters_sorted[:, i:i+1, None, None] + + # Secondary steering not currently implemented in EmGauss model + # effective_yaw_i = np.zeros_like(yaw_angle_i) + # effective_yaw_i += yaw_angle_i average_velocities = average_velocity( flow_field.u_sorted, @@ -1256,7 +1244,7 @@ def empirical_gauss_solver( cubature_weights=grid.cubature_weights ) tilt_angle_i = farm.calculate_tilt_for_eff_velocities(average_velocities) - tilt_angle_i = tilt_angle_i[:, :, i:i+1, None, None] + tilt_angle_i = tilt_angle_i[:, i:i+1, None, None] if model_manager.enable_secondary_steering: raise NotImplementedError( @@ -1268,7 +1256,7 @@ def empirical_gauss_solver( if model_manager.enable_yaw_added_recovery: # Influence of yawing on turbine's own wake - mixing_factor[:, :, i:i+1, i] += \ + mixing_factor[:, i:i+1, i] += \ yaw_added_wake_mixing( axial_induction_i, yaw_angle_i, @@ -1276,10 +1264,21 @@ def empirical_gauss_solver( model_manager.deflection_model.yaw_added_mixing_gain ) + if model_manager.enable_active_wake_mixing: + # Influence of awc on turbine's own wake + mixing_factor[:, i:i+1, i] += \ + awc_added_wake_mixing( + awc_mode_i, + awc_amplitude_i, + awc_frequency_i, + model_manager.velocity_model.awc_wake_exp, + model_manager.velocity_model.awc_wake_denominator + ) + # Extract total wake induced mixing for turbine i mixing_i = np.linalg.norm( - mixing_factor[:, :, i:i+1, :, None], - ord=2, axis=3, keepdims=True + mixing_factor[:, i:i+1, :, None], + ord=2, axis=2, keepdims=True ) # Model calculations @@ -1287,7 +1286,7 @@ def empirical_gauss_solver( deflection_field_y, deflection_field_z = model_manager.deflection_model.function( x_i, y_i, - effective_yaw_i, + yaw_angle_i, tilt_angle_i, mixing_i, ct_i, @@ -1318,20 +1317,20 @@ def empirical_gauss_solver( ) # Calculate wake overlap for wake-added turbulence (WAT) - area_overlap = np.sum(velocity_deficit * flow_field.u_initial_sorted > 0.05, axis=(3, 4))\ + area_overlap = np.sum(velocity_deficit * flow_field.u_initial_sorted > 0.05, axis=(2, 3))\ / (grid.grid_resolution * grid.grid_resolution) # Compute wake induced mixing factor - mixing_factor[:,:,:,i] += \ + mixing_factor[:,:,i] += \ area_overlap * model_manager.turbulence_model.function( - axial_induction_i, downstream_distance_D[:,:,:,i] + axial_induction_i, downstream_distance_D[:,:,i] ) if model_manager.enable_yaw_added_recovery: - mixing_factor[:,:,:,i] += \ + mixing_factor[:,:,i] += \ area_overlap * yaw_added_wake_mixing( axial_induction_i, yaw_angle_i, - downstream_distance_D[:,:,:,i], + downstream_distance_D[:,:,i], model_manager.deflection_model.yaw_added_mixing_gain ) @@ -1354,30 +1353,25 @@ def full_flow_empirical_gauss_solver( turbine_grid_flow_field = copy.deepcopy(flow_field) turbine_grid_farm.construct_turbine_map() - turbine_grid_farm.construct_turbine_fCts() - turbine_grid_farm.construct_turbine_power_interps() + turbine_grid_farm.construct_turbine_thrust_coefficient_functions() + turbine_grid_farm.construct_turbine_axial_induction_functions() + turbine_grid_farm.construct_turbine_power_functions() turbine_grid_farm.construct_hub_heights() turbine_grid_farm.construct_rotor_diameters() turbine_grid_farm.construct_turbine_TSRs() - turbine_grid_farm.construct_turbine_pPs() - turbine_grid_farm.construct_turbine_pTs() - turbine_grid_farm.construct_turbine_ref_density_cp_cts() - turbine_grid_farm.construct_turbine_ref_tilt_cp_cts() + turbine_grid_farm.construct_turbine_ref_tilts() turbine_grid_farm.construct_turbine_tilt_interps() turbine_grid_farm.construct_turbine_correct_cp_ct_for_tilt() - turbine_grid_farm.set_tilt_to_ref_tilt(flow_field.n_wind_directions, flow_field.n_wind_speeds) + turbine_grid_farm.set_tilt_to_ref_tilt(flow_field.n_findex) turbine_grid = TurbineGrid( turbine_coordinates=turbine_grid_farm.coordinates, turbine_diameters=turbine_grid_farm.rotor_diameters, wind_directions=turbine_grid_flow_field.wind_directions, - wind_speeds=turbine_grid_flow_field.wind_speeds, grid_resolution=3, - time_series=turbine_grid_flow_field.time_series, ) turbine_grid_farm.expand_farm_properties( - turbine_grid_flow_field.n_wind_directions, - turbine_grid_flow_field.n_wind_speeds, + turbine_grid_flow_field.n_findex, turbine_grid.sorted_coord_indices ) turbine_grid_flow_field.initialize_velocity_field(turbine_grid) @@ -1405,49 +1399,59 @@ def full_flow_empirical_gauss_solver( for i in range(flow_field_grid.n_turbines): # Get the current turbine quantities - x_i = np.mean(turbine_grid.x_sorted[:, :, i:i+1], axis=(3, 4)) - x_i = x_i[:, :, :, None, None] - y_i = np.mean(turbine_grid.y_sorted[:, :, i:i+1], axis=(3, 4)) - y_i = y_i[:, :, :, None, None] - z_i = np.mean(turbine_grid.z_sorted[:, :, i:i+1], axis=(3, 4)) - z_i = z_i[:, :, :, None, None] - - turbine_grid_flow_field.u_sorted[:, :, i:i+1] - turbine_grid_flow_field.v_sorted[:, :, i:i+1] - - ct_i = Ct( + x_i = np.mean(turbine_grid.x_sorted[:, i:i+1], axis=(2,3)) + x_i = x_i[:, :, None, None] + y_i = np.mean(turbine_grid.y_sorted[:, i:i+1], axis=(2,3)) + y_i = y_i[:, :, None, None] + z_i = np.mean(turbine_grid.z_sorted[:, i:i+1], axis=(2,3)) + z_i = z_i[:, :, None, None] + + ct_i = thrust_coefficient( velocities=turbine_grid_flow_field.u_sorted, - yaw_angle=turbine_grid_farm.yaw_angles_sorted, - tilt_angle=turbine_grid_farm.tilt_angles_sorted, - ref_tilt_cp_ct=turbine_grid_farm.ref_tilt_cp_cts_sorted, - fCt=turbine_grid_farm.turbine_fCts, - tilt_interp=turbine_grid_farm.turbine_tilt_interps, + air_density=turbine_grid_flow_field.air_density, + yaw_angles=turbine_grid_farm.yaw_angles_sorted, + tilt_angles=turbine_grid_farm.tilt_angles_sorted, + power_setpoints=turbine_grid_farm.power_setpoints_sorted, + awc_modes=turbine_grid_farm.awc_modes_sorted, + awc_amplitudes=turbine_grid_farm.awc_amplitudes_sorted, + thrust_coefficient_functions=turbine_grid_farm.turbine_thrust_coefficient_functions, + tilt_interps=turbine_grid_farm.turbine_tilt_interps, correct_cp_ct_for_tilt=turbine_grid_farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=turbine_grid_farm.turbine_type_map_sorted, + turbine_power_thrust_tables=turbine_grid_farm.turbine_power_thrust_tables, ix_filter=[i], + average_method=turbine_grid.average_method, + cubature_weights=turbine_grid.cubature_weights, + multidim_condition=turbine_grid_flow_field.multidim_conditions, ) - # Since we are filtering for the i'th turbine in the Ct function, + # Since we are filtering for the i'th turbine in the thrust coefficient function, # get the first index here (0:1) - ct_i = ct_i[:, :, 0:1, None, None] + ct_i = ct_i[:, 0:1, None, None] axial_induction_i = axial_induction( velocities=turbine_grid_flow_field.u_sorted, - yaw_angle=turbine_grid_farm.yaw_angles_sorted, - tilt_angle=turbine_grid_farm.tilt_angles_sorted, - ref_tilt_cp_ct=turbine_grid_farm.ref_tilt_cp_cts_sorted, - fCt=turbine_grid_farm.turbine_fCts, - tilt_interp=turbine_grid_farm.turbine_tilt_interps, + air_density=turbine_grid_flow_field.air_density, + yaw_angles=turbine_grid_farm.yaw_angles_sorted, + tilt_angles=turbine_grid_farm.tilt_angles_sorted, + power_setpoints=turbine_grid_farm.power_setpoints_sorted, + awc_modes=turbine_grid_farm.awc_modes_sorted, + awc_amplitudes=turbine_grid_farm.awc_amplitudes_sorted, + axial_induction_functions=turbine_grid_farm.turbine_axial_induction_functions, + tilt_interps=turbine_grid_farm.turbine_tilt_interps, correct_cp_ct_for_tilt=turbine_grid_farm.correct_cp_ct_for_tilt_sorted, turbine_type_map=turbine_grid_farm.turbine_type_map_sorted, + turbine_power_thrust_tables=turbine_grid_farm.turbine_power_thrust_tables, ix_filter=[i], + average_method=turbine_grid.average_method, + cubature_weights=turbine_grid.cubature_weights, + multidim_condition=turbine_grid_flow_field.multidim_conditions, ) # Since we are filtering for the i'th turbine in the axial induction function, # get the first index here (0:1) - axial_induction_i = axial_induction_i[:, :, 0:1, None, None] - yaw_angle_i = turbine_grid_farm.yaw_angles_sorted[:, :, i:i+1, None, None] - hub_height_i = turbine_grid_farm.hub_heights_sorted[: ,:, i:i+1, None, None] - rotor_diameter_i = turbine_grid_farm.rotor_diameters_sorted[: ,:, i:i+1, None, None] - wake_induced_mixing_i = wim_field[:, :, i:i+1, :, None].sum(axis=3, keepdims=1) - + axial_induction_i = axial_induction_i[:, 0:1, None, None] + yaw_angle_i = turbine_grid_farm.yaw_angles_sorted[:, i:i+1, None, None] + hub_height_i = turbine_grid_farm.hub_heights_sorted[:, i:i+1, None, None] + rotor_diameter_i = turbine_grid_farm.rotor_diameters_sorted[:, i:i+1, None, None] + wake_induced_mixing_i = wim_field[:, i:i+1, :, None].sum(axis=2, keepdims=1) effective_yaw_i = np.zeros_like(yaw_angle_i) effective_yaw_i += yaw_angle_i @@ -1457,7 +1461,7 @@ def full_flow_empirical_gauss_solver( cubature_weights=turbine_grid.cubature_weights ) tilt_angle_i = turbine_grid_farm.calculate_tilt_for_eff_velocities(average_velocities) - tilt_angle_i = tilt_angle_i[:, :, i:i+1, None, None] + tilt_angle_i = tilt_angle_i[:, i:i+1, None, None] if model_manager.enable_secondary_steering: raise NotImplementedError( @@ -1505,208 +1509,3 @@ def full_flow_empirical_gauss_solver( flow_field.u_sorted = flow_field.u_initial_sorted - wake_field flow_field.v_sorted += v_wake flow_field.w_sorted += w_wake - - -def sequential_multidim_solver( - farm: Farm, - flow_field: FlowField, - grid: TurbineGrid, - model_manager: WakeModelManager -) -> None: - # Algorithm - # For each turbine, calculate its effect on every downstream turbine. - # For the current turbine, we are calculating the deficit that it adds to downstream turbines. - # Integrate this into the main data structure. - # Move on to the next turbine. - - # <> - deflection_model_args = model_manager.deflection_model.prepare_function(grid, flow_field) - deficit_model_args = model_manager.velocity_model.prepare_function(grid, flow_field) - downselect_turbine_fCts = multidim_Ct_down_select( - farm.turbine_fCts_sorted, - flow_field.multidim_conditions, - ) - - # This is u_wake - wake_field = np.zeros_like(flow_field.u_initial_sorted) - v_wake = np.zeros_like(flow_field.v_initial_sorted) - w_wake = np.zeros_like(flow_field.w_initial_sorted) - - turbine_turbulence_intensity = ( - flow_field.turbulence_intensity - * np.ones((flow_field.n_wind_directions, flow_field.n_wind_speeds, farm.n_turbines, 1, 1)) - ) - ambient_turbulence_intensity = flow_field.turbulence_intensity - - # Calculate the velocity deficit sequentially from upstream to downstream turbines - for i in range(grid.n_turbines): - - # Get the current turbine quantities - x_i = np.mean(grid.x_sorted[:, :, i:i+1], axis=(3, 4)) - x_i = x_i[:, :, :, None, None] - y_i = np.mean(grid.y_sorted[:, :, i:i+1], axis=(3, 4)) - y_i = y_i[:, :, :, None, None] - z_i = np.mean(grid.z_sorted[:, :, i:i+1], axis=(3, 4)) - z_i = z_i[:, :, :, None, None] - - u_i = flow_field.u_sorted[:, :, i:i+1] - v_i = flow_field.v_sorted[:, :, i:i+1] - - ct_i = Ct_multidim( - velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=downselect_turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, - correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, - turbine_type_map=farm.turbine_type_map_sorted, - ix_filter=[i], - average_method=grid.average_method, - cubature_weights=grid.cubature_weights - ) - # Since we are filtering for the i'th turbine in the Ct function, - # get the first index here (0:1) - ct_i = ct_i[:, :, 0:1, None, None] - axial_induction_i = axial_induction_multidim( - velocities=flow_field.u_sorted, - yaw_angle=farm.yaw_angles_sorted, - tilt_angle=farm.tilt_angles_sorted, - ref_tilt_cp_ct=farm.ref_tilt_cp_cts_sorted, - fCt=downselect_turbine_fCts, - tilt_interp=farm.turbine_tilt_interps, - correct_cp_ct_for_tilt=farm.correct_cp_ct_for_tilt_sorted, - turbine_type_map=farm.turbine_type_map_sorted, - ix_filter=[i], - average_method=grid.average_method, - cubature_weights=grid.cubature_weights - ) - # Since we are filtering for the i'th turbine in the axial induction function, - # get the first index here (0:1) - axial_induction_i = axial_induction_i[:, :, 0:1, None, None] - turbulence_intensity_i = turbine_turbulence_intensity[:, :, i:i+1] - yaw_angle_i = farm.yaw_angles_sorted[:, :, i:i+1, None, None] - hub_height_i = farm.hub_heights_sorted[:, :, i:i+1, None, None] - rotor_diameter_i = farm.rotor_diameters_sorted[:, :, i:i+1, None, None] - TSR_i = farm.TSRs_sorted[:, :, i:i+1, None, None] - - effective_yaw_i = np.zeros_like(yaw_angle_i) - effective_yaw_i += yaw_angle_i - - if model_manager.enable_secondary_steering: - added_yaw = wake_added_yaw( - u_i, - v_i, - flow_field.u_initial_sorted, - grid.y_sorted[:, :, i:i+1] - y_i, - grid.z_sorted[:, :, i:i+1], - rotor_diameter_i, - hub_height_i, - ct_i, - TSR_i, - axial_induction_i, - flow_field.wind_shear, - ) - effective_yaw_i += added_yaw - - # Model calculations - # NOTE: exponential - deflection_field = model_manager.deflection_model.function( - x_i, - y_i, - effective_yaw_i, - turbulence_intensity_i, - ct_i, - rotor_diameter_i, - **deflection_model_args, - ) - - if model_manager.enable_transverse_velocities: - v_wake, w_wake = calculate_transverse_velocity( - u_i, - flow_field.u_initial_sorted, - flow_field.dudz_initial_sorted, - grid.x_sorted - x_i, - grid.y_sorted - y_i, - grid.z_sorted, - rotor_diameter_i, - hub_height_i, - yaw_angle_i, - ct_i, - TSR_i, - axial_induction_i, - flow_field.wind_shear, - ) - - if model_manager.enable_yaw_added_recovery: - I_mixing = yaw_added_turbulence_mixing( - u_i, - turbulence_intensity_i, - v_i, - flow_field.w_sorted[:, :, i:i+1], - v_wake[:, :, i:i+1], - w_wake[:, :, i:i+1], - ) - gch_gain = 2 - turbine_turbulence_intensity[:, :, i:i+1] = turbulence_intensity_i + gch_gain * I_mixing - - # NOTE: exponential - velocity_deficit = model_manager.velocity_model.function( - x_i, - y_i, - z_i, - axial_induction_i, - deflection_field, - yaw_angle_i, - turbulence_intensity_i, - ct_i, - hub_height_i, - rotor_diameter_i, - **deficit_model_args, - ) - - wake_field = model_manager.combination_model.function( - wake_field, - velocity_deficit * flow_field.u_initial_sorted - ) - - wake_added_turbulence_intensity = model_manager.turbulence_model.function( - ambient_turbulence_intensity, - grid.x_sorted, - x_i, - rotor_diameter_i, - axial_induction_i, - ) - - # Calculate wake overlap for wake-added turbulence (WAT) - area_overlap = ( - np.sum(velocity_deficit * flow_field.u_initial_sorted > 0.05, axis=(3, 4)) - / (grid.grid_resolution * grid.grid_resolution) - ) - area_overlap = area_overlap[:, :, :, None, None] - - # Modify wake added turbulence by wake area overlap - downstream_influence_length = 15 * rotor_diameter_i - ti_added = ( - area_overlap - * np.nan_to_num(wake_added_turbulence_intensity, posinf=0.0) - * (grid.x_sorted > x_i) - * (np.abs(y_i - grid.y_sorted) < 2 * rotor_diameter_i) - * (grid.x_sorted <= downstream_influence_length + x_i) - ) - - # Combine turbine TIs with WAT - turbine_turbulence_intensity = np.maximum( - np.sqrt( ti_added ** 2 + ambient_turbulence_intensity ** 2 ), - turbine_turbulence_intensity - ) - - flow_field.u_sorted = flow_field.u_initial_sorted - wake_field - flow_field.v_sorted += v_wake - flow_field.w_sorted += w_wake - - flow_field.turbulence_intensity_field_sorted = turbine_turbulence_intensity - flow_field.turbulence_intensity_field_sorted_avg = np.mean( - turbine_turbulence_intensity, - axis=(3,4) - )[:, :, :, None, None] diff --git a/floris/core/turbine/__init__.py b/floris/core/turbine/__init__.py new file mode 100644 index 000000000..6216fe2b0 --- /dev/null +++ b/floris/core/turbine/__init__.py @@ -0,0 +1,8 @@ + +from floris.core.turbine.operation_models import ( + AWCTurbine, + CosineLossTurbine, + MixedOperationTurbine, + SimpleDeratingTurbine, + SimpleTurbine, +) diff --git a/floris/core/turbine/operation_models.py b/floris/core/turbine/operation_models.py new file mode 100644 index 000000000..bd592343c --- /dev/null +++ b/floris/core/turbine/operation_models.py @@ -0,0 +1,583 @@ + +from __future__ import annotations + +import copy +from abc import abstractmethod +from typing import ( + Any, + Dict, + Final, +) + +import numpy as np +from attrs import define, field +from scipy.interpolate import interp1d + +from floris.core import BaseClass +from floris.core.rotor_velocity import ( + average_velocity, + compute_tilt_angles_for_floating_turbines, + rotor_velocity_air_density_correction, + rotor_velocity_tilt_cosine_correction, + rotor_velocity_yaw_cosine_correction, +) +from floris.type_dec import ( + NDArrayFloat, + NDArrayObject, +) +from floris.utilities import cosd + + +POWER_SETPOINT_DEFAULT = 1e12 +POWER_SETPOINT_DISABLED = 0.001 + + +@define +class BaseOperationModel(BaseClass): + """ + Base class for turbine operation models. All turbine operation models must implement static + power(), thrust_coefficient(), and axial_induction() methods, which are called by power() and + thrust_coefficient() through the interface in the turbine.py module. + + Args: + BaseClass (_type_): _description_ + + Raises: + NotImplementedError: _description_ + NotImplementedError: _description_ + """ + @staticmethod + @abstractmethod + def power() -> None: + raise NotImplementedError("BaseOperationModel.power") + + @staticmethod + @abstractmethod + def thrust_coefficient() -> None: + raise NotImplementedError("BaseOperationModel.thrust_coefficient") + + @staticmethod + @abstractmethod + def axial_induction() -> None: + # TODO: Consider whether we can make a generic axial_induction method + # based purely on thrust_coefficient so that we don't need to implement + # axial_induciton() in individual operation models. + raise NotImplementedError("BaseOperationModel.axial_induction") + +@define +class SimpleTurbine(BaseOperationModel): + """ + Static class defining an actuator disk turbine model that is fully aligned with the flow. No + handling for yaw or tilt angles. + + As with all turbine submodules, implements only static power() and thrust_coefficient() methods, + which are called by power() and thrust_coefficient() on turbine.py, respectively. This class is + not intended to be instantiated; it simply defines a library of static methods. + """ + + def power( + power_thrust_table: dict, + velocities: NDArrayFloat, + air_density: float, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + # Construct power interpolant + power_interpolator = interp1d( + power_thrust_table["wind_speed"], + power_thrust_table["power"], + fill_value=0.0, + bounds_error=False, + ) + + # Compute the power-effective wind speed across the rotor + rotor_average_velocities = average_velocity( + velocities=velocities, + method=average_method, + cubature_weights=cubature_weights, + ) + + rotor_effective_velocities = rotor_velocity_air_density_correction( + velocities=rotor_average_velocities, + air_density=air_density, + ref_air_density=power_thrust_table["ref_air_density"] + ) + + # Compute power + power = power_interpolator(rotor_effective_velocities) * 1e3 # Convert to W + + return power + + def thrust_coefficient( + power_thrust_table: dict, + velocities: NDArrayFloat, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + # Construct thrust coefficient interpolant + thrust_coefficient_interpolator = interp1d( + power_thrust_table["wind_speed"], + power_thrust_table["thrust_coefficient"], + fill_value=0.0001, + bounds_error=False, + ) + + # Compute the effective wind speed across the rotor + rotor_average_velocities = average_velocity( + velocities=velocities, + method=average_method, + cubature_weights=cubature_weights, + ) + + # TODO: Do we need an air density correction here? + + thrust_coefficient = thrust_coefficient_interpolator(rotor_average_velocities) + thrust_coefficient = np.clip(thrust_coefficient, 0.0001, 0.9999) + + return thrust_coefficient + + def axial_induction( + power_thrust_table: dict, + velocities: NDArrayFloat, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + + thrust_coefficient = SimpleTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + average_method=average_method, + cubature_weights=cubature_weights, + ) + + return (1 - np.sqrt(1 - thrust_coefficient))/2 + + +@define +class CosineLossTurbine(BaseOperationModel): + """ + Static class defining an actuator disk turbine model that may be misaligned with the flow. + Nonzero tilt and yaw angles are handled via cosine relationships, with the power lost to yawing + defined by the cosine of the yaw misalignment raised to the power of cosine_loss_exponent_yaw. + This turbine submodel is the default, and matches the turbine model in FLORIS v3. + + As with all turbine submodules, implements only static power() and thrust_coefficient() methods, + which are called by power() and thrust_coefficient() on turbine.py, respectively. This class is + not intended to be instantiated; it simply defines a library of static methods. + """ + + def power( + power_thrust_table: dict, + velocities: NDArrayFloat, + air_density: float, + yaw_angles: NDArrayFloat, + tilt_angles: NDArrayFloat, + tilt_interp: NDArrayObject, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + correct_cp_ct_for_tilt: bool = False, + **_ # <- Allows other models to accept other keyword arguments + ): + # Construct power interpolant + power_interpolator = interp1d( + power_thrust_table["wind_speed"], + power_thrust_table["power"], + fill_value=0.0, + bounds_error=False, + ) + + # Compute the power-effective wind speed across the rotor + rotor_average_velocities = average_velocity( + velocities=velocities, + method=average_method, + cubature_weights=cubature_weights, + ) + + rotor_effective_velocities = rotor_velocity_air_density_correction( + velocities=rotor_average_velocities, + air_density=air_density, + ref_air_density=power_thrust_table["ref_air_density"] + ) + + rotor_effective_velocities = rotor_velocity_yaw_cosine_correction( + cosine_loss_exponent_yaw=power_thrust_table["cosine_loss_exponent_yaw"], + yaw_angles=yaw_angles, + rotor_effective_velocities=rotor_effective_velocities, + ) + + rotor_effective_velocities = rotor_velocity_tilt_cosine_correction( + tilt_angles=tilt_angles, + ref_tilt=power_thrust_table["ref_tilt"], + cosine_loss_exponent_tilt=power_thrust_table["cosine_loss_exponent_tilt"], + tilt_interp=tilt_interp, + correct_cp_ct_for_tilt=correct_cp_ct_for_tilt, + rotor_effective_velocities=rotor_effective_velocities, + ) + + # Compute power + power = power_interpolator(rotor_effective_velocities) * 1e3 # Convert to W + + return power + + def thrust_coefficient( + power_thrust_table: dict, + velocities: NDArrayFloat, + yaw_angles: NDArrayFloat, + tilt_angles: NDArrayFloat, + tilt_interp: NDArrayObject, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + correct_cp_ct_for_tilt: bool = False, + **_ # <- Allows other models to accept other keyword arguments + ): + # Construct thrust coefficient interpolant + thrust_coefficient_interpolator = interp1d( + power_thrust_table["wind_speed"], + power_thrust_table["thrust_coefficient"], + fill_value=0.0001, + bounds_error=False, + ) + + # Compute the effective wind speed across the rotor + rotor_average_velocities = average_velocity( + velocities=velocities, + method=average_method, + cubature_weights=cubature_weights, + ) + + # TODO: Do we need an air density correction here? + thrust_coefficient = thrust_coefficient_interpolator(rotor_average_velocities) + thrust_coefficient = np.clip(thrust_coefficient, 0.0001, 0.9999) + + # Apply tilt and yaw corrections + # Compute the tilt, if using floating turbines + old_tilt_angles = copy.deepcopy(tilt_angles) + tilt_angles = compute_tilt_angles_for_floating_turbines( + tilt_angles=tilt_angles, + tilt_interp=tilt_interp, + rotor_effective_velocities=rotor_average_velocities, + ) + # Only update tilt angle if requested (if the tilt isn't accounted for in the Ct curve) + tilt_angles = np.where(correct_cp_ct_for_tilt, tilt_angles, old_tilt_angles) + + thrust_coefficient = ( + thrust_coefficient + * cosd(yaw_angles) + * cosd(tilt_angles - power_thrust_table["ref_tilt"]) + ) + + return thrust_coefficient + + def axial_induction( + power_thrust_table: dict, + velocities: NDArrayFloat, + yaw_angles: NDArrayFloat, + tilt_angles: NDArrayFloat, + tilt_interp: NDArrayObject, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + correct_cp_ct_for_tilt: bool = False, + **_ # <- Allows other models to accept other keyword arguments + ): + + thrust_coefficient = CosineLossTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + yaw_angles=yaw_angles, + tilt_angles=tilt_angles, + tilt_interp=tilt_interp, + average_method=average_method, + cubature_weights=cubature_weights, + correct_cp_ct_for_tilt=correct_cp_ct_for_tilt + ) + + misalignment_loss = cosd(yaw_angles) * cosd(tilt_angles - power_thrust_table["ref_tilt"]) + return 0.5 / misalignment_loss * (1 - np.sqrt(1 - thrust_coefficient * misalignment_loss)) + +@define +class SimpleDeratingTurbine(BaseOperationModel): + """ + power_thrust_table is a dictionary (normally defined on the turbine input yaml) + that contains the parameters necessary to evaluate power(), thrust(), and axial_induction(). + Any specific parameters for derating can be placed here. (they can be added to the turbine + yaml). For this operation model to receive those arguements, they'll need to be + added to the kwargs dictionaries in the respective functions on turbine.py. They won't affect + the other operation models. + """ + def power( + power_thrust_table: dict, + velocities: NDArrayFloat, + air_density: float, + power_setpoints: NDArrayFloat | None, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + base_powers = SimpleTurbine.power( + power_thrust_table=power_thrust_table, + velocities=velocities, + air_density=air_density, + average_method=average_method, + cubature_weights=cubature_weights + ) + if power_setpoints is None: + return base_powers + else: + return np.minimum(base_powers, power_setpoints) + + # TODO: would we like special handling of zero power setpoints + # (mixed with non-zero values) to speed up computation in that case? + + def thrust_coefficient( + power_thrust_table: dict, + velocities: NDArrayFloat, + air_density: float, + power_setpoints: NDArrayFloat, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + base_thrust_coefficients = SimpleTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + average_method=average_method, + cubature_weights=cubature_weights + ) + if power_setpoints is None: + return base_thrust_coefficients + else: + # Assume thrust coefficient scales directly with power + base_powers = SimpleTurbine.power( + power_thrust_table=power_thrust_table, + velocities=velocities, + air_density=air_density + ) + power_fractions = power_setpoints / base_powers + thrust_coefficients = power_fractions * base_thrust_coefficients + return np.minimum(base_thrust_coefficients, thrust_coefficients) + + def axial_induction( + power_thrust_table: dict, + velocities: NDArrayFloat, + air_density: float, + power_setpoints: NDArrayFloat, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + thrust_coefficient = SimpleDeratingTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + air_density=air_density, + power_setpoints=power_setpoints, + average_method=average_method, + cubature_weights=cubature_weights, + ) + + return (1 - np.sqrt(1 - thrust_coefficient))/2 + +@define +class MixedOperationTurbine(BaseOperationModel): + + def power( + yaw_angles: NDArrayFloat, + power_setpoints: NDArrayFloat, + **kwargs + ): + # Yaw angles mask all yaw_angles not equal to zero + yaw_angles_mask = yaw_angles != 0.0 + power_setpoints_mask = power_setpoints < POWER_SETPOINT_DEFAULT + neither_mask = np.logical_not(yaw_angles_mask) & np.logical_not(power_setpoints_mask) + + if (power_setpoints_mask & yaw_angles_mask).any(): + raise ValueError(( + "Power setpoints and yaw angles are incompatible." + "If yaw_angles entry is nonzero, power_setpoints must be greater than" + " or equal to {0}.".format(POWER_SETPOINT_DEFAULT) + )) + + powers = np.zeros_like(power_setpoints) + powers[yaw_angles_mask] += CosineLossTurbine.power( + yaw_angles=yaw_angles, + **kwargs + )[yaw_angles_mask] + powers[power_setpoints_mask] += SimpleDeratingTurbine.power( + power_setpoints=power_setpoints, + **kwargs + )[power_setpoints_mask] + powers[neither_mask] += SimpleTurbine.power( + **kwargs + )[neither_mask] + + return powers + + def thrust_coefficient( + yaw_angles: NDArrayFloat, + power_setpoints: NDArrayFloat, + **kwargs + ): + yaw_angles_mask = yaw_angles != 0.0 + power_setpoints_mask = power_setpoints < POWER_SETPOINT_DEFAULT + neither_mask = np.logical_not(yaw_angles_mask) & np.logical_not(power_setpoints_mask) + + if (power_setpoints_mask & yaw_angles_mask).any(): + raise ValueError(( + "Power setpoints and yaw angles are incompatible." + "If yaw_angles entry is nonzero, power_setpoints must be greater than" + " or equal to {0}.".format(POWER_SETPOINT_DEFAULT) + )) + + thrust_coefficients = np.zeros_like(power_setpoints) + thrust_coefficients[yaw_angles_mask] += CosineLossTurbine.thrust_coefficient( + yaw_angles=yaw_angles, + **kwargs + )[yaw_angles_mask] + thrust_coefficients[power_setpoints_mask] += SimpleDeratingTurbine.thrust_coefficient( + power_setpoints=power_setpoints, + **kwargs + )[power_setpoints_mask] + thrust_coefficients[neither_mask] += SimpleTurbine.thrust_coefficient( + **kwargs + )[neither_mask] + + return thrust_coefficients + + def axial_induction( + yaw_angles: NDArrayFloat, + power_setpoints: NDArrayFloat, + **kwargs + ): + yaw_angles_mask = yaw_angles != 0.0 + power_setpoints_mask = power_setpoints < POWER_SETPOINT_DEFAULT + neither_mask = np.logical_not(yaw_angles_mask) & np.logical_not(power_setpoints_mask) + + if (power_setpoints_mask & yaw_angles_mask).any(): + raise ValueError(( + "Power setpoints and yaw angles are incompatible." + "If yaw_angles entry is nonzero, power_setpoints must be greater than" + " or equal to {0}.".format(POWER_SETPOINT_DEFAULT) + )) + + axial_inductions = np.zeros_like(power_setpoints) + axial_inductions[yaw_angles_mask] += CosineLossTurbine.axial_induction( + yaw_angles=yaw_angles, + **kwargs + )[yaw_angles_mask] + axial_inductions[power_setpoints_mask] += SimpleDeratingTurbine.axial_induction( + power_setpoints=power_setpoints, + **kwargs + )[power_setpoints_mask] + axial_inductions[neither_mask] += SimpleTurbine.axial_induction( + **kwargs + )[neither_mask] + + return axial_inductions + +@define +class AWCTurbine(BaseOperationModel): + """ + power_thrust_table is a dictionary (normally defined on the turbine input yaml) + that contains the parameters necessary to evaluate power(), thrust(), and axial_induction(). + + Feel free to put any Helix tuning parameters into here (they can be added to the turbine yaml). + Also, feel free to add any commanded inputs to power(), thrust_coefficient(), or + axial_induction(). For this operation model to receive those arguments, they'll need to be + added to the kwargs dictionaries in the respective functions on turbine.py. They won't affect + the other operation models. + """ + + def power( + power_thrust_table: dict, + velocities: NDArrayFloat, + air_density: float, + awc_modes: str, + awc_amplitudes: NDArrayFloat | None, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + base_powers = SimpleTurbine.power( + power_thrust_table=power_thrust_table, + velocities=velocities, + air_density=air_density, + average_method=average_method, + cubature_weights=cubature_weights + ) + + if (awc_modes == 'helix').any(): + if np.any(np.isclose( + base_powers/1000, + np.max(power_thrust_table['power']) + )): + raise UserWarning( + 'The selected wind speed is above or near rated wind speed. ' + '`AWCTurbine` operation model is not designed ' + 'or verified for above-rated conditions.' + ) + return base_powers * (1 - ( + power_thrust_table['helix_power_b'] + + power_thrust_table['helix_power_c']*base_powers + ) + *awc_amplitudes**power_thrust_table['helix_a'] + ) # TODO: Should probably add max function here + if (awc_modes == 'baseline').any(): + return base_powers + else: + raise UserWarning( + 'Active wake mixing strategies other than the `helix` strategy ' + 'have not yet been implemented in FLORIS. Returning baseline power.' + ) + + + def thrust_coefficient( + power_thrust_table: dict, + velocities: NDArrayFloat, + awc_modes: str, + awc_amplitudes: NDArrayFloat | None, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + base_thrust_coefficients = SimpleTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + average_method=average_method, + cubature_weights=cubature_weights + ) + if (awc_modes == 'helix').any(): + return base_thrust_coefficients * (1 - ( + power_thrust_table['helix_thrust_b'] + + power_thrust_table['helix_thrust_c']*base_thrust_coefficients + ) + *awc_amplitudes**power_thrust_table['helix_a'] + ) + if (awc_modes == 'baseline').any(): + return base_thrust_coefficients + else: + raise UserWarning( + 'Active wake mixing strategies other than the `helix` strategy ' + 'have not yet been implemented in FLORIS. Returning baseline power.' + ) + + def axial_induction( + power_thrust_table: dict, + velocities: NDArrayFloat, + awc_modes: str, + awc_amplitudes: NDArrayFloat, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + **_ # <- Allows other models to accept other keyword arguments + ): + thrust_coefficient = AWCTurbine.thrust_coefficient( + power_thrust_table=power_thrust_table, + velocities=velocities, + awc_modes=awc_modes, + awc_amplitudes=awc_amplitudes, + average_method=average_method, + cubature_weights=cubature_weights, + ) + + return (1 - np.sqrt(1 - thrust_coefficient))/2 diff --git a/floris/core/turbine/turbine.py b/floris/core/turbine/turbine.py new file mode 100644 index 000000000..17fd956e3 --- /dev/null +++ b/floris/core/turbine/turbine.py @@ -0,0 +1,655 @@ + +from __future__ import annotations + +import copy +from collections.abc import Callable, Iterable +from pathlib import Path + +import attrs +import numpy as np +import pandas as pd +from attrs import define, field +from scipy.interpolate import interp1d + +from floris.core import BaseClass +from floris.core.turbine import ( + AWCTurbine, + CosineLossTurbine, + MixedOperationTurbine, + SimpleDeratingTurbine, + SimpleTurbine, +) +from floris.type_dec import ( + convert_to_path, + floris_numeric_dict_converter, + NDArrayBool, + NDArrayFilter, + NDArrayFloat, + NDArrayInt, + NDArrayObject, + NDArrayStr, +) +from floris.utilities import cosd + + +TURBINE_MODEL_MAP = { + "operation_model": { + "simple": SimpleTurbine, + "cosine-loss": CosineLossTurbine, + "simple-derating": SimpleDeratingTurbine, + "mixed": MixedOperationTurbine, + "awc": AWCTurbine, + }, +} + + +def select_multidim_condition( + condition: dict | tuple, + specified_conditions: Iterable[tuple] +) -> tuple: + """ + Convert condition to the type expected by power_thrust_table and select + nearest specified condition + """ + if type(condition) is tuple: + pass + elif type(condition) is dict: + condition = tuple(condition.values()) + else: + raise TypeError("condition should be of type dict or tuple.") + + # Find the nearest key to the specified conditions. + specified_conditions = np.array(specified_conditions) + + # Find the nearest key to the specified conditions. + nearest_condition = np.zeros_like(condition) + for i, c in enumerate(condition): + nearest_condition[i] = ( + specified_conditions[:, i][np.absolute(specified_conditions[:, i] - c).argmin()] + ) + + return tuple(nearest_condition) + + +def power( + velocities: NDArrayFloat, + air_density: float, + power_functions: dict[str, Callable], + yaw_angles: NDArrayFloat, + tilt_angles: NDArrayFloat, + power_setpoints: NDArrayFloat, + awc_modes: NDArrayStr, + awc_amplitudes: NDArrayFloat, + tilt_interps: dict[str, interp1d], + turbine_type_map: NDArrayObject, + turbine_power_thrust_tables: dict, + ix_filter: NDArrayInt | Iterable[int] | None = None, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + correct_cp_ct_for_tilt: bool = False, + multidim_condition: tuple | None = None, # Assuming only one condition at a time? +) -> NDArrayFloat: + """Power produced by a turbine adjusted for yaw and tilt. Value + given in Watts. + + Args: + velocities (NDArrayFloat[n_findex, n_turbines, n_grid, n_grid]): The velocities at a + turbine. + air_density (float): air density for simulation [kg/m^3] + power_functions (dict[str, Callable]): A dictionary of power functions for + each turbine type. Keys are the turbine type and values are the callable functions. + yaw_angles (NDArrayFloat[findex, turbines]): The yaw angle for each turbine. + tilt_angles (NDArrayFloat[findex, turbines]): The tilt angle for each turbine. + power_setpoints: (NDArrayFloat[findex, turbines]): Maximum power setpoint for each + turbine [W]. + awc_modes: (NDArrayStr[findex, turbines]): awc excitation mode (currently, only "baseline" + and "helix" are implemented). + awc_modes: (NDArrayStr[findex, turbines]): awc excitation mode (currently, only "baseline" + and "helix" are implemented). + awc_amplitudes: (NDArrayFloat[findex, turbines]): awc excitation amplitude for each + turbine [deg]. + tilt_interps (Iterable[tuple]): The tilt interpolation functions for each + turbine. + turbine_type_map: (NDArrayObject[wd, ws, turbines]): The Turbine type definition for + each turbine. + turbine_power_thrust_tables: Reference data for the power and thrust representation + ix_filter (NDArrayInt, optional): The boolean array, or + integer indices to filter out before calculation. Defaults to None. + average_method (str, optional): The method for averaging over turbine rotor points + to determine a rotor-average wind speed. Defaults to "cubic-mean". + cubature_weights (NDArrayFloat | None): Weights for cubature averaging methods. Defaults to + None. + multidim_condition (tuple | None): The condition tuple used to select the appropriate + thrust coefficient relationship for multidimensional power/thrust tables. Defaults to + None. + + Returns: + NDArrayFloat: The power, in Watts, for each turbine after adjusting for yaw and tilt. + """ + + # Down-select inputs if ix_filter is given + if ix_filter is not None: + velocities = velocities[:, ix_filter] + yaw_angles = yaw_angles[:, ix_filter] + tilt_angles = tilt_angles[:, ix_filter] + power_setpoints = power_setpoints[:, ix_filter] + awc_modes = awc_modes[:, ix_filter] + awc_amplitudes = awc_amplitudes[:, ix_filter] + turbine_type_map = turbine_type_map[:, ix_filter] + if type(correct_cp_ct_for_tilt) is bool: + pass + else: + correct_cp_ct_for_tilt = correct_cp_ct_for_tilt[:, ix_filter] + + # Loop over each turbine type given to get power for all turbines + p = np.zeros(np.shape(velocities)[0:2]) + turb_types = np.unique(turbine_type_map) + for turb_type in turb_types: + # Handle possible multidimensional power thrust tables + if "power" in turbine_power_thrust_tables[turb_type]: # normal + power_thrust_table = turbine_power_thrust_tables[turb_type] + else: # assumed multidimensional, use multidim lookup + # Currently, only works for single mutlidim condition. May need to + # loop in the case where there are multiple conditions. + multidim_condition = select_multidim_condition( + multidim_condition, + list(turbine_power_thrust_tables[turb_type].keys()) + ) + power_thrust_table = turbine_power_thrust_tables[turb_type][multidim_condition] + + # Construct full set of possible keyword arguments for power() + power_model_kwargs = { + "power_thrust_table": power_thrust_table, + "velocities": velocities, + "air_density": air_density, + "yaw_angles": yaw_angles, + "tilt_angles": tilt_angles, + "power_setpoints": power_setpoints, + "awc_modes": awc_modes, + "awc_amplitudes": awc_amplitudes, + "tilt_interp": tilt_interps[turb_type], + "average_method": average_method, + "cubature_weights": cubature_weights, + "correct_cp_ct_for_tilt": correct_cp_ct_for_tilt, + } + + # Using a masked array, apply the power for all turbines of the current + # type to the main power + p += power_functions[turb_type](**power_model_kwargs) * (turbine_type_map == turb_type) + + return p + + +def thrust_coefficient( + velocities: NDArrayFloat, + air_density: float, + yaw_angles: NDArrayFloat, + tilt_angles: NDArrayFloat, + power_setpoints: NDArrayFloat, + awc_modes: NDArrayStr, + awc_amplitudes: NDArrayFloat, + thrust_coefficient_functions: dict[str, Callable], + tilt_interps: dict[str, interp1d], + correct_cp_ct_for_tilt: NDArrayBool, + turbine_type_map: NDArrayObject, + turbine_power_thrust_tables: dict, + ix_filter: NDArrayFilter | Iterable[int] | None = None, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + multidim_condition: tuple | None = None, # Assuming only one condition at a time? +) -> NDArrayFloat: + + """Thrust coefficient of a turbine. + The value is obtained from the coefficient of thrust specified by the callables specified + in the thrust_coefficient_functions. + + Args: + velocities (NDArrayFloat[findex, turbines, grid1, grid2]): The velocity field at + a turbine. + air_density (float): air density for simulation [kg/m^3] + yaw_angles (NDArrayFloat[findex, turbines]): The yaw angle for each turbine. + tilt_angles (NDArrayFloat[findex, turbines]): The tilt angle for each turbine. + power_setpoints: (NDArrayFloat[findex, turbines]): Maximum power setpoint for each + turbine [W]. + awc_modes: (NDArrayStr[findex, turbines]): awc excitation mode (currently, only "baseline" + and "helix" are implemented). + awc_amplitudes: (NDArrayFloat[findex, turbines]): awc excitation amplitude for each + turbine [deg]. + thrust_coefficient_functions (dict): The thrust coefficient functions for each turbine. Keys + are the turbine type string and values are the callable functions. + tilt_interps (Iterable[tuple]): The tilt interpolation functions for each + turbine. + correct_cp_ct_for_tilt (NDArrayBool[findex, turbines]): Boolean for determining if the + turbines Cp and Ct should be corrected for tilt. + turbine_type_map: (NDArrayObject[findex, turbines]): The Turbine type definition + for each turbine. + ix_filter (NDArrayFilter | Iterable[int] | None, optional): The boolean array, or + integer indices as an iterable of array to filter out before calculation. + Defaults to None. + average_method (str, optional): The method for averaging over turbine rotor points + to determine a rotor-average wind speed. Defaults to "cubic-mean". + cubature_weights (NDArrayFloat | None): Weights for cubature averaging methods. Defaults to + None. + multidim_condition (tuple | None): The condition tuple used to select the appropriate + thrust coefficient relationship for multidimensional power/thrust tables. Defaults to + None. + + Returns: + NDArrayFloat: Coefficient of thrust for each requested turbine. + """ + + # Down-select inputs if ix_filter is given + if ix_filter is not None: + velocities = velocities[:, ix_filter] + yaw_angles = yaw_angles[:, ix_filter] + tilt_angles = tilt_angles[:, ix_filter] + power_setpoints = power_setpoints[:, ix_filter] + awc_modes = awc_modes[:, ix_filter] + awc_amplitudes = awc_amplitudes[:, ix_filter] + turbine_type_map = turbine_type_map[:, ix_filter] + if type(correct_cp_ct_for_tilt) is bool: + pass + else: + correct_cp_ct_for_tilt = correct_cp_ct_for_tilt[:, ix_filter] + + # Loop over each turbine type given to get thrust coefficient for all turbines + thrust_coefficient = np.zeros(np.shape(velocities)[0:2]) + turb_types = np.unique(turbine_type_map) + for turb_type in turb_types: + # Handle possible multidimensional power thrust tables + if "thrust_coefficient" in turbine_power_thrust_tables[turb_type]: # normal + power_thrust_table = turbine_power_thrust_tables[turb_type] + else: # assumed multidimensional, use multidim lookup + # Currently, only works for single mutlidim condition. May need to + # loop in the case where there are multiple conditions. + multidim_condition = select_multidim_condition( + multidim_condition, + list(turbine_power_thrust_tables[turb_type].keys()) + ) + power_thrust_table = turbine_power_thrust_tables[turb_type][multidim_condition] + + # Construct full set of possible keyword arguments for thrust_coefficient() + thrust_model_kwargs = { + "power_thrust_table": power_thrust_table, + "velocities": velocities, + "air_density": air_density, + "yaw_angles": yaw_angles, + "tilt_angles": tilt_angles, + "power_setpoints": power_setpoints, + "awc_modes": awc_modes, + "awc_amplitudes": awc_amplitudes, + "tilt_interp": tilt_interps[turb_type], + "average_method": average_method, + "cubature_weights": cubature_weights, + "correct_cp_ct_for_tilt": correct_cp_ct_for_tilt, + } + + # Using a masked array, apply the thrust coefficient for all turbines of the current + # type to the main thrust coefficient array + thrust_coefficient += ( + thrust_coefficient_functions[turb_type](**thrust_model_kwargs) + * (turbine_type_map == turb_type) + ) + + return thrust_coefficient + + +def axial_induction( + velocities: NDArrayFloat, + air_density: float, + yaw_angles: NDArrayFloat, + tilt_angles: NDArrayFloat, + power_setpoints: NDArrayFloat, + awc_modes: NDArrayStr, + awc_amplitudes: NDArrayFloat, + axial_induction_functions: dict, + tilt_interps: NDArrayObject, + correct_cp_ct_for_tilt: NDArrayBool, + turbine_type_map: NDArrayObject, + turbine_power_thrust_tables: dict, + ix_filter: NDArrayFilter | Iterable[int] | None = None, + average_method: str = "cubic-mean", + cubature_weights: NDArrayFloat | None = None, + multidim_condition: tuple | None = None, # Assuming only one condition at a time? +) -> NDArrayFloat: + """Axial induction factor of the turbine incorporating + the thrust coefficient and yaw angle. + + Args: + velocities (NDArrayFloat): The velocity field at each turbine; should be shape: + (number of turbines, ngrid, ngrid), or (ngrid, ngrid) for a single turbine. + yaw_angles (NDArrayFloat[findex, turbines]): The yaw angle for each turbine. + tilt_angles (NDArrayFloat[findex, turbines]): The tilt angle for each turbine. + power_setpoints: (NDArrayFloat[findex, turbines]): Maximum power setpoint for each + turbine [W]. + awc_amplitudes: (NDArrayFloat[findex, turbines]): awc excitation amplitude for each + turbine [deg]. + axial_induction_functions (dict): The axial induction functions for each turbine. Keys are + the turbine type string and values are the callable functions. + tilt_interps (Iterable[tuple]): The tilt interpolation functions for each + turbine. + correct_cp_ct_for_tilt (NDArrayBool[findex, turbines]): Boolean for determining if the + turbines Cp and Ct should be corrected for tilt. + turbine_type_map: (NDArrayObject[findex, turbines]): The Turbine type definition + for each turbine. + ix_filter (NDArrayFilter | Iterable[int] | None, optional): The boolean array, or + integer indices (as an array or iterable) to filter out before calculation. + Defaults to None. + average_method (str, optional): The method for averaging over turbine rotor points + to determine a rotor-average wind speed. Defaults to "cubic-mean". + cubature_weights (NDArrayFloat | None): Weights for cubature averaging methods. Defaults to + None. + multidim_condition (tuple | None): The condition tuple used to select the appropriate + thrust coefficient relationship for multidimensional power/thrust tables. Defaults to + None. + + Returns: + Union[float, NDArrayFloat]: [description] + """ + + # Down-select inputs if ix_filter is given + if ix_filter is not None: + velocities = velocities[:, ix_filter] + yaw_angles = yaw_angles[:, ix_filter] + tilt_angles = tilt_angles[:, ix_filter] + power_setpoints = power_setpoints[:, ix_filter] + awc_modes = awc_modes[:, ix_filter] + awc_amplitudes = awc_amplitudes[:, ix_filter] + turbine_type_map = turbine_type_map[:, ix_filter] + if type(correct_cp_ct_for_tilt) is bool: + pass + else: + correct_cp_ct_for_tilt = correct_cp_ct_for_tilt[:, ix_filter] + + # Loop over each turbine type given to get axial induction for all turbines + axial_induction = np.zeros(np.shape(velocities)[0:2]) + turb_types = np.unique(turbine_type_map) + for turb_type in turb_types: + # Handle possible multidimensional power thrust tables + if "thrust_coefficient" in turbine_power_thrust_tables[turb_type]: # normal + power_thrust_table = turbine_power_thrust_tables[turb_type] + else: # assumed multidimensional, use multidim lookup + # Currently, only works for single mutlidim condition. May need to + # loop in the case where there are multiple conditions. + multidim_condition = select_multidim_condition( + multidim_condition, + list(turbine_power_thrust_tables[turb_type].keys()) + ) + power_thrust_table = turbine_power_thrust_tables[turb_type][multidim_condition] + + # Construct full set of possible keyword arguments for thrust_coefficient() + axial_induction_model_kwargs = { + "power_thrust_table": power_thrust_table, + "velocities": velocities, + "air_density": air_density, + "yaw_angles": yaw_angles, + "tilt_angles": tilt_angles, + "power_setpoints": power_setpoints, + "awc_modes": awc_modes, + "awc_amplitudes": awc_amplitudes, + "tilt_interp": tilt_interps[turb_type], + "average_method": average_method, + "cubature_weights": cubature_weights, + "correct_cp_ct_for_tilt": correct_cp_ct_for_tilt, + } + + # Using a masked array, apply the thrust coefficient for all turbines of the current + # type to the main thrust coefficient array + axial_induction += ( + axial_induction_functions[turb_type](**axial_induction_model_kwargs) + * (turbine_type_map == turb_type) + ) + + return axial_induction + + +@define +class Turbine(BaseClass): + """ + A class containing the parameters and infrastructure to model a wind turbine's performance + for a particular atmospheric condition. + + Args: + turbine_type (str): An identifier for this type of turbine such as "NREL_5MW". + rotor_diameter (float): The rotor diameter in meters. + hub_height (float): The hub height in meters. + TSR (float): The Tip Speed Ratio of the turbine. + power_thrust_table (dict[str, float]): Contains power coefficient and thrust coefficient + values at a series of wind speeds to define the turbine performance. + The dictionary must have the following three keys with equal length values: + { + "wind_speeds": List[float], + "power": List[float], + "thrust": List[float], + } + or, contain a key "power_thrust_data_file" pointing to the power/thrust data. + Optionally, power_thrust_table may include parameters for use in the turbine submodel, + for example: + cosine_loss_exponent_yaw (float): The cosine exponent relating the yaw misalignment + angle to turbine power. + cosine_loss_exponent_tilt (float): The cosine exponent relating the rotor tilt angle + to turbine power. + ref_air_density (float): The density at which the provided Cp and Ct curves are + defined. + ref_tilt (float): The implicit tilt of the turbine for which the Cp and Ct + curves are defined. This is typically the nacelle tilt. + correct_cp_ct_for_tilt (bool): A flag to indicate whether to correct Cp and Ct for tilt + usually for a floating turbine. + Optional, defaults to False. + floating_tilt_table (dict[str, float]): Look up table of tilt angles at a series of + wind speeds. The dictionary must have the following keys with equal length values: + { + "wind_speeds": List[float], + "tilt": List[float], + } + Required if `correct_cp_ct_for_tilt = True`. Defaults to None. + multi_dimensional_cp_ct (bool): Use a multidimensional power_thrust_table. Defaults to + False. + """ + turbine_type: str = field() + rotor_diameter: float = field() + hub_height: float = field() + TSR: float = field() + power_thrust_table: dict = field(default={}) # conversion to numpy in __post_init__ + operation_model: str = field(default="cosine-loss") + + correct_cp_ct_for_tilt: bool = field(default=False) + floating_tilt_table: dict[str, NDArrayFloat] | None = field(default=None) + + # Even though this Turbine class does not support the multidimensional features as they + # are implemented in TurbineMultiDim, providing the following two attributes here allows + # the turbine data inputs to keep the multidimensional Cp and Ct curve but switch them off + # with multi_dimensional_cp_ct = False + multi_dimensional_cp_ct: bool = field(default=False) + + # Initialized in the post_init function + rotor_radius: float = field(init=False) + rotor_area: float = field(init=False) + thrust_coefficient_function: Callable = field(init=False) + axial_induction_function: Callable = field(init=False) + power_function: Callable = field(init=False) + tilt_interp: interp1d = field(init=False, default=None) + power_thrust_data_file: str = field(default=None) + + # Only used by mutlidimensional turbines + turbine_library_path: Path = field( + default=Path(__file__).parents[2] / "turbine_library", + converter=convert_to_path, + validator=attrs.validators.instance_of(Path) + ) + + # Not to be provided by the user + condition_keys: list[str] = field(init=False, factory=list) + + def __attrs_post_init__(self) -> None: + self._initialize_power_thrust_functions() + self.__post_init__() + + def __post_init__(self) -> None: + self._initialize_tilt_interpolation() + if self.multi_dimensional_cp_ct: + self._initialize_multidim_power_thrust_table() + else: + self.power_thrust_table = floris_numeric_dict_converter(self.power_thrust_table) + + def _initialize_power_thrust_functions(self) -> None: + turbine_function_model = TURBINE_MODEL_MAP["operation_model"][self.operation_model] + self.thrust_coefficient_function = turbine_function_model.thrust_coefficient + self.axial_induction_function = turbine_function_model.axial_induction + self.power_function = turbine_function_model.power + + + def _initialize_tilt_interpolation(self) -> None: + # TODO: + # Remove any duplicate wind speed entries + # _, duplicate_filter = np.unique(self.wind_speeds, return_index=True) + # self.tilt = self.tilt[duplicate_filter] + # self.wind_speeds = self.wind_speeds[duplicate_filter] + + if self.floating_tilt_table is not None: + self.floating_tilt_table = floris_numeric_dict_converter(self.floating_tilt_table) + + # If defined, create a tilt interpolation function for floating turbines. + # fill_value currently set to apply the min or max tilt angles if outside + # of the interpolation range. + if self.correct_cp_ct_for_tilt: + self.tilt_interp = interp1d( + self.floating_tilt_table["wind_speed"], + self.floating_tilt_table["tilt"], + fill_value=(0.0, self.floating_tilt_table["tilt"][-1]), + bounds_error=False, + ) + + def _initialize_multidim_power_thrust_table(self): + # Collect reference information + power_thrust_table_ref = copy.deepcopy(self.power_thrust_table) + self.power_thrust_data_file = power_thrust_table_ref.pop("power_thrust_data_file") + + # Solidify the data file path and name + self.power_thrust_data_file = self.turbine_library_path / self.power_thrust_data_file + + # Read in the multi-dimensional data supplied by the user. + df = pd.read_csv(self.power_thrust_data_file) + + # Down-select the DataFrame to have just the ws, Cp, and Ct values + index_col = df.columns.values[:-3] + self.condition_keys = index_col.tolist() + df2 = df.set_index(index_col.tolist()) + + # Loop over the multi-dimensional keys to get the correct ws/Cp/Ct data to make + # the thrust_coefficient and power interpolants. + power_thrust_table_ = {} # Reset + for key in df2.index.unique(): + # Select the correct ws/Cp/Ct data + data = df2.loc[key] + + # Build the interpolants + power_thrust_table_.update( + { + key: { + "wind_speed": data['ws'].values, + "power": data['power'].values, + "thrust_coefficient": data['thrust_coefficient'].values, + **power_thrust_table_ref + }, + } + ) + # Add reference information at the lower level + + # Set on-object version + self.power_thrust_table = power_thrust_table_ + + @power_thrust_table.validator + def check_power_thrust_table(self, instance: attrs.Attribute, value: dict) -> None: + """ + Verify that the power and thrust tables are given with arrays of equal length + to the wind speed array. + """ + + if self.multi_dimensional_cp_ct: + if isinstance(list(value.keys())[0], tuple): + value = list(value.values())[0] # Check the first entry of multidim + elif "power_thrust_data_file" in value.keys(): + return None + else: + raise ValueError( + "power_thrust_data_file must be defined if multi_dimensional_cp_ct is True." + ) + + if not {"wind_speed", "power", "thrust_coefficient"} <= set(value.keys()): + raise ValueError( + """ + power_thrust_table dictionary must contain: + { + "wind_speed": List[float], + "power": List[float], + "thrust_coefficient": List[float], + } + """ + ) + + @rotor_diameter.validator + def reset_rotor_diameter_dependencies(self, instance: attrs.Attribute, value: float) -> None: + """Resets the `rotor_radius` and `rotor_area` attributes.""" + # Temporarily turn off validators to avoid infinite recursion + with attrs.validators.disabled(): + # Reset the values + self.rotor_radius = value / 2.0 + self.rotor_area = np.pi * self.rotor_radius ** 2.0 + + @rotor_radius.validator + def reset_rotor_radius(self, instance: attrs.Attribute, value: float) -> None: + """ + Resets the `rotor_diameter` value to trigger the recalculation of + `rotor_diameter`, `rotor_radius` and `rotor_area`. + """ + self.rotor_diameter = value * 2.0 + + @rotor_area.validator + def reset_rotor_area(self, instance: attrs.Attribute, value: float) -> None: + """ + Resets the `rotor_radius` value to trigger the recalculation of + `rotor_diameter`, `rotor_radius` and `rotor_area`. + """ + self.rotor_radius = (value / np.pi) ** 0.5 + + @floating_tilt_table.validator + def check_floating_tilt_table(self, instance: attrs.Attribute, value: dict | None) -> None: + """ + If the tilt / wind_speed table is defined, verify that the tilt and + wind_speed arrays are the same length. + """ + if value is None: + return + + if len(value.keys()) != 2 or set(value.keys()) != {"wind_speed", "tilt"}: + raise ValueError( + """ + floating_tilt_table dictionary must have the form: + { + "wind_speed": List[float], + "tilt": List[float], + } + """ + ) + + if any(len(np.shape(e)) > 1 for e in (value["tilt"], value["wind_speed"])): + raise ValueError("tilt and wind_speed inputs must be 1-D.") + + if len( {len(value["tilt"]), len(value["wind_speed"])} ) > 1: + raise ValueError("tilt and wind_speed inputs must be the same size.") + + @correct_cp_ct_for_tilt.validator + def check_for_cp_ct_correct_flag_if_floating( + self, + instance: attrs.Attribute, + value: bool + ) -> None: + """ + Check that the boolean flag exists for correcting Cp/Ct for tilt + if a tile/wind_speed table is also defined. + """ + if self.correct_cp_ct_for_tilt and self.floating_tilt_table is None: + raise ValueError( + "To enable the Cp and Ct tilt correction, a tilt table must be given." + ) diff --git a/floris/simulation/wake.py b/floris/core/wake.py similarity index 85% rename from floris/simulation/wake.py rename to floris/core/wake.py index 877ca45fa..fe2fa9c50 100644 --- a/floris/simulation/wake.py +++ b/floris/core/wake.py @@ -1,38 +1,25 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import attrs from attrs import define, field -from floris.simulation import BaseClass, BaseModel -from floris.simulation.wake_combination import ( +from floris.core import BaseClass, BaseModel +from floris.core.wake_combination import ( FLS, MAX, SOSFS, ) -from floris.simulation.wake_deflection import ( +from floris.core.wake_deflection import ( EmpiricalGaussVelocityDeflection, GaussVelocityDeflection, JimenezVelocityDeflection, NoneVelocityDeflection, ) -from floris.simulation.wake_turbulence import ( +from floris.core.wake_turbulence import ( CrespoHernandez, NoneWakeTurbulence, WakeInducedMixing, ) -from floris.simulation.wake_velocity import ( +from floris.core.wake_velocity import ( CumulativeGaussCurlVelocityDeficit, EmpiricalGaussVelocityDeficit, GaussVelocityDeficit, @@ -66,7 +53,6 @@ "jensen": JensenVelocityDeficit, "turbopark": TurbOParkVelocityDeficit, "empirical_gauss": EmpiricalGaussVelocityDeficit, - "multidim_cp_ct": GaussVelocityDeficit }, } @@ -87,6 +73,7 @@ class WakeModelManager(BaseClass): model_strings: dict = field(converter=dict) enable_secondary_steering: bool = field(converter=bool) enable_yaw_added_recovery: bool = field(converter=bool) + enable_active_wake_mixing: bool = field(converter=bool) enable_transverse_velocities: bool = field(converter=bool) wake_deflection_parameters: dict = field(converter=dict) diff --git a/floris/core/wake_combination/__init__.py b/floris/core/wake_combination/__init__.py new file mode 100644 index 000000000..246aab65c --- /dev/null +++ b/floris/core/wake_combination/__init__.py @@ -0,0 +1,4 @@ + +from floris.core.wake_combination.fls import FLS +from floris.core.wake_combination.max import MAX +from floris.core.wake_combination.sosfs import SOSFS diff --git a/floris/simulation/wake_combination/fls.py b/floris/core/wake_combination/fls.py similarity index 58% rename from floris/simulation/wake_combination/fls.py rename to floris/core/wake_combination/fls.py index f64c23dc1..42e68045f 100644 --- a/floris/simulation/wake_combination/fls.py +++ b/floris/core/wake_combination/fls.py @@ -1,19 +1,8 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. import numpy as np from attrs import define -from floris.simulation import BaseModel +from floris.core import BaseModel @define diff --git a/floris/simulation/wake_combination/max.py b/floris/core/wake_combination/max.py similarity index 62% rename from floris/simulation/wake_combination/max.py rename to floris/core/wake_combination/max.py index f9d5ae5b2..0898cc842 100644 --- a/floris/simulation/wake_combination/max.py +++ b/floris/core/wake_combination/max.py @@ -1,19 +1,8 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. import numpy as np from attrs import define -from floris.simulation import BaseModel +from floris.core import BaseModel @define diff --git a/floris/simulation/wake_combination/sosfs.py b/floris/core/wake_combination/sosfs.py similarity index 56% rename from floris/simulation/wake_combination/sosfs.py rename to floris/core/wake_combination/sosfs.py index 0f6d280f9..c277e21bb 100644 --- a/floris/simulation/wake_combination/sosfs.py +++ b/floris/core/wake_combination/sosfs.py @@ -1,19 +1,8 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. import numpy as np from attrs import define -from floris.simulation import BaseModel +from floris.core import BaseModel @define diff --git a/floris/core/wake_deflection/__init__.py b/floris/core/wake_deflection/__init__.py new file mode 100644 index 000000000..ba5e63788 --- /dev/null +++ b/floris/core/wake_deflection/__init__.py @@ -0,0 +1,5 @@ + +from floris.core.wake_deflection.empirical_gauss import EmpiricalGaussVelocityDeflection +from floris.core.wake_deflection.gauss import GaussVelocityDeflection +from floris.core.wake_deflection.jimenez import JimenezVelocityDeflection +from floris.core.wake_deflection.none import NoneVelocityDeflection diff --git a/floris/simulation/wake_deflection/empirical_gauss.py b/floris/core/wake_deflection/empirical_gauss.py similarity index 86% rename from floris/simulation/wake_deflection/empirical_gauss.py rename to floris/core/wake_deflection/empirical_gauss.py index fc3772f0e..185588f52 100644 --- a/floris/simulation/wake_deflection/empirical_gauss.py +++ b/floris/core/wake_deflection/empirical_gauss.py @@ -1,21 +1,10 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, @@ -60,7 +49,7 @@ class EmpiricalGaussVelocityDeflection(BaseModel): """ horizontal_deflection_gain_D: float = field(default=3.0) vertical_deflection_gain_D: float = field(default=-1) - deflection_rate: float = field(default=30) + deflection_rate: float = field(default=22) mixing_gain_deflection: float = field(default=0.0) yaw_added_mixing_gain: float = field(default=0.0) @@ -145,8 +134,8 @@ def yaw_added_wake_mixing( yaw_added_mixing_gain ): return ( - axial_induction_i[:,:,:,0,0] + axial_induction_i[:,:,0,0] * yaw_added_mixing_gain - * (1 - cosd(yaw_angle_i[:,:,:,0,0])) + * (1 - cosd(yaw_angle_i[:,:,0,0])) / downstream_distance_D_i**2 ) diff --git a/floris/simulation/wake_deflection/gauss.py b/floris/core/wake_deflection/gauss.py similarity index 90% rename from floris/simulation/wake_deflection/gauss.py rename to floris/core/wake_deflection/gauss.py index 8ba77ad7f..8e1f7378f 100644 --- a/floris/simulation/wake_deflection/gauss.py +++ b/floris/core/wake_deflection/gauss.py @@ -1,14 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from __future__ import annotations @@ -23,7 +12,7 @@ ) from numpy import pi -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, @@ -130,7 +119,12 @@ def function( for details on the methods used. Args: - # TODO + x_i (np.array): x-coordinates of turbine i. + y_i (np.array): y-coordinates of turbine i. + yaw_i (np.array): Yaw angle of turbine i. + turbulence_intensity_i (np.array): Turbulence intensity at turbine i. + ct_i (np.array): Thrust coefficient of turbine i. + rotor_diameter_i (float): Rotor diameter of turbine i. Returns: np.array: Deflection field for the wake. @@ -264,20 +258,20 @@ def wake_added_yaw( # turbine parameters D = rotor_diameter # scalar HH = hub_height # scalar - Ct = ct_i # (wd, ws, 1, 1, 1) for the current turbine + Ct = ct_i # (findex, 1, 1, 1) for the current turbine TSR = tip_speed_ratio # scalar - aI = axial_induction_i # (wd, ws, 1, 1, 1) for the current turbine - avg_v = np.mean(v_i, axis=(3, 4)) # (wd, ws, 1, grid, grid) + aI = axial_induction_i # (findex, 1, 1, 1) for the current turbine + avg_v = np.mean(v_i, axis=(2,3)) # (findex, 1, grid, grid) # flow parameters - Uinf = np.mean(u_initial, axis=(2, 3, 4)) - Uinf = Uinf[:, :, None, None, None] + Uinf = np.mean(u_initial, axis=(1, 2, 3)) + Uinf = Uinf[:, None, None, None] # TODO: Allow user input for eps gain eps_gain = 0.2 eps = eps_gain * D # Use set value - vel_top = ((HH + D / 2) / HH) ** wind_shear * np.ones((1, 1, 1, 1, 1)) + vel_top = ((HH + D / 2) / HH) ** wind_shear * np.ones((1, 1, 1, 1)) Gamma_top = gamma( D, vel_top, @@ -286,7 +280,7 @@ def wake_added_yaw( scale, ) - vel_bottom = ((HH - D / 2) / HH) ** wind_shear * np.ones((1, 1, 1, 1, 1)) + vel_bottom = ((HH - D / 2) / HH) ** wind_shear * np.ones((1, 1, 1, 1)) Gamma_bottom = -1 * gamma( D, vel_bottom, @@ -295,7 +289,7 @@ def wake_added_yaw( scale, ) - turbine_average_velocity = np.cbrt(np.mean(u_i ** 3, axis=(3, 4)))[:, :, :, None, None] + turbine_average_velocity = np.cbrt(np.mean(u_i ** 3, axis=(2, 3)))[:, :, None, None] Gamma_wake_rotation = 0.25 * 2 * pi * D * (aI - aI ** 2) * turbine_average_velocity / TSR ### compute the spanwise and vertical velocities induced by yaw @@ -311,7 +305,7 @@ def wake_added_yaw( # it defines the vortex profile in the spanwise directions core_shape = ne.evaluate("1 - exp(-rT / (eps ** 2))") v_top = ne.evaluate("(Gamma_top * zT) / (2 * pi * rT) * core_shape") - v_top = np.mean( v_top, axis=(3,4) ) + v_top = np.mean( v_top, axis=(2,3) ) # w_top = (-1 * Gamma_top * yLocs) / (2 * pi * rT) * core_shape * decay # bottom vortex @@ -319,7 +313,7 @@ def wake_added_yaw( rB = ne.evaluate("yLocs ** 2 + zB ** 2") core_shape = ne.evaluate("1 - exp(-rB / (eps ** 2))") v_bottom = ne.evaluate("(Gamma_bottom * zB) / (2 * pi * rB) * core_shape") - v_bottom = np.mean( v_bottom, axis=(3,4) ) + v_bottom = np.mean( v_bottom, axis=(2,3) ) # w_bottom = (-1 * Gamma_bottom * yLocs) / (2 * pi * rB) * core_shape * decay # wake rotation vortex @@ -327,7 +321,7 @@ def wake_added_yaw( rC = ne.evaluate("yLocs ** 2 + zC ** 2") core_shape = ne.evaluate("1 - exp(-rC / (eps ** 2))") v_core = ne.evaluate("(Gamma_wake_rotation * zC) / (2 * pi * rC) * core_shape") - v_core = np.mean( v_core, axis=(3,4) ) + v_core = np.mean( v_core, axis=(2,3) ) # w_core = (-1 * Gamma_wake_rotation * yLocs) / (2 * pi * rC) * core_shape * decay # Cap the effective yaw values between -45 and 45 degrees @@ -336,8 +330,7 @@ def wake_added_yaw( val = np.where(val > 1.0, 1.0, val) y = np.degrees(0.5 * np.arcsin(val)) - return y[:, :, :, None, None] - + return y[:, :, None, None] def calculate_transverse_velocity( u_i, @@ -368,12 +361,13 @@ def calculate_transverse_velocity( aI = axial_induction_i # flow parameters - Uinf = np.mean(u_initial, axis=(2, 3, 4))[:, :, None, None, None] + Uinf = np.mean(u_initial, axis=(1, 2, 3)) + Uinf = Uinf[:, None, None, None] eps_gain = 0.2 eps = eps_gain * D # Use set value - vel_top = ((HH + D / 2) / HH) ** wind_shear * np.ones((1, 1, 1, 1, 1)) + vel_top = ((HH + D / 2) / HH) ** wind_shear * np.ones((1, 1, 1, 1)) Gamma_top = sind(yaw) * cosd(yaw) * gamma( D, vel_top, @@ -382,7 +376,7 @@ def calculate_transverse_velocity( scale, ) - vel_bottom = ((HH - D / 2) / HH) ** wind_shear * np.ones((1, 1, 1, 1, 1)) + vel_bottom = ((HH - D / 2) / HH) ** wind_shear * np.ones((1, 1, 1, 1)) Gamma_bottom = -1 * sind(yaw) * cosd(yaw) * gamma( D, vel_bottom, @@ -390,7 +384,7 @@ def calculate_transverse_velocity( Ct, scale, ) - turbine_average_velocity = np.cbrt(np.mean(u_i ** 3, axis=(3, 4)))[:, :, :, None, None] + turbine_average_velocity = np.cbrt(np.mean(u_i ** 3, axis=(2,3)))[:, :, None, None] Gamma_wake_rotation = 0.25 * 2 * pi * D * (aI - aI ** 2) * turbine_average_velocity / TSR ### compute the spanwise and vertical velocities induced by yaw @@ -486,16 +480,16 @@ def yaw_added_turbulence_mixing( # use the left two dimensions only here and expand # before returning. Dimensions are (wd, ws). - I_i = I_i[:, :, 0, 0, 0] + I_i = I_i[:, 0, 0, 0] - average_u_i = np.cbrt(np.mean(u_i ** 3, axis=(2, 3, 4))) + average_u_i = np.cbrt(np.mean(u_i ** 3, axis=(1, 2, 3))) # Convert ambient turbulence intensity to TKE (eq 24) k = (average_u_i * I_i) ** 2 / (2 / 3) u_term = np.sqrt(2 * k) - v_term = np.mean(v_i + turb_v_i, axis=(2, 3, 4)) - w_term = np.mean(w_i + turb_w_i, axis=(2, 3, 4)) + v_term = np.mean(v_i + turb_v_i, axis=(1, 2, 3)) + w_term = np.mean(w_i + turb_w_i, axis=(1, 2, 3)) # Compute the new TKE (eq 23) k_total = 0.5 * (u_term ** 2 + v_term ** 2 + w_term ** 2) @@ -506,4 +500,4 @@ def yaw_added_turbulence_mixing( # Remove ambient from total TI leaving only the TI due to mixing I_mixing = I_total - I_i - return I_mixing[:, :, None, None, None] + return I_mixing[:, None, None, None] diff --git a/floris/simulation/wake_deflection/jimenez.py b/floris/core/wake_deflection/jimenez.py similarity index 82% rename from floris/simulation/wake_deflection/jimenez.py rename to floris/core/wake_deflection/jimenez.py index ceb6a3e8f..daca6e9c5 100644 --- a/floris/simulation/wake_deflection/jimenez.py +++ b/floris/core/wake_deflection/jimenez.py @@ -1,14 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict @@ -16,7 +5,7 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, @@ -75,13 +64,13 @@ def function( y_locations (np.array): spanwise locations in wake z_locations (np.array): vertical locations in wake (not used in Jiménez) - turbine (:py:class:`floris.simulation.turbine.Turbine`): + turbine (:py:class:`floris.core.turbine.Turbine`): Turbine object coord - (:py:meth:`floris.simulation.turbine_map.TurbineMap.coords`): + (:py:meth:`floris.core.turbine_map.TurbineMap.coords`): Spatial coordinates of wind turbine. flow_field - (:py:class:`floris.simulation.flow_field.FlowField`): + (:py:class:`floris.core.flow_field.FlowField`): Flow field object. Returns: diff --git a/floris/simulation/wake_deflection/none.py b/floris/core/wake_deflection/none.py similarity index 70% rename from floris/simulation/wake_deflection/none.py rename to floris/core/wake_deflection/none.py index df80e30d1..b428c8af9 100644 --- a/floris/simulation/wake_deflection/none.py +++ b/floris/core/wake_deflection/none.py @@ -1,21 +1,10 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict import numpy as np from attrs import define -from floris.simulation import ( +from floris.core import ( BaseModel, FlowField, Grid, diff --git a/floris/core/wake_turbulence/__init__.py b/floris/core/wake_turbulence/__init__.py new file mode 100644 index 000000000..8bec72939 --- /dev/null +++ b/floris/core/wake_turbulence/__init__.py @@ -0,0 +1,4 @@ + +from floris.core.wake_turbulence.crespo_hernandez import CrespoHernandez +from floris.core.wake_turbulence.none import NoneWakeTurbulence +from floris.core.wake_turbulence.wake_induced_mixing import WakeInducedMixing diff --git a/floris/simulation/wake_turbulence/crespo_hernandez.py b/floris/core/wake_turbulence/crespo_hernandez.py similarity index 83% rename from floris/simulation/wake_turbulence/crespo_hernandez.py rename to floris/core/wake_turbulence/crespo_hernandez.py index 923b62c6a..b5c623fe0 100644 --- a/floris/simulation/wake_turbulence/crespo_hernandez.py +++ b/floris/core/wake_turbulence/crespo_hernandez.py @@ -1,14 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict @@ -16,7 +5,7 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/simulation/wake_turbulence/none.py b/floris/core/wake_turbulence/none.py similarity index 56% rename from floris/simulation/wake_turbulence/none.py rename to floris/core/wake_turbulence/none.py index 6b8bf947d..146ca970b 100644 --- a/floris/simulation/wake_turbulence/none.py +++ b/floris/core/wake_turbulence/none.py @@ -1,21 +1,10 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict import numpy as np from attrs import define, field -from floris.simulation import BaseModel +from floris.core import BaseModel @define diff --git a/floris/simulation/wake_turbulence/wake_induced_mixing.py b/floris/core/wake_turbulence/wake_induced_mixing.py similarity index 77% rename from floris/simulation/wake_turbulence/wake_induced_mixing.py rename to floris/core/wake_turbulence/wake_induced_mixing.py index 9d57ee5aa..64306ff75 100644 --- a/floris/simulation/wake_turbulence/wake_induced_mixing.py +++ b/floris/core/wake_turbulence/wake_induced_mixing.py @@ -1,21 +1,10 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, @@ -82,6 +71,6 @@ def function( the ith turbine. """ - wake_induced_mixing = axial_induction_i[:,:,:,0,0] / downstream_distance_D_i**2 + wake_induced_mixing = axial_induction_i[:,:,0,0] / downstream_distance_D_i**2 return wake_induced_mixing diff --git a/floris/core/wake_velocity/__init__.py b/floris/core/wake_velocity/__init__.py new file mode 100644 index 000000000..dc1342f8a --- /dev/null +++ b/floris/core/wake_velocity/__init__.py @@ -0,0 +1,7 @@ + +from floris.core.wake_velocity.cumulative_gauss_curl import CumulativeGaussCurlVelocityDeficit +from floris.core.wake_velocity.empirical_gauss import EmpiricalGaussVelocityDeficit +from floris.core.wake_velocity.gauss import GaussVelocityDeficit +from floris.core.wake_velocity.jensen import JensenVelocityDeficit +from floris.core.wake_velocity.none import NoneVelocityDeficit +from floris.core.wake_velocity.turbopark import TurbOParkVelocityDeficit diff --git a/floris/simulation/wake_velocity/cumulative_gauss_curl.py b/floris/core/wake_velocity/cumulative_gauss_curl.py similarity index 76% rename from floris/simulation/wake_velocity/cumulative_gauss_curl.py rename to floris/core/wake_velocity/cumulative_gauss_curl.py index ba337ab3e..86d8c982e 100644 --- a/floris/simulation/wake_velocity/cumulative_gauss_curl.py +++ b/floris/core/wake_velocity/cumulative_gauss_curl.py @@ -1,14 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict @@ -16,7 +5,7 @@ from attrs import define, field from scipy.special import gamma -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, @@ -95,58 +84,58 @@ def function( turbine_yaw = yaw_i # TODO Should this be cbrt? This is done to match v2 - turb_avg_vels = np.cbrt(np.mean(u_i ** 3, axis=(3, 4))) - turb_avg_vels = turb_avg_vels[:, :, :, None, None] + turb_avg_vels = np.cbrt(np.mean(u_i ** 3, axis=(2, 3))) + turb_avg_vels = turb_avg_vels[:, :, None, None] delta_x = x - x_i sigma_n = wake_expansion( delta_x, - turbine_Ct[:, :, ii:ii+1], - turbine_ti[:, :, ii:ii+1], - turbine_diameter[:, :, ii:ii+1], + turbine_Ct[:, ii:ii+1], + turbine_ti[:, ii:ii+1], + turbine_diameter[:, ii:ii+1], self.a_s, self.b_s, self.c_s1, self.c_s2, ) - x_i_loc = np.mean(x_i, axis=(3, 4)) - x_i_loc = x_i_loc[:, :, :, None, None] + x_i_loc = np.mean(x_i, axis=(2, 3)) + x_i_loc = x_i_loc[:, :, None, None] - y_i_loc = np.mean(y_i, axis=(3, 4)) - y_i_loc = y_i_loc[:, :, :, None, None] + y_i_loc = np.mean(y_i, axis=(2, 3)) + y_i_loc = y_i_loc[:, :, None, None] - z_i_loc = np.mean(z_i, axis=(3, 4)) - z_i_loc = z_i_loc[:, :, :, None, None] + z_i_loc = np.mean(z_i, axis=(2, 3)) + z_i_loc = z_i_loc[:, :, None, None] - x_coord = np.mean(x, axis=(3, 4))[:, :, :, None, None] + x_coord = np.mean(x, axis=(2, 3))[:, :, None, None] y_loc = y - y_coord = np.mean(y, axis=(3, 4))[:, :, :, None, None] + y_coord = np.mean(y, axis=(2, 3))[:, :, None, None] z_loc = z # np.mean(z, axis=(3,4)) - z_coord = np.mean(z, axis=(3, 4))[:, :, :, None, None] + z_coord = np.mean(z, axis=(2, 3))[:, :, None, None] sum_lbda = np.zeros_like(u_initial) for m in range(0, ii - 1): - x_coord_m = x_coord[:, :, m:m+1] - y_coord_m = y_coord[:, :, m:m+1] - z_coord_m = z_coord[:, :, m:m+1] + x_coord_m = x_coord[:, m:m+1] + y_coord_m = y_coord[:, m:m+1] + z_coord_m = z_coord[:, m:m+1] # For computing cross planes, we don't need to compute downstream # turbines from out cross plane position. - if x_coord[:, :, m:m+1].size == 0: + if x_coord[:, m:m+1].size == 0: break delta_x_m = x - x_coord_m sigma_i = wake_expansion( delta_x_m, - turbine_Ct[:, :, m:m+1], - turbine_ti[:, :, m:m+1], - turbine_diameter[:, :, m:m+1], + turbine_Ct[:, m:m+1], + turbine_ti[:, m:m+1], + turbine_diameter[:, m:m+1], self.a_s, self.b_s, self.c_s1, @@ -181,9 +170,9 @@ def function( # blondel # super gaussian # b_f = self.b_f1 * np.exp(self.b_f2 * TI) + self.b_f3 - x_tilde = np.abs(delta_x) / turbine_diameter[:,:,ii:ii+1] + x_tilde = np.abs(delta_x) / turbine_diameter[:,ii:ii+1] r_tilde = np.sqrt( (y_loc - y_i_loc - deflection_field) ** 2 + (z_loc - z_i_loc) ** 2 ) - r_tilde /= turbine_diameter[:,:,ii:ii+1] + r_tilde /= turbine_diameter[:,ii:ii+1] n = self.a_f * np.exp(self.b_f * x_tilde) + self.c_f a1 = 2 ** (2 / n - 1) @@ -191,7 +180,7 @@ def function( # based on Blondel model, modified to include cumulative effects tmp = a2 - ( - (n * turbine_Ct[:, :, ii:ii+1]) + (n * turbine_Ct[:, ii:ii+1]) * cosd(turbine_yaw) / ( 16.0 diff --git a/floris/simulation/wake_velocity/empirical_gauss.py b/floris/core/wake_velocity/empirical_gauss.py similarity index 91% rename from floris/simulation/wake_velocity/empirical_gauss.py rename to floris/core/wake_velocity/empirical_gauss.py index 2043e8138..2e22db525 100644 --- a/floris/simulation/wake_velocity/empirical_gauss.py +++ b/floris/core/wake_velocity/empirical_gauss.py @@ -1,14 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict @@ -16,14 +5,14 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, Grid, Turbine, ) -from floris.simulation.wake_velocity.gauss import gaussian_function +from floris.core.wake_velocity.gauss import gaussian_function from floris.utilities import ( cosd, sind, @@ -70,6 +59,9 @@ class EmpiricalGaussVelocityDeficit(BaseModel): sigma_0_D: float = field(default=0.28) smoothing_length_D: float = field(default=2.0) mixing_gain_velocity: float = field(default=2.0) + awc_mode: str = field(default="baseline") + awc_wake_exp: float = field(default=1.2) + awc_wake_denominator: float = field(default=400) def prepare_function( self, @@ -170,7 +162,7 @@ def function( self.mixing_gain_velocity * mixing_i, ) sigma_y[upstream_mask] = \ - np.tile(sigma_y0, np.shape(sigma_y)[2:])[upstream_mask] + np.tile(sigma_y0, np.shape(sigma_y)[1:])[upstream_mask] sigma_z = empirical_gauss_model_wake_width( x - x_i, @@ -181,7 +173,7 @@ def function( self.mixing_gain_velocity * mixing_i, ) sigma_z[upstream_mask] = \ - np.tile(sigma_z0, np.shape(sigma_z)[2:])[upstream_mask] + np.tile(sigma_z0, np.shape(sigma_z)[1:])[upstream_mask] # 'Standard' wake component r, C = rCalt( @@ -265,7 +257,7 @@ def rCalt(wind_veer, sigma_y, sigma_z, y, y_i, delta_y, delta_z, z, HH, Ct, def sigmoid_integral(x, center=0, width=1): y = np.zeros_like(x) - #TODO: Can this be made faster? + # TODO: Can this be made faster? above_smoothing_zone = (x-center) > width/2 y[above_smoothing_zone] = (x-center)[above_smoothing_zone] in_smoothing_zone = ((x-center) >= -width/2) & ((x-center) <= width/2) @@ -292,3 +284,22 @@ def empirical_gauss_model_wake_width( sigmoid_integral(x, center=b, width=smoothing_length) return sigma + +def awc_added_wake_mixing( + awc_mode_i, + awc_amplitude_i, + awc_frequency_i, + awc_wake_exp, + awc_wake_denominator +): + + # TODO: Add TI in the mix, finetune amplitude/freq effect + if (awc_mode_i == "helix").any(): + return awc_amplitude_i[:,:,0,0]**awc_wake_exp/awc_wake_denominator + elif (awc_mode_i == "baseline").any(): + return 0 + else: + raise NotImplementedError( + 'Active wake mixing strategies other than the `helix` mode ' + 'have not yet been implemented in FLORIS.' + ) diff --git a/floris/simulation/wake_velocity/gauss.py b/floris/core/wake_velocity/gauss.py similarity index 92% rename from floris/simulation/wake_velocity/gauss.py rename to floris/core/wake_velocity/gauss.py index e98672a68..bac3cf415 100644 --- a/floris/simulation/wake_velocity/gauss.py +++ b/floris/core/wake_velocity/gauss.py @@ -1,14 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict @@ -16,7 +5,7 @@ import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, @@ -131,7 +120,7 @@ def function( # Another linear ramp, but positive upstream of the far wake and negative in the # far wake; 0 at the start of the far wake near_wake_ramp_down = (x0 - x) / (x0 - xR) - # near_wake_ramp_down = -1 * (near_wake_ramp_up - 1) # TODO: this is equivalent, right? + # near_wake_ramp_down = -1 * (near_wake_ramp_up - 1) # : this is equivalent, right? sigma_y = near_wake_ramp_down * 0.501 * rotor_diameter_i * np.sqrt(ct_i / 2.0) sigma_y += near_wake_ramp_up * sigma_y0 diff --git a/floris/simulation/wake_velocity/jensen.py b/floris/core/wake_velocity/jensen.py similarity index 87% rename from floris/simulation/wake_velocity/jensen.py rename to floris/core/wake_velocity/jensen.py index b5efce92e..7d6b09c31 100644 --- a/floris/simulation/wake_velocity/jensen.py +++ b/floris/core/wake_velocity/jensen.py @@ -1,14 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict @@ -20,7 +9,7 @@ fields, ) -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, diff --git a/floris/simulation/wake_velocity/none.py b/floris/core/wake_velocity/none.py similarity index 67% rename from floris/simulation/wake_velocity/none.py rename to floris/core/wake_velocity/none.py index 58c00779b..af1ea448a 100644 --- a/floris/simulation/wake_velocity/none.py +++ b/floris/core/wake_velocity/none.py @@ -1,21 +1,10 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from typing import Any, Dict import numpy as np from attrs import define, field -from floris.simulation import ( +from floris.core import ( BaseModel, FlowField, Grid, diff --git a/floris/simulation/wake_velocity/turbopark.py b/floris/core/wake_velocity/turbopark.py similarity index 87% rename from floris/simulation/wake_velocity/turbopark.py rename to floris/core/wake_velocity/turbopark.py index cf0443347..63ad6e06c 100644 --- a/floris/simulation/wake_velocity/turbopark.py +++ b/floris/core/wake_velocity/turbopark.py @@ -1,14 +1,4 @@ -# Copyright 2022 NREL -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. from pathlib import Path from typing import Any, Dict @@ -19,7 +9,7 @@ from scipy import integrate from scipy.interpolate import RegularGridInterpolator -from floris.simulation import ( +from floris.core import ( BaseModel, Farm, FlowField, @@ -80,7 +70,7 @@ def function( x_i: np.ndarray, y_i: np.ndarray, z_i: np.ndarray, - ambient_turbulence_intensity: np.ndarray, + ambient_turbulence_intensities: np.ndarray, Cts: np.ndarray, rotor_diameter_i: np.ndarray, rotor_diameters: np.ndarray, @@ -109,10 +99,10 @@ def function( r_dist = np.sqrt((y_i - (y + deflection_field)) ** 2 + (z_i - z) ** 2) r_dist_image = np.sqrt((y_i - (y + deflection_field)) ** 2 + (z_i - (-z)) ** 2) - Cts[:, :, i:, :, :] = 0.00001 + Cts[:, i:, :, :] = 0.00001 # Characteristic wake widths from all turbines relative to turbine i - dw = characteristic_wake_width(x_dist, ambient_turbulence_intensity, Cts, self.A) + dw = characteristic_wake_width(x_dist, ambient_turbulence_intensities, Cts, self.A) epsilon = 0.25 * np.sqrt( np.min( 0.5 * (1 + np.sqrt(1 - Cts)) / np.sqrt(1 - Cts), 3, keepdims=True ) ) @@ -137,9 +127,9 @@ def function( delta_image = C * wtg_overlapping * self.overlap_gauss_interp( (r_dist_image / sigma, rotor_diameter_i / 2 / sigma) ) - delta = np.concatenate((delta_real, delta_image), axis=2) + delta = np.concatenate((delta_real, delta_image), axis=1) - delta_total[:, :, i, :, :] = np.sqrt(np.sum(np.nan_to_num(delta) ** 2, axis=2)) + delta_total[:, i, :, :] = np.sqrt(np.sum(np.nan_to_num(delta) ** 2, axis=1)) return delta_total diff --git a/floris/simulation/wake_velocity/turbopark_lookup_table.mat b/floris/core/wake_velocity/turbopark_lookup_table.mat similarity index 100% rename from floris/simulation/wake_velocity/turbopark_lookup_table.mat rename to floris/core/wake_velocity/turbopark_lookup_table.mat diff --git a/floris/tools/cut_plane.py b/floris/cut_plane.py similarity index 94% rename from floris/tools/cut_plane.py rename to floris/cut_plane.py index ade17b7d7..10c573353 100644 --- a/floris/tools/cut_plane.py +++ b/floris/cut_plane.py @@ -1,17 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import copy @@ -352,7 +338,7 @@ def calculate_wind_speed(cross_plane, x1_loc, x2_loc, R): Calculate effective wind speed within specified range of a point. Args: - cross_plane (:py:class:`floris.tools.cut_plane.CrossPlane`): + cross_plane (:py:class:`floris.cut_plane.CrossPlane`): plane of data. x1_loc (float): x1-coordinate of point of interest. x2_loc (float): x2-coordinate of point of interest. @@ -391,7 +377,7 @@ def calculate_power( Calculate maximum power available in a given cross plane. Args: - cross_plane (:py:class:`floris.tools.cut_plane.CrossPlane`): + cross_plane (:py:class:`floris.cut_plane.CrossPlane`): plane of data. x1_loc (float): x1-coordinate of point of interest. x2_loc (float): x2-coordinate of point of interest. diff --git a/floris/floris_model.py b/floris/floris_model.py new file mode 100644 index 000000000..99ab55eab --- /dev/null +++ b/floris/floris_model.py @@ -0,0 +1,1689 @@ + +from __future__ import annotations + +import copy +import inspect +from pathlib import Path +from typing import ( + Any, + List, + Optional, +) + +import numpy as np +import pandas as pd + +from floris.core import Core, State +from floris.core.rotor_velocity import average_velocity +from floris.core.turbine.operation_models import ( + POWER_SETPOINT_DEFAULT, + POWER_SETPOINT_DISABLED, +) +from floris.core.turbine.turbine import ( + axial_induction, + power, + thrust_coefficient, +) +from floris.cut_plane import CutPlane +from floris.logging_manager import LoggingManager +from floris.type_dec import ( + floris_array_converter, + NDArrayBool, + NDArrayFloat, + NDArrayStr, +) +from floris.utilities import ( + nested_get, + nested_set, + print_nested_dict, +) +from floris.wind_data import ( + TimeSeries, + WindDataBase, + WindRose, + WindTIRose, +) + + +class FlorisModel(LoggingManager): + """ + FlorisModel provides a high-level user interface to many of the + underlying methods within the FLORIS framework. It is meant to act as a + single entry-point for the majority of users, simplifying the calls to + methods on objects within FLORIS. + + Args: + configuration (:py:obj:`dict`): The Floris configuration dictionary or YAML file. + The configuration should have the following inputs specified. + - **flow_field**: See `floris.simulation.flow_field.FlowField` for more details. + - **farm**: See `floris.simulation.farm.Farm` for more details. + - **turbine**: See `floris.simulation.turbine.Turbine` for more details. + - **wake**: See `floris.simulation.wake.WakeManager` for more details. + - **logging**: See `floris.simulation.core.Core` for more details. + """ + + def __init__(self, configuration: dict | str | Path): + self.configuration = configuration + + if isinstance(self.configuration, (str, Path)): + try: + self.core = Core.from_file(self.configuration) + except FileNotFoundError: + # If the file cannot be found, then attempt the configuration path relative to the + # file location from which FlorisModel was attempted to be run. If successful, + # update self.configuration to an absolute, working file path and name. + base_fn = Path(inspect.stack()[-1].filename).resolve().parent + config = (base_fn / self.configuration).resolve() + self.core = Core.from_file(config) + self.configuration = config + + elif isinstance(self.configuration, dict): + self.core = Core.from_dict(self.configuration) + + else: + raise TypeError("The Floris `configuration` must be of type 'dict', 'str', or 'Path'.") + + # If ref height is -1, assign the hub height + if np.abs(self.core.flow_field.reference_wind_height + 1.0) < 1.0e-6: + self.assign_hub_height_to_ref_height() + + # Make a check on reference height and provide a helpful warning + unique_heights = np.unique(np.round(self.core.farm.hub_heights, decimals=6)) + if (( + len(unique_heights) == 1) and + (np.abs(self.core.flow_field.reference_wind_height - unique_heights[0]) > 1.0e-6 + )): + err_msg = ( + "The only unique hub-height is not the equal to the specified reference " + "wind height. If this was unintended use -1 as the reference hub height to " + " indicate use of hub-height as reference wind height." + ) + self.logger.warning(err_msg, stack_info=True) + + # Check the turbine_grid_points is reasonable + if self.core.solver["type"] == "turbine_grid": + if self.core.solver["turbine_grid_points"] > 3: + self.logger.error( + f"turbine_grid_points value is {self.core.solver['turbine_grid_points']} " + "which is larger than the recommended value of less than or equal to 3. " + "High amounts of turbine grid points reduce the computational performance " + "but have a small change on accuracy." + ) + raise ValueError("turbine_grid_points must be less than or equal to 3.") + + # Initialize stored wind_data object to None + self._wind_data = None + + ### Methods for setting and running the FlorisModel + + def _reinitialize( + self, + wind_speeds: list[float] | NDArrayFloat | None = None, + wind_directions: list[float] | NDArrayFloat | None = None, + wind_shear: float | None = None, + wind_veer: float | None = None, + reference_wind_height: float | None = None, + turbulence_intensities: list[float] | NDArrayFloat | None = None, + air_density: float | None = None, + layout_x: list[float] | NDArrayFloat | None = None, + layout_y: list[float] | NDArrayFloat | None = None, + turbine_type: list | None = None, + turbine_library_path: str | Path | None = None, + solver_settings: dict | None = None, + heterogeneous_inflow_config=None, + wind_data: type[WindDataBase] | None = None, + ): + """ + Instantiate a new Floris object with updated conditions set by arguments. Any parameters + in Floris that aren't changed by arguments to this function retain their values. + Note that, although it's name is similar to the reinitialize() method from Floris v3, + this function is not meant to be called directly by the user---users should instead call + the set() method. + + Args: + wind_speeds (NDArrayFloat | list[float] | None, optional): Wind speeds at each findex. + Defaults to None. + wind_directions (NDArrayFloat | list[float] | None, optional): Wind directions at each + findex. Defaults to None. + wind_shear (float | None, optional): Wind shear exponent. Defaults to None. + wind_veer (float | None, optional): Wind veer. Defaults to None. + reference_wind_height (float | None, optional): Reference wind height. Defaults to None. + turbulence_intensities (NDArrayFloat | list[float] | None, optional): Turbulence + intensities at each findex. Defaults to None. + air_density (float | None, optional): Air density. Defaults to None. + layout_x (NDArrayFloat | list[float] | None, optional): X-coordinates of the turbines. + Defaults to None. + layout_y (NDArrayFloat | list[float] | None, optional): Y-coordinates of the turbines. + Defaults to None. + turbine_type (list | None, optional): Turbine type. Defaults to None. + turbine_library_path (str | Path | None, optional): Path to the turbine library. + Defaults to None. + solver_settings (dict | None, optional): Solver settings. Defaults to None. + heterogeneous_inflow_config (None, optional): heterogeneous inflow configuration. + Defaults to None. + wind_data (type[WindDataBase] | None, optional): Wind data. Defaults to None. + """ + # Export the floris object recursively as a dictionary + floris_dict = self.core.as_dict() + flow_field_dict = floris_dict["flow_field"] + farm_dict = floris_dict["farm"] + + # + if ( + (wind_directions is not None) + or (wind_speeds is not None) + or (turbulence_intensities is not None) + or (heterogeneous_inflow_config is not None) + ): + if wind_data is not None: + raise ValueError( + "If wind_data is passed to reinitialize, then do not pass wind_directions, " + "wind_speeds, turbulence_intensities or " + "heterogeneous_inflow_config as this is redundant" + ) + elif self.wind_data is not None: + self.logger.warning("Deleting stored wind_data information.") + self._wind_data = None + if wind_data is not None: + # Unpack wind data for reinitialization and save wind_data for use in output + ( + wind_directions, + wind_speeds, + turbulence_intensities, + heterogeneous_inflow_config, + ) = wind_data.unpack_for_reinitialize() + self._wind_data = wind_data + + ## FlowField + if wind_speeds is not None: + flow_field_dict["wind_speeds"] = wind_speeds + if wind_directions is not None: + flow_field_dict["wind_directions"] = wind_directions + if wind_shear is not None: + flow_field_dict["wind_shear"] = wind_shear + if wind_veer is not None: + flow_field_dict["wind_veer"] = wind_veer + if reference_wind_height is not None: + flow_field_dict["reference_wind_height"] = reference_wind_height + if turbulence_intensities is not None: + flow_field_dict["turbulence_intensities"] = turbulence_intensities + if air_density is not None: + flow_field_dict["air_density"] = air_density + if heterogeneous_inflow_config is not None: + flow_field_dict["heterogeneous_inflow_config"] = heterogeneous_inflow_config + + ## Farm + if layout_x is not None: + farm_dict["layout_x"] = layout_x + if layout_y is not None: + farm_dict["layout_y"] = layout_y + if turbine_type is not None: + farm_dict["turbine_type"] = turbine_type + if turbine_library_path is not None: + farm_dict["turbine_library_path"] = turbine_library_path + + if solver_settings is not None: + floris_dict["solver"] = solver_settings + + floris_dict["flow_field"] = flow_field_dict + floris_dict["farm"] = farm_dict + + # Create a new instance of floris and attach to self + self.core = Core.from_dict(floris_dict) + + def set_operation( + self, + yaw_angles: NDArrayFloat | list[float] | None = None, + power_setpoints: NDArrayFloat | list[float] | list[float, None] | None = None, + awc_modes: NDArrayStr | list[str] | list[str, None] | None = None, + awc_amplitudes: NDArrayFloat | list[float] | list[float, None] | None = None, + awc_frequencies: NDArrayFloat | list[float] | list[float, None] | None = None, + disable_turbines: NDArrayBool | list[bool] | None = None, + ): + """ + Apply operating setpoints to the floris object. + + This function is not meant to be called directly by most users---users should instead call + the set() method. + + Args: + yaw_angles (NDArrayFloat | list[float] | None, optional): Turbine yaw angles. Defaults + to None. + power_setpoints (NDArrayFloat | list[float] | list[float, None] | None, optional): + Turbine power setpoints. Defaults to None. + disable_turbines (NDArrayBool | list[bool] | None, optional): Boolean array on whether + to disable turbines. Defaults to None. + """ + # Add operating conditions to the floris object + if yaw_angles is not None: + if np.array(yaw_angles).shape[1] != self.core.farm.n_turbines: + raise ValueError( + f"yaw_angles has a size of {np.array(yaw_angles).shape[1]} in the 1st " + f"dimension, must be equal to n_turbines={self.core.farm.n_turbines}" + ) + self.core.farm.set_yaw_angles(yaw_angles) + + if power_setpoints is not None: + if np.array(power_setpoints).shape[1] != self.core.farm.n_turbines: + raise ValueError( + f"power_setpoints has a size of {np.array(power_setpoints).shape[1]} in the 1st" + f" dimension, must be equal to n_turbines={self.core.farm.n_turbines}" + ) + power_setpoints = np.array(power_setpoints) + + # Convert any None values to the default power setpoint + power_setpoints[ + power_setpoints == np.full(power_setpoints.shape, None) + ] = POWER_SETPOINT_DEFAULT + power_setpoints = floris_array_converter(power_setpoints) + + self.core.farm.set_power_setpoints(power_setpoints) + + if awc_modes is None: + awc_modes = np.array( + [["baseline"] + *self.core.farm.n_turbines] + *self.core.flow_field.n_findex + ) + self.core.farm.awc_modes = awc_modes + + if awc_amplitudes is None: + awc_amplitudes = np.zeros( + ( + self.core.flow_field.n_findex, + self.core.farm.n_turbines, + ) + ) + self.core.farm.awc_amplitudes = awc_amplitudes + + if awc_frequencies is None: + awc_frequencies = np.zeros( + ( + self.core.flow_field.n_findex, + self.core.farm.n_turbines, + ) + ) + self.core.farm.awc_frequencies = awc_frequencies + + # Check for turbines to disable + if disable_turbines is not None: + + # Force to numpy array + disable_turbines = np.array(disable_turbines) + + # Must have first dimension = n_findex + if disable_turbines.shape[0] != self.core.flow_field.n_findex: + raise ValueError( + f"disable_turbines has a size of {disable_turbines.shape[0]} " + f"in the 0th dimension, must be equal to " + f"n_findex={self.core.flow_field.n_findex}" + ) + + # Must have first dimension = n_turbines + if disable_turbines.shape[1] != self.core.farm.n_turbines: + raise ValueError( + f"disable_turbines has a size of {disable_turbines.shape[1]} " + f"in the 1th dimension, must be equal to " + f"n_turbines={self.core.farm.n_turbines}" + ) + + # Set power setpoints to small value (non zero to avoid numerical issues) and + # yaw_angles to 0 in all locations where disable_turbines is True + self.core.farm.yaw_angles[disable_turbines] = 0.0 + self.core.farm.power_setpoints[disable_turbines] = POWER_SETPOINT_DISABLED + + if any([yaw_angles is not None, power_setpoints is not None, disable_turbines is not None]): + self.core.state = State.UNINITIALIZED + + def set( + self, + wind_speeds: list[float] | NDArrayFloat | None = None, + wind_directions: list[float] | NDArrayFloat | None = None, + wind_shear: float | None = None, + wind_veer: float | None = None, + reference_wind_height: float | None = None, + turbulence_intensities: list[float] | NDArrayFloat | None = None, + air_density: float | None = None, + layout_x: list[float] | NDArrayFloat | None = None, + layout_y: list[float] | NDArrayFloat | None = None, + turbine_type: list | None = None, + turbine_library_path: str | Path | None = None, + solver_settings: dict | None = None, + heterogeneous_inflow_config=None, + wind_data: type[WindDataBase] | None = None, + yaw_angles: NDArrayFloat | list[float] | None = None, + power_setpoints: NDArrayFloat | list[float] | list[float, None] | None = None, + awc_modes: NDArrayStr | list[str] | list[str, None] | None = None, + awc_amplitudes: NDArrayFloat | list[float] | list[float, None] | None = None, + awc_frequencies: NDArrayFloat | list[float] | list[float, None] | None = None, + disable_turbines: NDArrayBool | list[bool] | None = None, + ): + """ + Set the wind conditions and operation setpoints for the wind farm. + + Args: + wind_speeds (NDArrayFloat | list[float] | None, optional): Wind speeds at each findex. + Defaults to None. + wind_directions (NDArrayFloat | list[float] | None, optional): Wind directions at each + findex. Defaults to None. + wind_shear (float | None, optional): Wind shear exponent. Defaults to None. + wind_veer (float | None, optional): Wind veer. Defaults to None. + reference_wind_height (float | None, optional): Reference wind height. Defaults to None. + turbulence_intensities (NDArrayFloat | list[float] | None, optional): Turbulence + intensities at each findex. Defaults to None. + air_density (float | None, optional): Air density. Defaults to None. + layout_x (NDArrayFloat | list[float] | None, optional): X-coordinates of the turbines. + Defaults to None. + layout_y (NDArrayFloat | list[float] | None, optional): Y-coordinates of the turbines. + Defaults to None. + turbine_type (list | None, optional): Turbine type. Defaults to None. + turbine_library_path (str | Path | None, optional): Path to the turbine library. + Defaults to None. + solver_settings (dict | None, optional): Solver settings. Defaults to None. + heterogeneous_inflow_config (None, optional): heterogeneous inflow configuration. + Defaults to None. + wind_data (type[WindDataBase] | None, optional): Wind data. Defaults to None. + yaw_angles (NDArrayFloat | list[float] | None, optional): Turbine yaw angles. + Defaults to None. + power_setpoints (NDArrayFloat | list[float] | list[float, None] | None, optional): + Turbine power setpoints. + disable_turbines (NDArrayBool | list[bool] | None, optional): NDArray with dimensions + n_findex x n_turbines. True values indicate the turbine is disabled at that findex + and the power setpoint at that position is set to 0. Defaults to None. + """ + # Initialize a new Floris object after saving the setpoints + _yaw_angles = self.core.farm.yaw_angles + _power_setpoints = self.core.farm.power_setpoints + _awc_modes = self.core.farm.awc_modes + _awc_amplitudes = self.core.farm.awc_amplitudes + _awc_frequencies = self.core.farm.awc_frequencies + self._reinitialize( + wind_speeds=wind_speeds, + wind_directions=wind_directions, + wind_shear=wind_shear, + wind_veer=wind_veer, + reference_wind_height=reference_wind_height, + turbulence_intensities=turbulence_intensities, + air_density=air_density, + layout_x=layout_x, + layout_y=layout_y, + turbine_type=turbine_type, + turbine_library_path=turbine_library_path, + solver_settings=solver_settings, + heterogeneous_inflow_config=heterogeneous_inflow_config, + wind_data=wind_data, + ) + + # If the yaw angles or power setpoints are not the default, set them back to the + # previous setting + if not (_yaw_angles == 0).all(): + self.core.farm.set_yaw_angles(_yaw_angles) + if not ( + (_power_setpoints == POWER_SETPOINT_DEFAULT) + | (_power_setpoints == POWER_SETPOINT_DISABLED) + ).all(): + self.core.farm.set_power_setpoints(_power_setpoints) + if _awc_modes is not None: + self.core.farm.set_awc_modes(_awc_modes) + if not (_awc_amplitudes == 0).all(): + self.core.farm.set_awc_amplitudes(_awc_amplitudes) + if not (_awc_frequencies == 0).all(): + self.core.farm.set_awc_frequencies(_awc_frequencies) + + # Set the operation + self.set_operation( + yaw_angles=yaw_angles, + power_setpoints=power_setpoints, + awc_modes=awc_modes, + awc_amplitudes=awc_amplitudes, + awc_frequencies=awc_frequencies, + disable_turbines=disable_turbines, + ) + + def reset_operation(self): + """ + Instantiate a new Floris object to set all operation setpoints to their default values. + """ + self._reinitialize() + + def run(self) -> None: + """ + Run the FLORIS solve to compute the velocity field and wake effects. + """ + + # Initialize solution space + self.core.initialize_domain() + + # Perform the wake calculations + self.core.steady_state_atmospheric_condition() + + def run_no_wake(self) -> None: + """ + This function is similar to `run()` except that it does not apply a wake model. That is, + the wind farm is modeled as if there is no wake in the flow. Operation settings may + reduce the power and thrust of the turbine to where they're applied. + """ + + # Initialize solution space + self.core.initialize_domain() + + # Finalize values to user-supplied order + self.core.finalize() + + + ### Methods for extracting turbine performance after running + + def _get_turbine_powers(self) -> NDArrayFloat: + """Calculates the power at each turbine in the wind farm. + + Returns: + NDArrayFloat: Powers at each turbine. + """ + + # Confirm calculate wake has been run + if self.core.state is not State.USED: + raise RuntimeError( + "Can't compute turbine powers without first running `FlorisModel.run()`." + ) + # Check for negative velocities, which could indicate bad model + # parameters or turbines very closely spaced. + if (self.core.flow_field.u < 0.0).any(): + self.logger.warning("Some velocities at the rotor are negative.") + + turbine_powers = power( + velocities=self.core.flow_field.u, + air_density=self.core.flow_field.air_density, + power_functions=self.core.farm.turbine_power_functions, + yaw_angles=self.core.farm.yaw_angles, + tilt_angles=self.core.farm.tilt_angles, + power_setpoints=self.core.farm.power_setpoints, + awc_modes = self.core.farm.awc_modes, + awc_amplitudes=self.core.farm.awc_amplitudes, + tilt_interps=self.core.farm.turbine_tilt_interps, + turbine_type_map=self.core.farm.turbine_type_map, + turbine_power_thrust_tables=self.core.farm.turbine_power_thrust_tables, + correct_cp_ct_for_tilt=self.core.farm.correct_cp_ct_for_tilt, + multidim_condition=self.core.flow_field.multidim_conditions, + ) + return turbine_powers + + + def get_turbine_powers(self): + """ + Calculates the power at each turbine in the wind farm. + + Returns: + NDArrayFloat: Powers at each turbine. + """ + turbine_powers = self._get_turbine_powers() + + if self.wind_data is not None: + if type(self.wind_data) is WindRose: + turbine_powers_rose = np.full( + (len(self.wind_data.wd_flat), self.core.farm.n_turbines), + np.nan + ) + turbine_powers_rose[self.wind_data.non_zero_freq_mask, :] = turbine_powers + turbine_powers = turbine_powers_rose.reshape( + len(self.wind_data.wind_directions), + len(self.wind_data.wind_speeds), + self.core.farm.n_turbines + ) + elif type(self.wind_data) is WindTIRose: + turbine_powers_rose = np.full( + (len(self.wind_data.wd_flat), self.core.farm.n_turbines), + np.nan + ) + turbine_powers_rose[self.wind_data.non_zero_freq_mask, :] = turbine_powers + turbine_powers = turbine_powers_rose.reshape( + len(self.wind_data.wind_directions), + len(self.wind_data.wind_speeds), + len(self.wind_data.turbulence_intensities), + self.core.farm.n_turbines + ) + + return turbine_powers + + def _get_farm_power( + self, + turbine_weights=None, + use_turbulence_correction=False, + ): + """ + Report wind plant power from instance of floris. Optionally includes + uncertainty in wind direction and yaw position when determining power. + Uncertainty is included by computing the mean wind farm power for a + distribution of wind direction and yaw position deviations from the + original wind direction and yaw angles. + + Args: + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the power production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris + is multiplied with this array in the calculation of the + objective function. If None, this is an array with all values + 1.0 and with shape equal to (n_findex, n_turbines). + Defaults to None. + use_turbulence_correction: (bool, optional): When True uses a + turbulence parameter to adjust power output calculations. + Defaults to False. Not currently implemented. + + Returns: + float: Sum of wind turbine powers in W. + """ + if use_turbulence_correction: + raise NotImplementedError( + "Turbulence correction is not yet implemented in the power calculation." + ) + + # Confirm run() has been run + if self.core.state is not State.USED: + raise RuntimeError( + "Can't run function `FlorisModel.get_farm_power` without " + "first running `FlorisModel.run`." + ) + + if turbine_weights is None: + # Default to equal weighing of all turbines when turbine_weights is None + turbine_weights = np.ones( + ( + self.core.flow_field.n_findex, + self.core.farm.n_turbines, + ) + ) + elif len(np.shape(turbine_weights)) == 1: + # Deal with situation when 1D array is provided + turbine_weights = np.tile( + turbine_weights, + (self.core.flow_field.n_findex, 1), + ) + + # Calculate all turbine powers and apply weights + turbine_powers = self._get_turbine_powers() + turbine_powers = np.multiply(turbine_weights, turbine_powers) + + return np.sum(turbine_powers, axis=1) + + def get_farm_power( + self, + turbine_weights=None, + use_turbulence_correction=False, + ): + """ + Report wind plant power from instance of floris. Optionally includes + uncertainty in wind direction and yaw position when determining power. + Uncertainty is included by computing the mean wind farm power for a + distribution of wind direction and yaw position deviations from the + original wind direction and yaw angles. + + Args: + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the power production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris + is multiplied with this array in the calculation of the + objective function. If None, this is an array with all values + 1.0 and with shape equal to (n_findex, n_turbines). + Defaults to None. + use_turbulence_correction: (bool, optional): When True uses a + turbulence parameter to adjust power output calculations. + Defaults to False. Not currently implemented. + + Returns: + float: Sum of wind turbine powers in W. + """ + farm_power = self._get_farm_power(turbine_weights, use_turbulence_correction) + + if self.wind_data is not None: + if type(self.wind_data) is WindRose: + farm_power_rose = np.full(len(self.wind_data.wd_flat), np.nan) + farm_power_rose[self.wind_data.non_zero_freq_mask] = farm_power + farm_power = farm_power_rose.reshape( + len(self.wind_data.wind_directions), + len(self.wind_data.wind_speeds) + ) + elif type(self.wind_data) is WindTIRose: + farm_power_rose = np.full(len(self.wind_data.wd_flat), np.nan) + farm_power_rose[self.wind_data.non_zero_freq_mask] = farm_power + farm_power = farm_power_rose.reshape( + len(self.wind_data.wind_directions), + len(self.wind_data.wind_speeds), + len(self.wind_data.turbulence_intensities) + ) + + return farm_power + + def get_expected_farm_power( + self, + freq=None, + turbine_weights=None, + ) -> float: + """ + Compute the expected (mean) power of the wind farm. + + Args: + freq (NDArrayFloat): NumPy array with shape (n_findex) + with the frequencies of each wind direction and + wind speed combination. These frequencies should typically sum + up to 1.0 and are used to weigh the wind farm power for every + condition in calculating the wind farm's AEP. Defaults to None. + If None and a WindData object was supplied, the WindData object's + frequencies will be used. Otherwise, uniform frequencies are assumed + (i.e., a simple mean over the findices is computed). + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the power production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris + is multiplied with this array in the calculation of the + objective function. If None, this is an array with all values + 1.0 and with shape equal to (n_findex, + n_turbines). Defaults to None. + """ + + farm_power = self._get_farm_power(turbine_weights=turbine_weights) + + if freq is None: + if self.wind_data is None: + freq = np.array([1.0/self.core.flow_field.n_findex]) + else: + freq = self.wind_data.unpack_freq() + + return np.nansum(np.multiply(freq, farm_power)) + + def get_farm_AEP( + self, + freq=None, + turbine_weights=None, + hours_per_year=8760, + ) -> float: + """ + Estimate annual energy production (AEP) for distributions of wind speed, wind + direction, frequency of occurrence, and yaw offset. + + Args: + freq (NDArrayFloat): NumPy array with shape (n_findex) + with the frequencies of each wind direction and + wind speed combination. These frequencies should typically sum + up to 1.0 and are used to weigh the wind farm power for every + condition in calculating the wind farm's AEP. Defaults to None. + If None and a WindData object was supplied, the WindData object's + frequencies will be used. Otherwise, uniform frequencies are assumed. + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the power production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris + is multiplied with this array in the calculation of the + objective function. If None, this is an array with all values + 1.0 and with shape equal to (n_findex, + n_turbines). Defaults to None. + hours_per_year (float, optional): Number of hours in a year. Defaults to 365 * 24. + + Returns: + float: + The Annual Energy Production (AEP) for the wind farm in + watt-hours. + """ + if ( + freq is None + and not isinstance(self.wind_data, WindRose) + and not isinstance(self.wind_data, WindTIRose) + ): + self.logger.warning( + "Computing AEP with uniform frequencies. Results results may not reflect annual " + "operation." + ) + + return self.get_expected_farm_power( + freq=freq, + turbine_weights=turbine_weights + ) * hours_per_year + + def get_expected_farm_value( + self, + freq=None, + values=None, + turbine_weights=None, + ) -> float: + """ + Compute the expected (mean) value produced by the wind farm. This is + computed by multiplying the wind farm power for each wind condition by + the corresponding value of the power generated (e.g., electricity + market price per unit of energy), then weighting by frequency and + summing over all conditions. + + Args: + freq (NDArrayFloat): NumPy array with shape (n_findex) + with the frequencies of each wind condition combination. + These frequencies should typically sum up to 1.0 and are used + to weigh the wind farm value for every condition in calculating + the wind farm's expected value. Defaults to None. If None and a + WindData object is supplied, the WindData object's frequencies + will be used. Otherwise, uniform frequencies are assumed (i.e., + a simple mean over the findices is computed). + values (NDArrayFloat): NumPy array with shape (n_findex) + with the values corresponding to the power generated for each + wind condition combination. The wind farm power is multiplied + by the value for every condition in calculating the wind farm's + expected value. Defaults to None. If None and a WindData object + is supplied, the WindData object's values will be used. + Otherwise, a value of 1 for all conditions is assumed (i.e., + the expected farm value will be equivalent to the expected farm + power). + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the value production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris + is multiplied with this array in the calculation of the + expected value. If None, this is an array with all values 1.0 + and with shape equal to (n_findex, n_turbines). Defaults to None. + + Returns: + float: + The expected value produced by the wind farm in units of value. + """ + + farm_power = self._get_farm_power(turbine_weights=turbine_weights) + + if freq is None: + if self.wind_data is None: + freq = np.array([1.0/self.core.flow_field.n_findex]) + else: + freq = self.wind_data.unpack_freq() + + if values is None: + if self.wind_data is None: + values = np.array([1.0]) + else: + values = self.wind_data.unpack_value() + + farm_value = np.multiply(values, farm_power) + + return np.nansum(np.multiply(freq, farm_value)) + + def get_farm_AVP( + self, + freq=None, + values=None, + turbine_weights=None, + hours_per_year=8760, + ) -> float: + """ + Estimate annual value production (AVP) for distribution of wind + conditions, frequencies of occurrence, and corresponding values of + power generated (e.g., electricity price per unit of energy). + + Args: + freq (NDArrayFloat): NumPy array with shape (n_findex) + with the frequencies of each wind condition combination. + These frequencies should typically sum up to 1.0 and are used + to weigh the wind farm value for every condition in calculating + the wind farm's AVP. Defaults to None. If None and a + WindData object is supplied, the WindData object's frequencies + will be used. Otherwise, uniform frequencies are assumed (i.e., + a simple mean over the findices is computed). + values (NDArrayFloat): NumPy array with shape (n_findex) + with the values corresponding to the power generated for each + wind condition combination. The wind farm power is multiplied + by the value for every condition in calculating the wind farm's + AVP. Defaults to None. If None and a WindData object is + supplied, the WindData object's values will be used. Otherwise, + a value of 1 for all conditions is assumed (i.e., the AVP will + be equivalent to the AEP). + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the value production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris is + multiplied with this array in the calculation of the AVP. If + None, this is an array with all values 1.0 and with shape equal + to (n_findex, n_turbines). Defaults to None. + hours_per_year (float, optional): Number of hours in a year. + Defaults to 365 * 24. + + Returns: + float: + The Annual Value Production (AVP) for the wind farm in units + of value. + """ + if ( + freq is None + and not isinstance(self.wind_data, WindRose) + and not isinstance(self.wind_data, WindTIRose) + ): + self.logger.warning( + "Computing AVP with uniform frequencies. Results results may not reflect annual " + "operation." + ) + + if values is None and self.wind_data is None: + self.logger.warning( + "Computing AVP with uniform value equal to 1. Results will be equivalent to " + "annual energy production." + ) + + return self.get_expected_farm_value( + freq=freq, + values=values, + turbine_weights=turbine_weights + ) * hours_per_year + + def get_turbine_ais(self) -> NDArrayFloat: + turbine_ais = axial_induction( + velocities=self.core.flow_field.u, + air_density=self.core.flow_field.air_density, + yaw_angles=self.core.farm.yaw_angles, + tilt_angles=self.core.farm.tilt_angles, + power_setpoints=self.core.farm.power_setpoints, + awc_modes = self.core.farm.awc_modes, + awc_amplitudes=self.core.farm.awc_amplitudes, + axial_induction_functions=self.core.farm.turbine_axial_induction_functions, + tilt_interps=self.core.farm.turbine_tilt_interps, + correct_cp_ct_for_tilt=self.core.farm.correct_cp_ct_for_tilt, + turbine_type_map=self.core.farm.turbine_type_map, + turbine_power_thrust_tables=self.core.farm.turbine_power_thrust_tables, + average_method=self.core.grid.average_method, + cubature_weights=self.core.grid.cubature_weights, + multidim_condition=self.core.flow_field.multidim_conditions, + ) + return turbine_ais + + def get_turbine_thrust_coefficients(self) -> NDArrayFloat: + turbine_thrust_coefficients = thrust_coefficient( + velocities=self.core.flow_field.u, + air_density=self.core.flow_field.air_density, + yaw_angles=self.core.farm.yaw_angles, + tilt_angles=self.core.farm.tilt_angles, + power_setpoints=self.core.farm.power_setpoints, + awc_modes = self.core.farm.awc_modes, + awc_amplitudes=self.core.farm.awc_amplitudes, + thrust_coefficient_functions=self.core.farm.turbine_thrust_coefficient_functions, + tilt_interps=self.core.farm.turbine_tilt_interps, + correct_cp_ct_for_tilt=self.core.farm.correct_cp_ct_for_tilt, + turbine_type_map=self.core.farm.turbine_type_map, + turbine_power_thrust_tables=self.core.farm.turbine_power_thrust_tables, + average_method=self.core.grid.average_method, + cubature_weights=self.core.grid.cubature_weights, + multidim_condition=self.core.flow_field.multidim_conditions, + ) + return turbine_thrust_coefficients + + def get_turbine_TIs(self) -> NDArrayFloat: + return self.core.flow_field.turbulence_intensity_field + + + ### Methods for sampling and visualization + + def set_for_viz(self, findex: int, solver_settings: dict) -> None: + """ + Set the floris object to a single findex for visualization. + + Args: + findex (int): The findex to set the floris object to. + solver_settings (dict): The solver settings to use for visualization. + """ + self.set( + wind_speeds=self.wind_speeds[findex:findex+1], + wind_directions=self.wind_directions[findex:findex+1], + turbulence_intensities=self.turbulence_intensities[findex:findex+1], + yaw_angles=self.core.farm.yaw_angles[findex:findex+1,:], + power_setpoints=self.core.farm.power_setpoints[findex:findex+1,:], + awc_modes=self.core.farm.awc_modes[findex:findex+1,:], + awc_amplitudes=self.core.farm.awc_amplitudes[findex:findex+1,:], + solver_settings=solver_settings, + ) + + def calculate_cross_plane( + self, + downstream_dist, + y_resolution=200, + z_resolution=200, + y_bounds=None, + z_bounds=None, + findex_for_viz=None, + ): + """ + Shortcut method to instantiate a :py:class:`~.tools.cut_plane.CutPlane` + object containing the velocity field in a horizontal plane cut through + the simulation domain at a specific height. + + Args: + downstream_dist (float): Distance downstream of turbines to compute. + y_resolution (float, optional): Output array resolution. + Defaults to 200 points. + z_resolution (float, optional): Output array resolution. + Defaults to 200 points. + y_bounds (tuple, optional): Limits of output array (in m). + Defaults to None. + z_bounds (tuple, optional): Limits of output array (in m). + Defaults to None. + finder_for_viz (int, optional): Index of the condition to visualize. + Returns: + :py:class:`~.tools.cut_plane.CutPlane`: containing values + of x, y, u, v, w + """ + if self.n_findex > 1 and findex_for_viz is None: + self.logger.warning( + "Multiple findices detected. Using first findex for visualization." + ) + if findex_for_viz is None: + findex_for_viz = 0 + + # Store the current state for reinitialization + fmodel_viz = copy.deepcopy(self) + + # Set the solver to a flow field planar grid + solver_settings = { + "type": "flow_field_planar_grid", + "normal_vector": "x", + "planar_coordinate": downstream_dist, + "flow_field_grid_points": [y_resolution, z_resolution], + "flow_field_bounds": [y_bounds, z_bounds], + } + fmodel_viz.set_for_viz(findex_for_viz, solver_settings) + + # Calculate wake + fmodel_viz.core.solve_for_viz() + + # Get the points of data in a dataframe + # TODO this just seems to be flattening and storing the data in a df; is this necessary? + # It seems the biggest dependency is on CutPlane and the subsequent visualization tools. + df = fmodel_viz.get_plane_of_points( + normal_vector="x", + planar_coordinate=downstream_dist, + ) + + # Compute the cutplane + cross_plane = CutPlane(df, y_resolution, z_resolution, "x") + + return cross_plane + + def calculate_horizontal_plane( + self, + height, + x_resolution=200, + y_resolution=200, + x_bounds=None, + y_bounds=None, + findex_for_viz=None, + ): + """ + Shortcut method to instantiate a :py:class:`~.tools.cut_plane.CutPlane` + object containing the velocity field in a horizontal plane cut through + the simulation domain at a specific height. + + Args: + height (float): Height of cut plane. Defaults to Hub-height. + x_resolution (float, optional): Output array resolution. + Defaults to 200 points. + y_resolution (float, optional): Output array resolution. + Defaults to 200 points. + x_bounds (tuple, optional): Limits of output array (in m). + Defaults to None. + y_bounds (tuple, optional): Limits of output array (in m). + Defaults to None. + finder_for_viz (int, optional): Index of the condition to visualize. + + Returns: + :py:class:`~.tools.cut_plane.CutPlane`: containing values + of x, y, u, v, w + """ + if self.n_findex > 1 and findex_for_viz is None: + self.logger.warning( + "Multiple findices detected. Using first findex for visualization." + ) + if findex_for_viz is None: + findex_for_viz = 0 + + # Store the current state for reinitialization + fmodel_viz = copy.deepcopy(self) + + # Set the solver to a flow field planar grid + solver_settings = { + "type": "flow_field_planar_grid", + "normal_vector": "z", + "planar_coordinate": height, + "flow_field_grid_points": [x_resolution, y_resolution], + "flow_field_bounds": [x_bounds, y_bounds], + } + fmodel_viz.set_for_viz(findex_for_viz, solver_settings) + + # Calculate wake + fmodel_viz.core.solve_for_viz() + + # Get the points of data in a dataframe + # TODO this just seems to be flattening and storing the data in a df; is this necessary? + # It seems the biggest depenedcy is on CutPlane and the subsequent visualization tools. + df = fmodel_viz.get_plane_of_points( + normal_vector="z", + planar_coordinate=height, + ) + + # Compute the cutplane + horizontal_plane = CutPlane( + df, + fmodel_viz.core.grid.grid_resolution[0], + fmodel_viz.core.grid.grid_resolution[1], + "z", + ) + + return horizontal_plane + + def calculate_y_plane( + self, + crossstream_dist, + x_resolution=200, + z_resolution=200, + x_bounds=None, + z_bounds=None, + findex_for_viz=None, + ): + """ + Shortcut method to instantiate a :py:class:`~.tools.cut_plane.CutPlane` + object containing the velocity field in a horizontal plane cut through + the simulation domain at a specific height. + + Args: + height (float): Height of cut plane. Defaults to Hub-height. + x_resolution (float, optional): Output array resolution. + Defaults to 200 points. + z_resolution (float, optional): Output array resolution. + Defaults to 200 points. + x_bounds (tuple, optional): Limits of output array (in m). + Defaults to None. + z_bounds (tuple, optional): Limits of output array (in m). + Defaults to None. + findex_for_viz (int, optional): Index of the condition to visualize. + Defaults to 0. + + Returns: + :py:class:`~.tools.cut_plane.CutPlane`: containing values + of x, y, u, v, w + """ + if self.n_findex > 1 and findex_for_viz is None: + self.logger.warning( + "Multiple findices detected. Using first findex for visualization." + ) + if findex_for_viz is None: + findex_for_viz = 0 + + # Store the current state for reinitialization + fmodel_viz = copy.deepcopy(self) + + # Set the solver to a flow field planar grid + solver_settings = { + "type": "flow_field_planar_grid", + "normal_vector": "y", + "planar_coordinate": crossstream_dist, + "flow_field_grid_points": [x_resolution, z_resolution], + "flow_field_bounds": [x_bounds, z_bounds], + } + fmodel_viz.set_for_viz(findex_for_viz, solver_settings) + + # Calculate wake + fmodel_viz.core.solve_for_viz() + + # Get the points of data in a dataframe + # TODO this just seems to be flattening and storing the data in a df; is this necessary? + # It seems the biggest depenedcy is on CutPlane and the subsequent visualization tools. + df = fmodel_viz.get_plane_of_points( + normal_vector="y", + planar_coordinate=crossstream_dist, + ) + + # Compute the cutplane + y_plane = CutPlane(df, x_resolution, z_resolution, "y") + + return y_plane + + def get_plane_of_points( + self, + normal_vector="z", + planar_coordinate=None, + ): + """ + Calculates velocity values through the + :py:meth:`FlorisModel.calculate_wake` method at points in plane + specified by inputs. + + Args: + normal_vector (string, optional): Vector normal to plane. + Defaults to z. + planar_coordinate (float, optional): Value of normal vector + to slice through. Defaults to None. + + Returns: + :py:class:`pandas.DataFrame`: containing values of x1, x2, x3, u, v, w + """ + # Get results vectors + if normal_vector == "z": + x_flat = self.core.grid.x_sorted_inertial_frame[0].flatten() + y_flat = self.core.grid.y_sorted_inertial_frame[0].flatten() + z_flat = self.core.grid.z_sorted_inertial_frame[0].flatten() + else: + x_flat = self.core.grid.x_sorted[0].flatten() + y_flat = self.core.grid.y_sorted[0].flatten() + z_flat = self.core.grid.z_sorted[0].flatten() + u_flat = self.core.flow_field.u_sorted[0].flatten() + v_flat = self.core.flow_field.v_sorted[0].flatten() + w_flat = self.core.flow_field.w_sorted[0].flatten() + + # Create a df of these + if normal_vector == "z": + df = pd.DataFrame( + { + "x1": x_flat, + "x2": y_flat, + "x3": z_flat, + "u": u_flat, + "v": v_flat, + "w": w_flat, + } + ) + if normal_vector == "x": + df = pd.DataFrame( + { + "x1": y_flat, + "x2": z_flat, + "x3": x_flat, + "u": u_flat, + "v": v_flat, + "w": w_flat, + } + ) + if normal_vector == "y": + df = pd.DataFrame( + { + "x1": x_flat, + "x2": z_flat, + "x3": y_flat, + "u": u_flat, + "v": v_flat, + "w": w_flat, + } + ) + + # Subset to plane + # TODO: Seems sloppy as need more than one plane in the z-direction for GCH + if planar_coordinate is not None: + df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)] + + # Drop duplicates + # TODO is this still needed now that we setup a grid for just this plane? + df = df.drop_duplicates() + + # Sort values of df to make sure plotting is acceptable + df = df.sort_values(["x2", "x1"]).reset_index(drop=True) + + return df + + def sample_flow_at_points(self, x: NDArrayFloat, y: NDArrayFloat, z: NDArrayFloat): + """ + Extract the wind speed at points in the flow. + + Args: + x (1DArrayFloat | list): x-locations of points where flow is desired. + y (1DArrayFloat | list): y-locations of points where flow is desired. + z (1DArrayFloat | list): z-locations of points where flow is desired. + + Returns: + 3DArrayFloat containing wind speed with dimensions + (# of findex, # of sample points) + """ + + # Check that x, y, z are all the same length + if not len(x) == len(y) == len(z): + raise ValueError("x, y, and z must be the same size") + + return self.core.solve_for_points(x, y, z) + + def sample_velocity_deficit_profiles( + self, + direction: str = "cross-stream", + downstream_dists: NDArrayFloat | list = None, + profile_range: NDArrayFloat | list = None, + resolution: int = 100, + wind_direction: float = None, + homogeneous_wind_speed: float = None, + ref_rotor_diameter: float = None, + x_start: float = 0.0, + y_start: float = 0.0, + reference_height: float = None, + ) -> list[pd.DataFrame]: + """ + Extract velocity deficit profiles at a set of downstream distances from a starting point + (usually a turbine location). For each downstream distance, a profile is sampled along + a line in either the cross-stream direction (x2) or the vertical direction (x3). + Velocity deficit is here defined as (homogeneous_wind_speed - u)/homogeneous_wind_speed, + where u is the wake velocity obtained when wind_shear = 0.0. + + Args: + direction: At each downstream location, this is the direction in which to sample the + profile. Either `cross-stream` or `vertical`. + downstream_dists: A list/array of streamwise locations for where to sample the profiles. + Default starting point is (0.0, 0.0, reference_height). + profile_range: Determines the extent of the line along which the profiles are sampled. + The range is defined about a point which lies some distance directly downstream of + the starting point. + resolution: Number of sample points in each profile. + wind_direction: A single wind direction. + homogeneous_wind_speed: A single wind speed. It is called homogeneous since 'wind_shear' + is temporarily set to 0.0 in this method. + ref_rotor_diameter: A reference rotor diameter which is used to normalize the + coordinates. + x_start: x-coordinate of starting point. + y_start: y-coordinate of starting point. + reference_height: If `direction` is cross-stream, then `reference_height` defines the + height of the horizontal plane in which the velocity profiles are sampled. + If `direction` is vertical, then the velocity is sampled along the vertical + direction with the `profile_range` being relative to the `reference_height`. + Returns: + A list of pandas DataFrame objects where each DataFrame represents one velocity deficit + profile. + """ + + if direction not in ["cross-stream", "vertical"]: + raise ValueError("`direction` must be either `cross-stream` or `vertical`.") + + if ref_rotor_diameter is None: + unique_rotor_diameters = np.unique(self.core.farm.rotor_diameters) + if len(unique_rotor_diameters) == 1: + ref_rotor_diameter = unique_rotor_diameters[0] + else: + raise ValueError( + "Please provide a `ref_rotor_diameter`. This is needed to normalize the " + "coordinates. Could not select a value automatically since the number of " + "unique rotor diameters in the turbine layout is not 1. " + f"Found the following rotor diameters: {unique_rotor_diameters}." + ) + + if downstream_dists is None: + downstream_dists = ref_rotor_diameter * np.array([3, 5, 7, 9]) + + if profile_range is None: + profile_range = ref_rotor_diameter * np.array([-2, 2]) + + wind_directions_copy = np.array(self.core.flow_field.wind_directions, copy=True) + wind_speeds_copy = np.array(self.core.flow_field.wind_speeds, copy=True) + wind_shear_copy = self.core.flow_field.wind_shear + + if wind_direction is None: + if len(wind_directions_copy) == 1: + wind_direction = wind_directions_copy[0] + else: + raise ValueError( + "Could not determine a wind direction for which to sample the velocity " + "profiles. Either provide a single `wind_direction` as an argument to this " + "method, or initialize the Floris object with a single wind direction." + ) + + if homogeneous_wind_speed is None: + if len(wind_speeds_copy) == 1: + homogeneous_wind_speed = wind_speeds_copy[0] + self.logger.warning( + "`homogeneous_wind_speed` not provided. Setting it to the following wind speed " + f"found in the current flow field: {wind_speeds_copy[0]} m/s. Note that the " + "inflow is always homogeneous when calculating the velocity deficit profiles. " + "This is done by temporarily setting `wind_shear` to 0.0" + ) + else: + raise ValueError( + "Could not determine a wind speed for which to sample the velocity " + "profiles. Provide a single `homogeneous_wind_speed` to this method." + ) + + if reference_height is None: + reference_height = self.core.flow_field.reference_wind_height + + self.set( + wind_directions=[wind_direction], + wind_speeds=[homogeneous_wind_speed], + wind_shear=0.0, + ) + + velocity_deficit_profiles = self.core.solve_for_velocity_deficit_profiles( + direction, + downstream_dists, + profile_range, + resolution, + homogeneous_wind_speed, + ref_rotor_diameter, + x_start, + y_start, + reference_height, + ) + + self.set( + wind_directions=wind_directions_copy, + wind_speeds=wind_speeds_copy, + wind_shear=wind_shear_copy, + ) + + return velocity_deficit_profiles + + + ### Utility methods + + def assign_hub_height_to_ref_height(self): + + # Confirm can do this operation + unique_heights = np.unique(self.core.farm.hub_heights) + if len(unique_heights) > 1: + raise ValueError( + "To assign hub heights to reference height, can not have more than one " + "specified height. " + f"Current length is {unique_heights}." + ) + + self.core.flow_field.reference_wind_height = unique_heights[0] + + def get_operation_model(self) -> str: + """Get the operation model of a FlorisModel. + + Returns: + str: The operation_model. + """ + operation_models = [ + self.core.farm.turbine_definitions[tindex]["operation_model"] + for tindex in range(self.core.farm.n_turbines) + ] + if len(set(operation_models)) == 1: + return operation_models[0] + else: + return operation_models + + def set_operation_model(self, operation_model: str | List[str]): + """Set the turbine operation model(s). + + Args: + operation_model (str): The operation model to set. + """ + if isinstance(operation_model, str): + if len(self.core.farm.turbine_type) == 1: + # Set a single one here, then, and return + turbine_type = self.core.farm.turbine_definitions[0] + turbine_type["operation_model"] = operation_model + self.set(turbine_type=[turbine_type]) + return + else: + operation_model = [operation_model]*self.core.farm.n_turbines + + if len(operation_model) != self.core.farm.n_turbines: + raise ValueError( + "The length of the operation_model list must be " + "equal to the number of turbines." + ) + + turbine_type_list = self.core.farm.turbine_definitions + + for tindex in range(self.core.farm.n_turbines): + turbine_type_list[tindex]["turbine_type"] = ( + turbine_type_list[tindex]["turbine_type"]+"_"+operation_model[tindex] + ) + turbine_type_list[tindex]["operation_model"] = operation_model[tindex] + + self.set(turbine_type=turbine_type_list) + + def copy(self): + """Create an independent copy of the current FlorisModel object""" + return FlorisModel(self.core.as_dict()) + + def get_param( + self, + param: List[str], + param_idx: Optional[int] = None + ) -> Any: + """Get a parameter from a FlorisModel object. + + Args: + param (List[str]): A list of keys to traverse the FlorisModel dictionary. + param_idx (Optional[int], optional): The index to get the value at. Defaults to None. + If None, the entire parameter is returned. + + Returns: + Any: The value of the parameter. + """ + fm_dict = self.core.as_dict() + + if param_idx is None: + return nested_get(fm_dict, param) + else: + return nested_get(fm_dict, param)[param_idx] + + def set_param( + self, + param: List[str], + value: Any, + param_idx: Optional[int] = None + ): + """Set a parameter in a FlorisModel object. + + Args: + param (List[str]): A list of keys to traverse the FlorisModel dictionary. + value (Any): The value to set. + param_idx (Optional[int], optional): The index to set the value at. Defaults to None. + """ + fm_dict_mod = self.core.as_dict() + nested_set(fm_dict_mod, param, value, param_idx) + self.__init__(fm_dict_mod) + + def get_turbine_layout(self, z=False): + """ + Get turbine layout + + Args: + z (bool): When *True*, return lists of x, y, and z coords, + otherwise, return x and y only. Defaults to *False*. + + Returns: + np.array: lists of x, y, and (optionally) z coordinates of + each turbine + """ + xcoords, ycoords, zcoords = self.core.farm.coordinates.T + if z: + return xcoords, ycoords, zcoords + else: + return xcoords, ycoords + + def print_dict(self) -> None: + """Print the FlorisModel dictionary. + """ + print_nested_dict(self.core.as_dict()) + + + ### Properties + + @property + def layout_x(self): + """ + Wind turbine coordinate information. + + Returns: + np.array: Wind turbine x-coordinate. + """ + return self.core.farm.layout_x + + @property + def layout_y(self): + """ + Wind turbine coordinate information. + + Returns: + np.array: Wind turbine y-coordinate. + """ + return self.core.farm.layout_y + + @property + def wind_directions(self): + """ + Wind direction information. + + Returns: + np.array: Wind direction. + """ + return self.core.flow_field.wind_directions + + @property + def wind_speeds(self): + """ + Wind speed information. + + Returns: + np.array: Wind speed. + """ + return self.core.flow_field.wind_speeds + + @property + def turbulence_intensities(self): + """ + Turbulence intensity information. + + Returns: + np.array: Turbulence intensity. + """ + return self.core.flow_field.turbulence_intensities + + @property + def n_findex(self): + """ + Number of floris indices (findex). + + Returns: + int: Number of flow indices. + """ + return self.core.flow_field.n_findex + + @property + def n_turbines(self): + """ + Number of turbines. + + Returns: + int: Number of turbines. + """ + return self.core.farm.n_turbines + + @property + def turbine_average_velocities(self) -> NDArrayFloat: + return average_velocity( + velocities=self.core.flow_field.u, + method=self.core.grid.average_method, + cubature_weights=self.core.grid.cubature_weights, + ) + + @property + def wind_data(self): + return self._wind_data + + + ### v3 functions that are removed - raise an error if used + + def calculate_wake(self, **_): + raise NotImplementedError( + "The calculate_wake method has been removed. Please use the run method. " + "See https://nrel.github.io/floris/v3_to_v4.html for more information." + ) + + def reinitialize(self, **_): + raise NotImplementedError( + "The reinitialize method has been removed. Please use the set method. " + "See https://nrel.github.io/floris/v3_to_v4.html for more information." + ) + + + @staticmethod + def merge_floris_models(fmodel_list, reference_wind_height=None): + """Merge a list of FlorisModel objects into a single FlorisModel object. Note that it uses + the very first object specified in fmodel_list to build upon, + so it uses those wake model parameters, air density, and so on. + + Args: + fmodel_list (list): Array-like of FlorisModel objects. + reference_wind_height (float, optional): Height in meters + at which the reference wind speed is assigned. If None, will assume + this value is equal to the reference wind height specified in the FlorisModel + objects. This only works if all objects have the same value + for their reference_wind_height. + + Returns: + fmodel_merged (FlorisModel): The merged FlorisModel object, + merged in the same order as fmodel_list. The objects are merged + on the turbine locations and turbine types, but not on the wake parameters + or general solver settings. + """ + + if not isinstance(fmodel_list[0], FlorisModel): + raise ValueError( + "Incompatible input specified. fmodel_list must be a list of FlorisModel objects." + ) + + # Get the turbine locations and specifications for each subset and save as a list + x_list = [] + y_list = [] + turbine_type_list = [] + reference_wind_heights = [] + for fmodel in fmodel_list: + # Remove any control setpoints that might be specified for the turbines on one fmodel + fmodel.reset_operation() + + x_list.extend(fmodel.layout_x) + y_list.extend(fmodel.layout_y) + + fmodel_turbine_type = fmodel.core.farm.turbine_type + if len(fmodel_turbine_type) == 1: + fmodel_turbine_type = fmodel_turbine_type * len(fmodel.layout_x) + elif not len(fmodel_turbine_type) == len(fmodel.layout_x): + raise ValueError("Incompatible format of turbine_type in fmodel.") + + turbine_type_list.extend(fmodel_turbine_type) + reference_wind_heights.append(fmodel.core.flow_field.reference_wind_height) + + # Derive reference wind height, if unspecified by the user + if reference_wind_height is None: + reference_wind_height = np.mean(reference_wind_heights) + if np.any(np.abs(np.array(reference_wind_heights) - reference_wind_height) > 1.0e-3): + raise ValueError( + "Cannot automatically derive a fitting reference_wind_height since they " + "substantially differ between FlorisModel objects. " + "Please specify 'reference_wind_height' manually." + ) + + # Construct the merged FLORIS model based on the first entry in fmodel_list + fmodel_merged = fmodel_list[0].copy() + fmodel_merged.set( + layout_x=x_list, + layout_y=y_list, + turbine_type=turbine_type_list, + reference_wind_height=reference_wind_height, + ) + + return fmodel_merged diff --git a/floris/tools/visualization.py b/floris/flow_visualization.py similarity index 75% rename from floris/tools/visualization.py rename to floris/flow_visualization.py index fe01a595b..720399d99 100644 --- a/floris/tools/visualization.py +++ b/floris/flow_visualization.py @@ -1,16 +1,4 @@ -# Copyright 2021 NREL -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from __future__ import annotations import copy @@ -27,9 +15,10 @@ from matplotlib import rcParams from scipy.spatial import ConvexHull -from floris.simulation import Floris -from floris.tools.cut_plane import CutPlane -from floris.tools.floris_interface import FlorisInterface +from floris import FlorisModel +from floris.core import Core +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT +from floris.cut_plane import CutPlane from floris.type_dec import ( floris_array_converter, NDArrayFloat, @@ -37,125 +26,14 @@ from floris.utilities import rotate_coordinates_rel_west, wind_delta -def show_plots(): - plt.show() - -def plot_turbines( - ax, - layout_x, - layout_y, - yaw_angles, - rotor_diameters, - color: str | None = None, -): - """ - This function is deprecated and will be removed in v3.5, use `plot_turbines_with_fi` instead. - - Plot wind plant layout from turbine locations. - - Args: - ax (:py:class:`matplotlib.pyplot.axes`): Figure axes. - layout_x (np.array): Wind turbine locations (east-west). - layout_y (np.array): Wind turbine locations (north-south). - yaw_angles (np.array): Yaw angles of each wind turbine. - rotor_diameters (np.array): Wind turbine rotor diameter. - color (str): pyplot color option to plot the turbines. - """ - warnings.warn( - "The `plot_turbines` function is deprecated and will be removed in v3.5, " - "use `plot_turbines_with_fi` instead.", - DeprecationWarning, - stacklevel=2 # This prints the calling function and this function in the warning - ) - - if color is None: - color = "k" - - for x, y, yaw, d in zip(layout_x, layout_y, yaw_angles, rotor_diameters): - R = d / 2.0 - x_0 = x + np.sin(np.deg2rad(yaw)) * R - x_1 = x - np.sin(np.deg2rad(yaw)) * R - y_0 = y - np.cos(np.deg2rad(yaw)) * R - y_1 = y + np.cos(np.deg2rad(yaw)) * R - ax.plot([x_0, x_1], [y_0, y_1], color=color) - - -def plot_turbines_with_fi( - fi: FlorisInterface, - ax: plt.Axes = None, - color: str = None, - wd: np.ndarray = None, - yaw_angles: np.ndarray = None, -): - """ - Plot the wind plant layout from turbine locations gotten from a FlorisInterface object. - Note that this function automatically uses the first wind direction and first wind speed. - Generally, it is most explicit to create a new FlorisInterface with only the single - wind condition that should be plotted. - - Args: - fi (:py:class:`floris.tools.floris_interface.FlorisInterface`): FlorisInterface object. - ax (:py:class:`matplotlib.pyplot.axes`): Figure axes. Defaults to None. - color (str, optional): Color to plot turbines. Defaults to None. - wd (list, optional): The wind direction to plot the turbines relative to. Defaults to None. - yaw_angles (NDArray, optional): The yaw angles for the turbines. Defaults to None. - """ - if not ax: - fig, ax = plt.subplots() - if yaw_angles is None: - yaw_angles = fi.floris.farm.yaw_angles - if wd is None: - wd = fi.floris.flow_field.wind_directions[0] - - # Rotate yaw angles to inertial frame for plotting turbines relative to wind direction - yaw_angles = yaw_angles - wind_delta(np.array(wd)) - - if color is None: - color = "k" - - rotor_diameters = fi.floris.farm.rotor_diameters.flatten() - for x, y, yaw, d in zip(fi.layout_x, fi.layout_y, yaw_angles[0,0], rotor_diameters): - R = d / 2.0 - x_0 = x + np.sin(np.deg2rad(yaw)) * R - x_1 = x - np.sin(np.deg2rad(yaw)) * R - y_0 = y - np.cos(np.deg2rad(yaw)) * R - y_1 = y + np.cos(np.deg2rad(yaw)) * R - ax.plot([x_0, x_1], [y_0, y_1], color=color) - - -def add_turbine_id_labels(fi: FlorisInterface, ax: plt.Axes, **kwargs): +def show(): """ - Adds index labels to a plot based on the given FlorisInterface. - See the pyplot.annotate docs for more info: - https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.annotate.html. - kwargs are passed to Text - (https://matplotlib.org/stable/api/text_api.html#matplotlib.text.Text). - - Args: - fi (FlorisInterface): Simulation object to get the layout and index information. - ax (plt.Axes): Axes object to add the labels. + Display all open figures. This is a wrapper for `plt.show()`. + This function is useful if the user doesn't wish to import `matplotlib.pyplot` """ - - # Rotate layout to inertial frame for plotting turbines relative to wind direction - coordinates_array = np.array([ - [x, y, 0.0] - for x, y in list(zip(fi.layout_x, fi.layout_y)) - ]) - wind_direction = fi.floris.flow_field.wind_directions[0] - layout_x, layout_y, _, _, _ = rotate_coordinates_rel_west( - np.array([wind_direction]), - coordinates_array + plt.show( ) - for i in range(fi.floris.farm.n_turbines): - ax.annotate( - i, - (layout_x[0,0,i], layout_y[0,0,i]), - xytext=(0,10), - textcoords="offset points", - **kwargs - ) - def line_contour_cut_plane( cut_plane, @@ -317,7 +195,7 @@ def visualize_cut_plane( def visualize_heterogeneous_cut_plane( cut_plane, - fi, + fmodel, ax=None, vel_component='u', min_speed=None, @@ -337,7 +215,7 @@ def visualize_heterogeneous_cut_plane( Args: cut_plane (:py:class:`~.tools.cut_plane.CutPlane`): 2D plane through wind plant. - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): FlorisInterface object. + fmodel (:py:class:`~.floris_model.FlorisModel`): FlorisModel object. ax (:py:class:`matplotlib.pyplot.axes`): Figure axes. Defaults to None. vel_component (str, optional): The velocity component that the cut plane is @@ -419,8 +297,8 @@ def visualize_heterogeneous_cut_plane( points = np.array( list( zip( - fi.floris.flow_field.heterogenous_inflow_config['x'], - fi.floris.flow_field.heterogenous_inflow_config['y'], + fmodel.core.flow_field.heterogeneous_inflow_config['x'], + fmodel.core.flow_field.heterogeneous_inflow_config['y'], ) ) ) @@ -508,8 +386,7 @@ def reverse_cut_plane_x_axis_in_plot(ax): def plot_rotor_values( values: np.ndarray, - wd_index: int, - ws_index: int, + findex: int, n_rows: int, n_cols: int, t_range: range | None = None, @@ -524,10 +401,9 @@ def plot_rotor_values( used for inspection of what values are differing, and under what conditions. Parameters: - values (np.ndarray): The 5-dimensional array of values to plot. Should be: - N wind directions x N wind speeds x N turbines X N rotor points X N rotor points. - wd_index (int): The index for the wind direction to plot. - ws_index (int): The index of the wind speed to plot. + values (np.ndarray): The 4-dimensional array of values to plot. Should be: + (N findex, N turbines, N rotor points, N rotor points). + findex (int): The index for the sample point to plot. n_rows (int): The number of rows to include for subplots. With ncols, this should generally add up to the number of turbines in the farm. n_cols (int): The number of columns to include for subplots. With ncols, this should @@ -547,16 +423,16 @@ def plot_rotor_values( figure objects are returned for custom editing. Example: - from floris.tools.visualization import plot_rotor_values - plot_rotor_values(floris.flow_field.u, wd_index=0, ws_index=0, n_rows=1, ncols=4) - plot_rotor_values(floris.flow_field.v, wd_index=0, ws_index=0, n_rows=1, ncols=4) - plot_rotor_values(floris.flow_field.w, wd_index=0, ws_index=0, n_rows=1, ncols=4, show=True) + from floris.visualization import plot_rotor_values + plot_rotor_values(floris.flow_field.u, findex=0, n_rows=1, ncols=4) + plot_rotor_values(floris.flow_field.v, findex=0, n_rows=1, ncols=4) + plot_rotor_values(floris.flow_field.w, findex=0, n_rows=1, ncols=4, show=True) """ cmap = plt.cm.get_cmap(name=cmap) if t_range is None: - t_range = range(values.shape[2]) + t_range = range(values.shape[1]) fig = plt.figure() axes = fig.subplots(n_rows, n_cols) @@ -566,16 +442,16 @@ def plot_rotor_values( if n_rows == 1 and n_cols == 1: axes = np.array([axes]) - titles = np.array([f"T{i}" for i in t_range]) + titles = np.array([f"tindex: {i}" for i in t_range]) for ax, t, i in zip(axes.flatten(), titles, t_range): - vmin = np.min(values[wd_index, ws_index]) - vmax = np.max(values[wd_index, ws_index]) + vmin = np.min(values[findex]) + vmax = np.max(values[findex]) norm = mplcolors.Normalize(vmin, vmax) - ax.imshow(values[wd_index, ws_index, i].T, cmap=cmap, norm=norm, origin="lower") + ax.imshow(values[findex, i].T, cmap=cmap, norm=norm, origin="lower") ax.invert_xaxis() ax.set_xticks([]) @@ -596,14 +472,12 @@ def plot_rotor_values( plt.show() def calculate_horizontal_plane_with_turbines( - fi_in, + fmodel, x_resolution=200, y_resolution=200, x_bounds=None, y_bounds=None, - wd=None, - ws=None, - yaw_angles=None, + findex_for_viz=None, ) -> CutPlane: """ This function creates a :py:class:`~.tools.cut_plane.CutPlane` by @@ -615,63 +489,81 @@ def calculate_horizontal_plane_with_turbines( and the flow field is reset to its initial state for every new location. Then, the local velocities are put into a DataFrame and then into a CutPlane. This method is much slower than - `FlorisInterface.calculate_horizontal_plane`, but it is helpful + `FlorisModel.calculate_horizontal_plane`, but it is helpful for models where the visualization capability is not yet available. Args: - fi_in (:py:class:`floris.tools.floris_interface.FlorisInterface`): - Preinitialized FlorisInterface object. + fmodel (:py:class:`floris.floris_model.FlorisModel`): + Preinitialized FlorisModel object. x_resolution (float, optional): Output array resolution. Defaults to 200 points. y_resolution (float, optional): Output array resolution. Defaults to 200 points. x_bounds (tuple, optional): Limits of output array (in m). Defaults to None. y_bounds (tuple, optional): Limits of output array (in m). Defaults to None. - wd (float, optional): Wind direction setting. Defaults to None. - ws (float, optional): Wind speed setting. Defaults to None. - yaw_angles (np.ndarray, optional): Yaw angles settings. Defaults to None. + findex_for_viz (int, optional): Index of the condition to visualize. Returns: :py:class:`~.tools.cut_plane.CutPlane`: containing values of x, y, u, v, w """ + if fmodel.core.flow_field.n_findex > 1 and findex_for_viz is None: + print( + "Multiple findices detected. Using first findex for visualization." + ) + if findex_for_viz is None: + findex_for_viz = 0 - # Make a local copy of fi to avoid editing passed in fi - fi = copy.deepcopy(fi_in) - - # If wd/ws not provided, use what is set in fi - if wd is None: - wd = fi.floris.flow_field.wind_directions - if ws is None: - ws = fi.floris.flow_field.wind_speeds - fi.check_wind_condition_for_viz(wd=wd, ws=ws) + # Make a local copy of fmodel to avoid editing passed in fmodel + fmodel_viz = copy.deepcopy(fmodel) # Set the ws and wd - fi.reinitialize(wind_directions=wd, wind_speeds=ws) - - # Re-set yaw angles - if yaw_angles is not None: - fi.floris.farm.yaw_angles = yaw_angles + fmodel_viz.set_for_viz(findex_for_viz, None) - # Now place the yaw_angles back into yaw_angles - # to be sure not None - yaw_angles = fi.floris.farm.yaw_angles + yaw_angles = fmodel_viz.core.farm.yaw_angles + power_setpoints = fmodel_viz.core.farm.power_setpoints + awc_modes = fmodel_viz.core.farm.awc_modes + awc_amplitudes = fmodel_viz.core.farm.awc_amplitudes + awc_frequencies = fmodel_viz.core.farm.awc_frequencies # Grab the turbine layout - layout_x = copy.deepcopy(fi.layout_x) - layout_y = copy.deepcopy(fi.layout_y) - turbine_types = copy.deepcopy(fi.floris.farm.turbine_type) - D = fi.floris.farm.rotor_diameters_sorted[0, 0, 0] + layout_x = copy.deepcopy(fmodel_viz.layout_x) + layout_y = copy.deepcopy(fmodel_viz.layout_y) + turbine_types = copy.deepcopy(fmodel_viz.core.farm.turbine_type) + D = fmodel_viz.core.farm.rotor_diameters_sorted[0, 0] # Declare a new layout array with an extra turbine layout_x_test = np.append(layout_x,[0]) layout_y_test = np.append(layout_y,[0]) - # Declare turbine types with an extra turbine in - # case of special one type useage + # Declare turbine types with an extra turbine in case of special one-type usage if len(layout_x) > 1 and len(turbine_types) == 1: # Convert to list length len(layout_x) + 1 turbine_types_test = [turbine_types[0] for i in range(len(layout_x))] + ['nrel_5MW'] else: turbine_types_test = np.append(turbine_types, 'nrel_5MW').tolist() - yaw_angles = np.append(yaw_angles, np.zeros([len(wd), len(ws), 1]), axis=2) + yaw_angles = np.append( + yaw_angles, + np.zeros([fmodel_viz.core.flow_field.n_findex, 1]), + axis=1 + ) + power_setpoints = np.append( + power_setpoints, + POWER_SETPOINT_DEFAULT * np.ones([fmodel_viz.core.flow_field.n_findex, 1]), + axis=1 + ) + awc_modes = np.append( + awc_modes, + np.full((fmodel_viz.core.flow_field.n_findex, 1), "baseline"), + axis=1 + ) + awc_amplitudes = np.append( + awc_amplitudes, + np.zeros([fmodel_viz.core.flow_field.n_findex, 1]), + axis=1 + ) + awc_frequencies = np.append( + awc_frequencies, + np.zeros([fmodel_viz.core.flow_field.n_findex, 1]), + axis=1 + ) # Get a grid of points test test if x_bounds is None: @@ -703,16 +595,21 @@ def calculate_horizontal_plane_with_turbines( # Place the test turbine at this location and calculate wake layout_x_test[-1] = x layout_y_test[-1] = y - fi.reinitialize( + fmodel_viz.set( layout_x=layout_x_test, layout_y=layout_y_test, + yaw_angles=yaw_angles, + power_setpoints=power_setpoints, + awc_modes=awc_modes, + awc_amplitudes=awc_amplitudes, + awc_frequencies=awc_frequencies, turbine_type=turbine_types_test ) - fi.calculate_wake(yaw_angles=yaw_angles) + fmodel_viz.run() # Get the velocity of that test turbines central point - center_point = int(np.floor(fi.floris.flow_field.u[0,0,-1].shape[0] / 2.0)) - u_results[idx] = fi.floris.flow_field.u[0,0,-1,center_point,center_point] + center_point = int(np.floor(fmodel_viz.core.flow_field.u[0,-1].shape[0] / 2.0)) + u_results[idx] = fmodel_viz.core.flow_field.u[0,-1,center_point,center_point] # Increment index idx = idx + 1 diff --git a/floris/layout_visualization.py b/floris/layout_visualization.py new file mode 100644 index 000000000..876c6474e --- /dev/null +++ b/floris/layout_visualization.py @@ -0,0 +1,591 @@ + +import math +from typing import ( + Any, + Dict, + List, + Tuple, +) + +import matplotlib.lines +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from scipy.spatial.distance import pdist, squareform + +from floris import FlorisModel +from floris.utilities import rotate_coordinates_rel_west, wind_delta + + +def plot_turbine_points( + fmodel: FlorisModel, + ax: plt.Axes = None, + turbine_indices: List[int] = None, + plotting_dict: Dict[str, Any] = {}, +) -> plt.Axes: + """ + Plots turbine layout from a FlorisModel object. + + Args: + fmodel (FlorisModel): The FlorisModel object containing layout data. + ax (plt.Axes, optional): An existing axes object to plot on. If None, + a new figure and axes will be created. Defaults to None. + turbine_indices (List[int], optional): A list of turbine indices to plot. + If None, all turbines will be plotted. Defaults to None. + plotting_dict (Dict[str, Any], optional): A dictionary to customize plot + appearance. Valid keys include: + * 'color' (str): Turbine marker color. Defaults to 'black'. + * 'marker' (str): Turbine marker style. Defaults to '.'. + * 'markersize' (int): Turbine marker size. Defaults to 10. + * 'label' (str): Label for the legend. Defaults to None. + + Returns: + plt.Axes: The axes object used for the plot. + + Raises: + IndexError: If any value in `turbine_indices` is an invalid turbine index. + """ + + # Generate axis, if needed + if ax is None: + _, ax = plt.subplots() + + # If turbine_indices is not none, make sure all elements correspond to real indices + if turbine_indices is not None: + try: + fmodel.layout_x[turbine_indices] + except IndexError: + raise IndexError("turbine_indices does not correspond to turbine indices in fi") + else: + turbine_indices = list(range(len(fmodel.layout_x))) + + # Generate plotting dictionary + default_plotting_dict = { + "color": "black", + "marker": ".", + "markersize": 10, + "label": None, + } + plotting_dict = {**default_plotting_dict, **plotting_dict} + + # Plot + ax.plot( + fmodel.layout_x[turbine_indices], + fmodel.layout_y[turbine_indices], + linestyle="None", + **plotting_dict, + ) + + # Make sure axis set to equal + ax.axis("equal") + + return ax + + +def plot_turbine_labels( + fmodel: FlorisModel, + ax: plt.Axes = None, + turbine_names: List[str] = None, + turbine_indices: List[int] = None, + label_offset: float = None, + show_bbox: bool = False, + bbox_dict: Dict[str, Any] = {}, + plotting_dict: Dict[str, Any] = {}, +) -> plt.Axes: + """ + Adds turbine labels to a turbine layout plot. + + Args: + fmodel (FlorisModel): The FlorisModel object containing layout data. + ax (plt.Axes, optional): An existing axes object to plot on. If None, + a new figure and axes will be created. Defaults to None. + turbine_names (List[str], optional): Custom turbine labels. If None, + defaults to turbine indices (e.g., '000', '001'). Defaults to None. + turbine_indices (List[int], optional): Indices of turbines to label. + If None, all turbines will be labeled. Defaults to None. + label_offset (float, optional): Distance to offset labels from turbine + points (in meters). If None, defaults to rotor_diameter/8. + Defaults to None. + show_bbox (bool, optional): If True, adds a bounding box around each label. + Defaults to False. + bbox_dict (Dict[str, Any], optional): Dictionary to customize the appearance + of bounding boxes (if show_bbox is True). Valid keys include: + * 'facecolor' (str): Box background color. Defaults to 'gray'. + * 'alpha' (float): Opacity of box. Defaults to 0.5. + * 'pad' (float): Padding around text. Defaults to 0.1. + * 'boxstyle' (str): Box style (e.g., 'round'). Defaults to 'round'. + plotting_dict (Dict[str, Any], optional): Dictionary to control text + appearance. Valid keys include: + * 'color' (str): Text color. Defaults to 'black'. + + Returns: + plt.Axes: The axes object used for the plot. + + Raises: + IndexError: If any value in `turbine_indices` is an invalid turbine index. + ValueError: If the length of `turbine_names` does not match the number of turbines. + """ + + # Generate axis, if needed + if ax is None: + _, ax = plt.subplots() + + # If turbine names not none, confirm has correct number of turbines + if turbine_names is not None: + if len(turbine_names) != len(fmodel.layout_x): + raise ValueError( + "Length of turbine_names not equal to number turbines in fmodel object" + ) + else: + # Assign simple default numbering + turbine_names = [f"{i:03d}" for i in range(len(fmodel.layout_x))] + + # If label_offset is None, use default value of r/8 + if label_offset is None: + rotor_diameters = fmodel.core.farm.rotor_diameters.flatten() + r = rotor_diameters[0] / 2.0 + label_offset = r / 8.0 + + # If turbine_indices is not none, make sure all elements correspond to real indices + if turbine_indices is not None: + try: + fmodel.layout_x[turbine_indices] + except IndexError: + raise IndexError("turbine_indices does not correspond to turbine indices in fi") + else: + turbine_indices = list(range(len(fmodel.layout_x))) + + # Generate plotting dictionary + default_plotting_dict = { + "color": "black", + "label": None, + } + plotting_dict = {**default_plotting_dict, **plotting_dict} + + # If showing bbox is true, if bbox_dict is None, use a default + default_bbox_dict = {"facecolor": "gray", "alpha": 0.5, "pad": 0.1, "boxstyle": "round"} + bbox_dict = {**default_bbox_dict, **bbox_dict} + + for ti in turbine_indices: + if not show_bbox: + ax.text( + fmodel.layout_x[ti] + label_offset, + fmodel.layout_y[ti] + label_offset, + turbine_names[ti], + **plotting_dict, + ) + else: + ax.text( + fmodel.layout_x[ti] + label_offset, + fmodel.layout_y[ti] + label_offset, + turbine_names[ti], + bbox=bbox_dict, + **plotting_dict, + ) + + # Plot labels and aesthetics + ax.axis("equal") + + return ax + + +def plot_turbine_rotors( + fmodel: FlorisModel, + ax: plt.Axes = None, + color: str = "k", + wd: float = None, + yaw_angles: np.ndarray = None, +) -> plt.Axes: + """ + Plots wind turbine rotors on an existing axes, visually representing their yaw angles. + + Args: + fmodel (FlorisModel): The FlorisModel object containing layout and turbine data. + ax (plt.Axes, optional): An existing axes object to plot on. If None, + a new figure and axes will be created. Defaults to None. + color (str, optional): Color of the turbine rotor lines. Defaults to 'k' (black). + wd (float, optional): Wind direction (in degrees) relative to global reference. + If None, the first wind direction in `fmodel.core.flow_field.wind_directions` is used. + Defaults to None. + yaw_angles (np.ndarray, optional): Array of turbine yaw angles (in degrees). If None, + the values from `fmodel.core.farm.yaw_angles` are used. Defaults to None. + + Returns: + plt.Axes: The axes object used for the plot. + """ + if not ax: + _, ax = plt.subplots() + if yaw_angles is None: + yaw_angles = fmodel.core.farm.yaw_angles + if wd is None: + wd = fmodel.core.flow_field.wind_directions[0] + + # Rotate yaw angles to inertial frame for plotting turbines relative to wind direction + yaw_angles = yaw_angles - wind_delta(np.array(wd)) + + if color is None: + color = "k" + + # If yaw angles is not 1D, assume we want first findex + yaw_angles = np.array(yaw_angles) + if yaw_angles.ndim == 2: + yaw_angles = yaw_angles[0, :] + + rotor_diameters = fmodel.core.farm.rotor_diameters.flatten() + for x, y, yaw, d in zip(fmodel.layout_x, fmodel.layout_y, yaw_angles, rotor_diameters): + R = d / 2.0 + x_0 = x + np.sin(np.deg2rad(yaw)) * R + x_1 = x - np.sin(np.deg2rad(yaw)) * R + y_0 = y - np.cos(np.deg2rad(yaw)) * R + y_1 = y + np.cos(np.deg2rad(yaw)) * R + ax.plot([x_0, x_1], [y_0, y_1], color=color) + + return ax + + +def get_wake_direction(x_i: float, y_i: float, x_j: float, y_j: float) -> float: + """ + Calculates the wind direction at which the wake of turbine i would impact turbine j. + + Args: + x_i (float): X-coordinate of turbine i (the upstream turbine). + y_i (float): Y-coordinate of turbine i. + x_j (float): X-coordinate of turbine j (the downstream turbine). + y_j (float): Y-coordinate of turbine j. + + Returns: + float: Wind direction in degrees (0-360) where 0 degrees represents wind + blowing from the north, and the angle increases clockwise. + """ + + dx = x_j - x_i + dy = y_j - y_i + + angle_rad = np.arctan2(dy, dx) + + + # Adjust for "from" direction (add 180 degrees) and wrap within 0-360 + angle_deg = 270 - np.rad2deg(angle_rad) + wind_direction = angle_deg % 360 + + return wind_direction + + +def label_line( + line: matplotlib.lines.Line2D, + label_text: str, + ax: plt.Axes, + near_i: int = None, + near_x: float = None, + near_y: float = None, + rotation_offset: float = 0.0, + offset: Tuple[float, float] = (0, 0), + size: int = 7, +) -> None: + """ + Adds a text label to a matplotlib line, with options to specify label placement. + + Args: + line (matplotlib.lines.Line2D): The line object to label. + label_text (str): The text of the label. + ax (plt.Axes): The axes object where the line is plotted. + near_i (int, optional): Index near which to place the label. Defaults to None. + near_x (float, optional): X-coordinate near which to place the label. Defaults to None. + near_y (float, optional): Y-coordinate near which to place the label. Defaults to None. + rotation_offset (float, optional): Additional rotation for the label (in degrees). + Defaults to 0.0. + offset (Tuple[float, float], optional): X and Y offset from the label position. + Defaults to (0, 0). + size (int, optional): Font size of the label. Defaults to 7. + + Raises: + ValueError: If none of `near_i`, `near_x`, or `near_y` + are provided to determine label placement. + """ + + def put_label(i: int) -> None: + """ + Adds a label to a line segment within a plot (used internally by the 'label_line' function). + + Args: + i (int): The index of the line segment where the label should be placed. + The label will be positioned between points i and i+1. + """ + i = min(i, len(x) - 2) + dx = sx[i + 1] - sx[i] + dy = sy[i + 1] - sy[i] + rotation = np.rad2deg(np.arctan2(dy, dx)) + rotation_offset + pos = [(x[i] + x[i + 1]) / 2.0 + offset[0], (y[i] + y[i + 1]) / 2 + offset[1]] + ax.text( + pos[0], + pos[1], + label_text, + size=size, + rotation=rotation, + color=line.get_color(), + ha="center", + va="center", + bbox={"ec": "1", "fc": "1", "alpha": 0.8}, + ) + + # extract line data + x = line.get_xdata() + y = line.get_ydata() + + # define screen spacing + if ax.get_xscale() == "log": + sx = np.log10(x) + else: + sx = x + if ax.get_yscale() == "log": + sy = np.log10(y) + else: + sy = y + + # find index + if near_i is not None: + i = near_i + if i < 0: # sanitize negative i + i = len(x) + i + put_label(i) + elif near_x is not None: + for i in range(len(x) - 2): + if (x[i] < near_x and x[i + 1] >= near_x) or (x[i + 1] < near_x and x[i] >= near_x): + put_label(i) + elif near_y is not None: + for i in range(len(y) - 2): + if (y[i] < near_y and y[i + 1] >= near_y) or (y[i + 1] < near_y and y[i] >= near_y): + put_label(i) + else: + raise ValueError("Need one of near_i, near_x, near_y") + + +def plot_waking_directions( + fmodel: FlorisModel, + ax: plt.Axes = None, + turbine_indices: List[int] = None, + wake_plotting_dict: Dict[str, Any] = {}, + D: float = None, + limit_dist_D: float = None, + limit_dist_m: float = None, + limit_num: int = None, + wake_label_size: int = 7, +) -> plt.Axes: + """ + Plots lines representing potential waking directions between wind turbines in a layout. + + Args: + fmodel (FlorisModel): Instantiated FlorisModel object containing layout data. + ax (plt.Axes, optional): An existing axes object to plot on. If None, a new + figure and axes will be created. Defaults to None. + turbine_indices (List[int], optional): Indices of turbines to include in the plot. + If None, all turbines are plotted. Defaults to None. + wake_plotting_dict (Dict[str, Any], optional): Dictionary to customize the appearance + of waking direction lines. Valid keys include: + * 'color' (str): Line color. Defaults to 'black'. + * 'linestyle' (str): Line style (e.g., 'solid', 'dashed'). Defaults to 'solid'. + * 'linewidth' (float): Line width. Defaults to 0.5. + D (float, optional): Rotor diameter. Used for distance calculations if `limit_dist_D` + is provided. If None, defaults to the first turbine's rotor diameter. + limit_dist_D (float, optional): Maximum distance between turbines (in rotor diameters) + to plot waking lines. Defaults to None (no limit). + limit_dist_m (float, optional): Maximum distance (in meters) between turbines to plot + waking lines. Overrides `limit_dist_D` if provided. Defaults to None (no limit). + limit_num (int, optional): Limits the number of waking lines plotted from each turbine + to the `limit_num` closest neighbors. Defaults to None (no limit). + wake_label_size (int, optional): Font size for labels showing wake distance and direction. + Defaults to 7. + + Returns: + plt.Axes: The axes object used for the plot. + + Raises: + IndexError: If any value in `turbine_indices` is an invalid turbine index. + + """ + + if not ax: + _, ax = plt.subplots() + + # If turbine_indices is not none, make sure all elements correspond to real indices + if turbine_indices is not None: + try: + fmodel.layout_x[turbine_indices] + except IndexError: + raise IndexError("turbine_indices does not correspond to turbine indices in fi") + else: + turbine_indices = list(range(len(fmodel.layout_x))) + + layout_x = fmodel.layout_x[turbine_indices] + layout_y = fmodel.layout_y[turbine_indices] + N_turbs = len(layout_x) + + # Combine default plotting options + def_wake_plotting_dict = { + "color": "black", + "linestyle": "solid", + "linewidth": 0.5, + } + wake_plotting_dict = {**def_wake_plotting_dict, **wake_plotting_dict} + + # N_turbs = len(fmodel.core.farm.turbine_definitions) + + if D is None: + D = fmodel.core.farm.turbine_definitions[0]["rotor_diameter"] + # TODO: build out capability to use multiple diameters, if of interest. + # D = np.array([turb['rotor_diameter'] for turb in + # fmodel.core.farm.turbine_definitions]) + # else: + # D = D*np.ones(N_turbs) + + dists_m = np.zeros((N_turbs, N_turbs)) + angles_d = np.zeros((N_turbs, N_turbs)) + + for i in range(N_turbs): + for j in range(N_turbs): + dists_m[i, j] = np.linalg.norm([layout_x[i] - layout_x[j], layout_y[i] - layout_y[j]]) + angles_d[i, j] = get_wake_direction(layout_x[i], layout_y[i], layout_x[j], layout_y[j]) + + # Mask based on the limit distance (assumed to be in measurement D) + if limit_dist_D is not None and limit_dist_m is None: + limit_dist_m = limit_dist_D * D + if limit_dist_m is not None: + mask = dists_m > limit_dist_m + dists_m[mask] = np.nan + angles_d[mask] = np.nan + + # Handle default limit number case + if limit_num is None: + limit_num = -1 + + # Loop over pairs, plot + label_exists = np.full((N_turbs, N_turbs), False) + for i in range(N_turbs): + for j in range(N_turbs): + # import ipdb; ipdb.set_trace() + if ( + ~np.isnan(dists_m[i, j]) + and dists_m[i, j] != 0.0 + and ~(dists_m[i, j] > np.sort(dists_m[i, :])[limit_num]) + # and i in layout_plotting_dict["turbine_indices"] + # and j in layout_plotting_dict["turbine_indices"] + ): + (h,) = ax.plot( + layout_x[[i, j]], + layout_y[[i, j]], + **wake_plotting_dict + ) + + # Only label in one direction + if ~label_exists[i, j]: + linetext = "{0:.1f} D --- {1:.0f}/{2:.0f}".format( + dists_m[i, j] / D, + angles_d[i, j], + angles_d[j, i], + ) + + label_line( + h, + linetext, + ax, + near_i=1, + near_x=None, + near_y=None, + rotation_offset=0, + size=wake_label_size, + ) + + label_exists[i, j] = True + label_exists[j, i] = True + + return ax + + +def plot_farm_terrain(fmodel: FlorisModel, ax: plt.Axes = None) -> None: + """ + Creates a filled contour plot visualizing terrain-corrected wind turbine hub heights. + + Args: + fmodel (FlorisModel): The FlorisModel object containing layout data. + ax (plt.Axes, optional): An existing axes object to plot on. If None, a new + figure and axes will be created. Defaults to None. + """ + if not ax: + _, ax = plt.subplots() + + hub_heights = fmodel.core.farm.hub_heights.flatten() + cntr = ax.tricontourf(fmodel.layout_x, fmodel.layout_y, hub_heights, levels=14, cmap="RdBu_r") + + ax.get_figure().colorbar( + cntr, + ax=ax, + label="Terrain-corrected hub height (m)", + ticks=np.linspace( + np.min(hub_heights) - 10.0, + np.max(hub_heights) + 10.0, + 15, + ), + ) + + return ax + + +def shade_region( + points: np.ndarray, + show_points: bool = False, + plotting_dict_region: Dict[str, Any] = {}, + plotting_dict_points: Dict[str, Any] = {}, + ax: plt.Axes = None, +) -> plt.Axes: + """ + Shades a region defined by a set of vertices and optionally plots the vertices. + + Args: + points (np.ndarray): A 2D array where each row represents (x, y) coordinates of a vertex. + show_points (bool, optional): If True, plots markers at the specified vertices. + Defaults to False. + plotting_dict_region (Dict[str, Any], optional): Customization options for shaded region. + Valid keys include: + * 'color' (str): Fill color. Defaults to 'black'. + * 'edgecolor' (str): Edge color. Defaults to None (no edge). + * 'alpha' (float): Opacity (transparency) of the fill. Defaults to 0.3. + * 'label' (str): Optional label for legend. + plotting_dict_points (Dict[str, Any], optional): Customization options for vertex markers. + Valid keys include: + * 'color' (str): Marker color. Defaults to 'black'. + * 'marker' (str): Marker style (e.g., '.', 'o', 'x'). Defaults to None (no marker). + * 's' (float): Marker size. Defaults to 10. + * 'label' (str): Optional label for legend. + ax (plt.Axes, optional): An existing axes object for plotting. If None, creates a new figure + and axes. Defaults to None. + + Returns: + plt.Axes: The axes object used for the plot. + """ + + # Generate axis, if needed + if ax is None: + fig = plt.figure(figsize=(8, 8)) + ax = fig.add_subplot(111) + + # Generate plotting dictionary + default_plotting_dict_region = { + "color": "black", + "edgecolor": None, + "alpha": 0.3, + "label": None, + } + plotting_dict_region = {**default_plotting_dict_region, **plotting_dict_region} + + ax.fill(points[:, 0], points[:, 1], **plotting_dict_region) + + if show_points: + default_plotting_dict_points = {"color": "black", "marker": ".", "s": 10, "label": None} + plotting_dict_points = {**default_plotting_dict_points, **plotting_dict_points} + + ax.scatter(points[:, 0], points[:, 1], **plotting_dict_points) + + # Plot labels and aesthetics + ax.axis("equal") + + return ax diff --git a/floris/logging_manager.py b/floris/logging_manager.py index abdeff0e9..3636f2df7 100644 --- a/floris/logging_manager.py +++ b/floris/logging_manager.py @@ -1,16 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import logging from datetime import datetime diff --git a/floris/tools/optimization/__init__.py b/floris/optimization/__init__.py similarity index 86% rename from floris/tools/optimization/__init__.py rename to floris/optimization/__init__.py index 8aaab3393..28021fd92 100644 --- a/floris/tools/optimization/__init__.py +++ b/floris/optimization/__init__.py @@ -1,6 +1,5 @@ from . import ( layout_optimization, - legacy, other, yaw_optimization, ) diff --git a/floris/tools/optimization/layout_optimization/__init__.py b/floris/optimization/layout_optimization/__init__.py similarity index 100% rename from floris/tools/optimization/layout_optimization/__init__.py rename to floris/optimization/layout_optimization/__init__.py diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_base.py b/floris/optimization/layout_optimization/layout_optimization_base.py similarity index 52% rename from floris/tools/optimization/layout_optimization/layout_optimization_base.py rename to floris/optimization/layout_optimization/layout_optimization_base.py index fc67ac021..dd9afaae3 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_base.py +++ b/floris/optimization/layout_optimization/layout_optimization_base.py @@ -1,33 +1,49 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import matplotlib.pyplot as plt import numpy as np from shapely.geometry import LineString, Polygon -from floris.tools.optimization.yaw_optimization.yaw_optimizer_geometric import ( +from floris import TimeSeries +from floris.optimization.yaw_optimization.yaw_optimizer_geometric import ( YawOptimizationGeometric, ) +from floris.wind_data import WindDataBase -from ....logging_manager import LoggingManager +from ...logging_manager import LoggingManager class LayoutOptimization(LoggingManager): - def __init__(self, fi, boundaries, min_dist=None, freq=None, enable_geometric_yaw=False): - self.fi = fi.copy() + """ + Base class for layout optimization. This class should not be used directly + but should be subclassed by a specific optimization method. + + Args: + fmodel (FlorisModel): A FlorisModel object. + boundaries (iterable(float, float)): Pairs of x- and y-coordinates + that represent the boundary's vertices (m). + min_dist (float, optional): The minimum distance to be maintained + between turbines during the optimization (m). If not specified, + initializes to 2 rotor diameters. Defaults to None. + enable_geometric_yaw (bool, optional): If True, enables geometric yaw + optimization. Defaults to False. + use_value (bool, optional): If True, the layout optimization objective + is to maximize annual value production using the value array in the + FLORIS model's WindData object. If False, the optimization + objective is to maximize AEP. Defaults to False. + """ + def __init__( + self, + fmodel, + boundaries, + min_dist=None, + enable_geometric_yaw=False, + use_value=False, + ): + self.fmodel = fmodel.copy() # Does not copy over the wind_data object + self.fmodel.set(wind_data=fmodel.wind_data) self.boundaries = boundaries self.enable_geometric_yaw = enable_geometric_yaw + self.use_value = use_value self._boundary_polygon = Polygon(self.boundaries) self._boundary_line = LineString(self.boundaries) @@ -37,32 +53,40 @@ def __init__(self, fi, boundaries, min_dist=None, freq=None, enable_geometric_ya self.ymin = np.min([tup[1] for tup in boundaries]) self.ymax = np.max([tup[1] for tup in boundaries]) - # If no minimum distance is provided, assume a value of 2 rotor diamters + # If no minimum distance is provided, assume a value of 2 rotor diameters if min_dist is None: self.min_dist = 2 * self.rotor_diameter else: self.min_dist = min_dist - # If freq is not provided, give equal weight to all wind conditions - if freq is None: - self.freq = np.ones(( - self.fi.floris.flow_field.n_wind_directions, - self.fi.floris.flow_field.n_wind_speeds - )) - self.freq = self.freq / self.freq.sum() - else: - self.freq = freq + # Check that wind_data is a WindDataBase object + if (not isinstance(self.fmodel.wind_data, WindDataBase)): + # NOTE: it is no longer strictly necessary that fmodel use + # a WindData object, but it is still recommended. + self.logger.warning( + "Running layout optimization without a WindData object (e.g. TimeSeries, WindRose, " + "WindTIRose). We suggest that the user set the wind conditions (and if applicable, " + "frequencies and values) on the FlorisModel using the wind_data keyword argument " + "for layout optimizations to capture frequencies and the value of the energy " + "production accurately. If a WindData object is not defined, uniform frequencies " + "will be assumed. If use_value is True and a WindData object is not defined, a " + "value of 1 will be used for each wind condition and layout optimization will " + "simply be performed to maximize AEP." + ) # Establish geometric yaw class if self.enable_geometric_yaw: self.yaw_opt = YawOptimizationGeometric( - fi, + fmodel, minimum_yaw_angle=-30.0, maximum_yaw_angle=30.0, - exploit_layout_symmetry=False ) + fmodel.run() - self.initial_AEP = fi.get_farm_AEP(self.freq) + if self.use_value: + self.initial_AEP_or_AVP = fmodel.get_farm_AVP() + else: + self.initial_AEP_or_AVP = fmodel.get_farm_AEP() def __str__(self): return "layout" @@ -77,9 +101,9 @@ def _get_geoyaw_angles(self): # NOTE: requires that child class saves x and y locations # as self.x and self.y and updates them during optimization. if self.enable_geometric_yaw: - self.yaw_opt.fi_subset.reinitialize(layout_x=self.x, layout_y=self.y) + self.yaw_opt.fmodel_subset.set(layout_x=self.x, layout_y=self.y) df_opt = self.yaw_opt.optimize() - self.yaw_angles = np.vstack(df_opt['yaw_angles_opt'])[:, None, :] + self.yaw_angles = np.vstack(df_opt['yaw_angles_opt'])[:, :] else: self.yaw_angles = None @@ -135,9 +159,9 @@ def nturbs(self): Returns: nturbs (int): The number of turbines in the FLORIS object. """ - self._nturbs = self.fi.floris.farm.n_turbines + self._nturbs = self.fmodel.core.farm.n_turbines return self._nturbs @property def rotor_diameter(self): - return self.fi.floris.farm.rotor_diameters_sorted[0][0][0] + return self.fmodel.core.farm.rotor_diameters_sorted[0][0] diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_boundary_grid.py b/floris/optimization/layout_optimization/layout_optimization_boundary_grid.py similarity index 96% rename from floris/tools/optimization/layout_optimization/layout_optimization_boundary_grid.py rename to floris/optimization/layout_optimization/layout_optimization_boundary_grid.py index 714387ffc..c43310017 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_boundary_grid.py +++ b/floris/optimization/layout_optimization/layout_optimization_boundary_grid.py @@ -1,17 +1,3 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import matplotlib.pyplot as plt import numpy as np @@ -28,7 +14,7 @@ class LayoutOptimizationBoundaryGrid(LayoutOptimization): def __init__( self, - fi, + fmodel, boundaries, start, x_spacing, @@ -41,7 +27,7 @@ def __init__( n_boundary_turbines=None, boundary_spacing=None, ): - self.fi = fi + self.fmodel = fmodel self.boundary_x = np.array([val[0] for val in boundaries]) self.boundary_y = np.array([val[1] for val in boundaries]) @@ -626,13 +612,13 @@ def reinitialize_xy(self): self.boundary_spacing, ) - self.fi.reinitialize(layout=(layout_x, layout_y)) + self.fmodel.set(layout=(layout_x, layout_y)) def plot_layout(self): plt.figure(figsize=(9, 6)) fontsize = 16 - plt.plot(self.fi.layout_x, self.fi.layout_y, "ob") + plt.plot(self.fmodel.layout_x, self.fmodel.layout_y, "ob") # plt.plot(locsx, locsy, "or") plt.xlabel("x (m)", fontsize=fontsize) diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse.py b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py similarity index 67% rename from floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse.py rename to floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py index 5539b84a0..3a87dff70 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse.py +++ b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse.py @@ -1,17 +1,3 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import matplotlib.pyplot as plt import numpy as np @@ -22,24 +8,63 @@ class LayoutOptimizationPyOptSparse(LayoutOptimization): + """ + This class provides an interface for optimizing the layout of wind turbines + using the pyOptSparse optimization library. The optimization objective is to + maximize annual energy production (AEP) or annual value production (AVP). + + Args: + fmodel (FlorisModel): A FlorisModel object. + boundaries (iterable(float, float)): Pairs of x- and y-coordinates + that represent the boundary's vertices (m). + min_dist (float, optional): The minimum distance to be maintained + between turbines during the optimization (m). If not specified, + initializes to 2 rotor diameters. Defaults to None. + solver (str, optional): Sets the solver used by pyOptSparse. Defaults + to 'SLSQP'. + optOptions (dict, optional): Dictionary for setting the + optimization options. Defaults to None. + timeLimit (float, optional): Variable passed to pyOptSparse optimizer. + The maximum amount of time for optimizer to run (seconds). If None, + no time limit is imposed. Defaults to None. + storeHistory (str, optional): Variable passed to pyOptSparse optimizer. + File name of the history file into which the history of the + pyOptSparse optimization will be stored. Defaults to "hist.hist". + hotStart (str, optional): Variable passed to pyOptSparse optimizer. + File name of the history file to “replay” for the optimization. + If None, pyOptSparse initializes the optimization from scratch. + Defaults to None. + enable_geometric_yaw (bool, optional): If True, enables geometric yaw + optimization. Defaults to False. + use_value (bool, optional): If True, the layout optimization objective + is to maximize annual value production using the value array in the + FLORIS model's WindData object. If False, the optimization + objective is to maximize AEP. Defaults to False. + """ def __init__( self, - fi, + fmodel, boundaries, min_dist=None, - freq=None, solver=None, optOptions=None, timeLimit=None, storeHistory='hist.hist', hotStart=None, enable_geometric_yaw=False, + use_value=False, ): - super().__init__(fi, boundaries, min_dist=min_dist, freq=freq, - enable_geometric_yaw=enable_geometric_yaw) - self.x0 = self._norm(self.fi.layout_x, self.xmin, self.xmax) - self.y0 = self._norm(self.fi.layout_y, self.ymin, self.ymax) + super().__init__( + fmodel, + boundaries, + min_dist=min_dist, + enable_geometric_yaw=enable_geometric_yaw, + use_value=use_value + ) + + self.x0 = self._norm(self.fmodel.layout_x, self.xmin, self.xmax) + self.y0 = self._norm(self.fmodel.layout_y, self.ymin, self.ymax) self.storeHistory = storeHistory self.timeLimit = timeLimit @@ -57,7 +82,7 @@ def __init__( self.logger.error(err_msg, stack_info=True) raise ImportError(err_msg) - # Insantiate ptOptSparse optimization object with name and objective function + # Instantiate pyOptSparse optimization object with name and objective function self.optProb = pyoptsparse.Optimization('layout', self._obj_func) self.optProb = self.add_var_group(self.optProb) @@ -105,17 +130,18 @@ def _obj_func(self, varDict): # Parse the variable dictionary self.parse_opt_vars(varDict) - # Update turbine map with turbince locations - self.fi.reinitialize(layout_x = self.x, layout_y = self.y) - # Compute turbine yaw angles using PJ's geometric code (if enabled) yaw_angles = self._get_geoyaw_angles() + # Update turbine map with turbine locations and yaw angles + self.fmodel.set(layout_x=self.x, layout_y=self.y, yaw_angles=yaw_angles) + self.fmodel.run() # Compute the objective function funcs = {} - funcs["obj"] = ( - -1 * self.fi.get_farm_AEP(self.freq, yaw_angles=yaw_angles) / self.initial_AEP - ) + if self.use_value: + funcs["obj"] = -1 * self.fmodel.get_farm_AVP() / self.initial_AEP_or_AVP + else: + funcs["obj"] = -1 * self.fmodel.get_farm_AEP() / self.initial_AEP_or_AVP # Compute constraints, if any are defined for the optimization funcs = self.compute_cons(funcs, self.x, self.y) diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py similarity index 88% rename from floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py rename to floris/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py index d4ff29c35..ac568d4de 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py +++ b/floris/optimization/layout_optimization/layout_optimization_pyoptsparse_spread.py @@ -1,17 +1,3 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import matplotlib.pyplot as plt import numpy as np @@ -24,17 +10,16 @@ class LayoutOptimizationPyOptSparse(LayoutOptimization): def __init__( self, - fi, + fmodel, boundaries, min_dist=None, - freq=None, solver=None, optOptions=None, timeLimit=None, storeHistory='hist.hist', hotStart=None ): - super().__init__(fi, boundaries, min_dist=min_dist, freq=freq) + super().__init__(fmodel, boundaries, min_dist=min_dist) self._reinitialize(solver=solver, optOptions=optOptions) self.storeHistory = storeHistory @@ -102,14 +87,13 @@ def _obj_func(self, varDict): self.parse_opt_vars(varDict) # Update turbine map with turbince locations - # self.fi.reinitialize(layout=[self.x, self.y]) - # self.fi.calculate_wake() + # self.fmodel.reinitialize(layout=[self.x, self.y]) + # self.fmodel.calculate_wake() # Compute the objective function funcs = {} funcs["obj"] = ( -1 * self.mean_distance(self.x, self.y) - # -1 * np.sum(self.fi.get_farm_power() * self.freq * 8760) / self.initial_AEP ) # Compute constraints, if any are defined for the optimization diff --git a/floris/tools/optimization/layout_optimization/layout_optimization_scipy.py b/floris/optimization/layout_optimization/layout_optimization_scipy.py similarity index 73% rename from floris/tools/optimization/layout_optimization/layout_optimization_scipy.py rename to floris/optimization/layout_optimization/layout_optimization_scipy.py index d8f3fa2d5..f7ca643b1 100644 --- a/floris/tools/optimization/layout_optimization/layout_optimization_scipy.py +++ b/floris/optimization/layout_optimization/layout_optimization_scipy.py @@ -1,16 +1,3 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import matplotlib.pyplot as plt import numpy as np @@ -22,40 +9,51 @@ class LayoutOptimizationScipy(LayoutOptimization): + """ + This class provides an interface for optimizing the layout of wind turbines + using the Scipy optimization library. The optimization objective is to + maximize annual energy production (AEP) or annual value production (AVP). + + + Args: + fmodel (FlorisModel): A FlorisModel object. + boundaries (iterable(float, float)): Pairs of x- and y-coordinates + that represent the boundary's vertices (m). + bnds (iterable, optional): Bounds for the optimization + variables (pairs of min/max values for each variable (m)). If + none are specified, they are set to 0 and 1. Defaults to None. + min_dist (float, optional): The minimum distance to be maintained + between turbines during the optimization (m). If not specified, + initializes to 2 rotor diameters. Defaults to None. + solver (str, optional): Sets the solver used by Scipy. Defaults to 'SLSQP'. + optOptions (dict, optional): Dictionary for setting the + optimization options. Defaults to None. + enable_geometric_yaw (bool, optional): If True, enables geometric yaw + optimization. Defaults to False. + use_value (bool, optional): If True, the layout optimization objective + is to maximize annual value production using the value array in the + FLORIS model's WindData object. If False, the optimization + objective is to maximize AEP. Defaults to False. + """ def __init__( self, - fi, + fmodel, boundaries, - freq=None, bnds=None, min_dist=None, solver='SLSQP', optOptions=None, enable_geometric_yaw=False, + use_value=False, ): - """ - _summary_ - - Args: - fi (_type_): _description_ - boundaries (iterable(float, float)): Pairs of x- and y-coordinates - that represent the boundary's vertices (m). - freq (np.array): An array of the frequencies of occurance - correponding to each pair of wind direction and wind speed - values. If None, equal weight is given to each pair of wind conditions - Defaults to None. - bnds (iterable, optional): Bounds for the optimization - variables (pairs of min/max values for each variable (m)). If - none are specified, they are set to 0 and 1. Defaults to None. - min_dist (float, optional): The minimum distance to be maintained - between turbines during the optimization (m). If not specified, - initializes to 2 rotor diameters. Defaults to None. - solver (str, optional): Sets the solver used by Scipy. Defaults to 'SLSQP'. - optOptions (dict, optional): Dicitonary for setting the - optimization options. Defaults to None. - """ - super().__init__(fi, boundaries, min_dist=min_dist, freq=freq, - enable_geometric_yaw=enable_geometric_yaw) + + super().__init__( + fmodel, + boundaries, + min_dist=min_dist, + enable_geometric_yaw=enable_geometric_yaw, + use_value=use_value + ) self.boundaries_norm = [ [ @@ -66,10 +64,10 @@ def __init__( ] self.x0 = [ self._norm(x, self.xmin, self.xmax) - for x in self.fi.layout_x + for x in self.fmodel.layout_x ] + [ self._norm(y, self.ymin, self.ymax) - for y in self.fi.layout_y + for y in self.fmodel.layout_y ] if bnds is not None: self.bnds = bnds @@ -112,8 +110,14 @@ def _obj_func(self, locs): self._change_coordinates(locs_unnorm) # Compute turbine yaw angles using PJ's geometric code (if enabled) yaw_angles = self._get_geoyaw_angles() - return (-1 * self.fi.get_farm_AEP(self.freq, yaw_angles=yaw_angles) / - self.initial_AEP) + self.fmodel.set_operation(yaw_angles=yaw_angles) + self.fmodel.run() + + if self.use_value: + return -1 * self.fmodel.get_farm_AVP() / self.initial_AEP_or_AVP + else: + return -1 * self.fmodel.get_farm_AEP() / self.initial_AEP_or_AVP + def _change_coordinates(self, locs): # Parse the layout coordinates @@ -125,7 +129,7 @@ def _change_coordinates(self, locs): self.y = layout_y # Update the turbine map in floris - self.fi.reinitialize(layout_x=layout_x, layout_y=layout_y) + self.fmodel.set(layout_x=layout_x, layout_y=layout_y) def _generate_constraints(self): tmp1 = { @@ -216,7 +220,7 @@ def _get_initial_and_final_locs(self): def optimize(self): """ This method finds the optimized layout of wind turbines for power - production given the provided frequencies of occurance of wind + production given the provided frequencies of occurrence of wind conditions (wind speed, direction). Returns: diff --git a/floris/tools/optimization/other/__init__.py b/floris/optimization/other/__init__.py similarity index 100% rename from floris/tools/optimization/other/__init__.py rename to floris/optimization/other/__init__.py diff --git a/floris/tools/optimization/other/boundary_grid.py b/floris/optimization/other/boundary_grid.py similarity index 93% rename from floris/tools/optimization/other/boundary_grid.py rename to floris/optimization/other/boundary_grid.py index 299251385..9d160b8a6 100644 --- a/floris/tools/optimization/other/boundary_grid.py +++ b/floris/optimization/other/boundary_grid.py @@ -1,17 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import numpy as np from shapely.geometry import Point, Polygon @@ -257,13 +243,12 @@ class BoundaryGrid: def __init__(self, fi): """ Initializes a BoundaryGrid object by assigning a - FlorisInterface object. + FlorisModel object. Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. + fmodel (FlorisModel): A FlorisModel object. """ - self.fi = fi + self.fmodel = fi self.n_boundary_turbs = 0 self.start = 0.0 @@ -346,7 +331,7 @@ def reinitialize_xy(self): eps=self.eps, ) - self.fi.reinitialize_flow_field(layout_array=(layout_x, layout_y)) + self.fmodel.reinitialize_flow_field(layout_array=(layout_x, layout_y)) if __name__ == "__main__": diff --git a/floris/tools/optimization/legacy/__init__.py b/floris/optimization/yaw_optimization/__init__.py similarity index 100% rename from floris/tools/optimization/legacy/__init__.py rename to floris/optimization/yaw_optimization/__init__.py diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimization_base.py b/floris/optimization/yaw_optimization/yaw_optimization_base.py similarity index 67% rename from floris/tools/optimization/yaw_optimization/yaw_optimization_base.py rename to floris/optimization/yaw_optimization/yaw_optimization_base.py index baffb9822..07a2f7e11 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimization_base.py +++ b/floris/optimization/yaw_optimization/yaw_optimization_base.py @@ -1,17 +1,3 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import copy from time import perf_counter as timerpc @@ -21,19 +7,19 @@ from floris.logging_manager import LoggingManager -from .yaw_optimization_tools import derive_downstream_turbines, find_layout_symmetry +from .yaw_optimization_tools import derive_downstream_turbines class YawOptimization(LoggingManager): """ - YawOptimization is a subclass of :py:class:`floris.tools.optimization.scipy. + YawOptimization is a subclass of :py:class:`floris.optimization.scipy. Optimization` that is used to optimize the yaw angles of all turbines in a Floris Farm for a single set of inflow conditions using the SciPy optimize package. """ def __init__( self, - fi, + fmodel, minimum_yaw_angle=0.0, maximum_yaw_angle=25.0, yaw_angles_baseline=None, @@ -42,16 +28,14 @@ def __init__( normalize_control_variables=False, calc_baseline_power=True, exclude_downstream_turbines=True, - exploit_layout_symmetry=True, verify_convergence=False, ): """ - Instantiate YawOptimization object with a FlorisInterface object + Instantiate YawOptimization object with a FlorisModel object and assign parameter values. Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. + fmodel (:py:class:`~.floris_model.FlorisModel`): A FlorisModel object. minimum_yaw_angle (float or ndarray): Minimum constraint on yaw angle (deg). If a single value specified, assumes this value for all turbines. If a 1D array is specified, assumes these @@ -115,11 +99,11 @@ def __init__( """ # Save turbine object to self - self.fi = fi.copy() - self.nturbs = len(self.fi.layout_x) + self.fmodel = fmodel.copy() + self.nturbs = len(self.fmodel.layout_x) # # Check floris options - # if self.fi.floris.flow_field.n_wind_speeds > 1: + # if self.fmodel.core.flow_field.n_wind_speeds > 1: # raise NotImplementedError( # "Optimizer currently does not support more than one wind" + # " speed. Please assign FLORIS a single wind speed." @@ -131,7 +115,7 @@ def __init__( yaw_angles_baseline = self._unpack_variable(yaw_angles_baseline) self.yaw_angles_baseline = yaw_angles_baseline else: - b = self.fi.floris.farm.yaw_angles + b = self.fmodel.core.farm.yaw_angles self.yaw_angles_baseline = self._unpack_variable(b) if np.any(np.abs(b) > 0.0): print( @@ -153,10 +137,10 @@ def __init__( else: self.x0 = self._unpack_variable(0.0) for ti in range(self.nturbs): - yaw_lb = self.minimum_yaw_angle[:, 0, ti] - yaw_ub = self.maximum_yaw_angle[:, 0, ti] + yaw_lb = self.minimum_yaw_angle[:, ti] + yaw_ub = self.maximum_yaw_angle[:, ti] idx = (yaw_lb > 0.0) | (yaw_ub < 0.0) - self.x0[idx, 0, ti] = (yaw_lb[idx] + yaw_ub[idx]) / 2.0 + self.x0[idx, ti] = (yaw_lb[idx] + yaw_ub[idx]) / 2.0 # Check inputs for consistency if np.any(self.yaw_angles_baseline < self.minimum_yaw_angle): @@ -179,16 +163,6 @@ def __init__( self.calc_baseline_power = calc_baseline_power self.exclude_downstream_turbines = exclude_downstream_turbines - # Check if exploit_layout_symmetry is being used with heterogeneous inflow - if exploit_layout_symmetry and fi.floris.flow_field.heterogenous_inflow_config is not None: - err_msg = ( - "Layout symmetry cannot be exploited with heterogeneous inflows. " - "Setting exploit_layout_symmetry to False." - ) - self.logger.warning(err_msg, stack_info=True) - self.exploit_layout_symmetry = False - else: - self.exploit_layout_symmetry = exploit_layout_symmetry # Prepare for optimization and calculate baseline powers (if applic.) self._initialize() @@ -203,9 +177,6 @@ def __init__( # Private methods def _initialize(self): - # Derive layout symmetry, if applicable - self._derive_layout_symmetry() - # Reduce optimization problem as much as possible self._reduce_control_problem() @@ -222,7 +193,7 @@ def _unpack_variable(self, variable, subset=False): # Deal with full vs. subset dimensions nturbs = self.nturbs if subset: - nturbs = np.shape(self._x0_subset.shape[2]) + nturbs = np.shape(self._x0_subset.shape[1]) # Then process maximum yaw angle if isinstance(variable, (int, float)): @@ -234,17 +205,9 @@ def _unpack_variable(self, variable, subset=False): # If one-dimensional array, copy over to all atmos. conditions variable = np.tile( variable, - ( - self.fi.floris.flow_field.n_wind_directions, - self.fi.floris.flow_field.n_wind_speeds, - 1 - ) + (self.fmodel.core.flow_field.n_findex, 1) ) - if len(np.shape(variable)) == 2: - raise UserWarning( - "Variable input must have shape (n_wind_directions, n_wind_speeds, nturbs)" - ) return variable @@ -255,16 +218,14 @@ def _reduce_control_problem(self): user-specified set of bounds (where bounds[i][0] == bounds[i][1]), or alternatively turbines that are far downstream in the wind farm and of which the wake does not impinge other turbines, if - exclude_downstream_turbines == True. This function also reduces - the optimization problem by exploiting layout symmetry, if - exploit_layout_symmetry == True. + exclude_downstream_turbines == True. """ # Initialize which turbines to optimize for self.turbs_to_opt = (self.maximum_yaw_angle - self.minimum_yaw_angle >= 0.001) # Initialize subset variables as full set - self.fi_subset = self.fi.copy() - nwinddirections_subset = copy.deepcopy(self.fi.floris.flow_field.n_wind_directions) + self.fmodel_subset = self.fmodel.copy() + n_findex_subset = copy.deepcopy(self.fmodel.core.flow_field.n_findex) minimum_yaw_angle_subset = copy.deepcopy(self.minimum_yaw_angle) maximum_yaw_angle_subset = copy.deepcopy(self.maximum_yaw_angle) x0_subset = copy.deepcopy(self.x0) @@ -275,31 +236,13 @@ def _reduce_control_problem(self): # Define which turbines to optimize for if self.exclude_downstream_turbines: - for iw, wd in enumerate(self.fi.floris.flow_field.wind_directions): + for iw, wd in enumerate(self.fmodel.core.flow_field.wind_directions): # Remove turbines from turbs_to_opt that are downstream - downstream_turbines = derive_downstream_turbines(self.fi, wd) + downstream_turbines = derive_downstream_turbines(self.fmodel, wd) downstream_turbines = np.array(downstream_turbines, dtype=int) - self.turbs_to_opt[iw, 0, downstream_turbines] = False + self.turbs_to_opt[iw, downstream_turbines] = False turbs_to_opt_subset = copy.deepcopy(self.turbs_to_opt) # Update - # Reduce optimization problem through layout symmetry - if (self.exploit_layout_symmetry) & (self._sym_df is not None): - # Reinitialize floris with subset of wind directions - wd_array = self.fi.floris.flow_field.wind_directions - wind_direction_subset = wd_array[self._sym_mapping_reduce] - self.fi_subset.reinitialize(wind_directions=wind_direction_subset) - - # Reduce control variables - red_map = self._sym_mapping_reduce - nwinddirections_subset = len(wind_direction_subset) - minimum_yaw_angle_subset = minimum_yaw_angle_subset[red_map, :, :] - maximum_yaw_angle_subset = maximum_yaw_angle_subset[red_map, :, :] - x0_subset = x0_subset[red_map, :, :] - turbs_to_opt_subset = turbs_to_opt_subset[red_map, :, :] - turbine_weights_subset = turbine_weights_subset[red_map, :, :] - yaw_angles_template_subset = yaw_angles_template_subset[red_map, :, :] - yaw_angles_baseline_subset = yaw_angles_baseline_subset[red_map, :, :] - # Set up a template yaw angles array with default solutions. The default # solutions are either 0.0 or the allowable yaw angle closest to 0.0 deg. # This solution addresses both downstream turbines, minimizing their abs. @@ -321,7 +264,7 @@ def _reduce_control_problem(self): yaw_angles_template_subset[idx] = yaw_mb[idx] # Save all subset variables to self - self._nwinddirections_subset = nwinddirections_subset + self._n_findex_subset = n_findex_subset self._minimum_yaw_angle_subset = minimum_yaw_angle_subset self._maximum_yaw_angle_subset = maximum_yaw_angle_subset self._x0_subset = x0_subset @@ -350,8 +293,14 @@ def _normalize_control_problem(self): / self._normalization_length ) - def _calculate_farm_power(self, yaw_angles=None, wd_array=None, turbine_weights=None, - heterogeneous_speed_multipliers=None + def _calculate_farm_power( + self, + yaw_angles=None, + wd_array=None, + ws_array=None, + ti_array=None, + turbine_weights=None, + heterogeneous_speed_multipliers=None, ): """ Calculate the wind farm power production assuming the predefined @@ -359,22 +308,37 @@ def _calculate_farm_power(self, yaw_angles=None, wd_array=None, turbine_weights= appropriate weighing terms, and for a specific set of yaw angles. Args: - yaw_angles ([iteratible]): Array or list of yaw angles in degrees. + yaw_angles (iterable, optional): Array or list of yaw angles in degrees. + Defaults to None. + wd_array (iterable, optional): Array or list of wind directions in degrees. + Defaults to None. + ws_array (iterable, optional): Array or list of wind speeds in m/s. Defaults to None. + ti_array (iterable, optional): Array or list of turbulence intensities. + Defaults to None. + turbine_weights (iterable, optional): Array or list of weights to apply to the turbine + powers. Defaults to None. + heterogeneous_speed_multipliers (iterable, optional): Array or list of speed up factors + for heterogeneous inflow. Defaults to None. + Returns: farm_power (float): Weighted wind farm power. """ # Unpack all variables, whichever are defined. - fi_subset = copy.deepcopy(self.fi_subset) + fmodel_subset = copy.deepcopy(self.fmodel_subset) if wd_array is None: - wd_array = fi_subset.floris.flow_field.wind_directions + wd_array = fmodel_subset.core.flow_field.wind_directions + if ws_array is None: + ws_array = fmodel_subset.core.flow_field.wind_speeds + if ti_array is None: + ti_array = fmodel_subset.core.flow_field.turbulence_intensities if yaw_angles is None: yaw_angles = self._yaw_angles_baseline_subset if turbine_weights is None: turbine_weights = self._turbine_weights_subset if heterogeneous_speed_multipliers is not None: - fi_subset.floris.flow_field.\ - heterogenous_inflow_config['speed_multipliers'] = heterogeneous_speed_multipliers + fmodel_subset.core.flow_field.\ + heterogeneous_inflow_config['speed_multipliers'] = heterogeneous_speed_multipliers # Ensure format [incompatible with _subset notation] yaw_angles = self._unpack_variable(yaw_angles, subset=True) @@ -383,14 +347,19 @@ def _calculate_farm_power(self, yaw_angles=None, wd_array=None, turbine_weights= # wd_array = wrap_360(wd_array) # Calculate solutions - turbine_power = np.zeros_like(self._minimum_yaw_angle_subset[:, 0, :]) - fi_subset.reinitialize(wind_directions=wd_array) - fi_subset.calculate_wake(yaw_angles=yaw_angles) - turbine_power = fi_subset.get_turbine_powers() + turbine_power = np.zeros_like(self._minimum_yaw_angle_subset[:, :]) + fmodel_subset.set( + wind_directions=wd_array, + wind_speeds=ws_array, + turbulence_intensities=ti_array, + yaw_angles=yaw_angles, + ) + fmodel_subset.run() + turbine_power = fmodel_subset.get_turbine_powers() # Multiply with turbine weighing terms turbine_power_weighted = np.multiply(turbine_weights, turbine_power) - farm_power_weighted = np.sum(turbine_power_weighted, axis=2) + farm_power_weighted = np.sum(turbine_power_weighted, axis=1) return farm_power_weighted def _calculate_baseline_farm_power(self): @@ -401,114 +370,11 @@ def _calculate_baseline_farm_power(self): if self.calc_baseline_power: P = self._calculate_farm_power(self._yaw_angles_baseline_subset) self._farm_power_baseline_subset = P - self.farm_power_baseline = self._unreduce_variable(P) + self.farm_power_baseline = P else: self._farm_power_baseline_subset = None self.farm_power_baseline = None - def _derive_layout_symmetry(self): - """Derive symmetry lines in the wind farm layout and use that - to reduce the optimization problem by 50 %. - """ - self._sym_df = None # Default option - if self.exploit_layout_symmetry: - # Check symmetry of bounds & turbine_weights - if np.unique(self.minimum_yaw_angle, axis=0).shape[0] > 1: - print("minimum_yaw_angle is not equal over wind directions.") - print("Exploiting of symmetry has been disabled.") - return - - if np.unique(self.maximum_yaw_angle, axis=0).shape[0] > 1: - print("maximum_yaw_angle is not equal over wind directions.") - print("Exploiting of symmetry has been disabled.") - return - - if np.unique(self.maximum_yaw_angle, axis=0).shape[0] > 1: - print("maximum_yaw_angle is not equal over wind directions.") - print("Exploiting of symmetry has been disabled.") - return - - if np.unique(self.turbine_weights, axis=0).shape[0] > 1: - print("turbine_weights is not equal over wind directions.") - print("Exploiting of symmetry has been disabled.") - return - - # Check if turbine_weights are consistently 1.0 everywhere - if np.any(np.abs(self.turbine_weights - 1.0) > 0.001): - print("turbine_weights are not uniformly 1.0.") - print("Exploiting of symmetry has been disabled.") - return - - x = self.fi.layout_x - y = self.fi.layout_y - df = find_layout_symmetry(x=x, y=y) - - # If no axes of symmetry, exit function - if df.shape[0] <= 0: - print("Wind farm layout in floris is not symmetrical.") - print("Exploitation of symmetry has been disabled.") - return - - wd_array = self.fi.floris.flow_field.wind_directions - sym_step = df.iloc[0]["wd_range"][1] - if ((0.0 not in wd_array) or(sym_step not in wd_array)): - print("Floris wind direction array does not " + - "intersect {:.1f} and {:.1f}.".format(0.0, sym_step)) - print("Exploitation of symmetry has been disabled.") - return - - ids_minimal = (wd_array >= 0.0) & (wd_array < sym_step) - wd_array_min = wd_array[ids_minimal] - wd_array_remn = np.remainder(wd_array, sym_step) - - if not np.all([(x in wd_array_min) for x in wd_array_remn]): - print("Wind direction array appears irregular.") - print("Exploitation of symmetry has been disabled.") - - self._sym_mapping_extrap = np.array( - [np.where(np.abs(x - wd_array_min) < 0.0001)[0][0] - for x in wd_array_remn], dtype=int) - - self._sym_mapping_reduce = copy.deepcopy(ids_minimal) - self._sym_df = df - - return - - def _unreduce_variable(self, variable): - # Check if needed to un-reduce at all, if not, return directly - if variable is None: - return variable - - if not self.exploit_layout_symmetry: - return variable - - if self._sym_df is None: - return variable - - # Apply operation on right dimension - ndims = len(np.shape(variable)) - if ndims == 1: - full_array = variable[self._sym_mapping_extrap] - elif ndims == 2: - full_array = variable[self._sym_mapping_extrap, :] - elif ndims == 3: - # First upsample to full wind rose - full_array = variable[self._sym_mapping_extrap, :, :] - - # Now process turbine mapping - wd_array = self.fi.floris.flow_field.wind_directions - for ii, dfrow in self._sym_df.iloc[1::].iterrows(): - ids = ( - (wd_array >= dfrow["wd_range"][0]) & - (wd_array < dfrow["wd_range"][1]) - ) - tmap = np.argsort(dfrow["turbine_mapping"]) - full_array[ids, :, :] = full_array[ids, :, :][:, :, tmap] - else: - raise UserWarning("Unknown data shape.") - - return full_array - def _finalize(self, farm_power_opt_subset=None, yaw_angles_opt_subset=None): # Process final solutions if farm_power_opt_subset is None: @@ -526,24 +392,27 @@ def _finalize(self, farm_power_opt_subset=None, yaw_angles_opt_subset=None): ) # Finalization step for optimization: undo reduction step - self.farm_power_opt = self._unreduce_variable(farm_power_opt_subset) - self.yaw_angles_opt = self._unreduce_variable(yaw_angles_opt_subset) + self.farm_power_opt = farm_power_opt_subset + self.yaw_angles_opt = yaw_angles_opt_subset # Produce output table - ti = np.min(self.fi.floris.flow_field.turbulence_intensity) df_list = [] - num_wind_directions = len(self.fi.floris.flow_field.wind_directions) - for ii, wind_speed in enumerate(self.fi.floris.flow_field.wind_speeds): - df_list.append(pd.DataFrame({ - "wind_direction": self.fi.floris.flow_field.wind_directions, - "wind_speed": wind_speed * np.ones(num_wind_directions), - "turbulence_intensity": ti * np.ones(num_wind_directions), - "yaw_angles_opt": list(self.yaw_angles_opt[:, ii, :]), - "farm_power_opt": None if self.farm_power_opt is None \ - else self.farm_power_opt[:, ii], - "farm_power_baseline": None if self.farm_power_baseline is None \ - else self.farm_power_baseline[:, ii], - })) + df_list.append( + pd.DataFrame( + { + "wind_direction": self.fmodel.core.flow_field.wind_directions, + "wind_speed": self.fmodel.core.flow_field.wind_speeds, + "turbulence_intensity": self.fmodel.core.flow_field.turbulence_intensities, + "yaw_angles_opt": list(self.yaw_angles_opt[:, :]), + "farm_power_opt": None + if self.farm_power_opt is None + else self.farm_power_opt[:], + "farm_power_baseline": None + if self.farm_power_baseline is None + else self.farm_power_baseline[:], + } + ) + ) df_opt = pd.concat(df_list, axis=0) return df_opt @@ -559,14 +428,14 @@ def _verify_solutions_for_convergence( """ This function verifies whether the found solutions (yaw_angles_opt) have any nonzero yaw angles that are actually a result of incorrect - converge. By evaluating the power production by setting each turbine's + convergence. By evaluating the power production by setting each turbine's yaw angle to 0.0 deg, one by one, we verify that the found optimal values do in fact lead to a nonzero power production gain. Args: - farm_power_opt_subset (iteratible): Array with the optimal wind + farm_power_opt_subset (iterable): Array with the optimal wind farm power values (i.e., farm powers with yaw_angles_opt_subset). - yaw_angles_opt_subset (iteratible): Array with the optimal yaw angles + yaw_angles_opt_subset (iterable): Array with the optimal yaw angles for all turbines in the farm (or for all the to-be-optimized turbines in the farm). The yaw angles in this array will be verified. @@ -574,14 +443,14 @@ def _verify_solutions_for_convergence( this amount compared to the baseline value will be assumed to be too small to make any notable difference. Therefore, for practical reasons, the value is overwritten by its baseline value (which - typically is 0.0 deg). Defaults to 0.10. + typically is 0.0 deg). Defaults to 0.01. min_power_gain_for_yaw (float, optional): The minimum percentage uplift a turbine must create in the farm power production for its yaw offset to be considered non negligible. Set to 0.0 to ignore this criteria. Defaults to 0.02 (implying 0.02%). - verbose (bool, optional): Print to console. Defaults to False. + verbose (bool, optional): Print to console. Defaults to True. Returns: - x_opt (iteratible): Array with the optimal yaw angles, possibly + x_opt (iterable): Array with the optimal yaw angles, possibly with certain values being set to 0.0 deg as they were found to be a result of incorrect convergence. If the optimization has perfectly converged, x_opt will be identical to the user- @@ -623,29 +492,33 @@ def _verify_solutions_for_convergence( # we copy the atmospheric conditions n_turbs times and for each # copy of atmospheric conditions, we reset that turbine's yaw angle # to its baseline value for all conditions. - n_turbs = len(self.fi.layout_x) - sp = (n_turbs, 1, 1) # Tile shape for matrix expansion - wd_array_nominal = self.fi_subset.floris.flow_field.wind_directions + n_turbs = len(self.fmodel.layout_x) + sp = (n_turbs, 1) # Tile shape for matrix expansion + wd_array_nominal = self.fmodel_subset.core.flow_field.wind_directions + ws_array_nominal = self.fmodel_subset.core.flow_field.wind_speeds + ti_array_nominal = self.fmodel_subset.core.flow_field.turbulence_intensities n_wind_directions = len(wd_array_nominal) yaw_angles_verify = np.tile(yaw_angles_opt_subset, sp) yaw_angles_bl_verify = np.tile(yaw_angles_baseline_subset, sp) turbine_id_array = np.zeros(np.shape(yaw_angles_verify)[0], dtype=int) for ti in range(n_turbs): ids = ti * n_wind_directions + np.arange(n_wind_directions) - yaw_angles_verify[ids, :, ti] = yaw_angles_bl_verify[ids, :, ti] + yaw_angles_verify[ids, ti] = yaw_angles_bl_verify[ids, ti] turbine_id_array[ids] = ti # Now evaluate all situations - farm_power_baseline_verify = np.tile(farm_power_baseline_subset, (n_turbs, 1)) + farm_power_baseline_verify = np.tile(farm_power_baseline_subset, (n_turbs)) farm_power = self._calculate_farm_power( yaw_angles=yaw_angles_verify, wd_array=np.tile(wd_array_nominal, n_turbs), + ws_array=np.tile(ws_array_nominal, n_turbs), + ti_array=np.tile(ti_array_nominal, n_turbs), turbine_weights=np.tile(self._turbs_to_opt_subset, sp) ) # Calculate power uplift for optimal solutions uplift_o = 100 * ( - np.tile(farm_power_opt_subset, (n_turbs, 1)) / + np.tile(farm_power_opt_subset, (n_turbs)) / farm_power_baseline_verify - 1.0 ) @@ -659,7 +532,6 @@ def _verify_solutions_for_convergence( ids_to_simplify = np.where(dp < min_power_gain_for_yaw) ids_to_simplify = ( np.remainder(ids_to_simplify[0], n_wind_directions), # Wind direction identifier - ids_to_simplify[1], # Wind speed identifier turbine_id_array[ids_to_simplify[0]], # Turbine identifier ) @@ -692,16 +564,16 @@ def _verify_solutions_for_convergence( diff_uplift = dP_old - dP_new ids_max_loss = np.where(np.nanmax(diff_uplift) == diff_uplift) jj = (ids_max_loss[0][0], ids_max_loss[1][0]) - ws_array_nominal = self.fi_subset.floris.flow_field.wind_speeds + ws_array_nominal = self.fmodel_subset.core.flow_field.wind_speeds print( "Nullified the optimal yaw offset for {:d}".format(n) + " conditions and turbines." - ) + ) print( - "Simplifying the yaw angles for these conditions lead " + - "to a maximum change in wake-steering power uplift from " - + "{:.5f}% to {:.5f}% at ".format(dP_old[jj], dP_new[jj]) - + " WD = {:.1f} deg and WS = {:.1f} m/s.".format( + "Simplifying the yaw angles for these conditions lead " + + "to a maximum change in wake-steering power uplift from " + + "{:.5f}% to {:.5f}% at ".format(dP_old[jj], dP_new[jj]) + + " WD = {:.1f} deg and WS = {:.1f} m/s.".format( wd_array_nominal[jj[0]], ws_array_nominal[jj[1]], ) ) diff --git a/floris/tools/optimization/legacy/scipy/derive_downstream_turbines.py b/floris/optimization/yaw_optimization/yaw_optimization_tools.py similarity index 82% rename from floris/tools/optimization/legacy/scipy/derive_downstream_turbines.py rename to floris/optimization/yaw_optimization/yaw_optimization_tools.py index e5e42da70..dedf8f057 100644 --- a/floris/tools/optimization/legacy/scipy/derive_downstream_turbines.py +++ b/floris/optimization/yaw_optimization/yaw_optimization_tools.py @@ -1,23 +1,10 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import matplotlib.pyplot as plt import numpy as np +import pandas as pd -def derive_downstream_turbines(fi, wind_direction, wake_slope=0.30, plot_lines=False): +def derive_downstream_turbines(fmodel, wind_direction, wake_slope=0.30, plot_lines=False): """Determine which turbines have no effect on other turbines in the farm, i.e., which turbines have wakes that do not impact the other turbines in the farm. This allows the user to exclude these turbines @@ -36,7 +23,7 @@ def derive_downstream_turbines(fi, wind_direction, wake_slope=0.30, plot_lines=F time compared to FLORIS. Args: - fi ([floris object]): FLORIS object of the farm of interest. + fmodel (FlorisModel): A FlorisModel object. wind_direction (float): The wind direction in the FLORIS frame of reference for which the downstream turbines are to be determined. wake_slope (float, optional): linear slope of the wake (dy/dx) @@ -50,9 +37,9 @@ def derive_downstream_turbines(fi, wind_direction, wake_slope=0.30, plot_lines=F """ # Get farm layout - x = fi.layout_x - y = fi.layout_y - D = np.array([t.rotor_diameter for t in fi.floris.farm.turbines]) + x = fmodel.layout_x + y = fmodel.layout_y + D = np.ones_like(x) * fmodel.core.farm.rotor_diameters_sorted[0][0] n_turbs = len(x) # Rotate farm and determine freestream/waked turbines @@ -134,7 +121,10 @@ def determine_if_in_wake(xt, yt): ax.set_xlim([np.min(x_rot) - 500.0, x1]) ax.set_ylim([np.min(y_rot) - 500.0, np.max(y_rot) + 500.0]) ax.plot( - x_rot[turbs_downstream], y_rot[turbs_downstream], "o", color="green", + x_rot[turbs_downstream], + y_rot[turbs_downstream], + "o", + color="green", ) return turbs_downstream diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimizer_geometric.py b/floris/optimization/yaw_optimization/yaw_optimizer_geometric.py similarity index 84% rename from floris/tools/optimization/yaw_optimization/yaw_optimizer_geometric.py rename to floris/optimization/yaw_optimization/yaw_optimizer_geometric.py index 6c63b52fd..e78d48c9d 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimizer_geometric.py +++ b/floris/optimization/yaw_optimization/yaw_optimizer_geometric.py @@ -1,17 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import numpy as np @@ -23,28 +9,26 @@ class YawOptimizationGeometric(YawOptimization): """ YawOptimizationGeometric is a subclass of - :py:class:`floris.tools.optimization.general_library.YawOptimization` that is + :py:class:`floris.optimization.general_library.YawOptimization` that is used to provide a rough estimate of optimal yaw angles based purely on the wind farm geometry. Main use case is for coupled layout and yaw optimization. """ def __init__( self, - fi, + fmodel, minimum_yaw_angle=0.0, maximum_yaw_angle=25.0, - exploit_layout_symmetry=True, ): """ - Instantiate YawOptimizationGeometric object with a FlorisInterface + Instantiate YawOptimizationGeometric object with a FlorisModel object assign parameter values. """ super().__init__( - fi=fi, + fmodel=fmodel, minimum_yaw_angle=minimum_yaw_angle, maximum_yaw_angle=maximum_yaw_angle, - exploit_layout_symmetry=exploit_layout_symmetry, calc_baseline_power=False ) @@ -58,18 +42,18 @@ def optimize(self): array is equal in length to the number of turbines in the farm. """ # Loop through every WD individually. WS ignored! - wd_array = self.fi_subset.floris.flow_field.wind_directions + wd_array = self.fmodel_subset.core.flow_field.wind_directions for nwdi, wd in enumerate(wd_array): - self._yaw_angles_opt_subset[nwdi, :, :] = geometric_yaw( - self.fi_subset.layout_x, - self.fi_subset.layout_y, + self._yaw_angles_opt_subset[nwdi, :] = geometric_yaw( + self.fmodel_subset.layout_x, + self.fmodel_subset.layout_y, wd, - self.fi.floris.farm.turbine_definitions[0]["rotor_diameter"], - top_left_yaw_upper=self.maximum_yaw_angle[0,0,0], - bottom_left_yaw_upper=self.maximum_yaw_angle[0,0,0], - top_left_yaw_lower=self.minimum_yaw_angle[0,0,0], - bottom_left_yaw_lower=self.minimum_yaw_angle[0,0,0] + self.fmodel.core.farm.turbine_definitions[0]["rotor_diameter"], + top_left_yaw_upper=self.maximum_yaw_angle[0, 0], + bottom_left_yaw_upper=self.maximum_yaw_angle[0, 0], + top_left_yaw_lower=self.minimum_yaw_angle[0, 0], + bottom_left_yaw_lower=self.minimum_yaw_angle[0, 0], ) # Finalize optimization, i.e., retrieve full solutions @@ -94,7 +78,7 @@ def geometric_yaw( top_left_yaw_lower=-30.0, top_right_yaw_lower=0.0, bottom_left_yaw_lower=-30.0, - bottom_right_yaw_lower=0.0 + bottom_right_yaw_lower=0.0, ): """ turbine_x: unrotated x turbine coords @@ -125,7 +109,7 @@ def geometric_yaw( np.array([wind_direction]), turbine_coordinates_array ) - processed_x, processed_y = _process_layout(rotated_x[0][0],rotated_y[0][0],rotor_diameter) + processed_x, processed_y = _process_layout(rotated_x[0], rotated_y[0], rotor_diameter) yaw_array = np.zeros(nturbs) for i in range(nturbs): # TODO: fix shape of top left yaw etc? @@ -143,7 +127,7 @@ def geometric_yaw( top_left_yaw_lower, top_right_yaw_lower, bottom_left_yaw_lower, - bottom_right_yaw_lower + bottom_right_yaw_lower, ) return yaw_array diff --git a/floris/optimization/yaw_optimization/yaw_optimizer_scipy.py b/floris/optimization/yaw_optimization/yaw_optimizer_scipy.py new file mode 100644 index 000000000..cdde87656 --- /dev/null +++ b/floris/optimization/yaw_optimization/yaw_optimizer_scipy.py @@ -0,0 +1,142 @@ + +import numpy as np +from scipy.optimize import minimize + +from .yaw_optimization_base import YawOptimization + + +class YawOptimizationScipy(YawOptimization): + """ + YawOptimizationScipy is a subclass of + :py:class:`floris.optimization.general_library.YawOptimization` that is + used to optimize the yaw angles of all turbines in a Floris Farm for a single + set of inflow conditions using the SciPy optimize package. + """ + + def __init__( + self, + fmodel, + minimum_yaw_angle=0.0, + maximum_yaw_angle=25.0, + yaw_angles_baseline=None, + x0=None, + opt_method="SLSQP", + opt_options=None, + turbine_weights=None, + exclude_downstream_turbines=True, + verify_convergence=False, + ): + """ + Instantiate YawOptimizationScipy object with a FlorisModel object + and assign parameter values. + """ + if opt_options is None: + # Default SciPy parameters + opt_options = { + "maxiter": 100, + "disp": True, + "iprint": 2, + "ftol": 1e-12, + "eps": 0.1, + } + + super().__init__( + fmodel=fmodel, + minimum_yaw_angle=minimum_yaw_angle, + maximum_yaw_angle=maximum_yaw_angle, + yaw_angles_baseline=yaw_angles_baseline, + x0=x0, + turbine_weights=turbine_weights, + normalize_control_variables=True, + calc_baseline_power=True, + exclude_downstream_turbines=exclude_downstream_turbines, + verify_convergence=verify_convergence, + ) + + self.opt_method = opt_method + self.opt_options = opt_options + + def optimize(self): + """ + Find optimum setting of turbine yaw angles for a single turbine + cluster that maximizes the weighted wind farm power production + given fixed atmospheric conditions (wind speed, direction, etc.) + using the scipy.optimize.minimize function. + + Returns: + opt_yaw_angles (np.array): Optimal yaw angles in degrees. This + array is equal in length to the number of turbines in the farm. + """ + # Loop through every wind condition individually + wd_array = self.fmodel_subset.core.flow_field.wind_directions + ws_array = self.fmodel_subset.core.flow_field.wind_speeds + ti_array = self.fmodel_subset.core.flow_field.turbulence_intensities + for i, (wd, ws, ti) in enumerate(zip(wd_array, ws_array, ti_array)): + + self.fmodel_subset.set( + wind_directions=[wd], + wind_speeds=[ws], + turbulence_intensities=[ti] + ) + + + # Find turbines to optimize + turbs_to_opt = self._turbs_to_opt_subset[i, :] + if not any(turbs_to_opt): + continue # Nothing to do here: no turbines to optimize + + # Extract current optimization problem variables (normalized) + yaw_lb = self._minimum_yaw_angle_subset_norm[i, turbs_to_opt] + yaw_ub = self._maximum_yaw_angle_subset_norm[i, turbs_to_opt] + bnds = [(a, b) for a, b in zip(yaw_lb, yaw_ub)] + x0 = self._x0_subset_norm[i, turbs_to_opt] + + J0 = self._farm_power_baseline_subset[i] + yaw_template = self._yaw_angles_template_subset[i, :] + turbine_weights = self._turbine_weights_subset[i, :] + yaw_template = np.tile(yaw_template, (1, 1)) + turbine_weights = np.tile(turbine_weights, (1, 1)) + + # Handle heterogeneous inflow, if there is one + if (hasattr(self.fmodel.core.flow_field, 'heterogeneous_inflow_config') and + self.fmodel.core.flow_field.heterogeneous_inflow_config is not None): + het_sm_orig = np.array( + self.fmodel.core.flow_field.heterogeneous_inflow_config['speed_multipliers'] + ) + het_sm = het_sm_orig[i, :].reshape(1, -1) + else: + het_sm = None + + # Define cost function + def cost(x): + x_full = np.array(yaw_template, copy=True) + x_full[0, turbs_to_opt] = x * self._normalization_length + return ( + - 1.0 * self._calculate_farm_power( + yaw_angles=x_full, + wd_array=[wd], + ws_array=[ws], + ti_array=[ti], + turbine_weights=turbine_weights, + heterogeneous_speed_multipliers=het_sm + )[0] / J0 + ) + + # Perform optimization + residual_plant = minimize( + fun=cost, + x0=x0, + bounds=bnds, + method=self.opt_method, + options=self.opt_options, + ) + + # Undo normalization/masks and save results to self + self._farm_power_opt_subset[i] = -residual_plant.fun * J0 + self._yaw_angles_opt_subset[i, turbs_to_opt] = ( + residual_plant.x * self._normalization_length + ) + + # Finalize optimization, i.e., retrieve full solutions + df_opt = self._finalize() + return df_opt diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimizer_sr.py b/floris/optimization/yaw_optimization/yaw_optimizer_sr.py similarity index 80% rename from floris/tools/optimization/yaw_optimization/yaw_optimizer_sr.py rename to floris/optimization/yaw_optimization/yaw_optimizer_sr.py index 6b0dbc4cf..2b5b7ad1b 100644 --- a/floris/tools/optimization/yaw_optimization/yaw_optimizer_sr.py +++ b/floris/optimization/yaw_optimization/yaw_optimizer_sr.py @@ -1,17 +1,3 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import copy import warnings @@ -29,7 +15,7 @@ class YawOptimizationSR(YawOptimization, LoggingManager): def __init__( self, - fi, + fmodel, minimum_yaw_angle=0.0, maximum_yaw_angle=25.0, yaw_angles_baseline=None, @@ -37,17 +23,16 @@ def __init__( Ny_passes=[5, 4], # Optimization options turbine_weights=None, exclude_downstream_turbines=True, - exploit_layout_symmetry=True, verify_convergence=False, ): """ - Instantiate YawOptimizationSR object with a FlorisInterface object + Instantiate YawOptimizationSR object with a FlorisModel object and assign parameter values. """ # Initialize base class super().__init__( - fi=fi, + fmodel=fmodel, minimum_yaw_angle=minimum_yaw_angle, maximum_yaw_angle=maximum_yaw_angle, yaw_angles_baseline=yaw_angles_baseline, @@ -55,7 +40,6 @@ def __init__( turbine_weights=turbine_weights, calc_baseline_power=True, exclude_downstream_turbines=exclude_downstream_turbines, - exploit_layout_symmetry=exploit_layout_symmetry, verify_convergence=verify_convergence, ) @@ -78,8 +62,8 @@ def __init__( # if reduce_ngrid: # for ti in range(self.nturbs): # # Force number of grid points to 2 - # self.fi.floris.farm.turbines[ti].ngrid = 2 - # self.fi.floris.farm.turbines[ti].initialize_turbine() + # self.fmodel.core.farm.turbines[ti].ngrid = 2 + # self.fmodel.core.farm.turbines[ti].initialize_turbine() # print("Reducing ngrid. Unsure if this functionality works!") # Save optimization choices to self @@ -89,10 +73,10 @@ def __init__( self._get_turbine_orders() def _get_turbine_orders(self): - layout_x = self.fi.layout_x - layout_y = self.fi.layout_y + layout_x = self.fmodel.layout_x + layout_y = self.fmodel.layout_y turbines_ordered_array = [] - for wd in self.fi_subset.floris.flow_field.wind_directions: + for wd in self.fmodel_subset.core.flow_field.wind_directions: layout_x_rot = ( np.cos((wd - 270.0) * np.pi / 180.0) * layout_x - np.sin((wd - 270.0) * np.pi / 180.0) * layout_y @@ -106,30 +90,34 @@ def _calc_powers_with_memory(self, yaw_angles_subset, use_memory=True): # Define current optimal solutions and floris wind directions locally yaw_angles_opt_subset = self._yaw_angles_opt_subset farm_power_opt_subset = self._farm_power_opt_subset - wd_array_subset = self.fi_subset.floris.flow_field.wind_directions + wd_array_subset = self.fmodel_subset.core.flow_field.wind_directions + ws_array_subset = self.fmodel_subset.core.flow_field.wind_speeds + ti_array_subset = self.fmodel_subset.core.flow_field.turbulence_intensities turbine_weights_subset = self._turbine_weights_subset # Reformat yaw_angles_subset, if necessary - eval_multiple_passes = (len(np.shape(yaw_angles_subset)) == 4) + eval_multiple_passes = (len(np.shape(yaw_angles_subset)) == 3) if eval_multiple_passes: # Four-dimensional; format everything into three-dimensional Ny = yaw_angles_subset.shape[0] # Number of passes yaw_angles_subset = np.vstack( - [yaw_angles_subset[iii, :, :, :] for iii in range(Ny)] + [yaw_angles_subset[iii, :, :] for iii in range(Ny)] ) - yaw_angles_opt_subset = np.tile(yaw_angles_opt_subset, (Ny, 1, 1)) - farm_power_opt_subset = np.tile(farm_power_opt_subset, (Ny, 1)) + yaw_angles_opt_subset = np.tile(yaw_angles_opt_subset, (Ny, 1)) + farm_power_opt_subset = np.tile(farm_power_opt_subset, (Ny)) wd_array_subset = np.tile(wd_array_subset, Ny) - turbine_weights_subset = np.tile(turbine_weights_subset, (Ny, 1, 1)) + ws_array_subset = np.tile(ws_array_subset, Ny) + ti_array_subset = np.tile(ti_array_subset, Ny) + turbine_weights_subset = np.tile(turbine_weights_subset, (Ny, 1)) # Initialize empty matrix for floris farm power outputs - farm_powers = np.zeros((yaw_angles_subset.shape[0], yaw_angles_subset.shape[1])) + farm_powers = np.zeros((yaw_angles_subset.shape[0])) # Find indices of yaw angles that we previously already evaluated, and # prevent redoing the same calculations if use_memory: - idx = (np.abs(yaw_angles_opt_subset - yaw_angles_subset) < 0.01).all(axis=2).all(axis=1) - farm_powers[idx, :] = farm_power_opt_subset[idx, :] + idx = (np.abs(yaw_angles_opt_subset - yaw_angles_subset) < 0.01).all(axis=1) + farm_powers[idx] = farm_power_opt_subset[idx] if self.print_progress: self.logger.info( "Skipping {:d}/{:d} calculations: already in memory.".format( @@ -141,18 +129,20 @@ def _calc_powers_with_memory(self, yaw_angles_subset, use_memory=True): if not np.all(idx): # Now calculate farm powers for conditions we haven't yet evaluated previously start_time = timerpc() - if (hasattr(self.fi.floris.flow_field, 'heterogenous_inflow_config') and - self.fi.floris.flow_field.heterogenous_inflow_config is not None): + if (hasattr(self.fmodel.core.flow_field, 'heterogeneous_inflow_config') and + self.fmodel.core.flow_field.heterogeneous_inflow_config is not None): het_sm_orig = np.array( - self.fi.floris.flow_field.heterogenous_inflow_config['speed_multipliers'] + self.fmodel.core.flow_field.heterogeneous_inflow_config['speed_multipliers'] ) het_sm = np.tile(het_sm_orig, (Ny, 1))[~idx, :] else: het_sm = None - farm_powers[~idx, :] = self._calculate_farm_power( + farm_powers[~idx] = self._calculate_farm_power( wd_array=wd_array_subset[~idx], - turbine_weights=turbine_weights_subset[~idx, :, :], - yaw_angles=yaw_angles_subset[~idx, :, :], + ws_array=ws_array_subset[~idx], + ti_array=ti_array_subset[~idx], + turbine_weights=turbine_weights_subset[~idx, :], + yaw_angles=yaw_angles_subset[~idx, :], heterogeneous_speed_multipliers=het_sm ) self.time_spent_in_floris += (timerpc() - start_time) @@ -163,8 +153,7 @@ def _calc_powers_with_memory(self, yaw_angles_subset, use_memory=True): farm_powers, ( Ny, - self.fi_subset.floris.flow_field.n_wind_directions, - self.fi_subset.floris.flow_field.n_wind_speeds + self.fmodel_subset.core.flow_field.n_findex ) ) @@ -180,10 +169,10 @@ def _generate_evaluation_grid(self, pass_depth, turbine_depth): # Initialize yaw angles to evaluate, 'Ny' times the wind rose Ny = self.Ny_passes[pass_depth] - evaluation_grid = np.tile(self._yaw_angles_opt_subset, (Ny, 1, 1, 1)) + evaluation_grid = np.tile(self._yaw_angles_opt_subset, (Ny, 1, 1)) # Get a list of the turbines in order of x and sort front to back - for iw in range(self._nwinddirections_subset): + for iw in range(self._n_findex_subset): turbid = self.turbines_ordered_array_subset[iw, turbine_depth] # Turbine to manipulate # # Check if this turbine needs to be optimized. If not, continue @@ -194,19 +183,19 @@ def _generate_evaluation_grid(self, pass_depth, turbine_depth): # turbines_ordered = [ti for ti in turbines_ordered if ti in self.turbs_to_opt] # Grab yaw bounds from self - yaw_lb = self._yaw_lbs[iw, :, turbid] - yaw_ub = self._yaw_ubs[iw, :, turbid] + yaw_lb = self._yaw_lbs[iw, turbid] + yaw_ub = self._yaw_ubs[iw, turbid] # Saturate to allowable yaw limits yaw_lb = np.clip( yaw_lb, - self.minimum_yaw_angle[iw, :, turbid], - self.maximum_yaw_angle[iw, :, turbid] + self.minimum_yaw_angle[iw, turbid], + self.maximum_yaw_angle[iw, turbid] ) yaw_ub = np.clip( yaw_ub, - self.minimum_yaw_angle[iw, :, turbid], - self.maximum_yaw_angle[iw, :, turbid] + self.minimum_yaw_angle[iw, turbid], + self.maximum_yaw_angle[iw, turbid] ) if pass_depth == 0: @@ -218,7 +207,7 @@ def _generate_evaluation_grid(self, pass_depth, turbine_depth): ids = [*list(range(0, c)), *list(range(c + 1, Ny + 1))] yaw_angles_subset = np.linspace(yaw_lb, yaw_ub, Ny + 1)[ids] - evaluation_grid[:, iw, :, turbid] = yaw_angles_subset + evaluation_grid[:, iw, turbid] = yaw_angles_subset self._yaw_evaluation_grid = evaluation_grid return evaluation_grid @@ -276,7 +265,7 @@ def optimize(self, print_progress=True): yaw_angles_opt_new = np.squeeze( np.take_along_axis( evaluation_grid, - np.expand_dims(args_opt, axis=3), + np.expand_dims(args_opt, axis=2), axis=0 ), axis=0 @@ -299,8 +288,8 @@ def optimize(self, print_progress=True): # Update bounds for next iteration to close proximity of optimal solution dx = ( - evaluation_grid[1, :, :, :] - - evaluation_grid[0, :, :, :] + evaluation_grid[1, :, :] - + evaluation_grid[0, :, :] )[ids] self._yaw_lbs[ids] = np.clip( yaw_angles_opt[ids] - 0.50 * dx, diff --git a/floris/tools/parallel_computing_interface.py b/floris/parallel_floris_model.py similarity index 62% rename from floris/tools/parallel_computing_interface.py rename to floris/parallel_floris_model.py index 1192fcfdb..ea235aaae 100644 --- a/floris/tools/parallel_computing_interface.py +++ b/floris/parallel_floris_model.py @@ -6,36 +6,21 @@ import numpy as np import pandas as pd +from floris.floris_model import FlorisModel from floris.logging_manager import LoggingManager -from floris.tools.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR -from floris.tools.uncertainty_interface import FlorisInterface, UncertaintyInterface +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR +from floris.uncertain_floris_model import map_turbine_powers_uncertain, UncertainFlorisModel -def _load_local_floris_object( - fi_dict, - unc_pmfs=None, - fix_yaw_in_relative_frame=False -): - # Load local FLORIS object - if unc_pmfs is None: - fi = FlorisInterface(fi_dict) - else: - fi = UncertaintyInterface( - fi_dict, - unc_pmfs=unc_pmfs, - fix_yaw_in_relative_frame=fix_yaw_in_relative_frame, - ) - return fi - - -def _get_turbine_powers_serial(fi_information, yaw_angles=None): - fi = _load_local_floris_object(*fi_information) - fi.calculate_wake(yaw_angles=yaw_angles) - return (fi.get_turbine_powers(), fi.floris.flow_field) +def _get_turbine_powers_serial(fmodel_information, yaw_angles=None): + fmodel = FlorisModel(fmodel_information) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run() + return (fmodel.get_turbine_powers(), fmodel.core.flow_field) def _optimize_yaw_angles_serial( - fi_information, + fmodel_information, minimum_yaw_angle, maximum_yaw_angle, yaw_angles_baseline, @@ -43,13 +28,12 @@ def _optimize_yaw_angles_serial( Ny_passes, turbine_weights, exclude_downstream_turbines, - exploit_layout_symmetry, verify_convergence, print_progress, ): - fi_opt = _load_local_floris_object(*fi_information) + fmodel_opt = FlorisModel(fmodel_information) yaw_opt = YawOptimizationSR( - fi=fi_opt, + fmodel=fmodel_opt, minimum_yaw_angle=minimum_yaw_angle, maximum_yaw_angle=maximum_yaw_angle, yaw_angles_baseline=yaw_angles_baseline, @@ -57,7 +41,6 @@ def _optimize_yaw_angles_serial( Ny_passes=Ny_passes, turbine_weights=turbine_weights, exclude_downstream_turbines=exclude_downstream_turbines, - exploit_layout_symmetry=exploit_layout_symmetry, verify_convergence=verify_convergence, ) @@ -66,31 +49,28 @@ def _optimize_yaw_angles_serial( return df_opt -class ParallelComputingInterface(LoggingManager): +class ParallelFlorisModel(LoggingManager): def __init__( self, - fi, + fmodel, max_workers, - n_wind_direction_splits, - n_wind_speed_splits=1, + n_wind_condition_splits, interface="multiprocessing", # Options are 'multiprocessing', 'mpi4py' or 'concurrent' use_mpi4py=None, propagate_flowfield_from_workers=False, print_timings=False ): """A wrapper around the nominal floris_interface class that adds - parallel computing to common FlorisInterface properties. + parallel computing to common FlorisModel properties. Args: - fi (FlorisInterface or UncertaintyInterface object): Interactive FLORIS object used to - perform the wake and turbine calculations. Can either be a regular FlorisInterface - object or can be an UncertaintyInterface object. + fmodel (FlorisModel or UncertainFlorisModel object): Interactive FLORIS object used to + perform the wake and turbine calculations. Can either be a regular FlorisModel + object or can be an UncertainFlorisModel object. max_workers (int): Number of parallel workers, typically equal to the number of cores you have on your system or HPC. - n_wind_direction_splits (int): Number of sectors to split the wind direction array over. + n_wind_condition_splits (int): Number of sectors to split the wind findex array over. This is typically equal to max_workers, or a multiple of it. - n_wind_speed_splits (int): Number of sectors to split the wind speed array over. This is - typically 1 or 2. Defaults to 1. interface (str): Parallel computing interface to leverage. Recommended is 'concurrent' or 'multiprocessing' for local (single-system) use, and 'mpi4py' for high performance computing on multiple nodes. Defaults to 'multiprocessing'. @@ -132,22 +112,27 @@ def __init__( ) # Initialize floris object and copy common properties - self.fi = fi.copy() - self.floris = self.fi.floris # Static copy as a placeholder + if isinstance(fmodel, FlorisModel): + self.fmodel = fmodel.copy() + self._is_uncertain = False + elif isinstance(fmodel, UncertainFlorisModel): + self.fmodel = fmodel.fmodel_expanded.copy() + self._is_uncertain = True + self._weights = fmodel.weights + self._n_unexpanded = fmodel.n_unexpanded + self._n_sample_points = fmodel.n_sample_points + self._map_to_expanded_inputs = fmodel.map_to_expanded_inputs + self.core = self.fmodel.core # Static copy as a placeholder # Save to self - self._n_wind_direction_splits = n_wind_direction_splits # Save initial user input - self._n_wind_speed_splits = n_wind_speed_splits # Save initial user input + self._n_wind_condition_splits = n_wind_condition_splits # Save initial user input self._max_workers = max_workers # Save initial user input - self.n_wind_direction_splits = int( - np.min([n_wind_direction_splits, self.fi.floris.flow_field.n_wind_directions]) - ) - self.n_wind_speed_splits = int( - np.min([n_wind_speed_splits, self.fi.floris.flow_field.n_wind_speeds]) + self.n_wind_condition_splits = int( + np.min([n_wind_condition_splits, self.fmodel.core.flow_field.n_findex]) ) self.max_workers = int( - np.min([max_workers, self.n_wind_direction_splits * self.n_wind_speed_splits]) + np.min([max_workers, self.n_wind_condition_splits]) ) self.propagate_flowfield_from_workers = propagate_flowfield_from_workers self.interface = interface @@ -156,17 +141,17 @@ def __init__( def copy(self): # Make an independent copy self_copy = copy.deepcopy(self) - self_copy.fi = self.fi.copy() + self_copy.fmodel = self.fmodel.copy() return self_copy - def reinitialize( + def set( self, wind_speeds=None, wind_directions=None, wind_shear=None, wind_veer=None, reference_wind_height=None, - turbulence_intensity=None, + turbulence_intensities=None, air_density=None, layout=None, layout_x=None, @@ -174,9 +159,9 @@ def reinitialize( turbine_type=None, solver_settings=None, ): - """Pass to the FlorisInterface reinitialize function. To allow users - to directly replace a FlorisInterface object with this - UncertaintyInterface object, this function is required.""" + """Pass to the FlorisModel set function. To allow users + to directly replace a FlorisModel object with this + UncertainFlorisModel object, this function is required.""" if layout is not None: msg = "Use the `layout_x` and `layout_y` parameters in place of `layout` " @@ -186,14 +171,14 @@ def reinitialize( layout_y = layout[1] # Just passes arguments to the floris object - fi = self.fi.copy() - fi.reinitialize( + fmodel = self.fmodel.copy() + fmodel.set( wind_speeds=wind_speeds, wind_directions=wind_directions, wind_shear=wind_shear, wind_veer=wind_veer, reference_wind_height=reference_wind_height, - turbulence_intensity=turbulence_intensity, + turbulence_intensities=turbulence_intensities, air_density=air_density, layout_x=layout_x, layout_y=layout_y, @@ -203,10 +188,9 @@ def reinitialize( # Reinitialize settings self.__init__( - fi=fi, + fmodel=fmodel, max_workers=self._max_workers, - n_wind_direction_splits=self._n_wind_direction_splits, - n_wind_speed_splits=self._n_wind_speed_splits, + n_wind_condition_splits=self._n_wind_condition_splits, interface=self.interface, propagate_flowfield_from_workers=self.propagate_flowfield_from_workers, print_timings=self.print_timings, @@ -216,72 +200,44 @@ def _preprocessing(self, yaw_angles=None): # Format yaw angles if yaw_angles is None: yaw_angles = np.zeros(( - self.fi.floris.flow_field.n_wind_directions, - self.fi.floris.flow_field.n_wind_speeds, - self.fi.floris.farm.n_turbines + self.fmodel.core.flow_field.n_findex, + self.fmodel.core.farm.n_turbines )) # Prepare settings - n_wind_direction_splits = self.n_wind_direction_splits - n_wind_direction_splits = np.min( - [n_wind_direction_splits, self.fi.floris.flow_field.n_wind_directions] + n_wind_condition_splits = self.n_wind_condition_splits + n_wind_condition_splits = np.min( + [n_wind_condition_splits, self.fmodel.core.flow_field.n_findex] ) - n_wind_speed_splits = self.n_wind_speed_splits - n_wind_speed_splits = np.min([n_wind_speed_splits, self.fi.floris.flow_field.n_wind_speeds]) # Prepare the input arguments for parallel execution - fi_dict = self.fi.floris.as_dict() - wind_direction_id_splits = np.array_split( - np.arange(self.fi.floris.flow_field.n_wind_directions), - n_wind_direction_splits - ) - wind_speed_id_splits = np.array_split( - np.arange(self.fi.floris.flow_field.n_wind_speeds), - n_wind_speed_splits + fmodel_dict = self.fmodel.core.as_dict() + wind_condition_id_splits = np.array_split( + np.arange(self.fmodel.core.flow_field.n_findex), + n_wind_condition_splits, ) multiargs = [] - for wd_id_split in wind_direction_id_splits: - for ws_id_split in wind_speed_id_splits: - fi_dict_split = copy.deepcopy(fi_dict) - wind_directions = self.fi.floris.flow_field.wind_directions[wd_id_split] - wind_speeds = self.fi.floris.flow_field.wind_speeds[ws_id_split] - yaw_angles_subset = yaw_angles[wd_id_split[0]:wd_id_split[-1]+1, ws_id_split, :] - fi_dict_split["flow_field"]["wind_directions"] = wind_directions - fi_dict_split["flow_field"]["wind_speeds"] = wind_speeds - - # Prepare lightweight data to pass along - if isinstance(self.fi, FlorisInterface): - fi_information = (fi_dict_split, None, None) - else: - fi_information = ( - fi_dict_split, - self.fi.fi.het_map, - self.fi.unc_pmfs, - self.fi.fix_yaw_in_relative_frame - ) - multiargs.append((fi_information, yaw_angles_subset)) + for wc_id_split in wind_condition_id_splits: + # for ws_id_split in wind_speed_id_splits: + fmodel_dict_split = copy.deepcopy(fmodel_dict) + wind_directions = self.fmodel.core.flow_field.wind_directions[wc_id_split] + wind_speeds = self.fmodel.core.flow_field.wind_speeds[wc_id_split] + turbulence_intensities = self.fmodel.core.flow_field.turbulence_intensities[wc_id_split] + yaw_angles_subset = yaw_angles[wc_id_split[0]:wc_id_split[-1]+1, :] + fmodel_dict_split["flow_field"]["wind_directions"] = wind_directions + fmodel_dict_split["flow_field"]["wind_speeds"] = wind_speeds + fmodel_dict_split["flow_field"]["turbulence_intensities"] = turbulence_intensities + + # Prepare lightweight data to pass along + multiargs.append((fmodel_dict_split, yaw_angles_subset)) return multiargs # Function to merge subsets in dictionaries def _merge_subsets(self, field, subset): - return np.concatenate( # Merges wind speeds - [ - np.concatenate( # Merges wind directions - [ - eval("f.{:s}".format(field)) - for f in subset[ - wii - * self.n_wind_direction_splits:(wii+1) - * self.n_wind_direction_splits - ] - ], - axis=0 - ) - for wii in range(self.n_wind_speed_splits) - ], - axis=1 - ) + i, j, k = np.shape(subset) + subset_reshape = np.reshape(subset, (i*j, k)) + return [eval("f.{:s}".format(field) for f in subset_reshape)] def _postprocessing(self, output): # Split results @@ -289,37 +245,29 @@ def _postprocessing(self, output): flowfield_subsets = [p[1] for p in output] # Retrieve and merge turbine power productions - turbine_powers = np.concatenate( - [ - np.concatenate( - power_subsets[self.n_wind_speed_splits*(ii):self.n_wind_speed_splits*(ii+1)], - axis=1 - ) - for ii in range(self.n_wind_direction_splits) - ], - axis=0 - ) + turbine_powers = np.concatenate(power_subsets, axis=0) # Optionally, also merge flow field dictionaries from individual floris solutions if self.propagate_flowfield_from_workers: - self.floris = self.fi.floris # Refresh static copy of underlying floris class - # self.floris.flow_field.u_initial = self._merge_subsets("u_initial", flowfield_subsets) - # self.floris.flow_field.v_initial = self._merge_subsets("v_initial", flowfield_subsets) - # self.floris.flow_field.w_initial = self._merge_subsets("w_initial", flowfield_subsets) - self.floris.flow_field.u = self._merge_subsets("u", flowfield_subsets) - self.floris.flow_field.v = self._merge_subsets("v", flowfield_subsets) - self.floris.flow_field.w = self._merge_subsets("w", flowfield_subsets) - self.floris.flow_field.turbulence_intensity_field = self._merge_subsets( + self.core = self.fmodel.core # Refresh static copy of underlying floris class + # self.core.flow_field.u_initial = self._merge_subsets("u_initial", flowfield_subsets) + # self.core.flow_field.v_initial = self._merge_subsets("v_initial", flowfield_subsets) + # self.core.flow_field.w_initial = self._merge_subsets("w_initial", flowfield_subsets) + self.core.flow_field.u = self._merge_subsets("u", flowfield_subsets) + self.core.flow_field.v = self._merge_subsets("v", flowfield_subsets) + self.core.flow_field.w = self._merge_subsets("w", flowfield_subsets) + self.core.flow_field.turbulence_intensity_field = self._merge_subsets( "turbulence_intensity_field", flowfield_subsets ) return turbine_powers - def calculate_wake(self): - # raise UserWarning("'calculate_wake' not supported. Please use - # 'get_turbine_powers' or 'get_farm_power' directly.") - return None # Do nothing + def run(self): + raise UserWarning( + "'run' not supported on ParallelFlorisModel. Please use " + "'get_turbine_powers' or 'get_farm_power' directly." + ) def get_turbine_powers(self, yaw_angles=None): # Retrieve multiargs: preprocessing @@ -344,6 +292,15 @@ def get_turbine_powers(self, yaw_angles=None): # Postprocessing: merge power production (and opt. flow field) from individual runs t2 = timerpc() turbine_powers = self._postprocessing(out) + if self._is_uncertain: + turbine_powers = map_turbine_powers_uncertain( + unique_turbine_powers=turbine_powers, + map_to_expanded_inputs=self._map_to_expanded_inputs, + weights=self._weights, + n_unexpanded=self._n_unexpanded, + n_sample_points=self._n_sample_points, + n_turbines=self.fmodel.core.farm.n_turbines, + ) t_postprocessing = timerpc() - t2 t_total = timerpc() - t0 @@ -364,9 +321,9 @@ def get_farm_power(self, yaw_angles=None, turbine_weights=None): # Default to equal weighing of all turbines when turbine_weights is None turbine_weights = np.ones( ( - self.fi.floris.flow_field.n_wind_directions, - self.fi.floris.flow_field.n_wind_speeds, - self.fi.floris.farm.n_turbines + (self._n_unexpanded if self._is_uncertain + else self.fmodel.core.flow_field.n_findex), + self.fmodel.core.farm.n_turbines ) ) elif len(np.shape(turbine_weights)) == 1: @@ -374,8 +331,8 @@ def get_farm_power(self, yaw_angles=None, turbine_weights=None): turbine_weights = np.tile( turbine_weights, ( - self.fi.floris.flow_field.n_wind_directions, - self.fi.floris.flow_field.n_wind_speeds, + (self._n_unexpanded if self._is_uncertain + else self.fmodel.core.flow_field.n_findex), 1 ) ) @@ -384,12 +341,12 @@ def get_farm_power(self, yaw_angles=None, turbine_weights=None): turbine_powers = self.get_turbine_powers(yaw_angles=yaw_angles) turbine_powers = np.multiply(turbine_weights, turbine_powers) - return np.sum(turbine_powers, axis=2) + return np.sum(turbine_powers, axis=1) def get_farm_AEP( self, freq, - cut_in_wind_speed=0.001, + cut_in_wind_speed=None, cut_out_wind_speed=None, yaw_angles=None, turbine_weights=None, @@ -405,15 +362,8 @@ def get_farm_AEP( wind speed combination. These frequencies should typically sum up to 1.0 and are used to weigh the wind farm power for every condition in calculating the wind farm's AEP. - cut_in_wind_speed (float, optional): Wind speed in m/s below which - any calculations are ignored and the wind farm is known to - produce 0.0 W of power. Note that to prevent problems with the - wake models at negative / zero wind speeds, this variable must - always have a positive value. Defaults to 0.001 [m/s]. - cut_out_wind_speed (float, optional): Wind speed above which the - wind farm is known to produce 0.0 W of power. If None is - specified, will assume that the wind farm does not cut out - at high wind speeds. Defaults to None. + cut_in_wind_speed (float, optional): No longer supported. + cut_out_wind_speed (float, optional): No longer supported. yaw_angles (NDArrayFloat | list[float] | None, optional): The relative turbine yaw angles in degrees. If None is specified, will assume that the turbine yaw angles are all @@ -444,7 +394,7 @@ def get_farm_AEP( # If no_wake==True, ignore parallelization because it's fast enough if no_wake: - return self.fi.get_farm_AEP( + return self.fmodel.get_farm_AEP( freq=freq, cut_in_wind_speed=cut_in_wind_speed, cut_out_wind_speed=cut_out_wind_speed, @@ -454,48 +404,52 @@ def get_farm_AEP( ) # Verify dimensions of the variable "freq" - if not ( - (np.shape(freq)[0] == self.fi.floris.flow_field.n_wind_directions) - & (np.shape(freq)[1] == self.fi.floris.flow_field.n_wind_speeds) - & (len(np.shape(freq)) == 2) - ): + if ((self._is_uncertain and np.shape(freq)[0] != self._n_unexpanded) or + (not self._is_uncertain and np.shape(freq)[0] != self.fmodel.core.flow_field.n_findex)): raise UserWarning( - "'freq' should be a two-dimensional array with dimensions " - + "(n_wind_directions, n_wind_speeds)." + "'freq' should be a one-dimensional array with dimensions (n_findex). " + f"Given shape is {np.shape(freq)}" ) # Check if frequency vector sums to 1.0. If not, raise a warning if np.abs(np.sum(freq) - 1.0) > 0.001: self.logger.warning( - "WARNING: The frequency array provided to get_farm_AEP() does not sum to 1.0. " + "WARNING: The frequency array provided to get_farm_AEP() does not sum to 1.0." ) # Copy the full wind speed array from the floris object and initialize # the the farm_power variable as an empty array. - wind_speeds = np.array(self.fi.floris.flow_field.wind_speeds, copy=True) - farm_power = np.zeros((self.fi.floris.flow_field.n_wind_directions, len(wind_speeds))) + wind_speeds = np.array(self.fmodel.core.flow_field.wind_speeds, copy=True) + wind_directions = np.array(self.fmodel.core.flow_field.wind_directions, copy=True) + turbulence_intensities = np.array( + self.fmodel.core.flow_field.turbulence_intensities, + copy=True, + ) + farm_power = np.zeros( + self._n_unexpanded if self._is_uncertain else self.core.flow_field.n_findex + ) # Determine which wind speeds we must evaluate in floris - conditions_to_evaluate = wind_speeds >= cut_in_wind_speed - if cut_out_wind_speed is not None: - conditions_to_evaluate = conditions_to_evaluate & (wind_speeds < cut_out_wind_speed) - - # Evaluate the conditions in floris - if np.any(conditions_to_evaluate): - wind_speeds_subset = wind_speeds[conditions_to_evaluate] - yaw_angles_subset = None - if yaw_angles is not None: - yaw_angles_subset = yaw_angles[:, conditions_to_evaluate] - self.fi.reinitialize(wind_speeds=wind_speeds_subset) - farm_power[:, conditions_to_evaluate] = ( - self.get_farm_power(yaw_angles=yaw_angles_subset, turbine_weights=turbine_weights) + if cut_in_wind_speed is not None or cut_out_wind_speed is not None: + raise NotImplementedError( + "WARNING: The 'cut_in_wind_speed' and 'cut_out_wind_speed' " + "parameters are no longer supported in the 'ParallelFlorisModel.get_farm_AEP' " + "method." ) + farm_power = ( + self.get_farm_power(yaw_angles=yaw_angles, turbine_weights=turbine_weights) + ) + # Finally, calculate AEP in GWh - aep = np.sum(np.multiply(freq, farm_power) * 365 * 24) + aep = np.nansum(np.multiply(freq, farm_power) * 365 * 24) # Reset the FLORIS object to the full wind speed array - self.fi.reinitialize(wind_speeds=wind_speeds) + self.fmodel.set( + wind_directions=wind_directions, + wind_speeds=wind_speeds, + turbulence_intensities=turbulence_intensities, + ) return aep @@ -508,7 +462,6 @@ def optimize_yaw_angles( Ny_passes=[5,4], turbine_weights=None, exclude_downstream_turbines=True, - exploit_layout_symmetry=True, verify_convergence=False, print_worker_progress=False, # Recommended disabled to avoid clutter. Useful for debugging ): @@ -526,7 +479,6 @@ def optimize_yaw_angles( Ny_passes, turbine_weights, exclude_downstream_turbines, - exploit_layout_symmetry, verify_convergence, print_worker_progress, ) @@ -550,7 +502,6 @@ def optimize_yaw_angles( [j[7] for j in multiargs], [j[8] for j in multiargs], [j[9] for j in multiargs], - [j[10] for j in multiargs] ) t2 = timerpc() @@ -574,12 +525,33 @@ def optimize_yaw_angles( @property def layout_x(self): - return self.fi.layout_x + return self.fmodel.layout_x @property def layout_y(self): - return self.fi.layout_y + return self.fmodel.layout_y + + @property + def wind_speeds(self): + return self.fmodel.wind_speeds + + @property + def wind_directions(self): + return self.fmodel.wind_directions + + @property + def turbulence_intensities(self): + return self.fmodel.turbulence_intensities + + @property + def n_findex(self): + return self.fmodel.n_findex + + @property + def n_turbines(self): + return self.fmodel.n_turbines + # @property # def floris(self): - # return self.fi.floris + # return self.fmodel.core diff --git a/floris/simulation/turbine.py b/floris/simulation/turbine.py deleted file mode 100644 index b99ba1906..000000000 --- a/floris/simulation/turbine.py +++ /dev/null @@ -1,680 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -from __future__ import annotations - -import copy -from collections.abc import Iterable - -import attrs -import numpy as np -from attrs import define, field -from scipy.interpolate import interp1d - -from floris.simulation import BaseClass -from floris.type_dec import ( - floris_numeric_dict_converter, - NDArrayBool, - NDArrayFilter, - NDArrayFloat, - NDArrayInt, - NDArrayObject, -) -from floris.utilities import cosd - - -def _rotor_velocity_yaw_correction( - pP: float, - yaw_angle: NDArrayFloat, - rotor_effective_velocities: NDArrayFloat, -) -> NDArrayFloat: - # Compute the rotor effective velocity adjusting for yaw settings - pW = pP / 3.0 # Convert from pP to w - rotor_effective_velocities = rotor_effective_velocities * cosd(yaw_angle) ** pW - - return rotor_effective_velocities - - -def _rotor_velocity_tilt_correction( - turbine_type_map: NDArrayObject, - tilt_angle: NDArrayFloat, - ref_tilt_cp_ct: NDArrayFloat, - pT: float, - tilt_interp: NDArrayObject, - correct_cp_ct_for_tilt: NDArrayBool, - rotor_effective_velocities: NDArrayFloat, -) -> NDArrayFloat: - # Compute the tilt, if using floating turbines - old_tilt_angle = copy.deepcopy(tilt_angle) - tilt_angle = compute_tilt_angles_for_floating_turbines( - turbine_type_map, - tilt_angle, - tilt_interp, - rotor_effective_velocities, - ) - # Only update tilt angle if requested (if the tilt isn't accounted for in the Cp curve) - tilt_angle = np.where(correct_cp_ct_for_tilt, tilt_angle, old_tilt_angle) - - # Compute the rotor effective velocity adjusting for tilt - relative_tilt = tilt_angle - ref_tilt_cp_ct - rotor_effective_velocities = rotor_effective_velocities * cosd(relative_tilt) ** (pT / 3.0) - return rotor_effective_velocities - - -def compute_tilt_angles_for_floating_turbines( - turbine_type_map: NDArrayObject, - tilt_angle: NDArrayFloat, - tilt_interp: dict[str, interp1d], - rotor_effective_velocities: NDArrayFloat, -) -> NDArrayFloat: - # Loop over each turbine type given to get tilt angles for all turbines - tilt_angles = np.zeros(np.shape(rotor_effective_velocities)) - turb_types = np.unique(turbine_type_map) - for turb_type in turb_types: - # If no tilt interpolation is specified, assume no modification to tilt - if tilt_interp[turb_type] is None: - # TODO should this be break? Should it be continue? Do we want to support mixed - # fixed-bottom and floating? Or non-tilting floating? - pass - # Using a masked array, apply the tilt angle for all turbines of the current - # type to the main tilt angle array - else: - tilt_angles += ( - tilt_interp[turb_type](rotor_effective_velocities) - * (turbine_type_map == turb_type) - ) - - # TODO: Not sure if this is the best way to do this? Basically replaces the initialized - # tilt_angles if there are non-zero tilt angles calculated above (meaning that the turbine - # definition contained a wind_speed/tilt table definition) - if not tilt_angles.all() == 0.0: - tilt_angle = tilt_angles - - return tilt_angle - - -def rotor_effective_velocity( - air_density: float, - ref_density_cp_ct: float, - velocities: NDArrayFloat, - yaw_angle: NDArrayFloat, - tilt_angle: NDArrayFloat, - ref_tilt_cp_ct: NDArrayFloat, - pP: float, - pT: float, - tilt_interp: NDArrayObject, - correct_cp_ct_for_tilt: NDArrayBool, - turbine_type_map: NDArrayObject, - ix_filter: NDArrayInt | Iterable[int] | None = None, - average_method: str = "cubic-mean", - cubature_weights: NDArrayFloat | None = None -) -> NDArrayFloat: - - if isinstance(yaw_angle, list): - yaw_angle = np.array(yaw_angle) - if isinstance(tilt_angle, list): - tilt_angle = np.array(tilt_angle) - - # Down-select inputs if ix_filter is given - if ix_filter is not None: - velocities = velocities[:, :, ix_filter] - yaw_angle = yaw_angle[:, :, ix_filter] - tilt_angle = tilt_angle[:, :, ix_filter] - ref_tilt_cp_ct = ref_tilt_cp_ct[:, :, ix_filter] - pP = pP[:, :, ix_filter] - pT = pT[:, :, ix_filter] - turbine_type_map = turbine_type_map[:, :, ix_filter] - - # Compute the rotor effective velocity adjusting for air density - # TODO: This correction is currently split across two functions: this one and `power`, where in - # `power` the returned power is multiplied by the reference air density - average_velocities = average_velocity( - velocities, - method=average_method, - cubature_weights=cubature_weights - ) - rotor_effective_velocities = (air_density/ref_density_cp_ct)**(1/3) * average_velocities - - # Compute the rotor effective velocity adjusting for yaw settings - rotor_effective_velocities = _rotor_velocity_yaw_correction( - pP, yaw_angle, rotor_effective_velocities - ) - - # Compute the tilt, if using floating turbines - rotor_effective_velocities = _rotor_velocity_tilt_correction( - turbine_type_map, - tilt_angle, - ref_tilt_cp_ct, - pT, - tilt_interp, - correct_cp_ct_for_tilt, - rotor_effective_velocities, - ) - - return rotor_effective_velocities - - -def power( - ref_density_cp_ct: float, - rotor_effective_velocities: NDArrayFloat, - power_interp: dict[str, interp1d], - turbine_type_map: NDArrayObject, - ix_filter: NDArrayInt | Iterable[int] | None = None, -) -> NDArrayFloat: - """Power produced by a turbine adjusted for yaw and tilt. Value - given in Watts. - - Args: - ref_density_cp_cts (NDArrayFloat[wd, ws, turbines]): The reference density for each turbine - rotor_effective_velocities (NDArrayFloat[wd, ws, turbines]): The rotor - effective velocities at a turbine. - power_interp (dict[str, interp1d]): A dictionary of power interpolation functions for - each turbine type. - turbine_type_map: (NDArrayObject[wd, ws, turbines]): The Turbine type definition for - each turbine. - ix_filter (NDArrayInt, optional): The boolean array, or - integer indices to filter out before calculation. Defaults to None. - - Returns: - NDArrayFloat: The power, in Watts, for each turbine after adjusting for yaw and tilt. - """ - # TODO: Change the order of input arguments to be consistent with the other - # utility functions - velocities first... - # Update to power calculation which replaces the fixed pP exponent with - # an exponent pW, that changes the effective wind speed input to the power - # calculation, rather than scaling the power. This better handles power - # loss to yaw in above rated conditions - # - # based on the paper "Optimising yaw control at wind farm level" by - # Ervin Bossanyi - - # TODO: check this - where is it? - # P = 1/2 rho A V^3 Cp - - # Down-select inputs if ix_filter is given - if ix_filter is not None: - rotor_effective_velocities = rotor_effective_velocities[:, :, ix_filter] - turbine_type_map = turbine_type_map[:, :, ix_filter] - - # Loop over each turbine type given to get power for all turbines - p = np.zeros(np.shape(rotor_effective_velocities)) - turb_types = np.unique(turbine_type_map) - for turb_type in turb_types: - # Using a masked array, apply the thrust coefficient for all turbines of the current - # type to the main thrust coefficient array - p += power_interp[turb_type](rotor_effective_velocities) * (turbine_type_map == turb_type) - - return p * ref_density_cp_ct - - -def Ct( - velocities: NDArrayFloat, - yaw_angle: NDArrayFloat, - tilt_angle: NDArrayFloat, - ref_tilt_cp_ct: NDArrayFloat, - fCt: dict, - tilt_interp: NDArrayObject, - correct_cp_ct_for_tilt: NDArrayBool, - turbine_type_map: NDArrayObject, - ix_filter: NDArrayFilter | Iterable[int] | None = None, - average_method: str = "cubic-mean", - cubature_weights: NDArrayFloat | None = None -) -> NDArrayFloat: - - """Thrust coefficient of a turbine incorporating the yaw angle. - The value is interpolated from the coefficient of thrust vs - wind speed table using the rotor swept area average velocity. - - Args: - velocities (NDArrayFloat[wd, ws, turbines, grid1, grid2]): The velocity field at - a turbine. - yaw_angle (NDArrayFloat[wd, ws, turbines]): The yaw angle for each turbine. - tilt_angle (NDArrayFloat[wd, ws, turbines]): The tilt angle for each turbine. - ref_tilt_cp_ct (NDArrayFloat[wd, ws, turbines]): The reference tilt angle for each turbine - that the Cp/Ct tables are defined at. - fCt (dict): The thrust coefficient interpolation functions for each turbine. Keys are - the turbine type string and values are the interpolation functions. - tilt_interp (Iterable[tuple]): The tilt interpolation functions for each - turbine. - correct_cp_ct_for_tilt (NDArrayBool[wd, ws, turbines]): Boolean for determining if the - turbines Cp and Ct should be corrected for tilt. - turbine_type_map: (NDArrayObject[wd, ws, turbines]): The Turbine type definition - for each turbine. - ix_filter (NDArrayFilter | Iterable[int] | None, optional): The boolean array, or - integer indices as an iterable of array to filter out before calculation. - Defaults to None. - - Returns: - NDArrayFloat: Coefficient of thrust for each requested turbine. - """ - - if isinstance(yaw_angle, list): - yaw_angle = np.array(yaw_angle) - - if isinstance(tilt_angle, list): - tilt_angle = np.array(tilt_angle) - - # Down-select inputs if ix_filter is given - if ix_filter is not None: - velocities = velocities[:, :, ix_filter] - yaw_angle = yaw_angle[:, :, ix_filter] - tilt_angle = tilt_angle[:, :, ix_filter] - ref_tilt_cp_ct = ref_tilt_cp_ct[:, :, ix_filter] - turbine_type_map = turbine_type_map[:, :, ix_filter] - correct_cp_ct_for_tilt = correct_cp_ct_for_tilt[:, :, ix_filter] - - average_velocities = average_velocity( - velocities, - method=average_method, - cubature_weights=cubature_weights - ) - - # Compute the tilt, if using floating turbines - old_tilt_angle = copy.deepcopy(tilt_angle) - tilt_angle = compute_tilt_angles_for_floating_turbines( - turbine_type_map, - tilt_angle, - tilt_interp, - average_velocities, - ) - # Only update tilt angle if requested (if the tilt isn't accounted for in the Ct curve) - tilt_angle = np.where(correct_cp_ct_for_tilt, tilt_angle, old_tilt_angle) - - # Loop over each turbine type given to get thrust coefficient for all turbines - thrust_coefficient = np.zeros(np.shape(average_velocities)) - turb_types = np.unique(turbine_type_map) - for turb_type in turb_types: - # Using a masked array, apply the thrust coefficient for all turbines of the current - # type to the main thrust coefficient array - thrust_coefficient += ( - fCt[turb_type](average_velocities) - * (turbine_type_map == turb_type) - ) - thrust_coefficient = np.clip(thrust_coefficient, 0.0001, 0.9999) - effective_thrust = thrust_coefficient * cosd(yaw_angle) * cosd(tilt_angle - ref_tilt_cp_ct) - return effective_thrust - - -def axial_induction( - velocities: NDArrayFloat, # (wind directions, wind speeds, turbines, grid, grid) - yaw_angle: NDArrayFloat, # (wind directions, wind speeds, turbines) - tilt_angle: NDArrayFloat, # (wind directions, wind speeds, turbines) - ref_tilt_cp_ct: NDArrayFloat, - fCt: dict, # (turbines) - tilt_interp: NDArrayObject, # (turbines) - correct_cp_ct_for_tilt: NDArrayBool, # (wind directions, wind speeds, turbines) - turbine_type_map: NDArrayObject, # (wind directions, 1, turbines) - ix_filter: NDArrayFilter | Iterable[int] | None = None, - average_method: str = "cubic-mean", - cubature_weights: NDArrayFloat | None = None -) -> NDArrayFloat: - """Axial induction factor of the turbine incorporating - the thrust coefficient and yaw angle. - - Args: - velocities (NDArrayFloat): The velocity field at each turbine; should be shape: - (number of turbines, ngrid, ngrid), or (ngrid, ngrid) for a single turbine. - yaw_angle (NDArrayFloat[wd, ws, turbines]): The yaw angle for each turbine. - tilt_angle (NDArrayFloat[wd, ws, turbines]): The tilt angle for each turbine. - ref_tilt_cp_ct (NDArrayFloat[wd, ws, turbines]): The reference tilt angle for each turbine - that the Cp/Ct tables are defined at. - fCt (dict): The thrust coefficient interpolation functions for each turbine. Keys are - the turbine type string and values are the interpolation functions. - tilt_interp (Iterable[tuple]): The tilt interpolation functions for each - turbine. - correct_cp_ct_for_tilt (NDArrayBool[wd, ws, turbines]): Boolean for determining if the - turbines Cp and Ct should be corrected for tilt. - turbine_type_map: (NDArrayObject[wd, ws, turbines]): The Turbine type definition - for each turbine. - ix_filter (NDArrayFilter | Iterable[int] | None, optional): The boolean array, or - integer indices (as an array or iterable) to filter out before calculation. - Defaults to None. - - Returns: - Union[float, NDArrayFloat]: [description] - """ - - if isinstance(yaw_angle, list): - yaw_angle = np.array(yaw_angle) - - # TODO: Should the tilt_angle used for the return calculation be modified the same as the - # tilt_angle in Ct, if the user has supplied a tilt/wind_speed table? - if isinstance(tilt_angle, list): - tilt_angle = np.array(tilt_angle) - - # Get Ct first before modifying any data - thrust_coefficient = Ct( - velocities, - yaw_angle, - tilt_angle, - ref_tilt_cp_ct, - fCt, - tilt_interp, - correct_cp_ct_for_tilt, - turbine_type_map, - ix_filter, - average_method, - cubature_weights - ) - - # Then, process the input arguments as needed for this function - if ix_filter is not None: - yaw_angle = yaw_angle[:, :, ix_filter] - tilt_angle = tilt_angle[:, :, ix_filter] - ref_tilt_cp_ct = ref_tilt_cp_ct[:, :, ix_filter] - - return ( - 0.5 - / (cosd(yaw_angle) - * cosd(tilt_angle - ref_tilt_cp_ct)) - * ( - 1 - np.sqrt( - 1 - thrust_coefficient * cosd(yaw_angle) * cosd(tilt_angle - ref_tilt_cp_ct) - ) - ) - ) - - -def simple_mean(array, axis=0): - return np.mean(array, axis=axis) - -def cubic_mean(array, axis=0): - return np.cbrt(np.mean(array ** 3.0, axis=axis)) - -def simple_cubature(array, cubature_weights, axis=0): - weights = cubature_weights.flatten() - weights = weights * len(weights) / np.sum(weights) - product = (array * weights[None, None, None, :, None]) - return simple_mean(product, axis) - -def cubic_cubature(array, cubature_weights, axis=0): - weights = cubature_weights.flatten() - weights = weights * len(weights) / np.sum(weights) - return np.cbrt(np.mean((array**3.0 * weights[None, None, None, :, None]), axis=axis)) - -def average_velocity( - velocities: NDArrayFloat, - ix_filter: NDArrayFilter | Iterable[int] | None = None, - method: str = "cubic-mean", - cubature_weights: NDArrayFloat | None = None -) -> NDArrayFloat: - """This property calculates and returns the cube root of the - mean cubed velocity in the turbine's rotor swept area (m/s). - - **Note:** The velocity is scaled to an effective velocity by the yaw. - - Args: - velocities (NDArrayFloat): The velocity field at each turbine; should be shape: - (number of turbines, ngrid, ngrid), or (ngrid, ngrid) for a single turbine. - ix_filter (NDArrayFilter | Iterable[int] | None], optional): The boolean array, or - integer indices (as an iterable or array) to filter out before calculation. - Defaults to None. - - Returns: - NDArrayFloat: The average velocity across the rotor(s). - """ - - # The input velocities are expected to be a 5 dimensional array with shape: - # (# wind directions, # wind speeds, # turbines, grid resolution, grid resolution) - - if ix_filter is not None: - velocities = velocities[:, :, ix_filter] - - axis = tuple([3 + i for i in range(velocities.ndim - 3)]) - if method == "simple-mean": - return simple_mean(velocities, axis) - - elif method == "cubic-mean": - return cubic_mean(velocities, axis) - - elif method == "simple-cubature": - if cubature_weights is None: - raise ValueError("cubature_weights is required for 'simple-cubature' method.") - return simple_cubature(velocities, cubature_weights, axis) - - elif method == "cubic-cubature": - if cubature_weights is None: - raise ValueError("cubature_weights is required for 'cubic-cubature' method.") - return cubic_cubature(velocities, cubature_weights, axis) - - else: - raise ValueError("Incorrect method given.") - -@define -class Turbine(BaseClass): - """ - A class containing the parameters and infrastructure to model a wind turbine's performance - for a particular atmospheric condition. - - Args: - turbine_type (str): An identifier for this type of turbine such as "NREL_5MW". - rotor_diameter (float): The rotor diameter in meters. - hub_height (float): The hub height in meters. - pP (float): The cosine exponent relating the yaw misalignment angle to turbine power. - pT (float): The cosine exponent relating the rotor tilt angle to turbine power. - TSR (float): The Tip Speed Ratio of the turbine. - generator_efficiency (float): The efficiency of the generator used to scale - power production. - ref_density_cp_ct (float): The density at which the provided Cp and Ct curves are defined. - ref_tilt_cp_ct (float): The implicit tilt of the turbine for which the Cp and Ct - curves are defined. This is typically the nacelle tilt. - power_thrust_table (dict[str, float]): Contains power coefficient and thrust coefficient - values at a series of wind speeds to define the turbine performance. - The dictionary must have the following three keys with equal length values: - { - "wind_speeds": List[float], - "power": List[float], - "thrust": List[float], - } - correct_cp_ct_for_tilt (bool): A flag to indicate whether to correct Cp and Ct for tilt - usually for a floating turbine. - Optional, defaults to False. - floating_tilt_table (dict[str, float]): Look up table of tilt angles at a series of - wind speeds. The dictionary must have the following keys with equal length values: - { - "wind_speeds": List[float], - "tilt": List[float], - } - Required if `correct_cp_ct_for_tilt = True`. Defaults to None. - """ - turbine_type: str = field() - rotor_diameter: float = field() - hub_height: float = field() - pP: float = field() - pT: float = field() - TSR: float = field() - generator_efficiency: float = field() - ref_density_cp_ct: float = field() - ref_tilt_cp_ct: float = field() - power_thrust_table: dict[str, NDArrayFloat] = field(converter=floris_numeric_dict_converter) - - correct_cp_ct_for_tilt: bool = field(default=False) - floating_tilt_table: dict[str, NDArrayFloat] | None = field(default=None) - - # Even though this Turbine class does not support the multidimensional features as they - # are implemented in TurbineMultiDim, providing the following two attributes here allows - # the turbine data inputs to keep the multidimensional Cp and Ct curve but switch them off - # with multi_dimensional_cp_ct = False - multi_dimensional_cp_ct: bool = field(default=False) - power_thrust_data_file: str = field(default=None) - - # Initialized in the post_init function - rotor_radius: float = field(init=False) - rotor_area: float = field(init=False) - fCt_interp: interp1d = field(init=False) - power_interp: interp1d = field(init=False) - tilt_interp: interp1d = field(init=False, default=None) - - def __attrs_post_init__(self) -> None: - self._initialize_power_thrust_interpolation() - self.__post_init__() - - def __post_init__(self) -> None: - self._initialize_tilt_interpolation() - - def _initialize_power_thrust_interpolation(self) -> None: - # TODO This validation for the power thrust tables should go in the turbine library - # since it's preprocessing - # Remove any duplicate wind speed entries - # _, duplicate_filter = np.unique(self.wind_speed, return_index=True) - # self.power = self.power[duplicate_filter] - # self.thrust = self.thrust[duplicate_filter] - # self.wind_speed = self.wind_speed[duplicate_filter] - - wind_speeds = self.power_thrust_table["wind_speed"] - cp_interp = interp1d( - wind_speeds, - self.power_thrust_table["power"], - fill_value=(0.0, 1.0), - bounds_error=False, - ) - self.power_interp = interp1d( - wind_speeds, - ( - 0.5 * self.rotor_area - * cp_interp(wind_speeds) - * self.generator_efficiency - * wind_speeds ** 3 - ), - bounds_error=False, - fill_value=0 - ) - - """ - Given an array of wind speeds, this function returns an array of the - interpolated thrust coefficients from the power / thrust table used - to define the Turbine. The values are bound by the range of the input - values. Any requested wind speeds outside of the range of input wind - speeds are assigned Ct of 0.0001 or 0.9999. - - The fill_value arguments sets (upper, lower) bounds for any values - outside of the input range. - """ - self.fCt_interp = interp1d( - wind_speeds, - self.power_thrust_table["thrust"], - fill_value=(0.0001, 0.9999), - bounds_error=False, - ) - - def _initialize_tilt_interpolation(self) -> None: - # TODO: - # Remove any duplicate wind speed entries - # _, duplicate_filter = np.unique(self.wind_speeds, return_index=True) - # self.tilt = self.tilt[duplicate_filter] - # self.wind_speeds = self.wind_speeds[duplicate_filter] - - if self.floating_tilt_table is not None: - self.floating_tilt_table = floris_numeric_dict_converter(self.floating_tilt_table) - - # If defined, create a tilt interpolation function for floating turbines. - # fill_value currently set to apply the min or max tilt angles if outside - # of the interpolation range. - if self.correct_cp_ct_for_tilt: - self.tilt_interp = interp1d( - self.floating_tilt_table["wind_speed"], - self.floating_tilt_table["tilt"], - fill_value=(0.0, self.floating_tilt_table["tilt"][-1]), - bounds_error=False, - ) - - @power_thrust_table.validator - def check_power_thrust_table(self, instance: attrs.Attribute, value: dict) -> None: - """ - Verify that the power and thrust tables are given with arrays of equal length - to the wind speed array. - """ - if len(value.keys()) != 3 or set(value.keys()) != {"wind_speed", "power", "thrust"}: - raise ValueError( - """ - power_thrust_table dictionary must have the form: - { - "wind_speed": List[float], - "power": List[float], - "thrust": List[float], - } - """ - ) - - if any(e.ndim > 1 for e in (value["power"], value["thrust"], value["wind_speed"])): - raise ValueError("power, thrust, and wind_speed inputs must be 1-D.") - - if len( {value["power"].size, value["thrust"].size, value["wind_speed"].size} ) > 1: - raise ValueError("power, thrust, and wind_speed tables must be the same size.") - - @rotor_diameter.validator - def reset_rotor_diameter_dependencies(self, instance: attrs.Attribute, value: float) -> None: - """Resets the `rotor_radius` and `rotor_area` attributes.""" - # Temporarily turn off validators to avoid infinite recursion - with attrs.validators.disabled(): - # Reset the values - self.rotor_radius = value / 2.0 - self.rotor_area = np.pi * self.rotor_radius ** 2.0 - - @rotor_radius.validator - def reset_rotor_radius(self, instance: attrs.Attribute, value: float) -> None: - """ - Resets the `rotor_diameter` value to trigger the recalculation of - `rotor_diameter`, `rotor_radius` and `rotor_area`. - """ - self.rotor_diameter = value * 2.0 - - @rotor_area.validator - def reset_rotor_area(self, instance: attrs.Attribute, value: float) -> None: - """ - Resets the `rotor_radius` value to trigger the recalculation of - `rotor_diameter`, `rotor_radius` and `rotor_area`. - """ - self.rotor_radius = (value / np.pi) ** 0.5 - - @floating_tilt_table.validator - def check_floating_tilt_table(self, instance: attrs.Attribute, value: dict | None) -> None: - """ - If the tilt / wind_speed table is defined, verify that the tilt and - wind_speed arrays are the same length. - """ - if value is None: - return - - if len(value.keys()) != 2 or set(value.keys()) != {"wind_speed", "tilt"}: - raise ValueError( - """ - floating_tilt_table dictionary must have the form: - { - "wind_speed": List[float], - "tilt": List[float], - } - """ - ) - - if any(len(np.shape(e)) > 1 for e in (value["tilt"], value["wind_speed"])): - raise ValueError("tilt and wind_speed inputs must be 1-D.") - - if len( {len(value["tilt"]), len(value["wind_speed"])} ) > 1: - raise ValueError("tilt and wind_speed inputs must be the same size.") - - @correct_cp_ct_for_tilt.validator - def check_for_cp_ct_correct_flag_if_floating( - self, - instance: attrs.Attribute, - value: bool - ) -> None: - """ - Check that the boolean flag exists for correcting Cp/Ct for tilt - if a tile/wind_speed table is also defined. - """ - if self.correct_cp_ct_for_tilt and self.floating_tilt_table is None: - raise ValueError( - "To enable the Cp and Ct tilt correction, a tilt table must be given." - ) diff --git a/floris/simulation/turbine_multi_dim.py b/floris/simulation/turbine_multi_dim.py deleted file mode 100644 index d101462a8..000000000 --- a/floris/simulation/turbine_multi_dim.py +++ /dev/null @@ -1,502 +0,0 @@ -# Copyright 2023 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -from __future__ import annotations - -import copy -from collections.abc import Iterable -from pathlib import Path - -import attrs -import numpy as np -import pandas as pd -from attrs import define, field -from flatten_dict import flatten -from scipy.interpolate import interp1d - -from floris.simulation import ( - average_velocity, - compute_tilt_angles_for_floating_turbines, - Turbine, -) -from floris.type_dec import ( - convert_to_path, - NDArrayBool, - NDArrayFilter, - NDArrayFloat, - NDArrayInt, - NDArrayObject, -) -from floris.utilities import cosd - - -def power_multidim( - ref_density_cp_ct: float, - rotor_effective_velocities: NDArrayFloat, - power_interp: NDArrayObject, - ix_filter: NDArrayInt | Iterable[int] | None = None, -) -> NDArrayFloat: - """Power produced by a turbine defined with multi-dimensional - Cp/Ct values, adjusted for yaw and tilt. Value given in Watts. - - Args: - ref_density_cp_cts (NDArrayFloat[wd, ws, turbines]): The reference density for each turbine - rotor_effective_velocities (NDArrayFloat[wd, ws, turbines, grid1, grid2]): The rotor - effective velocities at a turbine. - power_interp (NDArrayObject[wd, ws, turbines]): The power interpolation function - for each turbine. - ix_filter (NDArrayInt, optional): The boolean array, or - integer indices to filter out before calculation. Defaults to None. - - Returns: - NDArrayFloat: The power, in Watts, for each turbine after adjusting for yaw and tilt. - """ - # TODO: Change the order of input arguments to be consistent with the other - # utility functions - velocities first... - # Update to power calculation which replaces the fixed pP exponent with - # an exponent pW, that changes the effective wind speed input to the power - # calculation, rather than scaling the power. This better handles power - # loss to yaw in above rated conditions - # - # based on the paper "Optimising yaw control at wind farm level" by - # Ervin Bossanyi - - # TODO: check this - where is it? - # P = 1/2 rho A V^3 Cp - - # Down-select inputs if ix_filter is given - if ix_filter is not None: - power_interp = power_interp[:, :, ix_filter] - rotor_effective_velocities = rotor_effective_velocities[:, :, ix_filter] - # Loop over each turbine to get power for all turbines - p = np.zeros(np.shape(rotor_effective_velocities)) - for i, wd in enumerate(power_interp): - for j, ws in enumerate(wd): - for k, turb in enumerate(ws): - p[i, j, k] = power_interp[i, j, k](rotor_effective_velocities[i, j, k]) - - return p * ref_density_cp_ct - - -def Ct_multidim( - velocities: NDArrayFloat, - yaw_angle: NDArrayFloat, - tilt_angle: NDArrayFloat, - ref_tilt_cp_ct: NDArrayFloat, - fCt: list, - tilt_interp: NDArrayObject, - correct_cp_ct_for_tilt: NDArrayBool, - turbine_type_map: NDArrayObject, - ix_filter: NDArrayFilter | Iterable[int] | None = None, - average_method: str = "cubic-mean", - cubature_weights: NDArrayFloat | None = None -) -> NDArrayFloat: - - """Thrust coefficient of a turbine defined with multi-dimensional - Cp/Ct values, incorporating the yaw angle. The value is interpolated - from the coefficient of thrust vs wind speed table using the rotor - swept area average velocity. - - Args: - velocities (NDArrayFloat[wd, ws, turbines, grid1, grid2]): The velocity field at - a turbine. - yaw_angle (NDArrayFloat[wd, ws, turbines]): The yaw angle for each turbine. - tilt_angle (NDArrayFloat[wd, ws, turbines]): The tilt angle for each turbine. - ref_tilt_cp_ct (NDArrayFloat[wd, ws, turbines]): The reference tilt angle for each turbine - that the Cp/Ct tables are defined at. - fCt (list): The thrust coefficient interpolation functions for each turbine. - tilt_interp (Iterable[tuple]): The tilt interpolation functions for each - turbine. - correct_cp_ct_for_tilt (NDArrayBool[wd, ws, turbines]): Boolean for determining if the - turbines Cp and Ct should be corrected for tilt. - turbine_type_map: (NDArrayObject[wd, ws, turbines]): The Turbine type definition - for each turbine. - ix_filter (NDArrayFilter | Iterable[int] | None, optional): The boolean array, or - integer indices as an iterable of array to filter out before calculation. - Defaults to None. - - Returns: - NDArrayFloat: Coefficient of thrust for each requested turbine. - """ - - if isinstance(yaw_angle, list): - yaw_angle = np.array(yaw_angle) - - if isinstance(tilt_angle, list): - tilt_angle = np.array(tilt_angle) - - # Down-select inputs if ix_filter is given - if ix_filter is not None: - velocities = velocities[:, :, ix_filter] - yaw_angle = yaw_angle[:, :, ix_filter] - tilt_angle = tilt_angle[:, :, ix_filter] - ref_tilt_cp_ct = ref_tilt_cp_ct[:, :, ix_filter] - fCt = fCt[:, :, ix_filter] - turbine_type_map = turbine_type_map[:, :, ix_filter] - correct_cp_ct_for_tilt = correct_cp_ct_for_tilt[:, :, ix_filter] - - average_velocities = average_velocity( - velocities, - method=average_method, - cubature_weights=cubature_weights - ) - - # Compute the tilt, if using floating turbines - old_tilt_angle = copy.deepcopy(tilt_angle) - tilt_angle = compute_tilt_angles_for_floating_turbines( - turbine_type_map, - tilt_angle, - tilt_interp, - average_velocities, - ) - # Only update tilt angle if requested (if the tilt isn't accounted for in the Ct curve) - tilt_angle = np.where(correct_cp_ct_for_tilt, tilt_angle, old_tilt_angle) - - # Loop over each turbine to get thrust coefficient for all turbines - thrust_coefficient = np.zeros(np.shape(average_velocities)) - for i, wd in enumerate(fCt): - for j, ws in enumerate(wd): - for k, turb in enumerate(ws): - thrust_coefficient[i, j, k] = fCt[i, j, k](average_velocities[i, j, k]) - thrust_coefficient = np.clip(thrust_coefficient, 0.0001, 0.9999) - effective_thrust = thrust_coefficient * cosd(yaw_angle) * cosd(tilt_angle - ref_tilt_cp_ct) - return effective_thrust - - -def axial_induction_multidim( - velocities: NDArrayFloat, # (wind directions, wind speeds, turbines, grid, grid) - yaw_angle: NDArrayFloat, # (wind directions, wind speeds, turbines) - tilt_angle: NDArrayFloat, # (wind directions, wind speeds, turbines) - ref_tilt_cp_ct: NDArrayFloat, - fCt: list, # (turbines) - tilt_interp: NDArrayObject, # (turbines) - correct_cp_ct_for_tilt: NDArrayBool, # (wind directions, wind speeds, turbines) - turbine_type_map: NDArrayObject, # (wind directions, 1, turbines) - ix_filter: NDArrayFilter | Iterable[int] | None = None, - average_method: str = "cubic-mean", - cubature_weights: NDArrayFloat | None = None -) -> NDArrayFloat: - """Axial induction factor of the turbines defined with multi-dimensional - Cp/Ct values, incorporating the thrust coefficient and yaw angle. - - Args: - velocities (NDArrayFloat): The velocity field at each turbine; should be shape: - (number of turbines, ngrid, ngrid), or (ngrid, ngrid) for a single turbine. - yaw_angle (NDArrayFloat[wd, ws, turbines]): The yaw angle for each turbine. - tilt_angle (NDArrayFloat[wd, ws, turbines]): The tilt angle for each turbine. - ref_tilt_cp_ct (NDArrayFloat[wd, ws, turbines]): The reference tilt angle for each turbine - that the Cp/Ct tables are defined at. - fCt (list): The thrust coefficient interpolation functions for each turbine. - tilt_interp (Iterable[tuple]): The tilt interpolation functions for each - turbine. - correct_cp_ct_for_tilt (NDArrayBool[wd, ws, turbines]): Boolean for determining if the - turbines Cp and Ct should be corrected for tilt. - turbine_type_map: (NDArrayObject[wd, ws, turbines]): The Turbine type definition - for each turbine. - ix_filter (NDArrayFilter | Iterable[int] | None, optional): The boolean array, or - integer indices (as an array or iterable) to filter out before calculation. - Defaults to None. - - Returns: - Union[float, NDArrayFloat]: [description] - """ - - if isinstance(yaw_angle, list): - yaw_angle = np.array(yaw_angle) - - # TODO: Should the tilt_angle used for the return calculation be modified the same as the - # tilt_angle in Ct, if the user has supplied a tilt/wind_speed table? - if isinstance(tilt_angle, list): - tilt_angle = np.array(tilt_angle) - - # Get Ct first before modifying any data - thrust_coefficient = Ct_multidim( - velocities, - yaw_angle, - tilt_angle, - ref_tilt_cp_ct, - fCt, - tilt_interp, - correct_cp_ct_for_tilt, - turbine_type_map, - ix_filter, - average_method, - cubature_weights - ) - - # Then, process the input arguments as needed for this function - if ix_filter is not None: - yaw_angle = yaw_angle[:, :, ix_filter] - tilt_angle = tilt_angle[:, :, ix_filter] - ref_tilt_cp_ct = ref_tilt_cp_ct[:, :, ix_filter] - - return ( - 0.5 - / (cosd(yaw_angle) - * cosd(tilt_angle - ref_tilt_cp_ct)) - * ( - 1 - np.sqrt( - 1 - thrust_coefficient * cosd(yaw_angle) * cosd(tilt_angle - ref_tilt_cp_ct) - ) - ) - ) - - -def multidim_Ct_down_select( - turbine_fCts, - conditions, -) -> list: - """ - Ct interpolants are down selected from the multi-dimensional Ct data - provided for the turbine based on the specified conditions. - - Args: - turbine_fCts (NDArray[wd, ws, turbines]): The Ct interpolants generated from the - multi-dimensional Ct turbine data for all specified conditions. - conditions (dict): The conditions at which to determine which Ct interpolant to use. - - Returns: - NDArray: The down selected Ct interpolants for the selected conditions. - """ - downselect_turbine_fCts = np.empty_like(turbine_fCts) - # Loop over the wind directions, wind speeds, and turbines, finding the Ct interpolant - # that is closest to the specified multi-dimensional condition. - for i, wd in enumerate(turbine_fCts): - for j, ws in enumerate(wd): - for k, turb in enumerate(ws): - # Get the interpolant keys in float type for comparison - keys_float = np.array([[float(v) for v in val] for val in turb.keys()]) - - # Find the nearest key to the specified conditions. - key_vals = [] - for ii, cond in enumerate(conditions.values()): - key_vals.append( - keys_float[:, ii][np.absolute(keys_float[:, ii] - cond).argmin()] - ) - - downselect_turbine_fCts[i, j, k] = turb[tuple(key_vals)] - - return downselect_turbine_fCts - - -def multidim_power_down_select( - power_interps, - conditions, -) -> list: - """ - Cp interpolants are down selected from the multi-dimensional Cp data - provided for the turbine based on the specified conditions. - - Args: - power_interps (NDArray[wd, ws, turbines]): The power interpolants generated from the - multi-dimensional Cp turbine data for all specified conditions. - conditions (dict): The conditions at which to determine which Ct interpolant to use. - - Returns: - NDArray: The down selected power interpolants for the selected conditions. - """ - downselect_power_interps = np.empty_like(power_interps) - # Loop over the wind directions, wind speeds, and turbines, finding the power interpolant - # that is closest to the specified multi-dimensional condition. - for i, wd in enumerate(power_interps): - for j, ws in enumerate(wd): - for k, turb in enumerate(ws): - # Get the interpolant keys in float type for comparison - keys_float = np.array([[float(v) for v in val] for val in turb.keys()]) - - # Find the nearest key to the specified conditions. - key_vals = [] - for ii, cond in enumerate(conditions.values()): - key_vals.append( - keys_float[:, ii][np.absolute(keys_float[:, ii] - cond).argmin()] - ) - - # Use the constructed key to choose the correct interpolant - downselect_power_interps[i, j, k] = turb[tuple(key_vals)] - - return downselect_power_interps - - -@define -class MultiDimensionalPowerThrustTable(): - """Helper class to convert the multi-dimensional inputs to a dictionary of objects. - """ - - @classmethod - def from_dataframe(self, df) -> None: - # Validate the dataframe - if not all(ele in df.columns.values.tolist() for ele in ["ws", "Cp", "Ct"]): - print(df.columns.values.tolist()) - raise ValueError("Multidimensional data missing required ws/Cp/Ct data.") - if df.columns.values[-3:].tolist() != ["ws", "Cp", "Ct"]: - print(df.columns.values[-3:].tolist()) - raise ValueError( - "Multidimensional data not in correct form. ws, Cp, and Ct must be " - "defined as the last 3 columns, in that order." - ) - - # Extract the supplied dimensions, minus the required ws, Cp, and Ct columns. - keys = df.columns.values[:-3].tolist() - values = [df[df.columns.values[i]].unique().tolist() for i in range(len(keys))] - values = [[str(val) for val in value] for value in values] - - # Functions for recursively building a nested dictionary from - # an arbitrary number of paired-inputs. - def add_level(obj, k, v): - tmp = {} - for val in v: - tmp.update({val: []}) - obj.update({k: tmp}) - return obj - - def add_sub_level(obj, k): - tmp = {} - for key in k: - tmp.update({key: obj}) - return tmp - - obj = {} - # Reverse the lists to start from the lowest level of the dictionary - keys.reverse() - values.reverse() - # Recursively build a nested dictionary from the user-supplied dimensions - for i, key in enumerate(keys): - if i == 0: - obj = add_level(obj, key, values[i]) - else: - obj = add_sub_level(obj, values[i]) - obj = {key: obj} - - return flatten(obj) - - -@define -class TurbineMultiDimensional(Turbine): - """ - Turbine is a class containing objects pertaining to the individual - turbines. - - Turbine is a model class representing a particular wind turbine. It - is largely a container of data and parameters, but also contains - methods to probe properties for output. - - Parameters: - rotor_diameter (:py:obj: float): The rotor diameter (m). - hub_height (:py:obj: float): The hub height (m). - pP (:py:obj: float): The cosine exponent relating the yaw - misalignment angle to power. - pT (:py:obj: float): The cosine exponent relating the rotor - tilt angle to power. - generator_efficiency (:py:obj: float): The generator - efficiency factor used to scale the power production. - ref_density_cp_ct (:py:obj: float): The density at which the provided - cp and ct is defined - power_thrust_table (PowerThrustTable): A dictionary containing the - following key-value pairs: - - power (:py:obj: List[float]): The coefficient of power at - different wind speeds. - thrust (:py:obj: List[float]): The coefficient of thrust - at different wind speeds. - wind_speed (:py:obj: List[float]): The wind speeds for - which the power and thrust values are provided (m/s). - ngrid (*int*, optional): The square root of the number - of points to use on the turbine grid. This number will be - squared so that the points can be evenly distributed. - Defaults to 5. - rloc (:py:obj: float, optional): A value, from 0 to 1, that determines - the width/height of the grid of points on the rotor as a ratio of - the rotor radius. - Defaults to 0.5. - power_thrust_data_file (:py:obj:`str`): The path and name of the file containing the - multidimensional power thrust curve. The path may be an absolute location or a relative - path to where FLORIS is being run. - multi_dimensional_cp_ct (:py:obj:`bool`, optional): Indicates if the turbine definition is - single dimensional (False) or multidimensional (True). - turbine_library_path (:py:obj:`pathlib.Path`, optional): The - :py:attr:`Farm.turbine_library_path` or :py:attr:`Farm.internal_turbine_library_path`, - whichever is being used to load turbine definitions. - Defaults to the internal turbine library. - """ - multi_dimensional_cp_ct: bool = field(default=False) - power_thrust_table: dict = field(default={}) - # TODO power_thrust_data_file is actually required and should not default to None. - # However, the super class has optional attributes so a required attribute here breaks - power_thrust_data_file: str = field(default=None) - power_thrust_data: MultiDimensionalPowerThrustTable = field(default=None) - turbine_library_path: Path = field( - default=Path(__file__).parents[1] / "turbine_library", - converter=convert_to_path, - validator=attrs.validators.instance_of(Path) - ) - - # Not to be provided by the user - condition_keys: list[str] = field(init=False, factory=list) - - def __attrs_post_init__(self) -> None: - super().__post_init__() - - # Solidify the data file path and name - self.power_thrust_data_file = self.turbine_library_path / self.power_thrust_data_file - - # Read in the multi-dimensional data supplied by the user. - df = pd.read_csv(self.power_thrust_data_file) - - # Build the multi-dimensional power/thrust table - self.power_thrust_data = MultiDimensionalPowerThrustTable.from_dataframe(df) - - # Create placeholders for the interpolation functions - self.fCt_interp = {} - self.power_interp = {} - - # Down-select the DataFrame to have just the ws, Cp, and Ct values - index_col = df.columns.values[:-3] - self.condition_keys = index_col.tolist() - df2 = df.set_index(index_col.tolist()) - - # Loop over the multi-dimensional keys to get the correct ws/Cp/Ct data to make - # the Ct and power interpolants. - for key in df2.index.unique(): - # Select the correct ws/Cp/Ct data - data = df2.loc[key] - - # Build the interpolants - wind_speeds = data['ws'].values - cp_interp = interp1d( - wind_speeds, - data['Cp'].values, - fill_value=(0.0, 1.0), - bounds_error=False, - ) - self.power_interp.update({ - key: interp1d( - wind_speeds, - ( - 0.5 * self.rotor_area - * cp_interp(wind_speeds) - * self.generator_efficiency - * wind_speeds ** 3 - ), - bounds_error=False, - fill_value=0 - ) - }) - self.fCt_interp.update({ - key: interp1d( - wind_speeds, - data['Ct'].values, - fill_value=(0.0001, 0.9999), - bounds_error=False, - ) - }) diff --git a/floris/simulation/wake_combination/__init__.py b/floris/simulation/wake_combination/__init__.py deleted file mode 100644 index 59976c375..000000000 --- a/floris/simulation/wake_combination/__init__.py +++ /dev/null @@ -1,18 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -from floris.simulation.wake_combination.fls import FLS -from floris.simulation.wake_combination.max import MAX -from floris.simulation.wake_combination.sosfs import SOSFS diff --git a/floris/simulation/wake_deflection/__init__.py b/floris/simulation/wake_deflection/__init__.py deleted file mode 100644 index 62fba9ca5..000000000 --- a/floris/simulation/wake_deflection/__init__.py +++ /dev/null @@ -1,19 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -from floris.simulation.wake_deflection.empirical_gauss import EmpiricalGaussVelocityDeflection -from floris.simulation.wake_deflection.gauss import GaussVelocityDeflection -from floris.simulation.wake_deflection.jimenez import JimenezVelocityDeflection -from floris.simulation.wake_deflection.none import NoneVelocityDeflection diff --git a/floris/simulation/wake_turbulence/__init__.py b/floris/simulation/wake_turbulence/__init__.py deleted file mode 100644 index 346bc15cb..000000000 --- a/floris/simulation/wake_turbulence/__init__.py +++ /dev/null @@ -1,18 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -from floris.simulation.wake_turbulence.crespo_hernandez import CrespoHernandez -from floris.simulation.wake_turbulence.none import NoneWakeTurbulence -from floris.simulation.wake_turbulence.wake_induced_mixing import WakeInducedMixing diff --git a/floris/simulation/wake_velocity/__init__.py b/floris/simulation/wake_velocity/__init__.py deleted file mode 100644 index f551f5be8..000000000 --- a/floris/simulation/wake_velocity/__init__.py +++ /dev/null @@ -1,21 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -from floris.simulation.wake_velocity.cumulative_gauss_curl import CumulativeGaussCurlVelocityDeficit -from floris.simulation.wake_velocity.empirical_gauss import EmpiricalGaussVelocityDeficit -from floris.simulation.wake_velocity.gauss import GaussVelocityDeficit -from floris.simulation.wake_velocity.jensen import JensenVelocityDeficit -from floris.simulation.wake_velocity.none import NoneVelocityDeficit -from floris.simulation.wake_velocity.turbopark import TurbOParkVelocityDeficit diff --git a/floris/tools/__init__.py b/floris/tools/__init__.py deleted file mode 100644 index 6a2cca91b..000000000 --- a/floris/tools/__init__.py +++ /dev/null @@ -1,63 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -""" -The :py:obj:`floris.tools` package contains the modules used to drive -FLORIS simulations and perform studies in various areas of research and -analysis. - -All modules can be imported with - - >>> import floris.tools - -The ``__init__.py`` file enables the import of all modules in this -package so any additional modules should be included there. - -Examples: - >>> import floris.tools - - >>> dir(floris.tools) - ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', - '__name__', '__package__', '__path__', '__spec__', 'cut_plane', - 'floris_interface', - 'layout_functions', 'optimization', 'plotting', 'power_rose', - 'rews', 'visualization', 'wind_rose'] -""" - -from .floris_interface import FlorisInterface -from .floris_interface_legacy_reader import FlorisInterfaceLegacyV2 -from .parallel_computing_interface import ParallelComputingInterface -from .uncertainty_interface import UncertaintyInterface -from .visualization import ( - plot_rotor_values, - plot_turbines_with_fi, - visualize_cut_plane, - visualize_quiver, -) -from .wind_rose import WindRose - - -# from floris.tools import ( - # cut_plane, - # floris_interface, - # interface_utilities, - # layout_functions, - # optimization, - # plotting, - # power_rose, - # rews, - # visualization, - # wind_rose, -# ) diff --git a/floris/tools/floris_interface.py b/floris/tools/floris_interface.py deleted file mode 100644 index a466ad583..000000000 --- a/floris/tools/floris_interface.py +++ /dev/null @@ -1,1158 +0,0 @@ -# Copyright 2021 NREL -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -from __future__ import annotations - -import inspect -from pathlib import Path - -import numpy as np -import pandas as pd - -from floris.logging_manager import LoggingManager -from floris.simulation import Floris, State -from floris.simulation.turbine import ( - average_velocity, - axial_induction, - Ct, - power, - rotor_effective_velocity, -) -from floris.simulation.turbine_multi_dim import multidim_power_down_select, power_multidim -from floris.tools.cut_plane import CutPlane -from floris.type_dec import NDArrayFloat - - -class FlorisInterface(LoggingManager): - """ - FlorisInterface provides a high-level user interface to many of the - underlying methods within the FLORIS framework. It is meant to act as a - single entry-point for the majority of users, simplifying the calls to - methods on objects within FLORIS. - - Args: - configuration (:py:obj:`dict`): The Floris configuration dictionary or YAML file. - The configuration should have the following inputs specified. - - **flow_field**: See `floris.simulation.flow_field.FlowField` for more details. - - **farm**: See `floris.simulation.farm.Farm` for more details. - - **turbine**: See `floris.simulation.turbine.Turbine` for more details. - - **wake**: See `floris.simulation.wake.WakeManager` for more details. - - **logging**: See `floris.simulation.floris.Floris` for more details. - """ - - def __init__(self, configuration: dict | str | Path): - self.configuration = configuration - - if isinstance(self.configuration, (str, Path)): - try: - self.floris = Floris.from_file(self.configuration) - except FileNotFoundError: - # If the file cannot be found, then attempt the configuration path relative to the - # file location from which FlorisInterface was attempted to be run. If successful, - # update self.configuration to an absolute, working file path and name. - base_fn = Path(inspect.stack()[-1].filename).resolve().parent - config = (base_fn / self.configuration).resolve() - self.floris = Floris.from_file(config) - self.configuration = config - - elif isinstance(self.configuration, dict): - self.floris = Floris.from_dict(self.configuration) - - else: - raise TypeError("The Floris `configuration` must be of type 'dict', 'str', or 'Path'.") - - # If ref height is -1, assign the hub height - if np.abs(self.floris.flow_field.reference_wind_height + 1.0) < 1.0e-6: - self.assign_hub_height_to_ref_height() - - # Make a check on reference height and provide a helpful warning - unique_heights = np.unique(np.round(self.floris.farm.hub_heights, decimals=6)) - if (( - len(unique_heights) == 1) and - (np.abs(self.floris.flow_field.reference_wind_height - unique_heights[0]) > 1.0e-6 - )): - err_msg = ( - "The only unique hub-height is not the equal to the specified reference " - "wind height. If this was unintended use -1 as the reference hub height to " - " indicate use of hub-height as reference wind height." - ) - self.logger.warning(err_msg, stack_info=True) - - # Check the turbine_grid_points is reasonable - if self.floris.solver["type"] == "turbine_grid": - if self.floris.solver["turbine_grid_points"] > 3: - self.logger.error( - f"turbine_grid_points value is {self.floris.solver['turbine_grid_points']} " - "which is larger than the recommended value of less than or equal to 3. " - "High amounts of turbine grid points reduce the computational performance " - "but have a small change on accuracy." - ) - raise ValueError("turbine_grid_points must be less than or equal to 3.") - - def assign_hub_height_to_ref_height(self): - - # Confirm can do this operation - unique_heights = np.unique(self.floris.farm.hub_heights) - if len(unique_heights) > 1: - raise ValueError( - "To assign hub heights to reference height, can not have more than one " - "specified height. " - f"Current length is {unique_heights}." - ) - - self.floris.flow_field.reference_wind_height = unique_heights[0] - - def copy(self): - """Create an independent copy of the current FlorisInterface object""" - return FlorisInterface(self.floris.as_dict()) - - def calculate_wake( - self, - yaw_angles: NDArrayFloat | list[float] | None = None, - # tilt_angles: NDArrayFloat | list[float] | None = None, - ) -> None: - """ - Wrapper to the :py:meth:`~.Farm.set_yaw_angles` and - :py:meth:`~.FlowField.calculate_wake` methods. - - Args: - yaw_angles (NDArrayFloat | list[float] | None, optional): Turbine yaw angles. - Defaults to None. - """ - - if yaw_angles is None: - yaw_angles = np.zeros( - ( - self.floris.flow_field.n_wind_directions, - self.floris.flow_field.n_wind_speeds, - self.floris.farm.n_turbines - ) - ) - self.floris.farm.yaw_angles = yaw_angles - - # # TODO is this required? - # if tilt_angles is not None: - # self.floris.farm.tilt_angles = tilt_angles - # else: - # self.floris.farm.set_tilt_to_ref_tilt( - # self.floris.flow_field.n_wind_directions, - # self.floris.flow_field.n_wind_speeds - # ) - - # Initialize solution space - self.floris.initialize_domain() - - # Perform the wake calculations - self.floris.steady_state_atmospheric_condition() - - def calculate_no_wake( - self, - yaw_angles: NDArrayFloat | list[float] | None = None, - ) -> None: - """ - This function is similar to `calculate_wake()` except - that it does not apply a wake model. That is, the wind - farm is modeled as if there is no wake in the flow. - Yaw angles are used to reduce the power and thrust of - the turbine that is yawed. - - Args: - yaw_angles (NDArrayFloat | list[float] | None, optional): Turbine yaw angles. - Defaults to None. - """ - - if yaw_angles is None: - yaw_angles = np.zeros( - ( - self.floris.flow_field.n_wind_directions, - self.floris.flow_field.n_wind_speeds, - self.floris.farm.n_turbines - ) - ) - self.floris.farm.yaw_angles = yaw_angles - - # Initialize solution space - self.floris.initialize_domain() - - # Finalize values to user-supplied order - self.floris.finalize() - - def reinitialize( - self, - wind_speeds: list[float] | NDArrayFloat | None = None, - wind_directions: list[float] | NDArrayFloat | None = None, - wind_shear: float | None = None, - wind_veer: float | None = None, - reference_wind_height: float | None = None, - turbulence_intensity: float | None = None, - # turbulence_kinetic_energy=None, - air_density: float | None = None, - # wake: WakeModelManager = None, - layout_x: list[float] | NDArrayFloat | None = None, - layout_y: list[float] | NDArrayFloat | None = None, - turbine_type: list | None = None, - turbine_library_path: str | Path | None = None, - solver_settings: dict | None = None, - time_series: bool = False, - heterogenous_inflow_config=None, - ): - # Export the floris object recursively as a dictionary - floris_dict = self.floris.as_dict() - flow_field_dict = floris_dict["flow_field"] - farm_dict = floris_dict["farm"] - - # Make the given changes - - ## FlowField - if wind_speeds is not None: - flow_field_dict["wind_speeds"] = wind_speeds - if wind_directions is not None: - flow_field_dict["wind_directions"] = wind_directions - if wind_shear is not None: - flow_field_dict["wind_shear"] = wind_shear - if wind_veer is not None: - flow_field_dict["wind_veer"] = wind_veer - if reference_wind_height is not None: - flow_field_dict["reference_wind_height"] = reference_wind_height - if turbulence_intensity is not None: - flow_field_dict["turbulence_intensity"] = turbulence_intensity - if air_density is not None: - flow_field_dict["air_density"] = air_density - if heterogenous_inflow_config is not None: - flow_field_dict["heterogenous_inflow_config"] = heterogenous_inflow_config - - ## Farm - if layout_x is not None: - farm_dict["layout_x"] = layout_x - if layout_y is not None: - farm_dict["layout_y"] = layout_y - if turbine_type is not None: - farm_dict["turbine_type"] = turbine_type - if turbine_library_path is not None: - farm_dict["turbine_library_path"] = turbine_library_path - - flow_field_dict["time_series"] = time_series - - ## Wake - # if wake is not None: - # self.floris.wake = wake - # if turbulence_kinetic_energy is not None: - # pass # TODO: not needed until GCH - - if solver_settings is not None: - floris_dict["solver"] = solver_settings - - floris_dict["flow_field"] = flow_field_dict - floris_dict["farm"] = farm_dict - - # Create a new instance of floris and attach to self - self.floris = Floris.from_dict(floris_dict) - - def get_plane_of_points( - self, - normal_vector="z", - planar_coordinate=None, - ): - """ - Calculates velocity values through the - :py:meth:`FlorisInterface.calculate_wake` method at points in plane - specified by inputs. - - Args: - normal_vector (string, optional): Vector normal to plane. - Defaults to z. - planar_coordinate (float, optional): Value of normal vector - to slice through. Defaults to None. - - Returns: - :py:class:`pandas.DataFrame`: containing values of x1, x2, x3, u, v, w - """ - # Get results vectors - if (normal_vector == "z"): - x_flat = self.floris.grid.x_sorted_inertial_frame[0, 0].flatten() - y_flat = self.floris.grid.y_sorted_inertial_frame[0, 0].flatten() - z_flat = self.floris.grid.z_sorted_inertial_frame[0, 0].flatten() - else: - x_flat = self.floris.grid.x_sorted[0, 0].flatten() - y_flat = self.floris.grid.y_sorted[0, 0].flatten() - z_flat = self.floris.grid.z_sorted[0, 0].flatten() - u_flat = self.floris.flow_field.u_sorted[0, 0].flatten() - v_flat = self.floris.flow_field.v_sorted[0, 0].flatten() - w_flat = self.floris.flow_field.w_sorted[0, 0].flatten() - - # Create a df of these - if normal_vector == "z": - df = pd.DataFrame( - { - "x1": x_flat, - "x2": y_flat, - "x3": z_flat, - "u": u_flat, - "v": v_flat, - "w": w_flat, - } - ) - if normal_vector == "x": - df = pd.DataFrame( - { - "x1": y_flat, - "x2": z_flat, - "x3": x_flat, - "u": u_flat, - "v": v_flat, - "w": w_flat, - } - ) - if normal_vector == "y": - df = pd.DataFrame( - { - "x1": x_flat, - "x2": z_flat, - "x3": y_flat, - "u": u_flat, - "v": v_flat, - "w": w_flat, - } - ) - - # Subset to plane - # TODO: Seems sloppy as need more than one plane in the z-direction for GCH - if planar_coordinate is not None: - df = df[np.isclose(df.x3, planar_coordinate)] # , atol=0.1, rtol=0.0)] - - # Drop duplicates - # TODO is this still needed now that we setup a grid for just this plane? - df = df.drop_duplicates() - - # Sort values of df to make sure plotting is acceptable - df = df.sort_values(["x2", "x1"]).reset_index(drop=True) - - return df - - def calculate_horizontal_plane( - self, - height, - x_resolution=200, - y_resolution=200, - x_bounds=None, - y_bounds=None, - wd=None, - ws=None, - yaw_angles=None, - ): - """ - Shortcut method to instantiate a :py:class:`~.tools.cut_plane.CutPlane` - object containing the velocity field in a horizontal plane cut through - the simulation domain at a specific height. - - Args: - height (float): Height of cut plane. Defaults to Hub-height. - x_resolution (float, optional): Output array resolution. - Defaults to 200 points. - y_resolution (float, optional): Output array resolution. - Defaults to 200 points. - x_bounds (tuple, optional): Limits of output array (in m). - Defaults to None. - y_bounds (tuple, optional): Limits of output array (in m). - Defaults to None. - - Returns: - :py:class:`~.tools.cut_plane.CutPlane`: containing values - of x, y, u, v, w - """ - # TODO update docstring - if wd is None: - wd = self.floris.flow_field.wind_directions - if ws is None: - ws = self.floris.flow_field.wind_speeds - self.check_wind_condition_for_viz(wd=wd, ws=ws) - - # Store the current state for reinitialization - floris_dict = self.floris.as_dict() - current_yaw_angles = self.floris.farm.yaw_angles - - # Set the solver to a flow field planar grid - solver_settings = { - "type": "flow_field_planar_grid", - "normal_vector": "z", - "planar_coordinate": height, - "flow_field_grid_points": [x_resolution, y_resolution], - "flow_field_bounds": [x_bounds, y_bounds], - } - self.reinitialize(wind_directions=wd, wind_speeds=ws, solver_settings=solver_settings) - - # TODO this has to be done here as it seems to be lost with reinitialize - if yaw_angles is not None: - self.floris.farm.yaw_angles = yaw_angles - - # Calculate wake - self.floris.solve_for_viz() - - # Get the points of data in a dataframe - # TODO this just seems to be flattening and storing the data in a df; is this necessary? - # It seems the biggest depenedcy is on CutPlane and the subsequent visualization tools. - df = self.get_plane_of_points( - normal_vector="z", - planar_coordinate=height, - ) - - # Compute the cutplane - horizontal_plane = CutPlane( - df, - self.floris.grid.grid_resolution[0], - self.floris.grid.grid_resolution[1], - "z" - ) - - # Reset the fi object back to the turbine grid configuration - self.floris = Floris.from_dict(floris_dict) - - # Run the simulation again for futher postprocessing (i.e. now we can get farm power) - self.calculate_wake(yaw_angles=current_yaw_angles) - - return horizontal_plane - - def calculate_cross_plane( - self, - downstream_dist, - y_resolution=200, - z_resolution=200, - y_bounds=None, - z_bounds=None, - wd=None, - ws=None, - yaw_angles=None, - ): - """ - Shortcut method to instantiate a :py:class:`~.tools.cut_plane.CutPlane` - object containing the velocity field in a horizontal plane cut through - the simulation domain at a specific height. - - Args: - height (float): Height of cut plane. Defaults to Hub-height. - x_resolution (float, optional): Output array resolution. - Defaults to 200 points. - y_resolution (float, optional): Output array resolution. - Defaults to 200 points. - x_bounds (tuple, optional): Limits of output array (in m). - Defaults to None. - y_bounds (tuple, optional): Limits of output array (in m). - Defaults to None. - - Returns: - :py:class:`~.tools.cut_plane.CutPlane`: containing values - of x, y, u, v, w - """ - # TODO update docstring - if wd is None: - wd = self.floris.flow_field.wind_directions - if ws is None: - ws = self.floris.flow_field.wind_speeds - self.check_wind_condition_for_viz(wd=wd, ws=ws) - - # Store the current state for reinitialization - floris_dict = self.floris.as_dict() - current_yaw_angles = self.floris.farm.yaw_angles - - # Set the solver to a flow field planar grid - solver_settings = { - "type": "flow_field_planar_grid", - "normal_vector": "x", - "planar_coordinate": downstream_dist, - "flow_field_grid_points": [y_resolution, z_resolution], - "flow_field_bounds": [y_bounds, z_bounds], - } - self.reinitialize(wind_directions=wd, wind_speeds=ws, solver_settings=solver_settings) - - # TODO this has to be done here as it seems to be lost with reinitialize - if yaw_angles is not None: - self.floris.farm.yaw_angles = yaw_angles - - # Calculate wake - self.floris.solve_for_viz() - - # Get the points of data in a dataframe - # TODO this just seems to be flattening and storing the data in a df; is this necessary? - # It seems the biggest depenedcy is on CutPlane and the subsequent visualization tools. - df = self.get_plane_of_points( - normal_vector="x", - planar_coordinate=downstream_dist, - ) - - # Compute the cutplane - cross_plane = CutPlane(df, y_resolution, z_resolution, "x") - - # Reset the fi object back to the turbine grid configuration - self.floris = Floris.from_dict(floris_dict) - - # Run the simulation again for futher postprocessing (i.e. now we can get farm power) - self.calculate_wake(yaw_angles=current_yaw_angles) - - return cross_plane - - def calculate_y_plane( - self, - crossstream_dist, - x_resolution=200, - z_resolution=200, - x_bounds=None, - z_bounds=None, - wd=None, - ws=None, - yaw_angles=None, - ): - """ - Shortcut method to instantiate a :py:class:`~.tools.cut_plane.CutPlane` - object containing the velocity field in a horizontal plane cut through - the simulation domain at a specific height. - - Args: - height (float): Height of cut plane. Defaults to Hub-height. - x_resolution (float, optional): Output array resolution. - Defaults to 200 points. - y_resolution (float, optional): Output array resolution. - Defaults to 200 points. - x_bounds (tuple, optional): Limits of output array (in m). - Defaults to None. - y_bounds (tuple, optional): Limits of output array (in m). - Defaults to None. - - Returns: - :py:class:`~.tools.cut_plane.CutPlane`: containing values - of x, y, u, v, w - """ - # TODO update docstring - if wd is None: - wd = self.floris.flow_field.wind_directions - if ws is None: - ws = self.floris.flow_field.wind_speeds - self.check_wind_condition_for_viz(wd=wd, ws=ws) - - # Store the current state for reinitialization - floris_dict = self.floris.as_dict() - current_yaw_angles = self.floris.farm.yaw_angles - - # Set the solver to a flow field planar grid - solver_settings = { - "type": "flow_field_planar_grid", - "normal_vector": "y", - "planar_coordinate": crossstream_dist, - "flow_field_grid_points": [x_resolution, z_resolution], - "flow_field_bounds": [x_bounds, z_bounds], - } - self.reinitialize(wind_directions=wd, wind_speeds=ws, solver_settings=solver_settings) - - # TODO this has to be done here as it seems to be lost with reinitialize - if yaw_angles is not None: - self.floris.farm.yaw_angles = yaw_angles - - # Calculate wake - self.floris.solve_for_viz() - - # Get the points of data in a dataframe - # TODO this just seems to be flattening and storing the data in a df; is this necessary? - # It seems the biggest depenedcy is on CutPlane and the subsequent visualization tools. - df = self.get_plane_of_points( - normal_vector="y", - planar_coordinate=crossstream_dist, - ) - - # Compute the cutplane - y_plane = CutPlane(df, x_resolution, z_resolution, "y") - - # Reset the fi object back to the turbine grid configuration - self.floris = Floris.from_dict(floris_dict) - - # Run the simulation again for futher postprocessing (i.e. now we can get farm power) - self.calculate_wake(yaw_angles=current_yaw_angles) - - return y_plane - - def check_wind_condition_for_viz(self, wd=None, ws=None): - if len(wd) > 1 or len(wd) < 1: - raise ValueError( - "Wind direction input must be of length 1 for visualization. " - f"Current length is {len(wd)}." - ) - - if len(ws) > 1 or len(ws) < 1: - raise ValueError( - "Wind speed input must be of length 1 for visualization. " - f"Current length is {len(ws)}." - ) - - def get_turbine_powers(self) -> NDArrayFloat: - """Calculates the power at each turbine in the wind farm. - - Returns: - NDArrayFloat: Powers at each turbine. - """ - - # Confirm calculate wake has been run - if self.floris.state is not State.USED: - raise RuntimeError( - "Can't run function `FlorisInterface.get_turbine_powers` without " - "first running `FlorisInterface.calculate_wake`." - ) - # Check for negative velocities, which could indicate bad model - # parameters or turbines very closely spaced. - if (self.turbine_effective_velocities < 0.).any(): - self.logger.warning("Some rotor effective velocities are negative.") - - turbine_powers = power( - ref_density_cp_ct=self.floris.farm.ref_density_cp_cts, - rotor_effective_velocities=self.turbine_effective_velocities, - power_interp=self.floris.farm.turbine_power_interps, - turbine_type_map=self.floris.farm.turbine_type_map, - ) - return turbine_powers - - def get_turbine_powers_multidim(self) -> NDArrayFloat: - """Calculates the power at each turbine in the wind farm - when using multi-dimensional Cp/Ct turbine definitions. - - Returns: - NDArrayFloat: Powers at each turbine. - """ - - # Confirm calculate wake has been run - if self.floris.state is not State.USED: - raise RuntimeError( - "Can't run function `FlorisInterface.get_turbine_powers_multidim` without " - "first running `FlorisInterface.calculate_wake`." - ) - # Check for negative velocities, which could indicate bad model - # parameters or turbines very closely spaced. - if (self.turbine_effective_velocities < 0.).any(): - self.logger.warning("Some rotor effective velocities are negative.") - - turbine_power_interps = multidim_power_down_select( - self.floris.farm.turbine_power_interps, - self.floris.flow_field.multidim_conditions - ) - - turbine_powers = power_multidim( - ref_density_cp_ct=self.floris.farm.ref_density_cp_cts, - rotor_effective_velocities=self.turbine_effective_velocities, - power_interp=turbine_power_interps, - ) - return turbine_powers - - def get_turbine_Cts(self) -> NDArrayFloat: - turbine_Cts = Ct( - velocities=self.floris.flow_field.u, - yaw_angle=self.floris.farm.yaw_angles, - tilt_angle=self.floris.farm.tilt_angles, - ref_tilt_cp_ct=self.floris.farm.ref_tilt_cp_cts, - fCt=self.floris.farm.turbine_fCts, - tilt_interp=self.floris.farm.turbine_tilt_interps, - correct_cp_ct_for_tilt=self.floris.farm.correct_cp_ct_for_tilt, - turbine_type_map=self.floris.farm.turbine_type_map, - average_method=self.floris.grid.average_method, - cubature_weights=self.floris.grid.cubature_weights, - ) - return turbine_Cts - - def get_turbine_ais(self) -> NDArrayFloat: - turbine_ais = axial_induction( - velocities=self.floris.flow_field.u, - yaw_angle=self.floris.farm.yaw_angles, - tilt_angle=self.floris.farm.tilt_angles, - ref_tilt_cp_ct=self.floris.farm.ref_tilt_cp_cts, - fCt=self.floris.farm.turbine_fCts, - tilt_interp=self.floris.farm.turbine_tilt_interps, - correct_cp_ct_for_tilt=self.floris.farm.correct_cp_ct_for_tilt, - turbine_type_map=self.floris.farm.turbine_type_map, - average_method=self.floris.grid.average_method, - cubature_weights=self.floris.grid.cubature_weights, - ) - return turbine_ais - - @property - def turbine_average_velocities(self) -> NDArrayFloat: - return average_velocity( - velocities=self.floris.flow_field.u, - method=self.floris.grid.average_method, - cubature_weights=self.floris.grid.cubature_weights - ) - - @property - def turbine_effective_velocities(self) -> NDArrayFloat: - rotor_effective_velocities = rotor_effective_velocity( - air_density=self.floris.flow_field.air_density, - ref_density_cp_ct=self.floris.farm.ref_density_cp_cts, - velocities=self.floris.flow_field.u, - yaw_angle=self.floris.farm.yaw_angles, - tilt_angle=self.floris.farm.tilt_angles, - ref_tilt_cp_ct=self.floris.farm.ref_tilt_cp_cts, - pP=self.floris.farm.pPs, - pT=self.floris.farm.pTs, - tilt_interp=self.floris.farm.turbine_tilt_interps, - correct_cp_ct_for_tilt=self.floris.farm.correct_cp_ct_for_tilt, - turbine_type_map=self.floris.farm.turbine_type_map, - average_method=self.floris.grid.average_method, - cubature_weights=self.floris.grid.cubature_weights - ) - return rotor_effective_velocities - - def get_turbine_TIs(self) -> NDArrayFloat: - return self.floris.flow_field.turbulence_intensity_field - - def get_farm_power( - self, - turbine_weights=None, - use_turbulence_correction=False, - ): - """ - Report wind plant power from instance of floris. Optionally includes - uncertainty in wind direction and yaw position when determining power. - Uncertainty is included by computing the mean wind farm power for a - distribution of wind direction and yaw position deviations from the - original wind direction and yaw angles. - - Args: - turbine_weights (NDArrayFloat | list[float] | None, optional): - weighing terms that allow the user to emphasize power at - particular turbines and/or completely ignore the power - from other turbines. This is useful when, for example, you are - modeling multiple wind farms in a single floris object. If you - only want to calculate the power production for one of those - farms and include the wake effects of the neighboring farms, - you can set the turbine_weights for the neighboring farms' - turbines to 0.0. The array of turbine powers from floris - is multiplied with this array in the calculation of the - objective function. If None, this is an array with all values - 1.0 and with shape equal to (n_wind_directions, n_wind_speeds, - n_turbines). Defaults to None. - use_turbulence_correction: (bool, optional): When *True* uses a - turbulence parameter to adjust power output calculations. - Defaults to *False*. - - Returns: - float: Sum of wind turbine powers in W. - """ - # TODO: Turbulence correction used in the power calculation, but may not be in - # the model yet - # TODO: Turbines need a switch for using turbulence correction - # TODO: Uncomment out the following two lines once the above are resolved - # for turbine in self.floris.farm.turbines: - # turbine.use_turbulence_correction = use_turbulence_correction - - # Confirm calculate wake has been run - if self.floris.state is not State.USED: - raise RuntimeError( - "Can't run function `FlorisInterface.get_turbine_powers` without " - "first running `FlorisInterface.calculate_wake`." - ) - - if turbine_weights is None: - # Default to equal weighing of all turbines when turbine_weights is None - turbine_weights = np.ones( - ( - self.floris.flow_field.n_wind_directions, - self.floris.flow_field.n_wind_speeds, - self.floris.farm.n_turbines - ) - ) - elif len(np.shape(turbine_weights)) == 1: - # Deal with situation when 1D array is provided - turbine_weights = np.tile( - turbine_weights, - ( - self.floris.flow_field.n_wind_directions, - self.floris.flow_field.n_wind_speeds, - 1 - ) - ) - - # Calculate all turbine powers and apply weights - turbine_powers = self.get_turbine_powers() - turbine_powers = np.multiply(turbine_weights, turbine_powers) - - return np.sum(turbine_powers, axis=2) - - def get_farm_AEP( - self, - freq, - cut_in_wind_speed=0.001, - cut_out_wind_speed=None, - yaw_angles=None, - turbine_weights=None, - no_wake=False, - ) -> float: - """ - Estimate annual energy production (AEP) for distributions of wind speed, wind - direction, frequency of occurrence, and yaw offset. - - Args: - freq (NDArrayFloat): NumPy array with shape (n_wind_directions, - n_wind_speeds) with the frequencies of each wind direction and - wind speed combination. These frequencies should typically sum - up to 1.0 and are used to weigh the wind farm power for every - condition in calculating the wind farm's AEP. - cut_in_wind_speed (float, optional): Wind speed in m/s below which - any calculations are ignored and the wind farm is known to - produce 0.0 W of power. Note that to prevent problems with the - wake models at negative / zero wind speeds, this variable must - always have a positive value. Defaults to 0.001 [m/s]. - cut_out_wind_speed (float, optional): Wind speed above which the - wind farm is known to produce 0.0 W of power. If None is - specified, will assume that the wind farm does not cut out - at high wind speeds. Defaults to None. - yaw_angles (NDArrayFloat | list[float] | None, optional): - The relative turbine yaw angles in degrees. If None is - specified, will assume that the turbine yaw angles are all - zero degrees for all conditions. Defaults to None. - turbine_weights (NDArrayFloat | list[float] | None, optional): - weighing terms that allow the user to emphasize power at - particular turbines and/or completely ignore the power - from other turbines. This is useful when, for example, you are - modeling multiple wind farms in a single floris object. If you - only want to calculate the power production for one of those - farms and include the wake effects of the neighboring farms, - you can set the turbine_weights for the neighboring farms' - turbines to 0.0. The array of turbine powers from floris - is multiplied with this array in the calculation of the - objective function. If None, this is an array with all values - 1.0 and with shape equal to (n_wind_directions, n_wind_speeds, - n_turbines). Defaults to None. - no_wake: (bool, optional): When *True* updates the turbine - quantities without calculating the wake or adding the wake to - the flow field. This can be useful when quantifying the loss - in AEP due to wakes. Defaults to *False*. - - Returns: - float: - The Annual Energy Production (AEP) for the wind farm in - watt-hours. - """ - - # Verify dimensions of the variable "freq" - if not ( - (np.shape(freq)[0] == self.floris.flow_field.n_wind_directions) - & (np.shape(freq)[1] == self.floris.flow_field.n_wind_speeds) - & (len(np.shape(freq)) == 2) - ): - raise UserWarning( - "'freq' should be a two-dimensional array with dimensions " - " (n_wind_directions, n_wind_speeds)." - ) - - # Check if frequency vector sums to 1.0. If not, raise a warning - if np.abs(np.sum(freq) - 1.0) > 0.001: - self.logger.warning( - "WARNING: The frequency array provided to get_farm_AEP() " - "does not sum to 1.0." - ) - - # Copy the full wind speed array from the floris object and initialize - # the the farm_power variable as an empty array. - wind_speeds = np.array(self.floris.flow_field.wind_speeds, copy=True) - farm_power = np.zeros((self.floris.flow_field.n_wind_directions, len(wind_speeds))) - - # Determine which wind speeds we must evaluate in floris - conditions_to_evaluate = wind_speeds >= cut_in_wind_speed - if cut_out_wind_speed is not None: - conditions_to_evaluate = conditions_to_evaluate & (wind_speeds < cut_out_wind_speed) - - # Evaluate the conditions in floris - if np.any(conditions_to_evaluate): - wind_speeds_subset = wind_speeds[conditions_to_evaluate] - yaw_angles_subset = None - if yaw_angles is not None: - yaw_angles_subset = yaw_angles[:, conditions_to_evaluate] - self.reinitialize(wind_speeds=wind_speeds_subset) - if no_wake: - self.calculate_no_wake(yaw_angles=yaw_angles_subset) - else: - self.calculate_wake(yaw_angles=yaw_angles_subset) - farm_power[:, conditions_to_evaluate] = ( - self.get_farm_power(turbine_weights=turbine_weights) - ) - - # Finally, calculate AEP in GWh - aep = np.sum(np.multiply(freq, farm_power) * 365 * 24) - - # Reset the FLORIS object to the full wind speed array - self.reinitialize(wind_speeds=wind_speeds) - - return aep - - def get_farm_AEP_wind_rose_class( - self, - wind_rose, - cut_in_wind_speed=0.001, - cut_out_wind_speed=None, - yaw_angles=None, - turbine_weights=None, - no_wake=False, - ) -> float: - """ - Estimate annual energy production (AEP) for distributions of wind speed, wind - direction, frequency of occurrence, and yaw offset. - - Args: - wind_rose (wind_rose): An object of the wind rose class - cut_in_wind_speed (float, optional): Wind speed in m/s below which - any calculations are ignored and the wind farm is known to - produce 0.0 W of power. Note that to prevent problems with the - wake models at negative / zero wind speeds, this variable must - always have a positive value. Defaults to 0.001 [m/s]. - cut_out_wind_speed (float, optional): Wind speed above which the - wind farm is known to produce 0.0 W of power. If None is - specified, will assume that the wind farm does not cut out - at high wind speeds. Defaults to None. - yaw_angles (NDArrayFloat | list[float] | None, optional): - The relative turbine yaw angles in degrees. If None is - specified, will assume that the turbine yaw angles are all - zero degrees for all conditions. Defaults to None. - turbine_weights (NDArrayFloat | list[float] | None, optional): - weighing terms that allow the user to emphasize power at - particular turbines and/or completely ignore the power - from other turbines. This is useful when, for example, you are - modeling multiple wind farms in a single floris object. If you - only want to calculate the power production for one of those - farms and include the wake effects of the neighboring farms, - you can set the turbine_weights for the neighboring farms' - turbines to 0.0. The array of turbine powers from floris - is multiplied with this array in the calculation of the - objective function. If None, this is an array with all values - 1.0 and with shape equal to (n_wind_directions, n_wind_speeds, - n_turbines). Defaults to None. - no_wake: (bool, optional): When *True* updates the turbine - quantities without calculating the wake or adding the wake to - the flow field. This can be useful when quantifying the loss - in AEP due to wakes. Defaults to *False*. - - Returns: - float: - The Annual Energy Production (AEP) for the wind farm in - watt-hours. - """ - - # Hold the starting values of wind speed and direction - wind_speeds = np.array(self.floris.flow_field.wind_speeds, copy=True) - wind_directions = np.array(self.floris.flow_field.wind_directions, copy=True) - - # Now set FLORIS wind speed and wind direction - # over to those values in the wind rose class - wind_speeds_wind_rose = wind_rose.df.ws.unique() - wind_directions_wind_rose = wind_rose.df.wd.unique() - self.reinitialize( - wind_speeds=wind_speeds_wind_rose, - wind_directions=wind_directions_wind_rose - ) - - # Build the frequency matrix from wind rose - freq = wind_rose.df.set_index(['wd','ws']).unstack().values - - # Now compute aep - aep = self.get_farm_AEP( - freq, - cut_in_wind_speed=cut_in_wind_speed, - cut_out_wind_speed=cut_out_wind_speed, - yaw_angles=yaw_angles, - turbine_weights=turbine_weights, - no_wake=no_wake) - - - # Reset the FLORIS object to the original wind speed and directions - self.reinitialize( - wind_speeds=wind_speeds, - wind_directions=wind_directions - ) - - return aep - - def sample_flow_at_points(self, x: NDArrayFloat, y: NDArrayFloat, z: NDArrayFloat): - """ - Extract the wind speed at points in the flow. - - Args: - x (1DArrayFloat | list): x-locations of points where flow is desired. - y (1DArrayFloat | list): y-locations of points where flow is desired. - z (1DArrayFloat | list): z-locations of points where flow is desired. - - Returns: - 3DArrayFloat containing wind speed with dimensions - (# of wind directions, # of wind speeds, # of sample points) - """ - - # Check that x, y, z are all the same length - if not len(x) == len(y) == len(z): - raise ValueError("x, y, and z must be the same size") - - return self.floris.solve_for_points(x, y, z) - - def sample_velocity_deficit_profiles( - self, - direction: str = 'cross-stream', - downstream_dists: NDArrayFloat | list = None, - profile_range: NDArrayFloat | list = None, - resolution: int = 100, - wind_direction: float = None, - homogeneous_wind_speed: float = None, - ref_rotor_diameter: float = None, - x_start: float = 0.0, - y_start: float = 0.0, - reference_height: float = None, - ) -> list[pd.DataFrame]: - """ - Extract velocity deficit profiles at a set of downstream distances from a starting point - (usually a turbine location). For each downstream distance, a profile is sampled along - a line in either the cross-stream direction (x2) or the vertical direction (x3). - Velocity deficit is here defined as (homogeneous_wind_speed - u)/homogeneous_wind_speed, - where u is the wake velocity obtained when wind_shear = 0.0. - - Args: - direction: At each downstream location, this is the direction in which to sample the - profile. Either `cross-stream` or `vertical`. - downstream_dists: A list/array of streamwise locations for where to sample the profiles. - Default starting point is (0.0, 0.0, reference_height). - profile_range: Determines the extent of the line along which the profiles are sampled. - The range is defined about a point which lies some distance directly downstream of - the starting point. - resolution: Number of sample points in each profile. - wind_direction: A single wind direction. - homogeneous_wind_speed: A single wind speed. It is called homogeneous since 'wind_shear' - is temporarily set to 0.0 in this method. - ref_rotor_diameter: A reference rotor diameter which is used to normalize the - coordinates. - x_start: x-coordinate of starting point. - y_start: y-coordinate of starting point. - reference_height: If `direction` is cross-stream, then `reference_height` defines the - height of the horizontal plane in which the velocity profiles are sampled. - If `direction` is vertical, then the velocity is sampled along the vertical - direction with the `profile_range` being relative to the `reference_height`. - Returns: - A list of pandas DataFrame objects where each DataFrame represents one velocity deficit - profile. - """ - - if direction not in ['cross-stream', 'vertical']: - raise ValueError("`direction` must be either `cross-stream` or `vertical`.") - - if ref_rotor_diameter is None: - unique_rotor_diameters = np.unique(self.floris.farm.rotor_diameters) - if len(unique_rotor_diameters) == 1: - ref_rotor_diameter = unique_rotor_diameters[0] - else: - raise ValueError( - "Please provide a `ref_rotor_diameter`. This is needed to normalize the " - "coordinates. Could not select a value automatically since the number of " - "unique rotor diameters in the turbine layout is not 1. " - f"Found the following rotor diameters: {unique_rotor_diameters}." - ) - - if downstream_dists is None: - downstream_dists = ref_rotor_diameter * np.array([3, 5, 7, 9]) - - if profile_range is None: - profile_range = ref_rotor_diameter * np.array([-2, 2]) - - wind_directions_copy = np.array(self.floris.flow_field.wind_directions, copy=True) - wind_speeds_copy = np.array(self.floris.flow_field.wind_speeds, copy=True) - wind_shear_copy = self.floris.flow_field.wind_shear - - if wind_direction is None: - if len(wind_directions_copy) == 1: - wind_direction = wind_directions_copy[0] - else: - raise ValueError( - "Could not determine a wind direction for which to sample the velocity " - "profiles. Either provide a single `wind_direction` as an argument to this " - "method, or initialize the Floris object with a single wind direction." - ) - - if homogeneous_wind_speed is None: - if len(wind_speeds_copy) == 1: - homogeneous_wind_speed = wind_speeds_copy[0] - self.logger.warning( - "`homogeneous_wind_speed` not provided. Setting it to the following wind speed " - f"found in the current flow field: {wind_speeds_copy[0]} m/s. Note that the " - "inflow is always homogeneous when calculating the velocity deficit profiles. " - "This is done by temporarily setting `wind_shear` to 0.0" - ) - else: - raise ValueError( - "Could not determine a wind speed for which to sample the velocity " - "profiles. Provide a single `homogeneous_wind_speed` to this method." - ) - - if reference_height is None: - reference_height = self.floris.flow_field.reference_wind_height - - self.reinitialize( - wind_directions=[wind_direction], - wind_speeds=[homogeneous_wind_speed], - wind_shear=0.0, - ) - - velocity_deficit_profiles = self.floris.solve_for_velocity_deficit_profiles( - direction, - downstream_dists, - profile_range, - resolution, - homogeneous_wind_speed, - ref_rotor_diameter, - x_start, - y_start, - reference_height, - ) - - self.reinitialize( - wind_directions=wind_directions_copy, - wind_speeds=wind_speeds_copy, - wind_shear=wind_shear_copy, - ) - - return velocity_deficit_profiles - - @property - def layout_x(self): - """ - Wind turbine coordinate information. - - Returns: - np.array: Wind turbine x-coordinate. - """ - return self.floris.farm.layout_x - - @property - def layout_y(self): - """ - Wind turbine coordinate information. - - Returns: - np.array: Wind turbine y-coordinate. - """ - return self.floris.farm.layout_y - - def get_turbine_layout(self, z=False): - """ - Get turbine layout - - Args: - z (bool): When *True*, return lists of x, y, and z coords, - otherwise, return x and y only. Defaults to *False*. - - Returns: - np.array: lists of x, y, and (optionally) z coordinates of - each turbine - """ - xcoords, ycoords, zcoords = self.floris.farm.coordinates.T - if z: - return xcoords, ycoords, zcoords - else: - return xcoords, ycoords diff --git a/floris/tools/floris_interface_legacy_reader.py b/floris/tools/floris_interface_legacy_reader.py deleted file mode 100644 index 83f0ef7e7..000000000 --- a/floris/tools/floris_interface_legacy_reader.py +++ /dev/null @@ -1,236 +0,0 @@ -# Copyright 2021 NREL -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -from __future__ import annotations - -import copy -import json -import os -from pathlib import Path - -from floris.tools import FlorisInterface - - -class FlorisInterfaceLegacyV2(FlorisInterface): - """ - FlorisInterface_legacy_v24 provides a wrapper around FlorisInterface - which enables compatibility of the class with legacy floris v2.4 input - files. The user can simply pass this class the path to a legacy v2.4 - floris input file to this class and it'll convert it to a v3.0-compatible - input dictionary and load the floris v3.0 object. - - After successfully loading the v3.0 Floris object, you can export the - input file using: fi.floris.to_file("converted_input_file_v3.yaml"). - An example of such a use case is demonstrated at the end of this file. - - If you would like to manually convert the input dictionary without first - loading it in FLORIS, or if somehow the code fails to automatically - convert the input file to v3, you should follow the following steps: - 1. Load the legacy v2.4 input floris JSON file as a dictionary - 2. Pass the v2.4 dictionary to `_convert_v24_dictionary_to_v3(...)`. - That will return a v3.0-compatible input dictionary and a turbine - dictionary. - 3. Save the converted configuration file to a YAML or JSON file. - - For example: - - import json, yaml - from floris.tools.floris_interface_legacy_reader import ( - _convert_v24_dictionary_to_v3 - ) - - with open() as legacy_dict_file: - configuration_v2 = json.load(legacy_dict_file) - fi_dict, turb_dict = _convert_v24_dictionary_to_v3(configuration_v2) - with open(r'fi_input_file_v3.yaml', 'w') as file: - yaml.dump(fi_dict, file) - with open(r'turbine_input_file_v3.yaml', 'w') as file: - yaml.dump(turb_dict, file) - - Args: - configuration (:py:obj:`dict`): The legacy v2.4 Floris configuration - dictionary or the file path to the JSON file. - """ - - def __init__(self, configuration: dict | str | Path, het_map=None): - - if not isinstance(configuration, (str, Path, dict)): - raise TypeError("The Floris `configuration` must of type 'dict', 'str', or 'Path'.") - - print("Importing and converting legacy floris v2.4 input file...") - if isinstance(configuration, (str, Path)): - with open(configuration) as legacy_dict_file: - configuration = json.load(legacy_dict_file) - - dict_fi, dict_turbine = _convert_v24_dictionary_to_v3(configuration) - super().__init__(dict_fi, het_map=het_map) # Initialize full class - - # Now overwrite turbine types - n_turbs = len(self.layout_x) - self.reinitialize(turbine_type=[dict_turbine] * n_turbs) - - -def _convert_v24_dictionary_to_v3(dict_legacy): - """ - Converts a v2.4 floris input dictionary file to a v3.0-compatible - dictionary. See detailed instructions in the class - FlorisInterface_legacy_v24. - - Args: - dict_legacy (dict): Input dictionary in legacy floris v2.4 format. - - Returns: - dict_floris (dict): Converted dictionary containing the floris input - settings in v3.0-compatible format. - dict_turbine (dict): A converted dictionary containing the turbine - settings in v3.0-compatible format. - """ - # Simple entries that can just be copied over - dict_floris = {} # Output dictionary - dict_floris["name"] = dict_legacy["name"] + " (auto-converted to v3)" - dict_floris["description"] = dict_legacy["description"] - dict_floris["floris_version"] = "v3.0 (converted from legacy format v2)" - dict_floris["logging"] = dict_legacy["logging"] - - dict_floris["solver"] = { - "type": "turbine_grid", - "turbine_grid_points": dict_legacy["turbine"]["properties"]["ngrid"], - } - - fp = dict_legacy["farm"]["properties"] - tp = dict_legacy["turbine"]["properties"] - dict_floris["farm"] = { - "layout_x": fp["layout_x"], - "layout_y": fp["layout_y"], - "turbine_type": ["nrel_5MW"] # Placeholder - } - - ref_height = fp["specified_wind_height"] - if ref_height < 0: - ref_height = tp["hub_height"] - - dict_floris["flow_field"] = { - "air_density": fp["air_density"], - "reference_wind_height": ref_height, - "turbulence_intensity": fp["turbulence_intensity"][0], - "wind_directions": [fp["wind_direction"]], - "wind_shear": fp["wind_shear"], - "wind_speeds": [fp["wind_speed"]], - "wind_veer": fp["wind_veer"], - } - - wp = dict_legacy["wake"]["properties"] - velocity_model = wp["velocity_model"] - velocity_model_str = velocity_model - if velocity_model == "gauss_legacy": - velocity_model_str = "gauss" - deflection_model = wp["deflection_model"] - turbulence_model = wp["turbulence_model"] - wdp = wp["parameters"]["wake_deflection_parameters"][deflection_model] - wvp = wp["parameters"]["wake_velocity_parameters"][velocity_model] - wtp = wp["parameters"]["wake_turbulence_parameters"][turbulence_model] - dict_floris["wake"] = { - "model_strings": { - "combination_model": wp["combination_model"], - "deflection_model": deflection_model, - "turbulence_model": turbulence_model, - "velocity_model": velocity_model_str, - }, - "enable_secondary_steering": wdp["use_secondary_steering"], - "enable_yaw_added_recovery": wvp["use_yaw_added_recovery"], - "enable_transverse_velocities": wvp["calculate_VW_velocities"], - } - - # Copy over wake velocity parameters and remove unnecessary parameters - velocity_subdict = copy.deepcopy(wvp) - c = ["calculate_VW_velocities", "use_yaw_added_recovery", "eps_gain"] - for ci in [ci for ci in c if ci in velocity_subdict.keys()]: - velocity_subdict.pop(ci) - - # Copy over wake deflection parameters and remove unnecessary parameters - deflection_subdict = copy.deepcopy(wdp) - c = ["use_secondary_steering"] - for ci in [ci for ci in c if ci in deflection_subdict.keys()]: - deflection_subdict.pop(ci) - - # Copy over wake turbulence parameters and remove unnecessary parameters - turbulence_subdict = copy.deepcopy(wtp) - - # Save parameter settings to wake dictionary - dict_floris["wake"]["wake_velocity_parameters"] = { - velocity_model_str: velocity_subdict - } - dict_floris["wake"]["wake_deflection_parameters"] = { - deflection_model: deflection_subdict - } - dict_floris["wake"]["wake_turbulence_parameters"] = { - turbulence_model: turbulence_subdict - } - - # Finally add turbine information - dict_turbine = { - "turbine_type": dict_legacy["turbine"]["name"], - "generator_efficiency": tp["generator_efficiency"], - "hub_height": tp["hub_height"], - "pP": tp["pP"], - "pT": tp["pT"], - "rotor_diameter": tp["rotor_diameter"], - "TSR": tp["TSR"], - "power_thrust_table": tp["power_thrust_table"], - "ref_density_cp_ct": 1.225 # This was implicit in the former input file - } - - return dict_floris, dict_turbine - - -if __name__ == "__main__": - """ - When this file is ran as a script, it'll convert a legacy FLORIS v2.4 - legacy input file (.json) to a v3.0-compatible input file (.yaml). - Please specify your input and output paths accordingly, and it will - produce the necessary file. - """ - import argparse - - # Parse the input arguments - description = "Converts a FLORIS v2.4 input file to a FLORIS v3 compatible input file.\ - The file format is changed from JSON to YAML and all inputs are mapped, as needed." - - parser = argparse.ArgumentParser(description=description) - parser.add_argument("-i", - "--input-file", - nargs=1, - required=True, - help="Path to the legacy input file") - parser.add_argument("-o", - "--output-file", - nargs="?", - default=None, - help="Path to write the output file") - args = parser.parse_args() - - # Specify paths - legacy_json_path = Path(args.input_file[0]) - if args.output_file: - floris_yaml_output_path = args.output_file - else: - floris_yaml_output_path = legacy_json_path.stem + ".yaml" - - # Load legacy input .json file into V3 object - fi = FlorisInterfaceLegacyV2(legacy_json_path) - - # Create output directory and save converted input file - fi.floris.to_file(floris_yaml_output_path) - - print(f"Converted file saved to: {floris_yaml_output_path}") diff --git a/floris/tools/interface_utilities.py b/floris/tools/interface_utilities.py deleted file mode 100644 index 3a02b6960..000000000 --- a/floris/tools/interface_utilities.py +++ /dev/null @@ -1,269 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -import inspect - - -def show_params( - fi, - params=None, - verbose=False, - wake_velocity_model=True, - wake_deflection_model=True, - turbulence_model=True, -): - - if wake_velocity_model: - obj = "fi.floris.wake.velocity_model" - # props = get_props(obj, fi) - props = fi.floris.wake._asdict() - # props = props["wake_velocity_parameters"][fi.floris.wake.velocity_model.model_string] - # NOTE: _get_model_dict is remove and model.as_dict() should be used instead - props = fi.floris.wake.velocity_model._get_model_dict() - - if verbose: - print("=".join(["="] * 39)) - else: - print("=".join(["="] * 19)) - print( - "Wake Velocity Model Parameters:", - fi.floris.wake.velocity_model.model_string, - "model", - ) - - if params is not None: - props_subset = get_props_subset(params, props) - if not verbose: - print_props(obj, fi, props_subset) - else: - print_prop_docs(obj, fi, props_subset) - - else: - if not verbose: - print_props(obj, fi, props) - else: - print_prop_docs(obj, fi, props) - - if wake_deflection_model: - obj = "fi.floris.wake.deflection_model" - props = get_props(obj, fi) - - if verbose: - print("=".join(["="] * 39)) - else: - print("=".join(["="] * 19)) - print( - "Wake Deflection Model Parameters:", - fi.floris.wake.deflection_model.model_string, - "model", - ) - - if params is not None: - props_subset = get_props_subset(params, props) - if props_subset: # true if the subset is not empty - if not verbose: - print_props(obj, fi, props_subset) - else: - print_prop_docs(obj, fi, props_subset) - - else: - if not verbose: - print_props(obj, fi, props) - else: - print_prop_docs(obj, fi, props) - - if turbulence_model: - obj = "fi.floris.wake.turbulence_model" - props = get_props(obj, fi) - - if verbose: - print("=".join(["="] * 39)) - else: - print("=".join(["="] * 19)) - print( - "Wake Turbulence Model Parameters:", - fi.floris.wake.turbulence_model.model_string, - "model", - ) - - if params is not None: - props_subset = get_props_subset(params, props) - if props_subset: # true if the subset is not empty - if not verbose: - print_props(obj, fi, props_subset) - else: - print_prop_docs(obj, fi, props_subset) - - else: - if not verbose: - print_props(obj, fi, props) - else: - print_prop_docs(obj, fi, props) - - -def get_params( - fi, - params=None, - wake_velocity_model=True, - wake_deflection_model=True, - turbulence_model=True, -): - model_params = {} - - if wake_velocity_model: - wake_vel_vals = {} - obj = "fi.floris.farm.wake.velocity_model" - props = get_props(obj, fi) - if params is not None: - props_subset = get_props_subset(params, props) - wake_vel_vals = get_prop_values(obj, fi, props_subset) - else: - wake_vel_vals = get_prop_values(obj, fi, props) - model_params["Wake Velocity Parameters"] = wake_vel_vals - del model_params["Wake Velocity Parameters"]["logger"] - - if wake_deflection_model: - wake_defl_vals = {} - obj = "fi.floris.farm.wake.deflection_model" - props = get_props(obj, fi) - if params is not None: - props_subset = get_props_subset(params, props) - wake_defl_vals = get_prop_values(obj, fi, props_subset) - else: - wake_defl_vals = get_prop_values(obj, fi, props) - model_params["Wake Deflection Parameters"] = wake_defl_vals - del model_params["Wake Deflection Parameters"]["logger"] - - if turbulence_model: - wake_turb_vals = {} - obj = "fi.floris.farm.wake.turbulence_model" - props = get_props(obj, fi) - if params is not None: - props_subset = get_props_subset(params, props) - wake_turb_vals = get_prop_values(obj, fi, props_subset) - else: - wake_turb_vals = get_prop_values(obj, fi, props) - model_params["Wake Turbulence Parameters"] = wake_turb_vals - del model_params["Wake Turbulence Parameters"]["logger"] - - return model_params - - -def set_params(fi, params, verbose=True): - for param_dict in params: - if param_dict == "Wake Velocity Parameters": - obj = "fi.floris.farm.wake.velocity_model" - props = get_props(obj, fi) - for prop in params[param_dict]: - if prop in [val[0] for val in props]: - exec(obj + "." + prop + " = " + str(params[param_dict][prop])) - if verbose: - print( - "Wake velocity parameter " - + prop - + " set to " - + str(params[param_dict][prop]) - ) - else: - raise Exception( - ( - "Wake deflection parameter '{}' " - + "not part of current model. Value '{}' was not " - + "used." - ).format(prop, params[param_dict][prop]) - ) - - if param_dict == "Wake Deflection Parameters": - obj = "fi.floris.farm.wake.deflection_model" - props = get_props(obj, fi) - for prop in params[param_dict]: - if prop in [val[0] for val in props]: - exec(obj + "." + prop + " = " + str(params[param_dict][prop])) - if verbose: - print( - "Wake deflection parameter " - + prop - + " set to " - + str(params[param_dict][prop]) - ) - else: - raise Exception( - ( - "Wake deflection parameter '{}' " - + "not part of current model. Value '{}' was not " - + "used." - ).format(prop, params[param_dict][prop]) - ) - - if param_dict == "Wake Turbulence Parameters": - obj = "fi.floris.farm.wake.turbulence_model" - props = get_props(obj, fi) - for prop in params[param_dict]: - if prop in [val[0] for val in props]: - exec(obj + "." + prop + " = " + str(params[param_dict][prop])) - if verbose: - print( - "Wake turbulence parameter " - + prop - + " set to " - + str(params[param_dict][prop]) - ) - else: - raise Exception( - ( - "Wake turbulence parameter '{}' " - + "not part of current model. Value '{}' was not " - + "used." - ).format(prop, params[param_dict][prop]) - ) - - -def get_props_subset(params, props): - prop_names = [prop[0] for prop in props] - try: - props_subset_inds = [prop_names.index(param) for param in params] - except Exception: - props_subset_inds = [] - print("Parameter(s)", ", ".join(params), "does(do) not exist.") - props_subset = [props[i] for i in props_subset_inds] - return props_subset - - -# def get_props(obj, fi): -# return inspect.getmembers( -# eval(obj + ".__class__"), lambda obj: isinstance(obj, property) -# ) - - -def get_prop_values(obj, fi, props): - prop_val_dict = {} - for val in props: - prop_val_dict[val[0]] = eval(obj + "." + val[0]) - return prop_val_dict - - -def print_props(obj, fi, props): - print("-".join(["-"] * 19)) - for val in props: - print(val[0] + " = " + str(eval(obj + "." + val[0]))) - print("-".join(["-"] * 19)) - - -def print_prop_docs(obj, fi, props): - for val in props: - print( - "-".join(["-"] * 39) + "\n", - val[0] + " = " + str(eval(obj + "." + val[0])), - "\n", - eval(obj + ".__class__." + val[0] + ".__doc__"), - ) - print("-".join(["-"] * 39)) diff --git a/floris/tools/layout_functions.py b/floris/tools/layout_functions.py deleted file mode 100644 index 5ca950555..000000000 --- a/floris/tools/layout_functions.py +++ /dev/null @@ -1,427 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -# Defines a bunch of tools for plotting and manipulating -# layouts for quick visualizations - -import math - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -from scipy.spatial.distance import pdist, squareform - - -def visualize_layout( - fi, - ax=None, - show_wake_lines=False, - limit_dist_m=None, - lim_lines_per_turbine=None, - turbine_face_north=False, - one_index_turbine=False, - black_and_white=False, - plot_rotor=False, - turbine_names=None -): - """ - Make a plot which shows the turbine locations, and important wakes. - - Args: - fi object - ax (:py:class:`matplotlib.pyplot.axes` optional): - figure axes. Defaults to None. - show_wake_lines (bool, optional): flag to control plotting of - wake boundaries. Defaults to False. - limit_dist_m (float, optional): Only plot distances less than this ammount (m) - Defaults to None. - lim_lines_per_turbine (int, optional): Limit number of lines eminating from a turbine - turbine_face_north (bool, optional): Force orientation of wind - turbines. Defaults to False. - one_index_turbine (bool, optional): if true, 1st turbine is - turbine 1 (ignored if turbine names provided) - black_and_white (bool, optional): if true print in black and white - plot_rotor (bool, optional): if true plot the turbine rotors and offset the labels - turbines_names (list, optional): optional list of turbine names - - """ - - # Build a dataframe of locations and names - df_turbine = pd.DataFrame({ - 'x':fi.layout_x, - 'y':fi.layout_y - }) - - # Get some info - D = fi.floris.farm.rotor_diameters[0] - N_turbine = df_turbine.shape[0] - turbines = df_turbine.index - - # Set some color information - if black_and_white: - ec_color = 'k' - else: - ec_color = 'r' - - # If we're plotting the rotor, offset the label - if plot_rotor: - label_offset = D/2 - else: - label_offset = 0. - - # If turbine names passed in apply them - if turbine_names is not None: - - if len(turbine_names) != N_turbine: - raise ValueError( - "Length of turbine names array must equal number of turbines within fi" - ) - - df_turbine['turbine_names'] = turbine_names - - elif one_index_turbine: - df_turbine['turbine_names'] = list(range(1,N_turbine+1)) # 1-indexed list - df_turbine['turbine_names'] = df_turbine['turbine_names'].astype(int) - - else: - - df_turbine['turbine_names'] = list(range(N_turbine)) # 0-indexed list - df_turbine['turbine_names'] = df_turbine['turbine_names'].astype(int) - - - # if no axes provided, make one - if not ax: - fig, ax = plt.subplots(figsize=(7, 7)) - - - # Make ordered list of pairs sorted by distance if the distance - # and angle matrices are provided - if show_wake_lines: - - # Make a dataframe of distances - dist = pd.DataFrame( - squareform(pdist(df_turbine[['x','y']])), - index=df_turbine.index, - columns=df_turbine.index, - ) - - # Make a DF of turbine angles - angle = pd.DataFrame() - - for t1 in turbines: - for t2 in turbines: - angle.loc[t1, t2] = wakeAngle(df_turbine, [t1, t2]) - angle.index.name = "Turbine" - - # Now limit the matrix to only show waking from (row) to (column) - for t1 in turbines: - for t2 in turbines: - if dist.loc[t1, t2] == 0.0: - dist.loc[t1, t2] = np.nan - angle.loc[t1, t2] = np.nan - - ordList = pd.DataFrame() - for t1 in turbines: - for t2 in turbines: - temp = pd.DataFrame( - { - "T1": [t1], - "T2": [t2], - "Dist": [dist.loc[t1, t2]], - "angle": angle.loc[t1, t2], - } - ) - ordList = pd.concat([ordList, temp]) - - ordList.dropna(how="any", inplace=True) - ordList.sort_values("Dist", inplace=True, ascending=False) - - # If selected to limit the number of lines per turbine - if lim_lines_per_turbine is not None: - # Limit list to smallest lim_lines_per_turbine - ordList = ordList.groupby(['T1']) - ordList = ordList.apply(lambda x: x.nsmallest(n=lim_lines_per_turbine, columns='Dist')) - ordList = ordList.reset_index(drop=True) - - # Add in the reflected version of each case (only postive directions will be - # plotted to help test show face up) - df_reflect = ordList.copy() - df_reflect.columns = ['T2','T1','Dist','angle'] # Reflect T2 and T1 - ordList = pd.concat([ordList,df_reflect]).drop_duplicates().reset_index(drop=True) - - # If limiting to less than a certain distance - if limit_dist_m is not None: - ordList = ordList[ordList.Dist < limit_dist_m] - - # Plot wake lines and details - for t1, t2 in zip(ordList.T1, ordList.T2): - x = [df_turbine.loc[t1, "x"], df_turbine.loc[t2, "x"]] - y = [df_turbine.loc[t1, "y"], df_turbine.loc[t2, "y"]] - - - # Only plot positive x way - if x[1] >= x[0]: - continue - - if black_and_white: - (line,) = ax.plot(x, y, color="k") - else: - (line,) = ax.plot(x, y) - - linetext = "%.2f D --- %.1f/%.1f" % ( - dist.loc[t1, t2] / D, - np.min([angle.loc[t2, t1], angle.loc[t1, t2]]), - np.max([angle.loc[t2, t1], angle.loc[t1, t2]]), - ) - - label_line( - line, linetext, ax, near_i=1, near_x=None, near_y=None, rotation_offset=180 - ) - - - # If plotting rotors, mark the location of the nacelle - if plot_rotor: - ax.plot(df_turbine.x, df_turbine.y,'o',ls='None', color='k') - - # Also mark the place of each label to make sure figure is correct scale - ax.plot( - df_turbine.x + label_offset, - df_turbine.y + label_offset, - '.', - ls='None', - color='w', - alpha=0 - - ) - - # Plot turbines - for t1 in turbines: - - if plot_rotor: # If plotting the rotors, draw these fist - - if not turbine_face_north: # Plot turbines facing west - ax.plot( - [df_turbine.loc[t1].x, df_turbine.loc[t1].x], - [ - df_turbine.loc[t1].y - 0.5 * D / 2.0, - df_turbine.loc[t1].y + 0.5 * D / 2.0, - ], - color="k", - ) - else: # Plot facing north - ax.plot( - [ - df_turbine.loc[t1].x - 0.5 * D / 2.0, - df_turbine.loc[t1].x + 0.5 * D / 2.0, - ], - [df_turbine.loc[t1].y, df_turbine.loc[t1].y], - color="k", - ) - - # Draw a line from label to rotor - ax.plot( - [ - df_turbine.loc[t1].x, - df_turbine.loc[t1].x + D/2, - ], - [df_turbine.loc[t1].y, df_turbine.loc[t1].y + D/2], - color="k", - ls='--' - ) - - - # Now add the label - ax.text( - - df_turbine.loc[t1].x + label_offset, - df_turbine.loc[t1].y + label_offset, - df_turbine.turbine_names.values[t1], - ha="center", - bbox={"boxstyle": "round", "ec": ec_color, "fc": "white"} - ) - - ax.set_aspect("equal") - - -# Set wind direction -def set_direction(df_turbine, rotation_angle): - """ - Rotate wind farm CCW by the given angle provided in degrees - - #TODO add center of rotation? Default = center of farm? - - Args: - df_turbine (pd.DataFrame): turbine location data - rotation_angle (float): rotation angle in degrees - - Returns: - df_return (pd.DataFrame): rotated farm layout. - """ - theta = np.deg2rad(rotation_angle) - R = np.matrix([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]) - - xy = np.array([df_turbine.x, df_turbine.y]) - - xy_rot = R * xy - - df_return = df_turbine.copy(deep=True) - df_return["x"] = np.squeeze(np.asarray(xy_rot[0, :])) - df_return["y"] = np.squeeze(np.asarray(xy_rot[1, :])) - return df_return - - -def turbineDist(df, turbList): - """ - Derive distance between any two turbines. - - Args: - df (pd.DataFrame): DataFrame with layout data. - turbList (list): list of 2 turbines for which spacing distance - is of interest. - - Returns: - float: distance between turbines. - """ - x1 = df.loc[turbList[0], "x"] - x2 = df.loc[turbList[1], "x"] - y1 = df.loc[turbList[0], "y"] - y2 = df.loc[turbList[1], "y"] - - dist = np.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2) - - return dist - - -def wakeAngle(df, turbList): - """ - Get angles between turbines in wake direction - - Args: - df (pd.DataFrame): DataFrame with layout data. - turbList (list): list of 2 turbines for which spacing distance - is of interest. - - Returns: - wakeAngle (float): angle between turbines relative to compass - """ - x1 = df.loc[turbList[0], "x"] - x2 = df.loc[turbList[1], "x"] - y1 = df.loc[turbList[0], "y"] - y2 = df.loc[turbList[1], "y"] - wakeAngle = ( - np.arctan2(y2 - y1, x2 - x1) * 180.0 / np.pi - ) # Angle in normal cartesian coordinates - - # Convert angle to compass angle - wakeAngle = 270.0 - wakeAngle - if wakeAngle < 0: - wakeAngle = wakeAngle + 360.0 - if wakeAngle > 360: - wakeAngle = wakeAngle - 360.0 - - return wakeAngle - - -def label_line( - line, - label_text, - ax, - near_i=None, - near_x=None, - near_y=None, - rotation_offset=0.0, - offset=(0, 0), -): - """ - [summary] - - Args: - line (matplotlib.lines.Line2D): line to label. - label_text (str): label to add to line. - ax (:py:class:`matplotlib.pyplot.axes` optional): figure axes. - near_i (int, optional): Catch line near index i. - Defaults to None. - near_x (float, optional): Catch line near coordinate x. - Defaults to None. - near_y (float, optional): Catch line near coordinate y. - Defaults to None. - rotation_offset (float, optional): label rotation in degrees. - Defaults to 0. - offset (tuple, optional): label offset from turbine location. - Defaults to (0, 0). - - Raises: - ValueError: ("Need one of near_i, near_x, near_y") raised if - insufficient information is passed in. - """ - - def put_label(i, ax): - """ - Add a label to index. - - Args: - i (int): index to label. - """ - i = min(i, len(x) - 2) - dx = sx[i + 1] - sx[i] - dy = sy[i + 1] - sy[i] - rotation = np.rad2deg(math.atan2(dy, dx)) + rotation_offset - pos = [(x[i] + x[i + 1]) / 2.0 + offset[0], (y[i] + y[i + 1]) / 2 + offset[1]] - ax.text( - pos[0], - pos[1], - label_text, - size=9, - rotation=rotation, - color=line.get_color(), - ha="center", - va="center", - bbox={"ec": "1", "fc": "1", "alpha": 0.8}, - ) - - # extract line data - x = line.get_xdata() - y = line.get_ydata() - - # define screen spacing - if ax.get_xscale() == "log": - sx = np.log10(x) - else: - sx = x - if ax.get_yscale() == "log": - sy = np.log10(y) - else: - sy = y - - # find index - if near_i is not None: - i = near_i - if i < 0: # sanitize negative i - i = len(x) + i - put_label(i, ax) - elif near_x is not None: - for i in range(len(x) - 2): - if (x[i] < near_x and x[i + 1] >= near_x) or ( - x[i + 1] < near_x and x[i] >= near_x - ): - put_label(i, ax) - elif near_y is not None: - for i in range(len(y) - 2): - if (y[i] < near_y and y[i + 1] >= near_y) or ( - y[i + 1] < near_y and y[i] >= near_y - ): - put_label(i, ax) - else: - raise ValueError("Need one of near_i, near_x, near_y") diff --git a/floris/tools/optimization/legacy/pyoptsparse/__init__.py b/floris/tools/optimization/legacy/pyoptsparse/__init__.py deleted file mode 100644 index 3fe7863a8..000000000 --- a/floris/tools/optimization/legacy/pyoptsparse/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -from . import ( - layout, - optimization, - power_density, - yaw, -) diff --git a/floris/tools/optimization/legacy/pyoptsparse/layout.py b/floris/tools/optimization/legacy/pyoptsparse/layout.py deleted file mode 100644 index e006ed6ea..000000000 --- a/floris/tools/optimization/legacy/pyoptsparse/layout.py +++ /dev/null @@ -1,213 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np -from scipy.spatial.distance import cdist -from shapely.geometry import ( - LineString, - Point, - Polygon, -) - - -def _norm(val, x1, x2): - return (val - x1) / (x2 - x1) - -def _unnorm(val, x1, x2): - return np.array(val) * (x2 - x1) + x1 - -class Layout: - def __init__(self, fi, boundaries, freq): - self.fi = fi - self.boundaries = boundaries - self.freq = freq - - self.boundary_polygon = Polygon(self.boundaries) - self.boundary_line = LineString(self.boundaries) - - self.xmin = np.min([tup[0] for tup in boundaries]) - self.xmax = np.max([tup[0] for tup in boundaries]) - self.ymin = np.min([tup[1] for tup in boundaries]) - self.ymax = np.max([tup[1] for tup in boundaries]) - self.x0 = _norm(self.fi.layout_x, self.xmin, self.xmax) - self.y0 = _norm(self.fi.layout_y, self.ymin, self.ymax) - - self.min_dist = 2 * self.rotor_diameter - - self.wdir = self.fi.floris.flow_field.wind_directions - self.wspd = self.fi.floris.flow_field.wind_speeds - self.initial_AEP = np.sum(self.fi.get_farm_power() * self.freq) - - def __str__(self): - return "layout" - - ########################################################################### - # Required private optimization methods - ########################################################################### - - def reinitialize(self): - pass - - def obj_func(self, varDict): - # Parse the variable dictionary - self.parse_opt_vars(varDict) - - # Update turbine map with turbince locations - self.fi.reinitialize(layout_x=self.x, layout_y=self.y) - self.fi.calculate_wake() - - # Compute the objective function - funcs = {} - funcs["obj"] = ( - -1 * np.sum(self.fi.get_farm_power() * self.freq) / self.initial_AEP - ) - - # Compute constraints, if any are defined for the optimization - funcs = self.compute_cons(funcs) - - fail = False - return funcs, fail - - # Optionally, the user can supply the optimization with gradients - # def _sens(self, varDict, funcs): - # funcsSens = {} - # fail = False - # return funcsSens, fail - - def parse_opt_vars(self, varDict): - self.x = _unnorm(varDict["x"], self.xmin, self.xmax) - self.y = _unnorm(varDict["y"], self.ymin, self.ymax) - - def parse_sol_vars(self, sol): - self.x = list(_unnorm(sol.getDVs()["x"], self.xmin, self.xmax))[0] - self.y = list(_unnorm(sol.getDVs()["y"], self.ymin, self.ymax))[1] - - def add_var_group(self, optProb): - optProb.addVarGroup( - "x", self.nturbs, type="c", lower=0.0, upper=1.0, value=self.x0 - ) - optProb.addVarGroup( - "y", self.nturbs, type="c", lower=0.0, upper=1.0, value=self.y0 - ) - - return optProb - - def add_con_group(self, optProb): - optProb.addConGroup("boundary_con", self.nturbs, upper=0.0) - optProb.addConGroup("spacing_con", 1, upper=0.0) - - return optProb - - def compute_cons(self, funcs): - funcs["boundary_con"] = self.distance_from_boundaries() - funcs["spacing_con"] = self.space_constraint() - - return funcs - - ########################################################################### - # User-defined methods - ########################################################################### - - def space_constraint(self, rho=500): - x = self.x - y = self.y - - # Sped up distance calc here using vectorization - locs = np.vstack((x, y)).T - distances = cdist(locs, locs) - arange = np.arange(distances.shape[0]) - distances[arange, arange] = 1e10 - dist = np.min(distances, axis=0) - - g = 1 - np.array(dist) / self.min_dist - - # Following code copied from OpenMDAO KSComp(). - # Constraint is satisfied when KS_constraint <= 0 - g_max = np.max(np.atleast_2d(g), axis=-1)[:, np.newaxis] - g_diff = g - g_max - exponents = np.exp(rho * g_diff) - summation = np.sum(exponents, axis=-1)[:, np.newaxis] - KS_constraint = g_max + 1.0 / rho * np.log(summation) - - return KS_constraint[0][0] - - def distance_from_boundaries(self): - boundary_con = np.zeros(self.nturbs) - for i in range(self.nturbs): - loc = Point(self.x[i], self.y[i]) - boundary_con[i] = loc.distance(self.boundary_line) - if self.boundary_polygon.contains(loc) is True: - boundary_con[i] *= -1.0 - - return boundary_con - - def plot_layout_opt_results(self, sol): - """ - Method to plot the old and new locations of the layout opitimization. - """ - locsx = _unnorm(sol.getDVs()["x"], self.xmin, self.xmax) - locsy = _unnorm(sol.getDVs()["y"], self.ymin, self.ymax) - x0 = _unnorm(self.x0, self.xmin, self.xmax) - y0 = _unnorm(self.y0, self.ymin, self.ymax) - - plt.figure(figsize=(9, 6)) - fontsize = 16 - plt.plot(x0, y0, "ob") - plt.plot(locsx, locsy, "or") - # plt.title('Layout Optimization Results', fontsize=fontsize) - plt.xlabel("x (m)", fontsize=fontsize) - plt.ylabel("y (m)", fontsize=fontsize) - plt.axis("equal") - plt.grid() - plt.tick_params(which="both", labelsize=fontsize) - plt.legend( - ["Old locations", "New locations"], - loc="lower center", - bbox_to_anchor=(0.5, 1.01), - ncol=2, - fontsize=fontsize, - ) - - verts = self.boundaries - for i in range(len(verts)): - if i == len(verts) - 1: - plt.plot([verts[i][0], verts[0][0]], [verts[i][1], verts[0][1]], "b") - else: - plt.plot( - [verts[i][0], verts[i + 1][0]], [verts[i][1], verts[i + 1][1]], "b" - ) - - plt.show() - - ########################################################################### - # Properties - ########################################################################### - - @property - def nturbs(self): - """ - This property returns the number of turbines in the FLORIS - object. - - Returns: - nturbs (int): The number of turbines in the FLORIS object. - """ - self._nturbs = self.fi.floris.farm.n_turbines - return self._nturbs - - @property - def rotor_diameter(self): - return self.fi.floris.farm.rotor_diameters[0][0][0] diff --git a/floris/tools/optimization/legacy/pyoptsparse/optimization.py b/floris/tools/optimization/legacy/pyoptsparse/optimization.py deleted file mode 100644 index d0240c138..000000000 --- a/floris/tools/optimization/legacy/pyoptsparse/optimization.py +++ /dev/null @@ -1,114 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -from floris.logging_manager import LoggingManager - - -class Optimization(LoggingManager): - """ - Base optimization class. - - Args: - fi (:py:class:`floris.tools.floris_utilities.FlorisInterface`): - Interface from FLORIS to the tools package. - - Returns: - Optimization: An instantiated Optimization object. - """ - - def __init__(self, model, solver=None): - """ - Instantiate Optimization object and its parameters. - """ - self.model = model - self.solver_choices = [ - "SNOPT", - "IPOPT", - "SLSQP", - "NLPQLP", - "FSQP", - "NSGA2", - "PSQP", - "ParOpt", - "CONMIN", - "ALPSO", - ] - - if solver not in self.solver_choices: - raise ValueError( - "Solver must be one supported by pyOptSparse: " - + str(self.solver_choices) - ) - - self.reinitialize(solver=solver) - - # Private methods - - def _reinitialize(self, solver=None, optOptions=None): - try: - import pyoptsparse - except ImportError: - err_msg = ( - "It appears you do not have pyOptSparse installed. " - + "Please refer to https://pyoptsparse.readthedocs.io/ for " - + "guidance on how to properly install the module." - ) - self.logger.error(err_msg, stack_info=True) - raise ImportError(err_msg) - - self.optProb = pyoptsparse.Optimization(self.model, self.objective_func) - - self.optProb = self.model.add_var_group(self.optProb) - self.optProb = self.model.add_con_group(self.optProb) - self.optProb.addObj("obj") - - if solver is not None: - self.solver = solver - print("Setting up optimization with user's choice of solver: ", self.solver) - else: - self.solver = "SLSQP" - print("Setting up optimization with default solver: SLSQP.") - if optOptions is not None: - self.optOptions = optOptions - else: - if self.solver == "SNOPT": - self.optOptions = {"Major optimality tolerance": 1e-7} - else: - self.optOptions = {} - - exec("self.opt = pyoptsparse." + self.solver + "(options=self.optOptions)") - - def _optimize(self): - if hasattr(self.model, "_sens"): - self.sol = self.opt(self.optProb, sens=self.model._sens) - else: - self.sol = self.opt(self.optProb, sens="CDR", storeHistory='hist.hist') - - # Public methods - - def reinitialize(self, solver=None): - self._reinitialize(solver=solver) - - def optimize(self): - self._optimize() - - return self.sol - - def objective_func(self, varDict): - return self.model.obj_func(varDict) - - def sensitivity_func(self): - pass - - # Properties diff --git a/floris/tools/optimization/legacy/pyoptsparse/power_density.py b/floris/tools/optimization/legacy/pyoptsparse/power_density.py deleted file mode 100644 index 8236e77ec..000000000 --- a/floris/tools/optimization/legacy/pyoptsparse/power_density.py +++ /dev/null @@ -1,354 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import sys - -import matplotlib.pyplot as plt -import numpy as np - - -class PowerDensity: - def __init__( - self, fi, boundaries, wdir=None, wspd=None, wfreq=None, AEP_initial=None - ): - - self.fi = fi - self.boundaries = boundaries - - self.xmin = np.min([tup[0] for tup in boundaries]) - self.xmax = np.max([tup[0] for tup in boundaries]) - self.ymin = np.min([tup[1] for tup in boundaries]) - self.ymax = np.max([tup[1] for tup in boundaries]) - self.x0 = self.fi.layout_x - self.y0 = self.fi.layout_y - - self.yawmin = 0.0 - self.yawmax = 20.0 - self.yaw0 = 1.0 - - self.min_dist = 2 * self.rotor_diameter - - if wdir is not None: - self.wdir = wdir - else: - self.wdir = self.fi.floris.farm.flow_field.wind_direction - if wspd is not None: - self.wspd = wspd - else: - self.wspd = self.fi.floris.farm.flow_field.wind_speed - if wfreq is not None: - self.wfreq = wfreq - else: - self.wfreq = 1.0 - - if AEP_initial is not None: - self.AEP_initial = AEP_initial - else: - self.AEP_initial = self.fi.get_farm_AEP(self.wdir, self.wspd, self.wfreq) - - self.initial_area = self.find_layout_area(self.x0, self.y0) - - def __str__(self): - return "power_density" - - ########################################################################### - # Required private optimziation methods - ########################################################################### - - def reinitialize(self): - pass - - def obj_func(self, varDict): - # Parse the variable dictionary - self.parse_opt_vars(varDict) - - # Calculate new wind farm foorprint area - opt_area = self.find_layout_area(self.x, self.y) - - # Update turbine map with turbince locations - self.fi.reinitialize_flow_field(layout_array=[self.x, self.y]) - - # Compute the objective function - AEP_sum = self.fi.get_farm_AEP(self.wdir, self.wspd, self.wfreq, self.yaw) - - # for i in range(len(self.wdir)): - # AEP_sum = AEP_sum + self.fi.get_farm_AEP( - # self.wdir[i], - # self.wspd[i], - # self.wfreq[i], - # self.yaw[i] - # ) - - funcs = {} - funcs["obj"] = -1e1 * AEP_sum / self.AEP_initial * self.initial_area / opt_area - # print('obj: ', funcs['obj']) - - # Compute constraints, if any are defined for the optimization - funcs = self.compute_cons(funcs, AEP_sum) - - fail = False - return funcs, fail - - # Optionally, the user can supply the optimization with gradients - # def _sens(self, varDict, funcs): - # funcsSens = {} - # fail = False - # return funcsSens, fail - - def parse_opt_vars(self, varDict): - self.x = varDict["x"] - self.y = varDict["y"] - self.yaw = [ - varDict["yaw"][i * self.nturbs : i * self.nturbs + self.nturbs] - for i in range(len(self.wdir)) - ] - - def parse_sol_vars(self, sol): - self.x = list(sol.getDVs().values())[0] - self.y = list(sol.getDVs().values())[1] - self.yaw = list(sol.getDVs().values())[2] - - def add_var_group(self, optProb): - optProb.addVarGroup( - "x", - self.nturbs, - type="c", - lower=self.xmin, - upper=self.xmax, - value=self.x0, - scale=1e-4, - ) - optProb.addVarGroup( - "y", - self.nturbs, - type="c", - lower=self.ymin, - upper=self.ymax, - value=self.y0, - scale=1e-4, - ) - optProb.addVarGroup( - "yaw", - self.nturbs * len(self.wdir), - type="c", - lower=self.yawmin, - upper=self.yawmax, - value=self.yaw0, - ) - - return optProb - - def add_con_group(self, optProb): - optProb.addConGroup("boundary_con", self.nturbs, lower=0.0) - optProb.addConGroup("spacing_con", self.nturbs, lower=self.min_dist) - optProb.addConGroup("aep_con", 1, lower=1.0) - - return optProb - - def compute_cons(self, funcs, AEP_sum): - funcs["boundary_con"] = self.distance_from_boundaries() - funcs["spacing_con"] = self.space_constraint() - funcs["aep_con"] = self.aep_constraint(AEP_sum) - # print('boundary_con: ', funcs['boundary_con']) - # print('spacing_con: ', funcs['spacing_con']) - # print('aep_con: ', funcs['aep_con']) - - return funcs - - ########################################################################### - # User-defined methods - ########################################################################### - - def find_layout_area(self, x, y): - points = zip(x, y) - points = np.array(list(points)) - - hull = self.convex_hull(points) - - area = self.polygon_area( - np.array([val[0] for val in hull]), np.array([val[1] for val in hull]) - ) - - return area - - def convex_hull(self, points): - # find two hull points, U, V, and split to left and right search - u = min(points, key=lambda p: p[0]) - v = max(points, key=lambda p: p[0]) - left, right = self.split(u, v, points), self.split(v, u, points) - - # find convex hull on each side - return [v] + self.extend(u, v, left) + [u] + self.extend(v, u, right) + [v] - - def polygon_area(self, x, y): - # coordinate shift - x_ = x - x.mean() - y_ = y - y.mean() - - correction = x_[-1] * y_[0] - y_[-1] * x_[0] - main_area = np.dot(x_[:-1], y_[1:]) - np.dot(y_[:-1], x_[1:]) - return 0.5 * np.abs(main_area + correction) - - def split(self, u, v, points): - # return points on left side of UV - return [p for p in points if np.cross(p - u, v - u) < 0] - - def extend(self, u, v, points): - if not points: - return [] - - # find furthest point W, and split search to WV, UW - w = min(points, key=lambda p: np.cross(p - u, v - u)) - p1, p2 = self.split(w, v, points), self.split(u, w, points) - return self.extend(w, v, p1) + [w] + self.extend(u, w, p2) - - def aep_constraint(self, AEP_sum): - return AEP_sum / self.AEP_initial - - def space_constraint(self): - dist = [ - np.min( - [ - np.sqrt((self.x[i] - self.x[j]) ** 2 + (self.y[i] - self.y[j]) ** 2) - for j in range(self.nturbs) - if i != j - ] - ) - for i in range(self.nturbs) - ] - - return dist - - def distance_from_boundaries(self): - dist_out = [] - - for k in range(self.nturbs): - dist = [] - in_poly = self.point_inside_polygon(self.x[k], self.y[k], self.boundaries) - - for i in range(len(self.boundaries)): - self.boundaries = np.array(self.boundaries) - p1 = self.boundaries[i] - if i == len(self.boundaries) - 1: - p2 = self.boundaries[0] - else: - p2 = self.boundaries[i + 1] - - px = p2[0] - p1[0] - py = p2[1] - p1[1] - norm = px * px + py * py - - u = ( - (self.x[k] - self.boundaries[i][0]) * px - + (self.y[k] - self.boundaries[i][1]) * py - ) / float(norm) - - if u <= 0: - xx = p1[0] - yy = p1[1] - elif u >= 1: - xx = p2[0] - yy = p2[1] - else: - xx = p1[0] + u * px - yy = p1[1] + u * py - - dx = self.x[k] - xx - dy = self.y[k] - yy - dist.append(np.sqrt(dx * dx + dy * dy)) - - dist = np.array(dist) - if in_poly: - dist_out.append(np.min(dist)) - else: - dist_out.append(-np.min(dist)) - - dist_out = np.array(dist_out) - - return dist_out - - def point_inside_polygon(self, x, y, poly): - n = len(poly) - inside = False - - p1x, p1y = poly[0] - for i in range(n + 1): - p2x, p2y = poly[i % n] - if y > min(p1y, p2y): - if y <= max(p1y, p2y): - if x <= max(p1x, p2x): - if p1y != p2y: - xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x - if p1x == p2x or x <= xinters: - inside = not inside - p1x, p1y = p2x, p2y - - return inside - - def plot_layout_opt_results(self, sol): - """ - Method to plot the old and new locations of the layout opitimization. - """ - locsx = sol.getDVs()["x"] - locsy = sol.getDVs()["y"] - - plt.figure(figsize=(9, 6)) - fontsize = 16 - plt.plot(self.x0, self.y0, "ob") - plt.plot(locsx, locsy, "or") - # plt.title('Layout Optimization Results', fontsize=fontsize) - plt.xlabel("x (m)", fontsize=fontsize) - plt.ylabel("y (m)", fontsize=fontsize) - plt.axis("equal") - plt.grid() - plt.tick_params(which="both", labelsize=fontsize) - plt.legend( - ["Old locations", "New locations"], - loc="lower center", - bbox_to_anchor=(0.5, 1.01), - ncol=2, - fontsize=fontsize, - ) - - verts = self.boundaries - for i in range(len(verts)): - if i == len(verts) - 1: - plt.plot([verts[i][0], verts[0][0]], [verts[i][1], verts[0][1]], "b") - else: - plt.plot( - [verts[i][0], verts[i + 1][0]], [verts[i][1], verts[i + 1][1]], "b" - ) - - plt.show() - - ########################################################################### - # Properties - ########################################################################### - - @property - def nturbs(self): - """ - This property returns the number of turbines in the FLORIS - object. - - Returns: - nturbs (int): The number of turbines in the FLORIS object. - """ - self._nturbs = len(self.fi.floris.farm.turbines) - return self._nturbs - - @property - def rotor_diameter(self): - return self.fi.floris.farm.turbine_map.turbines[0].rotor_diameter diff --git a/floris/tools/optimization/legacy/pyoptsparse/yaw.py b/floris/tools/optimization/legacy/pyoptsparse/yaw.py deleted file mode 100644 index 1e90573b0..000000000 --- a/floris/tools/optimization/legacy/pyoptsparse/yaw.py +++ /dev/null @@ -1,344 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np -from scipy.stats import norm - -from floris.tools.visualization import visualize_cut_plane - - -class Yaw: - """ - Class that performs yaw optimization for a single set of - inflow conditions. Intended to be used together with an object of the - :py:class`floris.tools.optimization.optimization.Optimization` class. - - Args: - fi (:py:class:`floris.tools.floris_interface.FlorisInterface`): - Interface from FLORIS to the tools package. - minimum_yaw_angle (float, optional): Minimum constraint on - yaw. Defaults to None. - maximum_yaw_angle (float, optional): Maximum constraint on - yaw. Defaults to None. - x0 (iterable, optional): The initial yaw conditions. - Defaults to None. Initializes to the current turbine - yaw settings. - include_unc (bool): If True, uncertainty in wind direction - and/or yaw position is included when determining wind farm power. - Uncertainty is included by computing the mean wind farm power for - a distribution of wind direction and yaw position deviations from - the original wind direction and yaw angles. Defaults to False. - unc_pmfs (dictionary, optional): A dictionary containing optional - probability mass functions describing the distribution of wind - direction and yaw position deviations when wind direction and/or - yaw position uncertainty is included in the power calculations. - Contains the following key-value pairs: - - - **wd_unc**: A numpy array containing wind direction deviations - from the original wind direction. - - **wd_unc_pmf**: A numpy array containing the probability of - each wind direction deviation in **wd_unc** occuring. - - **yaw_unc**: A numpy array containing yaw angle deviations - from the original yaw angles. - - **yaw_unc_pmf**: A numpy array containing the probability of - each yaw angle deviation in **yaw_unc** occuring. - - Defaults to None, in which case default PMFs are calculated using - values provided in **unc_options**. - unc_options (disctionary, optional): A dictionary containing values used - to create normally-distributed, zero-mean probability mass functions - describing the distribution of wind direction and yaw position - deviations when wind direction and/or yaw position uncertainty is - included. This argument is only used when **unc_pmfs** is None and - contains the following key-value pairs: - - - **std_wd**: A float containing the standard deviation of the wind - direction deviations from the original wind direction. - - **std_yaw**: A float containing the standard deviation of the yaw - angle deviations from the original yaw angles. - - **pmf_res**: A float containing the resolution in degrees of the - wind direction and yaw angle PMFs. - - **pdf_cutoff**: A float containing the cumulative distribution - function value at which the tails of the PMFs are truncated. - - Defaults to None. Initializes to {'std_wd': 4.95, 'std_yaw': 1.75, - 'pmf_res': 1.0, 'pdf_cutoff': 0.995}. - wdir (float, optional): Wind direction to use for optimization. Defaults - to None. Initializes to current wind direction in floris. - wspd (float, optional): Wind speed to use for optimization. Defaults - to None. Initializes to current wind direction in floris. - - Returns: - Yaw: An instantiated Yaw object. - """ - - def __init__( - self, - fi, - minimum_yaw_angle=0.0, - maximum_yaw_angle=25.0, - x0=None, - include_unc=False, - unc_pmfs=None, - unc_options=None, - wdir=None, - wspd=None, - ): - """ - Instantiate Yaw object and parameter values. - """ - self.fi = fi - self.minimum_yaw_angle = minimum_yaw_angle - self.maximum_yaw_angle = maximum_yaw_angle - - if x0 is not None: - self.x0 = x0 - else: - self.x0 = [ - turbine.yaw_angle - for turbine in self.fi.floris.farm.turbine_map.turbines - ] - - self.include_unc = include_unc - self.unc_pmfs = unc_pmfs - if self.include_unc & (self.unc_pmfs is None): - self.unc_pmfs = calc_unc_pmfs(self.unc_pmfs) - - if wdir is not None: - self.wdir = wdir - else: - self.wdir = self.fi.floris.farm.flow_field.wind_direction - if wspd is not None: - self.wspd = wspd - else: - self.wspd = self.fi.floris.farm.flow_field.wind_speed - - self.fi.reinitialize_flow_field(wind_speed=self.wspd, wind_direction=self.wdir) - - def __str__(self): - return "yaw" - - ########################################################################### - # Required private optimization methods - ########################################################################### - - def reinitialize(self): - pass - - def obj_func(self, varDict): - # Parse the variable dictionary - self.parse_opt_vars(varDict) - - # Reinitialize with wind speed and direction - self.fi.reinitialize_flow_field(wind_speed=self.wspd, wind_direction=self.wdir) - - # Compute the objective function - funcs = {} - funcs["obj"] = -1 * self.fi.get_farm_power_for_yaw_angle(self.yaw) / 1e0 - - # Compute constraints, if any are defined for the optimization - funcs = self.compute_cons(funcs) - - fail = False - return funcs, fail - - def parse_opt_vars(self, varDict): - self.yaw = varDict["yaw"] - - def parse_sol_vars(self, sol): - self.yaw = list(sol.getDVs().values())[0] - - def add_var_group(self, optProb): - optProb.addVarGroup( - "yaw", - self.nturbs, - type="c", - lower=self.minimum_yaw_angle, - upper=self.maximum_yaw_angle, - value=self.x0, - ) - - return optProb - - def add_con_group(self, optProb): - # no constraints defined - return optProb - - def compute_cons(self, funcs): - # no constraints defined - return funcs - - ########################################################################### - # User-defined methods - ########################################################################### - - def plot_yaw_opt_results(self, sol): - """ - Method to plot the wind farm with optimal yaw offsets - """ - yaw = sol.getDVs()["yaw"] - - # Assign yaw angles to turbines and calculate wake - self.fi.calculate_wake(yaw_angles=yaw) - - # Initialize the horizontal cut - horizontal_plane = self.fi.calculate_horizontal_plane(x_resolution=400, y_resolution=100) - - # Plot and show - fig, ax = plt.subplots() - visualize_cut_plane(horizontal_plane, ax=ax) - ax.set_title( - "Optimal Yaw Offsets for U = " - + str(self.wspd[0]) - + " m/s, Wind Direction = " - + str(self.wdir[0]) - + "$^\\circ$" - ) - - plt.show() - - def print_power_gain(self, sol): - """ - Method to print the power gain from wake steering with optimal yaw offsets - """ - yaw = sol.getDVs()["yaw"] - - self.fi.calculate_wake(yaw_angles=0.0) - power_baseline = self.fi.get_farm_power() - - self.fi.calculate_wake(yaw_angles=yaw) - power_opt = self.fi.get_farm_power() - - pct_gain = 100.0 * (power_opt - power_baseline) / power_baseline - - print("==========================================") - print("Baseline Power = %.1f kW" % (power_baseline / 1e3)) - print("Optimal Power = %.1f kW" % (power_opt / 1e3)) - print("Total Power Gain = %.1f%%" % pct_gain) - print("==========================================") - - ########################################################################### - # Properties - ########################################################################### - - @property - def nturbs(self): - """ - This property returns the number of turbines in the FLORIS - object. - - Returns: - nturbs (int): The number of turbines in the FLORIS object. - """ - self._nturbs = len(self.fi.floris.farm.turbines) - return self._nturbs - - -def calc_unc_pmfs(unc_options=None): - """ - Calculates normally-distributed probability mass functions describing the - distribution of wind direction and yaw position deviations when wind direction - and/or yaw position uncertainty are included in power calculations. - - Args: - unc_options (dictionary, optional): A dictionary containing values used - to create normally-distributed, zero-mean probability mass functions - describing the distribution of wind direction and yaw position - deviations when wind direction and/or yaw position uncertainty is - included. This argument is only used when **unc_pmfs** is None and - contains the following key-value pairs: - - - **std_wd**: A float containing the standard deviation of the wind - direction deviations from the original wind direction. - - **std_yaw**: A float containing the standard deviation of the yaw - angle deviations from the original yaw angles. - - **pmf_res**: A float containing the resolution in degrees of the - wind direction and yaw angle PMFs. - - **pdf_cutoff**: A float containing the cumulative distribution - function value at which the tails of the PMFs are truncated. - - Defaults to None. Initializes to {'std_wd': 4.95, 'std_yaw': 1.75, - 'pmf_res': 1.0, 'pdf_cutoff': 0.995}. - - Returns: - [dictionary]: A dictionary containing - probability mass functions describing the distribution of wind - direction and yaw position deviations when wind direction and/or - yaw position uncertainty is included in the power calculations. - Contains the following key-value pairs: - - - **wd_unc**: A numpy array containing wind direction deviations - from the original wind direction. - - **wd_unc_pmf**: A numpy array containing the probability of - each wind direction deviation in **wd_unc** occuring. - - **yaw_unc**: A numpy array containing yaw angle deviations - from the original yaw angles. - - **yaw_unc_pmf**: A numpy array containing the probability of - each yaw angle deviation in **yaw_unc** occuring. - - """ - - if unc_options is None: - unc_options = { - "std_wd": 4.95, - "std_yaw": 1.75, - "pmf_res": 1.0, - "pdf_cutoff": 0.995, - } - - # create normally distributed wd and yaw uncertainty pmfs - if unc_options["std_wd"] > 0: - wd_bnd = int( - np.ceil( - norm.ppf(unc_options["pdf_cutoff"], scale=unc_options["std_wd"]) - / unc_options["pmf_res"] - ) - ) - wd_unc = np.linspace( - -1 * wd_bnd * unc_options["pmf_res"], - wd_bnd * unc_options["pmf_res"], - 2 * wd_bnd + 1, - ) - wd_unc_pmf = norm.pdf(wd_unc, scale=unc_options["std_wd"]) - wd_unc_pmf = wd_unc_pmf / np.sum(wd_unc_pmf) # normalize so sum = 1.0 - else: - wd_unc = np.zeros(1) - wd_unc_pmf = np.ones(1) - - if unc_options["std_yaw"] > 0: - yaw_bnd = int( - np.ceil( - norm.ppf(unc_options["pdf_cutoff"], scale=unc_options["std_yaw"]) - / unc_options["pmf_res"] - ) - ) - yaw_unc = np.linspace( - -1 * yaw_bnd * unc_options["pmf_res"], - yaw_bnd * unc_options["pmf_res"], - 2 * yaw_bnd + 1, - ) - yaw_unc_pmf = norm.pdf(yaw_unc, scale=unc_options["std_yaw"]) - yaw_unc_pmf = yaw_unc_pmf / np.sum(yaw_unc_pmf) # normalize so sum = 1.0 - else: - yaw_unc = np.zeros(1) - yaw_unc_pmf = np.ones(1) - - return { - "wd_unc": wd_unc, - "wd_unc_pmf": wd_unc_pmf, - "yaw_unc": yaw_unc, - "yaw_unc_pmf": yaw_unc_pmf, - } diff --git a/floris/tools/optimization/legacy/scipy/__init__.py b/floris/tools/optimization/legacy/scipy/__init__.py deleted file mode 100644 index 5e93e05a5..000000000 --- a/floris/tools/optimization/legacy/scipy/__init__.py +++ /dev/null @@ -1,12 +0,0 @@ -from . import ( - base_COE, - derive_downstream_turbines, - layout, - layout_height, - optimization, - power_density, - power_density_1D, - yaw, - yaw_wind_rose, - yaw_wind_rose_parallel, -) diff --git a/floris/tools/optimization/legacy/scipy/base_COE.py b/floris/tools/optimization/legacy/scipy/base_COE.py deleted file mode 100644 index 7f7a40232..000000000 --- a/floris/tools/optimization/legacy/scipy/base_COE.py +++ /dev/null @@ -1,143 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import numpy as np - - -class BaseCOE: - """ - BaseCOE is the base cost of energy (COE) class that is used to determine - the cost of energy associated with a - :py:class:`~.optimization.scipy.layout_height.LayoutHeightOptimization` - object. - - TODO: 1) Add references to NREL 2016 Cost of Wind Energy Review throughout? - """ - - def __init__(self, opt_obj): - """ - Instantiate a COE model object with a LayoutHeightOptimization object. - - Args: - opt_obj (:py:class:`~.layout_height.LayoutHeightOptimization`): - The optimization object. - """ - self.opt_obj = opt_obj - - # Public methods - - def FCR(self): - """ - This method returns the fixed charge rate used in the COE calculation. - - Returns: - float: The fixed charge rate. - """ - return 0.079 # % - Taken from 2016 Cost of Wind Energy Review - - def TCC(self, height): - """ - This method dertermines the turbine capital costs (TCC), - calculating the effect of varying turbine height and rotor - diameter on the cost of the tower. The relationship estiamted - the mass of steel needed for the tower from the NREL Cost and - Scaling Model (CSM), and then adds that to the tower cost - portion of the TCC. The proportion is determined from the NREL - 2016 Cost of Wind Energy Review. A price of 3.08 $/kg is - assumed for the needed steel. Tower height is passed directly - while the turbine rotor diameter is pulled directly from the - turbine object within the - :py:class:`~.tools.floris_interface.FlorisInterface`:. - - TODO: Turbine capital cost or tower capital cost? - - Args: - height (float): Turbine hub height in meters. - - Returns: - float: The turbine capital cost of a wind plant in units of $/kWh. - """ - # From CSM with a fudge factor - tower_mass = ( - 0.2694 - * height - * ( - np.pi - * (self.opt_obj.fi.floris.farm.turbines[0].rotor_diameter / 2) ** 2 - ) - + 1779.3 - ) / (1.341638) - - # Combo of 2016 Cost of Wind Energy Review and CSM - TCC = 831 + tower_mass * 3.08 * self.opt_obj.nturbs / self.opt_obj.plant_kw - - return TCC - - def BOS(self): - """ - This method returns the balance of station cost of a wind plant as - determined by a constant factor. As the rating of a wind plant grows, - the cost of the wind plant grows as well. - - Returns: - float: The balance of station cost of a wind plant in units of - $/kWh. - """ - return 364.0 # $/kW - Taken from 2016 Cost of Wind Energy Review - - def FC(self): - """ - This method returns the finance charge cost of a wind plant as - determined by a constant factor. As the rating of a wind plant grows, - the cost of the wind plant grows as well. - - Returns: - float: The finance charge cost of a wind plant in units of $/kWh. - """ - return 155.0 # $/kW - Taken from 2016 Cost of Wind Energy Review - - def O_M(self): - """ - This method returns the operational cost of a wind plant as determined - by a constant factor. As the rating of a wind plant grows, the cost of - the wind plant grows as well. - - Returns: - float: The operational cost of a wind plant in units of $/kWh. - """ - return 52.0 # $/kW - Taken from 2016 Cost of Wind Energy Review - - def COE(self, height, AEP_sum): - """ - This method calculates and returns the cost of energy of a wind plant. - This cost of energy (COE) formulation for a wind plant varies based on - turbine height, rotor diameter, and total annualized energy production - (AEP). The components of the COE equation are defined throughout the - BaseCOE class. - - Args: - height (float): The hub height of the turbines in meters - (all turbines are set to the same height). - AEP_sum (float): The annualized energy production (AEP) - for the wind plant as calculated across the wind rose - in kWh. - - Returns: - float: The cost of energy for a wind plant in units of - $/kWh. - """ - # Comptue Cost of Energy (COE) as $/kWh for a plant - return ( - self.FCR() * (self.TCC(height) + self.BOS() + self.FC()) + self.O_M() - ) / (AEP_sum / 1000 / self.opt_obj.plant_kw) diff --git a/floris/tools/optimization/legacy/scipy/cluster_turbines.py b/floris/tools/optimization/legacy/scipy/cluster_turbines.py deleted file mode 100644 index b402cd3b8..000000000 --- a/floris/tools/optimization/legacy/scipy/cluster_turbines.py +++ /dev/null @@ -1,184 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np - - -def cluster_turbines(fi, wind_direction=None, wake_slope=0.30, plot_lines=False): - """Separate a wind farm into separate clusters in which the turbines in - each subcluster only affects the turbines in its cluster and has zero - interaction with turbines from other clusters, both ways (being waked, - generating wake), This allows the user to separate the control setpoint - optimization in several lower-dimensional optimization problems, for - example. This function assumes a very simplified wake function where the - wakes are assumed to have a linearly diverging profile. In comparisons - with the FLORIS GCH model, the wake_slope matches well with the FLORIS' - wake profiles for a value of wake_slope = 0.5 * turbulence_intensity, where - turbulence_intensity is an input to the FLORIS model at the default - GCH parameterization. Note that does not include wind direction variability. - To be conservative, the user is recommended to use the rule of thumb: - `wake_slope = turbulence_intensity`. Hence, the default value for - `wake_slope=0.30` should be conservative for turbulence intensities up to - 0.30 and is likely to provide valid estimates of which turbines are - downstream until a turbulence intensity of 0.50. This simple model saves - time compared to FLORIS. - - Args: - fi ([floris object]): FLORIS object of the farm of interest. - wind_direction (float): The wind direction in the FLORIS frame - of reference for which the downstream turbines are to be determined. - wake_slope (float, optional): linear slope of the wake (dy/dx) - plot_lines (bool, optional): Enable plotting wakes/turbines. - Defaults to False. - - Returns: - clusters (iterable): A list in which each entry contains a list - of turbine numbers that together form a cluster which - exclusively interact with one another and have zero - interaction with turbines outside of this cluster. - """ - - if wind_direction is None: - wind_direction = np.mean(fi.floris.farm.wind_direction) - - # Get farm layout - x = fi.layout_x - y = fi.layout_y - D = np.array([t.rotor_diameter for t in fi.floris.farm.turbines]) - n_turbs = len(x) - - # Rotate farm and determine freestream/waked turbines - is_downstream = [False for _ in range(n_turbs)] - x_rot = ( - np.cos((wind_direction - 270.0) * np.pi / 180.0) * x - - np.sin((wind_direction - 270.0) * np.pi / 180.0) * y - ) - y_rot = ( - np.sin((wind_direction - 270.0) * np.pi / 180.0) * x - + np.cos((wind_direction - 270.0) * np.pi / 180.0) * y - ) - - if plot_lines: - fig, ax = plt.subplots() - for ii in range(n_turbs): - ax.plot( - x_rot[ii] * np.ones(2), - [y_rot[ii] - D[ii] / 2, y_rot[ii] + D[ii] / 2], - "k", - ) - for ii in range(n_turbs): - ax.text(x_rot[ii], y_rot[ii], "T%03d" % ii) - ax.axis("equal") - - srt = np.argsort(x_rot) - usrt = np.argsort(srt) - x_rot_srt = x_rot[srt] - y_rot_srt = y_rot[srt] - affected_by_turbs = np.tile(False, (n_turbs, n_turbs)) - for ii in range(n_turbs): - x0 = x_rot_srt[ii] - y0 = y_rot_srt[ii] - - def wake_profile_ub_turbii(x): - y = (y0 + D[ii]) + (x - x0) * wake_slope - if isinstance(y, (float, np.float64, np.float32)): - if x < (x0 + 0.01): - y = -np.Inf - else: - y[x < x0 + 0.01] = -np.Inf - return y - - def wake_profile_lb_turbii(x): - y = (y0 - D[ii]) - (x - x0) * wake_slope - if isinstance(y, (float, np.float64, np.float32)): - if x < (x0 + 0.01): - y = -np.Inf - else: - y[x < x0 + 0.01] = -np.Inf - return y - - def determine_if_in_wake(xt, yt): - return (yt < wake_profile_ub_turbii(xt)) & (yt > wake_profile_lb_turbii(xt)) - - # Get most downstream turbine - is_downstream[ii] = not any( - determine_if_in_wake(x_rot_srt[iii], y_rot_srt[iii]) for iii in range(n_turbs) - ) - # Determine which turbines are affected by this turbine ('ii') - affecting_following_turbs = [ - determine_if_in_wake(x_rot_srt[iii], y_rot_srt[iii]) - for iii in range(n_turbs) - ] - - # Determine by which turbines this turbine ('ii') is affected - for aft in np.where(affecting_following_turbs)[0]: - affected_by_turbs[aft, ii] = True - - if plot_lines: - x1 = np.max(x_rot_srt) + 500.0 - ax.fill_between( - [x0, x1, x1, x0], - [ - wake_profile_ub_turbii(x0 + 0.02), - wake_profile_ub_turbii(x1), - wake_profile_lb_turbii(x1), - wake_profile_lb_turbii(x0 + 0.02), - ], - alpha=0.1, - color="k", - edgecolor=None, - ) - - # Rearrange into initial frame of reference - affected_by_turbs = affected_by_turbs[:, usrt][usrt, :] - for ii in range(n_turbs): - affected_by_turbs[ii, ii] = True # Add self to turb_list_affected - affected_by_turbs = [np.where(c)[0] for c in affected_by_turbs] - - # List of downstream turbines - turbs_downstream = [is_downstream[i] for i in usrt] - turbs_downstream = list(np.where(turbs_downstream)[0]) - - # Initialize one cluster for each turbine and all the turbines its affected by - clusters = affected_by_turbs - - # Iteratively merge clusters if any overlap between turbines - ci = 0 - while ci < len(clusters): - # Compare current row to the ones to the right of it - cj = ci + 1 - merged_column = False - while cj < len(clusters): - if any(y in clusters[ci] for y in clusters[cj]): - # Merge - clusters[ci] = np.hstack([clusters[ci], clusters[cj]]) - clusters[ci] = np.array(np.unique(clusters[ci]), dtype=int) - clusters.pop(cj) - merged_column = True - else: - cj = cj + 1 - if not merged_column: - ci = ci + 1 - - if plot_lines: - ax.set_title("wind_direction = %.1f deg" % wind_direction) - ax.set_xlim([np.min(x_rot) - 500.0, x1]) - ax.set_ylim([np.min(y_rot) - 500.0, np.max(y_rot) + 500.0]) - for ci, cl in enumerate(clusters): - ax.plot(x_rot[cl], y_rot[cl], 'o', label='cluster %d' % ci) - ax.legend() - - return clusters diff --git a/floris/tools/optimization/legacy/scipy/layout.py b/floris/tools/optimization/legacy/scipy/layout.py deleted file mode 100644 index ebdcc50d1..000000000 --- a/floris/tools/optimization/legacy/scipy/layout.py +++ /dev/null @@ -1,441 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import matplotlib.pyplot as plt -import numpy as np -from scipy.optimize import minimize - -from .optimization import Optimization - - -class LayoutOptimization(Optimization): - """ - Layout is a subclass of the - :py:class:`~.tools.optimization.scipy.optimization.Optimization` class - that is used to perform layout optimization. - """ - - def __init__( - self, - fi, - boundaries, - wd, - ws, - freq, - AEP_initial, - x0=None, - bnds=None, - min_dist=None, - opt_method="SLSQP", - opt_options=None, - ): - """ - Instantiate LayoutOptimization object with a FlorisInterface object and - assign parameter values. - - Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - boundaries (iterable(float, float)): Pairs of x- and y-coordinates - that represent the boundary's vertices (m). - wd (np.array): An array of wind directions (deg). - ws (np.array): An array of wind speeds (m/s). - freq (np.array): An array of the frequencies of occurance - correponding to each pair of wind direction and wind speed - values. - AEP_initial (float): The initial Annual Energy - Production used for normalization in the optimization (Wh) - (TODO: Is Watt-hours the correct unit?). - x0 (iterable, optional): The initial turbine locations, - ordered by x-coordinate and then y-coordiante - (ie. [x1, x2, ..., xn, y1, y2, ..., yn]) (m). If none are - provided, x0 initializes to the current turbine locations. - Defaults to None. - bnds (iterable, optional): Bounds for the optimization - variables (pairs of min/max values for each variable (m)). If - none are specified, they are set to the min. and max. of the - boundaries iterable. Defaults to None. - min_dist (float, optional): The minimum distance to be - maintained between turbines during the optimization (m). If not - specified, initializes to 2 rotor diameters. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dict, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': True, 'iprint': 2, 'ftol': 1e-9}. - Defaults to None. - """ - super().__init__(fi) - self.epsilon = np.finfo(float).eps - - if opt_options is None: - self.opt_options = {"maxiter": 100, "disp": True, "iprint": 2, "ftol": 1e-9} - - self.reinitialize_opt( - boundaries=boundaries, - wd=wd, - ws=ws, - freq=freq, - AEP_initial=AEP_initial, - x0=x0, - bnds=bnds, - min_dist=min_dist, - opt_method=opt_method, - opt_options=opt_options, - ) - - # Private methods - - def _AEP_layout_opt(self, locs): - locs_unnorm = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in locs[0 : self.nturbs] - ] + [ - self._unnorm(valy, self.bndy_min, self.bndy_max) - for valy in locs[self.nturbs : 2 * self.nturbs] - ] - self._change_coordinates(locs_unnorm) - AEP_sum = self._AEP_loop_wd() - return -1 * AEP_sum / self.AEP_initial - - def _AEP_single_wd(self, wd, ws, freq): - self.fi.reinitialize_flow_field(wind_direction=[wd], wind_speed=[ws]) - self.fi.calculate_wake() - - turb_powers = [turbine.power for turbine in self.fi.floris.farm.turbines] - return np.sum(turb_powers) * freq * 8760 - - def _AEP_loop_wd(self): - AEP_sum = 0 - - for i in range(len(self.wd)): - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], wind_speed=[self.ws[i]] - ) - self.fi.calculate_wake() - - AEP_sum = AEP_sum + self.fi.get_farm_power() * self.freq[i] * 8760 - return AEP_sum - - def _change_coordinates(self, locs): - # Parse the layout coordinates - layout_x = locs[0 : self.nturbs] - layout_y = locs[self.nturbs : 2 * self.nturbs] - layout_array = [layout_x, layout_y] - - # Update the turbine map in floris - self.fi.reinitialize_flow_field(layout_array=layout_array) - - def _space_constraint(self, x_in, min_dist): - x = np.nan_to_num(x_in[0 : self.nturbs]) - y = np.nan_to_num(x_in[self.nturbs :]) - - dist = [ - np.sqrt((x[i] - x[j]) ** 2 + (y[i] - y[j]) ** 2) - for i in range(self.nturbs) - for j in range(self.nturbs) - if i != j - ] - - # dist = [] - # for i in range(self.nturbs): - # for j in range(self.nturbs): - # if i != j: - # dist.append(np.sqrt( (x[i]-x[j])**2 + (y[i]-y[j])**2)) - - return np.min(dist) - self._norm(min_dist, self.bndx_min, self.bndx_max) - - def _distance_from_boundaries(self, x_in, boundaries): - # x = self._unnorm(x_in[0:self.nturbs], self.bndx_min, self.bndx_max) - # y = self._unnorm(x_in[self.nturbs:2*self.nturbs], \ - # self.bndy_min, self.bndy_max) - x = x_in[0 : self.nturbs] - y = x_in[self.nturbs : 2 * self.nturbs] - - dist_out = [] - - for k in range(self.nturbs): - dist = [] - in_poly = self._point_inside_polygon(x[k], y[k], boundaries) - - for i in range(len(boundaries)): - boundaries = np.array(boundaries) - p1 = boundaries[i] - if i == len(boundaries) - 1: - p2 = boundaries[0] - else: - p2 = boundaries[i + 1] - - px = p2[0] - p1[0] - py = p2[1] - p1[1] - norm = px * px + py * py - - u = ( - (x[k] - boundaries[i][0]) * px + (y[k] - boundaries[i][1]) * py - ) / float(norm) - - if u <= 0: - xx = p1[0] - yy = p1[1] - elif u >= 1: - xx = p2[0] - yy = p2[1] - else: - xx = p1[0] + u * px - yy = p1[1] + u * py - - dx = x[k] - xx - dy = y[k] - yy - dist.append(np.sqrt(dx * dx + dy * dy)) - - dist = np.array(dist) - if in_poly: - dist_out.append(np.min(dist)) - else: - dist_out.append(-np.min(dist)) - - dist_out = np.array(dist_out) - - return np.min(dist_out) - - def _point_inside_polygon(self, x, y, poly): - n = len(poly) - inside = False - - p1x, p1y = poly[0] - for i in range(n + 1): - p2x, p2y = poly[i % n] - if y > min(p1y, p2y): - if y <= max(p1y, p2y): - if x <= max(p1x, p2x): - if p1y != p2y: - xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x - if p1x == p2x or x <= xinters: - inside = not inside - p1x, p1y = p2x, p2y - - return inside - - def _generate_constraints(self): - # grad_constraint1 = grad(self._space_constraint) - # grad_constraint2 = grad(self._distance_from_boundaries) - - tmp1 = { - "type": "ineq", - "fun": lambda x, *args: self._space_constraint(x, self.min_dist), - "args": (self.min_dist,), - } - tmp2 = { - "type": "ineq", - "fun": lambda x, *args: self._distance_from_boundaries( - x, self.boundaries_norm - ), - "args": (self.boundaries_norm,), - } - - self.cons = [tmp1, tmp2] - - def _optimize(self): - self.residual_plant = minimize( - self._AEP_layout_opt, - self.x0, - method=self.opt_method, - bounds=self.bnds, - constraints=self.cons, - options=self.opt_options, - ) - - opt_results = self.residual_plant.x - - return opt_results - - def _set_opt_bounds(self): - self.bnds = [(0.0, 1.0) for _ in range(2 * self.nturbs)] - - # Public methods - - def optimize(self): - """ - This method finds the optimized layout of wind turbines for power - production given the provided frequencies of occurance of wind - conditions (wind speed, direction). - - Returns: - opt_locs (iterable): A list of the optimized locations of each - turbine (m). - """ - print("=====================================================") - print("Optimizing turbine layout...") - print("Number of parameters to optimize = ", len(self.x0)) - print("=====================================================") - - opt_locs_norm = self._optimize() - - print("Optimization complete.") - - opt_locs = [ - [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in opt_locs_norm[0 : self.nturbs] - ], - [ - self._unnorm(valy, self.bndy_min, self.bndy_max) - for valy in opt_locs_norm[self.nturbs : 2 * self.nturbs] - ], - ] - - return opt_locs - - def reinitialize_opt( - self, - boundaries=None, - wd=None, - ws=None, - freq=None, - AEP_initial=None, - x0=None, - bnds=None, - min_dist=None, - opt_method=None, - opt_options=None, - ): - """ - This method reinitializes any optimization parameters that are - specified. Otherwise, the current parameter values are kept. - - Args: - boundaries (iterable(float, float)): Pairs of x- and y-coordinates - that represent the boundary's vertices (m). - wd (np.array): An array of wind directions (deg). Defaults to None. - ws (np.array): An array of wind speeds (m/s). Defaults to None. - freq (np.array): An array of the frequencies of occurance - correponding to each pair of wind direction and wind speed - values. Defaults to None. - AEP_initial (float): The initial Annual Energy - Production used for normalization in the optimization (Wh). If - not specified, initializes to the AEP of the current Floris - object. Defaults to None. - x0 (iterable, optional): The initial turbine locations, - ordered by x-coordinate and then y-coordiante (ie. [x1, x2, ... - , xn, y1, y2, ..., yn] (m)). If none are provided, x0 - initializes to the current turbine locations. Defaults to None. - bnds (iterable, optional): Bounds for the optimization - variables (pairs of min/max values for each variable (m)). If - none are specified, they are set to the min. and max. of the - boundaries iterable. Defaults to None. - min_dist (float, optional): The minimum distance to be maintained - between turbines during the optimization (m). If not specified, - initializes to 2 rotor diameters. Defaults to None. - opt_method (str, optional): The optimization method for - scipy.optimize.minize to use. If none is specified, initializes - to 'SLSQP'. Defaults to None. - opt_options (dict, optional): Dicitonary for setting the - optimization options. Defaults to None. - """ - if boundaries is not None: - self.boundaries = boundaries - self.bndx_min = np.min([val[0] for val in boundaries]) - self.bndy_min = np.min([val[1] for val in boundaries]) - self.bndx_max = np.max([val[0] for val in boundaries]) - self.bndy_max = np.max([val[1] for val in boundaries]) - self.boundaries_norm = [ - [ - self._norm(val[0], self.bndx_min, self.bndx_max), - self._norm(val[1], self.bndy_min, self.bndy_max), - ] - for val in self.boundaries - ] - if wd is not None: - self.wd = wd - if ws is not None: - self.ws = ws - if freq is not None: - self.freq = freq - if AEP_initial is not None: - self.AEP_initial = AEP_initial - else: - self.AEP_initial = self.fi.get_farm_AEP(self.wd, self.ws, self.freq) - if x0 is not None: - self.x0 = x0 - else: - self.x0 = [ - self._norm(coord.x1, self.bndx_min, self.bndx_max) - for coord in self.fi.floris.farm.turbine_map.coords - ] + [ - self._norm(coord.x2, self.bndy_min, self.bndy_max) - for coord in self.fi.floris.farm.turbine_map.coords - ] - if bnds is not None: - self.bnds = bnds - else: - self._set_opt_bounds() - if min_dist is not None: - self.min_dist = min_dist - else: - self.min_dist = 2 * self.fi.floris.farm.turbines[0].rotor_diameter - if opt_method is not None: - self.opt_method = opt_method - if opt_options is not None: - self.opt_options = opt_options - - self._generate_constraints() - - def plot_layout_opt_results(self): - """ - This method plots the original and new locations of the turbines in a - wind farm after layout optimization. - """ - locsx_old = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in self.x0[0 : self.nturbs] - ] - locsy_old = [ - self._unnorm(valy, self.bndy_min, self.bndy_max) - for valy in self.x0[self.nturbs : 2 * self.nturbs] - ] - locsx = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in self.residual_plant.x[0 : self.nturbs] - ] - locsy = [ - self._unnorm(valy, self.bndy_min, self.bndy_max) - for valy in self.residual_plant.x[self.nturbs : 2 * self.nturbs] - ] - - plt.figure(figsize=(9, 6)) - fontsize = 16 - plt.plot(locsx_old, locsy_old, "ob") - plt.plot(locsx, locsy, "or") - # plt.title('Layout Optimization Results', fontsize=fontsize) - plt.xlabel("x (m)", fontsize=fontsize) - plt.ylabel("y (m)", fontsize=fontsize) - plt.axis("equal") - plt.grid() - plt.tick_params(which="both", labelsize=fontsize) - plt.legend( - ["Old locations", "New locations"], - loc="lower center", - bbox_to_anchor=(0.5, 1.01), - ncol=2, - fontsize=fontsize, - ) - - verts = self.boundaries - for i in range(len(verts)): - if i == len(verts) - 1: - plt.plot([verts[i][0], verts[0][0]], [verts[i][1], verts[0][1]], "b") - else: - plt.plot( - [verts[i][0], verts[i + 1][0]], [verts[i][1], verts[i + 1][1]], "b" - ) diff --git a/floris/tools/optimization/legacy/scipy/layout_height.py b/floris/tools/optimization/legacy/scipy/layout_height.py deleted file mode 100644 index dc4b23f54..000000000 --- a/floris/tools/optimization/legacy/scipy/layout_height.py +++ /dev/null @@ -1,303 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import matplotlib.pyplot as plt -import numpy as np -from scipy.optimize import minimize - -from .base_COE import BaseCOE -from .layout import LayoutOptimization - - -class LayoutHeightOptimization(LayoutOptimization): - """ - LayoutHeightOptimization is a subclass of - :py:class:`~.tools.optimization.scipy.layout.LayoutOptimization` that - performs layout and turbine height optimization. This optimization method - aims to minimize Cost of Energy (COE) by changing individual turbine - locations and all turbine heights across the wind farm. Note that the - changing turbine height applies to all turbines, i.e. although the turbine - height is changing, all turbines will be assigned the same turbine height. - """ - - def __init__( - self, - fi, - boundaries, - height_lims, - wd, - ws, - freq, - AEP_initial, - COE_initial, - plant_kw, - x0=None, - bnds=None, - min_dist=None, - opt_method="SLSQP", - opt_options=None, - ): - """ - Instantiate LayoutHeightOptimization object with a FlorisInterface - object and assign parameter values. - - Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - boundaries (iterable(float, float)): Pairs of x- and y-coordinates - that represent the boundary's vertices (m). - height_lims (iterable): A list of the minimum and maximum - height limits for the optimization (m). Each value only - needs to be defined once since all the turbine heights - are the same (ie. [h_min, h_max]). - wd (np.array): An array of wind directions (deg). - ws (np.array): An array of wind speeds (m/s). - freq (np.array): An array of the frequencies of occurance - correponding to each pair of wind direction and wind speed - values. - AEP_initial (float): The initial Annual Energy - Production used for normalization in the optimization (Wh) - (TODO: Is Watt-hours the correct unit?). - COE_initial (float): Initial Cost of Energy used for - normalization in the optimization ($/kWh). - plant_kw (float): The rating of the entire wind plant (kW). - x0 (iterable, optional): The initial turbine locations, - ordered by x-coordinate and then y-coordiante - (ie. [x1, x2, ..., xn, y1, y2, ..., yn]), and the - initial turbine hub height (m). If none are provided, x0 - initializes to the current turbine locations and hub height. - Defaults to None. - bnds (iterable, optional): Bounds for the optimization - variables (TODO: just coordinates, or height too?) (pairs of - min/max values for each variable (m)). If none are specified, - they are set to the min. and max. of the boundaries iterable. - Defaults to None. - min_dist (float, optional): The minimum distance to be - maintained between turbines during the optimization (m). If not - specified, initializes to 2 rotor diameters. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dict, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': True, 'iprint': 2, 'ftol': 1e-9}. - Defaults to None. - """ - super().__init__(fi, boundaries, wd, ws, freq, AEP_initial) - self.epsilon = np.finfo(float).eps - - self.COE_model = BaseCOE(self) - - self.reinitialize_opt_height( - boundaries=boundaries, - height_lims=height_lims, - wd=wd, - ws=ws, - freq=freq, - AEP_initial=AEP_initial, - COE_initial=COE_initial, - plant_kw=plant_kw, - x0=x0, - bnds=bnds, - min_dist=min_dist, - opt_method=opt_method, - opt_options=opt_options, - ) - - # Private methods - - def _fCp_outside(self): - pass # for future use - - def _fCt_outside(self): - pass # for future use - - def _set_initial_conditions(self): - self.x0.append( - self._norm( - self.fi.floris.farm.turbines[0].hub_height, self.bndh_min, self.bndh_max - ) - ) - - def _set_opt_bounds_height(self): - self.bnds.append((0.0, 1.0)) - - def _optimize(self): - self.residual_plant = minimize( - self._COE_layout_height_opt, - self.x0, - method=self.opt_method, - bounds=self.bnds, - constraints=self.cons, - options=self.opt_options, - ) - - opt_results = self.residual_plant.x - - return opt_results - - def _COE_layout_height_opt(self, opt_vars): - locs = self._unnorm(opt_vars[0 : 2 * self.nturbs], self.bndx_min, self.bndx_max) - height = self._unnorm(opt_vars[-1], self.bndh_min, self.bndh_max) - - self._change_height(height) - self._change_coordinates(locs) - AEP_sum = self._AEP_loop_wd() - COE = self.COE_model.COE(height, AEP_sum) - - return COE / self.COE_initial - - def _change_height(self, height): - if isinstance(height, float) or isinstance(height, int): - for turb in self.fi.floris.farm.turbines: - turb.hub_height = height - else: - for k, turb in enumerate(self.fi.floris.farm.turbines): - turb.hub_height = height[k] - - self.fi.reinitialize_flow_field( - layout_array=((self.fi.layout_x, self.fi.layout_y)) - ) - - # Public methods - - def reinitialize_opt_height( - self, - boundaries=None, - height_lims=None, - wd=None, - ws=None, - freq=None, - AEP_initial=None, - COE_initial=None, - plant_kw=None, - x0=None, - bnds=None, - min_dist=None, - opt_method=None, - opt_options=None, - ): - """ - This method reinitializes any optimization parameters that are - specified. Otherwise, the current parameter values are kept. - - Args: - boundaries (iterable(float, float)): Pairs of x- and y-coordinates - that represent the boundary's vertices (m). - height_lims (iterable): A list of the minimum and maximum - height limits for the optimization (m). Each value only - needs to be defined once since all the turbine heights - are the same (ie. [h_min, h_max]). Defaults to None. - wd (np.array): An array of wind directions (deg). Defaults to None. - ws (np.array): An array of wind speeds (m/s). Defaults to None. - freq (np.array): An array of the frequencies of occurance - correponding to each pair of wind direction and wind speed - values. Defaults to None. - AEP_initial (float): The initial Annual Energy - Production used for normalization in the optimization (Wh). - Defaults to None. - COE_initial (float): Initial Cost of Energy used for - normalization in the optimization ($/kWh). Defaults to None. - plant_kw (float): The rating of the entire wind plant (kW). - Defaults to None. - x0 (iterable, optional): The initial turbine locations, - ordered by x-coordinate and then y-coordiante - (ie. [x1, x2, ..., xn, y1, y2, ..., yn]), and the - initial turbine hub height (m). If none are provided, x0 - initializes to the current turbine locations and hub height. - Defaults to None. - bnds (iterable, optional): Bounds for the optimization - variables (TODO: just coordinates, or height too?) (pairs of - min/max values for each variable (m)). If none are specified, - they are set to the min. and max. of the boundaries iterable. - Defaults to None. - min_dist (float, optional): The minimum distance to be - maintained between turbines during the optimization (m). If not - specified, initializes to 2 rotor diameters. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dict, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': True, 'iprint': 2, 'ftol': 1e-9}. - Defaults to None. - """ - LayoutOptimization.reinitialize_opt( - self, - boundaries=boundaries, - wd=wd, - ws=ws, - freq=freq, - AEP_initial=AEP_initial, - x0=x0, - bnds=bnds, - min_dist=min_dist, - opt_method=opt_method, - opt_options=opt_options, - ) - - if height_lims is not None: - self.bndh_min = height_lims[0] - self.bndh_max = height_lims[1] - if COE_initial is not None: - self.COE_initial = COE_initial - if plant_kw is not None: - self.plant_kw = plant_kw - - self._set_initial_conditions() - self._set_opt_bounds_height() - - def optimize(self): - """ - This method finds the optimized layout of wind turbines and wind - turbine height for power production and cost of energy given the - provided frequencies of occurance of wind conditions (wind speed, - direction). - - Returns: - (iterable): A list containing the optimized (x, y) locations of - each turbine followed by the optimized height for all turbines (m). - """ - print("=====================================================") - print("Optimizing turbine layout and height...") - print("Number of parameters to optimize = ", len(self.x0)) - print("=====================================================") - - opt_results_norm = self._optimize() - - print("Optimization complete.") - - opt_locs = [ - [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in opt_results_norm[0 : self.nturbs] - ], - [ - self._unnorm(valy, self.bndy_min, self.bndy_max) - for valy in opt_results_norm[self.nturbs : 2 * self.nturbs] - ], - ] - - opt_height = [self._unnorm(opt_results_norm[-1], self.bndh_min, self.bndh_max)] - - return [opt_locs, opt_height] - - def get_farm_COE(self): - """ - This method returns the cost of energy (COE) for the wind farm. - - Returns: - float: The cost of energy for a wind plant in units of $/kWh. - """ - AEP_sum = self._AEP_loop_wd() - height = self.fi.floris.farm.turbines[0].hub_height - return self.COE_model.COE(height, AEP_sum) diff --git a/floris/tools/optimization/legacy/scipy/optimization.py b/floris/tools/optimization/legacy/scipy/optimization.py deleted file mode 100644 index 621b1133f..000000000 --- a/floris/tools/optimization/legacy/scipy/optimization.py +++ /dev/null @@ -1,59 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import numpy as np - - -class Optimization: - """ - Optimization is the base optimization class for - `~.tools.optimization.scipy` subclasses. Contains some common - methods and properties that can be used by the individual optimization - classes. - """ - - def __init__(self, fi): - """ - Initializes an Optimization object by assigning a - FlorisInterface object. - - Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - """ - self.fi = fi - - # Private methods - - def _reinitialize(self): - pass - - def _norm(self, val, x1, x2): - return (val - x1) / (x2 - x1) - - def _unnorm(self, val, x1, x2): - return np.array(val) * (x2 - x1) + x1 - - # Properties - - @property - def nturbs(self): - """ - Number of turbines in the :py:class:`~.farm.Farm` object. - - Returns: - int - """ - self._nturbs = len(self.fi.floris.farm.turbine_map.turbines) - return self._nturbs diff --git a/floris/tools/optimization/legacy/scipy/power_density.py b/floris/tools/optimization/legacy/scipy/power_density.py deleted file mode 100644 index acfb91568..000000000 --- a/floris/tools/optimization/legacy/scipy/power_density.py +++ /dev/null @@ -1,502 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import matplotlib.pyplot as plt -import numpy as np -from scipy.optimize import minimize - -from .layout import LayoutOptimization - - -class PowerDensityOptimization(LayoutOptimization): - """ - PowerDensityOptimization is a subclass of the - :py:class:`~.tools.optimization.scipy.layout.LayoutOptimization` class - that performs power density optimization. - """ - - def __init__( - self, - fi, - boundaries, - wd, - ws, - freq, - AEP_initial, - yawbnds=None, - x0=None, - bnds=None, - min_dist=None, - opt_method="SLSQP", - opt_options=None, - ): - """ - Instantiate PowerDensityOptimization object with a FlorisInterface - object and assigns parameter values. - - Args: - fi (:py:class:`floris.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - boundaries (iterable(float, float)): Pairs of x- and y-coordinates - that represent the boundary's vertices (m). - wd (np.array): An array of wind directions (deg). - ws (np.array): An array of wind speeds (m/s). - freq (np.array): An array of the frequencies of occurance - correponding to each pair of wind direction and wind speed - values. - AEP_initial (float): The initial Annual Energy - Production used for normalization in the optimization (Wh) - (TODO: Is Watt-hours the correct unit?). - yawbnds: TODO: This parameter isn't used. Remove it? - x0 (iterable, optional): The initial turbine locations, - ordered by x-coordinate and then y-coordiante - (ie. [x1, x2, ..., xn, y1, y2, ..., yn]) (m). If none are - provided, x0 initializes to the current turbine locations. - Defaults to None. - bnds (iterable, optional): Bounds for the optimization - variables (pairs of min/max values for each variable (m)). If - none are specified, they are set to (0, 1) for each turbine. - Defaults to None. TODO: Explain significance of (0, 1). - min_dist (float, optional): The minimum distance to be - maintained between turbines during the optimization (m). If not - specified, initializes to 4 rotor diameters. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dict, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set t - {'maxiter': 100, 'disp': True, 'iprint': 2, 'ftol': 1e-9}. - Defaults to None. - """ - super().__init__( - fi, - boundaries, - wd, - ws, - freq, - AEP_initial, - x0=x0, - bnds=bnds, - min_dist=min_dist, - opt_method=opt_method, - opt_options=opt_options, - ) - self.epsilon = np.finfo(float).eps - self.counter = 0 - - if opt_options is None: - self.opt_options = {"maxiter": 100, "disp": True, "iprint": 2, "ftol": 1e-9} - - def _generate_constraints(self): - # grad_constraint1 = grad(self._space_constraint) - # grad_constraint2 = grad(self._distance_from_boundaries) - - tmp1 = { - "type": "ineq", - "fun": lambda x, *args: self._space_constraint(x, self.min_dist), - "args": (self.min_dist,), - } - tmp2 = { - "type": "ineq", - "fun": lambda x, *args: self._distance_from_boundaries( - x, self.boundaries_norm - ), - "args": (self.boundaries_norm,), - } - tmp3 = {"type": "ineq", "fun": lambda x, *args: self._AEP_constraint(x)} - - self.cons = [tmp1, tmp2, tmp3] - - def _set_opt_bounds(self): - self.bnds = [ - (0.0, 1.0) for _ in range(2 * self.nturbs + self.nturbs * len(self.wd)) - ] - - def _change_coordinates(self, locsx, locsy): - # Parse the layout coordinates - layout_array = [locsx, locsy] - - # Update the turbine map in floris - self.fi.reinitialize_flow_field(layout_array=layout_array) - - def _powDens_opt(self, optVars): - locsx = optVars[0 : self.nturbs] - locsy = optVars[self.nturbs : 2 * self.nturbs] - - locsx_unnorm = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) for valx in locsx - ] - locsy_unnorm = [ - self._unnorm(valy, self.bndy_min, self.bndy_max) for valy in locsy - ] - - turb_controls = [ - optVars[ - 2 * self.nturbs + i * self.nturbs : 3 * self.nturbs + i * self.nturbs - ] - for i in range(len(self.wd)) - ] - - turb_controls_unnorm = [ - self._unnorm(yaw, self.yaw_min, self.yaw_max) for yaw in turb_controls - ] - - self._change_coordinates(locsx_unnorm, locsy_unnorm) - opt_area = self.find_layout_area(locsx_unnorm + locsy_unnorm) - - AEP_sum = 0.0 - - for i in range(len(self.wd)): - for j, turbine in enumerate(self.fi.floris.farm.turbine_map.turbines): - turbine.yaw_angle = turb_controls_unnorm[i][j] - - AEP_sum = AEP_sum + self._AEP_single_wd( - self.wd[i], self.ws[i], self.freq[i] - ) - - # print('AEP ratio: ', AEP_sum/self.AEP_initial) - - return -1 * AEP_sum / self.AEP_initial * self.initial_area / opt_area - - def _AEP_constraint(self, optVars): - locsx = optVars[0 : self.nturbs] - locsy = optVars[self.nturbs : 2 * self.nturbs] - - locsx_unnorm = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) for valx in locsx - ] - locsy_unnorm = [ - self._unnorm(valy, self.bndy_min, self.bndy_max) for valy in locsy - ] - - turb_controls = [ - optVars[ - 2 * self.nturbs + i * self.nturbs : 3 * self.nturbs + i * self.nturbs - ] - for i in range(len(self.wd)) - ] - - turb_controls_unnorm = [ - self._unnorm(yaw, self.yaw_min, self.yaw_max) for yaw in turb_controls - ] - - self._change_coordinates(locsx_unnorm, locsy_unnorm) - - AEP_sum = 0.0 - - for i in range(len(self.wd)): - for j, turbine in enumerate(self.fi.floris.farm.turbine_map.turbines): - turbine.yaw_angle = turb_controls_unnorm[i][j] - - AEP_sum = AEP_sum + self._AEP_single_wd( - self.wd[i], self.ws[i], self.freq[i] - ) - - return AEP_sum / self.AEP_initial - 1.0 - - def _optimize(self): - self.residual_plant = minimize( - self._powDens_opt, - self.x0, - method=self.opt_method, - bounds=self.bnds, - constraints=self.cons, - options=self.opt_options, - ) - - opt_results = self.residual_plant.x - - return opt_results - - def optimize(self): - """ - This method finds the optimized layout of wind turbines for power - production given the provided frequencies of occurance of wind - conditions (wind speed, direction). - - TODO: update the doc - - Returns: - iterable: A list of the optimized x, y locations of each - turbine (m). - """ - print("=====================================================") - print("Optimizing turbine layout...") - print("Number of parameters to optimize = ", len(self.x0)) - print("=====================================================") - - opt_locs_norm = self._optimize() - - print("Optimization complete.") - - opt_locs = [ - [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in opt_locs_norm[0 : self.nturbs] - ], - [ - self._unnorm(valy, self.bndy_min, self.bndy_max) - for valy in opt_locs_norm[self.nturbs : 2 * self.nturbs] - ], - ] - - return opt_locs - - def reinitialize_opt( - self, - boundaries=None, - yawbnds=None, - wd=None, - ws=None, - freq=None, - AEP_initial=None, - x0=None, - bnds=None, - min_dist=None, - opt_method=None, - opt_options=None, - ): - """ - This method reinitializes any optimization parameters that are - specified. Otherwise, the current parameter values are kept. - - Args: - boundaries (iterable(float, float)): Pairs of x- and y-coordinates - that represent the boundary's vertices (m). - yawbnds (iterable): A list of the min. and max. yaw offset that is - allowed during the optimization (deg). If none are specified, - initialized to (0, 25.0). Defaults to None. - wd (np.array): An array of wind directions (deg). Defaults to None. - ws (np.array): An array of wind speeds (m/s). Defaults to None. - freq (np.array): An array of the frequencies of occurance - correponding to each pair of wind direction and wind speed - values. Defaults to None. - AEP_initial (float): The initial Annual Energy - Production used for normalization in the optimization (Wh) - (TODO: Is Watt-hours the correct unit?). If not specified, - initializes to the AEP of the current Floris object. Defaults - to None. - x0 (iterable, optional): The initial turbine locations, - ordered by x-coordinate and then y-coordiante - (ie. [x1, x2, ..., xn, y1, y2, ..., yn]) (m). If none are - provided, x0 initializes to the current turbine locations. - Defaults to None. - bnds (iterable, optional): Bounds for the optimization - variables (pairs of min/max values for each variable (m)). If - none are specified, they are set to (0, 1) for each turbine. - Defaults to None. - min_dist (float, optional): The minimum distance to be - maintained between turbines during the optimization (m). If not - specified, initializes to 4 rotor diameters. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to None. - opt_options (dict, optional): Optimization options used by - scipy.optimize.minize. Defaults to None. - """ - if boundaries is not None: - self.boundaries = boundaries - self.bndx_min = np.min([val[0] for val in boundaries]) - self.bndy_min = np.min([val[1] for val in boundaries]) - self.bndx_max = np.max([val[0] for val in boundaries]) - self.bndy_max = np.max([val[1] for val in boundaries]) - self.boundaries_norm = [ - [ - self._norm(val[0], self.bndx_min, self.bndx_max), - self._norm(val[1], self.bndy_min, self.bndy_max), - ] - for val in self.boundaries - ] - if yawbnds is not None: - self.yaw_min = yawbnds[0] - self.yaw_max = yawbnds[1] - else: - self.yaw_min = 0.0 - self.yaw_max = 25.0 - if wd is not None: - self.wd = wd - if ws is not None: - self.ws = ws - if freq is not None: - self.freq = freq - if AEP_initial is not None: - self.AEP_initial = AEP_initial - else: - self.AEP_initial = self.fi.get_farm_AEP(self.wd, self.ws, self.freq) - if x0 is not None: - self.x0 = x0 - else: - self.x0 = ( - [ - self._norm(coord.x1, self.bndx_min, self.bndx_max) - for coord in self.fi.floris.farm.turbine_map.coords - ] - + [ - self._norm(coord.x2, self.bndy_min, self.bndy_max) - for coord in self.fi.floris.farm.turbine_map.coords - ] - + [self._norm(5.0, self.yaw_min, self.yaw_max)] - * len(self.wd) - * self.nturbs - ) - if bnds is not None: - self.bnds = bnds - else: - self._set_opt_bounds() - if min_dist is not None: - self.min_dist = min_dist - else: - self.min_dist = 4 * self.fi.floris.farm.turbines[0].rotor_diameter - if opt_method is not None: - self.opt_method = opt_method - if opt_options is not None: - self.opt_options = opt_options - - self.layout_x_orig = [ - coord.x1 for coord in self.fi.floris.farm.turbine_map.coords - ] - self.layout_y_orig = [ - coord.x2 for coord in self.fi.floris.farm.turbine_map.coords - ] - - self._generate_constraints() - - self.initial_area = self.find_layout_area( - self.layout_x_orig + self.layout_y_orig - ) - - def find_layout_area(self, locs): - """ - This method returns the area occupied by the wind farm. - - Args: - locs (iterable): A list of the turbine coordinates, organized as - [x1, x2, ..., xn, y1, y2, ..., yn] (m). - - Returns: - float: The area occupied by the wind farm (m^2). - """ - locsx = locs[0 : self.nturbs] - locsy = locs[self.nturbs :] - - points = zip(locsx, locsy) - points = np.array(list(points)) - - hull = self.convex_hull(points) - - area = self.polygon_area( - np.array([val[0] for val in hull]), np.array([val[1] for val in hull]) - ) - - return area - - def convex_hull(self, points): - """ - Finds the vertices that describe the convex hull shape given the input - coordinates. - - Args: - points (iterable((float, float))): Coordinates of interest. - - Returns: - list: Vertices describing convex hull shape. - """ - # find two hull points, U, V, and split to left and right search - u = min(points, key=lambda p: p[0]) - v = max(points, key=lambda p: p[0]) - left, right = self.split(u, v, points), self.split(v, u, points) - - # find convex hull on each side - return [v] + self.extend(u, v, left) + [u] + self.extend(v, u, right) + [v] - - def polygon_area(self, x, y): - """ - Calculates the area of a polygon defined by its (x, y) vertices. - - Args: - x (iterable(float)): X-coordinates of polygon vertices. - y (iterable(float)): Y-coordinates of polygon vertices. - - Returns: - float: Area of polygon. - """ - # coordinate shift - x_ = x - x.mean() - y_ = y - y.mean() - - correction = x_[-1] * y_[0] - y_[-1] * x_[0] - main_area = np.dot(x_[:-1], y_[1:]) - np.dot(y_[:-1], x_[1:]) - return 0.5 * np.abs(main_area + correction) - - def split(self, u, v, points): - # TODO: Provide description of this method. - # return points on left side of UV - return [p for p in points if np.cross(p - u, v - u) < 0] - - def extend(self, u, v, points): - # TODO: Provide description of this method. - if not points: - return [] - - # find furthest point W, and split search to WV, UW - w = min(points, key=lambda p: np.cross(p - u, v - u)) - p1, p2 = self.split(w, v, points), self.split(u, w, points) - return self.extend(w, v, p1) + [w] + self.extend(u, w, p2) - - def plot_opt_results(self): - """ - This method plots the original and new locations of the turbines in a - wind farm after layout optimization. - """ - locsx_old = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in self.x0[0 : self.nturbs] - ] - locsy_old = [ - self._unnorm(valy, self.bndy_min, self.bndy_max) - for valy in self.x0[self.nturbs : 2 * self.nturbs] - ] - locsx = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in self.residual_plant.x[0 : self.nturbs] - ] - locsy = [ - self._unnorm(valy, self.bndy_min, self.bndy_max) - for valy in self.residual_plant.x[self.nturbs : 2 * self.nturbs] - ] - - plt.figure(figsize=(9, 6)) - fontsize = 16 - plt.plot(locsx_old, locsy_old, "ob") - plt.plot(locsx, locsy, "or") - # plt.title('Layout Optimization Results', fontsize=fontsize) - plt.xlabel("x (m)", fontsize=fontsize) - plt.ylabel("y (m)", fontsize=fontsize) - plt.axis("equal") - plt.grid() - plt.tick_params(which="both", labelsize=fontsize) - plt.legend( - ["Old locations", "New locations"], - loc="lower center", - bbox_to_anchor=(0.5, 1.01), - ncol=2, - fontsize=fontsize, - ) - - verts = self.boundaries - for i in range(len(verts)): - if i == len(verts) - 1: - plt.plot([verts[i][0], verts[0][0]], [verts[i][1], verts[0][1]], "b") - else: - plt.plot( - [verts[i][0], verts[i + 1][0]], [verts[i][1], verts[i + 1][1]], "b" - ) diff --git a/floris/tools/optimization/legacy/scipy/power_density_1D.py b/floris/tools/optimization/legacy/scipy/power_density_1D.py deleted file mode 100644 index e8a7d47ea..000000000 --- a/floris/tools/optimization/legacy/scipy/power_density_1D.py +++ /dev/null @@ -1,380 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import matplotlib.pyplot as plt -import numpy as np -from scipy.optimize import minimize - -from .optimization import Optimization - - -class PowerDensityOptimization1D(Optimization): - """ - PowerDensityOptimization1D is a subclass of the - :py:class:`~.tools.optimization.scipy.optimization.Optimization` class - that performs layout optimization in 1 dimension. TODO: What is this single - dimension? - """ - - def __init__( - self, - fi, - wd, - ws, - freq, - AEP_initial, - x0=None, - bnds=None, - min_dist=None, - opt_method="SLSQP", - opt_options=None, - ): - """ - Instantiate PowerDensityOptimization1D object with a FlorisInterface - object and assigns parameter values. - - Args: - fi (:py:class:`floris.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - wd (np.array): An array of wind directions (deg). - ws (np.array): An array of wind speeds (m/s). - freq (np.array): An array of the frequencies of occurance - correponding to each pair of wind direction and wind speed - values. - AEP_initial (float): The initial Annual Energy - Production used for normalization in the optimization (Wh) - (TODO: Is Watt-hours the correct unit?). - x0 (iterable, optional): The initial turbine locations, - ordered by x-coordinate and then y-coordiante - (ie. [x1, x2, ..., xn, y1, y2, ..., yn]) (m). If none are - provided, x0 initializes to the current turbine locations. - Defaults to None. - bnds (iterable, optional): Bounds for the optimization - variables (pairs of min/max values for each variable (m)). If - none are specified, they are set to some example values (TODO: - what is the significance of these example values?). Defaults to - None. - min_dist (float, optional): The minimum distance to be - maintained between turbines during the optimization (m). If not - specified, initializes to 2 rotor diameters. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dict, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': True, 'iprint': 2, 'ftol': 1e-9}. - Defaults to None. - """ - super().__init__(fi) - self.epsilon = np.finfo(float).eps - self.counter = 0 - - if opt_options is None: - self.opt_options = {"maxiter": 100, "disp": True, "iprint": 2, "ftol": 1e-9} - - self.reinitialize_opt( - wd=wd, - ws=ws, - freq=freq, - AEP_initial=AEP_initial, - x0=x0, - bnds=bnds, - min_dist=min_dist, - opt_method=opt_method, - opt_options=opt_options, - ) - - def _PowDens_opt(self, optVars): - locs = optVars[0 : self.nturbs] - locs_unnorm = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) for valx in locs - ] - turb_controls = [ - optVars[self.nturbs + i * self.nturbs : 2 * self.nturbs + i * self.nturbs] - for i in range(len(self.wd)) - ] - turb_controls_unnorm = [ - self._unnorm(yaw, self.yaw_min, self.yaw_max) for yaw in turb_controls - ] - - self._change_coordinates(locs_unnorm) - - for i, turbine in enumerate(self.fi.floris.farm.turbine_map.turbines): - turbine.yaw_angle = turb_controls_unnorm[0][i] - - layout_dist = self._avg_dist(locs) - # AEP_sum = self._AEP_single_wd(self.wd[0], self.ws[0]) - # print('AEP ratio: ', AEP_sum/self.AEP_initial) - - return layout_dist / self.layout_dist_initial - - def _avg_dist(self, locs): - dist = [] - for i in range(len(locs) - 1): - dist.append(locs[i + 1] - locs[i]) - - return np.mean(dist) - - def _change_coordinates(self, locs): - # Parse the layout coordinates - layout_x = locs - layout_y = [coord.x2 for coord in self.fi.floris.farm.turbine_map.coords] - layout_array = [layout_x, layout_y] - - # Update the turbine map in floris - self.fi.reinitialize_flow_field(layout_array=layout_array) - - def _set_opt_bounds(self): - # self.bnds = [(0.0, 1.0) for _ in range(2*self.nturbs)] - self.bnds = [ - (0.0, 0.0), - (0.083333, 0.25), - (0.166667, 0.5), - (0.25, 0.75), - (0.33333, 1.0), - (0.0, 1.0), - (0.0, 1.0), - (0.0, 1.0), - (0.0, 1.0), - (0.0, 1.0), - ] - - def _AEP_single_wd(self, wd, ws): - self.fi.reinitialize_flow_field(wind_direction=wd, wind_speed=ws) - self.fi.calculate_wake() - - turb_powers = [turbine.power for turbine in self.fi.floris.farm.turbines] - return np.sum(turb_powers) * self.freq[0] * 8760 - - def _AEP_constraint(self, optVars): - locs = optVars[0 : self.nturbs] - locs_unnorm = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) for valx in locs - ] - turb_controls = [ - optVars[self.nturbs + i * self.nturbs : 2 * self.nturbs + i * self.nturbs] - for i in range(len(self.wd)) - ] - turb_controls_unnorm = [ - self._unnorm(yaw, self.yaw_min, self.yaw_max) for yaw in turb_controls - ] - - for i, turbine in enumerate(self.fi.floris.farm.turbine_map.turbines): - turbine.yaw_angle = turb_controls_unnorm[0][i] - - self._change_coordinates(locs_unnorm) - - return ( - self._AEP_single_wd(self.wd[0], self.ws[0]) / self.AEP_initial - 1 - ) * 1000000.0 - - def _space_constraint(self, x_in, min_dist): - x = np.nan_to_num(x_in[0 : self.nturbs]) - y = np.nan_to_num(x_in[self.nturbs :]) - - dist = [ - np.sqrt((x[i] - x[j]) ** 2 + (y[i] - y[j]) ** 2) - for i in range(self.nturbs) - for j in range(self.nturbs) - if i != j - ] - - return np.min(dist) - self._norm(min_dist, self.bndx_min, self.bndx_max) - - def _generate_constraints(self): - tmp1 = { - "type": "ineq", - "fun": lambda x, *args: self._space_constraint(x, self.min_dist), - "args": (self.min_dist,), - } - tmp2 = {"type": "ineq", "fun": lambda x, *args: self._AEP_constraint(x)} - - self.cons = [tmp1, tmp2] - - def _optimize(self): - self.residual_plant = minimize( - self._PowDens_opt, - self.x0, - method=self.opt_method, - bounds=self.bnds, - constraints=self.cons, - options=self.opt_options, - ) - - opt_results = self.residual_plant.x - - return opt_results - - def optimize(self): - """ - This method finds the optimized layout of wind turbines for power - production given the provided frequencies of occurance of wind - conditions (wind speed, direction). - - Returns: - opt_locs (iterable): A list of the optimized x, y locations of each - turbine (m). - """ - print("=====================================================") - print("Optimizing turbine layout...") - print("Number of parameters to optimize = ", len(self.x0)) - print("=====================================================") - - opt_vars_norm = self._optimize() - - print("Optimization complete.") - - opt_locs = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in opt_vars_norm[0 : self.nturbs] - ] - - opt_yaw = [ - self._unnorm(yaw, self.yaw_min, self.yaw_max) - for yaw in opt_vars_norm[self.nturbs :] - ] - - return [opt_locs, opt_yaw] - - def reinitialize_opt( - self, - wd=None, - ws=None, - freq=None, - AEP_initial=None, - x0=None, - bnds=None, - min_dist=None, - yaw_lims=None, - opt_method=None, - opt_options=None, - ): - """ - This method reinitializes any optimization parameters that are - specified. Otherwise, the current parameter values are kept. - - Args: - wd (np.array): An array of wind directions (deg). Defaults to None. - ws (np.array): An array of wind speeds (m/s). Defaults to None. - freq (np.array): An array of the frequencies of occurance - correponding to each pair of wind direction and wind speed - values. Defaults to None. - AEP_initial (float): The initial Annual Energy - Production used for normalization in the optimization (Wh) - (TODO: Is Watt-hours the correct unit?). Defaults to None. - x0 (iterable, optional): The initial turbine locations, - ordered by x-coordinate and then y-coordiante - (ie. [x1, x2, ..., xn, y1, y2, ..., yn]) (m). If none are - provided, x0 initializes to the current turbine locations. - Defaults to None. - bnds (iterable, optional): Bounds for the optimization - variables (pairs of min/max values for each variable (m)). If - none are specified, they are set to some example values (TODO: - what is the significance of these example values?). Defaults to - None. - min_dist (float, optional): The minimum distance to be - maintained between turbines during the optimization (m). If not - specified, initializes to 2 rotor diameters. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to None. - opt_options (dict, optional): Optimization options used by - scipy.optimize.minize. Defaults to None. - """ - # if boundaries is not None: - # self.boundaries = boundaries - # self.bndx_min = np.min([val[0] for val in boundaries]) - # self.bndy_min = np.min([val[1] for val in boundaries]) - # self.boundaries_norm = [[self._norm(val[0], self.bndx_min, \ - # self.bndx_max)] for val in self.boundaries] - self.bndx_min = np.min( - [coord.x1 for coord in self.fi.floris.farm.turbine_map.coords] - ) - self.bndx_max = np.max( - [coord.x1 for coord in self.fi.floris.farm.turbine_map.coords] - ) - if yaw_lims is not None: - self.yaw_min = yaw_lims[0] - self.yaw_max = yaw_lims[1] - else: - self.yaw_min = 0.0 - self.yaw_max = 20.0 - if wd is not None: - self.wd = wd - if ws is not None: - self.ws = ws - if freq is not None: - self.freq = freq - if AEP_initial is not None: - self.AEP_initial = AEP_initial - else: - self.AEP_initial = self.fi.get_farm_AEP(self.wd, self.ws, self.freq) - if x0 is not None: - self.x0 = x0 - else: - self.x0 = [ - self._norm(coord.x1, self.bndx_min, self.bndx_max) - for coord in self.fi.floris.farm.turbine_map.coords - ] + [0.0] * self.nturbs - - if bnds is not None: - self.bnds = bnds - else: - self._set_opt_bounds() - if min_dist is not None: - self.min_dist = min_dist - else: - self.min_dist = 2 * self.fi.floris.farm.turbines[0].rotor_diameter - if opt_method is not None: - self.opt_method = opt_method - if opt_options is not None: - self.opt_options = opt_options - - self._generate_constraints() - # self.layout_dist_initial = np.max(self.x0[0:self.nturbs]) \ - # - np.min(self.x0[0:self.nturbs]) - self.layout_dist_initial = self._avg_dist(self.x0[0 : self.nturbs]) - # print('initial dist: ', self.layout_dist_initial) - - def plot_layout_opt_results(self): - """ - This method plots the original and new locations of the turbines in a - wind farm after layout optimization. - """ - locsx_old = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in self.x0[0 : self.nturbs] - ] - locsy_old = self.fi.layout_y - locsx = [ - self._unnorm(valx, self.bndx_min, self.bndx_max) - for valx in self.residual_plant.x[0 : self.nturbs] - ] - locsy = self.fi.layout_y - - plt.figure(figsize=(9, 6)) - fontsize = 16 - plt.plot(locsx_old, locsy_old, "ob") - plt.plot(locsx, locsy, "or") - # plt.title('Layout Optimization Results', fontsize=fontsize) - plt.xlabel("x (m)", fontsize=fontsize) - plt.ylabel("y (m)", fontsize=fontsize) - plt.axis("equal") - plt.grid() - plt.tick_params(which="both", labelsize=fontsize) - plt.legend( - ["Old locations", "New locations"], - loc="lower center", - bbox_to_anchor=(0.5, 1.01), - ncol=2, - fontsize=fontsize, - ) diff --git a/floris/tools/optimization/legacy/scipy/yaw.py b/floris/tools/optimization/legacy/scipy/yaw.py deleted file mode 100644 index 8ecdbae0b..000000000 --- a/floris/tools/optimization/legacy/scipy/yaw.py +++ /dev/null @@ -1,660 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import numpy as np -from scipy.optimize import minimize -from scipy.stats import norm - -from .derive_downstream_turbines import derive_downstream_turbines -from .optimization import Optimization - - -class YawOptimization(Optimization): - """ - YawOptimization is a subclass of :py:class:`floris.tools.optimization.scipy. - Optimization` that is used to optimize the yaw angles of all turbines in a Floris - Farm for a single set of inflow conditions using the SciPy optimize package. - """ - - def __init__( - self, - fi, - minimum_yaw_angle=0.0, - maximum_yaw_angle=25.0, - yaw_angles_baseline=None, - x0=None, - bnds=None, - opt_method="SLSQP", - opt_options=None, - include_unc=False, - unc_pmfs=None, - unc_options=None, - turbine_weights=None, - calc_init_power=True, - exclude_downstream_turbines=False, - ): - """ - Instantiate YawOptimization object with a FlorisInterface object - and assign parameter values. - - Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - minimum_yaw_angle (float, optional): Minimum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 0.0. - maximum_yaw_angle (float, optional): Maximum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 25.0. - yaw_angles_baseline (iterable, optional): The baseline yaw - angles used to calculate the initial and baseline power - production in the wind farm and used to normalize the cost - function. If none are specified, this variable is set equal - to the current yaw angles in floris. Note that this variable - need not meet the yaw constraints specified in self.bnds, - yet a warning is raised if it does to inform the user. - Defaults to None. - x0 (iterable, optional): The initial guess for the optimization - problem. These values must meet the constraints specified - in self.bnds. Note that, if exclude_downstream_turbines=True, - the initial guess for any downstream turbines are ignored - since they are not part of the optimization. Instead, the yaw - angles for those turbines are 0.0 if that meets the lower and - upper bound, or otherwise as close to 0.0 as feasible. If no - values for x0 are specified, x0 is set to be equal to zeros - wherever feasible (w.r.t. the bounds), and equal to the - average of its lower and upper bound for all non-downstream - turbines otherwise. Defaults to None. - bnds (iterable, optional): Bounds for the yaw angles, as tuples of - min, max values for each turbine (deg). One can fix the yaw - angle of certain turbines to a predefined value by setting that - turbine's lower bound equal to its upper bound (i.e., an - equality constraint), as: bnds[ti] = (x, x), where x is the - fixed yaw angle assigned to the turbine. This works for both - zero and nonzero yaw angles. Moreover, if - exclude_downstream_turbines=True, the yaw angles for all - downstream turbines will be 0.0 or a feasible value closest to - 0.0. If none are specified, the bounds are set to - (minimum_yaw_angle, maximum_yaw_angle) for each turbine. Note - that, if bnds is not none, its values overwrite any value given - in minimum_yaw_angle and maximum_yaw_angle. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dictionary, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': False, 'iprint': 1, 'ftol': 1e-7, - 'eps': 0.01}. Defaults to None. - include_unc (bool, optional): Determines whether wind direction or - yaw uncertainty are included. If True, uncertainty in wind - direction and/or yaw position is included when determining - wind farm power. Uncertainty is included by computing the - mean wind farm power for a distribution of wind direction - and yaw position deviations from the intended wind direction - and yaw angles. Defaults to False. - unc_pmfs (dictionary, optional): A dictionary containing - probability mass functions describing the distribution of - wind direction and yaw position deviations when wind direction - and/or yaw position uncertainty is included in the power - calculations. Contains the following key-value pairs: - - - **wd_unc** (*np.array*): The wind direction - deviations from the intended wind direction (deg). - - **wd_unc_pmf** (*np.array*): The probability - of each wind direction deviation in **wd_unc** occuring. - - **yaw_unc** (*np.array*): The yaw angle deviations - from the intended yaw angles (deg). - - **yaw_unc_pmf** (*np.array*): The probability - of each yaw angle deviation in **yaw_unc** occuring. - - If none are specified, default PMFs are calculated using - values provided in **unc_options**. Defaults to None. - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction and yaw - position deviations when wind direction and/or yaw position - uncertainty is included. This argument is only used when - **unc_pmfs** is None and contains the following key-value pairs: - - - **std_wd** (*float*): The standard deviation of - the wind direction deviations from the original wind - direction (deg). - - **std_yaw** (*float*): The standard deviation of - the yaw angle deviations from the original yaw angles (deg). - - **pmf_res** (*float*): The resolution in degrees - of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): The cumulative - distribution function value at which the tails of the - PMFs are truncated. - - If none are specified, default values of - {'std_wd': 4.95, 'std_yaw': 1.75, 'pmf_res': 1.0, - 'pdf_cutoff': 0.995} are used. Defaults to None. - turbine_weights (iterable, optional): weighing terms that allow - the user to emphasize power gains at particular turbines or - completely ignore power gains from other turbines. The array - of turbine powers from floris is multiplied with this array - in the calculation of the objective function. If None, this - is an array with all values 1.0 and length equal to the - number of turbines. Defaults to None. - calc_init_power (bool, optional): If True, calculates initial - wind farm power for each set of wind conditions. Defaults to - True. - exclude_downstream_turbines (bool, optional): If True, - automatically finds and excludes turbines that are most - downstream from the optimization problem. This significantly - reduces computation time at no loss in performance. The yaw - angles of these downstream turbines are fixed to 0.0 deg if - the yaw bounds specified in self.bnds allow that, or otherwise - are fixed to the lower or upper yaw bound, whichever is closer - to 0.0. Defaults to False. - """ - super().__init__(fi) - - if opt_options is None: - self.opt_options = { - "maxiter": 50, - "disp": True, - "iprint": 2, - "ftol": 1e-12, - "eps": 0.1, - } - - self.unc_pmfs = unc_pmfs - - if unc_options is None: - self.unc_options = { - "std_wd": 4.95, - "std_yaw": 1.75, - "pmf_res": 1.0, - "pdf_cutoff": 0.995, - } - - self.reinitialize_opt( - minimum_yaw_angle=minimum_yaw_angle, - maximum_yaw_angle=maximum_yaw_angle, - yaw_angles_baseline=yaw_angles_baseline, - x0=x0, - bnds=bnds, - opt_method=opt_method, - opt_options=opt_options, - include_unc=include_unc, - unc_pmfs=unc_pmfs, - unc_options=unc_options, - turbine_weights=turbine_weights, - calc_init_power=calc_init_power, - exclude_downstream_turbines=exclude_downstream_turbines, - ) - - # Private methods - - def _yaw_power_opt(self, yaw_angles_subset_norm): - # Unnorm subset - yaw_angles_subset = self._unnorm( - np.array(yaw_angles_subset_norm), - self.minimum_yaw_angle, - self.maximum_yaw_angle, - ) - # Create a full yaw angle array - yaw_angles = np.array(self.yaw_angles_template, copy=True) - yaw_angles[self.turbs_to_opt] = yaw_angles_subset - - self.fi.calculate_wake(yaw_angles=yaw_angles) - turbine_powers = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - - return ( - -1.0 - * np.dot(self.turbine_weights, turbine_powers) - / self.initial_farm_power - ) - - def _optimize(self): - """ - Find optimum setting of turbine yaw angles for power production - given fixed atmospheric conditins (wind speed, direction, etc.). - - Returns: - opt_yaw_angles (np.array): optimal yaw angles of each turbine. - """ - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - self._reduce_control_variables() - if len(self.turbs_to_opt) > 0: - self.residual_plant = minimize( - self._yaw_power_opt, - self.x0_norm, - method=self.opt_method, - bounds=self.bnds_norm, - options=self.opt_options, - ) - - opt_yaw_angles_subset = self._unnorm( - self.residual_plant.x, self.minimum_yaw_angle, self.maximum_yaw_angle - ) - opt_yaw_angles[self.turbs_to_opt] = opt_yaw_angles_subset - - return opt_yaw_angles - - def _set_opt_bounds(self, minimum_yaw_angle, maximum_yaw_angle): - self.bnds = [(minimum_yaw_angle, maximum_yaw_angle) for _ in range(self.nturbs)] - - def _reduce_control_variables(self): - """This function reduces the control problem by eliminating turbines - of which the yaw angles need not be optimized, either because of a - user-specified set of bounds (where bounds[i][0] == bounds[i][1]), - or alternatively turbines that are far downstream in the wind farm - and of which the wake does not impinge other turbines, if the - boolean exclude_downstream_turbines == True. The normalized initial - conditions and bounds are then calculated for the subset of turbines, - to be used in the optimization. - """ - if self.bnds is not None: - self.turbs_to_opt, _ = np.where(np.abs(np.diff(self.bnds)) >= 0.001) - else: - self.turbs_to_opt = np.array(range(self.nturbs), dtype=int) - - if self.exclude_downstream_turbines: - # Remove turbines from turbs_to_opt that are downstream - downstream_turbines = derive_downstream_turbines( - fi=self.fi, wind_direction=self.fi.floris.farm.wind_direction[0] - ) - downstream_turbines = np.array(downstream_turbines, dtype=int) - self.turbs_to_opt = [ - i for i in self.turbs_to_opt if i not in downstream_turbines - ] - - # Set up a template yaw angles array with default solutions. The default - # solutions are either 0.0 or the allowable yaw angle closest to 0.0 deg. - # This solution addresses both downstream turbines, minimizing their abs. - # yaw offset, and additionally fixing equality-constrained turbines to - # their appropriate yaw angle. - yaw_angles_template = np.zeros(self.nturbs, dtype=float) - for ti in range(self.nturbs): - if (self.bnds[ti][0] > 0.0) | (self.bnds[ti][1] < 0.0): - yaw_angles_template[ti] = self.bnds[ti][ - np.argmin(np.abs(self.bnds[ti])) - ] - self.yaw_angles_template = yaw_angles_template - - # Derive normalized initial condition and bounds - x0_subset = [self.x0[i] for i in self.turbs_to_opt] - self.x0_norm = self._norm( - np.array(x0_subset), self.minimum_yaw_angle, self.maximum_yaw_angle - ) - self.bnds_norm = [ - ( - self._norm( - self.bnds[i][0], self.minimum_yaw_angle, self.maximum_yaw_angle - ), - self._norm( - self.bnds[i][1], self.minimum_yaw_angle, self.maximum_yaw_angle - ), - ) - for i in self.turbs_to_opt - ] - - # Public methods - - def optimize(self, verbose=True): - """ - This method solves for the optimum turbine yaw angles for power - production given a fixed set of atmospheric conditions - (wind speed, direction, etc.). - - Returns: - np.array: Optimal yaw angles for each turbine (deg). - """ - if verbose: - print("=====================================================") - print("Optimizing wake redirection control...") - print("Number of parameters to optimize = ", len(self.turbs_to_opt)) - print("=====================================================") - - opt_yaw_angles = self._optimize() - - if verbose and np.sum(opt_yaw_angles) == 0: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - - return opt_yaw_angles - - def reinitialize_opt( - self, - minimum_yaw_angle=None, - maximum_yaw_angle=None, - yaw_angles_baseline=None, - x0=None, - bnds=None, - opt_method=None, - opt_options=None, - include_unc=None, - unc_pmfs=None, - unc_options=None, - turbine_weights=None, - calc_init_power=True, - exclude_downstream_turbines=None, - ): - """ - This method reinitializes any optimization parameters that are - specified. Otherwise, the current parameter values are kept. - - Args: - minimum_yaw_angle (float, optional): Minimum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to None. - maximum_yaw_angle (float, optional): Maximum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to None. - yaw_angles_baseline (iterable, optional): The baseline yaw - angles used to calculate the initial and baseline power - production in the wind farm and used to normalize the cost - function. If none are specified, this variable is set equal - to the current yaw angles in floris. Note that this variable - need not meet the yaw constraints specified in self.bnds, - yet a warning is raised if it does to inform the user. - Defaults to None. - x0 (iterable, optional): The initial guess for the optimization - problem. These values must meet the constraints specified - in self.bnds. Note that, if exclude_downstream_turbines=True, - the initial guess for any downstream turbines are ignored - since they are not part of the optimization. Instead, the yaw - angles for those turbines are 0.0 if that meets the lower and - upper bound, or otherwise as close to 0.0 as feasible. If no - values for x0 are specified, x0 is set to be equal to zeros - wherever feasible (w.r.t. the bounds), and equal to the - average of its lower and upper bound for all non-downstream - turbines otherwise. Defaults to None. - bnds (iterable, optional): Bounds for the yaw angles, as tuples of - min, max values for each turbine (deg). One can fix the yaw - angle of certain turbines to a predefined value by setting that - turbine's lower bound equal to its upper bound (i.e., an - equality constraint), as: bnds[ti] = (x, x), where x is the - fixed yaw angle assigned to the turbine. This works for both - zero and nonzero yaw angles. Moreover, if - exclude_downstream_turbines=True, the yaw angles for all - downstream turbines will be 0.0 or a feasible value closest to - 0.0. If none are specified, the bounds are set to - (minimum_yaw_angle, maximum_yaw_angle) for each turbine. Note - that, if bnds is not none, its values overwrite any value given - in minimum_yaw_angle and maximum_yaw_angle. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to None. - opt_options (dictionary, optional): Optimization options used by - scipy.optimize.minize. Defaults to None. - include_unc (bool, optional): Determines whether wind direction or - yaw uncertainty are included. If True, uncertainty in wind - direction and/or yaw position is included when determining - wind farm power. Uncertainty is included by computing the - mean wind farm power for a distribution of wind direction - and yaw position deviations from the intended wind direction - and yaw angles. Defaults to None. - unc_pmfs (dictionary, optional): A dictionary containing - probability mass functions describing the distribution of - wind direction and yaw position deviations when wind direction - and/or yaw position uncertainty is included in the power - calculations. Contains the following key-value pairs: - - - **wd_unc** (*np.array*): The wind direction - deviations from the intended wind direction (deg). - - **wd_unc_pmf** (*np.array*): The probability - of each wind direction deviation in **wd_unc** occuring. - - **yaw_unc** (*np.array*): The yaw angle deviations - from the intended yaw angles (deg). - - **yaw_unc_pmf** (*np.array*): The probability - of each yaw angle deviation in **yaw_unc** occuring. - - If none are specified, default PMFs are calculated using - values provided in **unc_options**. Defaults to None. - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction and yaw - position deviations when wind direction and/or yaw position - uncertainty is included. This argument is only used when - **unc_pmfs** is None and contains the following key-value pairs: - - - **std_wd** (*float*): The standard deviation of - the wind direction deviations from the original wind - direction (deg). - - **std_yaw** (*float*): The standard deviation of - the yaw angle deviations from the original yaw angles (deg). - - **pmf_res** (*float*): The resolution in degrees - of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): The cumulative - distribution function value at which the tails of the - PMFs are truncated. - - If none are specified, default values of - {'std_wd': 4.95, 'std_yaw': 1.75, 'pmf_res': 1.0, - 'pdf_cutoff': 0.995} are used. Defaults to None. - turbine_weights (iterable, optional): weighing terms that allow - the user to emphasize power gains at particular turbines or - completely ignore power gains from other turbines. The array - of turbine powers from floris is multiplied with this array - in the calculation of the objective function. If None, this - is an array with all values 1.0 and length equal to the - number of turbines. Defaults to None. - calc_init_power (bool, optional): If True, calculates initial - wind farm power for each set of wind conditions. Defaults to - None. - exclude_downstream_turbines (bool, optional): If True, - automatically finds and excludes turbines that are most - downstream from the optimization problem. This significantly - reduces computation time at no loss in performance. The yaw - angles of these downstream turbines are fixed to 0.0 deg if - the yaw bounds specified in self.bnds allow that, or otherwise - are fixed to the lower or upper yaw bound, whichever is closer - to 0.0. Defaults to None. - """ - if minimum_yaw_angle is not None: - self.minimum_yaw_angle = minimum_yaw_angle - if maximum_yaw_angle is not None: - self.maximum_yaw_angle = maximum_yaw_angle - if yaw_angles_baseline is not None: - self.yaw_angles_baseline = yaw_angles_baseline - else: - self.yaw_angles_baseline = [ - turbine.yaw_angle - for turbine in self.fi.floris.farm.turbine_map.turbines - ] - if any(np.abs(self.yaw_angles_baseline) > 0.0): - print( - "INFO: Baseline yaw angles were not specified and were derived " - "from the floris object." - ) - print( - "INFO: The inherent yaw angles in the floris object are not all 0.0 degrees." - ) - - self.bnds = bnds - if bnds is not None: - self.minimum_yaw_angle = np.min([bnds[i][0] for i in range(self.nturbs)]) - self.maximum_yaw_angle = np.max([bnds[i][1] for i in range(self.nturbs)]) - else: - self._set_opt_bounds(self.minimum_yaw_angle, self.maximum_yaw_angle) - - if x0 is not None: - self.x0 = x0 - else: - self.x0 = np.zeros(self.nturbs, dtype=float) - for ti in range(self.nturbs): - if (self.bnds[ti][0] > 0.0) | (self.bnds[ti][1] < 0.0): - self.x0[ti] = np.mean(self.bnds[ti]) - - if any( - np.array(self.yaw_angles_baseline) < np.array([b[0] for b in self.bnds]) - ): - print("INFO: yaw_angles_baseline exceed lower bound constraints.") - if any( - np.array(self.yaw_angles_baseline) > np.array([b[1] for b in self.bnds]) - ): - print("INFO: yaw_angles_baseline in FLORIS exceed upper bound constraints.") - if any(np.array(self.x0) < np.array([b[0] for b in self.bnds])): - raise ValueError("Initial guess x0 exceeds lower bound constraints.") - if any(np.array(self.x0) > np.array([b[1] for b in self.bnds])): - raise ValueError("Initial guess x0 exceeds upper bound constraints.") - - if opt_method is not None: - self.opt_method = opt_method - if opt_options is not None: - self.opt_options = opt_options - if include_unc is not None: - self.include_unc = include_unc - if unc_pmfs is not None: - self.unc_pmfs = unc_pmfs - if unc_options is not None: - self.unc_options = unc_options - - if self.include_unc & (self.unc_pmfs is None): - if self.unc_options is None: - self.unc_options = { - "std_wd": 4.95, - "std_yaw": 1.75, - "pmf_res": 1.0, - "pdf_cutoff": 0.995, - } - - # create normally distributed wd and yaw uncertainty pmfs - if self.unc_options["std_wd"] > 0: - wd_bnd = int( - np.ceil( - norm.ppf( - self.unc_options["pdf_cutoff"], - scale=self.unc_options["std_wd"], - ) - / self.unc_options["pmf_res"] - ) - ) - wd_unc = np.linspace( - -1 * wd_bnd * self.unc_options["pmf_res"], - wd_bnd * self.unc_options["pmf_res"], - 2 * wd_bnd + 1, - ) - wd_unc_pmf = norm.pdf(wd_unc, scale=self.unc_options["std_wd"]) - # normalize so sum = 1.0 - wd_unc_pmf = wd_unc_pmf / np.sum(wd_unc_pmf) - else: - wd_unc = np.zeros(1) - wd_unc_pmf = np.ones(1) - - if self.unc_options["std_yaw"] > 0: - yaw_bnd = int( - np.ceil( - norm.ppf( - self.unc_options["pdf_cutoff"], - scale=self.unc_options["std_yaw"], - ) - / self.unc_options["pmf_res"] - ) - ) - yaw_unc = np.linspace( - -1 * yaw_bnd * self.unc_options["pmf_res"], - yaw_bnd * self.unc_options["pmf_res"], - 2 * yaw_bnd + 1, - ) - yaw_unc_pmf = norm.pdf(yaw_unc, scale=self.unc_options["std_yaw"]) - # normalize so sum = 1.0 - yaw_unc_pmf = yaw_unc_pmf / np.sum(yaw_unc_pmf) - else: - yaw_unc = np.zeros(1) - yaw_unc_pmf = np.ones(1) - - self.unc_pmfs = { - "wd_unc": wd_unc, - "wd_unc_pmf": wd_unc_pmf, - "yaw_unc": yaw_unc, - "yaw_unc_pmf": yaw_unc_pmf, - } - - if turbine_weights is None: - self.turbine_weights = np.ones(self.nturbs) - else: - self.turbine_weights = np.array(turbine_weights, dtype=float) - - if calc_init_power: - self.fi.calculate_wake(yaw_angles=self.yaw_angles_baseline) - turbine_powers = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - self.initial_farm_power = np.dot(self.turbine_weights, turbine_powers) - - if exclude_downstream_turbines is not None: - self.exclude_downstream_turbines = exclude_downstream_turbines - self._reduce_control_variables() - - # Properties - - @property - def minimum_yaw_angle(self): - """ - The minimum yaw angle for the optimization. The setting-method - updates the optimization bounds accordingly. - - **Note**: This is a virtual property used to "get" or "set" a value. - - Args: - value (float): The minimum yaw angle to set (deg). - - Returns: - float: The minimum yaw angle currently set (deg). - """ - return self._minimum_yaw_angle - - @minimum_yaw_angle.setter - def minimum_yaw_angle(self, value): - self._minimum_yaw_angle = value - - @property - def maximum_yaw_angle(self): - """ - The maximum yaw angle for the optimization. The setting-method - updates the optimization bounds accordingly. - - **Note**: This is a virtual property used to "get" or "set" a value. - - Args: - value (float): The maximum yaw angle to set (deg). - - Returns: - float: The maximum yaw angle currently set (deg). - """ - return self._maximum_yaw_angle - - @maximum_yaw_angle.setter - def maximum_yaw_angle(self, value): - self._maximum_yaw_angle = value - - @property - def x0(self): - """ - The initial yaw angles used for the optimization. - - **Note**: This is a virtual property used to "get" or "set" a value. - - Args: - value (iterable): The yaw angle initial conditions to set (deg). - - Returns: - list: The yaw angle initial conditions currently set (deg). - """ - return self._x0 - - @x0.setter - def x0(self, value): - self._x0 = value diff --git a/floris/tools/optimization/legacy/scipy/yaw_clustered.py b/floris/tools/optimization/legacy/scipy/yaw_clustered.py deleted file mode 100644 index c880bd262..000000000 --- a/floris/tools/optimization/legacy/scipy/yaw_clustered.py +++ /dev/null @@ -1,289 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import copy - -import numpy as np -import pandas as pd - -from floris.logging_manager import LoggingManager - -from .cluster_turbines import cluster_turbines -from .yaw import YawOptimization - - -class YawOptimizationClustered(YawOptimization, LoggingManager): - """ - YawOptimization is a subclass of - :py:class:`~.tools.optimizationscipy.YawOptimization` that is used to - perform optimizations of the yaw angles of all or a subset of wind turbines - in a Floris Farm for a single set of inflow conditions using the scipy - optimization package. This class facilitates the clusterization of the - turbines inside seperate subsets in which the turbines witin each subset - exclusively interact with one another and have no impact on turbines - in other clusters. This may significantly reduce the computational - burden at no loss in performance (assuming the turbine clusters are truly - independent). - """ - - def __init__( - self, - fi, - minimum_yaw_angle=0.0, - maximum_yaw_angle=25.0, - yaw_angles_baseline=None, - x0=None, - bnds=None, - opt_method="SLSQP", - opt_options=None, - include_unc=False, - unc_pmfs=None, - unc_options=None, - turbine_weights=None, - calc_init_power=True, - exclude_downstream_turbines=False, - clustering_wake_slope=0.30, - ): - """ - Instantiate YawOptimization object with a FlorisInterface object - and assign parameter values. - - Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - minimum_yaw_angle (float, optional): Minimum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 0.0. - maximum_yaw_angle (float, optional): Maximum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 25.0. - yaw_angles_baseline (iterable, optional): The baseline yaw - angles used to calculate the initial and baseline power - production in the wind farm and used to normalize the cost - function. If none are specified, this variable is set equal - to the current yaw angles in floris. Note that this variable - need not meet the yaw constraints specified in self.bnds, - yet a warning is raised if it does to inform the user. - Defaults to None. - x0 (iterable, optional): The initial guess for the optimization - problem. These values must meet the constraints specified - in self.bnds. Note that, if exclude_downstream_turbines=True, - the initial guess for any downstream turbines are ignored - since they are not part of the optimization. Instead, the yaw - angles for those turbines are 0.0 if that meets the lower and - upper bound, or otherwise as close to 0.0 as feasible. If no - values for x0 are specified, x0 is set to be equal to zeros - wherever feasible (w.r.t. the bounds), and equal to the - average of its lower and upper bound for all non-downstream - turbines otherwise. Defaults to None. - bnds (iterable, optional): Bounds for the yaw angles, as tuples of - min, max values for each turbine (deg). One can fix the yaw - angle of certain turbines to a predefined value by setting that - turbine's lower bound equal to its upper bound (i.e., an - equality constraint), as: bnds[ti] = (x, x), where x is the - fixed yaw angle assigned to the turbine. This works for both - zero and nonzero yaw angles. Moreover, if - exclude_downstream_turbines=True, the yaw angles for all - downstream turbines will be 0.0 or a feasible value closest to - 0.0. If none are specified, the bounds are set to - (minimum_yaw_angle, maximum_yaw_angle) for each turbine. Note - that, if bnds is not none, its values overwrite any value given - in minimum_yaw_angle and maximum_yaw_angle. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dictionary, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': False, 'iprint': 1, 'ftol': 1e-7, - 'eps': 0.01}. Defaults to None. - include_unc (bool, optional): Determines whether wind direction or - yaw uncertainty are included. If True, uncertainty in wind - direction and/or yaw position is included when determining - wind farm power. Uncertainty is included by computing the - mean wind farm power for a distribution of wind direction - and yaw position deviations from the intended wind direction - and yaw angles. Defaults to False. - unc_pmfs (dictionary, optional): A dictionary containing - probability mass functions describing the distribution of - wind direction and yaw position deviations when wind direction - and/or yaw position uncertainty is included in the power - calculations. Contains the following key-value pairs: - - - **wd_unc** (*np.array*): The wind direction - deviations from the intended wind direction (deg). - - **wd_unc_pmf** (*np.array*): The probability - of each wind direction deviation in **wd_unc** occuring. - - **yaw_unc** (*np.array*): The yaw angle deviations - from the intended yaw angles (deg). - - **yaw_unc_pmf** (*np.array*): The probability - of each yaw angle deviation in **yaw_unc** occuring. - - If none are specified, default PMFs are calculated using - values provided in **unc_options**. Defaults to None. - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction and yaw - position deviations when wind direction and/or yaw position - uncertainty is included. This argument is only used when - **unc_pmfs** is None and contains the following key-value pairs: - - - **std_wd** (*float*): The standard deviation of - the wind direction deviations from the original wind - direction (deg). - - **std_yaw** (*float*): The standard deviation of - the yaw angle deviations from the original yaw angles (deg). - - **pmf_res** (*float*): The resolution in degrees - of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): The cumulative - distribution function value at which the tails of the - PMFs are truncated. - - If none are specified, default values of - {'std_wd': 4.95, 'std_yaw': 1.75, 'pmf_res': 1.0, - 'pdf_cutoff': 0.995} are used. Defaults to None. - turbine_weights (iterable, optional): weighing terms that allow - the user to emphasize power gains at particular turbines or - completely ignore power gains from other turbines. The array - of turbine powers from floris is multiplied with this array - in the calculation of the objective function. If None, this - is an array with all values 1.0 and length equal to the - number of turbines. Defaults to None. - calc_init_power (bool, optional): If True, calculates initial - wind farm power for each set of wind conditions. Defaults to - True. - exclude_downstream_turbines (bool, optional): If True, - automatically finds and excludes turbines that are most - downstream from the optimization problem. This significantly - reduces computation time at no loss in performance. The yaw - angles of these downstream turbines are fixed to 0.0 deg if - the yaw bounds specified in self.bnds allow that, or otherwise - are fixed to the lower or upper yaw bound, whichever is closer - to 0.0. Defaults to False. - clustering_wake_slope (float, optional): linear slope of the wake - in the simplified linear expansion wake model (dy/dx). This - model is used to derive wake interactions between turbines and - to identify the turbine clusters. A good value is about equal - to the turbulence intensity in FLORIS. Though, since yaw - optimizations may shift the wake laterally, a safer option - is twice the turbulence intensity. The default value is 0.30 - which should be valid for yaw optimizations at wd_std = 0.0 deg - and turbulence intensities up to 15%. Defaults to 0.30. - """ - super().__init__( - fi=fi, - minimum_yaw_angle=minimum_yaw_angle, - maximum_yaw_angle=maximum_yaw_angle, - yaw_angles_baseline=yaw_angles_baseline, - x0=x0, - bnds=bnds, - opt_method=opt_method, - opt_options=opt_options, - include_unc=include_unc, - unc_pmfs=unc_pmfs, - unc_options=unc_options, - turbine_weights=turbine_weights, - calc_init_power=calc_init_power, - exclude_downstream_turbines=exclude_downstream_turbines, - ) - self.clustering_wake_slope = clustering_wake_slope - - - def _cluster_turbines(self): - wind_directions = self.fi.floris.farm.wind_direction - if (np.std(wind_directions) > 0.001): - raise ValueError("Wind directions must be uniform for clustering algorithm.") - self.clusters = cluster_turbines( - fi=self.fi, - wind_direction=self.fi.floris.farm.wind_direction[0], - wake_slope=self.clustering_wake_slope - ) - - def plot_clusters(self): - cluster_turbines( - fi=self.fi, - wind_direction=self.fi.floris.farm.wind_direction[0], - wake_slope=self.clustering_wake_slope, - plot_lines=True - ) - - def optimize(self, verbose=True): - """ - This method solves for the optimum turbine yaw angles for power - production given a fixed set of atmospheric conditions - (wind speed, direction, etc.). - - Returns: - np.array: Optimal yaw angles for each turbine (deg). - """ - if verbose: - print("=====================================================") - print("Optimizing wake redirection control...") - print("Number of parameters to optimize = ", len(self.turbs_to_opt)) - print("=====================================================") - - # Cluster turbines first - self._cluster_turbines() - if verbose: - print("Clustered turbines into %d separate clusters." % len(self.clusters)) - - # Save parameters to a full list - yaw_angles_template_full = copy.copy(self.yaw_angles_template) - yaw_angles_baseline_full = copy.copy(self.yaw_angles_baseline) - turbine_weights_full = copy.copy(self.turbine_weights) - bnds_full = copy.copy(self.bnds) - # nturbs_full = copy.copy(self.nturbs) - x0_full = copy.copy(self.x0) - fi_full = copy.deepcopy(self.fi) - - # Overwrite parameters for each cluster and optimize - opt_yaw_angles = np.zeros_like(x0_full) - for ci, cl in enumerate(self.clusters): - if verbose: - print("=====================================================") - print("Optimizing %d parameters in cluster %d." % (len(cl), ci)) - print("=====================================================") - self.yaw_angles_template = np.array(yaw_angles_template_full)[cl] - self.yaw_angles_baseline = np.array(yaw_angles_baseline_full)[cl] - self.turbine_weights = np.array(turbine_weights_full)[cl] - self.bnds = np.array(bnds_full)[cl] - self.x0 = np.array(x0_full)[cl] - self.fi = copy.deepcopy(fi_full) - self.fi.reinitialize_flow_field( - layout_array=[ - np.array(fi_full.layout_x)[cl], - np.array(fi_full.layout_y)[cl] - ] - ) - opt_yaw_angles[cl] = self._optimize() - - # Restore parameters - self.yaw_angles_template = yaw_angles_template_full - self.yaw_angles_baseline = yaw_angles_baseline_full - self.turbine_weights = turbine_weights_full - self.bnds = bnds_full - self.x0 = x0_full - self.fi = fi_full - self.fi.reinitialize_flow_field( - layout_array=[ - np.array(fi_full.layout_x), - np.array(fi_full.layout_y) - ] - ) - - if verbose and np.sum(np.abs(opt_yaw_angles)) == 0: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - - return opt_yaw_angles diff --git a/floris/tools/optimization/legacy/scipy/yaw_wind_rose.py b/floris/tools/optimization/legacy/scipy/yaw_wind_rose.py deleted file mode 100644 index c6b2219a3..000000000 --- a/floris/tools/optimization/legacy/scipy/yaw_wind_rose.py +++ /dev/null @@ -1,997 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import numpy as np -import pandas as pd -from scipy.optimize import minimize -from scipy.stats import norm - -from .derive_downstream_turbines import derive_downstream_turbines -from .optimization import Optimization - - -class YawOptimizationWindRose(Optimization): - """ - YawOptimizationWindRose is a subclass of - :py:class:`~.tools.optimization.scipy.Optimization` that is used to - optimize the yaw angles of all turbines in a Floris Farm for multiple sets - of inflow conditions (combinations of wind speed, wind direction, and - optionally turbulence intensity) using the scipy optimize package. - """ - - def __init__( - self, - fi, - wd, - ws, - ti=None, - minimum_yaw_angle=0.0, - maximum_yaw_angle=25.0, - minimum_ws=3.0, - maximum_ws=25.0, - yaw_angles_baseline=None, - x0=None, - bnds=None, - opt_method="SLSQP", - opt_options=None, - include_unc=False, - unc_pmfs=None, - unc_options=None, - turbine_weights=None, - verbose=False, - calc_init_power=True, - exclude_downstream_turbines=False, - ): - """ - Instantiate YawOptimizationWindRose object with a FlorisInterface - object and assign parameter values. - - Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - wd (iterable) : The wind directions for which the yaw angles are - optimized (deg). - ws (iterable): The wind speeds for which the yaw angles are - optimized (m/s). - ti (iterable, optional): An optional list of turbulence intensity - values for which the yaw angles are optimized. If not - specified, the current TI value in the Floris object will be - used for all optimizations. Defaults to None. - minimum_yaw_angle (float, optional): Minimum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 0.0. - maximum_yaw_angle (float, optional): Maximum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 25.0. - minimum_ws (float, optional): Minimum wind speed at which - optimization is performed (m/s). Assumes zero power generated - below this value. Defaults to 3. - maximum_ws (float, optional): Maximum wind speed at which - optimization is performed (m/s). Assumes optimal yaw offsets - are zero above this wind speed. Defaults to 25. - yaw_angles_baseline (iterable, optional): The baseline yaw - angles used to calculate the initial and baseline power - production in the wind farm and used to normalize the cost - function. If none are specified, this variable is set equal - to the current yaw angles in floris. Note that this variable - need not meet the yaw constraints specified in self.bnds, - yet a warning is raised if it does to inform the user. - Defaults to None. - x0 (iterable, optional): The initial guess for the optimization - problem. These values must meet the constraints specified - in self.bnds. Note that, if exclude_downstream_turbines=True, - the initial guess for any downstream turbines are ignored - since they are not part of the optimization. Instead, the yaw - angles for those turbines are 0.0 if that meets the lower and - upper bound, or otherwise as close to 0.0 as feasible. If no - values for x0 are specified, x0 is set to be equal to zeros - wherever feasible (w.r.t. the bounds), and equal to the - average of its lower and upper bound for all non-downstream - turbines otherwise. Defaults to None. - bnds (iterable, optional): Bounds for the yaw angles, as tuples of - min, max values for each turbine (deg). One can fix the yaw - angle of certain turbines to a predefined value by setting that - turbine's lower bound equal to its upper bound (i.e., an - equality constraint), as: bnds[ti] = (x, x), where x is the - fixed yaw angle assigned to the turbine. This works for both - zero and nonzero yaw angles. Moreover, if - exclude_downstream_turbines=True, the yaw angles for all - downstream turbines will be 0.0 or a feasible value closest to - 0.0. If none are specified, the bounds are set to - (minimum_yaw_angle, maximum_yaw_angle) for each turbine. Note - that, if bnds is not none, its values overwrite any value given - in minimum_yaw_angle and maximum_yaw_angle. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dictionary, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': False, 'iprint': 1, 'ftol': 1e-7, - 'eps': 0.01}. Defaults to None. - include_unc (bool, optional): Determines whether wind direction or - yaw uncertainty are included. If True, uncertainty in wind - direction and/or yaw position is included when determining - wind farm power. Uncertainty is included by computing the - mean wind farm power for a distribution of wind direction - and yaw position deviations from the intended wind direction - and yaw angles. Defaults to False. - unc_pmfs (dictionary, optional): A dictionary containing - probability mass functions describing the distribution of - wind direction and yaw position deviations when wind direction - and/or yaw position uncertainty is included in the power - calculations. Contains the following key-value pairs: - - - **wd_unc** (*np.array*): The wind direction - deviations from the intended wind direction (deg). - - **wd_unc_pmf** (*np.array*): The probability - of each wind direction deviation in **wd_unc** occuring. - - **yaw_unc** (*np.array*): The yaw angle deviations - from the intended yaw angles (deg). - - **yaw_unc_pmf** (*np.array*): The probability - of each yaw angle deviation in **yaw_unc** occuring. - - If none are specified, default PMFs are calculated using - values provided in **unc_options**. Defaults to None. - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction and yaw - position deviations when wind direction and/or yaw position - uncertainty is included. This argument is only used when - **unc_pmfs** is None and contains the following key-value pairs: - - - **std_wd** (*float*): The standard deviation of - the wind direction deviations from the original wind - direction (deg). - - **std_yaw** (*float*): The standard deviation of - the yaw angle deviations from the original yaw angles (deg). - - **pmf_res** (*float*): The resolution in degrees - of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): The cumulative - distribution function value at which the tails of the - PMFs are truncated. - - If none are specified, default values of - {'std_wd': 4.95, 'std_yaw': 1.75, 'pmf_res': 1.0, - 'pdf_cutoff': 0.995} are used. Defaults to None. - turbine_weights (iterable, optional): weighing terms that allow - the user to emphasize power gains at particular turbines or - completely ignore power gains from other turbines. The array - of turbine powers from floris is multiplied with this array - in the calculation of the objective function. If None, this - is an array with all values 1.0 and length equal to the - number of turbines. Defaults to None. - calc_init_power (bool, optional): If True, calculates initial - wind farm power for each set of wind conditions. Defaults to - True. - exclude_downstream_turbines (bool, optional): If True, - automatically finds and excludes turbines that are most - downstream from the optimization problem. This significantly - reduces computation time at no loss in performance. The yaw - angles of these downstream turbines are fixed to 0.0 deg if - the yaw bounds specified in self.bnds allow that, or otherwise - are fixed to the lower or upper yaw bound, whichever is closer - to 0.0. Defaults to False. - """ - super().__init__(fi) - - if opt_options is None: - self.opt_options = { - "maxiter": 100, - "disp": False, - "iprint": 1, - "ftol": 1e-7, - "eps": 0.01, - } - - self.unc_pmfs = unc_pmfs - - if unc_options is None: - self.unc_options = { - "std_wd": 4.95, - "std_yaw": 1.75, - "pmf_res": 1.0, - "pdf_cutoff": 0.995, - } - - self.ti = ti - - self.reinitialize_opt_wind_rose( - wd=wd, - ws=ws, - ti=ti, - minimum_yaw_angle=minimum_yaw_angle, - maximum_yaw_angle=maximum_yaw_angle, - minimum_ws=minimum_ws, - maximum_ws=maximum_ws, - yaw_angles_baseline=yaw_angles_baseline, - x0=x0, - bnds=bnds, - opt_method=opt_method, - opt_options=opt_options, - include_unc=include_unc, - unc_pmfs=unc_pmfs, - unc_options=unc_options, - turbine_weights=turbine_weights, - calc_init_power=calc_init_power, - exclude_downstream_turbines=exclude_downstream_turbines, - ) - - self.verbose = verbose - - # Private methods - - def _get_initial_farm_power(self): - self.initial_farm_powers = [] - - for i in range(len(self.wd)): - if (self.ws[i] >= self.minimum_ws) & (self.ws[i] <= self.maximum_ws): - if self.ti is None: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], wind_speed=[self.ws[i]] - ) - else: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], - wind_speed=[self.ws[i]], - turbulence_intensity=self.ti[i], - ) - - # initial power - self.fi.calculate_wake(yaw_angles=self.yaw_angles_baseline) - power_init = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - elif self.ws[i] >= self.maximum_ws: - if self.ti is None: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], wind_speed=[self.ws[i]] - ) - else: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], - wind_speed=[self.ws[i]], - turbulence_intensity=self.ti[i], - ) - self.fi.calculate_wake(yaw_angles=self.yaw_angles_baseline) - power_init = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - else: - power_init = self.nturbs * [0.0] - - self.initial_farm_powers.append(np.dot(self.turbine_weights, power_init)) - - def _get_power_for_yaw_angle_opt(self, yaw_angles_subset_norm): - """ - Assign yaw angles to turbines, calculate wake, report power - - Args: - yaw_angles_subset_norm (np.array): Yaw to apply to subset - of controlled turbines, normalized. - - Returns: - power (float): Wind plant power. #TODO negative? in kW? - """ - yaw_angles_subset = self._unnorm( - np.array(yaw_angles_subset_norm), - self.minimum_yaw_angle, - self.maximum_yaw_angle, - ) - - # Create a full yaw angle array - yaw_angles = np.array(self.yaw_angles_template, copy=True) - yaw_angles[self.turbs_to_opt] = yaw_angles_subset - - self.fi.calculate_wake(yaw_angles=yaw_angles) - turbine_powers = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - - return ( - -1.0 - * np.dot(self.turbine_weights, turbine_powers) - / self.initial_farm_power - ) - - def _set_opt_bounds(self, minimum_yaw_angle, maximum_yaw_angle): - """ - Sets minimum and maximum yaw angle bounds for optimization. - """ - - self.bnds = [(minimum_yaw_angle, maximum_yaw_angle) for _ in range(self.nturbs)] - - def _optimize(self): - """ - Find optimum setting of turbine yaw angles for power production - given fixed atmospheric conditions (wind speed, direction, etc.). - - Returns: - opt_yaw_angles (np.array): Optimal yaw angles of each turbine. - """ - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - wind_map = self.fi.floris.farm.wind_map - self._reduce_control_variables() - - if len(self.turbs_to_opt) > 0: - self.residual_plant = minimize( - self._get_power_for_yaw_angle_opt, - self.x0_norm, - method=self.opt_method, - bounds=self.bnds_norm, - options=self.opt_options, - ) - opt_yaw_angles_subset = self._unnorm( - self.residual_plant.x, self.minimum_yaw_angle, self.maximum_yaw_angle - ) - opt_yaw_angles[self.turbs_to_opt] = opt_yaw_angles_subset - - self.fi.reinitialize_flow_field( - wind_speed=wind_map.input_speed, - wind_direction=wind_map.input_direction, - turbulence_intensity=wind_map.input_ti, - ) - return opt_yaw_angles - - def _reduce_control_variables(self): - """This function reduces the control problem by eliminating turbines - of which the yaw angles need not be optimized, either because of a - user-specified set of bounds (where bounds[i][0] == bounds[i][1]), - or alternatively turbines that are far downstream in the wind farm - and of which the wake does not impinge other turbines, if the - boolean exclude_downstream_turbines == True. The normalized initial - conditions and bounds are then calculated for the subset of turbines, - to be used in the optimization. - """ - if self.bnds is not None: - self.turbs_to_opt, _ = np.where(np.abs(np.diff(self.bnds)) >= 0.001) - else: - self.turbs_to_opt = np.array(range(self.nturbs), dtype=int) - - if self.exclude_downstream_turbines: - # Remove turbines from turbs_to_opt that are downstream - downstream_turbines = derive_downstream_turbines( - fi=self.fi, wind_direction=self.fi.floris.farm.wind_direction[0] - ) - downstream_turbines = np.array(downstream_turbines, dtype=int) - self.turbs_to_opt = [ - i for i in self.turbs_to_opt if i not in downstream_turbines - ] - - # Set up a template yaw angles array with default solutions. The default - # solutions are either 0.0 or the allowable yaw angle closest to 0.0 deg. - # This solution addresses both downstream turbines, minimizing their abs. - # yaw offset, and additionally fixing equality-constrained turbines to - # their appropriate yaw angle. - yaw_angles_template = np.zeros(self.nturbs, dtype=float) - for ti in range(self.nturbs): - if (self.bnds[ti][0] > 0.0) | (self.bnds[ti][1] < 0.0): - yaw_angles_template[ti] = self.bnds[ti][ - np.argmin(np.abs(self.bnds[ti])) - ] - self.yaw_angles_template = yaw_angles_template - - # Derive normalized initial condition and bounds - x0_subset = [self.x0[i] for i in self.turbs_to_opt] - self.x0_norm = self._norm( - np.array(x0_subset), self.minimum_yaw_angle, self.maximum_yaw_angle - ) - self.bnds_norm = [ - ( - self._norm( - self.bnds[i][0], self.minimum_yaw_angle, self.maximum_yaw_angle - ), - self._norm( - self.bnds[i][1], self.minimum_yaw_angle, self.maximum_yaw_angle - ), - ) - for i in self.turbs_to_opt - ] - - # Public methods - - def reinitialize_opt_wind_rose( - self, - wd=None, - ws=None, - ti=None, - minimum_yaw_angle=None, - maximum_yaw_angle=None, - minimum_ws=None, - maximum_ws=None, - yaw_angles_baseline=None, - x0=None, - bnds=None, - opt_method=None, - opt_options=None, - include_unc=None, - unc_pmfs=None, - unc_options=None, - turbine_weights=None, - calc_init_power=True, - exclude_downstream_turbines=None, - ): - """ - This method reinitializes any optimization parameters that are - specified. Otherwise, the current parameter values are kept. - - Args: - wd (iterable, optional) : The wind directions for which the yaw - angles are optimized (deg). Defaults to None. - ws (iterable, optional): The wind speeds for which the yaw angles - are optimized (m/s). Defaults to None. - ti (iterable, optional): An optional list of turbulence intensity - values for which the yaw angles are optimized. Defaults to None. - minimum_yaw_angle (float, optional): Minimum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to None. - maximum_yaw_angle (float, optional): Maximum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to None. - minimum_ws (float, optional): Minimum wind speed at which - optimization is performed (m/s). Assumes zero power generated - below this value. Defaults to None. - maximum_ws (float, optional): Maximum wind speed at which - optimization is performed (m/s). Assumes optimal yaw offsets - are zero above this wind speed. Defaults to None. - yaw_angles_baseline (iterable, optional): The baseline yaw - angles used to calculate the initial and baseline power - production in the wind farm and used to normalize the cost - function. If none are specified, this variable is set equal - to the current yaw angles in floris. Note that this variable - need not meet the yaw constraints specified in self.bnds, - yet a warning is raised if it does to inform the user. - Defaults to None. - x0 (iterable, optional): The initial guess for the optimization - problem. These values must meet the constraints specified - in self.bnds. Note that, if exclude_downstream_turbines=True, - the initial guess for any downstream turbines are ignored - since they are not part of the optimization. Instead, the yaw - angles for those turbines are 0.0 if that meets the lower and - upper bound, or otherwise as close to 0.0 as feasible. If no - values for x0 are specified, x0 is set to be equal to zeros - wherever feasible (w.r.t. the bounds), and equal to the - average of its lower and upper bound for all non-downstream - turbines otherwise. Defaults to None. - bnds (iterable, optional): Bounds for the yaw angles, as tuples of - min, max values for each turbine (deg). One can fix the yaw - angle of certain turbines to a predefined value by setting that - turbine's lower bound equal to its upper bound (i.e., an - equality constraint), as: bnds[ti] = (x, x), where x is the - fixed yaw angle assigned to the turbine. This works for both - zero and nonzero yaw angles. Moreover, if - exclude_downstream_turbines=True, the yaw angles for all - downstream turbines will be 0.0 or a feasible value closest to - 0.0. If none are specified, the bounds are set to - (minimum_yaw_angle, maximum_yaw_angle) for each turbine. Note - that, if bnds is not none, its values overwrite any value given - in minimum_yaw_angle and maximum_yaw_angle. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to None. - opt_options (dictionary, optional): Optimization options used by - scipy.optimize.minize. Defaults to None. - include_unc (bool, optional): Determines whether wind direction or - yaw uncertainty are included. If True, uncertainty in wind - direction and/or yaw position is included when determining - wind farm power. Uncertainty is included by computing the - mean wind farm power for a distribution of wind direction - and yaw position deviations from the intended wind direction - and yaw angles. Defaults to None. - unc_pmfs (dictionary, optional): A dictionary containing - probability mass functions describing the distribution of - wind direction and yaw position deviations when wind direction - and/or yaw position uncertainty is included in the power - calculations. Contains the following key-value pairs: - - - **wd_unc** (*np.array*): The wind direction - deviations from the intended wind direction (deg). - - **wd_unc_pmf** (*np.array*): The probability - of each wind direction deviation in **wd_unc** occuring. - - **yaw_unc** (*np.array*): The yaw angle deviations - from the intended yaw angles (deg). - - **yaw_unc_pmf** (*np.array*): The probability - of each yaw angle deviation in **yaw_unc** occuring. - - If none are specified, default PMFs are calculated using - values provided in **unc_options**. Defaults to None. - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction and yaw - position deviations when wind direction and/or yaw position - uncertainty is included. This argument is only used when - **unc_pmfs** is None and contains the following key-value pairs: - - - **std_wd** (*float*): The standard deviation of - the wind direction deviations from the original wind - direction (deg). - - **std_yaw** (*float*): The standard deviation of - the yaw angle deviations from the original yaw angles (deg). - - **pmf_res** (*float*): The resolution in degrees - of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): The cumulative - distribution function value at which the tails of the - PMFs are truncated. - - If none are specified, default values of - {'std_wd': 4.95, 'std_yaw': 1.75, 'pmf_res': 1.0, - 'pdf_cutoff': 0.995} are used. Defaults to None. - turbine_weights (iterable, optional): weighing terms that allow - the user to emphasize power gains at particular turbines or - completely ignore power gains from other turbines. The array - of turbine powers from floris is multiplied with this array - in the calculation of the objective function. If None, this - is an array with all values 1.0 and length equal to the - number of turbines. Defaults to None. - calc_init_power (bool, optional): If True, calculates initial - wind farm power for each set of wind conditions. Defaults to - None. - exclude_downstream_turbines (bool, optional): If True, - automatically finds and excludes turbines that are most - downstream from the optimization problem. This significantly - reduces computation time at no loss in performance. The yaw - angles of these downstream turbines are fixed to 0.0 deg if - the yaw bounds specified in self.bnds allow that, or otherwise - are fixed to the lower or upper yaw bound, whichever is closer - to 0.0. Defaults to None. - """ - - if wd is not None: - self.wd = wd - if ws is not None: - self.ws = ws - if ti is not None: - self.ti = ti - if minimum_ws is not None: - self.minimum_ws = minimum_ws - if maximum_ws is not None: - self.maximum_ws = maximum_ws - if minimum_yaw_angle is not None: - self.minimum_yaw_angle = minimum_yaw_angle - if maximum_yaw_angle is not None: - self.maximum_yaw_angle = maximum_yaw_angle - if opt_method is not None: - self.opt_method = opt_method - if opt_options is not None: - self.opt_options = opt_options - if yaw_angles_baseline is not None: - self.yaw_angles_baseline = yaw_angles_baseline - else: - self.yaw_angles_baseline = [ - turbine.yaw_angle - for turbine in self.fi.floris.farm.turbine_map.turbines - ] - if any(np.abs(self.yaw_angles_baseline) > 0.0): - print( - "INFO: Baseline yaw angles were not specified and were derived " - "from the floris object." - ) - print( - "INFO: The inherent yaw angles in the floris object are not all 0.0 degrees." - ) - - self.bnds = bnds - if bnds is not None: - self.minimum_yaw_angle = np.min([bnds[i][0] for i in range(self.nturbs)]) - self.maximum_yaw_angle = np.max([bnds[i][1] for i in range(self.nturbs)]) - else: - self._set_opt_bounds(self.minimum_yaw_angle, self.maximum_yaw_angle) - - if x0 is not None: - self.x0 = x0 - else: - self.x0 = np.zeros(self.nturbs, dtype=float) - for ti in range(self.nturbs): - if (self.bnds[ti][0] > 0.0) | (self.bnds[ti][1] < 0.0): - self.x0[ti] = np.mean(self.bnds[ti]) - - if any( - np.array(self.yaw_angles_baseline) < np.array([b[0] for b in self.bnds]) - ): - print("INFO: yaw_angles_baseline exceed lower bound constraints.") - if any( - np.array(self.yaw_angles_baseline) > np.array([b[1] for b in self.bnds]) - ): - print("INFO: yaw_angles_baseline in FLORIS exceed upper bound constraints.") - if any(np.array(self.x0) < np.array([b[0] for b in self.bnds])): - raise ValueError("Initial guess x0 exceeds lower bound constraints.") - if any(np.array(self.x0) > np.array([b[1] for b in self.bnds])): - raise ValueError("Initial guess x0 exceeds upper bound constraints.") - - if include_unc is not None: - self.include_unc = include_unc - if unc_pmfs is not None: - self.unc_pmfs = unc_pmfs - if unc_options is not None: - self.unc_options = unc_options - - if self.include_unc & (self.unc_pmfs is None): - if self.unc_options is None: - self.unc_options = { - "std_wd": 4.95, - "std_yaw": 1.75, - "pmf_res": 1.0, - "pdf_cutoff": 0.995, - } - - # create normally distributed wd and yaw uncertaitny pmfs - if self.unc_options["std_wd"] > 0: - wd_bnd = int( - np.ceil( - norm.ppf( - self.unc_options["pdf_cutoff"], - scale=self.unc_options["std_wd"], - ) - / self.unc_options["pmf_res"] - ) - ) - wd_unc = np.linspace( - -1 * wd_bnd * self.unc_options["pmf_res"], - wd_bnd * self.unc_options["pmf_res"], - 2 * wd_bnd + 1, - ) - wd_unc_pmf = norm.pdf(wd_unc, scale=self.unc_options["std_wd"]) - # normalize so sum = 1.0 - wd_unc_pmf = wd_unc_pmf / np.sum(wd_unc_pmf) - else: - wd_unc = np.zeros(1) - wd_unc_pmf = np.ones(1) - - if self.unc_options["std_yaw"] > 0: - yaw_bnd = int( - np.ceil( - norm.ppf( - self.unc_options["pdf_cutoff"], - scale=self.unc_options["std_yaw"], - ) - / self.unc_options["pmf_res"] - ) - ) - yaw_unc = np.linspace( - -1 * yaw_bnd * self.unc_options["pmf_res"], - yaw_bnd * self.unc_options["pmf_res"], - 2 * yaw_bnd + 1, - ) - yaw_unc_pmf = norm.pdf(yaw_unc, scale=self.unc_options["std_yaw"]) - # normalize so sum = 1.0 - yaw_unc_pmf = yaw_unc_pmf / np.sum(yaw_unc_pmf) - else: - yaw_unc = np.zeros(1) - yaw_unc_pmf = np.ones(1) - - self.unc_pmfs = { - "wd_unc": wd_unc, - "wd_unc_pmf": wd_unc_pmf, - "yaw_unc": yaw_unc, - "yaw_unc_pmf": yaw_unc_pmf, - } - - if turbine_weights is None: - self.turbine_weights = np.ones(self.nturbs) - else: - self.turbine_weights = np.array(turbine_weights, dtype=float) - - if calc_init_power: - self._get_initial_farm_power() - - if exclude_downstream_turbines is not None: - self.exclude_downstream_turbines = exclude_downstream_turbines - self._reduce_control_variables() - - def calc_baseline_power(self): - """ - This method computes the baseline power produced by the wind farm and - the ideal power without wake losses for a series of wind speed, wind - direction, and optionally TI combinations. - - Returns: - pandas.DataFrame: A pandas DataFrame with the same number of rows - as the length of the wd and ws arrays, containing the following - columns: - - - **ws** (*float*) - The wind speed values for which power is - computed (m/s). - - **wd** (*float*) - The wind direction value for which power - is calculated (deg). - - **ti** (*float*) - The turbulence intensity value for which - power is calculated. Only included if self.ti is not None. - - **power_baseline** (*float*) - The total power produced by - the wind farm with baseline yaw control (W). - - **power_no_wake** (*float*) - The ideal total power produced - by the wind farm without wake losses (W). - - **turbine_power_baseline** (*list* (*float*)) - A - list containing the baseline power without wake steering for - each wind turbine in the wind farm (W). - - **turbine_power_no_wake** (*list* (*float*)) - A list - containing the ideal power without wake losses for each wind - turbine in the wind farm (W). - """ - print("=====================================================") - print("Calculating baseline power...") - print("Number of wind conditions to calculate = ", len(self.wd)) - print("=====================================================") - - # Put results in dict for speed, instead of previously - # appending to frame. - result_dict = {} - - for i in range(len(self.wd)): - if self.verbose: - if self.ti is None: - print( - "Computing wind speed, wind direction pair " - + str(i) - + " out of " - + str(len(self.wd)) - + ": wind speed = " - + str(self.ws[i]) - + " m/s, wind direction = " - + str(self.wd[i]) - + " deg." - ) - else: - print( - "Computing wind speed, wind direction, turbulence " - + "intensity set " - + str(i) - + " out of " - + str(len(self.wd)) - + ": wind speed = " - + str(self.ws[i]) - + " m/s, wind direction = " - + str(self.wd[i]) - + " deg, turbulence intensity = " - + str(self.ti[i]) - + "." - ) - - # Find baseline power in FLORIS - - if self.ws[i] >= self.minimum_ws: - if self.ti is None: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], wind_speed=[self.ws[i]] - ) - else: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], - wind_speed=[self.ws[i]], - turbulence_intensity=self.ti[i], - ) - - # calculate baseline power - self.fi.calculate_wake( - yaw_angles=self.yaw_angles_baseline, no_wake=False - ) - power_base = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - - # calculate power for no wake case - self.fi.calculate_wake( - yaw_angles=self.yaw_angles_baseline, no_wake=True - ) - power_no_wake = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - no_wake=True, - ) - else: - power_base = self.nturbs * [0.0] - power_no_wake = self.nturbs * [0.0] - - # Include turbine weighing terms - power_base = np.multiply(self.turbine_weights, power_base) - power_no_wake = np.multiply(self.turbine_weights, power_no_wake) - - # add variables to dataframe - if self.ti is None: - result_dict[i] = { - "ws": self.ws[i], - "wd": self.wd[i], - "power_baseline": np.sum(power_base), - "turbine_power_baseline": power_base, - "power_no_wake": np.sum(power_no_wake), - "turbine_power_no_wake": power_no_wake, - } - # df_base = df_base.append(pd.DataFrame( - # {'ws':[self.ws[i]],'wd':[self.wd[i]], - # 'power_baseline':[np.sum(power_base)], - # 'turbine_power_baseline':[power_base], - # 'power_no_wake':[np.sum(power_no_wake)], - # 'turbine_power_no_wake':[power_no_wake]})) - else: - result_dict[i] = { - "ws": self.ws[i], - "wd": self.wd[i], - "ti": self.ti[i], - "power_baseline": np.sum(power_base), - "turbine_power_baseline": power_base, - "power_no_wake": np.sum(power_no_wake), - "turbine_power_no_wake": power_no_wake, - } - # df_base = df_base.append(pd.DataFrame( - # {'ws':[self.ws[i]],'wd':[self.wd[i]], - # 'ti':[self.ti[i]],'power_baseline':[np.sum(power_base)], - # 'turbine_power_baseline':[power_base], - # 'power_no_wake':[np.sum(power_no_wake)], - # 'turbine_power_no_wake':[power_no_wake]})) - df_base = pd.DataFrame.from_dict(result_dict, "index") - df_base.reset_index(drop=True, inplace=True) - - return df_base - - def optimize(self): - """ - This method solves for the optimum turbine yaw angles for power - production and the resulting power produced by the wind farm for a - series of wind speed, wind direction, and optionally TI combinations. - - Returns: - pandas.DataFrame: A pandas DataFrame with the same number of rows - as the length of the wd and ws arrays, containing the following - columns: - - - **ws** (*float*) - The wind speed values for which the yaw - angles are optimized and power is computed (m/s). - - **wd** (*float*) - The wind direction values for which the - yaw angles are optimized and power is computed (deg). - - **ti** (*float*) - The turbulence intensity values for which - the yaw angles are optimized and power is computed. Only - included if self.ti is not None. - - **power_opt** (*float*) - The total power produced by the - wind farm with optimal yaw offsets (W). - - **turbine_power_opt** (*list* (*float*)) - A list - containing the power produced by each wind turbine with optimal - yaw offsets (W). - - **yaw_angles** (*list* (*float*)) - A list containing - the optimal yaw offsets for maximizing total wind farm power - for each wind turbine (deg). - """ - print("=====================================================") - print("Optimizing wake redirection control...") - print("Number of wind conditions to optimize = ", len(self.wd)) - print("Number of yaw angles to optimize = ", len(self.turbs_to_opt)) - print("=====================================================") - - df_opt = pd.DataFrame() - - for i in range(len(self.wd)): - if self.verbose: - if self.ti is None: - print( - "Computing wind speed, wind direction pair " - + str(i) - + " out of " - + str(len(self.wd)) - + ": wind speed = " - + str(self.ws[i]) - + " m/s, wind direction = " - + str(self.wd[i]) - + " deg." - ) - else: - print( - "Computing wind speed, wind direction, turbulence " - + "intensity set " - + str(i) - + " out of " - + str(len(self.wd)) - + ": wind speed = " - + str(self.ws[i]) - + " m/s, wind direction = " - + str(self.wd[i]) - + " deg, turbulence intensity = " - + str(self.ti[i]) - + "." - ) - - # Optimizing wake redirection control - if (self.ws[i] >= self.minimum_ws) & (self.ws[i] <= self.maximum_ws): - if self.ti is None: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], wind_speed=[self.ws[i]] - ) - else: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], - wind_speed=[self.ws[i]], - turbulence_intensity=self.ti[i], - ) - - self.initial_farm_power = self.initial_farm_powers[i] - opt_yaw_angles = self._optimize() - - if np.sum(opt_yaw_angles) == 0: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - - # optimized power - self.fi.calculate_wake(yaw_angles=opt_yaw_angles) - power_opt = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - elif self.ws[i] >= self.maximum_ws: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - if self.ti is None: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], wind_speed=[self.ws[i]] - ) - else: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], - wind_speed=[self.ws[i]], - turbulence_intensity=self.ti[i], - ) - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - self.fi.calculate_wake(yaw_angles=opt_yaw_angles) - power_opt = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - else: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - power_opt = self.nturbs * [0.0] - - # Include turbine weighing terms - power_opt = np.multiply(self.turbine_weights, power_opt) - - # add variables to dataframe - if self.ti is None: - df_opt = df_opt.append( - pd.DataFrame( - { - "ws": [self.ws[i]], - "wd": [self.wd[i]], - "power_opt": [np.sum(power_opt)], - "turbine_power_opt": [power_opt], - "yaw_angles": [opt_yaw_angles], - } - ) - ) - else: - df_opt = df_opt.append( - pd.DataFrame( - { - "ws": [self.ws[i]], - "wd": [self.wd[i]], - "ti": [self.ti[i]], - "power_opt": [np.sum(power_opt)], - "turbine_power_opt": [power_opt], - "yaw_angles": [opt_yaw_angles], - } - ) - ) - - df_opt.reset_index(drop=True, inplace=True) - - return df_opt diff --git a/floris/tools/optimization/legacy/scipy/yaw_wind_rose_clustered.py b/floris/tools/optimization/legacy/scipy/yaw_wind_rose_clustered.py deleted file mode 100644 index 0c5d5a8e3..000000000 --- a/floris/tools/optimization/legacy/scipy/yaw_wind_rose_clustered.py +++ /dev/null @@ -1,452 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import copy - -import numpy as np -import pandas as pd - -from floris.logging_manager import LoggingManager - -from .cluster_turbines import cluster_turbines -from .yaw_wind_rose import YawOptimizationWindRose - - -class YawOptimizationWindRoseClustered(YawOptimizationWindRose, LoggingManager): - """ - YawOptimizationWindRose is a subclass of - :py:class:`~.tools.optimizationscipy.YawOptimizationWindRose` that is used - to perform optimizations of the yaw angles of all or a subset of wind - turbines in a Floris Farm for multiple sets of inflow conditions using the - scipy optimization package. This class facilitates the clusterization of the - turbines inside seperate subsets in which the turbines witin each subset - exclusively interact with one another and have no impact on turbines - in other clusters. This may significantly reduce the computational - burden at no loss in performance (assuming the turbine clusters are truly - independent). - """ - - def __init__( - self, - fi, - wd, - ws, - ti=None, - minimum_yaw_angle=0.0, - maximum_yaw_angle=25.0, - minimum_ws=3.0, - maximum_ws=25.0, - yaw_angles_baseline=None, - x0=None, - bnds=None, - opt_method="SLSQP", - opt_options=None, - include_unc=False, - unc_pmfs=None, - unc_options=None, - turbine_weights=None, - verbose=False, - calc_init_power=True, - exclude_downstream_turbines=False, - clustering_wake_slope=0.30, - ): - """ - Instantiate YawOptimizationWindRose object with a FlorisInterface object - and assign parameter values. - - Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - wd (iterable) : The wind directions for which the yaw angles are - optimized (deg). - ws (iterable): The wind speeds for which the yaw angles are - optimized (m/s). - ti (iterable, optional): An optional list of turbulence intensity - values for which the yaw angles are optimized. If not - specified, the current TI value in the Floris object will be - used for all optimizations. Defaults to None. - minimum_yaw_angle (float, optional): Minimum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 0.0. - maximum_yaw_angle (float, optional): Maximum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 25.0. - minimum_ws (float, optional): Minimum wind speed at which - optimization is performed (m/s). Assumes zero power generated - below this value. Defaults to 3. - maximum_ws (float, optional): Maximum wind speed at which - optimization is performed (m/s). Assumes optimal yaw offsets - are zero above this wind speed. Defaults to 25. - yaw_angles_baseline (iterable, optional): The baseline yaw - angles used to calculate the initial and baseline power - production in the wind farm and used to normalize the cost - function. If none are specified, this variable is set equal - to the current yaw angles in floris. Note that this variable - need not meet the yaw constraints specified in self.bnds, - yet a warning is raised if it does to inform the user. - Defaults to None. - x0 (iterable, optional): The initial guess for the optimization - problem. These values must meet the constraints specified - in self.bnds. Note that, if exclude_downstream_turbines=True, - the initial guess for any downstream turbines are ignored - since they are not part of the optimization. Instead, the yaw - angles for those turbines are 0.0 if that meets the lower and - upper bound, or otherwise as close to 0.0 as feasible. If no - values for x0 are specified, x0 is set to be equal to zeros - wherever feasible (w.r.t. the bounds), and equal to the - average of its lower and upper bound for all non-downstream - turbines otherwise. Defaults to None. - bnds (iterable, optional): Bounds for the yaw angles, as tuples of - min, max values for each turbine (deg). One can fix the yaw - angle of certain turbines to a predefined value by setting that - turbine's lower bound equal to its upper bound (i.e., an - equality constraint), as: bnds[ti] = (x, x), where x is the - fixed yaw angle assigned to the turbine. This works for both - zero and nonzero yaw angles. Moreover, if - exclude_downstream_turbines=True, the yaw angles for all - downstream turbines will be 0.0 or a feasible value closest to - 0.0. If none are specified, the bounds are set to - (minimum_yaw_angle, maximum_yaw_angle) for each turbine. Note - that, if bnds is not none, its values overwrite any value given - in minimum_yaw_angle and maximum_yaw_angle. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dictionary, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': False, 'iprint': 1, 'ftol': 1e-7, - 'eps': 0.01}. Defaults to None. - include_unc (bool, optional): Determines whether wind direction or - yaw uncertainty are included. If True, uncertainty in wind - direction and/or yaw position is included when determining - wind farm power. Uncertainty is included by computing the - mean wind farm power for a distribution of wind direction - and yaw position deviations from the intended wind direction - and yaw angles. Defaults to False. - unc_pmfs (dictionary, optional): A dictionary containing - probability mass functions describing the distribution of - wind direction and yaw position deviations when wind direction - and/or yaw position uncertainty is included in the power - calculations. Contains the following key-value pairs: - - - **wd_unc** (*np.array*): The wind direction - deviations from the intended wind direction (deg). - - **wd_unc_pmf** (*np.array*): The probability - of each wind direction deviation in **wd_unc** occuring. - - **yaw_unc** (*np.array*): The yaw angle deviations - from the intended yaw angles (deg). - - **yaw_unc_pmf** (*np.array*): The probability - of each yaw angle deviation in **yaw_unc** occuring. - - If none are specified, default PMFs are calculated using - values provided in **unc_options**. Defaults to None. - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction and yaw - position deviations when wind direction and/or yaw position - uncertainty is included. This argument is only used when - **unc_pmfs** is None and contains the following key-value pairs: - - - **std_wd** (*float*): The standard deviation of - the wind direction deviations from the original wind - direction (deg). - - **std_yaw** (*float*): The standard deviation of - the yaw angle deviations from the original yaw angles (deg). - - **pmf_res** (*float*): The resolution in degrees - of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): The cumulative - distribution function value at which the tails of the - PMFs are truncated. - - If none are specified, default values of - {'std_wd': 4.95, 'std_yaw': 1.75, 'pmf_res': 1.0, - 'pdf_cutoff': 0.995} are used. Defaults to None. - turbine_weights (iterable, optional): weighing terms that allow - the user to emphasize power gains at particular turbines or - completely ignore power gains from other turbines. The array - of turbine powers from floris is multiplied with this array - in the calculation of the objective function. If None, this - is an array with all values 1.0 and length equal to the - number of turbines. Defaults to None. - calc_init_power (bool, optional): If True, calculates initial - wind farm power for each set of wind conditions. Defaults to - True. - exclude_downstream_turbines (bool, optional): If True, - automatically finds and excludes turbines that are most - downstream from the optimization problem. This significantly - reduces computation time at no loss in performance. The yaw - angles of these downstream turbines are fixed to 0.0 deg if - the yaw bounds specified in self.bnds allow that, or otherwise - are fixed to the lower or upper yaw bound, whichever is closer - to 0.0. Defaults to False. - clustering_wake_slope (float, optional): linear slope of the wake - in the simplified linear expansion wake model (dy/dx). This - model is used to derive wake interactions between turbines and - to identify the turbine clusters. A good value is about equal - to the turbulence intensity in FLORIS. Though, since yaw - optimizations may shift the wake laterally, a safer option - is twice the turbulence intensity. The default value is 0.30 - which should be valid for yaw optimizations at wd_std = 0.0 deg - and turbulence intensities up to 15%. Defaults to 0.30. - """ - super().__init__( - fi=fi, - wd=wd, - ws=ws, - ti=ti, - minimum_yaw_angle=minimum_yaw_angle, - maximum_yaw_angle=maximum_yaw_angle, - minimum_ws=minimum_ws, - maximum_ws=maximum_ws, - yaw_angles_baseline=yaw_angles_baseline, - x0=x0, - bnds=bnds, - opt_method=opt_method, - opt_options=opt_options, - include_unc=include_unc, - unc_pmfs=unc_pmfs, - unc_options=unc_options, - turbine_weights=turbine_weights, - verbose=verbose, - calc_init_power=calc_init_power, - exclude_downstream_turbines=exclude_downstream_turbines, - ) - self.clustering_wake_slope = clustering_wake_slope - - - def _cluster_turbines(self): - wind_directions = self.fi.floris.farm.wind_direction - if (np.std(wind_directions) > 0.001): - raise ValueError("Wind directions must be uniform for clustering algorithm.") - self.clusters = cluster_turbines( - fi=self.fi, - wind_direction=self.fi.floris.farm.wind_direction[0], - wake_slope=self.clustering_wake_slope - ) - - def plot_clusters(self): - for wd in self.wd: - cluster_turbines( - fi=self.fi, - wind_direction=wd, - wake_slope=self.clustering_wake_slope, - plot_lines=True - ) - - - def optimize(self): - """ - This method solves for the optimum turbine yaw angles for power - production and the resulting power produced by the wind farm for a - series of wind speed, wind direction, and optionally TI combinations. - - Returns: - pandas.DataFrame: A pandas DataFrame with the same number of rows - as the length of the wd and ws arrays, containing the following - columns: - - - **ws** (*float*) - The wind speed values for which the yaw - angles are optimized and power is computed (m/s). - - **wd** (*float*) - The wind direction values for which the - yaw angles are optimized and power is computed (deg). - - **ti** (*float*) - The turbulence intensity values for which - the yaw angles are optimized and power is computed. Only - included if self.ti is not None. - - **power_opt** (*float*) - The total power produced by the - wind farm with optimal yaw offsets (W). - - **turbine_power_opt** (*list* (*float*)) - A list - containing the power produced by each wind turbine with optimal - yaw offsets (W). - - **yaw_angles** (*list* (*float*)) - A list containing - the optimal yaw offsets for maximizing total wind farm power - for each wind turbine (deg). - """ - print("=====================================================") - print("Optimizing wake redirection control...") - print("Number of wind conditions to optimize = ", len(self.wd)) - print("Number of yaw angles to optimize = ", len(self.turbs_to_opt)) - print("=====================================================") - - df_opt = pd.DataFrame() - - for i in range(len(self.wd)): - if self.verbose: - if self.ti is None: - print( - "Computing wind speed, wind direction pair " - + str(i) - + " out of " - + str(len(self.wd)) - + ": wind speed = " - + str(self.ws[i]) - + " m/s, wind direction = " - + str(self.wd[i]) - + " deg." - ) - else: - print( - "Computing wind speed, wind direction, turbulence " - + "intensity set " - + str(i) - + " out of " - + str(len(self.wd)) - + ": wind speed = " - + str(self.ws[i]) - + " m/s, wind direction = " - + str(self.wd[i]) - + " deg, turbulence intensity = " - + str(self.ti[i]) - + "." - ) - - # Optimizing wake redirection control - if (self.ws[i] >= self.minimum_ws) & (self.ws[i] <= self.maximum_ws): - if self.ti is None: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], wind_speed=[self.ws[i]] - ) - else: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], - wind_speed=[self.ws[i]], - turbulence_intensity=self.ti[i], - ) - - # Set initial farm power - self.initial_farm_power = self.initial_farm_powers[i] - - # Determine clusters and then optimize by cluster - self._cluster_turbines() - if self.verbose: - print("Clustered turbines into %d separate clusters." % len(self.clusters)) - - # Save parameters to a full list - yaw_angles_template_full = copy.copy(self.yaw_angles_template) - yaw_angles_baseline_full = copy.copy(self.yaw_angles_baseline) - turbine_weights_full = copy.copy(self.turbine_weights) - bnds_full = copy.copy(self.bnds) - # nturbs_full = copy.copy(self.nturbs) - x0_full = copy.copy(self.x0) - fi_full = copy.deepcopy(self.fi) - - # Overwrite parameters for each cluster and optimize - opt_yaw_angles = np.zeros_like(x0_full) - for ci, cl in enumerate(self.clusters): - if self.verbose: - print("=====================================================") - print("Optimizing %d parameters in cluster %d." % (len(cl), ci)) - print("=====================================================") - self.yaw_angles_template = np.array(yaw_angles_template_full)[cl] - self.yaw_angles_baseline = np.array(yaw_angles_baseline_full)[cl] - self.turbine_weights = np.array(turbine_weights_full)[cl] - self.bnds = np.array(bnds_full)[cl] - self.x0 = np.array(x0_full)[cl] - self.fi = copy.deepcopy(fi_full) - self.fi.reinitialize_flow_field( - layout_array=[ - np.array(fi_full.layout_x)[cl], - np.array(fi_full.layout_y)[cl] - ] - ) - opt_yaw_angles[cl] = self._optimize() - - # Restore parameters - self.yaw_angles_template = yaw_angles_template_full - self.yaw_angles_baseline = yaw_angles_baseline_full - self.turbine_weights = turbine_weights_full - self.bnds = bnds_full - self.x0 = x0_full - self.fi = fi_full - self.fi.reinitialize_flow_field( - layout_array=[ - np.array(fi_full.layout_x), - np.array(fi_full.layout_y) - ] - ) - - if np.sum(np.abs(opt_yaw_angles)) == 0: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - - # optimized power - self.fi.calculate_wake(yaw_angles=opt_yaw_angles) - power_opt = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - elif self.ws[i] >= self.maximum_ws: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - if self.ti is None: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], wind_speed=[self.ws[i]] - ) - else: - self.fi.reinitialize_flow_field( - wind_direction=[self.wd[i]], - wind_speed=[self.ws[i]], - turbulence_intensity=self.ti[i], - ) - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - self.fi.calculate_wake(yaw_angles=opt_yaw_angles) - power_opt = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - else: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - power_opt = self.nturbs * [0.0] - - # Include turbine weighing terms - power_opt = np.multiply(self.turbine_weights, power_opt) - - # add variables to dataframe - if self.ti is None: - df_opt = df_opt.append( - pd.DataFrame( - { - "ws": [self.ws[i]], - "wd": [self.wd[i]], - "power_opt": [np.sum(power_opt)], - "turbine_power_opt": [power_opt], - "yaw_angles": [opt_yaw_angles], - } - ) - ) - else: - df_opt = df_opt.append( - pd.DataFrame( - { - "ws": [self.ws[i]], - "wd": [self.wd[i]], - "ti": [self.ti[i]], - "power_opt": [np.sum(power_opt)], - "turbine_power_opt": [power_opt], - "yaw_angles": [opt_yaw_angles], - } - ) - ) - - df_opt.reset_index(drop=True, inplace=True) - - return df_opt diff --git a/floris/tools/optimization/legacy/scipy/yaw_wind_rose_parallel.py b/floris/tools/optimization/legacy/scipy/yaw_wind_rose_parallel.py deleted file mode 100644 index ec46763a5..000000000 --- a/floris/tools/optimization/legacy/scipy/yaw_wind_rose_parallel.py +++ /dev/null @@ -1,595 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -from itertools import repeat - -import numpy as np -import pandas as pd -from scipy.optimize import minimize - -from floris.logging_manager import LoggingManager - -from .yaw_wind_rose import YawOptimizationWindRose - - -class YawOptimizationWindRoseParallel(YawOptimizationWindRose, LoggingManager): - """ - YawOptimizationWindRose is a subclass of - :py:class:`~.tools.optimizationscipy.YawOptimizationWindRose` that is used - to perform parallel computing to optimize the yaw angles of all turbines in - a Floris Farm for multiple sets of inflow conditions (combinations of wind - speed, wind direction, and optionally turbulence intensity) using the scipy - optimize package. Parallel optimization is performed using the - MPIPoolExecutor method of the mpi4py.futures module. - """ - - def __init__( - self, - fi, - wd, - ws, - ti=None, - minimum_yaw_angle=0.0, - maximum_yaw_angle=25.0, - minimum_ws=3.0, - maximum_ws=25.0, - yaw_angles_baseline=None, - x0=None, - bnds=None, - opt_method="SLSQP", - opt_options=None, - include_unc=False, - unc_pmfs=None, - unc_options=None, - turbine_weights=None, - exclude_downstream_turbines=False, - ): - """ - Instantiate YawOptimizationWindRoseParallel object with a - FlorisInterface object and assign parameter values. - - Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - wd (iterable) : The wind directions for which the yaw angles are - optimized (deg). - ws (iterable): The wind speeds for which the yaw angles are - optimized (m/s). - ti (iterable, optional): An optional list of turbulence intensity - values for which the yaw angles are optimized. If not - specified, the current TI value in the Floris object will be - used for all optimizations. Defaults to None. - minimum_yaw_angle (float, optional): Minimum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 0.0. - maximum_yaw_angle (float, optional): Maximum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 25.0. - minimum_ws (float, optional): Minimum wind speed at which - optimization is performed (m/s). Assumes zero power generated - below this value. Defaults to 3. - maximum_ws (float, optional): Maximum wind speed at which - optimization is performed (m/s). Assumes optimal yaw offsets - are zero above this wind speed. Defaults to 25. - yaw_angles_baseline (iterable, optional): The baseline yaw - angles used to calculate the initial and baseline power - production in the wind farm and used to normalize the cost - function. If none are specified, this variable is set equal - to the current yaw angles in floris. Note that this variable - need not meet the yaw constraints specified in self.bnds, - yet a warning is raised if it does to inform the user. - Defaults to None. - x0 (iterable, optional): The initial guess for the optimization - problem. These values must meet the constraints specified - in self.bnds. Note that, if exclude_downstream_turbines=True, - the initial guess for any downstream turbines are ignored - since they are not part of the optimization. Instead, the yaw - angles for those turbines are 0.0 if that meets the lower and - upper bound, or otherwise as close to 0.0 as feasible. If no - values for x0 are specified, x0 is set to be equal to zeros - wherever feasible (w.r.t. the bounds), and equal to the - average of its lower and upper bound for all non-downstream - turbines otherwise. Defaults to None. - bnds (iterable, optional): Bounds for the yaw angles, as tuples of - min, max values for each turbine (deg). One can fix the yaw - angle of certain turbines to a predefined value by setting that - turbine's lower bound equal to its upper bound (i.e., an - equality constraint), as: bnds[ti] = (x, x), where x is the - fixed yaw angle assigned to the turbine. This works for both - zero and nonzero yaw angles. Moreover, if - exclude_downstream_turbines=True, the yaw angles for all - downstream turbines will be 0.0 or a feasible value closest to - 0.0. If none are specified, the bounds are set to - (minimum_yaw_angle, maximum_yaw_angle) for each turbine. Note - that, if bnds is not none, its values overwrite any value given - in minimum_yaw_angle and maximum_yaw_angle. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dictionary, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': False, 'iprint': 1, 'ftol': 1e-7, - 'eps': 0.01}. Defaults to None. - include_unc (bool, optional): Determines whether wind direction or - yaw uncertainty are included. If True, uncertainty in wind - direction and/or yaw position is included when determining - wind farm power. Uncertainty is included by computing the - mean wind farm power for a distribution of wind direction - and yaw position deviations from the intended wind direction - and yaw angles. Defaults to False. - unc_pmfs (dictionary, optional): A dictionary containing - probability mass functions describing the distribution of - wind direction and yaw position deviations when wind direction - and/or yaw position uncertainty is included in the power - calculations. Contains the following key-value pairs: - - - **wd_unc** (*np.array*): The wind direction - deviations from the intended wind direction (deg). - - **wd_unc_pmf** (*np.array*): The probability - of each wind direction deviation in **wd_unc** occuring. - - **yaw_unc** (*np.array*): The yaw angle deviations - from the intended yaw angles (deg). - - **yaw_unc_pmf** (*np.array*): The probability - of each yaw angle deviation in **yaw_unc** occuring. - - If none are specified, default PMFs are calculated using - values provided in **unc_options**. Defaults to None. - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction and yaw - position deviations when wind direction and/or yaw position - uncertainty is included. This argument is only used when - **unc_pmfs** is None and contains the following key-value pairs: - - - **std_wd** (*float*): The standard deviation of - the wind direction deviations from the original wind - direction (deg). - - **std_yaw** (*float*): The standard deviation of - the yaw angle deviations from the original yaw angles (deg). - - **pmf_res** (*float*): The resolution in degrees - of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): The cumulative - distribution function value at which the tails of the - PMFs are truncated. - - If none are specified, default values of - {'std_wd': 4.95, 'std_yaw': 1.75, 'pmf_res': 1.0, - 'pdf_cutoff': 0.995} are used. Defaults to None. - turbine_weights (iterable, optional): weighing terms that allow - the user to emphasize power gains at particular turbines or - completely ignore power gains from other turbines. The array - of turbine powers from floris is multiplied with this array - in the calculation of the objective function. If None, this - is an array with all values 1.0 and length equal to the - number of turbines. Defaults to None. - exclude_downstream_turbines (bool, optional): If True, - automatically finds and excludes turbines that are most - downstream from the optimization problem. This significantly - reduces computation time at no loss in performance. The yaw - angles of these downstream turbines are fixed to 0.0 deg if - the yaw bounds specified in self.bnds allow that, or otherwise - are fixed to the lower or upper yaw bound, whichever is closer - to 0.0. Defaults to False. - """ - super().__init__( - fi, - wd, - ws, - ti=ti, - minimum_yaw_angle=minimum_yaw_angle, - maximum_yaw_angle=maximum_yaw_angle, - minimum_ws=minimum_ws, - maximum_ws=maximum_ws, - yaw_angles_baseline=yaw_angles_baseline, - x0=x0, - bnds=bnds, - opt_method=opt_method, - opt_options=opt_options, - include_unc=include_unc, - unc_pmfs=unc_pmfs, - unc_options=unc_options, - turbine_weights=turbine_weights, - calc_init_power=False, - exclude_downstream_turbines=exclude_downstream_turbines, - ) - - # Private methods - - def _calc_baseline_power_one_case(self, ws, wd, ti=None): - """ - For a single (wind speed, direction, ti (optional)) combination, finds - the baseline power produced by the wind farm and the ideal power - without wake losses. - - Args: - ws (float): The wind speed used in floris for the yaw optimization. - wd (float): The wind direction used in floris for the yaw - optimization. - ti (float, optional): An optional turbulence intensity value for - the yaw optimization. Defaults to None, meaning TI will not be - included in the AEP calculations. - - Returns: - - **df_base** (*Pandas DataFrame*) - DataFrame with a single row, - containing the following columns: - - - **ws** (*float*) - The wind speed value for the row. - - **wd** (*float*) - The wind direction value for the row. - - **ti** (*float*) - The turbulence intensity value for the - row. Only included if self.ti is not None. - - **power_baseline** (*float*) - The total power produced by - the wind farm with baseline yaw control (W). - - **power_no_wake** (*float*) - The ideal total power produced - by the wind farm without wake losses (W). - - **turbine_power_baseline** (*list* (*float*)) - A - list containing the baseline power without wake steering - for each wind turbine (W). - - **turbine_power_no_wake** (*list* (*float*)) - A list - containing the ideal power without wake losses for each - wind turbine (W). - """ - if ti is None: - print( - "Computing wind speed = " - + str(ws) - + " m/s, wind direction = " - + str(wd) - + " deg." - ) - else: - print( - "Computing wind speed = " - + str(ws) - + " m/s, wind direction = " - + str(wd) - + " deg, turbulence intensity = " - + str(ti) - + "." - ) - - # Find baseline power in FLORIS - - if ws >= self.minimum_ws: - if ti is None: - self.fi.reinitialize_flow_field(wind_direction=wd, wind_speed=ws) - else: - self.fi.reinitialize_flow_field( - wind_direction=wd, wind_speed=ws, turbulence_intensity=ti - ) - # calculate baseline power - self.fi.calculate_wake(yaw_angles=self.yaw_angles_baseline) - power_base = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - # calculate power for no wake case - self.fi.calculate_wake(yaw_angles=self.yaw_angles_baseline, no_wake=True) - power_no_wake = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - no_wake=True, - ) - else: - power_base = self.nturbs * [0.0] - power_no_wake = self.nturbs * [0.0] - - # Add turbine weighing terms - power_base = np.multiply(self.turbine_weights, power_base) - power_no_wake = np.multiply(self.turbine_weights, power_no_wake) - - # add variables to dataframe - if ti is None: - df_base = pd.DataFrame( - { - "ws": [ws], - "wd": [wd], - "power_baseline": [np.sum(power_base)], - "turbine_power_baseline": [power_base], - "power_no_wake": [np.sum(power_no_wake)], - "turbine_power_no_wake": [power_no_wake], - } - ) - else: - df_base = pd.DataFrame( - { - "ws": [ws], - "wd": [wd], - "ti": [ti], - "power_baseline": [np.sum(power_base)], - "turbine_power_baseline": [power_base], - "power_no_wake": [np.sum(power_no_wake)], - "turbine_power_no_wake": [power_no_wake], - } - ) - - return df_base - - def _optimize_one_case(self, ws, wd, initial_farm_power, ti=None): - """ - For a single (wind speed, direction, ti (optional)) combination, finds - the power resulting from optimal wake steering. - - Args: - ws (float): The wind speed used in floris for the yaw optimization. - wd (float): The wind direction used in floris for the yaw - optimization. - ti (float, optional): An optional turbulence intensity value for - the yaw optimization. Defaults to None, meaning TI will not be - included in the AEP calculations. - - Returns: - - **df_opt** (*Pandas DataFrame*) - DataFrame with a single row, - containing the following columns: - - - **ws** (*float*) - The wind speed value for the row. - - **wd** (*float*) - The wind direction value for the row. - - **ti** (*float*) - The turbulence intensity value for the - row. Only included if self.ti is not None. - - **power_opt** (*float*) - The total power produced by the - wind farm with optimal yaw offsets (W). - - **turbine_power_opt** (*list* (*float*)) - A list - containing the power produced by each wind turbine with - optimal yaw offsets (W). - - **yaw_angles** (*list* (*float*)) - A list containing - the optimal yaw offsets for maximizing total wind farm - power for each wind turbine (deg). - """ - if ti is None: - print( - "Computing wind speed = " - + str(ws) - + " m/s, wind direction = " - + str(wd) - + " deg." - ) - else: - print( - "Computing wind speed = " - + str(ws) - + " m/s, wind direction = " - + str(wd) - + " deg, turbulence intensity = " - + str(ti) - + "." - ) - - # Optimizing wake redirection control - - if (ws >= self.minimum_ws) & (ws <= self.maximum_ws): - if ti is None: - self.fi.reinitialize_flow_field(wind_direction=wd, wind_speed=ws) - else: - self.fi.reinitialize_flow_field( - wind_direction=wd, wind_speed=ws, turbulence_intensity=ti - ) - - self.initial_farm_power = initial_farm_power - opt_yaw_angles = self._optimize() - - if np.sum(opt_yaw_angles) == 0: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - - # optimized power - self.fi.calculate_wake(yaw_angles=opt_yaw_angles) - power_opt = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - elif ws >= self.minimum_ws: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - if ti is None: - self.fi.reinitialize_flow_field(wind_direction=wd, wind_speed=ws) - else: - self.fi.reinitialize_flow_field( - wind_direction=wd, wind_speed=ws, turbulence_intensity=ti - ) - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - self.fi.calculate_wake(yaw_angles=opt_yaw_angles) - power_opt = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - else: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - power_opt = self.nturbs * [0.0] - - # Add turbine weighing terms - power_opt = np.multiply(self.turbine_weights, power_opt) - - # add variables to dataframe - if ti is None: - df_opt = pd.DataFrame( - { - "ws": [ws], - "wd": [wd], - "power_opt": [np.sum(power_opt)], - "turbine_power_opt": [power_opt], - "yaw_angles": [opt_yaw_angles], - } - ) - else: - df_opt = pd.DataFrame( - { - "ws": [ws], - "wd": [wd], - "ti": [ti], - "power_opt": [np.sum(power_opt)], - "turbine_power_opt": [power_opt], - "yaw_angles": [opt_yaw_angles], - } - ) - - return df_opt - - # Public methods - - def calc_baseline_power(self): - """ - This method computes the baseline power produced by the wind farm and - the ideal power without wake losses for a series of wind speed, wind - direction, and optionally TI combinations. The optimization for - different wind condition combinations is parallelized using the mpi4py - futures module. - - Returns: - pandas.DataFrame: A pandas DataFrame with the same number of rows - as the length of the wd and ws arrays, containing the following - columns: - - - **ws** (*float*) - The wind speed values for which power is - computed (m/s). - - **wd** (*float*) - The wind direction value for which power - is calculated (deg). - - **ti** (*float*) - The turbulence intensity value for which - power is calculated. Only included if self.ti is not None. - - **power_baseline** (*float*) - The total power produced by - he wind farm with baseline yaw control (W). - - **power_no_wake** (*float*) - The ideal total power produced - by the wind farm without wake losses (W). - - **turbine_power_baseline** (*list* (*float*)) - A list - containing the baseline power without wake steering for each - wind turbine in the wind farm (W). - - **turbine_power_no_wake** (*list* (*float*)) - A list - containing the ideal power without wake losses for each wind - turbine in the wind farm (W). - """ - try: - from mpi4py.futures import MPIPoolExecutor - except ImportError: - err_msg = ( - "It appears you do not have mpi4py installed. " - + "Please refer to https://mpi4py.readthedocs.io/ for " - + "guidance on how to properly install the module." - ) - self.logger.error(err_msg, stack_info=True) - raise ImportError(err_msg) - - print("=====================================================") - print("Calculating baseline power in parallel...") - print("Number of wind conditions to calculate = ", len(self.wd)) - print("=====================================================") - - df_base = pd.DataFrame() - - with MPIPoolExecutor() as executor: - if self.ti is None: - for df_base_one in executor.map( - self._calc_baseline_power_one_case, self.ws.values, self.wd.values - ): - - # add variables to dataframe - df_base = df_base.append(df_base_one) - else: - for df_base_one in executor.map( - self._calc_baseline_power_one_case, - self.ws.values, - self.wd.values, - self.ti.values, - ): - - # add variables to dataframe - df_base = df_base.append(df_base_one) - - df_base.reset_index(drop=True, inplace=True) - - self.df_base = df_base - return df_base - - def optimize(self): - """ - This method solves for the optimum turbine yaw angles for power - production and the resulting power produced by the wind farm for a - series of wind speed, wind direction, and optionally TI combinations. - The optimization for different wind condition combinations is - parallelized using the mpi4py.futures module. - - Returns: - pandas.DataFrame: A pandas DataFrame with the same number of rows - as the length of the wd and ws arrays, containing the following - columns: - - - **ws** (*float*) - The wind speed values for which the yaw - angles are optimized and power is computed (m/s). - - **wd** (*float*) - The wind direction values for which the - yaw angles are optimized and power is computed (deg). - - **ti** (*float*) - The turbulence intensity values for which - the yaw angles are optimized and power is computed. Only - included if self.ti is not None. - - **power_opt** (*float*) - The total power produced by the - wind farm with optimal yaw offsets (W). - - **turbine_power_opt** (*list* (*float*)) - A list containing - the power produced by each wind turbine with optimal yaw - offsets (W). - - **yaw_angles** (*list* (*float*)) - A list containing the - optimal yaw offsets for maximizing total wind farm power for - each wind turbine (deg). - """ - try: - from mpi4py.futures import MPIPoolExecutor - except ImportError: - err_msg = ( - "It appears you do not have mpi4py installed. " - + "Please refer to https://mpi4py.readthedocs.io/ for " - + "guidance on how to properly install the module." - ) - self.logger.error(err_msg, stack_info=True) - raise ImportError(err_msg) - - print("=====================================================") - print("Optimizing wake redirection control in parallel...") - print("Number of wind conditions to optimize = ", len(self.wd)) - print("Number of yaw angles to optimize = ", len(self.turbs_to_opt)) - print("=====================================================") - - df_opt = pd.DataFrame() - - with MPIPoolExecutor() as executor: - if self.ti is None: - for df_opt_one in executor.map( - self._optimize_one_case, - self.ws.values, - self.wd.values, - self.df_base.power_baseline.values, - ): - - # add variables to dataframe - df_opt = df_opt.append(df_opt_one) - else: - for df_opt_one in executor.map( - self._optimize_one_case, - self.ws.values, - self.wd.values, - self.df_base.power_baseline.values, - self.ti.values, - ): - - # add variables to dataframe - df_opt = df_opt.append(df_opt_one) - - df_opt.reset_index(drop=True, inplace=True) - - return df_opt diff --git a/floris/tools/optimization/legacy/scipy/yaw_wind_rose_parallel_clustered.py b/floris/tools/optimization/legacy/scipy/yaw_wind_rose_parallel_clustered.py deleted file mode 100644 index caacc0429..000000000 --- a/floris/tools/optimization/legacy/scipy/yaw_wind_rose_parallel_clustered.py +++ /dev/null @@ -1,658 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import copy -from itertools import repeat - -import numpy as np -import pandas as pd -from scipy.optimize import minimize - -from floris.logging_manager import LoggingManager - -from .yaw_wind_rose_clustered import YawOptimizationWindRoseClustered - - -class YawOptimizationWindRoseParallelClustered(YawOptimizationWindRoseClustered, LoggingManager): - """ - YawOptimizationWindRoseClustered is a subclass of - :py:class:`~.tools.optimizationscipy.YawOptimizationWindRoseClustered` that - is used to perform optimizations of the yaw angles of all turbines in a - Floris Farm for multiple sets of inflow conditions (combinations of wind - speed, wind direction, and optionally turbulence intensity) using the scipy - optimize package. This class additionally facilitates the clusterization of - the turbines into seperate subsets (clusters) in which the turbines witin - each subset exclusively interact with one another and have no impact on turbines - in other clusters. This may significantly reduce the computational - burden at no loss in performance (assuming the turbine clusters are truly - independent). This class additionally facilitates parallel optimization - using the MPIPoolExecutor method of the mpi4py.futures module. - """ - - def __init__( - self, - fi, - wd, - ws, - ti=None, - minimum_yaw_angle=0.0, - maximum_yaw_angle=25.0, - minimum_ws=3.0, - maximum_ws=25.0, - yaw_angles_baseline=None, - x0=None, - bnds=None, - opt_method="SLSQP", - opt_options=None, - include_unc=False, - unc_pmfs=None, - unc_options=None, - turbine_weights=None, - exclude_downstream_turbines=False, - clustering_wake_slope=0.30 - ): - """ - Instantiate YawOptimizationWindRoseParallel object with a - FlorisInterface object and assign parameter values. - - Args: - fi (:py:class:`~.tools.floris_interface.FlorisInterface`): - Interface used to interact with the Floris object. - wd (iterable) : The wind directions for which the yaw angles are - optimized (deg). - ws (iterable): The wind speeds for which the yaw angles are - optimized (m/s). - ti (iterable, optional): An optional list of turbulence intensity - values for which the yaw angles are optimized. If not - specified, the current TI value in the Floris object will be - used for all optimizations. Defaults to None. - minimum_yaw_angle (float, optional): Minimum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 0.0. - maximum_yaw_angle (float, optional): Maximum constraint on yaw - angle (deg). This value will be ignored if bnds is also - specified. Defaults to 25.0. - minimum_ws (float, optional): Minimum wind speed at which - optimization is performed (m/s). Assumes zero power generated - below this value. Defaults to 3. - maximum_ws (float, optional): Maximum wind speed at which - optimization is performed (m/s). Assumes optimal yaw offsets - are zero above this wind speed. Defaults to 25. - yaw_angles_baseline (iterable, optional): The baseline yaw - angles used to calculate the initial and baseline power - production in the wind farm and used to normalize the cost - function. If none are specified, this variable is set equal - to the current yaw angles in floris. Note that this variable - need not meet the yaw constraints specified in self.bnds, - yet a warning is raised if it does to inform the user. - Defaults to None. - x0 (iterable, optional): The initial guess for the optimization - problem. These values must meet the constraints specified - in self.bnds. Note that, if exclude_downstream_turbines=True, - the initial guess for any downstream turbines are ignored - since they are not part of the optimization. Instead, the yaw - angles for those turbines are 0.0 if that meets the lower and - upper bound, or otherwise as close to 0.0 as feasible. If no - values for x0 are specified, x0 is set to be equal to zeros - wherever feasible (w.r.t. the bounds), and equal to the - average of its lower and upper bound for all non-downstream - turbines otherwise. Defaults to None. - bnds (iterable, optional): Bounds for the yaw angles, as tuples of - min, max values for each turbine (deg). One can fix the yaw - angle of certain turbines to a predefined value by setting that - turbine's lower bound equal to its upper bound (i.e., an - equality constraint), as: bnds[ti] = (x, x), where x is the - fixed yaw angle assigned to the turbine. This works for both - zero and nonzero yaw angles. Moreover, if - exclude_downstream_turbines=True, the yaw angles for all - downstream turbines will be 0.0 or a feasible value closest to - 0.0. If none are specified, the bounds are set to - (minimum_yaw_angle, maximum_yaw_angle) for each turbine. Note - that, if bnds is not none, its values overwrite any value given - in minimum_yaw_angle and maximum_yaw_angle. Defaults to None. - opt_method (str, optional): The optimization method used by - scipy.optimize.minize. Defaults to 'SLSQP'. - opt_options (dictionary, optional): Optimization options used by - scipy.optimize.minize. If none are specified, they are set to - {'maxiter': 100, 'disp': False, 'iprint': 1, 'ftol': 1e-7, - 'eps': 0.01}. Defaults to None. - include_unc (bool, optional): Determines whether wind direction or - yaw uncertainty are included. If True, uncertainty in wind - direction and/or yaw position is included when determining - wind farm power. Uncertainty is included by computing the - mean wind farm power for a distribution of wind direction - and yaw position deviations from the intended wind direction - and yaw angles. Defaults to False. - unc_pmfs (dictionary, optional): A dictionary containing - probability mass functions describing the distribution of - wind direction and yaw position deviations when wind direction - and/or yaw position uncertainty is included in the power - calculations. Contains the following key-value pairs: - - - **wd_unc** (*np.array*): The wind direction - deviations from the intended wind direction (deg). - - **wd_unc_pmf** (*np.array*): The probability - of each wind direction deviation in **wd_unc** occuring. - - **yaw_unc** (*np.array*): The yaw angle deviations - from the intended yaw angles (deg). - - **yaw_unc_pmf** (*np.array*): The probability - of each yaw angle deviation in **yaw_unc** occuring. - - If none are specified, default PMFs are calculated using - values provided in **unc_options**. Defaults to None. - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction and yaw - position deviations when wind direction and/or yaw position - uncertainty is included. This argument is only used when - **unc_pmfs** is None and contains the following key-value pairs: - - - **std_wd** (*float*): The standard deviation of - the wind direction deviations from the original wind - direction (deg). - - **std_yaw** (*float*): The standard deviation of - the yaw angle deviations from the original yaw angles (deg). - - **pmf_res** (*float*): The resolution in degrees - of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): The cumulative - distribution function value at which the tails of the - PMFs are truncated. - - If none are specified, default values of - {'std_wd': 4.95, 'std_yaw': 1.75, 'pmf_res': 1.0, - 'pdf_cutoff': 0.995} are used. Defaults to None. - turbine_weights (iterable, optional): weighing terms that allow - the user to emphasize power gains at particular turbines or - completely ignore power gains from other turbines. The array - of turbine powers from floris is multiplied with this array - in the calculation of the objective function. If None, this - is an array with all values 1.0 and length equal to the - number of turbines. Defaults to None. - exclude_downstream_turbines (bool, optional): If True, - automatically finds and excludes turbines that are most - downstream from the optimization problem. This significantly - reduces computation time at no loss in performance. The yaw - angles of these downstream turbines are fixed to 0.0 deg if - the yaw bounds specified in self.bnds allow that, or otherwise - are fixed to the lower or upper yaw bound, whichever is closer - to 0.0. Defaults to False. - clustering_wake_slope (float, optional): linear slope of the wake - in the simplified linear expansion wake model (dy/dx). This - model is used to derive wake interactions between turbines and - to identify the turbine clusters. A good value is about equal - to the turbulence intensity in FLORIS. Though, since yaw - optimizations may shift the wake laterally, a safer option - is twice the turbulence intensity. The default value is 0.30 - which should be valid for yaw optimizations at wd_std = 0.0 deg - and turbulence intensities up to 15%. Defaults to 0.30. - """ - super().__init__( - fi, - wd, - ws, - ti=ti, - minimum_yaw_angle=minimum_yaw_angle, - maximum_yaw_angle=maximum_yaw_angle, - minimum_ws=minimum_ws, - maximum_ws=maximum_ws, - yaw_angles_baseline=yaw_angles_baseline, - x0=x0, - bnds=bnds, - opt_method=opt_method, - opt_options=opt_options, - include_unc=include_unc, - unc_pmfs=unc_pmfs, - unc_options=unc_options, - turbine_weights=turbine_weights, - calc_init_power=False, - exclude_downstream_turbines=exclude_downstream_turbines, - clustering_wake_slope=clustering_wake_slope - ) - self.clustering_wake_slope = clustering_wake_slope - - # Private methods - - def _calc_baseline_power_one_case(self, ws, wd, ti=None): - """ - For a single (wind speed, direction, ti (optional)) combination, finds - the baseline power produced by the wind farm and the ideal power - without wake losses. - - Args: - ws (float): The wind speed used in floris for the yaw optimization. - wd (float): The wind direction used in floris for the yaw - optimization. - ti (float, optional): An optional turbulence intensity value for - the yaw optimization. Defaults to None, meaning TI will not be - included in the AEP calculations. - - Returns: - - **df_base** (*Pandas DataFrame*) - DataFrame with a single row, - containing the following columns: - - - **ws** (*float*) - The wind speed value for the row. - - **wd** (*float*) - The wind direction value for the row. - - **ti** (*float*) - The turbulence intensity value for the - row. Only included if self.ti is not None. - - **power_baseline** (*float*) - The total power produced by - the wind farm with baseline yaw control (W). - - **power_no_wake** (*float*) - The ideal total power produced - by the wind farm without wake losses (W). - - **turbine_power_baseline** (*list* (*float*)) - A - list containing the baseline power without wake steering - for each wind turbine (W). - - **turbine_power_no_wake** (*list* (*float*)) - A list - containing the ideal power without wake losses for each - wind turbine (W). - """ - if ti is None: - print( - "Computing wind speed = " - + str(ws) - + " m/s, wind direction = " - + str(wd) - + " deg." - ) - else: - print( - "Computing wind speed = " - + str(ws) - + " m/s, wind direction = " - + str(wd) - + " deg, turbulence intensity = " - + str(ti) - + "." - ) - - # Find baseline power in FLORIS - - if ws >= self.minimum_ws: - if ti is None: - self.fi.reinitialize_flow_field(wind_direction=wd, wind_speed=ws) - else: - self.fi.reinitialize_flow_field( - wind_direction=wd, wind_speed=ws, turbulence_intensity=ti - ) - # calculate baseline power - self.fi.calculate_wake(yaw_angles=self.yaw_angles_baseline) - power_base = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - # calculate power for no wake case - self.fi.calculate_wake(yaw_angles=self.yaw_angles_baseline, no_wake=True) - power_no_wake = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - no_wake=True, - ) - else: - power_base = self.nturbs * [0.0] - power_no_wake = self.nturbs * [0.0] - - # Add turbine weighing terms - power_base = np.multiply(self.turbine_weights, power_base) - power_no_wake = np.multiply(self.turbine_weights, power_no_wake) - - # add variables to dataframe - if ti is None: - df_base = pd.DataFrame( - { - "ws": [ws], - "wd": [wd], - "power_baseline": [np.sum(power_base)], - "turbine_power_baseline": [power_base], - "power_no_wake": [np.sum(power_no_wake)], - "turbine_power_no_wake": [power_no_wake], - } - ) - else: - df_base = pd.DataFrame( - { - "ws": [ws], - "wd": [wd], - "ti": [ti], - "power_baseline": [np.sum(power_base)], - "turbine_power_baseline": [power_base], - "power_no_wake": [np.sum(power_no_wake)], - "turbine_power_no_wake": [power_no_wake], - } - ) - - return df_base - - def _optimize_one_case(self, ws, wd, initial_farm_power, ti=None): - """ - For a single (wind speed, direction, ti (optional)) combination, finds - the power resulting from optimal wake steering. - - Args: - ws (float): The wind speed used in floris for the yaw optimization. - wd (float): The wind direction used in floris for the yaw - optimization. - ti (float, optional): An optional turbulence intensity value for - the yaw optimization. Defaults to None, meaning TI will not be - included in the AEP calculations. - - Returns: - - **df_opt** (*Pandas DataFrame*) - DataFrame with a single row, - containing the following columns: - - - **ws** (*float*) - The wind speed value for the row. - - **wd** (*float*) - The wind direction value for the row. - - **ti** (*float*) - The turbulence intensity value for the - row. Only included if self.ti is not None. - - **power_opt** (*float*) - The total power produced by the - wind farm with optimal yaw offsets (W). - - **turbine_power_opt** (*list* (*float*)) - A list - containing the power produced by each wind turbine with - optimal yaw offsets (W). - - **yaw_angles** (*list* (*float*)) - A list containing - the optimal yaw offsets for maximizing total wind farm - power for each wind turbine (deg). - """ - if ti is None: - print( - "Computing wind speed = " - + str(ws) - + " m/s, wind direction = " - + str(wd) - + " deg." - ) - else: - print( - "Computing wind speed = " - + str(ws) - + " m/s, wind direction = " - + str(wd) - + " deg, turbulence intensity = " - + str(ti) - + "." - ) - - # Optimizing wake redirection control - - if (ws >= self.minimum_ws) & (ws <= self.maximum_ws): - if ti is None: - self.fi.reinitialize_flow_field(wind_direction=wd, wind_speed=ws) - else: - self.fi.reinitialize_flow_field( - wind_direction=wd, wind_speed=ws, turbulence_intensity=ti - ) - - self.initial_farm_power = initial_farm_power - - # Determine clusters and then optimize by cluster - self._cluster_turbines() - - # Save parameters to a full list - yaw_angles_template_full = copy.copy(self.yaw_angles_template) - yaw_angles_baseline_full = copy.copy(self.yaw_angles_baseline) - turbine_weights_full = copy.copy(self.turbine_weights) - bnds_full = copy.copy(self.bnds) - x0_full = copy.copy(self.x0) - fi_full = copy.deepcopy(self.fi) - - # Overwrite parameters for each cluster and optimize - opt_yaw_angles = np.zeros_like(x0_full) - for ci, cl in enumerate(self.clusters): - if self.verbose: - print("=====================================================") - print("Optimizing %d parameters in cluster %d." % (len(cl), ci)) - print("=====================================================") - self.yaw_angles_template = np.array(yaw_angles_template_full)[cl] - self.yaw_angles_baseline = np.array(yaw_angles_baseline_full)[cl] - self.turbine_weights = np.array(turbine_weights_full)[cl] - self.bnds = np.array(bnds_full)[cl] - self.x0 = np.array(x0_full)[cl] - self.fi = copy.deepcopy(fi_full) - self.fi.reinitialize_flow_field( - layout_array=[ - np.array(fi_full.layout_x)[cl], - np.array(fi_full.layout_y)[cl] - ] - ) - opt_yaw_angles[cl] = self._optimize() - - # Restore parameters - self.yaw_angles_template = yaw_angles_template_full - self.yaw_angles_baseline = yaw_angles_baseline_full - self.turbine_weights = turbine_weights_full - self.bnds = bnds_full - self.x0 = x0_full - self.fi = fi_full - self.fi.reinitialize_flow_field( - layout_array=[ - np.array(fi_full.layout_x), - np.array(fi_full.layout_y) - ] - ) - - if np.sum(np.abs(opt_yaw_angles)) == 0: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - - # optimized power - self.fi.calculate_wake(yaw_angles=opt_yaw_angles) - power_opt = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - elif ws >= self.minimum_ws: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - if ti is None: - self.fi.reinitialize_flow_field(wind_direction=wd, wind_speed=ws) - else: - self.fi.reinitialize_flow_field( - wind_direction=wd, wind_speed=ws, turbulence_intensity=ti - ) - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - self.fi.calculate_wake(yaw_angles=opt_yaw_angles) - power_opt = self.fi.get_turbine_power( - include_unc=self.include_unc, - unc_pmfs=self.unc_pmfs, - unc_options=self.unc_options, - ) - else: - print( - "No change in controls suggested for this inflow \ - condition..." - ) - opt_yaw_angles = np.array(self.yaw_angles_template, copy=True) - power_opt = self.nturbs * [0.0] - - # Add turbine weighing terms - power_opt = np.multiply(self.turbine_weights, power_opt) - - # add variables to dataframe - if ti is None: - df_opt = pd.DataFrame( - { - "ws": [ws], - "wd": [wd], - "power_opt": [np.sum(power_opt)], - "turbine_power_opt": [power_opt], - "yaw_angles": [opt_yaw_angles], - } - ) - else: - df_opt = pd.DataFrame( - { - "ws": [ws], - "wd": [wd], - "ti": [ti], - "power_opt": [np.sum(power_opt)], - "turbine_power_opt": [power_opt], - "yaw_angles": [opt_yaw_angles], - } - ) - - return df_opt - - # Public methods - - def calc_baseline_power(self): - """ - This method computes the baseline power produced by the wind farm and - the ideal power without wake losses for a series of wind speed, wind - direction, and optionally TI combinations. The optimization for - different wind condition combinations is parallelized using the mpi4py - futures module. - - Returns: - pandas.DataFrame: A pandas DataFrame with the same number of rows - as the length of the wd and ws arrays, containing the following - columns: - - - **ws** (*float*) - The wind speed values for which power is - computed (m/s). - - **wd** (*float*) - The wind direction value for which power - is calculated (deg). - - **ti** (*float*) - The turbulence intensity value for which - power is calculated. Only included if self.ti is not None. - - **power_baseline** (*float*) - The total power produced by - he wind farm with baseline yaw control (W). - - **power_no_wake** (*float*) - The ideal total power produced - by the wind farm without wake losses (W). - - **turbine_power_baseline** (*list* (*float*)) - A list - containing the baseline power without wake steering for each - wind turbine in the wind farm (W). - - **turbine_power_no_wake** (*list* (*float*)) - A list - containing the ideal power without wake losses for each wind - turbine in the wind farm (W). - """ - try: - from mpi4py.futures import MPIPoolExecutor - except ImportError: - err_msg = ( - "It appears you do not have mpi4py installed. " - + "Please refer to https://mpi4py.readthedocs.io/ for " - + "guidance on how to properly install the module." - ) - self.logger.error(err_msg, stack_info=True) - raise ImportError(err_msg) - - print("=====================================================") - print("Calculating baseline power in parallel...") - print("Number of wind conditions to calculate = ", len(self.wd)) - print("=====================================================") - - df_base = pd.DataFrame() - - with MPIPoolExecutor() as executor: - if self.ti is None: - for df_base_one in executor.map( - self._calc_baseline_power_one_case, self.ws.values, self.wd.values - ): - - # add variables to dataframe - df_base = df_base.append(df_base_one) - else: - for df_base_one in executor.map( - self._calc_baseline_power_one_case, - self.ws.values, - self.wd.values, - self.ti.values, - ): - - # add variables to dataframe - df_base = df_base.append(df_base_one) - - df_base.reset_index(drop=True, inplace=True) - - self.df_base = df_base - return df_base - - def optimize(self): - """ - This method solves for the optimum turbine yaw angles for power - production and the resulting power produced by the wind farm for a - series of wind speed, wind direction, and optionally TI combinations. - The optimization for different wind condition combinations is - parallelized using the mpi4py.futures module. - - Returns: - pandas.DataFrame: A pandas DataFrame with the same number of rows - as the length of the wd and ws arrays, containing the following - columns: - - - **ws** (*float*) - The wind speed values for which the yaw - angles are optimized and power is computed (m/s). - - **wd** (*float*) - The wind direction values for which the - yaw angles are optimized and power is computed (deg). - - **ti** (*float*) - The turbulence intensity values for which - the yaw angles are optimized and power is computed. Only - included if self.ti is not None. - - **power_opt** (*float*) - The total power produced by the - wind farm with optimal yaw offsets (W). - - **turbine_power_opt** (*list* (*float*)) - A list containing - the power produced by each wind turbine with optimal yaw - offsets (W). - - **yaw_angles** (*list* (*float*)) - A list containing the - optimal yaw offsets for maximizing total wind farm power for - each wind turbine (deg). - """ - try: - from mpi4py.futures import MPIPoolExecutor - except ImportError: - err_msg = ( - "It appears you do not have mpi4py installed. " - + "Please refer to https://mpi4py.readthedocs.io/ for " - + "guidance on how to properly install the module." - ) - self.logger.error(err_msg, stack_info=True) - raise ImportError(err_msg) - - print("=====================================================") - print("Optimizing wake redirection control in parallel...") - print("Number of wind conditions to optimize = ", len(self.wd)) - print("Number of yaw angles to optimize = ", len(self.turbs_to_opt)) - print("=====================================================") - - df_opt = pd.DataFrame() - - with MPIPoolExecutor() as executor: - if self.ti is None: - for df_opt_one in executor.map( - self._optimize_one_case, - self.ws.values, - self.wd.values, - self.df_base.power_baseline.values, - ): - - # add variables to dataframe - df_opt = df_opt.append(df_opt_one) - else: - for df_opt_one in executor.map( - self._optimize_one_case, - self.ws.values, - self.wd.values, - self.df_base.power_baseline.values, - self.ti.values, - ): - - # add variables to dataframe - df_opt = df_opt.append(df_opt_one) - - df_opt.reset_index(drop=True, inplace=True) - - return df_opt diff --git a/floris/tools/optimization/yaw_optimization/__init__.py b/floris/tools/optimization/yaw_optimization/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py b/floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py deleted file mode 100644 index 325637a81..000000000 --- a/floris/tools/optimization/yaw_optimization/yaw_optimization_tools.py +++ /dev/null @@ -1,207 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd - - -def derive_downstream_turbines(fi, wind_direction, wake_slope=0.30, plot_lines=False): - """Determine which turbines have no effect on other turbines in the - farm, i.e., which turbines have wakes that do not impact the other - turbines in the farm. This allows the user to exclude these turbines - from a control setpoint optimization, for example. This function - assumes a very simplified wake function where the wakes are assumed - to have a linearly diverging profile. In comparisons with the FLORIS - GCH model, the wake_slope matches well with the FLORIS' wake profiles - for a value of wake_slope = 0.5 * turbulence_intensity, where - turbulence_intensity is an input to the FLORIS model at the default - GCH parameterization. Note that does not include wind direction variability. - To be conservative, the user is recommended to use the rule of thumb: - `wake_slope = turbulence_intensity`. Hence, the default value for - `wake_slope=0.30` should be conservative for turbulence intensities up to - 0.30 and is likely to provide valid estimates of which turbines are - downstream until a turbulence intensity of 0.50. This simple model saves - time compared to FLORIS. - - Args: - fi ([floris object]): FLORIS object of the farm of interest. - wind_direction (float): The wind direction in the FLORIS frame - of reference for which the downstream turbines are to be determined. - wake_slope (float, optional): linear slope of the wake (dy/dx) - plot_lines (bool, optional): Enable plotting wakes/turbines. - Defaults to False. - - Returns: - turbs_downstream (iterable): A list containing the turbine - numbers that have a wake that does not affect any other - turbine inside the farm. - """ - - # Get farm layout - x = fi.layout_x - y = fi.layout_y - D = np.ones_like(x) * fi.floris.farm.rotor_diameters_sorted[0][0][0] - n_turbs = len(x) - - # Rotate farm and determine freestream/waked turbines - is_downstream = [False for _ in range(n_turbs)] - x_rot = ( - np.cos((wind_direction - 270.0) * np.pi / 180.0) * x - - np.sin((wind_direction - 270.0) * np.pi / 180.0) * y - ) - y_rot = ( - np.sin((wind_direction - 270.0) * np.pi / 180.0) * x - + np.cos((wind_direction - 270.0) * np.pi / 180.0) * y - ) - - if plot_lines: - fig, ax = plt.subplots() - for ii in range(n_turbs): - ax.plot( - x_rot[ii] * np.ones(2), - [y_rot[ii] - D[ii] / 2, y_rot[ii] + D[ii] / 2], - "k", - ) - for ii in range(n_turbs): - ax.text(x_rot[ii], y_rot[ii], "T%03d" % ii) - ax.axis("equal") - - srt = np.argsort(x_rot) - x_rot_srt = x_rot[srt] - y_rot_srt = y_rot[srt] - for ii in range(n_turbs): - x0 = x_rot_srt[ii] - y0 = y_rot_srt[ii] - - def wake_profile_ub_turbii(x): - y = (y0 + D[ii]) + (x - x0) * wake_slope - if isinstance(y, (float, np.float64, np.float32)): - if x < (x0 + 0.01): - y = -np.Inf - else: - y[x < x0 + 0.01] = -np.Inf - return y - - def wake_profile_lb_turbii(x): - y = (y0 - D[ii]) - (x - x0) * wake_slope - if isinstance(y, (float, np.float64, np.float32)): - if x < (x0 + 0.01): - y = -np.Inf - else: - y[x < x0 + 0.01] = -np.Inf - return y - - def determine_if_in_wake(xt, yt): - return (yt < wake_profile_ub_turbii(xt)) & (yt > wake_profile_lb_turbii(xt)) - - is_downstream[ii] = not any( - determine_if_in_wake(x_rot_srt[iii], y_rot_srt[iii]) for iii in range(n_turbs) - ) - - if plot_lines: - x1 = np.max(x_rot_srt) + 500.0 - ax.fill_between( - [x0, x1, x1, x0], - [ - wake_profile_ub_turbii(x0 + 0.02), - wake_profile_ub_turbii(x1), - wake_profile_lb_turbii(x1), - wake_profile_lb_turbii(x0 + 0.02), - ], - alpha=0.1, - color="k", - edgecolor=None, - ) - - usrt = np.argsort(srt) - is_downstream = [is_downstream[i] for i in usrt] - turbs_downstream = list(np.where(is_downstream)[0]) - - if plot_lines: - ax.set_title("wind_direction = %03d" % wind_direction) - ax.set_xlim([np.min(x_rot) - 500.0, x1]) - ax.set_ylim([np.min(y_rot) - 500.0, np.max(y_rot) + 500.0]) - ax.plot( - x_rot[turbs_downstream], - y_rot[turbs_downstream], - "o", - color="green", - ) - - return turbs_downstream - - -def find_layout_symmetry(x, y, step_sizes = [15.0], eps=0.00001): - # Place center of farm at (0, 0) - x = x - np.mean(x) - y = y - np.mean(y) - nturbs = len(x) - - # Evaluate at continuously refined step size - for ss in step_sizes: - wd_array = np.arange(ss, 180.001, ss) - for wd in wd_array: - is_faulty = False - x_rot = ( - np.cos(wd * np.pi / 180.0) * x - - np.sin(wd * np.pi / 180.0) * y - ) - y_rot = ( - np.sin(wd * np.pi / 180.0) * x - + np.cos(wd * np.pi / 180.0) * y - ) - - # compare differences: force turbine 0 to (0, 0) - for ti in range(nturbs): - if np.all(np.abs(x_rot[ti] - x) > eps): - is_faulty = True - break - - if is_faulty: - continue - - for ti in range(nturbs): - if np.all(np.abs(y_rot[ti] - y) > eps): - is_faulty = True - break - - if is_faulty: - continue - - # Found a valid solution. Now find mappings - wd_eval_array = [(0.0, wd)] - mapping_array = [list(range(nturbs))] - for wd_eval in np.arange(wd, 360.0, wd): - ang = wd_eval * -1.0 # Opposite rotation - x_rot = ( - np.cos(ang * np.pi / 180.0) * x - - np.sin(ang * np.pi / 180.0) * y - ) - y_rot = ( - np.sin(ang * np.pi / 180.0) * x - + np.cos(ang * np.pi / 180.0) * y - ) - wd_eval_array.append((wd_eval, wd_eval + wd)) - id_mapping = ([ - np.where((np.abs(xr - x) < eps) &(np.abs(yr - y) < eps))[0][0] - for xr, yr in zip(x_rot, y_rot) - ]) - mapping_array.append(id_mapping) - - df = pd.DataFrame({"wd_range": wd_eval_array, "turbine_mapping": mapping_array}) - return df - - return pd.DataFrame() # Return empty dataframe if completes without finding solution diff --git a/floris/tools/optimization/yaw_optimization/yaw_optimizer_scipy.py b/floris/tools/optimization/yaw_optimization/yaw_optimizer_scipy.py deleted file mode 100644 index 66339e426..000000000 --- a/floris/tools/optimization/yaw_optimization/yaw_optimizer_scipy.py +++ /dev/null @@ -1,151 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import numpy as np -from scipy.optimize import minimize - -from .yaw_optimization_base import YawOptimization - - -class YawOptimizationScipy(YawOptimization): - """ - YawOptimizationScipy is a subclass of - :py:class:`floris.tools.optimization.general_library.YawOptimization` that is - used to optimize the yaw angles of all turbines in a Floris Farm for a single - set of inflow conditions using the SciPy optimize package. - """ - - def __init__( - self, - fi, - minimum_yaw_angle=0.0, - maximum_yaw_angle=25.0, - yaw_angles_baseline=None, - x0=None, - opt_method="SLSQP", - opt_options=None, - turbine_weights=None, - exclude_downstream_turbines=True, - exploit_layout_symmetry=True, - verify_convergence=False, - ): - """ - Instantiate YawOptimizationScipy object with a FlorisInterface object - and assign parameter values. - """ - if opt_options is None: - # Default SciPy parameters - opt_options = { - "maxiter": 100, - "disp": True, - "iprint": 2, - "ftol": 1e-12, - "eps": 0.1, - } - - super().__init__( - fi=fi, - minimum_yaw_angle=minimum_yaw_angle, - maximum_yaw_angle=maximum_yaw_angle, - yaw_angles_baseline=yaw_angles_baseline, - x0=x0, - turbine_weights=turbine_weights, - normalize_control_variables=True, - calc_baseline_power=True, - exclude_downstream_turbines=exclude_downstream_turbines, - exploit_layout_symmetry=exploit_layout_symmetry, - verify_convergence=verify_convergence, - ) - - self.opt_method = opt_method - self.opt_options = opt_options - - def optimize(self): - """ - Find optimum setting of turbine yaw angles for a single turbine - cluster that maximizes the weighted wind farm power production - given fixed atmospheric conditions (wind speed, direction, etc.) - using the scipy.optimize.minimize function. - - Returns: - opt_yaw_angles (np.array): Optimal yaw angles in degrees. This - array is equal in length to the number of turbines in the farm. - """ - # Loop through every WD and WS individually - wd_array = self.fi_subset.floris.flow_field.wind_directions - ws_array = self.fi_subset.floris.flow_field.wind_speeds - for nwsi, ws in enumerate(ws_array): - - self.fi_subset.reinitialize(wind_speeds=[ws]) - - for nwdi, wd in enumerate(wd_array): - # Find turbines to optimize - turbs_to_opt = self._turbs_to_opt_subset[nwdi, nwsi, :] - if not any(turbs_to_opt): - continue # Nothing to do here: no turbines to optimize - - # Extract current optimization problem variables (normalized) - yaw_lb = self._minimum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt] - yaw_ub = self._maximum_yaw_angle_subset_norm[nwdi, nwsi, turbs_to_opt] - bnds = [(a, b) for a, b in zip(yaw_lb, yaw_ub)] - x0 = self._x0_subset_norm[nwdi, nwsi, turbs_to_opt] - - J0 = self._farm_power_baseline_subset[nwdi, nwsi] - yaw_template = self._yaw_angles_template_subset[nwdi, nwsi, :] - turbine_weights = self._turbine_weights_subset[nwdi, nwsi, :] - yaw_template = np.tile(yaw_template, (1, 1, 1)) - turbine_weights = np.tile(turbine_weights, (1, 1, 1)) - - # Handle heterogeneous inflow, if there is one - if (hasattr(self.fi.floris.flow_field, 'heterogenous_inflow_config') and - self.fi.floris.flow_field.heterogenous_inflow_config is not None): - het_sm_orig = np.array( - self.fi.floris.flow_field.heterogenous_inflow_config['speed_multipliers'] - ) - het_sm = het_sm_orig[nwdi,:].reshape(1,-1) - else: - het_sm = None - - # Define cost function - def cost(x): - x_full = np.array(yaw_template, copy=True) - x_full[0, 0, turbs_to_opt] = x * self._normalization_length - return ( - - 1.0 * self._calculate_farm_power( - yaw_angles=x_full, - wd_array=[wd], - turbine_weights=turbine_weights, - heterogeneous_speed_multipliers=het_sm - )[0, 0] / J0 - ) - - # Perform optimization - residual_plant = minimize( - fun=cost, - x0=x0, - bounds=bnds, - method=self.opt_method, - options=self.opt_options, - ) - - # Undo normalization/masks and save results to self - self._farm_power_opt_subset[nwdi, nwsi] = -residual_plant.fun * J0 - self._yaw_angles_opt_subset[nwdi, nwsi, turbs_to_opt] = ( - residual_plant.x * self._normalization_length - ) - - # Finalize optimization, i.e., retrieve full solutions - df_opt = self._finalize() - return df_opt diff --git a/floris/tools/power_rose.py b/floris/tools/power_rose.py deleted file mode 100644 index 579d5e783..000000000 --- a/floris/tools/power_rose.py +++ /dev/null @@ -1,500 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import os -import pickle - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd - -from floris.utilities import wrap_180 - - -# TODO: organize by private and public methods - - -class PowerRose: - """ - The PowerRose class is used to organize information about wind farm power - production for different wind conditions (e.g., wind speed, wind direction) - along with their frequencies of occurance to calculate the resulting annual - energy production (AEP). Power production and AEP are considered for - baseline operation, ideal operation without wake losses, and optionally - optimal operation with wake steering. The primary purpose of the PowerRose - class is for visualizing and reporting energy production and energy gains - from wake steering. A PowerRose object can be populated with user-specified - wind rose and power data (for example, using a :py:class:`~.tools - WindRose` object) or data from a previously saved PowerRose object can be - loaded. - """ - - def __init__(self,): - """ - Instantiate a PowerRose object. No explicit arguments required, and an - additional method will need to be called to populate the PowerRose - object with data. - """ - - def load(self, filename): - """ - This method loads data from a previously saved PowerRose pickle file - into a PowerRose object. - - Args: - filename (str): Path and filename of pickle file to load. - """ - - ( - self.name, - self.df_windrose, - self.power_no_wake, - self.power_baseline, - self.power_opt, - self.use_opt, - ) = pickle.load(open(filename, "rb")) - - # Compute energies - self.df_power = pd.DataFrame( - {"wd": self.df_windrose["wd"], "ws": self.df_windrose["ws"]} - ) - self._compute_energy() - - # Compute totals - self._compute_totals() - - def save(self, filename): - """ - This method saves PowerRose data as a pickle file so that it can be - imported into a PowerRose object later. - - Args: - filename (str): Path and filename of pickle file to save. - """ - pickle.dump( - [ - self.name, - self.df_windrose, - self.power_no_wake, - self.power_baseline, - self.power_opt, - self.use_opt, - ], - open(filename, "wb"), - ) - - # def _all_combine(self): - # df_power = self.df_power.copy(deep=True) - # df_yaw = self.df_yaw.copy(deep=True) - # df_turbine_power_no_wake = self.df_turbine_power_no_wake.copy( - # deep=True) - # df_turbine_power_baseline = self.df_turbine_power_baseline.copy( - # deep=True) - # df_turbine_power_opt = self.df_turbine_power_opt.copy(deep=True) - - # # Adjust the column names for uniqunes - # df_yaw.columns = [ - # 'yaw_%d' % c if type(c) is int else c for c in df_yaw.columns - # ] - # df_turbine_power_no_wake.columns = [ - # 'tnw_%d' % c if type(c) is int else c - # for c in df_turbine_power_no_wake.columns - # ] - # df_turbine_power_baseline.columns = [ - # 'tb_%d' % c if type(c) is int else c - # for c in df_turbine_power_baseline.columns - # ] - # df_turbine_power_opt.columns = [ - # 'topt_%d' % c if type(c) is int else c - # for c in df_turbine_power_opt.columns - # ] - - # # Merge - # df_combine = df_power.merge(df_yaw, on=['ws', 'wd']) - # df_combine = df_combine.merge(df_turbine_power_no_wake, - # on=['ws', 'wd']) - # df_combine = df_combine.merge(df_turbine_power_baseline, - # on=['ws', 'wd']) - # df_combine = df_combine.merge(df_turbine_power_opt, on=['ws', 'wd']) - - # return df_combine - - def _norm_frequency(self, df): - print("Norming frequency total of %.2f to 1.0" % df.freq_val.sum()) - df["freq_val"] = df.freq_val / df.freq_val.sum() - return df - - def _compute_energy(self): - self.df_power["energy_no_wake"] = self.df_windrose.freq_val * self.power_no_wake - self.df_power["energy_baseline"] = ( - self.df_windrose.freq_val * self.power_baseline - ) - if self.use_opt: - self.df_power["energy_opt"] = self.df_windrose.freq_val * self.power_opt - - def _compute_totals(self): - df = self.df_power.copy(deep=True) - df = df.sum() - - # Get total annual energy amounts - self.total_no_wake = (8760 / 1e9) * df.energy_no_wake - self.total_baseline = (8760 / 1e9) * df.energy_baseline - if self.use_opt: - self.total_opt = (8760 / 1e9) * df.energy_opt - - # Get wake loss amounts - self.baseline_percent = self.total_baseline / self.total_no_wake - self.baseline_wake_loss = 1 - self.baseline_percent - - if self.use_opt: - self.opt_percent = self.total_opt / self.total_no_wake - self.opt_wake_loss = 1 - self.opt_percent - - # Percent gain - if self.use_opt: - self.percent_gain = ( - self.total_opt - self.total_baseline - ) / self.total_baseline - self.reduction_in_wake_loss = ( - -1 - * (self.opt_wake_loss - self.baseline_wake_loss) - / self.baseline_wake_loss - ) - - def make_power_rose_from_user_data( - self, name, df_windrose, power_no_wake, power_baseline, power_opt=None - ): - """ - This method populates the PowerRose object with a user-specified wind - rose containing wind direction, wind speed, and additional optional - variables, as well as baseline wind farm power, ideal wind farm power - without wake losses, and optionally optimal wind farm power with wake - steering corresponding to each wind condition. - - TODO: Add inputs for turbine-level power and optimal yaw offsets. - - Args: - name (str): The name of the PowerRose object. - df_windrose (pandas.DataFrame): A DataFrame with wind rose - information containing at least - the following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - - power_no_wake (iterable): A list of wind farm power without wake - losses corresponding to the wind conditions in df_windrose (W). - power_baseline (iterable): A list of baseline wind farm power with - wake losses corresponding to the wind conditions in df_windrose - (W). - power_opt (iterable, optional): A list of optimal wind farm power - with wake steering corresponding to the wind conditions in - df_windrose (W). Defaults to None. - """ - self.name = name - if df_windrose is not None: - self.df_windrose = self._norm_frequency(df_windrose) - self.power_no_wake = power_no_wake - self.power_baseline = power_baseline - self.power_opt = power_opt - - # Only use_opt data if provided - if power_opt is None: - self.use_opt = False - else: - self.use_opt = True - - # # Make a single combined frame in case it's useful (Set aside for now) - # self.df_combine = self._all_combine() - - # Compute energies - self.df_power = pd.DataFrame({"wd": df_windrose["wd"], "ws": df_windrose["ws"]}) - self._compute_energy() - - # Compute totals - self._compute_totals() - - def report(self): - """ - This method prints information about annual energy production (AEP) - using the PowerRose object data. The AEP in GWh is listed for ideal - operation without wake losses, baseline operation, and optimal - operation with wake steering, if optimal power data are stored. The - wind farm efficiency (% of ideal energy production) and wake loss - percentages are listed for baseline and optimal operation (if optimal - power is stored), along with the AEP gain from wake steering (again, if - optimal power is stored). The AEP gain from wake steering is also - listed as a percentage of wake losses recovered, if applicable. - """ - if self.use_opt: - print("=============================================") - print("Case %s has results:" % self.name) - print("=============================================") - print("-\tNo-Wake\t\tBaseline\tOpt ") - print("---------------------------------------------") - print( - "AEP (GWh)\t%.1E\t\t%.1E\t\t%.1E" - % (self.total_no_wake, self.total_baseline, self.total_opt) - ) - print( - "%%\t--\t\t%.1f%%\t\t%.1f%%" - % (100.0 * self.baseline_percent, 100.0 * self.opt_percent) - ) - print( - "Wk Loss\t--\t\t%.1f%%\t\t%.1f%%" - % (100.0 * self.baseline_wake_loss, 100.0 * self.opt_wake_loss) - ) - print("AEP Gain --\t\t--\t\t%.1f%%" % (100.0 * self.percent_gain)) - print("Loss Red --\t\t--\t\t%.1f%%" % (100.0 * self.reduction_in_wake_loss)) - else: - print("=============================================") - print("Case %s has results:" % self.name) - print("=============================================") - print("-\tNo-Wake\t\tBaseline ") - print("---------------------------------------------") - print("AEP (GWh)\t%.1E\t\t%.1E" % (self.total_no_wake, self.total_baseline)) - print("%%\t--\t\t%.1f%%" % (100.0 * self.baseline_percent)) - print("Wk Loss\t--\t\t%.1f%%" % (100.0 * self.baseline_wake_loss)) - - def plot_by_direction(self, axarr=None): - """ - This method plots energy production, wind farm efficiency, and energy - gains from wake steering (if applicable) as a function of wind - direction. If axes are not provided, new ones are created. The plots - include: - - 1) The energy production as a function of wind direction for the - baseline and, if applicable, optimal wake steering cases normalized by - the maximum energy production. - 2) The wind farm efficiency (energy production relative to energy - production without wake losses) as a function of wind direction for the - baseline and, if applicable, optimal wake steering cases. - 3) Percent gain in energy production with optimal wake steering as a - function of wind direction. This third plot is only created if optimal - power data are stored in the PowerRose object. - - Args: - axarr (numpy.ndarray, optional): An array of 2 or 3 - :py:class:`matplotlib.axes._subplots.AxesSubplot` axes objects - on which data are plotted. Three axes are rquired if the - PowerRose object contains optimal power data. Default is None. - - Returns: - numpy.ndarray: An array of 2 or 3 - :py:class:`matplotlib.axes._subplots.AxesSubplot` axes objects on - which the data are plotted. - """ - - df = self.df_power.copy(deep=True) - df = df.groupby("wd").sum().reset_index() - - if self.use_opt: - - if axarr is None: - fig, axarr = plt.subplots(3, 1, sharex=True) - - ax = axarr[0] - ax.plot( - df.wd, - df.energy_baseline / np.max(df.energy_opt), - label="Baseline", - color="k", - ) - ax.axhline( - np.mean(df.energy_baseline / np.max(df.energy_opt)), color="r", ls="--" - ) - ax.plot( - df.wd, - df.energy_opt / np.max(df.energy_opt), - label="Optimized", - color="r", - ) - ax.axhline( - np.mean(df.energy_opt / np.max(df.energy_opt)), color="r", ls="--" - ) - ax.set_ylabel("Normalized Energy") - ax.grid(True) - ax.legend() - ax.set_title(self.name) - - ax = axarr[1] - ax.plot( - df.wd, - df.energy_baseline / df.energy_no_wake, - label="Baseline", - color="k", - ) - ax.axhline( - np.mean(df.energy_baseline) / np.mean(df.energy_no_wake), - color="k", - ls="--", - ) - ax.plot( - df.wd, df.energy_opt / df.energy_no_wake, label="Optimized", color="r" - ) - ax.axhline( - np.mean(df.energy_opt) / np.mean(df.energy_no_wake), color="r", ls="--" - ) - ax.set_ylabel("Wind Farm Efficiency") - ax.grid(True) - ax.legend() - - ax = axarr[2] - ax.plot( - df.wd, - 100.0 * (df.energy_opt - df.energy_baseline) / df.energy_baseline, - "r", - ) - ax.axhline( - 100.0 - * (df.energy_opt.mean() - df.energy_baseline.mean()) - / df.energy_baseline.mean(), - df.energy_baseline.mean(), - color="r", - ls="--", - ) - ax.set_ylabel("Percent Gain") - ax.set_xlabel("Wind Direction (deg)") - - return axarr - - else: - - if axarr is None: - fig, axarr = plt.subplots(2, 1, sharex=True) - - ax = axarr[0] - ax.plot( - df.wd, - df.energy_baseline / np.max(df.energy_baseline), - label="Baseline", - color="k", - ) - ax.axhline( - np.mean(df.energy_baseline / np.max(df.energy_baseline)), - color="r", - ls="--", - ) - ax.set_ylabel("Normalized Energy") - ax.grid(True) - ax.legend() - ax.set_title(self.name) - - ax = axarr[1] - ax.plot( - df.wd, - df.energy_baseline / df.energy_no_wake, - label="Baseline", - color="k", - ) - ax.axhline( - np.mean(df.energy_baseline) / np.mean(df.energy_no_wake), - color="k", - ls="--", - ) - ax.set_ylabel("Wind Farm Efficiency") - ax.grid(True) - ax.legend() - - ax.set_xlabel("Wind Direction (deg)") - - return axarr - - # def wake_loss_at_direction(self, wd): - # """ - # Calculate wake losses for a given direction. Plot rose figures - # for Power, Energy, Baseline power, Optimal gain, Total Gain, - # Percent Gain, etc. - - # Args: - # wd (float): Wind direction of interest. - - # Returns: - # tuple: tuple containing: - - # - **fig** (*plt.figure*): Figure handle. - # - **axarr** (*list*): list of axis handles. - # """ - - # df = self.df_power.copy(deep=True) - - # # Choose the nearest direction - # # Find nearest wind direction - # df['dist'] = np.abs(wrap_180(df.wd - wd)) - # wd_select = df[df.dist == df.dist.min()]['wd'].unique()[0] - # print('Nearest wd to %.1f is %.1f' % (wd, wd_select)) - # df = df[df.wd == wd_select] - - # df = df.groupby('ws').sum().reset_index() - - # fig, axarr = plt.subplots(4, 2, sharex=True, figsize=(14, 12)) - - # ax = axarr[0, 0] - # ax.set_title('Power') - # ax.plot(df.ws, df.power_no_wake, 'k', label='No Wake') - # ax.plot(df.ws, df.power_baseline, 'b', label='Baseline') - # ax.plot(df.ws, df.power_opt, 'r', label='Opt') - # ax.set_ylabel('Total') - # ax.grid() - - # ax = axarr[0, 1] - # ax.set_title('Energy') - # ax.plot(df.ws, df.energy_no_wake, 'k', label='No Wake') - # ax.plot(df.ws, df.energy_baseline, 'b', label='Baseline') - # ax.plot(df.ws, df.energy_opt, 'r', label='Opt') - # ax.legend() - # ax.grid() - - # ax = axarr[1, 0] - # ax.plot(df.ws, - # df.power_baseline / df.power_no_wake, - # 'b', - # label='Baseline') - # ax.plot(df.ws, df.power_opt / df.power_no_wake, 'r', label='Opt') - # ax.set_ylabel('Percent') - # ax.grid() - - # ax = axarr[1, 1] - # ax.plot(df.ws, - # df.energy_baseline / df.energy_no_wake, - # 'b', - # label='Baseline') - # ax.plot(df.ws, df.energy_opt / df.energy_no_wake, 'r', label='Opt') - # ax.grid() - - # ax = axarr[2, 0] - # ax.plot(df.ws, (df.power_opt - df.power_baseline), 'r') - # ax.set_ylabel('Total Gain') - # ax.grid() - - # ax = axarr[2, 1] - # ax.plot(df.ws, (df.energy_opt - df.energy_baseline), 'r') - # ax.grid() - - # ax = axarr[3, 0] - # ax.plot(df.ws, (df.power_opt - df.power_baseline) / df.power_baseline, - # 'r') - # ax.set_ylabel('Percent Gain') - # ax.grid() - # ax.set_xlabel('Wind Speed (m/s)') - - # ax = axarr[3, 1] - # ax.plot(df.ws, - # (df.energy_opt - df.energy_baseline) / df.energy_baseline, 'r') - # ax.grid() - # ax.set_xlabel('Wind Speed (m/s)') - - # return fig, axarr diff --git a/floris/tools/rews.py b/floris/tools/rews.py deleted file mode 100644 index 175aabb3b..000000000 --- a/floris/tools/rews.py +++ /dev/null @@ -1,124 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import numpy as np - -from ..utilities import wrap_180, wrap_360 - - -def log_law_interpolate(z_test, z_ref, v_ref, roughness=0.03): - """ - Interpolate wind speed assuming a log-law profile. - - Args: - z_test (float): height of interest for wind speed estimate. - z_ref (float): reference height. - v_ref (float): reference velocity. - roughness (float, optional): Effective roughness length. - Defaults to 0.03. - - Returns: - v_test (np.float): interpolated wind speed at z_test. - """ - return v_ref * np.log(z_test / roughness) / np.log(z_ref / roughness) - - -def determine_rews_weights(R, HH, heights_in): - """ - Weighting for rotor-equivalent wind speed (REWS). - - Args: - R (float): rotor diameter. - HH (float): hub height. - heights_in (iterable): heights of interest. - - Returns: - weights_return (list): list of weighting values for REWS. - """ - # Remove any heights not in range of the rotor - heights = [h for h in heights_in if ((h >= HH - R) and (h <= HH + R))] - num_heights = len(heights) - - # Determine the zone interfaces - zone_boundaries = np.zeros(num_heights + 1) - zone_boundaries[0] = HH - R - zone_boundaries[-1] = HH + R - for i in range(1, num_heights): - zone_boundaries[i] = (heights[i] - heights[i - 1]) / 2.0 + heights[i - 1] - zone_interfaces = zone_boundaries[1:-1] - - # Next find the central angles for each interace - h = zone_interfaces - HH - alpha = np.arcsin(h / R) - C = np.pi - 2 * alpha - A = ((R ** 2) / 2) * (C - np.sin(C)) - A = [np.pi * R ** 2] + list(A) - for i in range(num_heights - 1): - A[i] = A[i] - A[i + 1] - weights = A - - # normalize - weights = weights / np.sum(weights) - - # Now re-pad weights to include heights that were initally cropped - weight_dict = dict(zip(heights, weights)) - weights_return = [weight_dict.get(h, 0.0) for h in heights_in] - - return weights_return - - -def rews_from_df(df, columns_in, weights, rews_name, circular=False): - """ - Estimate the rotor-equivalent wind speed (REWS) from wind speed. - - Args: - df (pd.DataFrame): DataFrame containing flow information - columns_in (list): columns to include estimate of REWS. - weights (iterable): weighting values for REWS. - rews_name (str): column name for REWS output. - circular (bool, optional): flag to consider REWS azimuthally. - Defaults to False. - - Returns: - df (pd.DataFrame): updated dataframe with REWS column. - """ - # Ensure numpy array - weights = np.array(weights) - - # Get the data - data_matrix = df[columns_in].values - - if not circular: - df[rews_name] = compute_rews(data_matrix, weights) - else: - cos_vals = compute_rews(np.cos(np.deg2rad(data_matrix)), weights) - sin_vals = compute_rews(np.sin(np.deg2rad(data_matrix)), weights) - df[rews_name] = wrap_360(np.rad2deg(np.arctan2(sin_vals, cos_vals))) - - return df - - -def compute_rews(data_matrix, weights): - """ - Calculation method for REWS from wind speed and weighting values. - - Args: - data_matrix (np.array): wind speed data - weights (np.array): weighting values for REWS. - - Returns: - REWS (float): rotor-equivalent wind speed. - """ - return np.sum(data_matrix * weights, axis=1) diff --git a/floris/tools/uncertainty_interface.py b/floris/tools/uncertainty_interface.py deleted file mode 100644 index b871bd86d..000000000 --- a/floris/tools/uncertainty_interface.py +++ /dev/null @@ -1,650 +0,0 @@ -# Copyright 2021 NREL -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -import copy - -import numpy as np -from scipy.stats import norm - -from floris.logging_manager import LoggingManager -from floris.tools import FlorisInterface -from floris.utilities import wrap_360 - - -class UncertaintyInterface(LoggingManager): - def __init__( - self, - configuration, - unc_options=None, - unc_pmfs=None, - fix_yaw_in_relative_frame=False, - ): - """A wrapper around the nominal floris_interface class that adds - uncertainty to the floris evaluations. One can specify a probability - distribution function (pdf) for the ambient wind direction. Unless - the exact pdf is specified manually using the option 'unc_pmfs', a - Gaussian probability distribution function will be assumed. - - Args: - configuration (:py:obj:`dict` or FlorisInterface object): The Floris - object, configuration dictarionary, or YAML file. The - configuration should have the following inputs specified. - - **flow_field**: See `floris.simulation.flow_field.FlowField` for more details. - - **farm**: See `floris.simulation.farm.Farm` for more details. - - **turbine**: See `floris.simulation.turbine.Turbine` for more details. - - **wake**: See `floris.simulation.wake.WakeManager` for more details. - - **logging**: See `floris.simulation.floris.Floris` for more details. - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction deviations. - This argument is only used when **unc_pmfs** is None and contain - the following key-value pairs: - - **std_wd** (*float*): A float containing the standard - deviation of the wind direction deviations from the - original wind direction. - - **pmf_res** (*float*): A float containing the resolution in - degrees of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): A float containing the cumulative - distribution function value at which the tails of the - PMFs are truncated. - Defaults to None. Initializes to {'std_wd': 4.95, 'pmf_res': 1.0, - 'pdf_cutoff': 0.995}. - unc_pmfs (dictionary, optional): A dictionary containing optional - probability mass functions describing the distribution of wind - direction deviations. Contains the following key-value pairs: - - **wd_unc** (*np.array*): Wind direction deviations from the - original wind direction. - - **wd_unc_pmf** (*np.array*): Probability of each wind - direction deviation in **wd_unc** occuring. - Defaults to None, in which case default PMFs are calculated - using values provided in **unc_options**. - fix_yaw_in_relative_frame (bool, optional): When set to True, the - relative yaw angle of all turbines is fixed and always has the - nominal value (e.g., 0 deg) when evaluating uncertainty in the - wind direction. Evaluating wind direction uncertainty like this - will essentially come down to a Gaussian smoothing of FLORIS - solutions over the wind directions. This calculation can therefore - be really fast, since it does not require additional calculations - compared to a non-uncertainty FLORIS evaluation. - When fix_yaw_in_relative_frame=False, the yaw angles are fixed in - the absolute (compass) reference frame, meaning that for each - probablistic wind direction evaluation, our probablistic (relative) - yaw angle evaluated goes into the opposite direction. For example, - a probablistic wind direction 3 deg above the nominal value means - that we evaluate it with a relative yaw angle that is 3 deg below - its nominal value. This requires additional computations compared - to a non- uncertainty evaluation. - Typically, fix_yaw_in_relative_frame=True is used when comparing - FLORIS to historical data, in which a single measurement usually - represents a 10-minute average, and thus is often a mix of various - true wind directions. The inherent assumption then is that the turbine - perfectly tracks the wind direction changes within those 10 minutes. - Then, fix_yaw_in_relative_frame=False is typically used for robust - yaw angle optimization, in which we take into account that the turbine - often does not perfectly know the true wind direction, and that a - turbine often does not perfectly achieve its desired yaw angle offset. - Defaults to fix_yaw_in_relative_frame=False. - """ - - if (unc_options is None) & (unc_pmfs is None): - # Default options: - unc_options = { - "std_wd": 3.0, # Standard deviation for inflow wind direction (deg) - "pmf_res": 1.0, # Resolution over which to calculate angles (deg) - "pdf_cutoff": 0.995, # Probability density function cut-off (-) - } - - # Initialize floris object and uncertainty pdfs - if isinstance(configuration, FlorisInterface): - self.fi = configuration - else: - self.fi = FlorisInterface(configuration) - - self.reinitialize_uncertainty( - unc_options=unc_options, - unc_pmfs=unc_pmfs, - fix_yaw_in_relative_frame=fix_yaw_in_relative_frame, - ) - - # Add a _no_wake switch to keep track of calculate_wake/calculate_no_wake - self._no_wake = False - - # Private methods - - def _generate_pdfs_from_dict(self): - """Generates the uncertainty probability distributions from a - dictionary only describing the wd_std and yaw_std, and discretization - resolution. - """ - - wd_unc = np.zeros(1) - wd_unc_pmf = np.ones(1) - - # create normally distributed wd and yaw uncertaitny pmfs if appropriate - unc_options = self.unc_options - if unc_options["std_wd"] > 0: - wd_bnd = int( - np.ceil( - norm.ppf(unc_options["pdf_cutoff"], scale=unc_options["std_wd"]) - / unc_options["pmf_res"] - ) - ) - bound = wd_bnd * unc_options["pmf_res"] - wd_unc = np.linspace(-1 * bound, bound, 2 * wd_bnd + 1) - wd_unc_pmf = norm.pdf(wd_unc, scale=unc_options["std_wd"]) - wd_unc_pmf /= np.sum(wd_unc_pmf) # normalize so sum = 1.0 - - unc_pmfs = { - "wd_unc": wd_unc, - "wd_unc_pmf": wd_unc_pmf, - } - - # Save to self - self.unc_pmfs = unc_pmfs - - def _expand_wind_directions_and_yaw_angles(self): - """Expands the nominal wind directions and yaw angles to the full set - of conditions that need to be evaluated for the probablistic - calculation of the floris solutions. This produces the np.NDArrays - "wd_array_probablistic" and "yaw_angles_probablistic", with shapes: - ( - num_wind_direction_pdf_points_to_evaluate, - num_nominal_wind_directions, - ) - and - ( - num_wind_direction_pdf_points_to_evaluate, - num_nominal_wind_directions, - num_nominal_wind_speeds, - num_turbines - ), - respectively. - """ - - # First initialize unc_pmfs from self - unc_pmfs = self.unc_pmfs - - # We first save the nominal settings, since we will be overwriting - # the floris wind conditions and yaw angles to include all - # probablistic conditions. - wd_array_nominal = self.fi.floris.flow_field.wind_directions - yaw_angles_nominal = self.fi.floris.farm.yaw_angles - - # Expand wind direction and yaw angle array into the direction - # of uncertainty over the ambient wind direction. - wd_array_probablistic = np.vstack([ - np.expand_dims(wd_array_nominal, axis=0) + dy - for dy in unc_pmfs["wd_unc"] - ]) - - if self.fix_yaw_in_relative_frame: - # The relative yaw angle is fixed and always has the nominal - # value (e.g., 0 deg) when evaluating uncertainty. Evaluating - # wind direction uncertainty like this would essentially come - # down to a Gaussian smoothing of FLORIS solutions over the - # wind directions. This can also be really fast, since it would - # not require any additional calculations compared to the - # non-uncertainty FLORIS evaluation. - yaw_angles_probablistic = np.vstack([ - np.expand_dims(yaw_angles_nominal, axis=0) - for _ in unc_pmfs["wd_unc"] - ]) - else: - # Fix yaw angles in the absolute (compass) reference frame, - # meaning that for each probablistic wind direction evaluation, - # our probablistic (relative) yaw angle evaluated goes into - # the opposite direction. For example, a probablistic wind - # direction 3 deg above the nominal value means that we evaluate - # it with a relative yaw angle that is 3 deg below its nominal - # value. - yaw_angles_probablistic = np.vstack([ - np.expand_dims(yaw_angles_nominal, axis=0) - dy - for dy in unc_pmfs["wd_unc"] - ]) - - self.wd_array_probablistic = wd_array_probablistic - self.yaw_angles_probablistic = yaw_angles_probablistic - - def _reassign_yaw_angles(self, yaw_angles=None): - # Overwrite the yaw angles in the FlorisInterface object - if yaw_angles is not None: - self.fi.floris.farm.yaw_angles = yaw_angles - - # Public methods - - def copy(self): - """Create an independent copy of the current UncertaintyInterface - object""" - fi_unc_copy = copy.deepcopy(self) - fi_unc_copy.fi = self.fi.copy() - return fi_unc_copy - - def reinitialize_uncertainty( - self, - unc_options=None, - unc_pmfs=None, - fix_yaw_in_relative_frame=None - ): - """Reinitialize the wind direction and yaw angle probability - distributions used in evaluating FLORIS. Must either specify - 'unc_options', in which case distributions are calculated assuming - a Gaussian distribution, or `unc_pmfs` must be specified directly - assigning the probability distribution functions. - - Args: - unc_options (dictionary, optional): A dictionary containing values - used to create normally-distributed, zero-mean probability mass - functions describing the distribution of wind direction and yaw - position deviations when wind direction and/or yaw position - uncertainty is included. This argument is only used when - **unc_pmfs** is None and contains the following key-value pairs: - - - **std_wd** (*float*): A float containing the standard - deviation of the wind direction deviations from the - original wind direction. - - **std_yaw** (*float*): A float containing the standard - deviation of the yaw angle deviations from the original yaw - angles. - - **pmf_res** (*float*): A float containing the resolution in - degrees of the wind direction and yaw angle PMFs. - - **pdf_cutoff** (*float*): A float containing the cumulative - distribution function value at which the tails of the - PMFs are truncated. - - Defaults to None. - - unc_pmfs (dictionary, optional): A dictionary containing optional - probability mass functions describing the distribution of wind - direction and yaw position deviations when wind direction and/or - yaw position uncertainty is included in the power calculations. - Contains the following key-value pairs: - - - **wd_unc** (*np.array*): Wind direction deviations from the - original wind direction. - - **wd_unc_pmf** (*np.array*): Probability of each wind - direction deviation in **wd_unc** occuring. - - **yaw_unc** (*np.array*): Yaw angle deviations from the - original yaw angles. - - **yaw_unc_pmf** (*np.array*): Probability of each yaw angle - deviation in **yaw_unc** occuring. - - Defaults to None. - - fix_yaw_in_relative_frame (bool, optional): When set to True, the - relative yaw angle of all turbines is fixed and always has the - nominal value (e.g., 0 deg) when evaluating uncertainty in the - wind direction. Evaluating wind direction uncertainty like this - will essentially come down to a Gaussian smoothing of FLORIS - solutions over the wind directions. This calculation can therefore - be really fast, since it does not require additional calculations - compared to a non-uncertainty FLORIS evaluation. - When fix_yaw_in_relative_frame=False, the yaw angles are fixed in - the absolute (compass) reference frame, meaning that for each - probablistic wind direction evaluation, our probablistic (relative) - yaw angle evaluated goes into the opposite direction. For example, - a probablistic wind direction 3 deg above the nominal value means - that we evaluate it with a relative yaw angle that is 3 deg below - its nominal value. This requires additional computations compared - to a non- uncertainty evaluation. - Typically, fix_yaw_in_relative_frame=True is used when comparing - FLORIS to historical data, in which a single measurement usually - represents a 10-minute average, and thus is often a mix of various - true wind directions. The inherent assumption then is that the turbine - perfectly tracks the wind direction changes within those 10 minutes. - Then, fix_yaw_in_relative_frame=False is typically used for robust - yaw angle optimization, in which we take into account that the turbine - often does not perfectly know the true wind direction, and that a - turbine often does not perfectly achieve its desired yaw angle offset. - Defaults to fix_yaw_in_relative_frame=False. - - """ - - # Check inputs - if (unc_options is not None) and (unc_pmfs is not None): - self.logger.error("Must specify either 'unc_options' or 'unc_pmfs', not both.") - - # Assign uncertainty probability distributions - if unc_options is not None: - self.unc_options = unc_options - self._generate_pdfs_from_dict() - - if unc_pmfs is not None: - self.unc_pmfs = unc_pmfs - - if fix_yaw_in_relative_frame is not None: - self.fix_yaw_in_relative_frame = bool(fix_yaw_in_relative_frame) - - def reinitialize( - self, - wind_speeds=None, - wind_directions=None, - wind_shear=None, - wind_veer=None, - reference_wind_height=None, - turbulence_intensity=None, - air_density=None, - layout_x=None, - layout_y=None, - turbine_type=None, - solver_settings=None, - ): - """Pass to the FlorisInterface reinitialize function. To allow users - to directly replace a FlorisInterface object with this - UncertaintyInterface object, this function is required.""" - - # Just passes arguments to the floris object - self.fi.reinitialize( - wind_speeds=wind_speeds, - wind_directions=wind_directions, - wind_shear=wind_shear, - wind_veer=wind_veer, - reference_wind_height=reference_wind_height, - turbulence_intensity=turbulence_intensity, - air_density=air_density, - layout_x=layout_x, - layout_y=layout_y, - turbine_type=turbine_type, - solver_settings=solver_settings, - ) - - def calculate_wake(self, yaw_angles=None): - """Replaces the 'calculate_wake' function in the FlorisInterface - object. Fundamentally, this function only overwrites the nominal - yaw angles in the FlorisInterface object. The actual wake calculations - are performed once 'get_turbine_powers' or 'get_farm_powers' is - called. However, to allow users to directly replace a FlorisInterface - object with this UncertaintyInterface object, this function is - required. - - Args: - yaw_angles: NDArrayFloat | list[float] | None = None, - """ - self._reassign_yaw_angles(yaw_angles) - self._no_wake = False - - def calculate_no_wake(self, yaw_angles=None): - """Replaces the 'calculate_no_wake' function in the FlorisInterface - object. Fundamentally, this function only overwrites the nominal - yaw angles in the FlorisInterface object. The actual wake calculations - are performed once 'get_turbine_powers' or 'get_farm_powers' is - called. However, to allow users to directly replace a FlorisInterface - object with this UncertaintyInterface object, this function is - required. - - Args: - yaw_angles: NDArrayFloat | list[float] | None = None, - """ - self._reassign_yaw_angles(yaw_angles) - self._no_wake = True - - def get_turbine_powers(self): - """Calculates the probability-weighted power production of each - turbine in the wind farm. - - Returns: - NDArrayFloat: Power production of all turbines in the wind farm. - This array has the shape (num_wind_directions, num_wind_speeds, - num_turbines). - """ - - # To include uncertainty, we expand the dimensionality - # of the problem along the wind direction pdf and/or yaw angle - # pdf. We make use of the vectorization of FLORIS to - # evaluate all conditions in a single call, rather than in - # loops. Therefore, the effective number of wind conditions and - # yaw angle combinations we evaluate expands. - unc_pmfs = self.unc_pmfs - self._expand_wind_directions_and_yaw_angles() - - # Get dimensions of nominal conditions - wd_array_nominal = self.fi.floris.flow_field.wind_directions - num_wd = self.fi.floris.flow_field.n_wind_directions - num_ws = self.fi.floris.flow_field.n_wind_speeds - num_wd_unc = len(unc_pmfs["wd_unc"]) - num_turbines = self.fi.floris.farm.n_turbines - - # Format into conventional floris format by reshaping - wd_array_probablistic = np.reshape(self.wd_array_probablistic, -1) - yaw_angles_probablistic = np.reshape( - self.yaw_angles_probablistic, - (-1, num_ws, num_turbines) - ) - - # Wrap wind direction array around 360 deg - wd_array_probablistic = wrap_360(wd_array_probablistic) - - # Find minimal set of solutions to evaluate - wd_exp = np.tile(wd_array_probablistic, (1, num_ws, 1)).T - _, id_unq, id_unq_rev = np.unique( - np.append(yaw_angles_probablistic, wd_exp, axis=2), - axis=0, - return_index=True, - return_inverse=True - ) - wd_array_probablistic_min = wd_array_probablistic[id_unq] - yaw_angles_probablistic_min = yaw_angles_probablistic[id_unq, :, :] - - # Evaluate floris for minimal probablistic set - self.fi.reinitialize(wind_directions=wd_array_probablistic_min) - if self._no_wake: - self.fi.calculate_no_wake(yaw_angles=yaw_angles_probablistic_min) - else: - self.fi.calculate_wake(yaw_angles=yaw_angles_probablistic_min) - - # Retrieve all power productions using the nominal call - turbine_powers = self.fi.get_turbine_powers() - self.fi.reinitialize(wind_directions=wd_array_nominal) - - # Reshape solutions back to full set - power_probablistic = turbine_powers[id_unq_rev, :] - power_probablistic = np.reshape( - power_probablistic, - (num_wd_unc, num_wd, num_ws, num_turbines) - ) - - # Calculate probability weighing terms - wd_weighing = ( - (np.expand_dims(unc_pmfs["wd_unc_pmf"], axis=(1, 2, 3))) - .repeat(num_wd, 1) - .repeat(num_ws, 2) - .repeat(num_turbines, 3) - ) - - # Now apply probability distribution weighing to get turbine powers - return np.sum(wd_weighing * power_probablistic, axis=0) - - def get_farm_power(self, turbine_weights=None): - """Calculates the probability-weighted power production of the - collective of all turbines in the farm, for each wind direction - and wind speed specified. - - Args: - turbine_weights (NDArrayFloat | list[float] | None, optional): - weighing terms that allow the user to emphasize power at - particular turbines and/or completely ignore the power - from other turbines. This is useful when, for example, you are - modeling multiple wind farms in a single floris object. If you - only want to calculate the power production for one of those - farms and include the wake effects of the neighboring farms, - you can set the turbine_weights for the neighboring farms' - turbines to 0.0. The array of turbine powers from floris - is multiplied with this array in the calculation of the - objective function. If None, this is an array with all values - 1.0 and with shape equal to (n_wind_directions, n_wind_speeds, - n_turbines). Defaults to None. - - Returns: - NDArrayFloat: Expectation of power production of the wind farm. - This array has the shape (num_wind_directions, num_wind_speeds). - """ - - if turbine_weights is None: - # Default to equal weighing of all turbines when turbine_weights is None - turbine_weights = np.ones( - ( - self.floris.flow_field.n_wind_directions, - self.floris.flow_field.n_wind_speeds, - self.floris.farm.n_turbines - ) - ) - elif len(np.shape(turbine_weights)) == 1: - # Deal with situation when 1D array is provided - turbine_weights = np.tile( - turbine_weights, - ( - self.floris.flow_field.n_wind_directions, - self.floris.flow_field.n_wind_speeds, - 1 - ) - ) - - # Calculate all turbine powers and apply weights - turbine_powers = self.get_turbine_powers() - turbine_powers = np.multiply(turbine_weights, turbine_powers) - - return np.sum(turbine_powers, axis=2) - - def get_farm_AEP( - self, - freq, - cut_in_wind_speed=0.001, - cut_out_wind_speed=None, - yaw_angles=None, - turbine_weights=None, - no_wake=False, - ) -> float: - """ - Estimate annual energy production (AEP) for distributions of wind speed, wind - direction, frequency of occurrence, and yaw offset. - - Args: - freq (NDArrayFloat): NumPy array with shape (n_wind_directions, - n_wind_speeds) with the frequencies of each wind direction and - wind speed combination. These frequencies should typically sum - up to 1.0 and are used to weigh the wind farm power for every - condition in calculating the wind farm's AEP. - cut_in_wind_speed (float, optional): Wind speed in m/s below which - any calculations are ignored and the wind farm is known to - produce 0.0 W of power. Note that to prevent problems with the - wake models at negative / zero wind speeds, this variable must - always have a positive value. Defaults to 0.001 [m/s]. - cut_out_wind_speed (float, optional): Wind speed above which the - wind farm is known to produce 0.0 W of power. If None is - specified, will assume that the wind farm does not cut out - at high wind speeds. Defaults to None. - yaw_angles (NDArrayFloat | list[float] | None, optional): - The relative turbine yaw angles in degrees. If None is - specified, will assume that the turbine yaw angles are all - zero degrees for all conditions. Defaults to None. - turbine_weights (NDArrayFloat | list[float] | None, optional): - weighing terms that allow the user to emphasize power at - particular turbines and/or completely ignore the power - from other turbines. This is useful when, for example, you are - modeling multiple wind farms in a single floris object. If you - only want to calculate the power production for one of those - farms and include the wake effects of the neighboring farms, - you can set the turbine_weights for the neighboring farms' - turbines to 0.0. The array of turbine powers from floris - is multiplied with this array in the calculation of the - objective function. If None, this is an array with all values - 1.0 and with shape equal to (n_wind_directions, n_wind_speeds, - n_turbines). Defaults to None. - no_wake: (bool, optional): When *True* updates the turbine - quantities without calculating the wake or adding the wake to - the flow field. This can be useful when quantifying the loss - in AEP due to wakes. Defaults to *False*. - - Returns: - float: - The Annual Energy Production (AEP) for the wind farm in - watt-hours. - """ - - # Verify dimensions of the variable "freq" - if not ( - (np.shape(freq)[0] == self.floris.flow_field.n_wind_directions) - & (np.shape(freq)[1] == self.floris.flow_field.n_wind_speeds) - & (len(np.shape(freq)) == 2) - ): - raise UserWarning( - "'freq' should be a two-dimensional array with dimensions " - "(n_wind_directions, n_wind_speeds)." - ) - - # Check if frequency vector sums to 1.0. If not, raise a warning - if np.abs(np.sum(freq) - 1.0) > 0.001: - self.logger.warning( - "WARNING: The frequency array provided to get_farm_AEP() does not sum to 1.0. " - ) - - # Copy the full wind speed array from the floris object and initialize - # the the farm_power variable as an empty array. - wind_speeds = np.array(self.fi.floris.flow_field.wind_speeds, copy=True) - farm_power = np.zeros((self.fi.floris.flow_field.n_wind_directions, len(wind_speeds))) - - # Determine which wind speeds we must evaluate in floris - conditions_to_evaluate = wind_speeds >= cut_in_wind_speed - if cut_out_wind_speed is not None: - conditions_to_evaluate = conditions_to_evaluate & (wind_speeds < cut_out_wind_speed) - - # Evaluate the conditions in floris - if np.any(conditions_to_evaluate): - wind_speeds_subset = wind_speeds[conditions_to_evaluate] - yaw_angles_subset = None - if yaw_angles is not None: - yaw_angles_subset = yaw_angles[:, conditions_to_evaluate] - self.reinitialize(wind_speeds=wind_speeds_subset) - if no_wake: - self.calculate_no_wake(yaw_angles=yaw_angles_subset) - else: - self.calculate_wake(yaw_angles=yaw_angles_subset) - farm_power[:, conditions_to_evaluate] = ( - self.get_farm_power(turbine_weights=turbine_weights) - ) - - # Finally, calculate AEP in GWh - aep = np.sum(np.multiply(freq, farm_power) * 365 * 24) - - # Reset the FLORIS object to the full wind speed array - self.reinitialize(wind_speeds=wind_speeds) - - return aep - - def assign_hub_height_to_ref_height(self): - return self.fi.assign_hub_height_to_ref_height() - - def get_turbine_layout(self, z=False): - return self.fi.get_turbine_layout(z=z) - - def get_turbine_Cts(self): - return self.fi.get_turbine_Cts() - - def get_turbine_ais(self): - return self.fi.get_turbine_ais() - - def get_turbine_average_velocities(self): - return self.fi.get_turbine_average_velocities() - - # Define getter functions that just pass information from FlorisInterface - @property - def floris(self): - return self.fi.floris - - @property - def layout_x(self): - return self.fi.layout_x - - @property - def layout_y(self): - return self.fi.layout_y diff --git a/floris/tools/wind_rose.py b/floris/tools/wind_rose.py deleted file mode 100644 index 6725af485..000000000 --- a/floris/tools/wind_rose.py +++ /dev/null @@ -1,1626 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -# TODO -# 1: reorganize into private and public methods -# 2: Include smoothing? - -import os -import pickle - -import dateutil -import matplotlib.cm as cm -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -from scipy.interpolate import LinearNDInterpolator, NearestNDInterpolator - -import floris.utilities as geo - - -# from pyproj import Proj - - - -class WindRose: - """ - The WindRose class is used to organize information about the frequency of - occurance of different combinations of wind speed and wind direction (and - other optimal wind variables). A WindRose object can be used to help - calculate annual energy production (AEP) when combined with Floris power - calculations for different wind conditions. Several methods exist for - populating a WindRose object with wind data. WindRose also contains methods - for visualizing wind roses. - - References: - .. bibliography:: /references.bib - :style: unsrt - :filter: docname in docnames - :keyprefix: wr- - """ - - def __init__(self,): - """ - Instantiate a WindRose object and set some initial parameter values. - No explicit arguments required, and an additional method will need to - be called to populate the WindRose object with data. - """ - # Initialize some varibles - self.num_wd = 0 - self.num_ws = 0 - self.wd_step = 1.0 - self.ws_step = 5.0 - self.wd = np.array([]) - self.ws = np.array([]) - self.df = pd.DataFrame() - - def save(self, filename): - """ - This method saves the WindRose data as a pickle file so that it can be - imported into a WindRose object later. - - Args: - filename (str): Path and filename of pickle file to save. - """ - pickle.dump( - [ - self.num_wd, - self.num_ws, - self.wd_step, - self.ws_step, - self.wd, - self.ws, - self.df, - ], - open(filename, "wb"), - ) - - def load(self, filename): - """ - This method loads data from a previously saved WindRose pickle file - into a WindRose object. - - Args: - filename (str): Path and filename of pickle file to load. - - Returns: - int, int, float, float, np.array, np.array, pandas.DataFrame: - - - Number of wind direction bins. - - Number of wind speed bins. - - Wind direction bin size (deg). - - Wind speed bin size (m/s). - - List of wind direction bin center values (deg). - - List of wind speed bin center values (m/s). - - DataFrame containing at least the following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of - the wind conditions in the other columns. - """ - ( - self.num_wd, - self.num_ws, - self.wd_step, - self.ws_step, - self.wd, - self.ws, - self.df, - ) = pickle.load(open(filename, "rb")) - - return self.df - - def resample_wind_speed(self, df, ws=np.arange(0, 26, 1.0)): - """ - This method resamples the wind speed bins using the specified wind - speed bin center values. The frequency values are adjusted accordingly. - - Args: - df (pandas.DataFrame): Wind rose DataFrame containing at least the - following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - - ws (np.array, optional): List of new wind speed center bins (m/s). - Defaults to np.arange(0, 26, 1.). - - Returns: - pandas.DataFrame: Wind rose DataFrame with the resampled wind speed - bins and frequencies containing at least the following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - New wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - new wind conditions in the other columns. - """ - # Make a copy of incoming dataframe - df = df.copy(deep=True) - - # Get the wind step - ws_step = ws[1] - ws[0] - - # Ws - ws_edges = ws - ws_step / 2.0 - ws_edges = np.append(ws_edges, np.array(ws[-1] + ws_step / 2.0)) - - # Cut wind speed onto bins - df["ws"] = pd.cut(df.ws, ws_edges, labels=ws) - - # Regroup - df = df.groupby([c for c in df.columns if c != "freq_val"], observed=False).sum() - - # Fill nans - df = df.fillna(0) - - # Reset the index - df = df.reset_index() - - # Set to float - for c in [c for c in df.columns if c != "freq_val"]: - df[c] = df[c].astype(float) - df[c] = df[c].astype(float) - - return df - - def internal_resample_wind_speed(self, ws=np.arange(0, 26, 1.0)): - """ - Internal method for resampling wind speed into desired bins. The - frequency values are adjusted accordingly. Modifies data within - WindRose object without explicit return. - - TODO: make a private method - - Args: - ws (np.array, optional): Vector of wind speed bin centers for - the wind rose (m/s). Defaults to np.arange(0, 26, 1.). - """ - # Update ws and wd binning - self.ws = ws - self.num_ws = len(ws) - self.ws_step = ws[1] - ws[0] - - # Update internal data frame - self.df = self.resample_wind_speed(self.df, ws) - - def resample_wind_direction(self, df, wd=np.arange(0, 360, 5.0)): - """ - This method resamples the wind direction bins using the specified wind - direction bin center values. The frequency values are adjusted - accordingly. - - Args: - df (pandas.DataFrame): Wind rose DataFrame containing at least the - following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - - wd (np.array, optional): List of new wind direction center bins - (deg). Defaults to np.arange(0, 360, 5.). - - Returns: - pandas.DataFrame: Wind rose DataFrame with the resampled wind - direction bins and frequencies containing at least the following - columns: - - - **wd** (*float*) - New wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - new wind conditions in the other columns. - """ - # Make a copy of incoming dataframe - df = df.copy(deep=True) - - # Get the wind step - wd_step = wd[1] - wd[0] - - # Get bin edges - wd_edges = wd - wd_step / 2.0 - wd_edges = np.append(wd_edges, np.array(wd[-1] + wd_step / 2.0)) - - # Get the overhangs - negative_overhang = wd_edges[0] - positive_overhang = wd_edges[-1] - 360.0 - - # Need potentially to wrap high angle direction to negative for correct - # binning - df["wd"] = geo.wrap_360(df.wd) - if negative_overhang < 0: - print("Correcting negative Overhang:%.1f" % negative_overhang) - df["wd"] = np.where( - df.wd.values >= 360.0 + negative_overhang, - df.wd.values - 360.0, - df.wd.values, - ) - - # Check on other side - if positive_overhang > 0: - print("Correcting positive Overhang:%.1f" % positive_overhang) - df["wd"] = np.where( - df.wd.values <= positive_overhang, df.wd.values + 360.0, df.wd.values - ) - - # Cut into bins - df["wd"] = pd.cut(df.wd, wd_edges, labels=wd) - - # Regroup - df = df.groupby([c for c in df.columns if c != "freq_val"], observed=False).sum() - - # Fill nans - df = df.fillna(0) - - # Reset the index - df = df.reset_index() - - # Set to float Re-wrap - for c in [c for c in df.columns if c != "freq_val"]: - df[c] = df[c].astype(float) - df[c] = df[c].astype(float) - df["wd"] = geo.wrap_360(df.wd) - - return df - - def internal_resample_wind_direction(self, wd=np.arange(0, 360, 5.0)): - """ - Internal method for resampling wind direction into desired bins. The - frequency values are adjusted accordingly. Modifies data within - WindRose object without explicit return. - - TODO: make a private method - - Args: - wd (np.array, optional): Vector of wind direction bin centers for - the wind rose (deg). Defaults to np.arange(0, 360, 5.). - """ - # Update ws and wd binning - self.wd = wd - self.num_wd = len(wd) - self.wd_step = wd[1] - wd[0] - - # Update internal data frame - self.df = self.resample_wind_direction(self.df, wd) - - def resample_column(self, df, col, bins): - """ - This method resamples the specified wind parameter column using the - specified bin center values. The frequency values are adjusted - accordingly. - - Args: - df (pandas.DataFrame): Wind rose DataFrame containing at least the - following columns as well as *col*: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - - col (str): The name of the column to resample. - bins (np.array): List of new bin center values for the specified - column. - - Returns: - pandas.DataFrame: Wind rose DataFrame with the resampled wind - parameter bins and frequencies containing at least the following - columns as well as *col*: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - new wind conditions in the other columns. - """ - # Make a copy of incoming dataframe - df = df.copy(deep=True) - - # Cut into bins, make first and last bins extend to -/+ infinity - var_edges = np.append(0.5 * (bins[1:] + bins[:-1]), np.inf) - var_edges = np.append(-np.inf, var_edges) - df[col] = pd.cut(df[col], var_edges, labels=bins) - - # Regroup - df = df.groupby([c for c in df.columns if c != "freq_val"], observed=False).sum() - - # Fill nans - df = df.fillna(0) - - # Reset the index - df = df.reset_index() - - # Set to float - for c in [c for c in df.columns if c != "freq_val"]: - df[c] = df[c].astype(float) - - return df - - def internal_resample_column(self, col, bins): - """ - Internal method for resampling column into desired bins. The frequency - values are adjusted accordingly. Modifies data within WindRose object - without explicit return. - - TODO: make a private method - - Args: - col (str): Name of column to resample. - bins (np.array): Vector of bins for the WindRose column. - """ - # Update internal data frame - self.df = self.resample_column(self.df, col, bins) - - def resample_average_ws_by_wd(self, df): - """ - This method calculates the mean wind speed for each wind direction bin - and resamples the wind rose, resulting in a single mean wind speed per - wind direction bin. The frequency values are adjusted accordingly. - - Args: - df (pandas.DataFrame): Wind rose DataFrame containing at least the - following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - - Returns: - pandas.DataFrame: Wind rose DataFrame with the resampled wind speed - bins and frequencies containing at least the following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - The average wind speed for each wind - direction bin (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - new wind conditions in the other columns. - """ - # Make a copy of incoming dataframe - df = df.copy(deep=True) - - ws_avg = [] - - for val in df.wd.unique(): - ws_avg.append( - np.array( - df.loc[df["wd"] == val]["ws"] * df.loc[df["wd"] == val]["freq_val"] - ).sum() - / df.loc[df["wd"] == val]["freq_val"].sum() - ) - - # Regroup - df = df.groupby("wd").sum() - - df["ws"] = ws_avg - - # Reset the index - df = df.reset_index() - - # Set to float - df["ws"] = df.ws.astype(float) - df["wd"] = df.wd.astype(float) - - return df - - def internal_resample_average_ws_by_wd(self, wd=np.arange(0, 360, 5.0)): - """ - This internal method calculates the mean wind speed for each specified - wind direction bin and resamples the wind rose, resulting in a single - mean wind speed per wind direction bin. The frequency values are - adjusted accordingly. - - TODO: make an internal method - - Args: - wd (np.arange, optional): Wind direction bin centers (deg). - Defaults to np.arange(0, 360, 5.). - - Returns: - pandas.DataFrame: Wind rose DataFrame with the resampled wind speed - bins and frequencies containing at least the following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - The average wind speed for each wind - direction bin (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - new wind conditions in the other columns. - """ - # Update ws and wd binning - self.wd = wd - self.num_wd = len(wd) - self.wd_step = wd[1] - wd[0] - - # Update internal data frame - self.df = self.resample_average_ws_by_wd(self.df) - - def interpolate( - self, - wind_directions: np.ndarray, - wind_speeds: np.ndarray, - mirror_0_to_360=True, - fill_value=0.0, - method="linear" - ): - """ - This method returns a linear interpolant that will return the occurrence - frequency for any given wind direction and wind speed combination(s). - This can be particularly useful when evaluating the wind rose at a - higher frequency than the input data is provided. - - Args: - wind_directions (np.ndarray): One or multi-dimensional array containing - the wind direction values at which the wind rose frequency of occurrence - should be evaluated. - wind_speeds (np.ndarray): One or multi-dimensional array containing - the wind speed values at which the wind rose frequency of occurrence - should be evaluated. - mirror_0_to_360 (bool, optional): This function copies the wind rose - frequency values from 0 deg to 360 deg. This can be useful when, for example, - the wind rose is only calculated until 357 deg but then interpolant is - requesting values at 359 deg. Defaults to True. - fill_value (float, optional): Fill value for the interpolant when - interpolating values outside of the data region. Defaults to 0.0. - method (str, optional): The interpolation method. Options are 'linear' and - 'nearest'. Recommended usage is 'linear'. Defaults to 'linear'. - - Returns: - scipy.interpolate.LinearNDInterpolant: Linear interpolant for the - wind rose currently available in the class (self.df). - - Example: - wr = wind_rose.WindRose() - wr.make_wind_rose_from_user_data(...) - freq_floris = wr.interpolate(floris_wind_direction_grid, floris_wind_speed_grid) - """ - if method == "linear": - interpolator = LinearNDInterpolator - elif method == "nearest": - interpolator = NearestNDInterpolator - else: - UserWarning("Unknown interpolation method: '{:s}'".format(method)) - - # Load windrose information from self - df = self.df.copy() - - if mirror_0_to_360: - # Copy values from 0 deg over to 360 deg - df_copy = df[df["wd"] == 0.0].copy() - df_copy["wd"] = 360.0 - df = pd.concat([df, df_copy], axis=0) - - interp = interpolator( - points=df[["wd", "ws"]], - values=df["freq_val"], - fill_value=fill_value - ) - return interp(wind_directions, wind_speeds) - - def weibull(self, x, k=2.5, lam=8.0): - """ - This method returns a Weibull distribution corresponding to the input - data array (typically wind speed) using the specified Weibull - parameters. - - Args: - x (np.array): List of input data (typically binned wind speed - observations). - k (float, optional): Weibull shape parameter. Defaults to 2.5. - lam (float, optional): Weibull scale parameter. Defaults to 8.0. - - Returns: - np.array: Weibull distribution probabilities corresponding to - values in the input array. - """ - return (k / lam) * (x / lam) ** (k - 1) * np.exp(-((x / lam) ** k)) - - def make_wind_rose_from_weibull( - self, wd=np.arange(0, 360, 5.0), ws=np.arange(0, 26, 1.0) - ): - """ - Populate WindRose object with an example wind rose with wind speed - frequencies given by a Weibull distribution. The wind direction - frequencies are initialized according to an example distribution. - - Args: - wd (np.array, optional): Wind direciton bin centers (deg). Defaults - to np.arange(0, 360, 5.). - ws (np.array, optional): Wind speed bin centers (m/s). Defaults to - np.arange(0, 26, 1.). - - Returns: - pandas.DataFrame: Wind rose DataFrame containing at least the - following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - """ - # Use an assumed wind-direction for dir frequency - wind_dir = [ - 0, - 22.5, - 45, - 67.5, - 90, - 112.5, - 135, - 157.5, - 180, - 202.5, - 225, - 247.5, - 270, - 292.5, - 315, - 337.5, - ] - freq_dir = [ - 0.064, - 0.04, - 0.038, - 0.036, - 0.045, - 0.05, - 0.07, - 0.08, - 0.11, - 0.08, - 0.05, - 0.036, - 0.048, - 0.058, - 0.095, - 0.10, - ] - - freq_wd = np.interp(wd, wind_dir, freq_dir) - freq_ws = self.weibull(ws) - - freq_tot = np.zeros(len(wd) * len(ws)) - wd_tot = np.zeros(len(wd) * len(ws)) - ws_tot = np.zeros(len(wd) * len(ws)) - - count = 0 - for i in range(len(wd)): - for j in range(len(ws)): - wd_tot[count] = wd[i] - ws_tot[count] = ws[j] - - freq_tot[count] = freq_wd[i] * freq_ws[j] - count = count + 1 - - # renormalize - freq_tot = freq_tot / np.sum(freq_tot) - - # Load the wind toolkit data into a dataframe - df = pd.DataFrame() - - # Start by simply round and wrapping the wind direction and wind speed - # columns - df["wd"] = wd_tot - df["ws"] = ws_tot - - # Now group up - df["freq_val"] = freq_tot - - # Save the df at this point - self.df = df - # TODO is there a reason self.df is updated AND returned? - return self.df - - def make_wind_rose_from_user_data( - self, wd_raw, ws_raw, *args, wd=np.arange(0, 360, 5.0), ws=np.arange(0, 26, 1.0) - ): - """ - This method populates the WindRose object given user-specified - observations of wind direction, wind speed, and additional optional - variables. The wind parameters are binned and the frequencies of - occurance of each binned wind condition combination are calculated. - - Args: - wd_raw (array-like): An array-like list of all wind direction - observations used to calculate the normalized frequencies (deg). - ws_raw (array-like): An array-like list of all wind speed - observations used to calculate the normalized frequencies (m/s). - *args: Variable length argument list consisting of a sequence of - the following alternating arguments: - - - string - Name of additional wind parameters to include in - wind rose. - - array-like - Values of the additional wind parameters used - to calculate the frequencies of occurance - - np.array - Bin center values for binning the additional - wind parameters. - - wd (np.array, optional): Wind direction bin centers (deg). Defaults - to np.arange(0, 360, 5.). - ws (np.array, optional): Wind speed bin limits (m/s). Defaults to - np.arange(0, 26, 1.). - - Returns: - pandas.DataFrame: Wind rose DataFrame containing at least the - following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - """ - df = pd.DataFrame() - - # convert inputs to np.array - wd_raw = np.array(wd_raw) - ws_raw = np.array(ws_raw) - - # Start by simply round and wrapping the wind direction and wind speed - # columns - df["wd"] = geo.wrap_360(wd_raw.round()) - df["ws"] = ws_raw.round() - - # Loop through *args and assign new dataframe columns after cutting - # into possibly irregularly-spaced bins - for in_var in range(0, len(args), 3): - df[args[in_var]] = np.array(args[in_var + 1]) - - # Cut into bins, make first and last bins extend to -/+ infinity - var_edges = np.append( - 0.5 * (args[in_var + 2][1:] + args[in_var + 2][:-1]), np.inf - ) - var_edges = np.append(-np.inf, var_edges) - df[args[in_var]] = pd.cut( - df[args[in_var]], var_edges, labels=args[in_var + 2] - ) - - # Now group up - df["freq_val"] = 1.0 - df = df.groupby([c for c in df.columns if c != "freq_val"], observed=False).sum() - df["freq_val"] = df.freq_val.astype(float) / df.freq_val.sum() - df = df.reset_index() - - # Save the df at this point - self.df = df - - # Resample onto the provided wind speed and wind direction binnings - self.internal_resample_wind_speed(ws=ws) - self.internal_resample_wind_direction(wd=wd) - - return self.df - - def read_wind_rose_csv( - self, - filename - ): - - #Read in the csv - self.df = pd.read_csv(filename) - - # Renormalize the frequency column - self.df["freq_val"] = self.df["freq_val"] / self.df["freq_val"].sum() - - # Call the resample function in order to set all the internal variables - self.internal_resample_wind_speed(ws=self.df.ws.unique()) - self.internal_resample_wind_direction(wd=self.df.wd.unique()) - - - def make_wind_rose_from_user_dist( - self, - wd_raw, - ws_raw, - freq_val, - *args, - wd=np.arange(0, 360, 5.0), - ws=np.arange(0, 26, 1.0), - ): - """ - This method populates the WindRose object given user-specified - combinations of wind direction, wind speed, additional optional - variables, and the corresponding frequencies of occurance. The wind - parameters are binned using the specified wind parameter bin center - values and the corresponding frequencies of occrance are calculated. - - Args: - wd_raw (array-like): An array-like list of wind directions - corresponding to the specified frequencies of occurance (deg). - wd_raw (array-like): An array-like list of wind speeds - corresponding to the specified frequencies of occurance (m/s). - freq_val (array-like): An array-like list of normalized frequencies - corresponding to the provided wind parameter combinations. - *args: Variable length argument list consisting of a sequence of - the following alternating arguments: - - - string - Name of additional wind parameters to include in - wind rose. - - array-like - Values of the additional wind parameters - corresponding to the specified frequencies of occurance. - - np.array - Bin center values for binning the additional - wind parameters. - - wd (np.array, optional): Wind direction bin centers (deg). Defaults - to np.arange(0, 360, 5.). - ws (np.array, optional): Wind speed bin centers (m/s). Defaults to - np.arange(0, 26, 1.). - - Returns: - pandas.DataFrame: Wind rose DataFrame containing at least the - following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - """ - df = pd.DataFrame() - - # convert inputs to np.array - wd_raw = np.array(wd_raw) - ws_raw = np.array(ws_raw) - - # Start by simply wrapping the wind direction column - df["wd"] = geo.wrap_360(wd_raw) - df["ws"] = ws_raw - - # Loop through *args and assign new dataframe columns - for in_var in range(0, len(args), 3): - df[args[in_var]] = np.array(args[in_var + 1]) - - # Assign frequency column - df["freq_val"] = np.array(freq_val) - df["freq_val"] = df["freq_val"] / df["freq_val"].sum() - - # Save the df at this point - self.df = df - - # Resample onto the provided wind variable binnings - self.internal_resample_wind_speed(ws=ws) - self.internal_resample_wind_direction(wd=wd) - - # Loop through *args and resample using provided binnings - for in_var in range(0, len(args), 3): - self.internal_resample_column(args[in_var], args[in_var + 2]) - - return self.df - - def parse_wind_toolkit_folder( - self, - folder_name, - wd=np.arange(0, 360, 5.0), - ws=np.arange(0, 26, 1.0), - limit_month=None, - ): - """ - This method populates the WindRose object given raw wind direction and - wind speed data saved in csv files downloaded from the WIND Toolkit - application (see https://www.nrel.gov/grid/wind-toolkit.html for more - information). The wind parameters are binned using the specified wind - parameter bin center values and the corresponding frequencies of - occurance are calculated. - - Args: - folder_name (str): Path to the folder containing the WIND Toolkit - data files. - wd (np.array, optional): Wind direction bin centers (deg). Defaults - to np.arange(0, 360, 5.). - ws (np.array, optional): Wind speed bin centers (m/s). Defaults to - np.arange(0, 26, 1.). - limit_month (list, optional): List of ints of month(s) (e.g., 1, 2 - 3...) to consider when calculating the wind condition - frequencies. If none are specified, all months will be used. - Defaults to None. - - Returns: - pandas.DataFrame: Wind rose DataFrame containing the following - columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - """ - # Load the wind toolkit data into a dataframe - df = self.load_wind_toolkit_folder(folder_name, limit_month=limit_month) - - # Start by simply round and wrapping the wind direction and wind speed - # columns - df["wd"] = geo.wrap_360(df.wd.round()) - df["ws"] = geo.wrap_360(df.ws.round()) - - # Now group up - df["freq_val"] = 1.0 - df = df.groupby(["ws", "wd"]).sum() - df["freq_val"] = df.freq_val.astype(float) / df.freq_val.sum() - df = df.reset_index() - - # Save the df at this point - self.df = df - - # Resample onto the provided wind speed and wind direction binnings - self.internal_resample_wind_speed(ws=ws) - self.internal_resample_wind_direction(wd=wd) - - return self.df - - def load_wind_toolkit_folder(self, folder_name, limit_month=None): - """ - This method imports raw wind direction and wind speed data saved in csv - files in the specified folder downloaded from the WIND Toolkit - application (see https://www.nrel.gov/grid/wind-toolkit.html for more - information). - - TODO: make private method? - - Args: - folder_name (str): Path to the folder containing the WIND Toolkit - csv data files. - limit_month (list, optional): List of ints of month(s) (e.g., 1, 2, - 3...) to consider when calculating the wind condition - frequencies. If none are specified, all months will be used. - Defaults to None. - - Returns: - pandas.DataFrame: DataFrame containing the following columns: - - - **wd** (*float*) - Raw wind direction data (deg). - - **ws** (*float*) - Raw wind speed data (m/s). - """ - file_list = os.listdir(folder_name) - file_list = [os.path.join(folder_name, f) for f in file_list if ".csv" in f] - - df = pd.DataFrame() - for f_idx, f in enumerate(file_list): - print("%d of %d: %s" % (f_idx, len(file_list), f)) - df_temp = self.load_wind_toolkit_file(f, limit_month=limit_month) - df = df.append(df_temp) - - return df - - def load_wind_toolkit_file(self, filename, limit_month=None): - """ - This method imports raw wind direction and wind speed data saved in the - specified csv file downloaded from the WIND Toolkit application (see - https://www.nrel.gov/grid/wind-toolkit.html for more information). - - TODO: make private method? - - Args: - filename (str): Path to the WIND Toolkit csv file. - limit_month (list, optional): List of ints of month(s) (e.g., 1, 2, - 3...) to consider when calculating the wind condition - frequencies. If none are specified, all months will be used. - Defaults to None. - - Returns: - pandas.DataFrame: DataFrame containing the following columns with - data from the WIND Toolkit file: - - - **wd** (*float*) - Raw wind direction data (deg). - - **ws** (*float*) - Raw wind speed data (m/s). - """ - df = pd.read_csv(filename, header=3, sep=",") - - # If asked to limit to particular months - if limit_month is not None: - df = df[df.Month.isin(limit_month)] - - # Save just what I want - speed_column = [c for c in df.columns if "speed" in c][0] - direction_column = [c for c in df.columns if "direction" in c][0] - df = df.rename(index=str, columns={speed_column: "ws", direction_column: "wd"})[ - ["wd", "ws"] - ] - - return df - - def import_from_wind_toolkit_hsds( - self, - lat, - lon, - ht=100, - wd=np.arange(0, 360, 5.0), - ws=np.arange(0, 26, 1.0), - include_ti=False, - limit_month=None, - limit_hour=None, - st_date=None, - en_date=None, - ): - """ - This method populates the WindRose object using wind data from the WIND - Toolkit dataset (https://www.nrel.gov/grid/wind-toolkit.html) for the - specified lat/long coordinate in the continental US. The wind data - are obtained from the WIND Toolkit dataset using the HSDS service (see - https://github.com/NREL/hsds-examples). The wind data returned is - obtained from the nearest 2km x 2km grid point to the input - coordinate and is limited to the years 2007-2013. The wind parameters - are binned using the specified wind parameter bin center values and the - corresponding frequencies of occrance are calculated. - - Requires h5pyd package, which can be installed using: - pip install --user git+http://github.com/HDFGroup/h5pyd.git - - Then, make a configuration file at ~/.hscfg containing: - - hs_endpoint = https://developer.nrel.gov/api/hsds - - hs_username = None - - hs_password = None - - hs_api_key = 3K3JQbjZmWctY0xmIfSYvYgtIcM3CN0cb1Y2w9bf - - The example API key above is for demonstation and is - rate-limited per IP. To get your own API key, visit - https://developer.nrel.gov/signup/. - - More information can be found at: https://github.com/NREL/hsds-examples. - - Args: - lat (float): Latitude in degrees. - lon (float): Longitude in degrees. - ht (int, optional): The height above ground where wind - information is obtained (m). Defaults to 100. - wd (np.array, optional): Wind direction bin centers (deg). Defaults - to np.arange(0, 360, 5.). - ws (np.array, optional): Wind speed bin centers (m/s). Defaults to - np.arange(0, 26, 1.). - include_ti (bool, optional): Determines whether turbulence - intensity is included as an additional parameter. If True, TI - is added as an additional wind rose variable, estimated based - on the Obukhov length from WIND Toolkit. Defaults to False. - limit_month (list, optional): List of ints of month(s) (e.g., 1, 2, - 3...) to consider when calculating the wind condition - frequencies. If none are specified, all months will be used. - Defaults to None. - limit_hour (list, optional): List of ints of hour(s) (e.g., 0, 1, - ... 23) to consider when calculating the wind condition - frequencies. If none are specified, all hours will be used. - Defaults to None. - st_date (str, optional): The start date to consider when creating - the wind rose, formatted as 'MM-DD-YYYY'. If not specified data - beginning in 2007 will be used. Defaults to None. - en_date (str, optional): The end date to consider when creating - the wind rose, formatted as 'MM-DD-YYYY'. If not specified data - through 2013 will be used. Defaults to None. - - Returns: - pandas.DataFrame: Wind rose DataFrame containing at least the - following columns: - - - **wd** (*float*) - Wind direction bin center values (deg). - - **ws** (*float*) - Wind speed bin center values (m/s). - - **freq_val** (*float*) - The frequency of occurance of the - wind conditions in the other columns. - """ - # Check inputs - - # Array of hub height data avaliable on Toolkit - h_range = [10, 40, 60, 80, 100, 120, 140, 160, 200] - - if st_date is not None: - if dateutil.parser.parse(st_date) > dateutil.parser.parse( - "12-13-2013 23:00" - ): - print( - "Error, invalid date range. Valid range: 01-01-2007 - " - + "12/31/2013" - ) - return None - - if en_date is not None: - if dateutil.parser.parse(en_date) < dateutil.parser.parse( - "01-01-2007 00:00" - ): - print( - "Error, invalid date range. Valid range: 01-01-2007 - " - + "12/31/2013" - ) - return None - - if h_range[0] > ht: - print( - "Error, height is not in the range of avaliable " - + "WindToolKit data. Minimum height = 10m" - ) - return None - - if h_range[-1] < ht: - print( - "Error, height is not in the range of avaliable " - + "WindToolKit data. Maxiumum height = 200m" - ) - return None - - # Load wind speeds and directions from WimdToolkit - - # Case for turbine height (ht) matching discrete avaliable height - # (h_range) - if ht in h_range: - - d = self.load_wind_toolkit_hsds( - lat, - lon, - ht, - include_ti=include_ti, - limit_month=limit_month, - limit_hour=limit_hour, - st_date=st_date, - en_date=en_date, - ) - - ws_new = d["ws"] - wd_new = d["wd"] - if include_ti: - ti_new = d["ti"] - - # Case for ht not matching discete height - else: - h_range_up = next(x[0] for x in enumerate(h_range) if x[1] > ht) - h_range_low = h_range_up - 1 - h_up = h_range[h_range_up] - h_low = h_range[h_range_low] - - # Load data for boundary cases of ht - d_low = self.load_wind_toolkit_hsds( - lat, - lon, - h_low, - include_ti=include_ti, - limit_month=limit_month, - limit_hour=limit_hour, - st_date=st_date, - en_date=en_date, - ) - - d_up = self.load_wind_toolkit_hsds( - lat, - lon, - h_up, - include_ti=include_ti, - limit_month=limit_month, - limit_hour=limit_hour, - st_date=st_date, - en_date=en_date, - ) - - # Wind Speed interpolation - ws_low = d_low["ws"] - ws_high = d_up["ws"] - - ws_new = np.array(ws_low) * ( - 1 - ((ht - h_low) / (h_up - h_low)) - ) + np.array(ws_high) * ((ht - h_low) / (h_up - h_low)) - - # Wind Direction interpolation using Circular Mean method - wd_low = d_low["wd"] - wd_high = d_up["wd"] - - sin0 = np.sin(np.array(wd_low) * (np.pi / 180)) - cos0 = np.cos(np.array(wd_low) * (np.pi / 180)) - sin1 = np.sin(np.array(wd_high) * (np.pi / 180)) - cos1 = np.cos(np.array(wd_high) * (np.pi / 180)) - - sin_wd = sin0 * (1 - ((ht - h_low) / (h_up - h_low))) + sin1 * ( - (ht - h_low) / (h_up - h_low) - ) - cos_wd = cos0 * (1 - ((ht - h_low) / (h_up - h_low))) + cos1 * ( - (ht - h_low) / (h_up - h_low) - ) - - # Interpolated wind direction - wd_new = 180 / np.pi * np.arctan2(sin_wd, cos_wd) - - # TI is independent of height - if include_ti: - ti_new = d_up["ti"] - - # Create a dataframe named df - if include_ti: - df = pd.DataFrame({"ws": ws_new, "wd": wd_new, "ti": ti_new}) - else: - df = pd.DataFrame({"ws": ws_new, "wd": wd_new}) - - # Start by simply round and wrapping the wind direction and wind speed - # columns - df["wd"] = geo.wrap_360(df.wd.round()) - df["ws"] = df.ws.round() - - # Now group up - df["freq_val"] = 1.0 - df = df.groupby([c for c in df.columns if c != "freq_val"], observed=False).sum() - df["freq_val"] = df.freq_val.astype(float) / df.freq_val.sum() - df = df.reset_index() - - # Save the df at this point - self.df = df - - # Resample onto the provided wind speed and wind direction binnings - self.internal_resample_wind_speed(ws=ws) - self.internal_resample_wind_direction(wd=wd) - - return self.df - - def load_wind_toolkit_hsds( - self, - lat, - lon, - ht=100, - include_ti=False, - limit_month=None, - limit_hour=None, - st_date=None, - en_date=None, - ): - """ - This method returns a pandas DataFrame containing hourly wind speed, - wind direction, and optionally estimated turbulence intensity data - using wind data from the WIND Toolkit dataset - (https://www.nrel.gov/grid/wind-toolkit.html) for the specified - lat/long coordinate in the continental US. The wind data are obtained - from the WIND Toolkit dataset using the HSDS service - (see https://github.com/NREL/hsds-examples). The wind data returned is - obtained from the nearest 2km x 2km grid point to the input coordinate - and is limited to the years 2007-2013. - - TODO: make private method? - - Args: - lat (float): Latitude in degrees. - lon (float): Longitude in degrees - ht (int, optional): The height above ground where wind - information is obtained (m). Defaults to 100. - include_ti (bool, optional): Determines whether turbulence - intensity is included as an additional parameter. If True, TI - is added as an additional wind rose variable, estimated based - on the Obukhov length from WIND Toolkit. Defaults to False. - limit_month (list, optional): List of ints of month(s) (e.g., 1, 2, - 3...) to consider when calculating the wind condition - frequencies. If none are specified, all months will be used. - Defaults to None. - limit_hour (list, optional): List of ints of hour(s) (e.g., 0, 1, - ... 23) to consider when calculating the wind condition - frequencies. If none are specified, all hours will be used. - Defaults to None. - st_date (str, optional): The start date to consider, formatted as - 'MM-DD-YYYY'. If not specified data beginning in 2007 will be - used. Defaults to None. - en_date (str, optional): The end date to consider, formatted as - 'MM-DD-YYYY'. If not specified data through 2013 will be used. - Defaults to None. - - Returns: - pandas.DataFrame: DataFrame containing the following columns(abd - optionally turbulence intensity) with hourly data from WIND Toolkit: - - - **wd** (*float*) - Raw wind direction data (deg). - - **ws** (*float*) - Raw wind speed data (m/s). - """ - import h5pyd - - # Open the wind data "file" - # server endpoint, username, password is found via a config file - f = h5pyd.File("/nrel/wtk-us.h5", "r") - - # assign wind direction, wind speed, optional ti, and time datasets for - # the desired height - wd_dset = f["winddirection_" + str(ht) + "m"] - ws_dset = f["windspeed_" + str(ht) + "m"] - if include_ti: - obkv_dset = f["inversemoninobukhovlength_2m"] - dt = f["datetime"] - dt = pd.DataFrame({"datetime": dt[:]}, index=range(0, dt.shape[0])) - dt["datetime"] = dt["datetime"].apply(dateutil.parser.parse) - - # find dataset indices from lat/long - Location_idx = self.indices_for_coord(f, lat, lon) - - # check if in bounds - if ( - (Location_idx[0] < 0) - | (Location_idx[0] >= wd_dset.shape[1]) - | (Location_idx[1] < 0) - | (Location_idx[1] >= wd_dset.shape[2]) - ): - print( - "Error, coordinates out of bounds. WIND Toolkit database " - + "covers the continental United States." - ) - return None - - # create dataframe with wind direction and wind speed - df = pd.DataFrame() - df["wd"] = wd_dset[:, Location_idx[0], Location_idx[1]] - df["ws"] = ws_dset[:, Location_idx[0], Location_idx[1]] - if include_ti: - L = self.obkv_dset_to_L(obkv_dset, Location_idx) - ti = self.ti_calculator_IU2(L) - df["ti"] = ti - df["datetime"] = dt["datetime"] - - # limit dates if start and end dates are provided - if st_date is not None: - df = df[df.datetime >= st_date] - - if en_date is not None: - df = df[df.datetime < en_date] - - # limit to certain months if specified - if limit_month is not None: - df["month"] = df["datetime"].map(lambda x: x.month) - df = df[df.month.isin(limit_month)] - if limit_hour is not None: - df["hour"] = df["datetime"].map(lambda x: x.hour) - df = df[df.hour.isin(limit_hour)] - if include_ti: - df = df[["wd", "ws", "ti"]] - else: - df = df[["wd", "ws"]] - - return df - - def obkv_dset_to_L(self, obkv_dset, Location_idx): - """ - This function returns an array containing hourly Obukhov lengths from - the WIND Toolkit dataset for the specified Lat/Lon coordinate indices. - - Args: - obkv_dset (np.ndarray): Dataset for Obukhov lengths from WIND - Toolkit. - Location_idx (tuple): A tuple containing the Lat/Lon coordinate - indices of interest in the Obukhov length dataset. - - Returns: - np.array: An array containing Obukhov lengths for each time index - in the Wind Toolkit dataset (m). - """ - linv = obkv_dset[:, Location_idx[0], Location_idx[1]] - # avoid divide by zero - linv[linv == 0.0] = 0.0003 - L = 1 / linv - return L - - def ti_calculator_IU2(self, L): - """ - This function estimates the turbulence intensity corresponding to each - Obukhov length value in the input list using the relationship between - Obukhov length bins and TI given in the I_U2SODAR column in Table 2 of - :cite:`wr-wharton2010assessing`. - - Args: - L (iterable): A list of Obukhov Length values (m). - - Returns: - list: A list of turbulence intensity values expressed as fractions. - """ - ti_set = [] - for i in L: - # Strongly Stable - if 0 < i < 100: - TI = 0.04 # paper says < 8%, so using 4% - # Stable - elif 100 < i < 600: - TI = 0.09 - # Neutral - elif abs(i) > 600: - TI = 0.115 - # Convective - elif -600 < i < -50: - TI = 0.165 - # Strongly Convective - elif -50 < i < 0: - # no upper bound given, so using the lowest - # value from the paper for this stability bin - TI = 0.2 - ti_set.append(TI) - return ti_set - - def indices_for_coord(self, f, lat_index, lon_index): - """ - This method finds the nearest x/y indices of the WIND Toolkit dataset - for a given lat/lon coordinate in the continental US. Rather than - fetching the entire coordinates database, which is 500+ MB, this uses - the Proj4 library to find a nearby point and then converts to x/y - indices. - - **Note**: This method is obtained directly from: - https://github.com/NREL/hsds-examples/blob/master/notebooks/01_WTK_introduction.ipynb, - where it is called "indicesForCoord." - - Args: - f (h5pyd.File): A HDF5 "file" used to access the WIND Toolkit data. - lat_index (float): Latitude coordinate for which dataset indices - are to be found (degrees). - lon_index (float): Longitude coordinate for which dataset indices - are to be found (degrees). - - Returns: - tuple: A tuple containing the Lat/Lon coordinate indices of - interest in the WIND Toolkit dataset. - """ - dset_coords = f["coordinates"] - projstring = """+proj=lcc +lat_1=30 +lat_2=60 - +lat_0=38.47240422490422 +lon_0=-96.0 - +x_0=0 +y_0=0 +ellps=sphere - +units=m +no_defs """ - projectLcc = Proj(projstring) - origin_ll = reversed(dset_coords[0][0]) # Grab origin directly from database - origin = projectLcc(*origin_ll) - - coords = (lon_index, lat_index) - coords = projectLcc(*coords) - delta = np.subtract(coords, origin) - ij = [int(round(x / 2000)) for x in delta] - return tuple(reversed(ij)) - - def plot_wind_speed_all(self, ax=None, label=None): - """ - This method plots the wind speed frequency distribution of the WindRose - object averaged across all wind directions. If no axis is provided, a - new one is created. - - Args: - ax (:py:class:`matplotlib.pyplot.axes`, optional): Figure axes on - which data should be plotted. Defaults to None. - """ - if ax is None: - _, ax = plt.subplots() - - df_plot = self.df.groupby("ws").sum() - ax.plot(self.ws, df_plot.freq_val, label=label) - - def plot_wind_speed_by_direction(self, dirs, ax=None): - """ - This method plots the wind speed frequency distribution of the WindRose - object for each specified wind direction bin center. The wind - directions are resampled using the specified bin centers and the - frequencies of occurance of the wind conditions are modified - accordingly. If no axis is provided, a new one is created. - - Args: - dirs (np.array): A list of wind direction bin centers for which - wind speed distributions are plotted (deg). - ax (:py:class:`matplotlib.pyplot.axes`, optional): Figure axes on - which data should be plotted. Defaults to None. - """ - # Get a downsampled frame - df_plot = self.resample_wind_direction(self.df, wd=dirs) - - if ax is None: - _, ax = plt.subplots() - - for wd in dirs: - df_plot_sub = df_plot[df_plot.wd == wd] - ax.plot(df_plot_sub.ws, df_plot_sub["freq_val"], label=wd) - ax.legend() - - def plot_wind_rose( - self, - ax=None, - color_map="viridis_r", - ws_right_edges=np.array([5, 10, 15, 20, 25]), - wd_bins=np.arange(0, 360, 15.0), - legend_kwargs={}, - ): - """ - This method creates a wind rose plot showing the frequency of occurance - of the specified wind direction and wind speed bins. If no axis is - provided, a new one is created. - - **Note**: Based on code provided by Patrick Murphy from the University - of Colorado Boulder. - - Args: - ax (:py:class:`matplotlib.pyplot.axes`, optional): The figure axes - on which the wind rose is plotted. Defaults to None. - color_map (str, optional): Colormap to use. Defaults to 'viridis_r'. - ws_right_edges (np.array, optional): The upper bounds of the wind - speed bins (m/s). The first bin begins at 0. Defaults to - np.array([5, 10, 15, 20, 25]). - wd_bins (np.array, optional): The wind direction bin centers used - for plotting (deg). Defaults to np.arange(0, 360, 15.). - legend_kwargs (dict, optional): Keyword arguments to be passed to - ax.legend(). - - Returns: - :py:class:`matplotlib.pyplot.axes`: A figure axes object containing - the plotted wind rose. - """ - # Resample data onto bins - df_plot = self.resample_wind_direction(self.df, wd=wd_bins) - - # Make labels for wind speed based on edges - ws_step = ws_right_edges[1] - ws_right_edges[0] - ws_labels = ["%d-%d m/s" % (w - ws_step, w) for w in ws_right_edges] - - # Grab the wd_step - wd_step = wd_bins[1] - wd_bins[0] - - # Set up figure - if ax is None: - _, ax = plt.subplots(subplot_kw={"polar": True}) - - # Get a color array - color_array = cm.get_cmap(color_map, len(ws_right_edges)) - - for wd in wd_bins: - rects = [] - df_plot_sub = df_plot[df_plot.wd == wd] - for ws_idx, ws in enumerate(ws_right_edges[::-1]): - plot_val = df_plot_sub[ - df_plot_sub.ws <= ws - ].freq_val.sum() # Get the sum of frequency up to this wind speed - rects.append( - ax.bar( - np.radians(wd), - plot_val, - width=0.9 * np.radians(wd_step), - color=color_array(ws_idx), - edgecolor="k", - ) - ) - # break - - # Configure the plot - ax.legend(reversed(rects), ws_labels, **legend_kwargs) - ax.set_theta_direction(-1) - ax.set_theta_offset(np.pi / 2.0) - ax.set_theta_zero_location("N") - ax.set_xticks(np.arange(0, 2*np.pi, np.pi/4)) - ax.set_xticklabels(["N", "NE", "E", "SE", "S", "SW", "W", "NW"]) - - return ax - - def plot_wind_rose_ti( - self, - ax=None, - color_map="viridis_r", - ti_right_edges=np.array([0.06, 0.1, 0.14, 0.18, 0.22]), - wd_bins=np.arange(0, 360, 15.0), - ): - """ - This method creates a wind rose plot showing the frequency of occurance - of the specified wind direction and turbulence intensity bins. This - requires turbulence intensity to already be included as a parameter in - the wind rose. If no axis is provided,a new one is created. - - **Note**: Based on code provided by Patrick Murphy from the University - of Colorado Boulder. - - Args: - ax (:py:class:`matplotlib.pyplot.axes`, optional): The figure axes - on which the wind rose is plotted. Defaults to None. - color_map (str, optional): Colormap to use. Defaults to 'viridis_r'. - ti_right_edges (np.array, optional): The upper bounds of the - turbulence intensity bins. The first bin begins at 0. Defaults - to np.array([0.06, 0.1, 0.14, 0.18,0.22]). - wd_bins (np.array, optional): The wind direction bin centers used - for plotting (deg). Defaults to np.arange(0, 360, 15.). - - Returns: - :py:class:`matplotlib.pyplot.axes`: A figure axes object containing - the plotted wind rose. - """ - - # Resample data onto bins - df_plot = self.resample_wind_direction(self.df, wd=wd_bins) - - # Make labels for TI based on edges - ti_step = ti_right_edges[1] - ti_right_edges[0] - ti_labels = ["%.2f-%.2f " % (w - ti_step, w) for w in ti_right_edges] - - # Grab the wd_step - wd_step = wd_bins[1] - wd_bins[0] - - # Set up figure - if ax is None: - _, ax = plt.subplots(subplot_kw={"polar": True}) - - # Get a color array - color_array = cm.get_cmap(color_map, len(ti_right_edges)) - - for wd in wd_bins: - rects = [] - df_plot_sub = df_plot[df_plot.wd == wd] - for ti_idx, ti in enumerate(ti_right_edges[::-1]): - plot_val = df_plot_sub[ - df_plot_sub.ti <= ti - ].freq_val.sum() # Get the sum of frequency up to this wind speed - rects.append( - ax.bar( - np.radians(wd), - plot_val, - width=0.9 * np.radians(wd_step), - color=color_array(ti_idx), - edgecolor="k", - ) - ) - - # Configure the plot - ax.legend(reversed(rects), ti_labels, loc="lower right", title="TI") - ax.set_theta_direction(-1) - ax.set_theta_offset(np.pi / 2.0) - ax.set_theta_zero_location("N") - ax.set_xticks(np.arange(0, 2*np.pi, np.pi/4)) - ax.set_xticklabels(["N", "NE", "E", "SE", "S", "SW", "W", "NW"]) - - return ax - - def plot_ti_ws(self, ax=None, ws_bins=np.arange(0, 26, 1.0)): - """ - This method plots the wind speed frequency distribution of the WindRose - object for each turbulence intensity bin. The wind speeds are resampled - using the specified bin centers and the frequencies of occurance of the - wind conditions are modified accordingly. This method assumes there are - five TI bins. If no axis is provided, a new one is created. - - Args: - ax (:py:class:`matplotlib.pyplot.axes`, optional): Figure axes on - which data should be plotted. Defaults to None. - ws_bins (np.array, optional): A list of wind speed bin centers on - which the wind speeds are resampled before plotting (m/s). - Defaults to np.arange(0, 26, 1.). - - Returns: - :py:class:`matplotlib.pyplot.axes`: A figure axes object containing - the plotted wind speed distributions. - """ - - # Resample data onto bins - df_plot = self.resample_wind_speed(self.df, ws=ws_bins) - - df_plot = df_plot.groupby(["ws", "ti"]).sum() - df_plot = df_plot.reset_index() - - if ax is None: - _, ax = plt.subplots(figsize=(10, 7)) - - tis = df_plot["ti"].drop_duplicates() - margin_bottom = np.zeros(len(df_plot["ws"].drop_duplicates())) - colors = ["#1e5631", "#a4de02", "#76ba1b", "#4c9a2a", "#acdf87"] - - for num, ti in enumerate(tis): - values = list(df_plot[df_plot["ti"] == ti].loc[:, "freq_val"]) - - df_plot[df_plot["ti"] == ti].plot.bar( - x="ws", - y="freq_val", - ax=ax, - bottom=margin_bottom, - color=colors[num], - label=ti, - ) - - margin_bottom += values - - plt.title("Turbulence Intensity Frequencies as Function of Wind Speed") - plt.xlabel("Wind Speed (m/s)") - plt.ylabel("Frequency") - - return ax - - def export_for_floris_opt(self): - """ - This method returns a list of tuples of at least wind speed, wind - direction, and frequency of occurance, which can be used to help loop - through different wind conditions for Floris power calculations. - - Returns: - list: A list of tuples containing all combinations of wind - parameters and frequencies of occurance in the WindRose object's - wind rose DataFrame values. - """ - # Return a list of tuples, where each tuple is (ws,wd,freq) - return [tuple(x) for x in self.df.values] diff --git a/floris/turbine_library/__init__.py b/floris/turbine_library/__init__.py index 933615b0c..42e1962f3 100644 --- a/floris/turbine_library/__init__.py +++ b/floris/turbine_library/__init__.py @@ -1,2 +1,5 @@ from floris.turbine_library.turbine_previewer import TurbineInterface, TurbineLibrary -from floris.turbine_library.turbine_utilities import build_turbine_dict +from floris.turbine_library.turbine_utilities import ( + build_cosine_loss_turbine_dict, + check_smooth_power_curve, +) diff --git a/floris/turbine_library/iea_10MW.yaml b/floris/turbine_library/iea_10MW.yaml index eaa04d81b..f68278a70 100644 --- a/floris/turbine_library/iea_10MW.yaml +++ b/floris/turbine_library/iea_10MW.yaml @@ -1,178 +1,93 @@ +# Data based on: +# https://github.com/NREL/turbine-models/blob/master/Offshore/IEA_10MW_198_RWT.csv +# Note: Generator efficiency of 94% used. Small power variations above rated removed. turbine_type: 'iea_10MW' -generator_efficiency: 1.0 hub_height: 119.0 -pP: 1.88 -pT: 1.88 rotor_diameter: 198.0 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 6.0 +operation_model: cosine-loss power_thrust_table: + ref_air_density: 1.225 + ref_tilt: 6.0 + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 + helix_a: 1.719 + helix_power_b: 4.823e-03 + helix_power_c: 2.314e-10 + helix_thrust_b: 1.157e-03 + helix_thrust_c: 1.167e-04 power: - - 0.000000 - - 0.000000 - - 0.074 - - 0.325100 - - 0.376200 - - 0.402700 - - 0.415600 - - 0.423000 - - 0.427400 - - 0.429300 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.430500 - - 0.438256 - - 0.425908 - - 0.347037 - - 0.307306 - - 0.271523 - - 0.239552 - - 0.211166 - - 0.186093 - - 0.164033 - - 0.144688 - - 0.127760 - - 0.112969 - - 0.100062 - - 0.088800 - - 0.078975 - - 0.070401 - - 0.062913 - - 0.056368 - - 0.050640 - - 0.045620 - - 0.041216 - - 0.037344 - - 0.033935 - 0.0 - 0.0 - thrust: + - 35.60156 + - 414.0606 + - 1009.90686 + - 1855.02326 + - 2963.01442 + - 4440.26484 + - 6330.82856 + - 7392.13274 + - 8514.32824 + - 9691.10578 + - 10000.00 + - 10000.00 + - 10000.00 + - 10000.00 + - 10000.00 + - 10000.00 + - 10000.00 + - 10000.00 + - 10000.00 + - 10000.00 - 0.0 - 0.0 - - 0.7701 - - 0.7701 - - 0.7763 - - 0.7824 - - 0.7820 - - 0.7802 - - 0.7772 - - 0.7719 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7768 - - 0.7675 - - 0.7651 - - 0.7587 - - 0.5056 - - 0.4310 - - 0.3708 - - 0.3209 - - 0.2788 - - 0.2432 - - 0.2128 - - 0.1868 - - 0.1645 - - 0.1454 - - 0.1289 - - 0.1147 - - 0.1024 - - 0.0918 - - 0.0825 - - 0.0745 - - 0.0675 - - 0.0613 - - 0.0559 - - 0.0512 - - 0.0470 + thrust_coefficient: + - 0.0 + - 0.0 + - 0.915 + - 0.926 + - 0.921 + - 0.895 + - 0.885 + - 0.873 + - 0.827 + - 0.789 + - 0.754 + - 0.721 + - 0.591 + - 0.49 + - 0.418 + - 0.318 + - 0.251 + - 0.203 + - 0.167 + - 0.119 + - 0.088 + - 0.049 - 0.0 - 0.0 wind_speed: - 0.0000 - 2.9 - 3.0 - - 4.0000 - - 4.5147 - - 5.0008 - - 5.4574 - - 5.8833 - - 6.2777 - - 6.6397 - - 6.9684 - - 7.2632 - - 7.5234 - - 7.7484 - - 7.9377 - - 8.0909 - - 8.2077 - - 8.2877 - - 8.3308 - - 8.3370 - - 8.3678 - - 8.4356 - - 8.5401 - - 8.6812 - - 8.8585 - - 9.0717 - - 9.3202 - - 9.6035 - - 9.9210 - - 10.2720 - - 10.6557 - - 10.7577 - - 11.5177 - - 11.9941 - - 12.4994 - - 13.0324 - - 13.5920 - - 14.1769 - - 14.7859 - - 15.4175 - - 16.0704 - - 16.7432 - - 17.4342 - - 18.1421 - - 18.8652 - - 19.6019 - - 20.3506 - - 21.1096 - - 21.8773 - - 22.6519 - - 23.4317 - - 24.2150 - - 25.010 - - 25.020 + - 4.0 + - 5.0 + - 6.0 + - 7.0 + - 8.0 + - 9.0 + - 9.5 + - 10.0 + - 10.5 + - 11.0 + - 11.5 + - 12.0 + - 13.0 + - 14.0 + - 15.0 + - 16.0 + - 18.0 + - 20.0 + - 25.0 + - 25.01 - 50.0 diff --git a/floris/turbine_library/iea_15MW.yaml b/floris/turbine_library/iea_15MW.yaml index 0350cd9c4..6274b5f49 100644 --- a/floris/turbine_library/iea_15MW.yaml +++ b/floris/turbine_library/iea_15MW.yaml @@ -1,124 +1,137 @@ +# Data based on: +# https://github.com/IEAWindTask37/IEA-15-240-RWT/blob/master/Documentation/ +# IEA-15-240-RWT_tabular.xlsx +# Note: Small power variations above rated removed. +# Generator efficiency of 100% used. turbine_type: 'iea_15MW' -generator_efficiency: 1.0 hub_height: 150.0 -pP: 1.88 -pT: 1.88 rotor_diameter: 242.24 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 6.0 +operation_model: cosine-loss power_thrust_table: + ref_air_density: 1.225 + ref_tilt: 6.0 + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 + helix_a: 1.809 + helix_power_b: 4.828e-03 + helix_power_c: 4.017e-11 + helix_thrust_b: 1.390e-03 + helix_thrust_c: 5.084e-04 power: - 0.000000 - - 0.049361236 - - 0.224324252 - - 0.312216418 - - 0.36009987 - - 0.38761204 - - 0.404010164 - - 0.413979324 - - 0.420083692 - - 0.423787764 - - 0.425977895 - - 0.427193272 - - 0.427183505 - - 0.426860928 - - 0.426617959 - - 0.426458783 - - 0.426385957 - - 0.426371389 - - 0.426268826 - - 0.426077456 - - 0.425795302 - - 0.425420049 - - 0.424948854 - - 0.424379028 - - 0.423707714 - - 0.422932811 - - 0.422052556 - - 0.421065815 - - 0.419972455 - - 0.419400676 - - 0.418981957 - - 0.385839135 - - 0.335840083 - - 0.29191329 - - 0.253572514 - - 0.220278082 - - 0.191477908 - - 0.166631343 - - 0.145236797 - - 0.126834289 - - 0.111011925 - - 0.097406118 - - 0.085699408 - - 0.075616912 - - 0.066922115 - - 0.059412477 - - 0.052915227 - - 0.04728299 - - 0.042390922 - - 0.038132739 - - 0.03441828 + - 0.000000 + - 42.733312 + - 292.585981 + - 607.966543 + - 981.097693 + - 1401.98084 + - 1858.67086 + - 2337.575997 + - 2824.097302 + - 3303.06456 + - 3759.432328 + - 4178.637714 + - 4547.19121 + - 4855.342682 + - 5091.537139 + - 5248.453137 + - 5320.793207 + - 5335.345498 + - 5437.90563 + - 5631.253025 + - 5920.980626 + - 6315.115602 + - 6824.470067 + - 7462.846389 + - 8238.359448 + - 9167.96703 + - 10285.211 + - 11617.23699 + - 13194.41511 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 + - 15000.00 - 0.0 - 0.0 - thrust: + thrust_coefficient: + - 0.000000 - 0.000000 - - 0.817533319 - - 0.792115292 - - 0.786401899 - - 0.788898744 - - 0.790774576 - - 0.79208669 - - 0.79185809 - - 0.7903853 - - 0.788253035 - - 0.785845184 - - 0.783367164 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.77853469 - - 0.781531069 - - 0.758935311 - - 0.614478855 - - 0.498687801 - - 0.416354609 - - 0.351944846 - - 0.299832337 - - 0.256956606 - - 0.221322169 - - 0.19150758 - - 0.166435523 - - 0.145263684 - - 0.127319849 - - 0.11206048 - - 0.099042189 - - 0.087901155 - - 0.078337446 - - 0.07010295 - - 0.062991402 - - 0.056831647 - - 0.05148062 - - 0.046818787 + - 0.80742173 + - 0.784655297 + - 0.781771245 + - 0.785377072 + - 0.788045584 + - 0.789922119 + - 0.790464625 + - 0.789868339 + - 0.788727582 + - 0.787359348 + - 0.785895402 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.778275899 + - 0.77176172 + - 0.747149663 + - 0.562338457 + - 0.463477777 + - 0.389083718 + - 0.329822385 + - 0.281465071 + - 0.241494345 + - 0.208180574 + - 0.180257568 + - 0.156747535 + - 0.136877529 + - 0.120026379 + - 0.105689427 + - 0.093453742 + - 0.082979637 + - 0.073986457 + - 0.066241166 + - 0.059552107 + - 0.053756866 + - 0.048721662 + - 0.044334197 - 0.0 - 0.0 wind_speed: - 0.000 - - 3 + - 2.9 + - 3.0 - 3.54953237 - 4.067900771 - 4.553906848 diff --git a/floris/turbine_library/iea_15MW_floating_multi_dim_cp_ct.yaml b/floris/turbine_library/iea_15MW_floating_multi_dim_cp_ct.yaml index 58b2b3a1f..646a4e86a 100644 --- a/floris/turbine_library/iea_15MW_floating_multi_dim_cp_ct.yaml +++ b/floris/turbine_library/iea_15MW_floating_multi_dim_cp_ct.yaml @@ -1,14 +1,14 @@ turbine_type: 'iea_15MW_floating' -generator_efficiency: 1.0 hub_height: 150.0 -pP: 1.88 -pT: 1.88 rotor_diameter: 242.24 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 6.0 multi_dimensional_cp_ct: True -power_thrust_data_file: 'iea_15MW_multi_dim_Tp_Hs.csv' +power_thrust_table: + ref_air_density: 1.225 + ref_tilt: 6.0 + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 + power_thrust_data_file: 'iea_15MW_multi_dim_Tp_Hs.csv' floating_tilt_table: tilt: - 5.747296314800103 diff --git a/floris/turbine_library/iea_15MW_multi_dim_Tp_Hs.csv b/floris/turbine_library/iea_15MW_multi_dim_Tp_Hs.csv index b30eac5a3..70fcef234 100644 --- a/floris/turbine_library/iea_15MW_multi_dim_Tp_Hs.csv +++ b/floris/turbine_library/iea_15MW_multi_dim_Tp_Hs.csv @@ -1,213 +1,217 @@ -Tp,Hs,ws,Cp,Ct +Tp,Hs,ws,power,thrust_coefficient 2,1,0,0,0 -2,1,3,0.049361236,0.817533319 -2,1,3.54953237,0.224324252,0.792115292 -2,1,4.067900771,0.312216418,0.786401899 -2,1,4.553906848,0.36009987,0.788898744 -2,1,5.006427063,0.38761204,0.790774576 -2,1,5.424415288,0.404010164,0.79208669 -2,1,5.806905228,0.413979324,0.79185809 -2,1,6.153012649,0.420083692,0.7903853 -2,1,6.461937428,0.423787764,0.788253035 -2,1,6.732965398,0.425977895,0.785845184 -2,1,6.965470002,0.427193272,0.783367164 -2,1,7.158913742,0.427183505,0.77853469 -2,1,7.312849418,0.426860928,0.77853469 -2,1,7.426921164,0.426617959,0.77853469 -2,1,7.500865272,0.426458783,0.77853469 -2,1,7.534510799,0.426385957,0.77853469 -2,1,7.541241633,0.426371389,0.77853469 -2,1,7.58833327,0.426268826,0.77853469 -2,1,7.675676842,0.426077456,0.77853469 -2,1,7.803070431,0.425795302,0.77853469 -2,1,7.970219531,0.425420049,0.77853469 -2,1,8.176737731,0.424948854,0.77853469 -2,1,8.422147605,0.424379028,0.77853469 -2,1,8.70588182,0.423707714,0.77853469 -2,1,9.027284445,0.422932811,0.77853469 -2,1,9.385612468,0.422052556,0.77853469 -2,1,9.780037514,0.421065815,0.77853469 -2,1,10.20964776,0.419972455,0.77853469 -2,1,10.67345004,0.419400676,0.781531069 -2,1,10.86770694,0.418981957,0.758935311 -2,1,11.17037214,0.385839135,0.614478855 -2,1,11.6992653,0.335840083,0.498687801 -2,1,12.25890683,0.29191329,0.416354609 -2,1,12.84800295,0.253572514,0.351944846 -2,1,13.46519181,0.220278082,0.299832337 -2,1,14.10904661,0.191477908,0.256956606 -2,1,14.77807889,0.166631343,0.221322169 -2,1,15.470742,0.145236797,0.19150758 -2,1,16.18543466,0.126834289,0.166435523 -2,1,16.92050464,0.111011925,0.145263684 -2,1,17.67425264,0.097406118,0.127319849 -2,1,18.44493615,0.085699408,0.11206048 -2,1,19.23077353,0.075616912,0.099042189 -2,1,20.02994808,0.066922115,0.087901155 -2,1,20.8406123,0.059412477,0.078337446 -2,1,21.66089211,0.052915227,0.07010295 -2,1,22.4888912,0.04728299,0.062991402 -2,1,23.32269542,0.042390922,0.056831647 -2,1,24.1603772,0.038132739,0.05148062 -2,1,25,0.03441828,0.046818787 +2,1,2.9,0,0 +2,1,3,42.733312,0.80742173 +2,1,3.54953237,292.585981,0.784655297 +2,1,4.067900771,607.966543,0.781771245 +2,1,4.553906848,981.097693,0.785377072 +2,1,5.006427063,1401.98084,0.788045584 +2,1,5.424415288,1858.67086,0.789922119 +2,1,5.806905228,2337.575997,0.790464625 +2,1,6.153012649,2824.097302,0.789868339 +2,1,6.461937428,3303.06456,0.788727582 +2,1,6.732965398,3759.432328,0.787359348 +2,1,6.965470002,4178.637714,0.785895402 +2,1,7.158913742,4547.19121,0.778275899 +2,1,7.312849418,4855.342682,0.778275899 +2,1,7.426921164,5091.537139,0.778275899 +2,1,7.500865272,5248.453137,0.778275899 +2,1,7.534510799,5320.793207,0.778275899 +2,1,7.541241633,5335.345498,0.778275899 +2,1,7.58833327,5437.90563,0.778275899 +2,1,7.675676842,5631.253025,0.778275899 +2,1,7.803070431,5920.980626,0.778275899 +2,1,7.970219531,6315.115602,0.778275899 +2,1,8.176737731,6824.470067,0.778275899 +2,1,8.422147605,7462.846389,0.778275899 +2,1,8.70588182,8238.359448,0.778275899 +2,1,9.027284445,9167.96703,0.778275899 +2,1,9.385612468,10285.211,0.778275899 +2,1,9.780037514,11617.23699,0.778275899 +2,1,10.20964776,13194.41511,0.778275899 +2,1,10.67345004,15000,0.77176172 +2,1,10.86770694,15000,0.747149663 +2,1,11.17037214,15000,0.562338457 +2,1,11.6992653,15000,0.463477777 +2,1,12.25890683,15000,0.389083718 +2,1,12.84800295,15000,0.329822385 +2,1,13.46519181,15000,0.281465071 +2,1,14.10904661,15000,0.241494345 +2,1,14.77807889,15000,0.208180574 +2,1,15.470742,15000,0.180257568 +2,1,16.18543466,15000,0.156747535 +2,1,16.92050464,15000,0.136877529 +2,1,17.67425264,15000,0.120026379 +2,1,18.44493615,15000,0.105689427 +2,1,19.23077353,15000,0.093453742 +2,1,20.02994808,15000,0.082979637 +2,1,20.8406123,15000,0.073986457 +2,1,21.66089211,15000,0.066241166 +2,1,22.4888912,15000,0.059552107 +2,1,23.32269542,15000,0.053756866 +2,1,24.1603772,15000,0.048721662 +2,1,25,15000,0.044334197 2,1,25.02,0,0 2,1,50,0,0 2,5,0,0,0 -2,5,3,0.024680618,0.40876666 -2,5,3.54953237,0.112162126,0.396057646 -2,5,4.067900771,0.156108209,0.39320095 -2,5,4.553906848,0.180049935,0.394449372 -2,5,5.006427063,0.19380602,0.395387288 -2,5,5.424415288,0.202005082,0.396043345 -2,5,5.806905228,0.206989662,0.395929045 -2,5,6.153012649,0.210041846,0.39519265 -2,5,6.461937428,0.211893882,0.394126518 -2,5,6.732965398,0.212988948,0.392922592 -2,5,6.965470002,0.213596636,0.391683582 -2,5,7.158913742,0.213591753,0.389267345 -2,5,7.312849418,0.213430464,0.389267345 -2,5,7.426921164,0.21330898,0.389267345 -2,5,7.500865272,0.213229392,0.389267345 -2,5,7.534510799,0.213192979,0.389267345 -2,5,7.541241633,0.213185695,0.389267345 -2,5,7.58833327,0.213134413,0.389267345 -2,5,7.675676842,0.213038728,0.389267345 -2,5,7.803070431,0.212897651,0.389267345 -2,5,7.970219531,0.212710025,0.389267345 -2,5,8.176737731,0.212474427,0.389267345 -2,5,8.422147605,0.212189514,0.389267345 -2,5,8.70588182,0.211853857,0.389267345 -2,5,9.027284445,0.211466406,0.389267345 -2,5,9.385612468,0.211026278,0.389267345 -2,5,9.780037514,0.210532908,0.389267345 -2,5,10.20964776,0.209986228,0.389267345 -2,5,10.67345004,0.209700338,0.390765535 -2,5,10.86770694,0.209490979,0.379467656 -2,5,11.17037214,0.192919568,0.307239428 -2,5,11.6992653,0.167920042,0.249343901 -2,5,12.25890683,0.145956645,0.208177305 -2,5,12.84800295,0.126786257,0.175972423 -2,5,13.46519181,0.110139041,0.149916169 -2,5,14.10904661,0.095738954,0.128478303 -2,5,14.77807889,0.083315672,0.110661085 -2,5,15.470742,0.072618399,0.09575379 -2,5,16.18543466,0.063417145,0.083217762 -2,5,16.92050464,0.055505963,0.072631842 -2,5,17.67425264,0.048703059,0.063659925 -2,5,18.44493615,0.042849704,0.05603024 -2,5,19.23077353,0.037808456,0.049521095 -2,5,20.02994808,0.033461058,0.043950578 -2,5,20.8406123,0.029706239,0.039168723 -2,5,21.66089211,0.026457614,0.035051475 -2,5,22.4888912,0.023641495,0.031495701 -2,5,23.32269542,0.021195461,0.028415824 -2,5,24.1603772,0.01906637,0.02574031 -2,5,25,0.01720914,0.023409394 +2,5,2.9,0,0 +2,5,3,21.366656,0.403710865 +2,5,3.54953237,146.2929905,0.392327649 +2,5,4.067900771,303.9832715,0.390885623 +2,5,4.553906848,490.5488465,0.392688536 +2,5,5.006427063,700.99042,0.394022792 +2,5,5.424415288,929.33543,0.39496106 +2,5,5.806905228,1168.787999,0.395232313 +2,5,6.153012649,1412.048651,0.39493417 +2,5,6.461937428,1651.53228,0.394363791 +2,5,6.732965398,1879.716164,0.393679674 +2,5,6.965470002,2089.318857,0.392947701 +2,5,7.158913742,2273.595605,0.38913795 +2,5,7.312849418,2427.671341,0.38913795 +2,5,7.426921164,2545.76857,0.38913795 +2,5,7.500865272,2624.226569,0.38913795 +2,5,7.534510799,2660.396604,0.38913795 +2,5,7.541241633,2667.672749,0.38913795 +2,5,7.58833327,2718.952815,0.38913795 +2,5,7.675676842,2815.626513,0.38913795 +2,5,7.803070431,2960.490313,0.38913795 +2,5,7.970219531,3157.557801,0.38913795 +2,5,8.176737731,3412.235034,0.38913795 +2,5,8.422147605,3731.423195,0.38913795 +2,5,8.70588182,4119.179724,0.38913795 +2,5,9.027284445,4583.983515,0.38913795 +2,5,9.385612468,5142.6055,0.38913795 +2,5,9.780037514,5808.618495,0.38913795 +2,5,10.20964776,6597.207555,0.38913795 +2,5,10.67345004,7500,0.38588086 +2,5,10.86770694,7500,0.373574832 +2,5,11.17037214,7500,0.281169229 +2,5,11.6992653,7500,0.231738889 +2,5,12.25890683,7500,0.194541859 +2,5,12.84800295,7500,0.164911193 +2,5,13.46519181,7500,0.140732536 +2,5,14.10904661,7500,0.120747173 +2,5,14.77807889,7500,0.104090287 +2,5,15.470742,7500,0.090128784 +2,5,16.18543466,7500,0.078373768 +2,5,16.92050464,7500,0.068438765 +2,5,17.67425264,7500,0.06001319 +2,5,18.44493615,7500,0.052844714 +2,5,19.23077353,7500,0.046726871 +2,5,20.02994808,7500,0.041489819 +2,5,20.8406123,7500,0.036993229 +2,5,21.66089211,7500,0.033120583 +2,5,22.4888912,7500,0.029776054 +2,5,23.32269542,7500,0.026878433 +2,5,24.1603772,7500,0.024360831 +2,5,25,7500,0.022167099 2,5,25.02,0,0 2,5,50,0,0 4,1,0,0,0 -4,1,3,0.012340309,0.20438333 -4,1,3.54953237,0.056081063,0.198028823 -4,1,4.067900771,0.078054105,0.196600475 -4,1,4.553906848,0.090024968,0.197224686 -4,1,5.006427063,0.09690301,0.197693644 -4,1,5.424415288,0.101002541,0.198021673 -4,1,5.806905228,0.103494831,0.197964523 -4,1,6.153012649,0.105020923,0.197596325 -4,1,6.461937428,0.105946941,0.197063259 -4,1,6.732965398,0.106494474,0.196461296 -4,1,6.965470002,0.106798318,0.195841791 -4,1,7.158913742,0.106795876,0.194633673 -4,1,7.312849418,0.106715232,0.194633673 -4,1,7.426921164,0.10665449,0.194633673 -4,1,7.500865272,0.106614696,0.194633673 -4,1,7.534510799,0.106596489,0.194633673 -4,1,7.541241633,0.106592847,0.194633673 -4,1,7.58833327,0.106567207,0.194633673 -4,1,7.675676842,0.106519364,0.194633673 -4,1,7.803070431,0.106448826,0.194633673 -4,1,7.970219531,0.106355012,0.194633673 -4,1,8.176737731,0.106237214,0.194633673 -4,1,8.422147605,0.106094757,0.194633673 -4,1,8.70588182,0.105926929,0.194633673 -4,1,9.027284445,0.105733203,0.194633673 -4,1,9.385612468,0.105513139,0.194633673 -4,1,9.780037514,0.105266454,0.194633673 -4,1,10.20964776,0.104993114,0.194633673 -4,1,10.67345004,0.104850169,0.195382767 -4,1,10.86770694,0.104745489,0.189733828 -4,1,11.17037214,0.096459784,0.153619714 -4,1,11.6992653,0.083960021,0.12467195 -4,1,12.25890683,0.072978323,0.104088652 -4,1,12.84800295,0.063393129,0.087986212 -4,1,13.46519181,0.055069521,0.074958084 -4,1,14.10904661,0.047869477,0.064239152 -4,1,14.77807889,0.041657836,0.055330542 -4,1,15.470742,0.036309199,0.047876895 -4,1,16.18543466,0.031708572,0.041608881 -4,1,16.92050464,0.027752981,0.036315921 -4,1,17.67425264,0.02435153,0.031829962 -4,1,18.44493615,0.021424852,0.02801512 -4,1,19.23077353,0.018904228,0.024760547 -4,1,20.02994808,0.016730529,0.021975289 -4,1,20.8406123,0.014853119,0.019584362 -4,1,21.66089211,0.013228807,0.017525738 -4,1,22.4888912,0.011820748,0.015747851 -4,1,23.32269542,0.010597731,0.014207912 -4,1,24.1603772,0.009533185,0.012870155 -4,1,25,0.00860457,0.011704697 +4,1,2.9,0,0 +4,1,3,10.683328,0.201855433 +4,1,3.54953237,73.14649525,0.196163824 +4,1,4.067900771,151.9916358,0.195442811 +4,1,4.553906848,245.2744233,0.196344268 +4,1,5.006427063,350.49521,0.197011396 +4,1,5.424415288,464.667715,0.19748053 +4,1,5.806905228,584.3939993,0.197616156 +4,1,6.153012649,706.0243255,0.197467085 +4,1,6.461937428,825.76614,0.197181896 +4,1,6.732965398,939.858082,0.196839837 +4,1,6.965470002,1044.659429,0.196473851 +4,1,7.158913742,1136.797803,0.194568975 +4,1,7.312849418,1213.835671,0.194568975 +4,1,7.426921164,1272.884285,0.194568975 +4,1,7.500865272,1312.113284,0.194568975 +4,1,7.534510799,1330.198302,0.194568975 +4,1,7.541241633,1333.836375,0.194568975 +4,1,7.58833327,1359.476408,0.194568975 +4,1,7.675676842,1407.813256,0.194568975 +4,1,7.803070431,1480.245157,0.194568975 +4,1,7.970219531,1578.778901,0.194568975 +4,1,8.176737731,1706.117517,0.194568975 +4,1,8.422147605,1865.711597,0.194568975 +4,1,8.70588182,2059.589862,0.194568975 +4,1,9.027284445,2291.991758,0.194568975 +4,1,9.385612468,2571.30275,0.194568975 +4,1,9.780037514,2904.309248,0.194568975 +4,1,10.20964776,3298.603778,0.194568975 +4,1,10.67345004,3750,0.19294043 +4,1,10.86770694,3750,0.186787416 +4,1,11.17037214,3750,0.140584614 +4,1,11.6992653,3750,0.115869444 +4,1,12.25890683,3750,0.09727093 +4,1,12.84800295,3750,0.082455596 +4,1,13.46519181,3750,0.070366268 +4,1,14.10904661,3750,0.060373586 +4,1,14.77807889,3750,0.052045144 +4,1,15.470742,3750,0.045064392 +4,1,16.18543466,3750,0.039186884 +4,1,16.92050464,3750,0.034219382 +4,1,17.67425264,3750,0.030006595 +4,1,18.44493615,3750,0.026422357 +4,1,19.23077353,3750,0.023363436 +4,1,20.02994808,3750,0.020744909 +4,1,20.8406123,3750,0.018496614 +4,1,21.66089211,3750,0.016560292 +4,1,22.4888912,3750,0.014888027 +4,1,23.32269542,3750,0.013439217 +4,1,24.1603772,3750,0.012180416 +4,1,25,3750,0.011083549 4,1,25.02,0,0 4,1,50,0,0 4,5,0,0,0 -4,5,3,0.006170155,0.102191665 -4,5,3.54953237,0.028040532,0.099014412 -4,5,4.067900771,0.039027052,0.098300238 -4,5,4.553906848,0.045012484,0.098612343 -4,5,5.006427063,0.048451505,0.098846822 -4,5,5.424415288,0.050501271,0.099010836 -4,5,5.806905228,0.051747416,0.098982261 -4,5,6.153012649,0.052510462,0.098798163 -4,5,6.461937428,0.052973471,0.09853163 -4,5,6.732965398,0.053247237,0.098230648 -4,5,6.965470002,0.053399159,0.097920896 -4,5,7.158913742,0.053397938,0.097316836 -4,5,7.312849418,0.053357616,0.097316836 -4,5,7.426921164,0.053327245,0.097316836 -4,5,7.500865272,0.053307348,0.097316836 -4,5,7.534510799,0.053298245,0.097316836 -4,5,7.541241633,0.053296424,0.097316836 -4,5,7.58833327,0.053283603,0.097316836 -4,5,7.675676842,0.053259682,0.097316836 -4,5,7.803070431,0.053224413,0.097316836 -4,5,7.970219531,0.053177506,0.097316836 -4,5,8.176737731,0.053118607,0.097316836 -4,5,8.422147605,0.053047379,0.097316836 -4,5,8.70588182,0.052963464,0.097316836 -4,5,9.027284445,0.052866602,0.097316836 -4,5,9.385612468,0.05275657,0.097316836 -4,5,9.780037514,0.052633227,0.097316836 -4,5,10.20964776,0.052496557,0.097316836 -4,5,10.67345004,0.052425085,0.097691384 -4,5,10.86770694,0.052372745,0.094866914 -4,5,11.17037214,0.048229892,0.076809857 -4,5,11.6992653,0.041980011,0.062335975 -4,5,12.25890683,0.036489161,0.052044326 -4,5,12.84800295,0.031696564,0.043993106 -4,5,13.46519181,0.02753476,0.037479042 -4,5,14.10904661,0.023934739,0.032119576 -4,5,14.77807889,0.020828918,0.027665271 -4,5,15.470742,0.0181546,0.023938448 -4,5,16.18543466,0.015854286,0.020804441 -4,5,16.92050464,0.013876491,0.018157961 -4,5,17.67425264,0.012175765,0.015914981 -4,5,18.44493615,0.010712426,0.01400756 -4,5,19.23077353,0.009452114,0.012380274 -4,5,20.02994808,0.008365265,0.010987645 -4,5,20.8406123,0.00742656,0.009792181 -4,5,21.66089211,0.006614404,0.008762869 -4,5,22.4888912,0.005910374,0.007873925 -4,5,23.32269542,0.005298865,0.007103956 -4,5,24.1603772,0.004766593,0.006435078 -4,5,25,0.004302285,0.005852349 +4,5,2.9,0,0 +4,5,3,5.341664,0.100927716 +4,5,3.54953237,36.57324763,0.098081912 +4,5,4.067900771,75.99581788,0.097721406 +4,5,4.553906848,122.6372116,0.098172134 +4,5,5.006427063,175.247605,0.098505698 +4,5,5.424415288,232.3338575,0.098740265 +4,5,5.806905228,292.1969996,0.098808078 +4,5,6.153012649,353.0121628,0.098733542 +4,5,6.461937428,412.88307,0.098590948 +4,5,6.732965398,469.929041,0.098419919 +4,5,6.965470002,522.3297143,0.098236925 +4,5,7.158913742,568.3989013,0.097284487 +4,5,7.312849418,606.9178353,0.097284487 +4,5,7.426921164,636.4421424,0.097284487 +4,5,7.500865272,656.0566421,0.097284487 +4,5,7.534510799,665.0991509,0.097284487 +4,5,7.541241633,666.9181873,0.097284487 +4,5,7.58833327,679.7382038,0.097284487 +4,5,7.675676842,703.9066281,0.097284487 +4,5,7.803070431,740.1225783,0.097284487 +4,5,7.970219531,789.3894503,0.097284487 +4,5,8.176737731,853.0587584,0.097284487 +4,5,8.422147605,932.8557986,0.097284487 +4,5,8.70588182,1029.794931,0.097284487 +4,5,9.027284445,1145.995879,0.097284487 +4,5,9.385612468,1285.651375,0.097284487 +4,5,9.780037514,1452.154624,0.097284487 +4,5,10.20964776,1649.301889,0.097284487 +4,5,10.67345004,1875,0.096470215 +4,5,10.86770694,1875,0.093393708 +4,5,11.17037214,1875,0.070292307 +4,5,11.6992653,1875,0.057934722 +4,5,12.25890683,1875,0.048635465 +4,5,12.84800295,1875,0.041227798 +4,5,13.46519181,1875,0.035183134 +4,5,14.10904661,1875,0.030186793 +4,5,14.77807889,1875,0.026022572 +4,5,15.470742,1875,0.022532196 +4,5,16.18543466,1875,0.019593442 +4,5,16.92050464,1875,0.017109691 +4,5,17.67425264,1875,0.015003297 +4,5,18.44493615,1875,0.013211178 +4,5,19.23077353,1875,0.011681718 +4,5,20.02994808,1875,0.010372455 +4,5,20.8406123,1875,0.009248307 +4,5,21.66089211,1875,0.008280146 +4,5,22.4888912,1875,0.007444013 +4,5,23.32269542,1875,0.006719608 +4,5,24.1603772,1875,0.006090208 +4,5,25,1875,0.005541775 4,5,25.02,0,0 4,5,50,0,0 diff --git a/floris/turbine_library/iea_15MW_multi_dim_cp_ct.yaml b/floris/turbine_library/iea_15MW_multi_dim_cp_ct.yaml index d01e52633..b08b348de 100644 --- a/floris/turbine_library/iea_15MW_multi_dim_cp_ct.yaml +++ b/floris/turbine_library/iea_15MW_multi_dim_cp_ct.yaml @@ -1,11 +1,11 @@ turbine_type: 'iea_15MW_multi_dim_cp_ct' -generator_efficiency: 1.0 hub_height: 150.0 -pP: 1.88 -pT: 1.88 rotor_diameter: 242.24 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 6.0 multi_dimensional_cp_ct: True -power_thrust_data_file: 'iea_15MW_multi_dim_Tp_Hs.csv' +power_thrust_table: + ref_air_density: 1.225 + ref_tilt: 6.0 + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 + power_thrust_data_file: 'iea_15MW_multi_dim_Tp_Hs.csv' diff --git a/floris/turbine_library/nrel_5MW.yaml b/floris/turbine_library/nrel_5MW.yaml index 653ef14c7..228abd219 100644 --- a/floris/turbine_library/nrel_5MW.yaml +++ b/floris/turbine_library/nrel_5MW.yaml @@ -1,3 +1,8 @@ +# NREL 5MW reference wind turbine. +# Data based on: +# https://github.com/NREL/turbine-models/blob/master/Offshore/NREL_5MW_126_RWT_corrected.csv +# Note: Small power variations above rated removed. Rotor diameter includes coning angle. +# Note: generator efficiency of 94.4% is assumed for the NREL 5MW turbine. ### # An ID for this type of turbine definition. @@ -5,198 +10,216 @@ # match the root name of the file. turbine_type: 'nrel_5MW' -### -# Setting for generator losses to power. -generator_efficiency: 1.0 - ### # Hub height. hub_height: 90.0 -### -# Cosine exponent for power loss due to yaw misalignment. -pP: 1.88 - -### -# Cosine exponent for power loss due to tilt. -pT: 1.88 - ### # Rotor diameter. -rotor_diameter: 126.0 +rotor_diameter: 125.88 ### # Tip speed ratio defined as linear blade tip speed normalized by the incoming wind speed. TSR: 8.0 ### -# The air density at which the Cp and Ct curves are defined. -ref_density_cp_ct: 1.225 +# Model for power and thrust curve interpretation. +operation_model: 'cosine-loss' ### -# The tilt angle at which the Cp and Ct curves are defined. This is used to capture -# the effects of a floating platform on a turbine's power and wake. -ref_tilt_cp_ct: 5.0 - -### -# Cp and Ct as a function of wind speed for the turbine's full range of operating conditions. +# Parameters needed to evaluate the power and thrust produced by the turbine. power_thrust_table: - power: - - 0.0 - - 0.000000 - - 0.000000 - - 0.178085 - - 0.289075 - - 0.349022 - - 0.384728 - - 0.406059 - - 0.420228 - - 0.428823 - - 0.433873 - - 0.436223 - - 0.436845 - - 0.436575 - - 0.436511 - - 0.436561 - - 0.436517 - - 0.435903 - - 0.434673 - - 0.433230 - - 0.430466 - - 0.378869 - - 0.335199 - - 0.297991 - - 0.266092 - - 0.238588 - - 0.214748 - - 0.193981 - - 0.175808 - - 0.159835 - - 0.145741 - - 0.133256 - - 0.122157 - - 0.112257 - - 0.103399 - - 0.095449 - - 0.088294 - - 0.081836 - - 0.075993 - - 0.070692 - - 0.065875 - - 0.061484 - - 0.057476 - - 0.053809 - - 0.050447 - - 0.047358 - - 0.044518 - - 0.041900 - - 0.039483 - - 0.0 - - 0.0 - thrust: - - 0.0 - - 0.0 - - 0.0 - - 0.99 - - 0.99 - - 0.97373036 - - 0.92826162 - - 0.89210543 - - 0.86100905 - - 0.835423 - - 0.81237673 - - 0.79225789 - - 0.77584769 - - 0.7629228 - - 0.76156073 - - 0.76261984 - - 0.76169723 - - 0.75232027 - - 0.74026851 - - 0.72987175 - - 0.70701647 - - 0.54054532 - - 0.45509459 - - 0.39343381 - - 0.34250785 - - 0.30487242 - - 0.27164979 - - 0.24361964 - - 0.21973831 - - 0.19918151 - - 0.18131868 - - 0.16537679 - - 0.15103727 - - 0.13998636 - - 0.1289037 - - 0.11970413 - - 0.11087113 - - 0.10339901 - - 0.09617888 - - 0.09009926 - - 0.08395078 - - 0.0791188 - - 0.07448356 - - 0.07050731 - - 0.06684119 - - 0.06345518 - - 0.06032267 - - 0.05741999 - - 0.05472609 - - 0.0 - - 0.0 + ### Power thrust table parameters + # The air density at which the power and thrust_coefficient curves are defined. + ref_air_density: 1.225 + ### + # The tilt angle at which the Cp and Ct curves are defined. This is used to capture + # the effects of a floating platform on a turbine's power and wake. + ref_tilt: 5.0 + ### + # Cosine exponent for power loss due to tilt. + cosine_loss_exponent_tilt: 1.88 + ### + # Cosine exponent for power loss due to yaw misalignment. + cosine_loss_exponent_yaw: 1.88 + ### + # Helix parameters + helix_a: 1.802 + helix_power_b: 4.568e-03 + helix_power_c: 1.629e-10 + helix_thrust_b: 1.027e-03 + helix_thrust_c: 1.378e-06 + ### Power thrust table data + # wind speeds for look-up tables of power and thrust_coefficient wind_speed: - 0.0 - - 2.0 - - 2.5 + - 2.9 - 3.0 - - 3.5 - 4.0 - - 4.5 - 5.0 - - 5.5 - 6.0 - - 6.5 - 7.0 + - 7.1 + - 7.2 + - 7.3 + - 7.4 - 7.5 + - 7.6 + - 7.7 + - 7.8 + - 7.9 - 8.0 - - 8.5 - 9.0 - - 9.5 - 10.0 + - 10.1 + - 10.2 + - 10.3 + - 10.4 - 10.5 + - 10.6 + - 10.7 + - 10.8 + - 10.9 - 11.0 + - 11.1 + - 11.2 + - 11.3 + - 11.4 - 11.5 + - 11.6 + - 11.7 + - 11.8 + - 11.9 - 12.0 - - 12.5 - 13.0 - - 13.5 - 14.0 - - 14.5 - 15.0 - - 15.5 - 16.0 - - 16.5 - 17.0 - - 17.5 - 18.0 - - 18.5 - 19.0 - - 19.5 - 20.0 - - 20.5 - 21.0 - - 21.5 - 22.0 - - 22.5 - 23.0 - - 23.5 - 24.0 - - 24.5 - 25.0 - - 25.01 - - 25.02 + - 25.1 - 50.0 + ### + # power values (specified in kW) for lookup by wind speed + power: + - 0.0 + - 0.0 + - 40.518011517569214 + - 177.67162506419703 + - 403.900880943964 + - 737.5889584824021 + - 1187.1774030611875 + - 1239.245945375778 + - 1292.5184293723503 + - 1347.3213147477102 + - 1403.2573725578948 + - 1460.7011898730707 + - 1519.6419125979983 + - 1580.174365096404 + - 1642.1103166918167 + - 1705.758292831 + - 1771.1659528893977 + - 2518.553107505315 + - 3448.381605840943 + - 3552.140809000129 + - 3657.9545431794127 + - 3765.121299313842 + - 3873.928844315059 + - 3984.4800226955504 + - 4096.582833096852 + - 4210.721306623712 + - 4326.154305853405 + - 4443.395565353604 + - 4562.497934188341 + - 4683.419890251577 + - 4806.164748311019 + - 4929.931918769215 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 0.0 + - 0.0 + ### + # thrust coefficient values (unitless) for lookup by wind speed + thrust_coefficient: + - 0.0 + - 0.0 + - 1.132034888 + - 0.999470963 + - 0.917697381 + - 0.860849503 + - 0.815371198 + - 0.811614904 + - 0.807939328 + - 0.80443352 + - 0.800993851 + - 0.79768116 + - 0.794529244 + - 0.791495834 + - 0.788560434 + - 0.787217182 + - 0.787127977 + - 0.785839257 + - 0.783812219 + - 0.783568108 + - 0.783328285 + - 0.781194418 + - 0.777292539 + - 0.773464375 + - 0.769690236 + - 0.766001924 + - 0.762348072 + - 0.758760824 + - 0.755242872 + - 0.751792927 + - 0.748434131 + - 0.745113997 + - 0.717806682 + - 0.672204789 + - 0.63831272 + - 0.610176496 + - 0.585456847 + - 0.563222111 + - 0.542912273 + - 0.399312061 + - 0.310517829 + - 0.248633226 + - 0.203543725 + - 0.169616419 + - 0.143478955 + - 0.122938861 + - 0.106515296 + - 0.093026095 + - 0.081648606 + - 0.072197368 + - 0.064388275 + - 0.057782745 + - 0.0 + - 0.0 ### # A boolean flag used when the user wants FLORIS to use the user-supplied multi-dimensional diff --git a/floris/turbine_library/turbine_previewer.py b/floris/turbine_library/turbine_previewer.py index bb1ab0cd7..17d33d1d0 100644 --- a/floris/turbine_library/turbine_previewer.py +++ b/floris/turbine_library/turbine_previewer.py @@ -1,16 +1,3 @@ -# Copyright 2023 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from __future__ import annotations @@ -21,18 +8,12 @@ import numpy as np from attrs import define, field -from floris.simulation.turbine import ( - Ct, +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT +from floris.core.turbine.turbine import ( power, + thrust_coefficient, Turbine, ) -from floris.simulation.turbine_multi_dim import ( - Ct_multidim, - multidim_Ct_down_select, - multidim_power_down_select, - power_multidim, - TurbineMultiDimensional, -) from floris.type_dec import convert_to_path, NDArrayFloat from floris.utilities import ( load_yaml, @@ -47,9 +28,7 @@ @define(auto_attribs=True) class TurbineInterface: - turbine: Turbine | TurbineMultiDimensional = field( - validator=attrs.validators.instance_of((Turbine, TurbineMultiDimensional)) - ) + turbine: Turbine = field(validator=attrs.validators.instance_of(Turbine)) @classmethod def from_library(cls, library_path: str | Path, file_name: str): @@ -72,9 +51,6 @@ def from_library(cls, library_path: str | Path, file_name: str): # Add in the library specification if needed, and load from dict turb_dict = load_yaml(library_path / file_name) - if turb_dict.get("multi_dimensional_cp_ct", False): - turb_dict.setdefault("turbine_library_path", library_path) - return cls(turbine=TurbineMultiDimensional.from_dict(turb_dict)) return cls(turbine=Turbine.from_dict(turb_dict)) @classmethod @@ -92,9 +68,6 @@ def from_yaml(cls, file_path: str | Path): # Add in the library specification if needed, and load from dict turb_dict = load_yaml(file_path) - if turb_dict.get("multi_dimensional_cp_ct", False): - turb_dict.setdefault("turbine_library_path", file_path.parent) - return cls(turbine=TurbineMultiDimensional.from_dict(turb_dict)) return cls(turbine=Turbine.from_dict(turb_dict)) @classmethod @@ -108,11 +81,9 @@ def from_turbine_dict(cls, config_dict: dict): Returns: (`TurbineInterface`): Returns a ``TurbineInterface`` object. """ - if config_dict.get("multi_dimensional_cp_ct", False): - return cls(turbine=TurbineMultiDimensional.from_dict(config_dict)) return cls(turbine=Turbine.from_dict(config_dict)) - def power_curve( + def power_curve( self, wind_speeds: NDArrayFloat = DEFAULT_WIND_SPEEDS, ) -> tuple[NDArrayFloat, NDArrayFloat] | tuple[NDArrayFloat, dict[tuple, NDArrayFloat]]: @@ -128,33 +99,43 @@ def power_curve( Returns the wind speed array and the power array, or the wind speed array and a dictionary of the multidimensional parameters and their associated power arrays. """ - shape = (1, wind_speeds.size, 1) + shape = (wind_speeds.size, 1) if self.turbine.multi_dimensional_cp_ct: - power_interps = { - k: multidim_power_down_select( - np.full(shape, self.turbine.power_interp), - dict(zip(self.turbine.condition_keys, k)), - ) - for k in self.turbine.power_interp - } power_mw = { - k: power_multidim( - ref_density_cp_ct=np.full(shape, self.turbine.ref_density_cp_ct), - rotor_effective_velocities=wind_speeds.reshape(shape), - power_interp=power_interps[k], + k: power( + velocities=wind_speeds.reshape(shape), + air_density=np.full(shape, v["ref_air_density"]), + power_functions={self.turbine.turbine_type: self.turbine.power_function}, + yaw_angles=np.zeros(shape), + tilt_angles=np.full(shape, v["ref_tilt"]), + power_setpoints=np.full(shape, POWER_SETPOINT_DEFAULT), + awc_modes=np.full(shape, ["baseline"]), + awc_amplitudes=np.zeros(shape), + tilt_interps={self.turbine.turbine_type: self.turbine.tilt_interp}, + turbine_type_map=np.full(shape, self.turbine.turbine_type), + turbine_power_thrust_tables={self.turbine.turbine_type: v}, ).flatten() / 1e6 - for k in self.turbine.power_interp + for k,v in self.turbine.power_thrust_table.items() } else: power_mw = power( - ref_density_cp_ct=np.full(shape, self.turbine.ref_density_cp_ct), - rotor_effective_velocities=wind_speeds.reshape(shape), - power_interp={self.turbine.turbine_type: self.turbine.power_interp}, - turbine_type_map=np.full(shape, self.turbine.turbine_type) + velocities=wind_speeds.reshape(shape), + air_density=np.full(shape, self.turbine.power_thrust_table["ref_air_density"]), + power_functions={self.turbine.turbine_type: self.turbine.power_function}, + yaw_angles=np.zeros(shape), + tilt_angles=np.full(shape, self.turbine.power_thrust_table["ref_tilt"]), + power_setpoints=np.full(shape, POWER_SETPOINT_DEFAULT), + awc_modes=np.full(shape, ["baseline"]), + awc_amplitudes=np.zeros(shape), + tilt_interps={self.turbine.turbine_type: self.turbine.tilt_interp}, + turbine_type_map=np.full(shape, self.turbine.turbine_type), + turbine_power_thrust_tables={ + self.turbine.turbine_type: self.turbine.power_thrust_table + }, ).flatten() / 1e6 return wind_speeds, power_mw - def Ct_curve( + def thrust_coefficient_curve( self, wind_speeds: NDArrayFloat = DEFAULT_WIND_SPEEDS, ) -> tuple[NDArrayFloat, NDArrayFloat]: @@ -169,39 +150,45 @@ def Ct_curve( tuple[NDArrayFloat, NDArrayFloat] Returns the wind speed array and the thrust coefficient array. """ - shape = (1, wind_speeds.size, 1) - shape_single = (1, 1, 1) + shape = (wind_speeds.size, 1) if self.turbine.multi_dimensional_cp_ct: - fCt_interps = { - k: multidim_Ct_down_select( - np.full(shape, self.turbine.fCt_interp), - dict(zip(self.turbine.condition_keys, k)), - ) - for k in self.turbine.fCt_interp - } ct_curve = { - k: Ct_multidim( + k: thrust_coefficient( velocities=wind_speeds.reshape(shape), - yaw_angle=np.zeros(shape), - tilt_angle=np.full(shape, self.turbine.ref_tilt_cp_ct), - ref_tilt_cp_ct=np.full(shape_single, self.turbine.ref_tilt_cp_ct), - fCt=fCt_interps[k], - tilt_interp={self.turbine.turbine_type: self.turbine.tilt_interp}, - correct_cp_ct_for_tilt=np.zeros(shape_single, dtype=bool), - turbine_type_map=np.full(shape_single, self.turbine.turbine_type) + air_density=np.full(shape, v["ref_air_density"]), + yaw_angles=np.zeros(shape), + tilt_angles=np.full(shape, v["ref_tilt"]), + power_setpoints=np.full(shape, POWER_SETPOINT_DEFAULT), + awc_modes=np.full(shape, ["baseline"]), + awc_amplitudes=np.zeros(shape), + thrust_coefficient_functions={ + self.turbine.turbine_type: self.turbine.thrust_coefficient_function + }, + tilt_interps={self.turbine.turbine_type: self.turbine.tilt_interp}, + correct_cp_ct_for_tilt=np.zeros(shape, dtype=bool), + turbine_type_map=np.full(shape, self.turbine.turbine_type), + turbine_power_thrust_tables={self.turbine.turbine_type: v}, ).flatten() - for k in self.turbine.fCt_interp + for k,v in self.turbine.power_thrust_table.items() } else: - ct_curve = Ct( + ct_curve = thrust_coefficient( velocities=wind_speeds.reshape(shape), - yaw_angle=np.zeros(shape), - tilt_angle=np.full(shape, self.turbine.ref_tilt_cp_ct), - ref_tilt_cp_ct=np.full(shape, self.turbine.ref_tilt_cp_ct), - fCt={self.turbine.turbine_type: self.turbine.fCt_interp}, - tilt_interp={self.turbine.turbine_type: self.turbine.tilt_interp}, + air_density=np.full(shape, self.turbine.power_thrust_table["ref_air_density"]), + yaw_angles=np.zeros(shape), + tilt_angles=np.full(shape, self.turbine.power_thrust_table["ref_tilt"]), + power_setpoints=np.full(shape, POWER_SETPOINT_DEFAULT), + awc_modes=np.full(shape, ["baseline"]), + awc_amplitudes=np.zeros(shape), + thrust_coefficient_functions={ + self.turbine.turbine_type: self.turbine.thrust_coefficient_function + }, + tilt_interps={self.turbine.turbine_type: self.turbine.tilt_interp}, correct_cp_ct_for_tilt=np.zeros(shape, dtype=bool), turbine_type_map=np.full(shape, self.turbine.turbine_type), + turbine_power_thrust_tables={ + self.turbine.turbine_type: self.turbine.power_thrust_table + }, ).flatten() return wind_speeds, ct_curve @@ -275,7 +262,7 @@ def plot_power_curve( fig.tight_layout() - def plot_Ct_curve( + def plot_thrust_coefficient_curve( self, wind_speeds: NDArrayFloat = DEFAULT_WIND_SPEEDS, fig_kwargs: dict | None = None, @@ -301,7 +288,7 @@ def plot_Ct_curve( None | tuple[plt.Figure, plt.Axes]: None, if :py:attr:`return_fig` is False, otherwise a tuple of the Figure and Axes objects are returned. """ - wind_speeds, thrust = self.Ct_curve(wind_speeds=wind_speeds) + wind_speeds, thrust = self.thrust_coefficient_curve(wind_speeds=wind_speeds) # Initialize kwargs if None fig_kwargs = {} if fig_kwargs is None else fig_kwargs @@ -348,8 +335,7 @@ def plot_Ct_curve( class TurbineLibrary: turbine_map: dict[str: TurbineInterface] = field(factory=dict) power_curves: dict[str, tuple[NDArrayFloat, NDArrayFloat]] = field(factory=dict) - Cp_curves: dict[str, tuple[NDArrayFloat, NDArrayFloat]] = field(factory=dict) - Ct_curves: dict[str, tuple[NDArrayFloat, NDArrayFloat]] = field(factory=dict) + thrust_coefficient_curves: dict[str, tuple[NDArrayFloat, NDArrayFloat]] = field(factory=dict) def load_internal_library(self, which: list[str] = [], exclude: list[str] = []) -> None: """Loads all of the turbine configurations from ``floris/floris/turbine_libary``, @@ -415,19 +401,19 @@ def compute_power_curves( name: t.power_curve(wind_speeds) for name, t in self.turbine_map.items() } - def compute_Ct_curves( + def compute_thrust_coefficient_curves( self, wind_speeds: NDArrayFloat = DEFAULT_WIND_SPEEDS, ) -> None: """Computes the thrust curves for each turbine in ``turbine_map`` and sets the - ``Ct_curves`` attribute. + ``thrust_coefficient_curves`` attribute. Args: wind_speeds (NDArrayFloat, optional): A 1-D array of wind speeds, in m/s. Defaults to 0 m/s -> 40 m/s, every 0.5 m/s. """ - self.Ct_curves = { - name: t.Ct_curve(wind_speeds) for name, t in self.turbine_map.items() + self.thrust_coefficient_curves = { + name: t.thrust_coefficient_curve(wind_speeds) for name, t in self.turbine_map.items() } def plot_power_curves( @@ -523,7 +509,7 @@ def plot_power_curves( if show: fig.tight_layout() - def plot_Ct_curves( + def plot_thrust_coefficient_curves( self, fig: plt.Figure | None = None, ax: plt.Axes | None = None, @@ -562,8 +548,8 @@ def plot_Ct_curves( None | tuple[plt.Figure, plt.Axes]: None, if :py:attr:`return_fig` is False, otherwise a tuple of the Figure and Axes objects are returned. """ - if self.Ct_curves == {} or wind_speeds is None: - self.compute_Ct_curves(wind_speeds=wind_speeds) + if self.thrust_coefficient_curves == {} or wind_speeds is None: + self.compute_thrust_coefficient_curves(wind_speeds=wind_speeds) which = [*self.turbine_map] if which == [] else which @@ -585,7 +571,7 @@ def plot_Ct_curves( min_windspeed = 0 max_windspeed = 0 max_thrust = 0 - for name, (ws, t) in self.Ct_curves.items(): + for name, (ws, t) in self.thrust_coefficient_curves.items(): if name in exclude or name not in which: continue if isinstance(t, dict): @@ -824,7 +810,7 @@ def plot_comparison( wind_speeds=wind_speeds, plot_kwargs=plot_kwargs, ) - self.plot_Ct_curves( + self.plot_thrust_coefficient_curves( fig, ax3, which=which, diff --git a/floris/turbine_library/turbine_utilities.py b/floris/turbine_library/turbine_utilities.py index c862c21bd..f5bee158d 100644 --- a/floris/turbine_library/turbine_utilities.py +++ b/floris/turbine_library/turbine_utilities.py @@ -1,21 +1,24 @@ -import os.path + +from __future__ import annotations + +from collections.abc import Iterable import numpy as np import yaml -def build_turbine_dict( +def build_cosine_loss_turbine_dict( turbine_data_dict, turbine_name, - file_path=None, - generator_efficiency=1.0, + file_name=None, + generator_efficiency=None, hub_height=90.0, - pP=1.88, - pT=1.88, - rotor_diameter=126.0, + cosine_loss_exponent_yaw=1.88, + cosine_loss_exponent_tilt=1.88, + rotor_diameter=125.88, TSR=8.0, - air_density=1.225, - ref_tilt_cp_ct=5.0 + ref_air_density=1.225, + ref_tilt=5.0 ): """ Tool for formatting a full turbine dict from data formatted as a @@ -31,31 +34,36 @@ def build_turbine_dict( turbine power and thrust as a function of wind speed. The following keys are possible: - wind_speed [m/s] - - power_absolute [kW] + - power [kW] - power_coefficient [-] - - thrust_absolute [kN] + - thrust [kN] - thrust_coefficient [-] - Of these, wind_speed is required. One of power_absolute and power_coefficient - must be specified; and one of thrust_absolute and thrust_coefficient must be - specified. If both _absolute and _coefficient versions are specified, the - _coefficient entry will be used and the _absolute entry ignored. + Of these, wind_speed is required. One of power and power_coefficient + must be specified; and one of thrust and thrust_coefficient must be + specified. If both (absolute) and _coefficient versions are specified, the + (absolute) power will be used along with the thrust_coefficient, with the + other entries ignored. Args: turbine_data_dict (dict): Dictionary containing performance of the wind turbine as a function of wind speed. Described in more detail above. turbine_name (string): Name of the turbine, which will be used for the turbine_type field as well as the filename. - file_path (): Path for placement of the produced yaml. Defaults to None, - in which case no yaml is written. - generator_efficiency (float): Generator efficiency [-]. Defaults to 1.0. + file_name (): Name for the produced yaml, including possibly path. + Defaults to None, in which case no yaml is written. + generator_efficiency (float): Generator efficiency [-]. Unused if power is specified + in absolute terms in the turbine_data_dict. Must be specified if + power not specified and power_coefficient specified instead. Defaults to None. hub_height (float): Hub height [m]. Defaults to 90.0. - pP (float): Cosine exponent for power loss to yaw [-]. Defaults to 1.88. - pT (float): Cosine exponent for thrust loss to yaw [-]. Defaults to 1.88. + cosine_loss_exponent_yaw (float): Cosine exponent for power loss to yaw [-]. + Defaults to 1.88. + cosine_loss_exponent_tilt (float): Cosine exponent for thrust loss to yaw [-]. + Defaults to 1.88. rotor_diameter (float). Rotor diameter [m]. Defaults to 126.0. TSR (float). Turbine optimal tip-speed ratio [-]. Defaults to 8.0. - air_density (float). Air density used to specify power and thrust + ref_air_density (float). Air density used to specify power and thrust curves [kg/m^3]. Defaults to 1.225. - ref_tilt_cp_ct (float). Rotor tilt (due to shaft tilt and/or platform + ref_tilt (float). Rotor tilt (due to shaft tilt and/or platform tilt) used when defining the power and thrust curves [deg]. Defaults to 5.0. @@ -70,49 +78,56 @@ def build_turbine_dict( A = np.pi * rotor_diameter**2/4 # Construct the Cp curve - if "power_coefficient" in turbine_data_dict: - if "power_absolute" in turbine_data_dict: + if "power" in turbine_data_dict: + if "power_coefficient" in turbine_data_dict: print( - "Found both power_absolute and power_coefficient." - "Ignoring power_absolute." + "Found both power and power_coefficient. " + "Ignoring power_coefficient." ) - Cp = np.array(turbine_data_dict["power_coefficient"]) + p = np.array(turbine_data_dict["power"]) - elif "power_absolute" in turbine_data_dict: - P = np.array(turbine_data_dict["power_absolute"]) - if _find_nearest_value_for_wind_speed(P, u, 10) > 20000 or \ - _find_nearest_value_for_wind_speed(P, u, 10) < 1000: + elif "power_coefficient" in turbine_data_dict: + if generator_efficiency is None: + raise KeyError( + "generator_efficiency must be specified to convert power_coefficient to power." + ) + Cp = np.array(turbine_data_dict["power_coefficient"]) + if _find_nearest_value_for_wind_speed(Cp, u, 10) > 16.0/27.0 or \ + _find_nearest_value_for_wind_speed(Cp, u, 10) < 0.0: print( - "Unusual power value detected. Please check that power_absolute", - "is specified in kW." + "Unusual power coefficient detected. Check that power coefficients" + "are physical." ) - validity_mask = (P != 0) | (u != 0) - Cp = np.zeros_like(P, dtype=float) + validity_mask = (Cp != 0) | (u != 0) + p = np.zeros_like(Cp, dtype=float) - Cp[validity_mask] = (P[validity_mask]*1000) / \ - (0.5*air_density*A*u[validity_mask]**3) + p[validity_mask] = ( + Cp[validity_mask] + * 0.5 * ref_air_density * A * generator_efficiency + * u[validity_mask]**3 / 1000 + ) else: raise KeyError( - "Either power_absolute or power_coefficient must be specified." + "Either power or power_coefficient must be specified." ) # Construct Ct curve if "thrust_coefficient" in turbine_data_dict: - if "thrust_absolute" in turbine_data_dict: + if "thrust" in turbine_data_dict: print( - "Found both thrust_absolute and thrust_coefficient." - "Ignoring thrust_absolute." + "Found both thrust and thrust_coefficient. " + "Ignoring thrust." ) Ct = np.array(turbine_data_dict["thrust_coefficient"]) - elif "thrust_absolute" in turbine_data_dict: - T = np.array(turbine_data_dict["thrust_absolute"]) + elif "thrust" in turbine_data_dict: + T = np.array(turbine_data_dict["thrust"]) if _find_nearest_value_for_wind_speed(T, u, 10) > 3000 or \ _find_nearest_value_for_wind_speed(T, u, 10) < 100: print( - "Unusual thrust value detected. Please check that thrust_absolute", + "Unusual thrust value detected. Please check that thrust", "is specified in kN." ) @@ -120,43 +135,42 @@ def build_turbine_dict( Ct = np.zeros_like(T) Ct[validity_mask] = (T[validity_mask]*1000)/\ - (0.5*air_density*A*u[validity_mask]**2) + (0.5*ref_air_density*A*u[validity_mask]**2) else: raise KeyError( - "Either thrust_absolute or thrust_coefficient must be specified." + "Either thrust or thrust_coefficient must be specified." ) # Build the turbine dict power_thrust_dict = { + "ref_air_density": ref_air_density, + "ref_tilt": ref_tilt, + "cosine_loss_exponent_yaw": cosine_loss_exponent_yaw, + "cosine_loss_exponent_tilt": cosine_loss_exponent_tilt, "wind_speed": u.tolist(), - "power": Cp.tolist(), - "thrust": Ct.tolist() + "power": p.tolist(), + "thrust_coefficient": Ct.tolist() } turbine_dict = { "turbine_type": turbine_name, - "generator_efficiency": generator_efficiency, "hub_height": hub_height, - "pP": pP, - "pT": pT, "rotor_diameter": rotor_diameter, "TSR": TSR, - "ref_density_cp_ct": air_density, - "ref_tilt_cp_ct": ref_tilt_cp_ct, + "operation_model": "cosine-loss", "power_thrust_table": power_thrust_dict } # Create yaml file - if file_path is not None: - full_name = os.path.join(file_path, turbine_name+".yaml") + if file_name is not None: yaml.dump( turbine_dict, - open(full_name, "w"), + open(file_name, "w"), sort_keys=False ) - print(full_name, "created.") + print(file_name, "created.") return turbine_dict @@ -164,3 +178,23 @@ def _find_nearest_value_for_wind_speed(test_vals, ws_vals, ws): errs = np.absolute(ws_vals-ws) idx = errs.argmin() return test_vals[idx] + +def check_smooth_power_curve(power, tolerance=0.001): + """ + Check whether there are "wiggles" in the power signal. + """ + + if power[-1] < 0.95*max(power): # Cut-out or shutdown included + expected_changes = 2 + else: # Shutdown appears not to be included + expected_changes = 1 + + dirs = np.where( + np.abs(np.diff(power)) > tolerance, + np.sign(np.diff(power)), + np.zeros(len(power)-1) + ) + dir_changes = np.sum(np.abs(np.diff(dirs))) + is_smooth = dir_changes <= expected_changes + + return is_smooth diff --git a/floris/turbine_library/x_20MW.yaml b/floris/turbine_library/x_20MW.yaml deleted file mode 100644 index 79dcf0476..000000000 --- a/floris/turbine_library/x_20MW.yaml +++ /dev/null @@ -1,178 +0,0 @@ -turbine_type: 'x_20MW' -generator_efficiency: 1.0 -hub_height: 165.0 -pP: 1.88 -pT: 1.88 -rotor_diameter: 252.0 -TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 5.0 -power_thrust_table: - power: - - 0.000000 - - 0.000000 - - 0.074000 - - 0.325100 - - 0.376200 - - 0.402700 - - 0.415600 - - 0.423000 - - 0.427400 - - 0.429300 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429800 - - 0.429603 - - 0.354604 - - 0.316305 - - 0.281478 - - 0.250068 - - 0.221924 - - 0.196845 - - 0.174592 - - 0.154919 - - 0.137570 - - 0.122300 - - 0.108881 - - 0.097094 - - 0.086747 - - 0.077664 - - 0.069686 - - 0.062677 - - 0.056511 - - 0.051083 - - 0.046299 - - 0.043182 - - 0.033935 - - 0.000000 - - 0.000000 - thrust: - - 0.000000 - - 0.000000 - - 0.770100 - - 0.770100 - - 0.776300 - - 0.782400 - - 0.782000 - - 0.780200 - - 0.777200 - - 0.771900 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.776800 - - 0.767500 - - 0.765100 - - 0.758700 - - 0.505600 - - 0.431000 - - 0.370800 - - 0.320900 - - 0.278800 - - 0.243200 - - 0.212800 - - 0.186800 - - 0.164500 - - 0.145400 - - 0.128900 - - 0.114700 - - 0.102400 - - 0.091800 - - 0.082500 - - 0.074500 - - 0.067500 - - 0.061300 - - 0.055900 - - 0.051200 - - 0.047000 - - 0.000000 - - 0.000000 - wind_speed: - - 0.000000 - - 2.900000 - - 3.000000 - - 4.000000 - - 4.514700 - - 5.000800 - - 5.457400 - - 5.883300 - - 6.277700 - - 6.639700 - - 6.968400 - - 7.263200 - - 7.523400 - - 7.748400 - - 7.937700 - - 8.090900 - - 8.207700 - - 8.287700 - - 8.330800 - - 8.337000 - - 8.367800 - - 8.435600 - - 8.540100 - - 8.681200 - - 8.858500 - - 9.071700 - - 9.320200 - - 9.603500 - - 9.921000 - - 10.272000 - - 10.655700 - - 11.507700 - - 12.267700 - - 12.744100 - - 13.249400 - - 13.782400 - - 14.342000 - - 14.926900 - - 15.535900 - - 16.167500 - - 16.820400 - - 17.493200 - - 18.184200 - - 18.892100 - - 19.615200 - - 20.351900 - - 21.100600 - - 21.859600 - - 22.627300 - - 23.401900 - - 24.181700 - - 24.750000 - - 25.010000 - - 25.020000 - - 50.000000 diff --git a/floris/type_dec.py b/floris/type_dec.py index ebbb3178a..319a09917 100644 --- a/floris/type_dec.py +++ b/floris/type_dec.py @@ -1,16 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from __future__ import annotations @@ -40,22 +27,62 @@ NDArrayFilter = Union[npt.NDArray[np.int_], npt.NDArray[np.bool_]] NDArrayObject = npt.NDArray[np.object_] NDArrayBool = npt.NDArray[np.bool_] +NDArrayStr = npt.NDArray[np.str_] ### Custom callables for attrs objects and functions def floris_array_converter(data: Iterable) -> np.ndarray: + """ + For a given iterable, convert the data to a numpy array and cast to `floris_float_type`. + If the input is a scalar, np.array() creates a 0-dimensional array, and this is not supported + in FLORIS so this function raises an error. + + Args: + data (Iterable): The input data to be converted to a Numpy array. + + Raises: + TypeError: Raises if the input data is not iterable. + TypeError: Raises if the input data cannot be converted to a Numpy array. + + Returns: + np.ndarray: data converted to a Numpy array and cast to `floris_float_type`. + """ try: - a = np.array(data, dtype=floris_float_type) + iter(data) except TypeError as e: raise TypeError(e.args[0] + f". Data given: {data}") - return a -def floris_numeric_dict_converter(data: dict) -> dict: try: - return {k: floris_array_converter(v) for k, v in data.items()} - except TypeError as e: + a = np.array(data, dtype=floris_float_type) + except (TypeError, ValueError) as e: raise TypeError(e.args[0] + f". Data given: {data}") + return a + +def floris_numeric_dict_converter(data: dict) -> dict: + """ + For the given dictionary, convert all the values to a numeric type. If a value is a scalar, it + will be converted to a float. If a value is an iterable, it will be converted to a Numpy + array and cast to `floris_float_type`. If a value is not a numeric type, a TypeError will be + raised. + + Args: + data (dict): Dictionary of data to be converted to a numeric type. + + Returns: + dict: Dictionary with the same keys and all values converted to a numeric type. + """ + converted_dict = copy.deepcopy(data) # deepcopy -> data is a container and passed by reference + for k, v in data.items(): + try: + iter(v) + except TypeError: + # Not iterable so try to cast to float + converted_dict[k] = float(v) + else: + # Iterable so convert to Numpy array + converted_dict[k] = floris_array_converter(v) + return converted_dict # def array_field(**kwargs) -> Callable: # """ diff --git a/floris/uncertain_floris_model.py b/floris/uncertain_floris_model.py new file mode 100644 index 000000000..ba62c4ba5 --- /dev/null +++ b/floris/uncertain_floris_model.py @@ -0,0 +1,907 @@ +from __future__ import annotations + +from pathlib import Path + +import numpy as np + +from floris import FlorisModel +from floris.logging_manager import LoggingManager +from floris.type_dec import ( + floris_array_converter, + NDArrayBool, + NDArrayFloat, +) +from floris.utilities import wrap_180 +from floris.wind_data import ( + TimeSeries, + WindDataBase, + WindRose, + WindTIRose, +) + + +class UncertainFlorisModel(LoggingManager): + """ + An interface for handling uncertainty in wind farm simulations. + + This class contains a FlorisModel object and adds functionality to handle + uncertainty in wind direction. It is designed to be used similarly to FlorisModel. + In the model, the turbine powers are computed for a set of expanded wind conditions, + given by wd_sample_points, and then the powers are computed as a gaussian blend + of these expanded conditions. + + To reduce computational costs, the wind directions, wind speeds, turbulence intensities, + yaw angles, and power setpoints are rounded to specified resolutions. Only unique + conditions from within the expanded set of conditions are run. + + Args: + configuration (:py:obj:`dict`): The Floris configuration dictionary or YAML file. + The configuration should have the following inputs specified. + - **flow_field**: See `floris.simulation.flow_field.FlowField` for more details. + - **farm**: See `floris.simulation.farm.Farm` for more details. + - **turbine**: See `floris.simulation.turbine.Turbine` for more details. + - **wake**: See `floris.simulation.wake.WakeManager` for more details. + - **logging**: See `floris.simulation.core.Core` for more details. + wd_resolution (float, optional): The resolution of wind direction for generating + gaussian blends, in degrees. Defaults to 1.0. + ws_resolution (float, optional): The resolution of wind speed, in m/s. Defaults to 1.0. + ti_resolution (float, optional): The resolution of turbulence intensity. + Defaults to 0.01. + yaw_resolution (float, optional): The resolution of yaw angle, in degrees. + Defaults to 1.0. + power_setpoint_resolution (int, optional): The resolution of power setpoints, in kW. + Defaults to 100. + wd_std (float, optional): The standard deviation of wind direction. Defaults to 3.0. + wd_sample_points (list[float], optional): The sample points for wind direction. + If not provided, defaults to [-2 * wd_std, -1 * wd_std, 0, wd_std, 2 * wd_std]. + fix_yaw_to_nominal_direction (bool, optional): Fix the yaw angle to the nominal + direction? When False, the yaw misalignment is the same across the sampled wind + directions. When True, the turbine orientation is fixed to the nominal wind + direction such that the yaw misalignment changes depending on the sampled wind + direction. Defaults to False. + verbose (bool, optional): Verbosity flag for printing messages. Defaults to False. + """ + + def __init__( + self, + configuration: dict | str | Path, + wd_resolution=1.0, # Degree + ws_resolution=1.0, # m/s + ti_resolution=0.01, + yaw_resolution=1.0, # Degree + power_setpoint_resolution=100, # kW + awc_amplitude_resolution=0.1, # Deg + wd_std=3.0, + wd_sample_points=None, + fix_yaw_to_nominal_direction=False, + verbose=False, + ): + # Save these inputs + self.wd_resolution = wd_resolution + self.ws_resolution = ws_resolution + self.ti_resolution = ti_resolution + self.yaw_resolution = yaw_resolution + self.power_setpoint_resolution = power_setpoint_resolution + self.awc_amplitude_resolution = awc_amplitude_resolution + self.wd_std = wd_std + self.fix_yaw_to_nominal_direction = fix_yaw_to_nominal_direction + self.verbose = verbose + + # If wd_sample_points, default to 1 and 2 std + if wd_sample_points is None: + wd_sample_points = [-2 * wd_std, -1 * wd_std, 0, wd_std, 2 * wd_std] + + self.wd_sample_points = wd_sample_points + self.n_sample_points = len(self.wd_sample_points) + + # Get the weights + self.weights = self._get_weights(self.wd_std, self.wd_sample_points) + + # Instantiate the un-expanded FlorisModel + self.fmodel_unexpanded = FlorisModel(configuration) + + # Call set at this point with no arguments so ready to run + self.set() + + # Instantiate the expanded FlorisModel + # self.core_interface = FlorisModel(configuration) + + def set( + self, + **kwargs, + ): + """ + Set the wind farm conditions in the UncertainFlorisModel. + + See FlorisModel.set() for details of the contents of kwargs. + + Args: + **kwargs: The wind farm conditions to set. + """ + # Call the nominal set function + self.fmodel_unexpanded.set(**kwargs) + + self._set_uncertain() + + def _set_uncertain( + self, + ): + """ + Sets the underlying wind direction (wd), wind speed (ws), turbulence intensity (ti), + yaw angle, and power setpoint for unique conditions, accounting for uncertainties. + + """ + + # Grab the unexpanded values of all arrays + # These original dimensions are what is returned + self.wind_directions_unexpanded = self.fmodel_unexpanded.core.flow_field.wind_directions + self.wind_speeds_unexpanded = self.fmodel_unexpanded.core.flow_field.wind_speeds + self.turbulence_intensities_unexpanded = ( + self.fmodel_unexpanded.core.flow_field.turbulence_intensities + ) + self.yaw_angles_unexpanded = self.fmodel_unexpanded.core.farm.yaw_angles + self.power_setpoints_unexpanded = self.fmodel_unexpanded.core.farm.power_setpoints + self.awc_amplitudes_unexpanded = self.fmodel_unexpanded.core.farm.awc_amplitudes + self.n_unexpanded = len(self.wind_directions_unexpanded) + + # Combine into the complete unexpanded_inputs + self.unexpanded_inputs = np.hstack( + ( + self.wind_directions_unexpanded[:, np.newaxis], + self.wind_speeds_unexpanded[:, np.newaxis], + self.turbulence_intensities_unexpanded[:, np.newaxis], + self.yaw_angles_unexpanded, + self.power_setpoints_unexpanded, + self.awc_amplitudes_unexpanded, + ) + ) + + # Get the rounded inputs + self.rounded_inputs = self._get_rounded_inputs( + self.unexpanded_inputs, + self.wd_resolution, + self.ws_resolution, + self.ti_resolution, + self.yaw_resolution, + self.power_setpoint_resolution, + self.awc_amplitude_resolution, + ) + + # Get the expanded inputs + self._expanded_wind_directions = self._expand_wind_directions( + self.rounded_inputs, + self.wd_sample_points, + self.fix_yaw_to_nominal_direction, + self.fmodel_unexpanded.core.farm.n_turbines, + ) + self.n_expanded = self._expanded_wind_directions.shape[0] + + # Get the unique inputs + self.unique_inputs, self.map_to_expanded_inputs = self._get_unique_inputs( + self._expanded_wind_directions + ) + self.n_unique = self.unique_inputs.shape[0] + + # Display info on sizes + if self.verbose: + print(f"Original num rows: {self.n_unexpanded}") + print(f"Expanded num rows: {self.n_expanded}") + print(f"Unique num rows: {self.n_unique}") + + # Initiate the expanded FlorisModel + self.fmodel_expanded = self.fmodel_unexpanded.copy() + + # Now set the underlying wd/ws/ti/yaw/setpoint to check only the unique conditions + self.fmodel_expanded.set( + wind_directions=self.unique_inputs[:, 0], + wind_speeds=self.unique_inputs[:, 1], + turbulence_intensities=self.unique_inputs[:, 2], + yaw_angles=self.unique_inputs[:, 3 : 3 + self.fmodel_unexpanded.core.farm.n_turbines], + power_setpoints=self.unique_inputs[ + :, + 3 + self.fmodel_unexpanded.core.farm.n_turbines : 3 + + 2 * self.fmodel_unexpanded.core.farm.n_turbines, + ], + awc_amplitudes=self.unique_inputs[ + :, + 3 + 2 * self.fmodel_unexpanded.core.farm.n_turbines : 3 + + 3 * self.fmodel_unexpanded.core.farm.n_turbines, + ], + ) + + def reset_operation(self): + """ + Reset the operation of the underlying FlorisModel object. + """ + self.fmodel_unexpanded.set( + wind_directions=self.wind_directions_unexpanded, + wind_speeds=self.wind_speeds_unexpanded, + turbulence_intensities=self.turbulence_intensities_unexpanded, + ) + self.fmodel_unexpanded.reset_operation() + + # Calling set_uncertain again to reset the expanded FlorisModel + self._set_uncertain() + + def run(self): + """ + Run the simulation in the underlying FlorisModel object. + """ + + self.fmodel_expanded.run() + + def run_no_wake(self): + """ + Run the simulation in the underlying FlorisModel object without wakes. + """ + + self.fmodel_expanded.run_no_wake() + + def _get_turbine_powers(self): + """Calculates the power at each turbine in the wind farm. + + This method calculates the power at each turbine in the wind farm, considering + the underlying turbine powers and applying a weighted sum to handle uncertainty. + + Returns: + NDArrayFloat: An array containing the powers at each turbine for each findex. + + """ + + # Pass to off-class function + result = map_turbine_powers_uncertain( + unique_turbine_powers=self.fmodel_expanded._get_turbine_powers(), + map_to_expanded_inputs=self.map_to_expanded_inputs, + weights=self.weights, + n_unexpanded=self.n_unexpanded, + n_sample_points=self.n_sample_points, + n_turbines=self.fmodel_unexpanded.core.farm.n_turbines, + ) + + return result + + def get_turbine_powers(self): + """ + Calculate the power at each turbine in the wind farm. If WindRose or + WindTIRose is passed in, result is reshaped to match + + Returns: + NDArrayFloat: An array containing the powers at each turbine for each findex. + """ + + turbine_powers = self._get_turbine_powers() + + if self.fmodel_unexpanded.wind_data is not None: + if type(self.fmodel_unexpanded.wind_data) is WindRose: + turbine_powers_rose = np.full( + ( + len(self.fmodel_unexpanded.wind_data.wd_flat), + self.fmodel_unexpanded.core.farm.n_turbines, + ), + np.nan, + ) + turbine_powers_rose[ + self.fmodel_unexpanded.wind_data.non_zero_freq_mask, : + ] = turbine_powers + turbine_powers = turbine_powers_rose.reshape( + len(self.fmodel_unexpanded.wind_data.wind_directions), + len(self.fmodel_unexpanded.wind_data.wind_speeds), + self.fmodel_unexpanded.core.farm.n_turbines, + ) + elif type(self.fmodel_unexpanded.wind_data) is WindTIRose: + turbine_powers_rose = np.full( + ( + len(self.fmodel_unexpanded.wind_data.wd_flat), + self.fmodel_unexpanded.core.farm.n_turbines, + ), + np.nan, + ) + turbine_powers_rose[ + self.fmodel_unexpanded.wind_data.non_zero_freq_mask, : + ] = turbine_powers + turbine_powers = turbine_powers_rose.reshape( + len(self.fmodel_unexpanded.wind_data.wind_directions), + len(self.fmodel_unexpanded.wind_data.wind_speeds), + len(self.fmodel_unexpanded.wind_data.turbulence_intensities), + self.fmodel_unexpanded.core.farm.n_turbines, + ) + + return turbine_powers + + def _get_farm_power( + self, + turbine_weights=None, + use_turbulence_correction=False, + ): + """ + Report wind plant power from instance of floris with uncertainty. + + Args: + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the power production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris + is multiplied with this array in the calculation of the + objective function. If None, this is an array with all values + 1.0 and with shape equal to (n_findex, n_turbines). + Defaults to None. + use_turbulence_correction: (bool, optional): When True uses a + turbulence parameter to adjust power output calculations. + Defaults to False. Not currently implemented. + + Returns: + float: Sum of wind turbine powers in W. + """ + if use_turbulence_correction: + raise NotImplementedError( + "Turbulence correction is not yet implemented in the power calculation." + ) + + if turbine_weights is None: + # Default to equal weighing of all turbines when turbine_weights is None + turbine_weights = np.ones( + ( + self.n_unexpanded, + self.fmodel_unexpanded.core.farm.n_turbines, + ) + ) + elif len(np.shape(turbine_weights)) == 1: + # Deal with situation when 1D array is provided + turbine_weights = np.tile( + turbine_weights, + (self.n_unexpanded, 1), + ) + + # Calculate all turbine powers and apply weights + turbine_powers = self._get_turbine_powers() + turbine_powers = np.multiply(turbine_weights, turbine_powers) + + return np.sum(turbine_powers, axis=1) + + def get_farm_power( + self, + turbine_weights=None, + use_turbulence_correction=False, + ): + """ + Report wind plant power from instance of floris. Optionally includes + uncertainty in wind direction and yaw position when determining power. + Uncertainty is included by computing the mean wind farm power for a + distribution of wind direction and yaw position deviations from the + original wind direction and yaw angles. + + Args: + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the power production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris + is multiplied with this array in the calculation of the + objective function. If None, this is an array with all values + 1.0 and with shape equal to (n_findex, n_turbines). + Defaults to None. + use_turbulence_correction: (bool, optional): When True uses a + turbulence parameter to adjust power output calculations. + Defaults to False. Not currently implemented. + + Returns: + float: Sum of wind turbine powers in W. + """ + farm_power = self._get_farm_power(turbine_weights, use_turbulence_correction) + + if self.fmodel_unexpanded.wind_data is not None: + if type(self.fmodel_unexpanded.wind_data) is WindRose: + farm_power_rose = np.full(len(self.fmodel_unexpanded.wind_data.wd_flat), np.nan) + farm_power_rose[self.fmodel_unexpanded.wind_data.non_zero_freq_mask] = farm_power + farm_power = farm_power_rose.reshape( + len(self.fmodel_unexpanded.wind_data.wind_directions), + len(self.fmodel_unexpanded.wind_data.wind_speeds), + ) + elif type(self.fmodel_unexpanded.wind_data) is WindTIRose: + farm_power_rose = np.full(len(self.fmodel_unexpanded.wind_data.wd_flat), np.nan) + farm_power_rose[self.fmodel_unexpanded.wind_data.non_zero_freq_mask] = farm_power + farm_power = farm_power_rose.reshape( + len(self.fmodel_unexpanded.wind_data.wind_directions), + len(self.fmodel_unexpanded.wind_data.wind_speeds), + len(self.fmodel_unexpanded.wind_data.turbulence_intensities), + ) + + return farm_power + + def get_expected_farm_power( + self, + freq=None, + turbine_weights=None, + ) -> float: + """ + Compute the expected (mean) power of the wind farm. + + Args: + freq (NDArrayFloat): NumPy array with shape (n_findex) + with the frequencies of each wind direction and + wind speed combination. These frequencies should typically sum + up to 1.0 and are used to weigh the wind farm power for every + condition in calculating the wind farm's AEP. Defaults to None. + If None and a WindData object was supplied, the WindData object's + frequencies will be used. Otherwise, uniform frequencies are assumed + (i.e., a simple mean over the findices is computed). + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the power production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris + is multiplied with this array in the calculation of the + objective function. If None, this is an array with all values + 1.0 and with shape equal to (n_findex, + n_turbines). Defaults to None. + """ + + farm_power = self._get_farm_power(turbine_weights=turbine_weights) + + if freq is None: + if self.fmodel_unexpanded.wind_data is None: + freq = np.array([1.0 / self.core.flow_field.n_findex]) + else: + freq = self.fmodel_unexpanded.wind_data.unpack_freq() + + return np.nansum(np.multiply(freq, farm_power)) + + def get_farm_AEP( + self, + freq=None, + turbine_weights=None, + hours_per_year=8760, + ) -> float: + """ + Estimate annual energy production (AEP) for distributions of wind speed, wind + direction, frequency of occurrence, and yaw offset. + + Args: + freq (NDArrayFloat): NumPy array with shape (n_findex) + with the frequencies of each wind direction and + wind speed combination. These frequencies should typically sum + up to 1.0 and are used to weigh the wind farm power for every + condition in calculating the wind farm's AEP. Defaults to None. + If None and a WindData object was supplied, the WindData object's + frequencies will be used. Otherwise, uniform frequencies are assumed. + turbine_weights (NDArrayFloat | list[float] | None, optional): + weighing terms that allow the user to emphasize power at + particular turbines and/or completely ignore the power + from other turbines. This is useful when, for example, you are + modeling multiple wind farms in a single floris object. If you + only want to calculate the power production for one of those + farms and include the wake effects of the neighboring farms, + you can set the turbine_weights for the neighboring farms' + turbines to 0.0. The array of turbine powers from floris + is multiplied with this array in the calculation of the + objective function. If None, this is an array with all values + 1.0 and with shape equal to (n_findex, + n_turbines). Defaults to None. + hours_per_year (float, optional): Number of hours in a year. Defaults to 365 * 24. + + Returns: + float: + The Annual Energy Production (AEP) for the wind farm in + watt-hours. + """ + if ( + freq is None + and not isinstance(self.fmodel_unexpanded.wind_data, WindRose) + and not isinstance(self.fmodel_unexpanded.wind_data, WindTIRose) + ): + self.logger.warning( + "Computing AEP with uniform frequencies. Results results may not reflect annual " + "operation." + ) + + return ( + self.get_expected_farm_power(freq=freq, turbine_weights=turbine_weights) + * hours_per_year + ) + + def _get_rounded_inputs( + self, + input_array, + wd_resolution=1.0, # Degree + ws_resolution=1.0, # m/s + ti_resolution=0.025, + yaw_resolution=1.0, # Degree + power_setpoint_resolution=100, # kW + awc_amplitude_resolution=0.1, # Deg + ): + """ + Round the input array specified resolutions. + + Parameters: + input_array (numpy.ndarray): An array of shape (n, 5) with columns + for wind direction (wd), wind speed (ws), + turbulence intensity (tu), + yaw angle (yaw), and power setpoint. + wd_resolution (float): Resolution for rounding wind direction in degrees. + Default is 1.0 degree. + ws_resolution (float): Resolution for rounding wind speed in m/s. Default is 1.0 m/s. + ti_resolution (float): Resolution for rounding turbulence intensity. Default is 0.1. + yaw_resolution (float): Resolution for rounding yaw angle in degrees. + Default is 1.0 degree. + power_setpoint_resolution (int): Resolution for rounding power setpoint in kW. + Default is 100 kW. + awc_amplitude_resolution (float): Resolution for rounding amplitude of awc_amplitude + + Returns: + numpy.ndarray: A rounded array of wind turbine parameters with + the same shape as input_array, + where each parameter is rounded to the specified resolution. + """ + + # input_array is a nx5 numpy array whose columns are wd, ws, tu, yaw, power_setpoint + # round each column by the respective resolution + rounded_input_array = np.copy(input_array) + rounded_input_array[:, 0] = ( + np.round(rounded_input_array[:, 0] / wd_resolution) * wd_resolution + ) + rounded_input_array[:, 1] = ( + np.round(rounded_input_array[:, 1] / ws_resolution) * ws_resolution + ) + rounded_input_array[:, 2] = ( + np.round(rounded_input_array[:, 2] / ti_resolution) * ti_resolution + ) + rounded_input_array[:, 3 : 3 + self.fmodel_unexpanded.core.farm.n_turbines] = ( + np.round( + rounded_input_array[:, 3 : 3 + self.fmodel_unexpanded.core.farm.n_turbines] + / yaw_resolution + ) + * yaw_resolution + ) + rounded_input_array[ + :, + 3 + self.fmodel_unexpanded.core.farm.n_turbines : 3 + + 2 * self.fmodel_unexpanded.core.farm.n_turbines, + ] = ( + np.round( + rounded_input_array[ + :, + 3 + self.fmodel_unexpanded.core.farm.n_turbines : 3 + + 2 * self.fmodel_unexpanded.core.farm.n_turbines, + ] + / power_setpoint_resolution + ) + * power_setpoint_resolution + ) + + rounded_input_array[ + :, + 3 + 2 * self.fmodel_unexpanded.core.farm.n_turbines : 3 + + 3 * self.fmodel_unexpanded.core.farm.n_turbines, + ] = ( + np.round( + rounded_input_array[ + :, + 3 + 2 * self.fmodel_unexpanded.core.farm.n_turbines : 3 + + 3 * self.fmodel_unexpanded.core.farm.n_turbines, + ] + / awc_amplitude_resolution + ) + * awc_amplitude_resolution + ) + + return rounded_input_array + + def _expand_wind_directions( + self, input_array, wd_sample_points, fix_yaw_to_nominal_direction=False, n_turbines=None + ): + """ + Expand wind direction data. + + Args: + input_array (numpy.ndarray): 2D numpy array of shape (m, n) + representing wind direction data, + where m is the number of data points and n is the number of features. + The first column + represents wind direction. + wd_sample_points (list): List of integers representing + wind direction sample points. + fix_yaw_to_nominal_direction (bool): Fix the yaw angle to the nominal + direction? Defaults to False + n_turbines (int): The number of turbines in the wind farm. Must be supplied + if fix_yaw_to_nominal_direction is True. + + Returns: + numpy.ndarray: Expanded wind direction data as a 2D numpy array + of shape (m * p, n), where + p is the number of sample points. + + Raises: + ValueError: If wd_sample_points does not have an odd length or + if the middle element is not 0. + + This function takes wind direction data and expands it + by perturbing the wind direction column + based on a list of sample points. It vertically stacks + copies of the input array with the wind + direction column perturbed by each sample point, ensuring + the resultant values are within the range + of 0 to 360. + """ + + # Check if wd_sample_points is odd-length and the middle element is 0 + if len(wd_sample_points) % 2 != 1: + raise ValueError("wd_sample_points must have an odd length.") + if wd_sample_points[len(wd_sample_points) // 2] != 0: + raise ValueError("The middle element of wd_sample_points must be 0.") + + # If fix_yaw_to_nominal_direction is True, n_turbines must be supplied + if fix_yaw_to_nominal_direction and n_turbines is None: + raise ValueError("The number of turbines in the wind farm must be supplied") + + num_samples = len(wd_sample_points) + num_rows = input_array.shape[0] + + # Create an array to hold the expanded data + output_array = np.zeros((num_rows * num_samples, input_array.shape[1])) + + # Repeat each row of input_array for each sample point + for i in range(num_samples): + start_idx = i * num_rows + end_idx = start_idx + num_rows + output_array[start_idx:end_idx, :] = input_array.copy() + + # Perturb the wd column by the current sample point + output_array[start_idx:end_idx, 0] = ( + output_array[start_idx:end_idx, 0] + wd_sample_points[i] + ) % 360 + + # If fix_yaw_to_nominal_direction is True, set the yaw angle to relative + # to the nominal wind direction + if fix_yaw_to_nominal_direction: + # Wrap between -180 and 180 + output_array[start_idx:end_idx, 3 : 3 + n_turbines] = wrap_180( + output_array[start_idx:end_idx, 3 : 3 + n_turbines] + wd_sample_points[i] + ) + + return output_array + + def _get_unique_inputs(self, input_array): + """ + Finds unique rows in the input numpy array and constructs a mapping array + to reconstruct the input array from the unique rows. + + Args: + input_array (numpy.ndarray): Input array of shape (m, n). + + Returns: + tuple: A tuple containing: + numpy.ndarray: An array of unique rows found in the input_array, of shape (r, n), + where r <= m. + numpy.ndarray: A 1D array of indices mapping each row of the input_array + to the corresponding row in the unique_inputs array. + It represents how to reconstruct the input_array from the unique rows. + """ + + unique_inputs, indices, map_to_expanded_inputs = np.unique( + input_array, axis=0, return_index=True, return_inverse=True + ) + + return unique_inputs, map_to_expanded_inputs + + def _get_weights(self, wd_std, wd_sample_points): + """Generates weights based on a Gaussian distribution sampled at specific x-locations. + + Args: + wd_std (float): The standard deviation of the Gaussian distribution. + wd_sample_points (array-like): The x-locations where the Gaussian function is sampled. + + Returns: + numpy.ndarray: An array of weights, generated using a Gaussian distribution with mean 0 + and standard deviation wd_std, sampled at the specified x-locations. + The weights are normalized so that they sum to 1. + + """ + + # Calculate the Gaussian function values at sample points + gaussian_values = np.exp(-(np.array(wd_sample_points) ** 2) / (2 * wd_std**2)) + + # Normalize the Gaussian values to get the weights + weights = gaussian_values / np.sum(gaussian_values) + + return weights + + def copy(self): + """Create an independent copy of the current UncertainFlorisModel object""" + return UncertainFlorisModel( + self.fmodel_unexpanded.core.as_dict(), + wd_resolution=self.wd_resolution, + ws_resolution=self.ws_resolution, + ti_resolution=self.ti_resolution, + yaw_resolution=self.yaw_resolution, + power_setpoint_resolution=self.power_setpoint_resolution, + awc_amplitude_resolution=self.awc_amplitude_resolution, + wd_std=self.wd_std, + wd_sample_points=self.wd_sample_points, + fix_yaw_to_nominal_direction=self.fix_yaw_to_nominal_direction, + verbose=self.verbose, + ) + + @property + def layout_x(self): + """ + Wind turbine coordinate information. + + Returns: + np.array: Wind turbine x-coordinate. + """ + return self.fmodel_unexpanded.core.farm.layout_x + + @property + def layout_y(self): + """ + Wind turbine coordinate information. + + Returns: + np.array: Wind turbine y-coordinate. + """ + return self.fmodel_unexpanded.core.farm.layout_y + + @property + def wind_directions(self): + """ + Wind direction information. + + Returns: + np.array: Wind direction. + """ + return self.fmodel_unexpanded.core.flow_field.wind_directions + + @property + def wind_speeds(self): + """ + Wind speed information. + + Returns: + np.array: Wind speed. + """ + return self.fmodel_unexpanded.core.flow_field.wind_speeds + + @property + def turbulence_intensities(self): + """ + Turbulence intensity information. + + Returns: + np.array: Turbulence intensity. + """ + return self.fmodel_unexpanded.core.flow_field.turbulence_intensities + + @property + def n_findex(self): + """ + Number of unique wind conditions. + + Returns: + int: Number of unique wind conditions. + """ + return self.fmodel_unexpanded.core.flow_field.n_findex + + @property + def n_turbines(self): + """ + Number of turbines in the wind farm. + + Returns: + int: Number of turbines in the wind farm. + """ + return self.fmodel_unexpanded.core.farm.n_turbines + + @property + def core(self): + """ + Returns the core of the unexpanded model. + + Returns: + Floris: The core of the unexpanded model. + """ + return self.fmodel_unexpanded.core + + +def map_turbine_powers_uncertain( + unique_turbine_powers, + map_to_expanded_inputs, + weights, + n_unexpanded, + n_sample_points, + n_turbines, +): + """Calculates the power at each turbine in the wind farm based on uncertainty weights. + + This function calculates the power at each turbine in the wind farm, considering + the underlying turbine powers and applying a weighted sum to handle uncertainty. + + Args: + unique_turbine_powers (NDArrayFloat): An array of unique turbine powers from the + underlying FlorisModel + map_to_expanded_inputs (NDArrayFloat): An array of indices mapping the unique powers to + the expanded powers + weights (NDArrayFloat): An array of weights for each wind direction sample point + n_unexpanded (int): The number of unexpanded conditions + n_sample_points (int): The number of wind direction sample points + n_turbines (int): The number of turbines in the wind farm + + Returns: + NDArrayFloat: An array containing the powers at each turbine for each findex. + + """ + + # Expand back to the expanded value + expanded_turbine_powers = unique_turbine_powers[map_to_expanded_inputs] + + # Reshape the weights array to make it compatible with broadcasting + weights_reshaped = weights[:, np.newaxis] + + # Reshape expanded_turbine_powers into blocks + blocks = np.reshape( + expanded_turbine_powers, + (n_unexpanded, n_sample_points, n_turbines), + order="F", + ) + + # Multiply each block by the corresponding weight + weighted_blocks = blocks * weights_reshaped + + # Sum the blocks along the second axis + result = np.sum(weighted_blocks, axis=1) + + return result + + +class ApproxFlorisModel(UncertainFlorisModel): + """ + The ApproxFlorisModel overloads the UncertainFlorisModel with the special case that + the wd_sample_points = [0]. This is a special case where no uncertainty is added + but the resolution of the values wind direction, wind speed etc are still reduced + by the specified resolution. This allows for cases to be reused and a faster approximate + result computed + """ + + def __init__( + self, + configuration: dict | str | Path, + wd_resolution=1.0, # Degree + ws_resolution=1.0, # m/s + ti_resolution=0.01, + yaw_resolution=1.0, # Degree + power_setpoint_resolution=100, # kW + awc_amplitude_resolution=0.1, # Deg + verbose=False, + ): + super().__init__( + configuration, + wd_resolution, + ws_resolution, + ti_resolution, + yaw_resolution, + power_setpoint_resolution, + awc_amplitude_resolution, + wd_std=1.0, + wd_sample_points=[0], + fix_yaw_to_nominal_direction=False, + verbose=verbose, + ) + + self.wd_resolution = wd_resolution + self.ws_resolution = ws_resolution + self.ti_resolution = ti_resolution + self.yaw_resolution = yaw_resolution + self.power_setpoint_resolution = power_setpoint_resolution + self.awc_amplitude_resolution = awc_amplitude_resolution diff --git a/floris/utilities.py b/floris/utilities.py index e9f457945..074d9a1b3 100644 --- a/floris/utilities.py +++ b/floris/utilities.py @@ -1,22 +1,15 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from __future__ import annotations import os from math import ceil -from typing import Tuple +from typing import ( + Any, + Dict, + List, + Optional, + Tuple, +) import numpy as np import yaml @@ -146,7 +139,7 @@ def rotate_coordinates_rel_west( # Calculate the difference in given wind direction from 270 / West wind_deviation_from_west = wind_delta(wind_directions) - wind_deviation_from_west = np.reshape(wind_deviation_from_west, (len(wind_directions), 1, 1)) + wind_deviation_from_west = np.reshape(wind_deviation_from_west, (len(wind_directions), 1)) # Construct the arrays storing the turbine locations x_coordinates, y_coordinates, z_coordinates = coordinates.T @@ -189,8 +182,6 @@ def reverse_rotate_coordinates_rel_west( Args: wind_directions (NDArrayFloat): Series of wind directions to base the rotation. - coordinates (NDArrayFloat): Series of coordinates to rotate with shape (N coordinates, 3) - so that each element of the array coordinates[i] yields a three-component coordinate. grid_x (NDArrayFloat): X-coordinates to be rotated. grid_y (NDArrayFloat): Y-coordinates to be rotated. grid_z (NDArrayFloat): Z-coordinates to be rotated. @@ -281,3 +272,69 @@ def round_nearest(x: int | float, base: int = 5) -> int: int: The rounded number. """ return base * ceil((x + 0.5) / base) + + +def nested_get( + d: Dict[str, Any], + keys: List[str] +) -> Any: + """Get a value from a nested dictionary using a list of keys. + Based on: + https://stackoverflow.com/questions/14692690/access-nested-dictionary-items-via-a-list-of-keys + + Args: + d (Dict[str, Any]): The dictionary to get the value from. + keys (List[str]): A list of keys to traverse the dictionary. + + Returns: + Any: The value at the end of the key traversal. + """ + for key in keys: + d = d[key] + return d + +def nested_set( + d: Dict[str, Any], + keys: List[str], + value: Any, + idx: Optional[int] = None +) -> None: + """Set a value in a nested dictionary using a list of keys. + Based on: + https://stackoverflow.com/questions/14692690/access-nested-dictionary-items-via-a-list-of-keys + + Args: + dic (Dict[str, Any]): The dictionary to set the value in. + keys (List[str]): A list of keys to traverse the dictionary. + value (Any): The value to set. + idx (Optional[int], optional): If the value is an list, the index to change. + Defaults to None. + """ + d_in = d.copy() + + for key in keys[:-1]: + d = d.setdefault(key, {}) + if idx is None: + # Parameter is a scalar, set directly + d[keys[-1]] = value + else: + # Parameter is a list, need to first get the list, change the values at idx + + # # Get the underlying list + par_list = nested_get(d_in, keys) + par_list[idx] = value + d[keys[-1]] = par_list + +def print_nested_dict(dictionary: Dict[str, Any], indent: int = 0) -> None: + """Print a nested dictionary with indentation. + + Args: + dictionary (Dict[str, Any]): The dictionary to print. + indent (int, optional): The number of spaces to indent. Defaults to 0. + """ + for key, value in dictionary.items(): + print(" " * indent + str(key)) + if isinstance(value, dict): + print_nested_dict(value, indent + 4) + else: + print(" " * (indent + 4) + str(value)) diff --git a/floris/version.py b/floris/version.py index d70c8f8d8..b8626c4cf 100644 --- a/floris/version.py +++ b/floris/version.py @@ -1 +1 @@ -3.6 +4 diff --git a/floris/wind_data.py b/floris/wind_data.py new file mode 100644 index 000000000..1b0d11d00 --- /dev/null +++ b/floris/wind_data.py @@ -0,0 +1,2365 @@ +from __future__ import annotations + +import inspect +from abc import abstractmethod +from pathlib import Path + +import matplotlib.cm as cm +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +from pandas.api.types import CategoricalDtype +from scipy.interpolate import LinearNDInterpolator, NearestNDInterpolator + +from floris.type_dec import NDArrayFloat + + +class WindDataBase: + """ + Super class that WindRose and TimeSeries inherit from, enforcing the implementation of + unpack() on the child classes and providing the general functions unpack_for_reinitialize() and + unpack_freq(). + """ + + @abstractmethod + def unpack(self): + """ + Placeholder for child classes of WindDataBase, which each need to implement the unpack() + method. + """ + raise NotImplementedError("unpack() not implemented on {0}".format(self.__class__.__name__)) + + def unpack_for_reinitialize(self): + """ + Return only the variables need for FlorisModel.reinitialize + """ + ( + wind_directions_unpack, + wind_speeds_unpack, + ti_table_unpack, + _, + _, + heterogeneous_inflow_config, + ) = self.unpack() + + return ( + wind_directions_unpack, + wind_speeds_unpack, + ti_table_unpack, + heterogeneous_inflow_config, + ) + + def unpack_freq(self): + """Unpack frequency weighting""" + + return self.unpack()[3] + + def unpack_value(self): + """Unpack values of power generated""" + + return self.unpack()[4] + + def check_heterogeneous_inflow_config_by_wd(self, heterogeneous_inflow_config_by_wd): + """ + Check that the heterogeneous_inflow_config_by_wd dictionary is properly formatted + + Args: + heterogeneous_inflow_config_by_wd (dict): A dictionary containing the following keys: + * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) + of speed multipliers. + * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). + * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + """ + if heterogeneous_inflow_config_by_wd is not None: + if not isinstance(heterogeneous_inflow_config_by_wd, dict): + raise TypeError("heterogeneous_inflow_config_by_wd must be a dictionary") + if "speed_multipliers" not in heterogeneous_inflow_config_by_wd: + raise ValueError( + "heterogeneous_inflow_config_by_wd must contain a key 'speed_multipliers'" + ) + if "wind_directions" not in heterogeneous_inflow_config_by_wd: + raise ValueError( + "heterogeneous_inflow_config_by_wd must contain a key 'wind_directions'" + ) + if "x" not in heterogeneous_inflow_config_by_wd: + raise ValueError("heterogeneous_inflow_config_by_wd must contain a key 'x'") + if "y" not in heterogeneous_inflow_config_by_wd: + raise ValueError("heterogeneous_inflow_config_by_wd must contain a key 'y'") + + def check_heterogeneous_inflow_config(self, heterogeneous_inflow_config): + """ + Check that the heterogeneous_inflow_config dictionary is properly formatted + + Args: + heterogeneous_inflow_config (dict): A dictionary containing the following keys: + * 'speed_multipliers': A 2D NumPy array (size n_findex x num_points) + of speed multipliers. + * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). + * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + """ + if heterogeneous_inflow_config is not None: + if not isinstance(heterogeneous_inflow_config, dict): + raise TypeError("heterogeneous_inflow_config_by_wd must be a dictionary") + if "speed_multipliers" not in heterogeneous_inflow_config: + raise ValueError( + "heterogeneous_inflow_config must contain a key 'speed_multipliers'" + ) + if "x" not in heterogeneous_inflow_config: + raise ValueError("heterogeneous_inflow_config must contain a key 'x'") + if "y" not in heterogeneous_inflow_config: + raise ValueError("heterogeneous_inflow_config must contain a key 'y'") + + def get_speed_multipliers_by_wd(self, heterogeneous_inflow_config_by_wd, wind_directions): + """ + Processes heterogeneous inflow configuration data to generate a speed multiplier array + aligned with the wind directions. Accounts for the cyclical nature of wind directions. + Args: + heterogeneous_inflow_config_by_wd (dict): A dictionary containing the following keys: + * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) + of speed multipliers. + * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). + * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + + wind_directions (np.array): Wind directions to map onto + Returns: + numpy.ndarray: A 2D NumPy array (size n_findex x n) of speed multipliers + Each row corresponds to a wind direction, + with speed multipliers selected + based on the closest matching wind direction in 'het_wd'. + """ + + # Extract data from the configuration dictionary + speed_multipliers = np.array(heterogeneous_inflow_config_by_wd["speed_multipliers"]) + het_wd = np.array(heterogeneous_inflow_config_by_wd["wind_directions"]) + + # Confirm 0th dimension of speed_multipliers == len(het_wd) + if len(het_wd) != speed_multipliers.shape[0]: + raise ValueError( + "The legnth of het_wd must equal the number of rows speed_multipliers" + "Within the heterogeneous_inflow_config_by_wd dictionary" + ) + + # Calculate closest wind direction indices (accounting for angles) + angle_diffs = np.abs(wind_directions[:, None] - het_wd) + min_angle_diffs = np.minimum(angle_diffs, 360 - angle_diffs) + closest_wd_indices = np.argmin(min_angle_diffs, axis=1) + + # Construct the output array using the calculated indices + return speed_multipliers[closest_wd_indices] + + def get_heterogeneous_inflow_config(self, heterogeneous_inflow_config_by_wd, wind_directions): + # If heterogeneous_inflow_config_by_wd is None, return None + if heterogeneous_inflow_config_by_wd is None: + return None + + # If heterogeneous_inflow_config_by_wd is not None, then process it + # Build the n-findex version of the het map + speed_multipliers = self.get_speed_multipliers_by_wd( + heterogeneous_inflow_config_by_wd, wind_directions + ) + # Return heterogeneous_inflow_config + return { + "speed_multipliers": speed_multipliers, + "x": heterogeneous_inflow_config_by_wd["x"], + "y": heterogeneous_inflow_config_by_wd["y"], + } + + +class WindRose(WindDataBase): + """ + The WindRose class is used to drive FLORIS and optimization operations in + which the inflow is characterized by the frequency of binned wind speed and + wind direction values. Turbulence intensities are defined as a function of + wind direction and wind speed. + + Args: + wind_directions: NumPy array of wind directions (NDArrayFloat). + wind_speeds: NumPy array of wind speeds (NDArrayFloat). + ti_table: Turbulence intensity table for binned wind direction, wind + speed values (float, NDArrayFloat). Can be an array with dimensions + (n_wind_directions, n_wind_speeds) or a single float value. If a + single float value is provided, the turbulence intensity is assumed + to be constant across all wind directions and wind speeds. + freq_table: Frequency table for binned wind direction, wind speed + values (NDArrayFloat, optional). Must have dimension + (n_wind_directions, n_wind_speeds). Defaults to None in which case + uniform frequency of all bins is assumed. + value_table: Value table for binned wind direction, wind + speed values (NDArrayFloat, optional). Must have dimension + (n_wind_directions, n_wind_speeds). Defaults to None in which case + uniform values are assumed. Value can be used to weight power in + each bin to compute the total value of the energy produced + compute_zero_freq_occurrence: Flag indicating whether to compute zero + frequency occurrences (bool, optional). Defaults to False. + heterogeneous_inflow_config_by_wd (dict, optional): A dictionary containing the following + keys. Defaults to None. + * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) + of speed multipliers. + * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). + * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + + """ + + def __init__( + self, + wind_directions: NDArrayFloat, + wind_speeds: NDArrayFloat, + ti_table: float | NDArrayFloat, + freq_table: NDArrayFloat | None = None, + value_table: NDArrayFloat | None = None, + compute_zero_freq_occurrence: bool = False, + heterogeneous_inflow_config_by_wd: dict | None = None, + ): + if not isinstance(wind_directions, np.ndarray): + raise TypeError("wind_directions must be a NumPy array") + + if not isinstance(wind_speeds, np.ndarray): + raise TypeError("wind_speeds must be a NumPy array") + + # Save the wind speeds and directions + self.wind_directions = wind_directions + self.wind_speeds = wind_speeds + + # Check if ti_table is a single float value + if isinstance(ti_table, float): + self.ti_table = np.full((len(wind_directions), len(wind_speeds)), ti_table) + + # Otherwise confirm the dimensions and then save it + else: + if not ti_table.shape[0] == len(wind_directions): + raise ValueError("ti_table first dimension must equal len(wind_directions)") + if not ti_table.shape[1] == len(wind_speeds): + raise ValueError("ti_table second dimension must equal len(wind_speeds)") + self.ti_table = ti_table + + # If freq_table is not None, confirm it has correct dimension, + # otherwise initialize to uniform probability + if freq_table is not None: + if not freq_table.shape[0] == len(wind_directions): + raise ValueError("freq_table first dimension must equal len(wind_directions)") + if not freq_table.shape[1] == len(wind_speeds): + raise ValueError("freq_table second dimension must equal len(wind_speeds)") + self.freq_table = freq_table + else: + self.freq_table = np.ones((len(wind_directions), len(wind_speeds))) + + # Normalize freq table + self.freq_table = self.freq_table / np.sum(self.freq_table) + + # If value_table is not None, confirm it has correct dimension, + # otherwise initialize to all ones + if value_table is not None: + if not value_table.shape[0] == len(wind_directions): + raise ValueError("value_table first dimension must equal len(wind_directions)") + if not value_table.shape[1] == len(wind_speeds): + raise ValueError("value_table second dimension must equal len(wind_speeds)") + self.value_table = value_table + + # Save whether zero occurrence cases should be computed + # First check if the ti_table contains any nan values (which would occur for example + # if generated by the TimeSeries to WindRose conversion for wind speeds and directions + # that were not present in the original time series) In this case, raise an error + if compute_zero_freq_occurrence: + if np.isnan(self.ti_table).any(): + raise ValueError( + "ti_table contains nan values. (This is likely the result of " + " unsed wind speeds and directions in the original time series.)" + " Cannot compute zero frequency occurrences." + ) + self.compute_zero_freq_occurrence = compute_zero_freq_occurrence + + # Check that heterogeneous_inflow_config_by_wd is a dictionary with keys: + # speed_multipliers, wind_directions, x and y + self.check_heterogeneous_inflow_config_by_wd(heterogeneous_inflow_config_by_wd) + + # Then save + self.heterogeneous_inflow_config_by_wd = heterogeneous_inflow_config_by_wd + + # Build the gridded and flatten versions + self._build_gridded_and_flattened_version() + + def _build_gridded_and_flattened_version(self): + """ + Given the wind direction and speed array, build the gridded versions + covering all combinations, and then flatten versions which put all + combinations into 1D array + """ + # Gridded wind speed and direction + self.wd_grid, self.ws_grid = np.meshgrid( + self.wind_directions, self.wind_speeds, indexing="ij" + ) + + # Flat wind speed and direction + self.wd_flat = self.wd_grid.flatten() + self.ws_flat = self.ws_grid.flatten() + + # Flat frequency table + self.freq_table_flat = self.freq_table.flatten() + + # Flat TI table + self.ti_table_flat = self.ti_table.flatten() + + # value table + if self.value_table is not None: + self.value_table_flat = self.value_table.flatten() + else: + self.value_table_flat = None + + # Set mask to non-zero frequency cases depending on compute_zero_freq_occurrence + if self.compute_zero_freq_occurrence: + # If computing zero freq occurrences, then this is all True + self.non_zero_freq_mask = [True for i in range(len(self.freq_table_flat))] + else: + self.non_zero_freq_mask = self.freq_table_flat > 0.0 + + # N_findex should only be the calculated cases + self.n_findex = np.sum(self.non_zero_freq_mask) + + def unpack(self): + """ + Unpack the flattened versions of the matrices and return the values + accounting for the non_zero_freq_mask + """ + + # The unpacked versions start as the flat version of each + wind_directions_unpack = self.wd_flat.copy() + wind_speeds_unpack = self.ws_flat.copy() + freq_table_unpack = self.freq_table_flat.copy() + ti_table_unpack = self.ti_table_flat.copy() + + # Now mask thes values according to self.non_zero_freq_mask + wind_directions_unpack = wind_directions_unpack[self.non_zero_freq_mask] + wind_speeds_unpack = wind_speeds_unpack[self.non_zero_freq_mask] + freq_table_unpack = freq_table_unpack[self.non_zero_freq_mask] + ti_table_unpack = ti_table_unpack[self.non_zero_freq_mask] + + # Now get unpacked value table + if self.value_table_flat is not None: + value_table_unpack = self.value_table_flat[self.non_zero_freq_mask].copy() + else: + value_table_unpack = None + + # If heterogeneous_inflow_config_by_wd is not None, then update + # heterogeneous_inflow_config to match wind_directions_unpack + if self.heterogeneous_inflow_config_by_wd is not None: + heterogeneous_inflow_config = self.get_heterogeneous_inflow_config( + self.heterogeneous_inflow_config_by_wd, wind_directions_unpack + ) + else: + heterogeneous_inflow_config = None + + return ( + wind_directions_unpack, + wind_speeds_unpack, + ti_table_unpack, + freq_table_unpack, + value_table_unpack, + heterogeneous_inflow_config, + ) + + def aggregate(self, wd_step=None, ws_step=None, inplace=False): + """ + Aggregates the wind rose into fewer wind direction and wind speed bins. + It is necessary the wd_step and ws_step passed in are at least as + large as the current wind direction and wind speed steps. If they are + not, the function will raise an error. + + The function will return a new WindRose object with the aggregated + wind direction and wind speed bins. If inplace is set to True, the + current WindRose object will be updated with the aggregated bins. + + Args: + wd_step: Step size for wind direction resampling (float, optional). + If None, the current step size will be used. Defaults to None. + ws_step: Step size for wind speed resampling (float, optional). If + None, the current step size will be used. Defaults to None. + inplace: Flag indicating whether to update the current WindRose + object when True or return a new WindRose object when False + (bool, optional). Defaults to False. + + Returns: + WindRose: Aggregated wind rose based on the provided or default step + sizes. Only returned if inplace = False. + + Notes: + - Returns a aggregated version of the wind rose using new `ws_step` and `wd_step`. + - Uses the bin weights feature in TimeSeries to aggregated the wind rose. + - If `ws_step` or `wd_step` is not specified, it uses the current values. + """ + + # If ws_step is passed in, confirm is it at least as large as the current step + if ws_step is not None: + if len(self.wind_speeds) >= 2: + current_ws_step = self.wind_speeds[1] - self.wind_speeds[0] + if ws_step < current_ws_step: + raise ValueError( + "ws_step provided must be at least as large as the current ws_step " + f"({current_ws_step} m/s)" + ) + + # If wd_step is passed in, confirm is it at least as large as the current step + if wd_step is not None: + if len(self.wind_directions) >= 2: + current_wd_step = self.wind_directions[1] - self.wind_directions[0] + if wd_step < current_wd_step: + raise ValueError( + "wd_step provided must be at least as large as the current wd_step " + f"({current_wd_step} degrees)" + ) + + # If either ws_step or wd_step is None, set it to the current step + if ws_step is None: + if len(self.wind_speeds) >= 2: + ws_step = self.wind_speeds[1] - self.wind_speeds[0] + else: # wind rose will have only a single wind speed, and we assume a ws_step of 1 + ws_step = 1.0 + if wd_step is None: + if len(self.wind_directions) >= 2: + wd_step = self.wind_directions[1] - self.wind_directions[0] + else: # wind rose will have only a single wind direction, and we assume a wd_step of 1 + wd_step = 1.0 + + # Pass the flat versions of each quantity to build a TimeSeries model + time_series = TimeSeries( + self.wd_flat, + self.ws_flat, + self.ti_table_flat, + self.value_table_flat, + self.heterogeneous_inflow_config_by_wd, + ) + + # Now build a new wind rose using the new steps + aggregated_wind_rose = time_series.to_WindRose( + wd_step=wd_step, ws_step=ws_step, bin_weights=self.freq_table_flat + ) + if inplace: + self.__init__( + aggregated_wind_rose.wind_directions, + aggregated_wind_rose.wind_speeds, + aggregated_wind_rose.ti_table, + aggregated_wind_rose.freq_table, + aggregated_wind_rose.value_table, + aggregated_wind_rose.compute_zero_freq_occurrence, + aggregated_wind_rose.heterogeneous_inflow_config_by_wd, + ) + else: + return aggregated_wind_rose + + def resample_by_interpolation(self, wd_step=None, ws_step=None, method="linear", inplace=False): + """ + + Resample the wind rose using interpolation. The method can be either + 'linear' or 'nearest'. If inplace is set to True, the current WindRose + object will be updated with the resampled bins. + + Args: + wd_step: Step size for wind direction resampling (float, optional). + If None, the current step size will be used. Defaults to None. + ws_step: Step size for wind speed resampling (float, optional). + If None, the current step size will be used. Defaults to None. + method: Interpolation method to use (str, optional). Can be either + 'linear' or 'nearest'. Defaults to "linear". + inplace: Flag indicating whether to update the current WindRose + object when True or return a new WindRose object when False + (bool, optional). Defaults to False. + + Returns: + WindRose: Resampled wind rose based on the provided or default step + sizes. Only returned if inplace = False. + + """ + if method == "linear": + interpolator = LinearNDInterpolator + elif method == "nearest": + interpolator = NearestNDInterpolator + else: + raise ValueError( + f"Unknown interpolation method: '{method}'. " + "Available methods are 'linear' and 'nearest'" + ) + + # If either ws_step or wd_step is None, set it to the current step + if ws_step is None: + if len(self.wind_speeds) >= 2: + ws_step = self.wind_speeds[1] - self.wind_speeds[0] + else: # wind rose will have only a single wind speed, and we assume a ws_step of 1 + ws_step = 1.0 + if wd_step is None: + if len(self.wind_directions) >= 2: + wd_step = self.wind_directions[1] - self.wind_directions[0] + else: # wind rose will have only a single wind direction, and we assume a wd_step of 1 + wd_step = 1.0 + + # Set up the new wind direction and wind speed bins + new_wind_directions = np.arange( + self.wind_directions[0], self.wind_directions[-1] + wd_step / 2.0, wd_step + ) + new_wind_speeds = np.arange( + self.wind_speeds[0], self.wind_speeds[-1] + ws_step / 2.0, ws_step + ) + + # Set up for interpolation + wind_direction_column = self.wind_directions.copy() + wind_speed_column = self.wind_speeds.copy() + ti_matrix = self.ti_table.copy() + freq_matrix = self.freq_table.copy() + if self.value_table is not None: + value_matrix = self.value_table.copy() + else: + value_matrix = None + + # If the first entry of wind_direction column is 0, and the last entry is not 360, then + # pad 360 to the end of the wind direction column and the last row of the ti_matrix and + # freq_matrix by copying the 0 entry + if len(wind_direction_column) > 1: + if wind_direction_column[0] == 0 and wind_direction_column[-1] != 360: + wind_direction_column = np.append(wind_direction_column, 360) + ti_matrix = np.vstack((ti_matrix, ti_matrix[0, :])) + freq_matrix = np.vstack((freq_matrix, freq_matrix[0, :])) + if self.value_table is not None: + value_matrix = np.vstack((value_matrix, value_matrix[0, :])) + + # If the wind_direction columns has length 1, then pad the wind_direction column with + # that value + and - 1 and expand the matrices accordingly + # (this avoids interpolation errors) + if len(wind_direction_column) == 1: + wind_direction_column = np.array( + [ + wind_direction_column[0] - 1, + wind_direction_column[0], + wind_direction_column[0] + 1, + ] + ) + ti_matrix = np.vstack((ti_matrix, ti_matrix[0, :], ti_matrix[0, :])) + freq_matrix = np.vstack((freq_matrix, freq_matrix[0, :], freq_matrix[0, :])) + if self.value_table is not None: + value_matrix = np.vstack((value_matrix, value_matrix[0, :], value_matrix[0, :])) + + # If the wind_speed column has length 1, then pad the wind_speed column with + # that value + and - 1 + # and expand the matrices accordingly (this avoids interpolation errors) + if len(wind_speed_column) == 1: + wind_speed_column = np.array( + [wind_speed_column[0] - 1, wind_speed_column[0], wind_speed_column[0] + 1] + ) + ti_matrix = np.hstack((ti_matrix, ti_matrix[:, 0][:, None], ti_matrix[:, 0][:, None])) + freq_matrix = np.hstack( + (freq_matrix, freq_matrix[:, 0][:, None], freq_matrix[:, 0][:, None]) + ) + if self.value_table is not None: + value_matrix = np.hstack( + (value_matrix, value_matrix[:, 0][:, None], value_matrix[:, 0][:, None]) + ) + + # Grid wind directions and wind speeds to match the ti_matrix and freq_matrix when flattened + wd_grid, ws_grid = np.meshgrid(wind_direction_column, wind_speed_column, indexing="ij") + + # Form wd_grid and ws_grid to a 2-column matrix + wd_ws_mat = np.array([wd_grid.flatten(), ws_grid.flatten()]).T + + # Build the interpolator from wd_grid, ws_grid, to ti_matrix, freq_matrix and value_matrix + ti_interpolator = interpolator(wd_ws_mat, ti_matrix.flatten()) + freq_interpolator = interpolator(wd_ws_mat, freq_matrix.flatten()) + if self.value_table is not None: + value_interpolator = interpolator(wd_ws_mat, value_matrix.flatten()) + + # Grid the new wind directions and wind speeds + new_wd_grid, new_ws_grid = np.meshgrid(new_wind_directions, new_wind_speeds, indexing="ij") + new_wd_ws_mat = np.array([new_wd_grid.flatten(), new_ws_grid.flatten()]).T + + # Create the new ti_matrix and freq_matrix + new_ti_matrix = ti_interpolator(new_wd_ws_mat).reshape( + (len(new_wind_directions), len(new_wind_speeds)) + ) + new_freq_matrix = freq_interpolator(new_wd_ws_mat).reshape( + (len(new_wind_directions), len(new_wind_speeds)) + ) + + if self.value_table is not None: + new_value_matrix = value_interpolator(new_wd_ws_mat).reshape( + (len(new_wind_directions), len(new_wind_speeds)) + ) + else: + new_value_matrix = None + + # Create the resampled wind rose + resampled_wind_rose = WindRose( + new_wind_directions, + new_wind_speeds, + new_ti_matrix, + new_freq_matrix, + new_value_matrix, + self.compute_zero_freq_occurrence, + self.heterogeneous_inflow_config_by_wd, + ) + + if inplace: + self.__init__( + resampled_wind_rose.wind_directions, + resampled_wind_rose.wind_speeds, + resampled_wind_rose.ti_table, + resampled_wind_rose.freq_table, + resampled_wind_rose.value_table, + resampled_wind_rose.compute_zero_freq_occurrence, + resampled_wind_rose.heterogeneous_inflow_config_by_wd, + ) + else: + return resampled_wind_rose + + def plot( + self, + ax=None, + color_map="viridis_r", + wd_step=None, + ws_step=None, + legend_kwargs={"title": "Wind speed [m/s]"}, + ): + """ + This method creates a wind rose plot showing the frequency of occurrence + of the specified wind direction and wind speed bins. If no axis is + provided, a new one is created. + + **Note**: Based on code provided by Patrick Murphy from the University + of Colorado Boulder. + + Args: + ax (:py:class:`matplotlib.pyplot.axes`, optional): The figure axes + on which the wind rose is plotted. Defaults to None. + color_map (str, optional): Colormap to use. Defaults to 'viridis_r'. + wd_step: Step size for wind direction (float, optional). If None, + the current step size will be used. Defaults to None. + ws_step: Step size for wind speed (float, optional). + the current step size will be used. Defaults to None. + legend_kwargs (dict, optional): Keyword arguments to be passed to + ax.legend(). Defaults to {"title": "Wind speed [m/s]"}. + + Returns: + :py:class:`matplotlib.pyplot.axes`: A figure axes object containing + the plotted wind rose. + """ + + # Get a aggregated wind_rose + wind_rose_aggregate = self.aggregate(wd_step, ws_step, inplace=False) + wd_bins = wind_rose_aggregate.wind_directions + ws_bins = wind_rose_aggregate.wind_speeds + freq_table = wind_rose_aggregate.freq_table + + # Set up figure + if ax is None: + _, ax = plt.subplots(subplot_kw={"polar": True}) + + # Get the wd_step + if wd_step is None: + wd_step = wd_bins[1] - wd_bins[0] + + # Get a color array + color_array = cm.get_cmap(color_map, len(ws_bins)) + + for wd_idx, wd in enumerate(wd_bins): + rects = [] + freq_table_sub = freq_table[wd_idx, :].flatten() + for ws_idx, ws in reversed(list(enumerate(ws_bins))): + plot_val = freq_table_sub[:ws_idx].sum() + rects.append( + ax.bar( + np.radians(wd), + plot_val, + width=0.9 * np.radians(wd_step), + color=color_array(ws_idx), + edgecolor="k", + ) + ) + + # Configure the plot + ax.legend(reversed(rects), ws_bins, **legend_kwargs) + ax.set_theta_direction(-1) + ax.set_theta_offset(np.pi / 2.0) + ax.set_theta_zero_location("N") + ax.set_xticks(np.arange(0, 2 * np.pi, np.pi / 4)) + ax.set_xticklabels(["N", "NE", "E", "SE", "S", "SW", "W", "NW"]) + + return ax + + def assign_ti_using_wd_ws_function(self, func): + """ + Use the passed in function to assign new values to turbulence_intensities + + Args: + func (function): Function which accepts wind_directions as its + first argument and wind_speeds as second argument and returns + turbulence_intensities + """ + self.ti_table = func(self.wd_grid, self.ws_grid) + self._build_gridded_and_flattened_version() + + def assign_ti_using_IEC_method(self, Iref=0.07, offset=3.8): + """ + Define TI as a function of wind speed by specifying an Iref and offset + value as in the normal turbulence model in the IEC 61400-1 standard + + Args: + Iref (float): Reference turbulence level, defined as the expected + value of TI at 15 m/s. Default = 0.07. Note this value is + lower than the values of Iref for turbulence classes A, B, and + C in the IEC standard (0.16, 0.14, and 0.12, respectively), but + produces TI values more in line with those typically used in + FLORIS. When the default Iref and offset are used, the TI at + 8 m/s is 8.6%. + offset (float): Offset value to equation. Default = 3.8, as defined + in the IEC standard to give the expected value of TI for + each wind speed. + """ + if (Iref < 0) or (Iref > 1): + raise ValueError("Iref must be >= 0 and <=1") + + def iref_func(wind_directions, wind_speeds): + sigma_1 = Iref * (0.75 * wind_speeds + offset) + return sigma_1 / wind_speeds + + self.assign_ti_using_wd_ws_function(iref_func) + + def plot_ti_over_ws( + self, + ax=None, + marker=".", + ls="None", + color="k", + ): + """ + Scatter plot the turbulence_intensities against wind_speeds + + Args: + ax (:py:class:`matplotlib.pyplot.axes`, optional): The figure axes + on which the turbulence intensity is plotted. Defaults to None. + marker (str, optional): Scatter plot marker style. Defaults to ".". + ls (str, optional): Scatter plot line style. Defaults to "None". + color (str, optional): Scatter plot color. Defaults to "k". + + Returns: + :py:class:`matplotlib.pyplot.axes`: A figure axes object containing + the plotted turbulence intensities as a function of wind speed. + """ + + # TODO: Plot mean and std. devs. of TI in each ws bin in addition to + # individual points + + # Set up figure + if ax is None: + _, ax = plt.subplots() + + ax.plot(self.ws_flat, self.ti_table_flat * 100, marker=marker, ls=ls, color=color) + ax.set_xlabel("Wind Speed (m/s)") + ax.set_ylabel("Turbulence Intensity (%)") + ax.grid(True) + + def assign_value_using_wd_ws_function(self, func, normalize=False): + """ + Use the passed in function to assign new values to the value table. + + Args: + func (function): Function which accepts wind_directions as its + first argument and wind_speeds as second argument and returns + values. + normalize (bool, optional): If True, the value array will be + normalized by the mean value. Defaults to False. + + """ + self.value_table = func(self.wd_grid, self.ws_grid) + + if normalize: + self.value_table /= np.sum(self.freq_table * self.value_table) + + self._build_gridded_and_flattened_version() + + def assign_value_piecewise_linear( + self, + value_zero_ws=1.425, + ws_knee=4.5, + slope_1=0.0, + slope_2=-0.135, + limit_to_zero=False, + normalize=False, + ): + """ + Define value as a continuous piecewise linear function of wind speed + with two line segments. The default parameters yield a value function + that approximates the normalized mean electricity price vs. wind speed + curve for the SPP market in the U.S. for years 2018-2020 from figure 7 + in Simley et al. "The value of wake steering wind farm flow control in + US energy markets," Wind Energy Science, 2024. + https://doi.org/10.5194/wes-9-219-2024. This default value function is + constant at low wind speeds, then linearly decreases above 4.5 m/s. + + Args: + value_zero_ws (float, optional): The value when wind speed is zero. + Defaults to 1.425. + ws_knee (float, optional): The wind speed separating line segments + 1 and 2. Default = 4.5 m/s. + slope_1 (float, optional): The slope of the first line segment + (unit of value per m/s). Defaults to zero. + slope_2 (float, optional): The slope of the second line segment + (unit of value per m/s). Defaults to -0.135. + limit_to_zero (bool, optional): If True, negative values will be + set to zero. Defaults to False. + normalize (bool, optional): If True, the value array will be + normalized by the mean value. Defaults to False. + """ + + def piecewise_linear_value_func(wind_directions, wind_speeds): + value = np.zeros_like(wind_speeds, dtype=float) + value[wind_speeds < ws_knee] = ( + slope_1 * wind_speeds[wind_speeds < ws_knee] + value_zero_ws + ) + + offset_2 = (slope_1 - slope_2) * ws_knee + value_zero_ws + + value[wind_speeds >= ws_knee] = slope_2 * wind_speeds[wind_speeds >= ws_knee] + offset_2 + + if limit_to_zero: + value[value < 0] = 0.0 + + return value + + self.assign_value_using_wd_ws_function(piecewise_linear_value_func, normalize) + + def plot_value_over_ws( + self, + ax=None, + marker=".", + ls="None", + color="k", + ): + """ + Scatter plot the value of the energy generated against wind speed. + + Args: + ax (:py:class:`matplotlib.pyplot.axes`, optional): The figure axes + on which the value is plotted. Defaults to None. + marker (str, optional): Scatter plot marker style. Defaults to ".". + ls (str, optional): Scatter plot line style. Defaults to "None". + color (str, optional): Scatter plot color. Defaults to "k". + + Returns: + :py:class:`matplotlib.pyplot.axes`: A figure axes object containing + the plotted value as a function of wind speed. + """ + + # TODO: Plot mean and std. devs. of value in each ws bin in addition to + # individual points + + # Set up figure + if ax is None: + _, ax = plt.subplots() + + ax.plot(self.ws_flat, self.value_table_flat, marker=marker, ls=ls, color=color) + ax.set_xlabel("Wind Speed (m/s)") + ax.set_ylabel("Value") + ax.grid(True) + + @staticmethod + def read_csv_long( + file_path: str, + ws_col: str = "wind_speeds", + wd_col: str = "wind_directions", + ti_col_or_value: str | float = "turbulence_intensities", + freq_col: str | None = None, + sep: str = ",", + ) -> WindRose: + """ + Read a long-formatted CSV file into the wind rose object. By long, what is meant + is that the wind speed, wind direction combination is given for each row in the + CSV file. The wind speed, wind direction, are + given in separate columns, and the frequency of occurrence of each combination + is given in a separate column. The frequency column is optional, and if not + provided, uniform frequency of all bins is assumed. + + The value of ti_col_or_value can be either a string or a float. If it is a string, + it is assumed to be the name of the column in the CSV file that contains the + turbulence intensity values. If it is a float, it is assumed to be a constant + turbulence intensity value for all wind speed and direction combinations. + + Args: + file_path (str): Path to the CSV file. + ws_col (str): Name of the column in the CSV file that contains the wind speed + values. Defaults to 'wind_speeds'. + wd_col (str): Name of the column in the CSV file that contains the wind direction + values. Defaults to 'wind_directions'. + ti_col_or_value (str or float): Name of the column in the CSV file that contains + the turbulence intensity values, or a constant turbulence intensity value. + freq_col (str): Name of the column in the CSV file that contains the frequency + values. Defaults to None in which case constant frequency assumed. + sep (str): Delimiter to use. Defaults to ','. + + Returns: + WindRose: Wind rose object created from the CSV file. + """ + + # Read in the CSV file + try: + df = pd.read_csv(file_path, sep=sep) + except FileNotFoundError: + # If the file cannot be found, then attempt the level above + base_fn = Path(inspect.stack()[-1].filename).resolve().parent + file_path = base_fn / file_path + df = pd.read_csv(file_path, sep=sep) + + # Check that ti_col_or_value is a string or a float + if not isinstance(ti_col_or_value, (str, float)): + raise TypeError("ti_col_or_value must be a string or a float") + + # Check that the required columns are present + if ws_col not in df.columns: + raise ValueError(f"Column {ws_col} not found in CSV file") + if wd_col not in df.columns: + raise ValueError(f"Column {wd_col} not found in CSV file") + if ti_col_or_value not in df.columns and isinstance(ti_col_or_value, str): + raise ValueError(f"Column {ti_col_or_value} not found in CSV file") + if freq_col not in df.columns and freq_col is not None: + raise ValueError(f"Column {freq_col} not found in CSV file") + + # Get the wind speed, wind direction, and turbulence intensity values + wind_directions = df[wd_col].values + wind_speeds = df[ws_col].values + if isinstance(ti_col_or_value, str): + turbulence_intensities = df[ti_col_or_value].values + else: + turbulence_intensities = ti_col_or_value * np.ones(len(wind_speeds)) + if freq_col is not None: + freq_values = df[freq_col].values + else: + freq_values = np.ones(len(wind_speeds)) + + # Normalize freq_values + freq_values = freq_values / np.sum(freq_values) + + # Get the unique values of wind directions and wind speeds + unique_wd = np.unique(wind_directions) + unique_ws = np.unique(wind_speeds) + + # Get the step side for wind direction and wind speed + wd_step = unique_wd[1] - unique_wd[0] + ws_step = unique_ws[1] - unique_ws[0] + + # Now use TimeSeries to create a wind rose + time_series = TimeSeries(wind_directions, wind_speeds, turbulence_intensities) + + # Now build a new wind rose using the new steps + return time_series.to_WindRose(wd_step=wd_step, ws_step=ws_step, bin_weights=freq_values) + + +class WindTIRose(WindDataBase): + """ + WindTIRose is similar to the WindRose class, but contains turbulence + intensity as an additional wind rose dimension instead of being defined + as a function of wind direction and wind speed. The class is used to drive + FLORIS and optimization operations in which the inflow is characterized by + the frequency of binned wind speed, wind direction, and turbulence intensity + values. + + Args: + wind_directions: NumPy array of wind directions (NDArrayFloat). + wind_speeds: NumPy array of wind speeds (NDArrayFloat). + turbulence_intensities: NumPy array of turbulence intensities (NDArrayFloat). + freq_table: Frequency table for binned wind direction, wind speed, and + turbulence intensity values (NDArrayFloat, optional). Must have + dimension (n_wind_directions, n_wind_speeds, n_turbulence_intensities). + Defaults to None in which case uniform frequency of all bins is + assumed. + value_table: Value table for binned wind direction, wind + speed, and turbulence intensity values (NDArrayFloat, optional). + Must have dimension (n_wind_directions, n_wind_speeds, + n_turbulence_intensities). Defaults to None in which case uniform + values are assumed. Value can be used to weight power in each bin + to compute the total value of the energy produced. + compute_zero_freq_occurrence: Flag indicating whether to compute zero + frequency occurrences (bool, optional). Defaults to False. + heterogeneous_inflow_config_by_wd (dict, optional): A dictionary containing the following + keys. Defaults to None. + * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) + of speed multipliers. + * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). + * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + + """ + + def __init__( + self, + wind_directions: NDArrayFloat, + wind_speeds: NDArrayFloat, + turbulence_intensities: NDArrayFloat, + freq_table: NDArrayFloat | None = None, + value_table: NDArrayFloat | None = None, + compute_zero_freq_occurrence: bool = False, + heterogeneous_inflow_config_by_wd: dict | None = None, + ): + if not isinstance(wind_directions, np.ndarray): + raise TypeError("wind_directions must be a NumPy array") + + if not isinstance(wind_speeds, np.ndarray): + raise TypeError("wind_speeds must be a NumPy array") + + if not isinstance(turbulence_intensities, np.ndarray): + raise TypeError("turbulence_intensities must be a NumPy array") + + # Save the wind speeds and directions + self.wind_directions = wind_directions + self.wind_speeds = wind_speeds + self.turbulence_intensities = turbulence_intensities + + # If freq_table is not None, confirm it has correct dimension, + # otherwise initialize to uniform probability + if freq_table is not None: + if not freq_table.shape[0] == len(wind_directions): + raise ValueError("freq_table first dimension must equal len(wind_directions)") + if not freq_table.shape[1] == len(wind_speeds): + raise ValueError("freq_table second dimension must equal len(wind_speeds)") + if not freq_table.shape[2] == len(turbulence_intensities): + raise ValueError( + "freq_table third dimension must equal len(turbulence_intensities)" + ) + self.freq_table = freq_table + else: + self.freq_table = np.ones( + (len(wind_directions), len(wind_speeds), len(turbulence_intensities)) + ) + + # Normalize freq table + self.freq_table = self.freq_table / np.sum(self.freq_table) + + # If value_table is not None, confirm it has correct dimension, + # otherwise initialize to all ones + if value_table is not None: + if not value_table.shape[0] == len(wind_directions): + raise ValueError("value_table first dimension must equal len(wind_directions)") + if not value_table.shape[1] == len(wind_speeds): + raise ValueError("value_table second dimension must equal len(wind_speeds)") + if not value_table.shape[2] == len(turbulence_intensities): + raise ValueError( + "value_table third dimension must equal len(turbulence_intensities)" + ) + self.value_table = value_table + + # Check that heterogeneous_inflow_config_by_wd is a dictionary with keys: + # speed_multipliers, wind_directions, x and y + self.check_heterogeneous_inflow_config_by_wd(heterogeneous_inflow_config_by_wd) + + # Then save + self.heterogeneous_inflow_config_by_wd = heterogeneous_inflow_config_by_wd + + # Save whether zero occurrence cases should be computed + self.compute_zero_freq_occurrence = compute_zero_freq_occurrence + + # Build the gridded and flatten versions + self._build_gridded_and_flattened_version() + + def _build_gridded_and_flattened_version(self): + """ + Given the wind direction, wind speed, and turbulence intensity array, + build the gridded versions covering all combinations, and then flatten + versions which put all combinations into 1D array + """ + # Gridded wind speed and direction + self.wd_grid, self.ws_grid, self.ti_grid = np.meshgrid( + self.wind_directions, self.wind_speeds, self.turbulence_intensities, indexing="ij" + ) + + # Flat wind direction, wind speed, and turbulence intensity + self.wd_flat = self.wd_grid.flatten() + self.ws_flat = self.ws_grid.flatten() + self.ti_flat = self.ti_grid.flatten() + + # Flat frequency table + self.freq_table_flat = self.freq_table.flatten() + + # value table + if self.value_table is not None: + self.value_table_flat = self.value_table.flatten() + else: + self.value_table_flat = None + + # Set mask to non-zero frequency cases depending on compute_zero_freq_occurrence + if self.compute_zero_freq_occurrence: + # If computing zero freq occurrences, then this is all True + self.non_zero_freq_mask = [True for i in range(len(self.freq_table_flat))] + else: + self.non_zero_freq_mask = self.freq_table_flat > 0.0 + + # N_findex should only be the calculated cases + self.n_findex = np.sum(self.non_zero_freq_mask) + + def unpack(self): + """ + Unpack the flattened versions of the matrices and return the values + accounting for the non_zero_freq_mask + """ + + # The unpacked versions start as the flat version of each + wind_directions_unpack = self.wd_flat.copy() + wind_speeds_unpack = self.ws_flat.copy() + turbulence_intensities_unpack = self.ti_flat.copy() + freq_table_unpack = self.freq_table_flat.copy() + + # Now mask thes values according to self.non_zero_freq_mask + wind_directions_unpack = wind_directions_unpack[self.non_zero_freq_mask] + wind_speeds_unpack = wind_speeds_unpack[self.non_zero_freq_mask] + turbulence_intensities_unpack = turbulence_intensities_unpack[self.non_zero_freq_mask] + freq_table_unpack = freq_table_unpack[self.non_zero_freq_mask] + + # Now get unpacked value table + if self.value_table_flat is not None: + value_table_unpack = self.value_table_flat[self.non_zero_freq_mask].copy() + else: + value_table_unpack = None + + # If heterogeneous_inflow_config_by_wd is not None, then update + # heterogeneous_inflow_config to match wind_directions_unpack + if self.heterogeneous_inflow_config_by_wd is not None: + heterogeneous_inflow_config = self.get_heterogeneous_inflow_config( + self.heterogeneous_inflow_config_by_wd, wind_directions_unpack + ) + else: + heterogeneous_inflow_config = None + + return ( + wind_directions_unpack, + wind_speeds_unpack, + turbulence_intensities_unpack, + freq_table_unpack, + value_table_unpack, + heterogeneous_inflow_config, + ) + + def aggregate(self, wd_step=None, ws_step=None, ti_step=None, inplace=False): + """ + Aggregates the wind TI rose into fewer wind direction, wind speed and TI bins. + It is necessary the wd_step and ws_step ti_step passed in are at least as + large as the current wind direction and wind speed steps. If they are + not, the function will raise an error. + + The function will return a new WindTIRose object with the aggregated + wind direction, wind speed and TI bins. If inplace is set to True, the + current WindTIRose object will be updated with the aggregated bins. + + Args: + wd_step: Step size for wind direction resampling (float, optional). + ws_step: Step size for wind speed resampling (float, optional). + ti_step: Step size for turbulence intensity resampling (float, optional). + inplace: Flag indicating whether to update the current WindTIRose. + Defaults to False. + + Returns: + WindTIRose: Aggregated wind TI rose based on the provided or default step sizes. + + Notes: + - Returns an aggregated version of the wind TI rose using new `ws_step`, + `wd_step`, and `ti_step`. + - Uses the bin weights feature in TimeSeries to aggregate the wind rose. + - If `ws_step`, `wd_step`, or `ti_step` are not specified, it uses + the current values. + """ + + # If ws_step is passed in, confirm is it at least as large as the current step + if ws_step is not None: + if len(self.wind_speeds) >= 2: + current_ws_step = self.wind_speeds[1] - self.wind_speeds[0] + if ws_step < current_ws_step: + raise ValueError( + "ws_step provided must be at least as large as the current ws_step " + f"({current_ws_step} m/s)" + ) + + # If wd_step is passed in, confirm is it at least as large as the current step + if wd_step is not None: + if len(self.wind_directions) >= 2: + current_wd_step = self.wind_directions[1] - self.wind_directions[0] + if wd_step < current_wd_step: + raise ValueError( + "wd_step provided must be at least as large as the current wd_step " + f"({current_wd_step} degrees)" + ) + + # If ti_step is passed in, confirm is it at least as large as the current step + if ti_step is not None: + if len(self.turbulence_intensities) >= 2: + current_ti_step = self.turbulence_intensities[1] - self.turbulence_intensities[0] + if ti_step < current_ti_step: + raise ValueError( + "ti_step provided must be at least as large as the current ti_step " + f"({current_ti_step})" + ) + + # If ws_step, wd_step or ti_step is none, set it to the current step + if ws_step is None: + if len(self.wind_speeds) >= 2: + ws_step = self.wind_speeds[1] - self.wind_speeds[0] + else: # wind rose will have only a single wind speed, and we assume a ws_step of 1 + ws_step = 1.0 + if wd_step is None: + if len(self.wind_directions) >= 2: + wd_step = self.wind_directions[1] - self.wind_directions[0] + else: # wind rose will have only a single wind direction, and we assume a wd_step of 1 + wd_step = 1.0 + if ti_step is None: + if len(self.turbulence_intensities) >= 2: + ti_step = self.turbulence_intensities[1] - self.turbulence_intensities[0] + else: # wind rose will have only a single TI, and we assume a ti_step of 1 + ti_step = 1.0 + + # Pass the flat versions of each quantity to build a TimeSeries model + time_series = TimeSeries( + self.wd_flat, + self.ws_flat, + self.ti_flat, + self.value_table_flat, + self.heterogeneous_inflow_config_by_wd, + ) + + # Now build a new wind rose using the new steps + aggregated_wind_rose = time_series.to_WindTIRose( + wd_step=wd_step, ws_step=ws_step, ti_step=ti_step, bin_weights=self.freq_table_flat + ) + + if inplace: + self.__init__( + aggregated_wind_rose.wind_directions, + aggregated_wind_rose.wind_speeds, + aggregated_wind_rose.turbulence_intensities, + aggregated_wind_rose.freq_table, + aggregated_wind_rose.value_table, + aggregated_wind_rose.compute_zero_freq_occurrence, + aggregated_wind_rose.heterogeneous_inflow_config_by_wd, + ) + else: + return aggregated_wind_rose + + def resample_by_interpolation( + self, wd_step=None, ws_step=None, ti_step=None, method="linear", inplace=False + ): + """ + + Resample the wind TI rose using interpolation. The method can be either + 'linear' or 'nearest'. If inplace is set to True, the current WindTIRose + object will be updated with the resampled bins. + + Args: + wd_step: Step size for wind direction resampling (float, optional). + If None, the current step size will be used. Defaults to None. + ws_step: Step size for wind speed resampling (float, optional). + If None, the current step size will be used. Defaults to None. + ti_step: Step size for turbulence intensity resampling (float, optional). + If None, the current step size will be used. Defaults to None. + method: Interpolation method to use (str, optional). Can be either + 'linear' or 'nearest'. Defaults to "linear". + inplace: Flag indicating whether to update the current WindRose + object when True or return a new WindRose object when False + (bool, optional). Defaults to False. + + Returns: + WindRose: Resampled wind rose based on the provided or default step + sizes. Only returned if inplace = False. + + """ + if method == "linear": + interpolator = LinearNDInterpolator + elif method == "nearest": + interpolator = NearestNDInterpolator + else: + raise ValueError( + f"Unknown interpolation method: '{method}'. " + "Available methods are 'linear' and 'nearest'" + ) + + # If either ws_step or wd_step is None, set it to the current step + if ws_step is None: + if len(self.wind_speeds) >= 2: + ws_step = self.wind_speeds[1] - self.wind_speeds[0] + else: # wind rose will have only a single wind speed, and we assume a ws_step of 1 + ws_step = 1.0 + if wd_step is None: + if len(self.wind_directions) >= 2: + wd_step = self.wind_directions[1] - self.wind_directions[0] + else: # wind rose will have only a single wind direction, and we assume a wd_step of 1 + wd_step = 1.0 + if ti_step is None: + if len(self.turbulence_intensities) >= 2: + ti_step = self.turbulence_intensities[1] - self.turbulence_intensities[0] + else: + ti_step = 1.0 + + # Set up the new wind direction and wind speed and turbulence intensity bins + new_wind_directions = np.arange( + self.wind_directions[0], self.wind_directions[-1] + wd_step / 2.0, wd_step + ) + new_wind_speeds = np.arange( + self.wind_speeds[0], self.wind_speeds[-1] + ws_step / 2.0, ws_step + ) + new_turbulence_intensities = np.arange( + self.turbulence_intensities[0], self.turbulence_intensities[-1] + ti_step / 2.0, ti_step + ) + + # Set up for interpolation + wind_direction_column = self.wind_directions.copy() + wind_speed_column = self.wind_speeds.copy() + turbulence_intensity_column = self.turbulence_intensities.copy() + freq_matrix = self.freq_table.copy() + if self.value_table is not None: + value_matrix = self.value_table.copy() + else: + value_matrix = None + + # If the first entry of wind_direction column is 0, and the last entry is not 360, then + # pad 360 to the end of the wind direction column and the last row of the ti_matrix and + # freq_matrix by copying the 0 entry + if len(wind_direction_column) > 1: + if wind_direction_column[0] == 0 and wind_direction_column[-1] != 360: + wind_direction_column = np.append(wind_direction_column, 360) + freq_matrix = np.concatenate( + (freq_matrix, freq_matrix[0, :, :][None, :, :]), axis=0 + ) + if self.value_table is not None: + value_matrix = np.concatenate((value_matrix, value_matrix[0, :, :][None, :, :])) + + # If the wind_direction columns has length 1, then pad the wind_direction column with + # that value + and - 1 and expand the matrices accordingly + # (this avoids interpolation errors) + if len(wind_direction_column) == 1: + wind_direction_column = np.array( + [ + wind_direction_column[0] - 1, + wind_direction_column[0], + wind_direction_column[0] + 1, + ] + ) + freq_matrix = np.concatenate( + (freq_matrix, freq_matrix[0, :, :][None, :, :], freq_matrix[0, :, :][None, :, :]), + axis=0, + ) + if self.value_table is not None: + value_matrix = np.concatenate( + ( + value_matrix, + value_matrix[0, :, :][None, :, :], + value_matrix[0, :, :][None, :, :], + ), + axis=0, + ) + + # If the wind_speed column has length 1, then pad the wind_speed column with + # that value + and - 1 + # and expand the matrices accordingly (this avoids interpolation errors) + if len(wind_speed_column) == 1: + wind_speed_column = np.array( + [wind_speed_column[0] - 1, wind_speed_column[0], wind_speed_column[0] + 1] + ) + freq_matrix = np.concatenate( + (freq_matrix, freq_matrix[:, 0, :][:, None, :], freq_matrix[:, 0, :][:, None, :]), + axis=1, + ) + if self.value_table is not None: + value_matrix = np.concatenate( + ( + value_matrix, + value_matrix[:, 0, :][:, None, :], + value_matrix[:, 0, :][:, None, :], + ), + axis=1, + ) + + # If the turbulence_intensity column has length 1, then + # pad the turbulence_intensity column with + # that value + and - 1 + # and expand the matrices accordingly (this avoids interpolation errors) + if len(turbulence_intensity_column) == 1: + turbulence_intensity_column = np.array( + [ + turbulence_intensity_column[0] - 1, + turbulence_intensity_column[0], + turbulence_intensity_column[0] + 1, + ] + ) + freq_matrix = np.concatenate( + (freq_matrix, freq_matrix[:, :, 0][:, :, None], freq_matrix[:, :, 0][:, :, None]), + axis=2, + ) + if self.value_table is not None: + value_matrix = np.concatenate( + ( + value_matrix, + value_matrix[:, :, 0][:, :, None], + value_matrix[:, :, 0][:, :, None], + ), + axis=2, + ) + + # Grid wind directions and wind speeds to match the ti_matrix and freq_matrix when flattened + wd_grid, ws_grid, ti_grid = np.meshgrid( + wind_direction_column, wind_speed_column, turbulence_intensity_column, indexing="ij" + ) + + # Form wd_grid and ws_grid to a 2-column matrix + wd_ws_ti_mat = np.array([wd_grid.flatten(), ws_grid.flatten(), ti_grid.flatten()]).T + + # Build the interpolator from wd_grid, ws_grid, to ti_matrix, freq_matrix and value_matrix + freq_interpolator = interpolator(wd_ws_ti_mat, freq_matrix.flatten()) + if self.value_table is not None: + value_interpolator = interpolator(wd_ws_ti_mat, value_matrix.flatten()) + + # Grid the new wind directions and wind speeds + new_wd_grid, new_ws_grid, new_ti_grid = np.meshgrid( + new_wind_directions, new_wind_speeds, new_turbulence_intensities, indexing="ij" + ) + new_wd_ws_ti_mat = np.array( + [new_wd_grid.flatten(), new_ws_grid.flatten(), new_ti_grid.flatten()] + ).T + + # Create the new freq_matrix and value_matrix + new_freq_matrix = freq_interpolator(new_wd_ws_ti_mat).reshape( + (len(new_wind_directions), len(new_wind_speeds), len(new_turbulence_intensities)) + ) + + if self.value_table is not None: + new_value_matrix = value_interpolator(new_wd_ws_ti_mat).reshape( + (len(new_wind_directions), len(new_wind_speeds), len(new_turbulence_intensities)) + ) + else: + new_value_matrix = None + + # Create the resampled wind rose + resampled_wind_rose = WindTIRose( + new_wind_directions, + new_wind_speeds, + new_turbulence_intensities, + new_freq_matrix, + new_value_matrix, + self.compute_zero_freq_occurrence, + self.heterogeneous_inflow_config_by_wd, + ) + + if inplace: + self.__init__( + resampled_wind_rose.wind_directions, + resampled_wind_rose.wind_speeds, + resampled_wind_rose.turbulence_intensities, + resampled_wind_rose.freq_table, + resampled_wind_rose.value_table, + resampled_wind_rose.compute_zero_freq_occurrence, + resampled_wind_rose.heterogeneous_inflow_config_by_wd, + ) + else: + return resampled_wind_rose + + def plot( + self, + ax=None, + wind_rose_var="ws", + color_map="viridis_r", + wd_step=15.0, + wind_rose_var_step=None, + legend_kwargs={}, + ): + """ + This method creates a wind rose plot showing the frequency of occurrence + of either the specified wind direction and wind speed bins or wind + direction and turbulence intensity bins. If no axis is provided, a new + one is created. + + **Note**: Based on code provided by Patrick Murphy from the University + of Colorado Boulder. + + Args: + ax (:py:class:`matplotlib.pyplot.axes`, optional): The figure axes + on which the wind rose is plotted. Defaults to None. + wind_rose_var (str, optional): The variable to display in the wind + rose plot in addition to wind direction. If + wind_rose_var = "ws", wind speed frequencies will be plotted. + If wind_rose_var = "ti", turbulence intensity frequencies will + be plotted. Defaults to "ws". + color_map (str, optional): Colormap to use. Defaults to 'viridis_r'. + wd_step (float, optional): Step size for wind direction. Defaults + to 15 degrees. + wind_rose_var_step (float, optional): Step size for other wind rose + variable. Defaults to None. If unspecified, a value of 5 m/s + will be used if wind_rose_var = "ws", and a value of 4% will be + used if wind_rose_var = "ti". + legend_kwargs (dict, optional): Keyword arguments to be passed to + ax.legend(). + + Returns: + :py:class:`matplotlib.pyplot.axes`: A figure axes object containing + the plotted wind rose. + """ + + if wind_rose_var not in {"ws", "ti"}: + raise ValueError( + 'wind_rose_var must be either "ws" or "ti" for wind speed or turbulence intensity.' + ) + + # Get a aggregated wind_rose + if wind_rose_var == "ws": + if wind_rose_var_step is None: + wind_rose_var_step = 5.0 + wind_rose_aggregated = self.aggregate(wd_step, ws_step=wind_rose_var_step) + var_bins = wind_rose_aggregated.wind_speeds + freq_table = wind_rose_aggregated.freq_table.sum(2) # sum along TI dimension + else: # wind_rose_var == "ti" + if wind_rose_var_step is None: + wind_rose_var_step = 0.04 + wind_rose_aggregated = self.aggregate(wd_step, ti_step=wind_rose_var_step) + var_bins = wind_rose_aggregated.turbulence_intensities + freq_table = wind_rose_aggregated.freq_table.sum(1) # sum along wind speed dimension + + wd_bins = wind_rose_aggregated.wind_directions + + # Set up figure + if ax is None: + _, ax = plt.subplots(subplot_kw={"polar": True}) + + # Get a color array + color_array = cm.get_cmap(color_map, len(var_bins)) + + for wd_idx, wd in enumerate(wd_bins): + rects = [] + freq_table_sub = freq_table[wd_idx, :].flatten() + for var_idx, ws in reversed(list(enumerate(var_bins))): + plot_val = freq_table_sub[:var_idx].sum() + rects.append( + ax.bar( + np.radians(wd), + plot_val, + width=0.9 * np.radians(wd_step), + color=color_array(var_idx), + edgecolor="k", + ) + ) + + # Configure the plot + ax.legend(reversed(rects), var_bins, **legend_kwargs) + ax.set_theta_direction(-1) + ax.set_theta_offset(np.pi / 2.0) + ax.set_theta_zero_location("N") + ax.set_xticks(np.arange(0, 2 * np.pi, np.pi / 4)) + ax.set_xticklabels(["N", "NE", "E", "SE", "S", "SW", "W", "NW"]) + + return ax + + def plot_ti_over_ws( + self, + ax=None, + marker=".", + ls="-", + color="k", + ): + """ + Plot the mean turbulence intensity against wind speed. + + Args: + ax (:py:class:`matplotlib.pyplot.axes`, optional): The figure axes + on which the mean turbulence intensity is plotted. Defaults to None. + marker (str, optional): Scatter plot marker style. Defaults to ".". + ls (str, optional): Scatter plot line style. Defaults to "None". + color (str, optional): Scatter plot color. Defaults to "k". + + Returns: + :py:class:`matplotlib.pyplot.axes`: A figure axes object containing + the plotted mean turbulence intensities as a function of wind speed. + """ + + # TODO: Plot individual points and std. devs. of TI in addition to mean + # values + + # Set up figure + if ax is None: + _, ax = plt.subplots() + + # get mean TI for each wind speed by averaging along wind direction and + # TI dimensions + mean_ti_values = (self.ti_grid * self.freq_table).sum((0, 2)) / self.freq_table.sum((0, 2)) + + ax.plot(self.wind_speeds, mean_ti_values * 100, marker=marker, ls=ls, color=color) + ax.set_xlabel("Wind Speed (m/s)") + ax.set_ylabel("Mean Turbulence Intensity (%)") + ax.grid(True) + + def assign_value_using_wd_ws_ti_function(self, func, normalize=False): + """ + Use the passed in function to assign new values to the value table. + + Args: + func (function): Function which accepts wind_directions as its + first argument, wind_speeds as its second argument, and + turbulence_intensities as its third argument and returns + values. + normalize (bool, optional): If True, the value array will be + normalized by the mean value. Defaults to False. + + """ + self.value_table = func(self.wd_grid, self.ws_grid, self.ti_grid) + + if normalize: + self.value_table /= np.sum(self.freq_table * self.value_table) + + self._build_gridded_and_flattened_version() + + def assign_value_piecewise_linear( + self, + value_zero_ws=1.425, + ws_knee=4.5, + slope_1=0.0, + slope_2=-0.135, + limit_to_zero=False, + normalize=False, + ): + """ + Define value as a continuous piecewise linear function of wind speed + with two line segments. The default parameters yield a value function + that approximates the normalized mean electricity price vs. wind speed + curve for the SPP market in the U.S. for years 2018-2020 from figure 7 + in Simley et al. "The value of wake steering wind farm flow control in + US energy markets," Wind Energy Science, 2024. + https://doi.org/10.5194/wes-9-219-2024. This default value function is + constant at low wind speeds, then linearly decreases above 4.5 m/s. + + Args: + value_zero_ws (float, optional): The value when wind speed is zero. + Defaults to 1.425. + ws_knee (float, optional): The wind speed separating line segments + 1 and 2. Default = 4.5 m/s. + slope_1 (float, optional): The slope of the first line segment + (unit of value per m/s). Defaults to zero. + slope_2 (float, optional): The slope of the second line segment + (unit of value per m/s). Defaults to -0.135. + limit_to_zero (bool, optional): If True, negative values will be + set to zero. Defaults to False. + normalize (bool, optional): If True, the value array will be + normalized by the mean value. Defaults to False. + """ + + def piecewise_linear_value_func(wind_directions, wind_speeds, turbulence_intensities): + value = np.zeros_like(wind_speeds, dtype=float) + value[wind_speeds < ws_knee] = ( + slope_1 * wind_speeds[wind_speeds < ws_knee] + value_zero_ws + ) + + offset_2 = (slope_1 - slope_2) * ws_knee + value_zero_ws + + value[wind_speeds >= ws_knee] = slope_2 * wind_speeds[wind_speeds >= ws_knee] + offset_2 + + if limit_to_zero: + value[value < 0] = 0.0 + + return value + + self.assign_value_using_wd_ws_ti_function(piecewise_linear_value_func, normalize) + + def plot_value_over_ws( + self, + ax=None, + marker=".", + ls="None", + color="k", + ): + """ + Scatter plot the value of the energy generated against wind speed. + + Args: + ax (:py:class:`matplotlib.pyplot.axes`, optional): The figure axes + on which the value is plotted. Defaults to None. + marker (str, optional): Scatter plot marker style. Defaults to ".". + ls (str, optional): Scatter plot line style. Defaults to "None". + color (str, optional): Scatter plot color. Defaults to "k". + + Returns: + :py:class:`matplotlib.pyplot.axes`: A figure axes object containing + the plotted value as a function of wind speed. + """ + + # TODO: Plot mean and std. devs. of value in each ws bin in addition to + # individual points + + # Set up figure + if ax is None: + _, ax = plt.subplots() + + ax.plot(self.ws_flat, self.value_table_flat, marker=marker, ls=ls, color=color) + ax.set_xlabel("Wind Speed (m/s)") + ax.set_ylabel("Value") + ax.grid(True) + + @staticmethod + def read_csv_long( + file_path: str, + ws_col: str = "wind_speeds", + wd_col: str = "wind_directions", + ti_col: str = "turbulence_intensities", + freq_col: str | None = None, + sep: str = ",", + ) -> WindTIRose: + """ + Read a long-formatted CSV file into the WindTIRose object. By long, what is meant + is that the wind speed, wind direction and turbulence intensities + combination is given for each row in the + CSV file. The wind speed, wind direction, and turbulence intensity are + given in separate columns, and the frequency of occurrence of each combination + is given in a separate column. The frequency column is optional, and if not + provided, uniform frequency of all bins is assumed. + + Args: + file_path (str): Path to the CSV file. + ws_col (str): Name of the column in the CSV file that contains the wind speed + values. Defaults to 'wind_speeds'. + wd_col (str): Name of the column in the CSV file that contains the wind direction + values. Defaults to 'wind_directions'. + ti_col (str): Name of the column in the CSV file that contains + the turbulence intensity values. + freq_col (str): Name of the column in the CSV file that contains the frequency + values. Defaults to None in which case constant frequency assumed. + sep (str): Delimiter to use. Defaults to ','. + + Returns: + WindRose: Wind rose object created from the CSV file. + """ + + # Read in the CSV file + df = pd.read_csv(file_path, sep=sep) + + # Check that the required columns are present + if ws_col not in df.columns: + raise ValueError(f"Column {ws_col} not found in CSV file") + if wd_col not in df.columns: + raise ValueError(f"Column {wd_col} not found in CSV file") + if ti_col not in df.columns: + raise ValueError(f"Column {ti_col} not found in CSV file") + if freq_col not in df.columns and freq_col is not None: + raise ValueError(f"Column {freq_col} not found in CSV file") + + # Get the wind speed, wind direction, and turbulence intensity values + wind_directions = df[wd_col].values + wind_speeds = df[ws_col].values + turbulence_intensities = df[ti_col].values + if freq_col is not None: + freq_values = df[freq_col].values + else: + freq_values = np.ones(len(wind_speeds)) + + # Normalize freq_values + freq_values = freq_values / np.sum(freq_values) + + # Get the unique values of wind directions and wind speeds + unique_wd = np.unique(wind_directions) + unique_ws = np.unique(wind_speeds) + unique_ti = np.unique(turbulence_intensities) + + # Get the step side for wind direction and wind speed + wd_step = unique_wd[1] - unique_wd[0] + ws_step = unique_ws[1] - unique_ws[0] + ti_step = unique_ti[1] - unique_ti[0] + + # Now use TimeSeries to create a wind rose + time_series = TimeSeries(wind_directions, wind_speeds, turbulence_intensities) + + # Now build a new wind rose using the new steps + return time_series.to_WindTIRose( + wd_step=wd_step, ws_step=ws_step, ti_step=ti_step, bin_weights=freq_values + ) + + +class TimeSeries(WindDataBase): + """ + The TimeSeries class is used to drive FLORIS and optimization operations in + which the inflow is by a sequence of wind direction, wind speed and + turbulence intensity values. Each input of wind direction, wind speed, and + turbulence intensity can be assigned as an array of values or a single value. + At least one of wind_directions, wind_speeds, or turbulence_intensities must + be an array. If arrays are provided, they must be the same length as the + other arrays or the single values. If single values are provided, then an + array of the same length as the other arrays will be created with the single + value. + + Args: + wind_directions (float, NDArrayFloat): Wind direction. Can be a single + value or an array of values. + wind_speeds (float, NDArrayFloat): Wind speed. Can be a single value or + an array of values. + turbulence_intensities (float, NDArrayFloat): Turbulence intensity. Can be + a single value or an array of values. + values (NDArrayFloat, optional): Values associated with each wind + direction, wind speed, and turbulence intensity. Defaults to None. + heterogeneous_inflow_config_by_wd (dict, optional): A dictionary containing the following + keys. Defaults to None. + * 'speed_multipliers': A 2D NumPy array (size num_wd x num_points) + of speed multipliers. + * 'wind_directions': A 1D NumPy array (size num_wd) of wind directions (degrees). + * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). + * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + heterogeneous_inflow_config (dict, optional): A dictionary containing the following keys. + Defaults to None. + * 'speed_multipliers': A 2D NumPy array (size n_findex x num_points) + of speed multipliers. + * 'x': A 1D NumPy array (size num_points) of x-coordinates (meters). + * 'y': A 1D NumPy array (size num_points) of y-coordinates (meters). + """ + + def __init__( + self, + wind_directions: float | NDArrayFloat, + wind_speeds: float | NDArrayFloat, + turbulence_intensities: float | NDArrayFloat, + values: NDArrayFloat | None = None, + heterogeneous_inflow_config_by_wd: dict | None = None, + heterogeneous_inflow_config: dict | None = None, + ): + # At least one of wind_directions, wind_speeds, or turbulence_intensities must be an array + if ( + not isinstance(wind_directions, np.ndarray) + and not isinstance(wind_speeds, np.ndarray) + and not isinstance(turbulence_intensities, np.ndarray) + ): + raise TypeError( + "At least one of wind_directions, wind_speeds, or " + " turbulence_intensities must be a NumPy array" + ) + + # For each of wind_directions, wind_speeds, and turbulence_intensities provided as + # an array, confirm they are the same length + if isinstance(wind_directions, np.ndarray) and isinstance(wind_speeds, np.ndarray): + if len(wind_directions) != len(wind_speeds): + raise ValueError( + "wind_directions and wind_speeds must be the same length if provided as arrays" + ) + + if isinstance(wind_directions, np.ndarray) and isinstance( + turbulence_intensities, np.ndarray + ): + if len(wind_directions) != len(turbulence_intensities): + raise ValueError( + "wind_directions and turbulence_intensities must be " + "the same length if provided as arrays" + ) + + if isinstance(wind_speeds, np.ndarray) and isinstance(turbulence_intensities, np.ndarray): + if len(wind_speeds) != len(turbulence_intensities): + raise ValueError( + "wind_speeds and turbulence_intensities must be the " + "same length if provided as arrays" + ) + + # For each of wind_directions, wind_speeds, and turbulence_intensities + # provided as a single value, set them + # to be the same length as those passed in as arrays + if isinstance(wind_directions, float): + if isinstance(wind_speeds, np.ndarray): + wind_directions = np.full(len(wind_speeds), wind_directions) + elif isinstance(turbulence_intensities, np.ndarray): + wind_directions = np.full(len(turbulence_intensities), wind_directions) + + if isinstance(wind_speeds, float): + if isinstance(wind_directions, np.ndarray): + wind_speeds = np.full(len(wind_directions), wind_speeds) + elif isinstance(turbulence_intensities, np.ndarray): + wind_speeds = np.full(len(turbulence_intensities), wind_speeds) + + if isinstance(turbulence_intensities, float): + if isinstance(wind_directions, np.ndarray): + turbulence_intensities = np.full(len(wind_directions), turbulence_intensities) + elif isinstance(wind_speeds, np.ndarray): + turbulence_intensities = np.full(len(wind_speeds), turbulence_intensities) + + # If values is not None, must be same length as wind_directions/wind_speeds/ + if values is not None: + if len(wind_directions) != len(values): + raise ValueError("wind_directions and values must be the same length") + + self.wind_directions = wind_directions + self.wind_speeds = wind_speeds + self.turbulence_intensities = turbulence_intensities + self.values = values + + # Only one of heterogeneous_inflow_config_by_wd and + # heterogeneous_inflow_config can be not None + if ( + heterogeneous_inflow_config_by_wd is not None + and heterogeneous_inflow_config is not None + ): + raise ValueError( + "Only one of heterogeneous_inflow_config_by_wd and heterogeneous_inflow_config " + "can be not None" + ) + + # if heterogeneous_inflow_config is not None, then the speed_multipliers + # must be the same length as wind_directions + # in the 0th dimension + if heterogeneous_inflow_config is not None: + if len(heterogeneous_inflow_config["speed_multipliers"]) != len(wind_directions): + raise ValueError("speed_multipliers must be the same length as wind_directions") + + # Check that heterogeneous_inflow_config_by_wd is a dictionary with keys: + # speed_multipliers, wind_directions, x and y + self.check_heterogeneous_inflow_config_by_wd(heterogeneous_inflow_config_by_wd) + self.check_heterogeneous_inflow_config(heterogeneous_inflow_config) + + # Then save + self.heterogeneous_inflow_config_by_wd = heterogeneous_inflow_config_by_wd + self.heterogeneous_inflow_config = heterogeneous_inflow_config + + # Record findex + self.n_findex = len(self.wind_directions) + + def unpack(self): + """ + Unpack the time series data in a manner consistent with wind rose unpack + """ + + # to match wind_rose, make a uniform frequency + uniform_frequency = np.ones_like(self.wind_directions) + uniform_frequency = uniform_frequency / uniform_frequency.sum() + + # If heterogeneous_inflow_config_by_wd is not None, then update + # heterogeneous_inflow_config to match wind_directions_unpack + if self.heterogeneous_inflow_config_by_wd is not None: + heterogeneous_inflow_config = self.get_heterogeneous_inflow_config( + self.heterogeneous_inflow_config_by_wd, self.wind_directions + ) + else: + heterogeneous_inflow_config = self.heterogeneous_inflow_config + + return ( + self.wind_directions, + self.wind_speeds, + self.turbulence_intensities, + uniform_frequency, + self.values, + heterogeneous_inflow_config, + ) + + def _wrap_wind_directions_near_360(self, wind_directions, wd_step): + """ + Wraps the wind directions using `wd_step` to produce a wrapped version + where values between [360 - wd_step/2.0, 360] get mapped to negative numbers + for binning. + + Args: + wind_directions (NDArrayFloat): NumPy array of wind directions. + wd_step (float): Step size for wind direction. + + Returns: + NDArrayFloat: Wrapped version of wind directions. + + """ + wind_directions_wrapped = wind_directions.copy() + mask = wind_directions_wrapped >= 360 - wd_step / 2.0 + wind_directions_wrapped[mask] = wind_directions_wrapped[mask] - 360.0 + return wind_directions_wrapped + + def assign_ti_using_wd_ws_function(self, func): + """ + Use the passed in function to new assign values to turbulence_intensities + + Args: + func (function): Function which accepts wind_directions as its + first argument and wind_speeds as second argument and returns + turbulence_intensities + """ + self.turbulence_intensities = func(self.wind_directions, self.wind_speeds) + + def assign_ti_using_IEC_method(self, Iref=0.07, offset=3.8): + """ + Define TI as a function of wind speed by specifying an Iref and offset + value as in the normal turbulence model in the IEC 61400-1 standard + + Args: + Iref (float): Reference turbulence level, defined as the expected + value of TI at 15 m/s. Default = 0.07. Note this value is + lower than the values of Iref for turbulence classes A, B, and + C in the IEC standard (0.16, 0.14, and 0.12, respectively), but + produces TI values more in line with those typically used in + FLORIS. When the default Iref and offset are used, the TI at + 8 m/s is 8.6%. + offset (float): Offset value to equation. Default = 3.8, as defined + in the IEC standard to give the expected value of TI for + each wind speed. + """ + if (Iref < 0) or (Iref > 1): + raise ValueError("Iref must be >= 0 and <=1") + + def iref_func(wind_directions, wind_speeds): + sigma_1 = Iref * (0.75 * wind_speeds + offset) + return sigma_1 / wind_speeds + + self.assign_ti_using_wd_ws_function(iref_func) + + def assign_value_using_wd_ws_function(self, func, normalize=False): + """ + Use the passed in function to assign new values to the value table. + + Args: + func (function): Function which accepts wind_directions as its + first argument and wind_speeds as second argument and returns + values. + normalize (bool, optional): If True, the value array will be + normalized by the mean value. Defaults to False. + + """ + self.values = func(self.wind_directions, self.wind_speeds) + + if normalize: + self.values /= np.mean(self.values) + + def assign_value_piecewise_linear( + self, + value_zero_ws=1.425, + ws_knee=4.5, + slope_1=0.0, + slope_2=-0.135, + limit_to_zero=False, + normalize=False, + ): + """ + Define value as a continuous piecewise linear function of wind speed + with two line segments. The default parameters yield a value function + that approximates the normalized mean electricity price vs. wind speed + curve for the SPP market in the U.S. for years 2018-2020 from figure 7 + in Simley et al. "The value of wake steering wind farm flow control in + US energy markets," Wind Energy Science, 2024. + https://doi.org/10.5194/wes-9-219-2024. This default value function is + constant at low wind speeds, then linearly decreases above 4.5 m/s. + + Args: + value_zero_ws (float, optional): The value when wind speed is zero. + Defaults to 1.425. + ws_knee (float, optional): The wind speed separating line segments + 1 and 2. Default = 4.5 m/s. + slope_1 (float, optional): The slope of the first line segment + (unit of value per m/s). Defaults to zero. + slope_2 (float, optional): The slope of the second line segment + (unit of value per m/s). Defaults to -0.135. + limit_to_zero (bool, optional): If True, negative values will be + set to zero. Defaults to False. + normalize (bool, optional): If True, the value array will be + normalized by the mean value. Defaults to False. + """ + + def piecewise_linear_value_func(wind_directions, wind_speeds): + value = np.zeros_like(wind_speeds, dtype=float) + value[wind_speeds < ws_knee] = ( + slope_1 * wind_speeds[wind_speeds < ws_knee] + value_zero_ws + ) + + offset_2 = (slope_1 - slope_2) * ws_knee + value_zero_ws + + value[wind_speeds >= ws_knee] = slope_2 * wind_speeds[wind_speeds >= ws_knee] + offset_2 + + if limit_to_zero: + value[value < 0] = 0.0 + + return value + + self.assign_value_using_wd_ws_function(piecewise_linear_value_func, normalize) + + def to_WindRose(self, wd_step=2.0, ws_step=1.0, wd_edges=None, ws_edges=None, bin_weights=None): + """ + Converts the TimeSeries data to a WindRose. + + Args: + wd_step (float, optional): Step size for wind direction (default is 2.0). + ws_step (float, optional): Step size for wind speed (default is 1.0). + wd_edges (NDArrayFloat, optional): Custom wind direction edges. Defaults to None. + ws_edges (NDArrayFloat, optional): Custom wind speed edges. Defaults to None. + bin_weights (NDArrayFloat, optional): Bin weights for resampling. Note these + are primarily used by the aggregate() method. + Defaults to None. + + Returns: + WindRose: A WindRose object based on the TimeSeries data. + + Notes: + - If `wd_edges` is defined, it uses it to produce the bin centers. + - If `wd_edges` is not defined, it determines `wd_edges` from the step and data. + - If `ws_edges` is defined, it uses it for wind speed edges. + - If `ws_edges` is not defined, it determines `ws_edges` from the step and data. + """ + + # If wd_edges is defined, then use it to produce the bin centers + if wd_edges is not None: + wd_step = wd_edges[1] - wd_edges[0] + + # use wd_step to produce a wrapped version of wind_directions + wind_directions_wrapped = self._wrap_wind_directions_near_360( + self.wind_directions, wd_step + ) + + # Else, determine wd_edges from the step and data + else: + wd_edges = np.arange(0.0 - wd_step / 2.0, 360.0, wd_step) + + # use wd_step to produce a wrapped version of wind_directions + wind_directions_wrapped = self._wrap_wind_directions_near_360( + self.wind_directions, wd_step + ) + + # Only keep the range with values in it + wd_edges = wd_edges[wd_edges + wd_step > wind_directions_wrapped.min()] + wd_edges = wd_edges[wd_edges - wd_step <= wind_directions_wrapped.max()] + + # Define the centers from the edges + wd_centers = wd_edges[:-1] + wd_step / 2.0 + + # Repeat for wind speeds + if ws_edges is not None: + ws_step = ws_edges[1] - ws_edges[0] + + else: + ws_edges = np.arange(0.0 - ws_step / 2.0, 50.0, ws_step) + + # Only keep the range with values in it + ws_edges = ws_edges[ws_edges + ws_step > self.wind_speeds.min()] + ws_edges = ws_edges[ws_edges - ws_step <= self.wind_speeds.max()] + + # Define the centers from the edges + ws_centers = ws_edges[:-1] + ws_step / 2.0 + + # Now use pandas to get the tables need for wind rose + df = pd.DataFrame( + { + "wd": wind_directions_wrapped, + "ws": self.wind_speeds, + "freq_val": np.ones(len(wind_directions_wrapped)), + } + ) + + # If bin_weights are passed in, apply these to the frequency + # this is mostly used when resampling the wind rose + if bin_weights is not None: + df = df.assign(freq_val=df["freq_val"] * bin_weights) + + # Add turbulence intensities to dataframe + df = df.assign(turbulence_intensities=self.turbulence_intensities) + + # If values is not none, add to dataframe + if self.values is not None: + df = df.assign(values=self.values) + + # Bin wind speed and wind direction and then group things up + df = ( + df.assign( + wd_bin=pd.cut( + df.wd, bins=wd_edges, labels=wd_centers, right=False, include_lowest=True + ) + ) + .assign( + ws_bin=pd.cut( + df.ws, bins=ws_edges, labels=ws_centers, right=False, include_lowest=True + ) + ) + .drop(["wd", "ws"], axis=1) + ) + + # Convert wd_bin and ws_bin to categoricals to ensure all combinations + # are considered and then group + wd_cat = CategoricalDtype(categories=wd_centers, ordered=True) + ws_cat = CategoricalDtype(categories=ws_centers, ordered=True) + + df = ( + df.assign(wd_bin=df["wd_bin"].astype(wd_cat)) + .assign(ws_bin=df["ws_bin"].astype(ws_cat)) + .groupby(["wd_bin", "ws_bin"], observed=False) + .agg(["sum", "mean"]) + ) + # Flatten and combine levels using an underscore + df.columns = ["_".join(col) for col in df.columns] + + # Collect the frequency table and reshape + freq_table = df["freq_val_sum"].values.copy() + freq_table = freq_table / freq_table.sum() + freq_table = freq_table.reshape((len(wd_centers), len(ws_centers))) + + # Compute the TI table + ti_table = df["turbulence_intensities_mean"].values.copy() + ti_table = ti_table.reshape((len(wd_centers), len(ws_centers))) + + # If values is not none, compute the table + if self.values is not None: + value_table = df["values_mean"].values.copy() + value_table = value_table.reshape((len(wd_centers), len(ws_centers))) + else: + value_table = None + + # Return a WindRose + return WindRose( + wd_centers, + ws_centers, + ti_table, + freq_table, + value_table, + self.heterogeneous_inflow_config_by_wd, + ) + + def to_WindTIRose( + self, + wd_step=2.0, + ws_step=1.0, + ti_step=0.02, + wd_edges=None, + ws_edges=None, + ti_edges=None, + bin_weights=None, + ): + """ + Converts the TimeSeries data to a WindTIRose. + + Args: + wd_step (float, optional): Step size for wind direction (default is 2.0). + ws_step (float, optional): Step size for wind speed (default is 1.0). + ti_step (float, optional): Step size for turbulence intensity (default is 0.02). + wd_edges (NDArrayFloat, optional): Custom wind direction edges. Defaults to None. + ws_edges (NDArrayFloat, optional): Custom wind speed edges. Defaults to None. + ti_edges (NDArrayFloat, optional): Custom turbulence intensity + edges. Defaults to None. + bin_weights (NDArrayFloat, optional): Bin weights for resampling. Note these + are primarily used by the aggregate() method. + Defaults to None. + + Returns: + WindRose: A WindTIRose object based on the TimeSeries data. + + Notes: + - If `wd_edges` is defined, it uses it to produce the wind direction bin edges. + - If `wd_edges` is not defined, it determines `wd_edges` from the step and data. + - If `ws_edges` is defined, it uses it for wind speed edges. + - If `ws_edges` is not defined, it determines `ws_edges` from the step and data. + - If `ti_edges` is defined, it uses it for turbulence intensity edges. + - If `ti_edges` is not defined, it determines `ti_edges` from the step and data. + """ + + # If wd_edges is defined, then use it to produce the bin centers + if wd_edges is not None: + wd_step = wd_edges[1] - wd_edges[0] + + # use wd_step to produce a wrapped version of wind_directions + wind_directions_wrapped = self._wrap_wind_directions_near_360( + self.wind_directions, wd_step + ) + + # Else, determine wd_edges from the step and data + else: + wd_edges = np.arange(0.0 - wd_step / 2.0, 360.0, wd_step) + + # use wd_step to produce a wrapped version of wind_directions + wind_directions_wrapped = self._wrap_wind_directions_near_360( + self.wind_directions, wd_step + ) + + # Only keep the range with values in it + wd_edges = wd_edges[wd_edges + wd_step > wind_directions_wrapped.min()] + wd_edges = wd_edges[wd_edges - wd_step <= wind_directions_wrapped.max()] + + # Define the centers from the edges + wd_centers = wd_edges[:-1] + wd_step / 2.0 + + # Repeat for wind speeds + if ws_edges is not None: + ws_step = ws_edges[1] - ws_edges[0] + + else: + ws_edges = np.arange(0.0 - ws_step / 2.0, 50.0, ws_step) + + # Only keep the range with values in it + ws_edges = ws_edges[ws_edges + ws_step > self.wind_speeds.min()] + ws_edges = ws_edges[ws_edges - ws_step <= self.wind_speeds.max()] + + # Define the centers from the edges + ws_centers = ws_edges[:-1] + ws_step / 2.0 + + # Repeat for turbulence intensities + if ti_edges is not None: + ti_step = ti_edges[1] - ti_edges[0] + + else: + ti_edges = np.arange(0.0 - ti_step / 2.0, 1.0, ti_step) + + # Only keep the range with values in it + ti_edges = ti_edges[ti_edges + ti_step > self.turbulence_intensities.min()] + ti_edges = ti_edges[ti_edges - ti_step <= self.turbulence_intensities.max()] + + # Define the centers from the edges + ti_centers = ti_edges[:-1] + ti_step / 2.0 + + # Now use pandas to get the tables need for wind rose + df = pd.DataFrame( + { + "wd": wind_directions_wrapped, + "ws": self.wind_speeds, + "ti": self.turbulence_intensities, + "freq_val": np.ones(len(wind_directions_wrapped)), + } + ) + + # If bin_weights are passed in, apply these to the frequency + # this is mostly used when resampling the wind rose + if bin_weights is not None: + df = df.assign(freq_val=df["freq_val"] * bin_weights) + + # If values is not none, add to dataframe + if self.values is not None: + df = df.assign(values=self.values) + + # Bin wind speed, wind direction, and turbulence intensity and then group things up + df = ( + df.assign( + wd_bin=pd.cut( + df.wd, bins=wd_edges, labels=wd_centers, right=False, include_lowest=True + ) + ) + .assign( + ws_bin=pd.cut( + df.ws, bins=ws_edges, labels=ws_centers, right=False, include_lowest=True + ) + ) + .assign( + ti_bin=pd.cut( + df.ti, bins=ti_edges, labels=ti_centers, right=False, include_lowest=True + ) + ) + .drop(["wd", "ws", "ti"], axis=1) + ) + + # Convert wd_bin, ws_bin, and ti_bin to categoricals to ensure all + # combinations are considered and then group + wd_cat = CategoricalDtype(categories=wd_centers, ordered=True) + ws_cat = CategoricalDtype(categories=ws_centers, ordered=True) + ti_cat = CategoricalDtype(categories=ti_centers, ordered=True) + + df = ( + df.assign(wd_bin=df["wd_bin"].astype(wd_cat)) + .assign(ws_bin=df["ws_bin"].astype(ws_cat)) + .assign(ti_bin=df["ti_bin"].astype(ti_cat)) + .groupby(["wd_bin", "ws_bin", "ti_bin"], observed=False) + .agg(["sum", "mean"]) + ) + # Flatten and combine levels using an underscore + df.columns = ["_".join(col) for col in df.columns] + + # Collect the frequency table and reshape + freq_table = df["freq_val_sum"].values.copy() + freq_table = freq_table / freq_table.sum() + freq_table = freq_table.reshape((len(wd_centers), len(ws_centers), len(ti_centers))) + + # If values is not none, compute the table + if self.values is not None: + value_table = df["values_mean"].values.copy() + value_table = value_table.reshape((len(wd_centers), len(ws_centers), len(ti_centers))) + else: + value_table = None + + # Return a WindTIRose + return WindTIRose( + wd_centers, + ws_centers, + ti_centers, + freq_table, + value_table, + self.heterogeneous_inflow_config_by_wd, + ) diff --git a/profiling/linux_perf.py b/profiling/linux_perf.py index 150eeadf4..c6da03e2d 100644 --- a/profiling/linux_perf.py +++ b/profiling/linux_perf.py @@ -1,16 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from contextlib import contextmanager from os import getpid diff --git a/profiling/profiling.py b/profiling/profiling.py index b0432d991..a4fcc769d 100644 --- a/profiling/profiling.py +++ b/profiling/profiling.py @@ -1,16 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation # import re # import sys @@ -22,12 +9,12 @@ from conftest import SampleInputs -from floris.simulation import Floris +from floris.core import Core def run_floris(): - floris = Floris.from_file("examples/example_input.yaml") - return floris + core = Core.from_file("examples/example_input.yaml") + return core if __name__=="__main__": # if len(sys.argv) > 1: @@ -43,25 +30,25 @@ def run_floris(): sample_inputs = SampleInputs() - sample_inputs.floris["wake"]["model_strings"]["velocity_model"] = "gauss" - sample_inputs.floris["wake"]["model_strings"]["deflection_model"] = "gauss" - sample_inputs.floris["wake"]["enable_secondary_steering"] = True - sample_inputs.floris["wake"]["enable_yaw_added_recovery"] = True - sample_inputs.floris["wake"]["enable_transverse_velocities"] = True + sample_inputs.core["wake"]["model_strings"]["velocity_model"] = "gauss" + sample_inputs.core["wake"]["model_strings"]["deflection_model"] = "gauss" + sample_inputs.core["wake"]["enable_secondary_steering"] = True + sample_inputs.core["wake"]["enable_yaw_added_recovery"] = True + sample_inputs.core["wake"]["enable_transverse_velocities"] = True N_TURBINES = 100 - N_WIND_DIRECTIONS = 72 - N_WIND_SPEEDS = 25 + N_FINDEX = 72 * 25 # Size of a characteristic wind rose - TURBINE_DIAMETER = sample_inputs.floris["farm"]["turbine_type"][0]["rotor_diameter"] - sample_inputs.floris["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * i for i in range(N_TURBINES)] - sample_inputs.floris["farm"]["layout_y"] = [0.0 for i in range(N_TURBINES)] + TURBINE_DIAMETER = sample_inputs.core["farm"]["turbine_type"][0]["rotor_diameter"] + sample_inputs.core["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * i for i in range(N_TURBINES)] + sample_inputs.core["farm"]["layout_y"] = [0.0 for i in range(N_TURBINES)] - sample_inputs.floris["flow_field"]["wind_directions"] = N_WIND_DIRECTIONS * [270.0] - sample_inputs.floris["flow_field"]["wind_speeds"] = N_WIND_SPEEDS * [8.0] + sample_inputs.core["flow_field"]["wind_directions"] = N_FINDEX * [270.0] + sample_inputs.core["flow_field"]["wind_speeds"] = N_FINDEX * [8.0] + sample_inputs.core["flow_field"]["turbulence_intensities"] = N_FINDEX * [0.06] N = 1 for i in range(N): - floris = Floris.from_dict(copy.deepcopy(sample_inputs.floris)) - floris.initialize_domain() - floris.steady_state_atmospheric_condition() + core = Core.from_dict(copy.deepcopy(sample_inputs.core)) + core.initialize_domain() + core.steady_state_atmospheric_condition() diff --git a/profiling/quality_metrics.py b/profiling/quality_metrics.py index 66680e798..142480550 100644 --- a/profiling/quality_metrics.py +++ b/profiling/quality_metrics.py @@ -1,17 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import copy import time @@ -20,14 +6,18 @@ import numpy as np from linux_perf import perf -from floris.simulation import Floris - +from floris.core import Core -WIND_DIRECTIONS = np.arange(0, 360.0, 5) -N_WIND_DIRECTIONS = len(WIND_DIRECTIONS) -WIND_SPEEDS = np.arange(8.0, 12.0, 0.2) -N_WIND_SPEEDS = len(WIND_SPEEDS) +wd_grid, ws_grid = np.meshgrid( + np.arange(0, 360.0, 5), # wind directions + np.arange(8.0, 12.0, 0.2), # wind speeds + indexing="ij" +) +WIND_DIRECTIONS = wd_grid.flatten() +WIND_SPEEDS = ws_grid.flatten() +TURBULENCE_INTENSITIES = np.ones_like(WIND_DIRECTIONS) * 0.1 +N_FINDEX = len(WIND_DIRECTIONS) N_TURBINES = 3 X_COORDS, Y_COORDS = np.meshgrid( @@ -43,9 +33,9 @@ def run_floris(input_dict): try: start = time.perf_counter() - floris = Floris.from_dict(copy.deepcopy(input_dict.floris)) - floris.initialize_domain() - floris.steady_state_atmospheric_condition() + core = Core.from_dict(copy.deepcopy(input_dict.core)) + core.initialize_domain() + core.steady_state_atmospheric_condition() end = time.perf_counter() return end - start except KeyError: @@ -67,53 +57,53 @@ def time_profile(input_dict): def test_time_jensen_jimenez(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "jensen" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "jimenez" + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "jensen" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "jimenez" return time_profile(sample_inputs_fixture) def test_time_gauss(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "gauss" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "gauss" + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "gauss" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "gauss" return time_profile(sample_inputs_fixture) def test_time_gch(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "gauss" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "gauss" - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = True - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = True + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "gauss" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "gauss" + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = True + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True return time_profile(sample_inputs_fixture) def test_time_cumulative(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "cc" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "gauss" + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "cc" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "gauss" return time_profile(sample_inputs_fixture) def memory_profile(input_dict): # Run once to initialize Python and memory - floris = Floris.from_dict(copy.deepcopy(input_dict.floris)) - floris.initialize_domain() - floris.steady_state_atmospheric_condition() + core = Core.from_dict(copy.deepcopy(input_dict.core)) + core.initialize_domain() + core.steady_state_atmospheric_condition() with perf(): for i in range(N_ITERATIONS): - floris = Floris.from_dict(copy.deepcopy(input_dict.floris)) - floris.initialize_domain() - floris.steady_state_atmospheric_condition() + core = Core.from_dict(copy.deepcopy(input_dict.core)) + core.initialize_domain() + core.steady_state_atmospheric_condition() print( "Size of one data array: " - f"{64 * N_WIND_DIRECTIONS * N_WIND_SPEEDS * N_TURBINES * 25 / (1000 * 1000)} MB" + f"{64 * N_FINDEX * N_TURBINES * 25 / (1000 * 1000)} MB" ) def test_mem_jensen_jimenez(sample_inputs_fixture): - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = "jensen" - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = "jimenez" + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = "jensen" + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = "jimenez" memory_profile(sample_inputs_fixture) @@ -123,10 +113,11 @@ def test_mem_jensen_jimenez(sample_inputs_fixture): from conftest import SampleInputs sample_inputs = SampleInputs() - sample_inputs.floris["farm"]["layout_x"] = X_COORDS - sample_inputs.floris["farm"]["layout_y"] = Y_COORDS - sample_inputs.floris["flow_field"]["wind_directions"] = WIND_DIRECTIONS - sample_inputs.floris["flow_field"]["wind_speeds"] = WIND_SPEEDS + sample_inputs.core["farm"]["layout_x"] = X_COORDS + sample_inputs.core["farm"]["layout_y"] = Y_COORDS + sample_inputs.core["flow_field"]["wind_directions"] = WIND_DIRECTIONS + sample_inputs.core["flow_field"]["wind_speeds"] = WIND_SPEEDS + sample_inputs.core["flow_field"]["turbulence_intensities"] = TURBULENCE_INTENSITIES print() print("### Memory profiling") diff --git a/profiling/serial_vectorize.py b/profiling/serial_vectorize.py index 7c6c33207..fb66a1652 100644 --- a/profiling/serial_vectorize.py +++ b/profiling/serial_vectorize.py @@ -11,7 +11,7 @@ def time_vec(input_dict): start = time.time() - floris = Floris(input_dict=input_dict.floris) + floris = Floris(input_dict=input_dict.core) end = time.time() init_time = end - start @@ -29,11 +29,11 @@ def time_serial(input_dict, wd, ws): for i, (d, s) in enumerate(zip(wd, ws)): - input_dict.floris["flow_field"]["wind_directions"] = [d] - input_dict.floris["flow_field"]["wind_speeds"] = [s] + input_dict.core["flow_field"]["wind_directions"] = [d] + input_dict.core["flow_field"]["wind_speeds"] = [s] start = time.time() - floris = Floris(input_dict=input_dict.floris) + floris = Floris(input_dict=input_dict.core) end = time.time() init_times[i] = end - start @@ -48,9 +48,9 @@ def time_serial(input_dict, wd, ws): plt.figure() sample_inputs = SampleInputs() - sample_inputs.floris["flow_field"]["wind_directions"] = [270.0] - sample_inputs.floris["flow_field"]["wind_speeds"] = [8.0] - TURBINE_DIAMETER = sample_inputs.floris["turbine"]["rotor_diameter"] + sample_inputs.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs.core["flow_field"]["wind_speeds"] = [8.0] + TURBINE_DIAMETER = sample_inputs.core["turbine"]["rotor_diameter"] N = 5 simulation_size = np.arange(N) @@ -61,8 +61,8 @@ def time_serial(input_dict, wd, ws): vectorize_scaling_inputs = copy.deepcopy(sample_inputs) factor = (i+1) * 50 - vectorize_scaling_inputs.floris["flow_field"]["wind_directions"] = [270.0] - vectorize_scaling_inputs.floris["flow_field"]["wind_speeds"] = factor * [8.0] + vectorize_scaling_inputs.core["flow_field"]["wind_directions"] = [270.0] + vectorize_scaling_inputs.core["flow_field"]["wind_speeds"] = factor * [8.0] vectorize_init[i], vectorize_calc[i] = time_vec(copy.deepcopy(vectorize_scaling_inputs)) print("vectorize", i, vectorize_calc[i]) @@ -90,16 +90,16 @@ def time_serial(input_dict, wd, ws): # More than 1 turbine n_turbines = 10 - sample_inputs.floris["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * j for j in range(n_turbines)] - sample_inputs.floris["farm"]["layout_y"] = n_turbines * [0.0] + sample_inputs.core["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * j for j in range(n_turbines)] + sample_inputs.core["farm"]["layout_y"] = n_turbines * [0.0] vectorize_init, vectorize_calc = np.zeros(N), np.zeros(N) for i in range(N): vectorize_scaling_inputs = copy.deepcopy(sample_inputs) factor = (i+1) * 50 - vectorize_scaling_inputs.floris["flow_field"]["wind_speeds"] = factor * [8.0] - vectorize_scaling_inputs.floris["flow_field"]["wind_directions"] = [270.0] + vectorize_scaling_inputs.core["flow_field"]["wind_speeds"] = factor * [8.0] + vectorize_scaling_inputs.core["flow_field"]["wind_directions"] = [270.0] vectorize_init[i], vectorize_calc[i] = time_vec(copy.deepcopy(vectorize_scaling_inputs)) print("vectorize", i, vectorize_calc[i]) diff --git a/profiling/timing.py b/profiling/timing.py index 3083403da..b03cd23db 100644 --- a/profiling/timing.py +++ b/profiling/timing.py @@ -11,19 +11,19 @@ def time_profile(input_dict): - floris = Floris.from_dict(input_dict.floris) + floris = Floris.from_dict(input_dict.core) start = time.perf_counter() floris.steady_state_atmospheric_condition() end = time.perf_counter() return end - start def internal_probe(input_dict): - floris = Floris(input_dict=input_dict.floris) + floris = Floris(input_dict=input_dict.core) internal_quantity = floris.steady_state_atmospheric_condition() return internal_quantity def memory_profile(input_dict): - floris = Floris(input_dict=input_dict.floris) + floris = Floris(input_dict=input_dict.core) mem_usage = memory_profiler.memory_usage( (floris.steady_state_atmospheric_condition, (), {}), max_usage=True @@ -32,10 +32,10 @@ def memory_profile(input_dict): if __name__=="__main__": sample_inputs = SampleInputs() - TURBINE_DIAMETER = sample_inputs.floris["turbine"]["rotor_diameter"] + TURBINE_DIAMETER = sample_inputs.core["turbine"]["rotor_diameter"] # Use Gauss models - sample_inputs.floris["wake"]["model_strings"] = { + sample_inputs.core["wake"]["model_strings"] = { "velocity_model": "gauss", "deflection_model": "gauss", "combination_model": None, @@ -51,8 +51,8 @@ def memory_profile(input_dict): # wind_direction_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # wind_direction_scaling_inputs.floris["flow_field"]["wind_directions"] = factor * [270.0] - # wind_direction_scaling_inputs.floris["flow_field"]["wind_speeds"] = [8.0] + # wind_direction_scaling_inputs.core["flow_field"]["wind_directions"] = factor * [270.0] + # wind_direction_scaling_inputs.core["flow_field"]["wind_speeds"] = [8.0] # wd_calc_time[i] = time_profile(copy.deepcopy(wind_direction_scaling_inputs)) # wd_size[i] = factor @@ -64,8 +64,8 @@ def memory_profile(input_dict): # wind_speed_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # wind_speed_scaling_inputs.floris["flow_field"]["wind_directions"] = [270.0] - # wind_speed_scaling_inputs.floris["flow_field"]["wind_speeds"] = factor * [8.0] + # wind_speed_scaling_inputs.core["flow_field"]["wind_directions"] = [270.0] + # wind_speed_scaling_inputs.core["flow_field"]["wind_speeds"] = factor * [8.0] # ws_calc_time[i] = time_profile(copy.deepcopy(wind_speed_scaling_inputs)) # ws_size[i] = factor @@ -77,11 +77,11 @@ def memory_profile(input_dict): # turbine_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 3 - # turbine_scaling_inputs.floris["farm"]["layout_x"] = [ + # turbine_scaling_inputs.core["farm"]["layout_x"] = [ # 5 * TURBINE_DIAMETER * j # for j in range(factor) # ] - # turbine_scaling_inputs.floris["farm"]["layout_y"] = factor * [0.0] + # turbine_scaling_inputs.core["farm"]["layout_y"] = factor * [0.0] # turb_calc_time[i] = time_profile(copy.deepcopy(turbine_scaling_inputs)) # turb_size[i] = factor @@ -92,14 +92,14 @@ def memory_profile(input_dict): # scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(5): # factor = (i+1) * 2 - # scaling_inputs.floris["farm"]["layout_x"] = [ + # scaling_inputs.core["farm"]["layout_x"] = [ # 5 * TURBINE_DIAMETER * j # for j in range(factor) # ] - # scaling_inputs.floris["farm"]["layout_y"] = factor * [0.0] + # scaling_inputs.core["farm"]["layout_y"] = factor * [0.0] # factor = (i+1) * 20 - # scaling_inputs.floris["flow_field"]["wind_directions"] = factor * [270.0] - # scaling_inputs.floris["flow_field"]["wind_speeds"] = factor * [8.0] + # scaling_inputs.core["flow_field"]["wind_directions"] = factor * [270.0] + # scaling_inputs.core["flow_field"]["wind_speeds"] = factor * [8.0] # internal_quantity[i] = time_profile(scaling_inputs) # print("n turbine", i, internal_quantity[i]) @@ -118,7 +118,7 @@ def memory_profile(input_dict): n_wind_directions = 1 n_wind_speeds = 1 n_turbines = 3 - sample_inputs.floris["wake"]["model_strings"] = { + sample_inputs.core["wake"]["model_strings"] = { # "velocity_model": "jensen", # "deflection_model": "jimenez", "velocity_model": "cc", @@ -126,18 +126,18 @@ def memory_profile(input_dict): "combination_model": None, "turbulence_model": None, } - sample_inputs.floris["solver"] = { + sample_inputs.core["solver"] = { "type": "turbine_grid", "turbine_grid_points": 5 } - # sample_inputs.floris["wake"]["enable_transverse_velocities"] = False - # sample_inputs.floris["wake"]["enable_secondary_steering"] = False - # sample_inputs.floris["wake"]["enable_yaw_added_recovery"] = False - sample_inputs.floris["flow_field"]["wind_directions"] = n_wind_directions * [270.0] - sample_inputs.floris["flow_field"]["wind_speeds"] = n_wind_speeds * [8.0] - sample_inputs.floris["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * j for j in range(n_turbines)] - sample_inputs.floris["farm"]["layout_y"] = n_turbines * [0.0] + # sample_inputs.core["wake"]["enable_transverse_velocities"] = False + # sample_inputs.core["wake"]["enable_secondary_steering"] = False + # sample_inputs.core["wake"]["enable_yaw_added_recovery"] = False + sample_inputs.core["flow_field"]["wind_directions"] = n_wind_directions * [270.0] + sample_inputs.core["flow_field"]["wind_speeds"] = n_wind_speeds * [8.0] + sample_inputs.core["farm"]["layout_x"] = [5 * TURBINE_DIAMETER * j for j in range(n_turbines)] + sample_inputs.core["farm"]["layout_y"] = n_turbines * [0.0] N = 1 times = np.zeros(N) @@ -158,8 +158,8 @@ def memory_profile(input_dict): # wind_direction_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # wind_direction_scaling_inputs.floris["farm"]["wind_directions"] = factor * [270.0] - # wind_direction_scaling_inputs.floris["farm"]["wind_speeds"] = [8.0] + # wind_direction_scaling_inputs.core["farm"]["wind_directions"] = factor * [270.0] + # wind_direction_scaling_inputs.core["farm"]["wind_speeds"] = [8.0] # wd_space[i] = memory_profile(wind_direction_scaling_inputs) # print("wind direction", i, wd_space[i]) @@ -169,8 +169,8 @@ def memory_profile(input_dict): # wind_speed_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # wind_speed_scaling_inputs.floris["farm"]["wind_directions"] = [270.0] - # wind_speed_scaling_inputs.floris["farm"]["wind_speeds"] = factor * [8.0] + # wind_speed_scaling_inputs.core["farm"]["wind_directions"] = [270.0] + # wind_speed_scaling_inputs.core["farm"]["wind_speeds"] = factor * [8.0] # ws_space[i] = memory_profile(wind_speed_scaling_inputs) # print("wind speed", i, ws_space[i]) @@ -180,11 +180,11 @@ def memory_profile(input_dict): # turbine_scaling_inputs = copy.deepcopy(sample_inputs) # for i in range(N): # factor = (i+1) * 50 - # turbine_scaling_inputs.floris["farm"]["layout_x"] = [ + # turbine_scaling_inputs.core["farm"]["layout_x"] = [ # 5 * TURBINE_DIAMETER * j # for j in range(factor) # ] - # turbine_scaling_inputs.floris["farm"]["layout_y"] = factor * [0.0] + # turbine_scaling_inputs.core["farm"]["layout_y"] = factor * [0.0] # turb_space[i] = memory_profile(turbine_scaling_inputs) # print("n turbine", turb_space[i]) diff --git a/pyproject.toml b/pyproject.toml index 2bb5fdcf5..330c5a2d8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -116,20 +116,18 @@ dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" [tool.ruff.per-file-ignores] # F841 unused-variable: ignore since this file uses numexpr and many variables look unused -"floris/simulation/wake_deflection/jimenez.py" = ["F841"] -"floris/simulation/wake_turbulence/crespo_hernandez.py" = ["F841"] -"floris/simulation/wake_deflection/gauss.py" = ["F841"] -"floris/simulation/wake_velocity/jensen.py" = ["F841"] -"floris/simulation/wake_velocity/gauss.py" = ["F841"] -"floris/simulation/wake_velocity/empirical_gauss.py" = ["F841"] +"floris/core/wake_deflection/jimenez.py" = ["F841"] +"floris/core/wake_turbulence/crespo_hernandez.py" = ["F841"] +"floris/core/wake_deflection/gauss.py" = ["F841"] +"floris/core/wake_velocity/jensen.py" = ["F841"] +"floris/core/wake_velocity/gauss.py" = ["F841"] +"floris/core/wake_velocity/empirical_gauss.py" = ["F841"] +# Ignore `F401` (import violations) in all `__init__.py` files, and in `path/to/file.py`. +"__init__.py" = ["F401"] # I001 unsorted-imports: ignore because the import order is meaningful to navigate # import dependencies -"floris/simulation/__init__.py" = ["I001"] - -# FIXME -"floris/tools/interface_utilities.py" = ["F821"] -"floris/tools/wind_rose.py" = ["F821"] +"floris/core/__init__.py" = ["I001"] [tool.ruff.isort] combine-as-imports = true diff --git a/setup.py b/setup.py index 6e08029ae..1d12d08be 100644 --- a/setup.py +++ b/setup.py @@ -1,17 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - from pathlib import Path @@ -42,7 +28,6 @@ # utilities "coloredlogs~=10.0", - "flatten_dict~=0.0", ] # What packages are optional? @@ -82,16 +67,16 @@ url=URL, packages=find_packages(exclude=["tests", "*.tests", "*.tests.*", "tests.*"]), package_data={ - 'floris': ['turbine_library/*.yaml', 'simulation/wake_velocity/turbopark_lookup_table.mat'] + 'floris': ['turbine_library/*.yaml', 'core/wake_velocity/turbopark_lookup_table.mat'] }, install_requires=REQUIRED, extras_require=EXTRAS, include_package_data=True, - license="Apache-2.0", + license_files = ('LICENSE.txt',), classifiers=[ # Trove classifiers # Full list: https://pypi.python.org/pypi?%3Aaction=list_classifiers - "License :: OSI Approved :: Apache Software License", + "License :: OSI Approved :: BSD License", "Programming Language :: Python", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.8", diff --git a/tests/__init__.py b/tests/__init__.py index 109cd1192..e69de29bb 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,13 +0,0 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation diff --git a/tests/base_test.py b/tests/base_unit_test.py similarity index 61% rename from tests/base_test.py rename to tests/base_unit_test.py index 3be2e8710..fadae3523 100644 --- a/tests/base_test.py +++ b/tests/base_unit_test.py @@ -1,23 +1,9 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import pytest from attr import define, field from attrs.exceptions import FrozenAttributeError -from floris.simulation import BaseClass, BaseModel +from floris.core import BaseClass, BaseModel @define diff --git a/tests/conftest.py b/tests/conftest.py index edbb2b863..2b939e689 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,25 +1,13 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation +from __future__ import annotations import copy import numpy as np import pytest -from floris.simulation import ( - Floris, +from floris.core import ( + Core, FlowField, FlowFieldGrid, PointsGrid, @@ -54,36 +42,83 @@ def print_test_values( average_velocities: list, thrusts: list, powers: list, - axial_inductions: list + axial_inductions: list, + max_findex_print: int | None =None ): - n_wd, n_ws, n_turb = np.shape(average_velocities) - i=0 - for j in range(n_ws): + n_findex, n_turb = np.shape(average_velocities) + if max_findex_print is not None: + n_findex = min(n_findex, max_findex_print) + for i in range(n_findex): print("[") - for k in range(n_turb): + for j in range(n_turb): print( " [{:.7f}, {:.7f}, {:.7f}, {:.7f}],".format( - average_velocities[i,j,k], thrusts[i,j,k], powers[i,j,k], - axial_inductions[i,j,k] + average_velocities[i,j], thrusts[i,j], powers[i,j], + axial_inductions[i,j] ) ) print("],") WIND_DIRECTIONS = [ + 270.0, + 270.0, + 270.0, 270.0, 360.0, + 360.0, + 360.0, + 360.0, + 285.0, + 285.0, + 285.0, 285.0, 315.0, + 315.0, + 315.0, + 315.0, ] -N_WIND_DIRECTIONS = len(WIND_DIRECTIONS) WIND_SPEEDS = [ 8.0, 9.0, 10.0, 11.0, + 8.0, + 9.0, + 10.0, + 11.0, + 8.0, + 9.0, + 10.0, + 11.0, + 8.0, + 9.0, + 10.0, + 11.0, ] -N_WIND_SPEEDS = len(WIND_SPEEDS) +TURBULENCE_INTENSITIES = [ + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, + 0.1, +] + +# FINDEX is the length of the number of conditions, so it can be +# len(WIND_DIRECTIONS) or len(WIND_SPEEDS +N_FINDEX = len(WIND_DIRECTIONS) + X_COORDS = [ 0.0, 5 * 126.0, @@ -102,7 +137,6 @@ def print_test_values( N_TURBINES = len(X_COORDS) ROTOR_DIAMETER = 126.0 TURBINE_GRID_RESOLUTION = 2 -TIME_SERIES = False ## Unit test fixtures @@ -120,27 +154,24 @@ def turbine_grid_fixture(sample_inputs_fixture) -> TurbineGrid: turbine_coordinates=turbine_coordinates, turbine_diameters=rotor_diameters, wind_directions=np.array(WIND_DIRECTIONS), - wind_speeds=np.array(WIND_SPEEDS), grid_resolution=TURBINE_GRID_RESOLUTION, - time_series=TIME_SERIES ) @pytest.fixture def flow_field_grid_fixture(sample_inputs_fixture) -> FlowFieldGrid: turbine_coordinates = np.array(list(zip(X_COORDS, Y_COORDS, Z_COORDS))) - rotor_diameters = ROTOR_DIAMETER * np.ones( (N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES) ) + rotor_diameters = ROTOR_DIAMETER * np.ones( (N_FINDEX, N_TURBINES) ) return FlowFieldGrid( turbine_coordinates=turbine_coordinates, turbine_diameters=rotor_diameters, wind_directions=np.array(WIND_DIRECTIONS), - wind_speeds=np.array(WIND_SPEEDS), grid_resolution=[3,2,2] ) @pytest.fixture def points_grid_fixture(sample_inputs_fixture) -> PointsGrid: turbine_coordinates = np.array(list(zip(X_COORDS, Y_COORDS, Z_COORDS))) - rotor_diameters = ROTOR_DIAMETER * np.ones( (N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES) ) + rotor_diameters = ROTOR_DIAMETER * np.ones( (N_FINDEX, N_TURBINES) ) points_x = [0.0, 10.0] points_y = [0.0, 0.0] points_z = [1.0, 2.0] @@ -148,9 +179,7 @@ def points_grid_fixture(sample_inputs_fixture) -> PointsGrid: turbine_coordinates=turbine_coordinates, turbine_diameters=rotor_diameters, wind_directions=np.array(WIND_DIRECTIONS), - wind_speeds=np.array(WIND_SPEEDS), grid_resolution=None, - time_series=False, points_x=points_x, points_y=points_y, points_z=points_z, @@ -159,7 +188,7 @@ def points_grid_fixture(sample_inputs_fixture) -> PointsGrid: @pytest.fixture def floris_fixture(): sample_inputs = SampleInputs() - return Floris(sample_inputs.floris) + return Core(sample_inputs.core) @pytest.fixture def sample_inputs_fixture(): @@ -174,163 +203,186 @@ class SampleInputs: def __init__(self): self.turbine = { "turbine_type": "nrel_5mw", - "rotor_diameter": 126.0, + "rotor_diameter": 125.88, "hub_height": 90.0, - "pP": 1.88, - "pT": 1.88, - "generator_efficiency": 1.0, - "ref_density_cp_ct": 1.225, - "ref_tilt_cp_ct": 5.0, + "operation_model": "cosine-loss", "power_thrust_table": { + "cosine_loss_exponent_yaw": 1.88, + "cosine_loss_exponent_tilt": 1.88, + "ref_air_density": 1.225, + "ref_tilt": 5.0, + "helix_a": 1.802, + "helix_power_b": 4.568e-03, + "helix_power_c": 1.629e-10, + "helix_thrust_b": 1.027e-03, + "helix_thrust_c": 1.378e-06, "power": [ - 0.000000, - 0.000000, - 0.178085, - 0.289075, - 0.349022, - 0.384728, - 0.406059, - 0.420228, - 0.428823, - 0.433873, - 0.436223, - 0.436845, - 0.436575, - 0.436511, - 0.436561, - 0.436517, - 0.435903, - 0.434673, - 0.433230, - 0.430466, - 0.378869, - 0.335199, - 0.297991, - 0.266092, - 0.238588, - 0.214748, - 0.193981, - 0.175808, - 0.159835, - 0.145741, - 0.133256, - 0.122157, - 0.112257, - 0.103399, - 0.095449, - 0.088294, - 0.081836, - 0.075993, - 0.070692, - 0.065875, - 0.061484, - 0.057476, - 0.053809, - 0.050447, - 0.047358, - 0.044518, - 0.041900, - 0.039483, + 0.0, + 0.0, + 40.51801151756921, + 177.6716250641970, + 403.900880943964, + 737.5889584824021, + 1187.177403061187, + 1239.245945375778, + 1292.518429372350, + 1347.321314747710, + 1403.257372557894, + 1460.701189873070, + 1519.641912597998, + 1580.174365096404, + 1642.110316691816, + 1705.758292831, + 1771.165952889397, + 2518.553107505315, + 3448.381605840943, + 3552.140809000129, + 3657.954543179412, + 3765.121299313842, + 3873.928844315059, + 3984.480022695550, + 4096.582833096852, + 4210.721306623712, + 4326.154305853405, + 4443.395565353604, + 4562.497934188341, + 4683.419890251577, + 4806.164748311019, + 4929.931918769215, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 5000.00, + 0.0, + 0.0, ], - "thrust": [ + "thrust_coefficient": [ + 0.0, + 0.0, + 1.132034888, + 0.999470963, + 0.917697381, + 0.860849503, + 0.815371198, + 0.811614904, + 0.807939328, + 0.80443352, + 0.800993851, + 0.79768116, + 0.794529244, + 0.791495834, + 0.788560434, + 0.787217182, + 0.787127977, + 0.785839257, + 0.783812219, + 0.783568108, + 0.783328285, + 0.781194418, + 0.777292539, + 0.773464375, + 0.769690236, + 0.766001924, + 0.762348072, + 0.758760824, + 0.755242872, + 0.751792927, + 0.748434131, + 0.745113997, + 0.717806682, + 0.672204789, + 0.63831272, + 0.610176496, + 0.585456847, + 0.563222111, + 0.542912273, + 0.399312061, + 0.310517829, + 0.248633226, + 0.203543725, + 0.169616419, + 0.143478955, + 0.122938861, + 0.106515296, + 0.093026095, + 0.081648606, + 0.072197368, + 0.064388275, + 0.057782745, 0.0, 0.0, - 0.99, - 0.99, - 0.97373036, - 0.92826162, - 0.89210543, - 0.86100905, - 0.835423, - 0.81237673, - 0.79225789, - 0.77584769, - 0.7629228, - 0.76156073, - 0.76261984, - 0.76169723, - 0.75232027, - 0.74026851, - 0.72987175, - 0.70701647, - 0.54054532, - 0.45509459, - 0.39343381, - 0.34250785, - 0.30487242, - 0.27164979, - 0.24361964, - 0.21973831, - 0.19918151, - 0.18131868, - 0.16537679, - 0.15103727, - 0.13998636, - 0.1289037, - 0.11970413, - 0.11087113, - 0.10339901, - 0.09617888, - 0.09009926, - 0.08395078, - 0.0791188, - 0.07448356, - 0.07050731, - 0.06684119, - 0.06345518, - 0.06032267, - 0.05741999, - 0.05472609, ], "wind_speed": [ - 2.0, - 2.5, + 0.0, + 2.9, 3.0, - 3.5, 4.0, - 4.5, 5.0, - 5.5, 6.0, - 6.5, 7.0, + 7.1, + 7.2, + 7.3, + 7.4, 7.5, + 7.6, + 7.7, + 7.8, + 7.9, 8.0, - 8.5, 9.0, - 9.5, 10.0, + 10.1, + 10.2, + 10.3, + 10.4, 10.5, + 10.6, + 10.7, + 10.8, + 10.9, 11.0, + 11.1, + 11.2, + 11.3, + 11.4, 11.5, + 11.6, + 11.7, + 11.8, + 11.9, 12.0, - 12.5, 13.0, - 13.5, 14.0, - 14.5, 15.0, - 15.5, 16.0, - 16.5, 17.0, - 17.5, 18.0, - 18.5, 19.0, - 19.5, 20.0, - 20.5, 21.0, - 21.5, 22.0, - 22.5, 23.0, - 23.5, 24.0, - 24.5, 25.0, - 25.5, + 25.1, + 50.0, ], }, "TSR": 8.0 @@ -351,10 +403,20 @@ def __init__(self): } self.turbine_floating["correct_cp_ct_for_tilt"] = True - self.turbine_multi_dim = copy.deepcopy(self.turbine) - del self.turbine_multi_dim['power_thrust_table'] - self.turbine_multi_dim["multi_dimensional_cp_ct"] = True - self.turbine_multi_dim["power_thrust_data_file"] = "" + self.turbine_multi_dim = { + "turbine_type": 'iea_15MW_multi_dim_cp_ct', + "hub_height": 150.0, + "rotor_diameter": 242.24, + "TSR": 8.0, + "multi_dimensional_cp_ct": True, + "power_thrust_table": { + "ref_air_density": 1.225, + "ref_tilt": 6.0, + "cosine_loss_exponent_yaw": 1.88, + "cosine_loss_exponent_tilt": 1.88, + "power_thrust_data_file": 'iea_15MW_multi_dim_Tp_Hs.csv', + } + } self.farm = { "layout_x": X_COORDS, @@ -365,7 +427,7 @@ def __init__(self): self.flow_field = { "wind_speeds": WIND_SPEEDS, "wind_directions": WIND_DIRECTIONS, - "turbulence_intensity": 0.1, + "turbulence_intensities": TURBULENCE_INTENSITIES, "wind_shear": 0.12, "wind_veer": 0.0, "air_density": 1.225, @@ -397,7 +459,7 @@ def __init__(self): "empirical_gauss": { "horizontal_deflection_gain_D": 3.0, "vertical_deflection_gain_D": -1, - "deflection_rate": 30, + "deflection_rate": 22, "mixing_gain_deflection": 0.0, "yaw_added_mixing_gain": 0.0 }, @@ -431,7 +493,9 @@ def __init__(self): "breakpoints_D": [10], "sigma_0_D": 0.28, "smoothing_length_D": 2.0, - "mixing_gain_velocity": 2.0 + "mixing_gain_velocity": 2.0, + "awc_wake_exp": 1.2, + "awc_wake_denominator": 400 }, }, "wake_turbulence_parameters": { @@ -447,10 +511,11 @@ def __init__(self): }, "enable_secondary_steering": False, "enable_yaw_added_recovery": False, + "enable_active_wake_mixing": False, "enable_transverse_velocities": False, } - self.floris = { + self.core = { "farm": self.farm, "flow_field": self.flow_field, "wake": self.wake, @@ -464,5 +529,188 @@ def __init__(self): }, "name": "conftest", "description": "Inputs used for testing", - "floris_version": "v3.0.0", + "floris_version": "v4", + } + + self.v3type_turbine = { + "turbine_type": "nrel_5mw_v3type", + "rotor_diameter": 125.88, + "hub_height": 90.0, + "generator_efficiency": 0.944, + "operation_model": "cosine-loss", + "pP": 1.88, + "pT": 1.88, + "ref_density_cp_ct": 1.225, + "ref_tilt_cp_ct": 5.0, + "TSR": 8.0, + "power_thrust_table": { + "power": [ + 0.0, + 0.0, + 0.208546508, + 0.385795061, + 0.449038264, + 0.474546985, + 0.480994449, + 0.481172749, + 0.481235678, + 0.481305875, + 0.481238912, + 0.481167356, + 0.481081935, + 0.481007003, + 0.480880409, + 0.480789285, + 0.480737341, + 0.480111543, + 0.479218839, + 0.479120347, + 0.479022984, + 0.478834971, + 0.478597234, + 0.478324162, + 0.477994289, + 0.477665338, + 0.477253698, + 0.476819542, + 0.476368667, + 0.475896732, + 0.475404347, + 0.474814698, + 0.469087611, + 0.456886723, + 0.445156758, + 0.433837552, + 0.422902868, + 0.412332387, + 0.402110045, + 0.316270768, + 0.253224057, + 0.205881042, + 0.169640239, + 0.141430529, + 0.119144335, + 0.101304591, + 0.086856409, + 0.075029591, + 0.065256635, + 0.057109143, + 0.050263779, + 0.044470536, + 0.0, + 0.0, + ], + "thrust": [ + 0.0, + 0.0, + 1.132034888, + 0.999470963, + 0.917697381, + 0.860849503, + 0.815371198, + 0.811614904, + 0.807939328, + 0.80443352, + 0.800993851, + 0.79768116, + 0.794529244, + 0.791495834, + 0.788560434, + 0.787217182, + 0.787127977, + 0.785839257, + 0.783812219, + 0.783568108, + 0.783328285, + 0.781194418, + 0.777292539, + 0.773464375, + 0.769690236, + 0.766001924, + 0.762348072, + 0.758760824, + 0.755242872, + 0.751792927, + 0.748434131, + 0.745113997, + 0.717806682, + 0.672204789, + 0.63831272, + 0.610176496, + 0.585456847, + 0.563222111, + 0.542912273, + 0.399312061, + 0.310517829, + 0.248633226, + 0.203543725, + 0.169616419, + 0.143478955, + 0.122938861, + 0.106515296, + 0.093026095, + 0.081648606, + 0.072197368, + 0.064388275, + 0.057782745, + 0.0, + 0.0, + ], + "wind_speed": [ + 0.0, + 2.9, + 3.0, + 4.0, + 5.0, + 6.0, + 7.0, + 7.1, + 7.2, + 7.3, + 7.4, + 7.5, + 7.6, + 7.7, + 7.8, + 7.9, + 8.0, + 9.0, + 10.0, + 10.1, + 10.2, + 10.3, + 10.4, + 10.5, + 10.6, + 10.7, + 10.8, + 10.9, + 11.0, + 11.1, + 11.2, + 11.3, + 11.4, + 11.5, + 11.6, + 11.7, + 11.8, + 11.9, + 12.0, + 13.0, + 14.0, + 15.0, + 16.0, + 17.0, + 18.0, + 19.0, + 20.0, + 21.0, + 22.0, + 23.0, + 24.0, + 25.0, + 25.1, + 50.0, + ], + }, } diff --git a/tests/core_unit_test.py b/tests/core_unit_test.py new file mode 100644 index 000000000..5e9108354 --- /dev/null +++ b/tests/core_unit_test.py @@ -0,0 +1,47 @@ + +from pathlib import Path + +import yaml + +from floris.core import ( + Core, + Farm, + FlowField, + TurbineGrid, + WakeModelManager, +) + + +TEST_DATA = Path(__file__).resolve().parent / "data" +YAML_INPUT = TEST_DATA / "input_full.yaml" +DICT_INPUT = yaml.load(open(YAML_INPUT, "r"), Loader=yaml.SafeLoader) + + +def test_read_yaml(): + fmodel = Core.from_file(YAML_INPUT) + assert isinstance(fmodel, Core) + + +def test_read_dict(): + fmodel = Core.from_dict(DICT_INPUT) + assert isinstance(fmodel, Core) + + +def test_init(): + fmodel = Core.from_dict(DICT_INPUT) + assert isinstance(fmodel.farm, Farm) + assert isinstance(fmodel.wake, WakeModelManager) + assert isinstance(fmodel.flow_field, FlowField) + + +def test_asdict(turbine_grid_fixture: TurbineGrid): + + floris = Core.from_dict(DICT_INPUT) + floris.flow_field.initialize_velocity_field(turbine_grid_fixture) + dict1 = floris.as_dict() + + new_floris = Core.from_dict(dict1) + new_floris.flow_field.initialize_velocity_field(turbine_grid_fixture) + dict2 = new_floris.as_dict() + + assert dict1 == dict2 diff --git a/tests/data/input_full_v3.yaml b/tests/data/input_full.yaml similarity index 93% rename from tests/data/input_full_v3.yaml rename to tests/data/input_full.yaml index 5cace12df..f3235b581 100644 --- a/tests/data/input_full_v3.yaml +++ b/tests/data/input_full.yaml @@ -1,7 +1,7 @@ name: test_input description: Single turbine for testing -floris_version: v3.0.0 +floris_version: v4 logging: console: @@ -26,7 +26,8 @@ farm: flow_field: air_density: 1.225 reference_wind_height: 90.0 - turbulence_intensity: 0.06 + turbulence_intensities: + - 0.06 wind_directions: - 270.0 wind_shear: 0.12 @@ -43,6 +44,7 @@ wake: enable_secondary_steering: true enable_yaw_added_recovery: true + enable_active_wake_mixing: true enable_transverse_velocities: true wake_deflection_parameters: diff --git a/tests/data/nrel_5MW_custom.yaml b/tests/data/nrel_5MW_custom.yaml index 9e3ef6735..b7d3d8e5b 100644 --- a/tests/data/nrel_5MW_custom.yaml +++ b/tests/data/nrel_5MW_custom.yaml @@ -1,166 +1,174 @@ turbine_type: 'nrel_5MW_custom' -generator_efficiency: 1.0 hub_height: 90.0 -pP: 1.88 -pT: 1.88 rotor_diameter: 126.0 TSR: 8.0 -ref_density_cp_ct: 1.225 -ref_tilt_cp_ct: 5.0 power_thrust_table: + cosine_loss_exponent_yaw: 1.88 + cosine_loss_exponent_tilt: 1.88 + ref_air_density: 1.225 + ref_tilt: 5.0 power: - 0.0 - - 0.000000 - - 0.000000 - - 0.178085 - - 0.289075 - - 0.349022 - - 0.384728 - - 0.406059 - - 0.420228 - - 0.428823 - - 0.433873 - - 0.436223 - - 0.436845 - - 0.436575 - - 0.436511 - - 0.436561 - - 0.436517 - - 0.435903 - - 0.434673 - - 0.433230 - - 0.430466 - - 0.378869 - - 0.335199 - - 0.297991 - - 0.266092 - - 0.238588 - - 0.214748 - - 0.193981 - - 0.175808 - - 0.159835 - - 0.145741 - - 0.133256 - - 0.122157 - - 0.112257 - - 0.103399 - - 0.095449 - - 0.088294 - - 0.081836 - - 0.075993 - - 0.070692 - - 0.065875 - - 0.061484 - - 0.057476 - - 0.053809 - - 0.050447 - - 0.047358 - - 0.044518 - - 0.041900 - - 0.039483 - 0.0 + - 40.518011517569214 + - 177.67162506419703 + - 403.900880943964 + - 737.5889584824021 + - 1187.1774030611875 + - 1239.245945375778 + - 1292.5184293723503 + - 1347.3213147477102 + - 1403.2573725578948 + - 1460.7011898730707 + - 1519.6419125979983 + - 1580.174365096404 + - 1642.1103166918167 + - 1705.758292831 + - 1771.1659528893977 + - 2518.553107505315 + - 3448.381605840943 + - 3552.140809000129 + - 3657.9545431794127 + - 3765.121299313842 + - 3873.928844315059 + - 3984.4800226955504 + - 4096.582833096852 + - 4210.721306623712 + - 4326.154305853405 + - 4443.395565353604 + - 4562.497934188341 + - 4683.419890251577 + - 4806.164748311019 + - 4929.931918769215 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 + - 5000.00 - 0.0 - thrust: - 0.0 + thrust_coefficient: - 0.0 - 0.0 - - 0.99 - - 0.99 - - 0.97373036 - - 0.92826162 - - 0.89210543 - - 0.86100905 - - 0.835423 - - 0.81237673 - - 0.79225789 - - 0.77584769 - - 0.7629228 - - 0.76156073 - - 0.76261984 - - 0.76169723 - - 0.75232027 - - 0.74026851 - - 0.72987175 - - 0.70701647 - - 0.54054532 - - 0.45509459 - - 0.39343381 - - 0.34250785 - - 0.30487242 - - 0.27164979 - - 0.24361964 - - 0.21973831 - - 0.19918151 - - 0.18131868 - - 0.16537679 - - 0.15103727 - - 0.13998636 - - 0.1289037 - - 0.11970413 - - 0.11087113 - - 0.10339901 - - 0.09617888 - - 0.09009926 - - 0.08395078 - - 0.0791188 - - 0.07448356 - - 0.07050731 - - 0.06684119 - - 0.06345518 - - 0.06032267 - - 0.05741999 - - 0.05472609 + - 1.132034888 + - 0.999470963 + - 0.917697381 + - 0.860849503 + - 0.815371198 + - 0.811614904 + - 0.807939328 + - 0.80443352 + - 0.800993851 + - 0.79768116 + - 0.794529244 + - 0.791495834 + - 0.788560434 + - 0.787217182 + - 0.787127977 + - 0.785839257 + - 0.783812219 + - 0.783568108 + - 0.783328285 + - 0.781194418 + - 0.777292539 + - 0.773464375 + - 0.769690236 + - 0.766001924 + - 0.762348072 + - 0.758760824 + - 0.755242872 + - 0.751792927 + - 0.748434131 + - 0.745113997 + - 0.717806682 + - 0.672204789 + - 0.63831272 + - 0.610176496 + - 0.585456847 + - 0.563222111 + - 0.542912273 + - 0.399312061 + - 0.310517829 + - 0.248633226 + - 0.203543725 + - 0.169616419 + - 0.143478955 + - 0.122938861 + - 0.106515296 + - 0.093026095 + - 0.081648606 + - 0.072197368 + - 0.064388275 + - 0.057782745 - 0.0 - 0.0 wind_speed: - 0.0 - - 2.0 - - 2.5 + - 2.9 - 3.0 - - 3.5 - 4.0 - - 4.5 - 5.0 - - 5.5 - 6.0 - - 6.5 - 7.0 + - 7.1 + - 7.2 + - 7.3 + - 7.4 - 7.5 + - 7.6 + - 7.7 + - 7.8 + - 7.9 - 8.0 - - 8.5 - 9.0 - - 9.5 - 10.0 + - 10.1 + - 10.2 + - 10.3 + - 10.4 - 10.5 + - 10.6 + - 10.7 + - 10.8 + - 10.9 - 11.0 + - 11.1 + - 11.2 + - 11.3 + - 11.4 - 11.5 + - 11.6 + - 11.7 + - 11.8 + - 11.9 - 12.0 - - 12.5 - 13.0 - - 13.5 - 14.0 - - 14.5 - 15.0 - - 15.5 - 16.0 - - 16.5 - 17.0 - - 17.5 - 18.0 - - 18.5 - 19.0 - - 19.5 - 20.0 - - 20.5 - 21.0 - - 21.5 - 22.0 - - 22.5 - 23.0 - - 23.5 - 24.0 - - 24.5 - 25.0 - - 25.01 - - 25.02 + - 25.1 - 50.0 diff --git a/tests/data/wind_rose.csv b/tests/data/wind_rose.csv new file mode 100644 index 000000000..fd7279d49 --- /dev/null +++ b/tests/data/wind_rose.csv @@ -0,0 +1,4 @@ +ws,wd,freq_val +8,270,0.25 +9,270,0.25 +8,280,0.5 diff --git a/tests/data/wind_ti_rose.csv b/tests/data/wind_ti_rose.csv new file mode 100644 index 000000000..e293c3e63 --- /dev/null +++ b/tests/data/wind_ti_rose.csv @@ -0,0 +1,4 @@ +ws,wd,ti,freq_val +8,270,0.06,0.25 +9,270,0.06,0.25 +8,280,0.07,0.5 diff --git a/tests/farm_unit_test.py b/tests/farm_unit_test.py index 64d1d405e..3c8893998 100644 --- a/tests/farm_unit_test.py +++ b/tests/farm_unit_test.py @@ -1,16 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from copy import deepcopy from pathlib import Path @@ -18,12 +5,11 @@ import numpy as np import pytest -from floris.simulation import Farm +from floris.core import Farm from floris.utilities import load_yaml from tests.conftest import ( + N_FINDEX, N_TURBINES, - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, SampleInputs, ) @@ -49,7 +35,7 @@ def test_farm_init_homogenous_turbines(): # turbine_type=[turbine_data["turbine_type"]] farm.construct_hub_heights() - farm.set_yaw_angles(N_WIND_DIRECTIONS, N_WIND_SPEEDS) + farm.set_yaw_angles_to_ref_yaw(N_FINDEX) # Check initial values np.testing.assert_array_equal(farm.coordinates, coordinates) @@ -60,16 +46,24 @@ def test_farm_init_homogenous_turbines(): def test_asdict(sample_inputs_fixture: SampleInputs): farm = Farm.from_dict(sample_inputs_fixture.farm) farm.construct_hub_heights() - farm.construct_turbine_ref_tilt_cp_cts() - farm.set_yaw_angles(N_WIND_DIRECTIONS, N_WIND_SPEEDS) - farm.set_tilt_to_ref_tilt(N_WIND_DIRECTIONS, N_WIND_SPEEDS) + farm.construct_turbine_ref_tilts() + farm.set_yaw_angles_to_ref_yaw(N_FINDEX) + farm.set_tilt_to_ref_tilt(N_FINDEX) + farm.set_power_setpoints_to_ref_power(N_FINDEX) + farm.set_awc_modes_to_ref_mode(N_FINDEX) + farm.set_awc_amplitudes_to_ref_amp(N_FINDEX) + farm.set_awc_frequencies_to_ref_freq(N_FINDEX) dict1 = farm.as_dict() new_farm = farm.from_dict(dict1) new_farm.construct_hub_heights() - new_farm.construct_turbine_ref_tilt_cp_cts() - new_farm.set_yaw_angles(N_WIND_DIRECTIONS, N_WIND_SPEEDS) - new_farm.set_tilt_to_ref_tilt(N_WIND_DIRECTIONS, N_WIND_SPEEDS) + new_farm.construct_turbine_ref_tilts() + new_farm.set_yaw_angles_to_ref_yaw(N_FINDEX) + new_farm.set_tilt_to_ref_tilt(N_FINDEX) + new_farm.set_power_setpoints_to_ref_power(N_FINDEX) + new_farm.set_awc_modes_to_ref_mode(N_FINDEX) + new_farm.set_awc_amplitudes_to_ref_amp(N_FINDEX) + new_farm.set_awc_frequencies_to_ref_freq(N_FINDEX) dict2 = new_farm.as_dict() assert dict1 == dict2 @@ -95,7 +89,7 @@ def test_check_turbine_type(sample_inputs_fixture: SampleInputs): # All list of strings from internal library farm_data = deepcopy(sample_inputs_fixture.farm) - farm_data["turbine_type"] = ["nrel_5MW", "iea_10MW", "iea_15MW", "x_20MW", "nrel_5MW"] + farm_data["turbine_type"] = ["nrel_5MW", "iea_10MW", "iea_15MW", "nrel_5MW", "nrel_5MW"] farm_data["layout_x"] = np.arange(0, 500, 100) farm_data["layout_y"] = np.zeros(5) farm = Farm.from_dict(farm_data) diff --git a/tests/floris_interface_test.py b/tests/floris_interface_test.py deleted file mode 100644 index 494576983..000000000 --- a/tests/floris_interface_test.py +++ /dev/null @@ -1,76 +0,0 @@ - -from pathlib import Path - -import numpy as np - -from floris.tools.floris_interface import FlorisInterface - - -TEST_DATA = Path(__file__).resolve().parent / "data" -YAML_INPUT = TEST_DATA / "input_full_v3.yaml" - - -def test_read_yaml(): - fi = FlorisInterface(configuration=YAML_INPUT) - assert isinstance(fi, FlorisInterface) - - -def test_calculate_wake(): - - """ - In FLORIS v3.2, running calculate_wake twice incorrectly set the yaw angles when the first time - has non-zero yaw settings but the second run had all-zero yaw settings. The test below asserts - that the yaw angles are correctly set in subsequent calls to calculate_wake. - """ - fi = FlorisInterface(configuration=YAML_INPUT) - yaw_angles = 20 * np.ones( - ( - fi.floris.flow_field.n_wind_directions, - fi.floris.flow_field.n_wind_speeds, - fi.floris.farm.n_turbines - ) - ) - fi.calculate_wake(yaw_angles=yaw_angles) - assert fi.floris.farm.yaw_angles == yaw_angles - - yaw_angles = np.zeros( - ( - fi.floris.flow_field.n_wind_directions, - fi.floris.flow_field.n_wind_speeds, - fi.floris.farm.n_turbines - ) - ) - fi.calculate_wake(yaw_angles=yaw_angles) - assert fi.floris.farm.yaw_angles == yaw_angles - - -def test_calculate_no_wake(): - """ - In FLORIS v3.2, running calculate_no_wake twice incorrectly set the yaw angles when the first - time has non-zero yaw settings but the second run had all-zero yaw settings. The test below - asserts that the yaw angles are correctly set in subsequent calls to calculate_no_wake. - """ - fi = FlorisInterface(configuration=YAML_INPUT) - yaw_angles = 20 * np.ones( - ( - fi.floris.flow_field.n_wind_directions, - fi.floris.flow_field.n_wind_speeds, - fi.floris.farm.n_turbines - ) - ) - fi.calculate_no_wake(yaw_angles=yaw_angles) - assert fi.floris.farm.yaw_angles == yaw_angles - - yaw_angles = np.zeros( - ( - fi.floris.flow_field.n_wind_directions, - fi.floris.flow_field.n_wind_speeds, - fi.floris.farm.n_turbines - ) - ) - fi.calculate_no_wake(yaw_angles=yaw_angles) - assert fi.floris.farm.yaw_angles == yaw_angles - - -def test_reinitialize(): - pass diff --git a/tests/floris_model_integration_test.py b/tests/floris_model_integration_test.py new file mode 100644 index 000000000..7b3f7d140 --- /dev/null +++ b/tests/floris_model_integration_test.py @@ -0,0 +1,702 @@ +import logging +from pathlib import Path + +import numpy as np +import pytest +import yaml + +from floris import FlorisModel, WindRose +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT + + +TEST_DATA = Path(__file__).resolve().parent / "data" +YAML_INPUT = TEST_DATA / "input_full.yaml" + + +def test_read_yaml(): + fmodel = FlorisModel(configuration=YAML_INPUT) + assert isinstance(fmodel, FlorisModel) + +def test_assign_setpoints(): + + fmodel = FlorisModel(configuration=YAML_INPUT) + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000]) + + # Test setting yaw angles via a list, integers, numpy array + fmodel.set(yaw_angles=[[20.0, 30.0]]) + fmodel.set(yaw_angles=[[20, 30]]) + fmodel.set(yaw_angles=np.array([[20.0, 30.0]])) + + # Test setting power setpoints in various ways + fmodel.set(power_setpoints=[[1e6, 2e6]]) + fmodel.set(power_setpoints=np.array([[1e6, 2e6]])) + + # Disable turbines + fmodel.set(disable_turbines=[[True, False]]) + fmodel.set(disable_turbines=np.array([[True, False]])) + + # Combination + fmodel.set(yaw_angles=[[0, 30]], power_setpoints=np.array([[1e6, None]])) + + # power_setpoints and disable_turbines (disable_turbines overrides power_setpoints) + fmodel.set(power_setpoints=[[1e6, 2e6]], disable_turbines=[[True, False]]) + assert np.allclose(fmodel.core.farm.power_setpoints, np.array([[0.001, 2e6]])) + +def test_set_run(): + """ + These tests are designed to test the set / run sequence to ensure that inputs are + set when they should be, not set when they shouldn't be, and that the run sequence + retains or resets information as intended. + """ + + # In FLORIS v3.2, running calculate_wake twice incorrectly set the yaw angles when the + # first time has non-zero yaw settings but the second run had all-zero yaw settings. + # The test below asserts that the yaw angles are correctly set in subsequent calls to run. + fmodel = FlorisModel(configuration=YAML_INPUT) + yaw_angles = 20 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run() + assert fmodel.core.farm.yaw_angles == yaw_angles + + yaw_angles = np.zeros((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run() + assert fmodel.core.farm.yaw_angles == yaw_angles + + # Verify making changes to the layout, wind speed, wind direction and + # turbulence intensity both before and after running the calculation + fmodel.reset_operation() + fmodel.set( + layout_x=[0, 0], + layout_y=[0, 1000], + wind_speeds=[8, 8], + wind_directions=[270, 270], + turbulence_intensities=[0.06, 0.06] + ) + assert np.array_equal(fmodel.core.farm.layout_x, np.array([0, 0])) + assert np.array_equal(fmodel.core.farm.layout_y, np.array([0, 1000])) + assert np.array_equal(fmodel.core.flow_field.wind_speeds, np.array([8, 8])) + assert np.array_equal(fmodel.core.flow_field.wind_directions, np.array([270, 270])) + + # Double check that nothing has changed after running the calculation + fmodel.run() + assert np.array_equal(fmodel.core.farm.layout_x, np.array([0, 0])) + assert np.array_equal(fmodel.core.farm.layout_y, np.array([0, 1000])) + assert np.array_equal(fmodel.core.flow_field.wind_speeds, np.array([8, 8])) + assert np.array_equal(fmodel.core.flow_field.wind_directions, np.array([270, 270])) + + # Verify that changing wind shear doesn't change the other settings above + fmodel.set(wind_shear=0.1) + assert fmodel.core.flow_field.wind_shear == 0.1 + assert np.array_equal(fmodel.core.farm.layout_x, np.array([0, 0])) + assert np.array_equal(fmodel.core.farm.layout_y, np.array([0, 1000])) + assert np.array_equal(fmodel.core.flow_field.wind_speeds, np.array([8, 8])) + assert np.array_equal(fmodel.core.flow_field.wind_directions, np.array([270, 270])) + + # Verify that operation set-points are retained after changing other settings + yaw_angles = 20 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + assert np.array_equal(fmodel.core.farm.yaw_angles, yaw_angles) + fmodel.set() + assert np.array_equal(fmodel.core.farm.yaw_angles, yaw_angles) + fmodel.set(wind_speeds=[10, 10]) + assert np.array_equal(fmodel.core.farm.yaw_angles, yaw_angles) + power_setpoints = 1e6 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(power_setpoints=power_setpoints) + assert np.array_equal(fmodel.core.farm.yaw_angles, yaw_angles) + assert np.array_equal(fmodel.core.farm.power_setpoints, power_setpoints) + + # Test that setting power setpoints through the .set() function actually sets the + # power setpoints in the floris object + fmodel.reset_operation() + power_setpoints = 1e6 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(power_setpoints=power_setpoints) + fmodel.run() + assert np.array_equal(fmodel.core.farm.power_setpoints, power_setpoints) + + # Similar to above, any "None" set-points should be set to the default value + power_setpoints = np.array([[1e6, None]]) + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000], power_setpoints=power_setpoints) + fmodel.run() + assert np.array_equal( + fmodel.core.farm.power_setpoints, + np.array([[power_setpoints[0, 0], POWER_SETPOINT_DEFAULT]]) + ) + +def test_reset_operation(): + # Calling the reset function should reset the power setpoints to the default values + fmodel = FlorisModel(configuration=YAML_INPUT) + yaw_angles = 20 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + power_setpoints = 1e6 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(power_setpoints=power_setpoints, yaw_angles=yaw_angles) + fmodel.run() + fmodel.reset_operation() + assert fmodel.core.farm.yaw_angles == np.zeros( + (fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines) + ) + assert fmodel.core.farm.power_setpoints == ( + POWER_SETPOINT_DEFAULT * np.ones((fmodel.core.flow_field.n_findex, + fmodel.core.farm.n_turbines)) + ) + + # Double check that running the calculate also doesn't change the operating set points + fmodel.run() + assert fmodel.core.farm.yaw_angles == np.zeros( + (fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines) + ) + assert fmodel.core.farm.power_setpoints == ( + POWER_SETPOINT_DEFAULT * np.ones((fmodel.core.flow_field.n_findex, + fmodel.core.farm.n_turbines)) + ) + +def test_run_no_wake(): + # In FLORIS v3.2, running calculate_no_wake twice incorrectly set the yaw angles when the first + # time has non-zero yaw settings but the second run had all-zero yaw settings. The test below + # asserts that the yaw angles are correctly set in subsequent calls to run_no_wake. + fmodel = FlorisModel(configuration=YAML_INPUT) + yaw_angles = 20 * np.ones((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run_no_wake() + assert fmodel.core.farm.yaw_angles == yaw_angles + + yaw_angles = np.zeros((fmodel.core.flow_field.n_findex, fmodel.core.farm.n_turbines)) + fmodel.set(yaw_angles=yaw_angles) + fmodel.run_no_wake() + assert fmodel.core.farm.yaw_angles == yaw_angles + + # With no wake and three turbines in a line, the power for all turbines with zero yaw + # should be the same + fmodel.reset_operation() + fmodel.set(layout_x=[0, 200, 4000], layout_y=[0, 0, 0]) + fmodel.run_no_wake() + power_no_wake = fmodel.get_turbine_powers() + assert len(np.unique(power_no_wake)) == 1 + +def test_get_turbine_powers(): + # Get turbine powers should return n_findex x n_turbine powers + # Apply the same wind speed and direction multiple times and confirm all equal + + fmodel = FlorisModel(configuration=YAML_INPUT) + + wind_speeds = np.array([8.0, 8.0, 8.0]) + wind_directions = np.array([270.0, 270.0, 270.0]) + turbulence_intensities = np.array([0.06, 0.06, 0.06]) + n_findex = len(wind_directions) + + layout_x = np.array([0, 0]) + layout_y = np.array([0, 1000]) + n_turbines = len(layout_x) + + fmodel.set( + wind_speeds=wind_speeds, + wind_directions=wind_directions, + turbulence_intensities=turbulence_intensities, + layout_x=layout_x, + layout_y=layout_y, + ) + + fmodel.run() + + turbine_powers = fmodel.get_turbine_powers() + + assert turbine_powers.shape[0] == n_findex + assert turbine_powers.shape[1] == n_turbines + assert turbine_powers[0, 0] == turbine_powers[1, 0] + +def test_get_farm_power(): + fmodel = FlorisModel(configuration=YAML_INPUT) + + wind_speeds = np.array([8.0, 8.0, 8.0]) + wind_directions = np.array([270.0, 270.0, 270.0]) + turbulence_intensities = np.array([0.06, 0.06, 0.06]) + n_findex = len(wind_directions) + + layout_x = np.array([0, 0]) + layout_y = np.array([0, 1000]) + # n_turbines = len(layout_x) + + fmodel.set( + wind_speeds=wind_speeds, + wind_directions=wind_directions, + turbulence_intensities=turbulence_intensities, + layout_x=layout_x, + layout_y=layout_y, + ) + + fmodel.run() + + turbine_powers = fmodel.get_turbine_powers() + farm_powers = fmodel.get_farm_power() + + assert farm_powers.shape[0] == n_findex + + # Assert farm power is the same as summing turbine powers + # over the turbine axis + farm_power_from_turbine = turbine_powers.sum(axis=1) + np.testing.assert_almost_equal(farm_power_from_turbine, farm_powers) + + # Test using weights to disable the second turbine + turbine_weights = np.array([1.0, 0.0]) + farm_powers = fmodel.get_farm_power(turbine_weights=turbine_weights) + + # Assert farm power is now equal to the 0th turbine since 1st is + # disabled + farm_power_from_turbine = turbine_powers[:, 0] + np.testing.assert_almost_equal(farm_power_from_turbine, farm_powers) + + # Finally, test using weights only disable the 1 turbine on the final + # findex values + turbine_weights = np.array([[1.0, 1.0], [1.0, 1.0], [1.0, 0.0]]) + + farm_powers = fmodel.get_farm_power(turbine_weights=turbine_weights) + turbine_powers[-1, 1] = 0 + farm_power_from_turbine = turbine_powers.sum(axis=1) + np.testing.assert_almost_equal(farm_power_from_turbine, farm_powers) + +def test_disable_turbines(): + + fmodel = FlorisModel(configuration=YAML_INPUT) + + # Set to mixed turbine model + with open( + str( + fmodel.core.as_dict()["farm"]["turbine_library_path"] + / (fmodel.core.as_dict()["farm"]["turbine_type"][0] + ".yaml") + ) + ) as t: + turbine_type = yaml.safe_load(t) + turbine_type["operation_model"] = "mixed" + fmodel.set(turbine_type=[turbine_type]) + + # Init to n-findex = 2, n_turbines = 3 + fmodel.set( + wind_speeds=np.array([8.,8.,]), + wind_directions=np.array([270.,270.]), + turbulence_intensities=np.array([0.06,0.06]), + layout_x = [0,1000,2000], + layout_y=[0,0,0] + ) + + # Confirm that using a disable value with wrong n_findex raises error + with pytest.raises(ValueError): + fmodel.set(disable_turbines=np.zeros((10, 3), dtype=bool)) + fmodel.run() + + # Confirm that using a disable value with wrong n_turbines raises error + with pytest.raises(ValueError): + fmodel.set(disable_turbines=np.zeros((2, 10), dtype=bool)) + fmodel.run() + + # Confirm that if all turbines are disabled, power is near 0 for all turbines + fmodel.set(disable_turbines=np.ones((2, 3), dtype=bool)) + fmodel.run() + turbines_powers = fmodel.get_turbine_powers() + np.testing.assert_allclose(turbines_powers, 0, atol=0.1) + + # Confirm the same for run_no_wake + fmodel.run_no_wake() + turbines_powers = fmodel.get_turbine_powers() + np.testing.assert_allclose(turbines_powers, 0, atol=0.1) + + # Confirm that if all disabled values set to false, equivalent to running normally + fmodel.reset_operation() + fmodel.run() + turbines_powers_normal = fmodel.get_turbine_powers() + fmodel.set(disable_turbines=np.zeros((2, 3), dtype=bool)) + fmodel.run() + turbines_powers_false_disable = fmodel.get_turbine_powers() + np.testing.assert_allclose(turbines_powers_normal,turbines_powers_false_disable,atol=0.1) + + # Confirm the same for run_no_wake + fmodel.run_no_wake() + turbines_powers_normal = fmodel.get_turbine_powers() + fmodel.set(disable_turbines=np.zeros((2, 3), dtype=bool)) + fmodel.run_no_wake() + turbines_powers_false_disable = fmodel.get_turbine_powers() + np.testing.assert_allclose(turbines_powers_normal,turbines_powers_false_disable,atol=0.1) + + # Confirm the shutting off the middle turbine is like removing from the layout + # In terms of impact on third turbine + disable_turbines = np.zeros((2, 3), dtype=bool) + disable_turbines[:,1] = [True, True] + fmodel.set(disable_turbines=disable_turbines) + fmodel.run() + power_with_middle_disabled = fmodel.get_turbine_powers() + + # Two turbine case to compare against above + fmodel_remove_middle = fmodel.copy() + fmodel_remove_middle.set(layout_x=[0,2000], layout_y=[0, 0]) + fmodel_remove_middle.run() + power_with_middle_removed = fmodel_remove_middle.get_turbine_powers() + + np.testing.assert_almost_equal(power_with_middle_disabled[0,2], power_with_middle_removed[0,1]) + np.testing.assert_almost_equal(power_with_middle_disabled[1,2], power_with_middle_removed[1,1]) + + # Check that yaw angles are correctly set when turbines are disabled + fmodel.set( + layout_x=[0, 1000, 2000], + layout_y=[0, 0, 0], + disable_turbines=disable_turbines, + yaw_angles=np.ones((2, 3)) + ) + fmodel.run() + assert (fmodel.core.farm.yaw_angles == np.array([[1.0, 0.0, 1.0], [1.0, 0.0, 1.0]])).all() + +def test_get_farm_aep(caplog): + fmodel = FlorisModel(configuration=YAML_INPUT) + + wind_speeds = np.array([8.0, 8.0, 8.0]) + wind_directions = np.array([270.0, 270.0, 270.0]) + turbulence_intensities = np.array([0.06, 0.06, 0.06]) + n_findex = len(wind_directions) + + layout_x = np.array([0, 0]) + layout_y = np.array([0, 1000]) + # n_turbines = len(layout_x) + + fmodel.set( + wind_speeds=wind_speeds, + wind_directions=wind_directions, + turbulence_intensities=turbulence_intensities, + layout_x=layout_x, + layout_y=layout_y, + ) + + fmodel.run() + + farm_powers = fmodel.get_farm_power() + + # Start with uniform frequency + freq = np.ones(n_findex) + freq = freq / np.sum(freq) + + # Check warning raised if freq not passed; no warning if freq passed + with caplog.at_level(logging.WARNING): + fmodel.get_farm_AEP() + assert caplog.text != "" # Checking not empty + caplog.clear() + with caplog.at_level(logging.WARNING): + fmodel.get_farm_AEP(freq=freq) + assert caplog.text == "" # Checking empty + + farm_aep = fmodel.get_farm_AEP(freq=freq) + + aep = np.sum(np.multiply(freq, farm_powers) * 365 * 24) + + # In this case farm_aep should match farm powers + np.testing.assert_allclose(farm_aep, aep) + + # Also check get_expected_farm_power + expected_farm_power = fmodel.get_expected_farm_power(freq=freq) + np.testing.assert_allclose(expected_farm_power, aep / (365 * 24)) + +def test_get_farm_avp(caplog): + fmodel = FlorisModel(configuration=YAML_INPUT) + + wind_speeds = np.array([7.0, 8.0, 9.0]) + wind_directions = np.array([260.0, 270.0, 280.0]) + turbulence_intensities = np.array([0.07, 0.06, 0.05]) + + layout_x = np.array([0, 0]) + layout_y = np.array([0, 1000]) + # n_turbines = len(layout_x) + + fmodel.set( + wind_speeds=wind_speeds, + wind_directions=wind_directions, + turbulence_intensities=turbulence_intensities, + layout_x=layout_x, + layout_y=layout_y, + ) + + fmodel.run() + + farm_powers = fmodel.get_farm_power() + + # Define frequencies + freq = np.array([0.25, 0.5, 0.25]) + + # Define values of energy produced (e.g., price per MWh) + values = np.array([30.0, 20.0, 10.0]) + + # Check warning raised if values not passed; no warning if values passed + with caplog.at_level(logging.WARNING): + fmodel.get_farm_AVP(freq=freq) + assert caplog.text != "" # Checking not empty + caplog.clear() + with caplog.at_level(logging.WARNING): + fmodel.get_farm_AVP(freq=freq, values=values) + assert caplog.text == "" # Checking empty + + # Check that AVP is equivalent to AEP when values not passed + farm_aep = fmodel.get_farm_AEP(freq=freq) + farm_avp = fmodel.get_farm_AVP(freq=freq) + + np.testing.assert_allclose(farm_avp, farm_aep) + + # Now check that AVP is what we expect when values passed + farm_avp = fmodel.get_farm_AVP(freq=freq,values=values) + + farm_values = np.multiply(values, farm_powers) + avp = np.sum(np.multiply(freq, farm_values) * 365 * 24) + + np.testing.assert_allclose(farm_avp, avp) + + # Also check get_expected_farm_value + expected_farm_power = fmodel.get_expected_farm_value(freq=freq, values=values) + np.testing.assert_allclose(expected_farm_power, avp / (365 * 24)) + +def test_set_ti(): + fmodel = FlorisModel(configuration=YAML_INPUT) + + # Set wind directions, wind speeds and turbulence intensities with n_findex = 3 + fmodel.set( + wind_speeds=[8.0, 8.0, 8.0], + wind_directions=[240.0, 250.0, 260.0], + turbulence_intensities=[0.1, 0.1, 0.1], + ) + + # Confirm can change turbulence intensities if not changing the length of the array + fmodel.set(turbulence_intensities=[0.12, 0.12, 0.12]) + + # Confirm that changes to wind speeds and directions without changing turbulence intensities + # raises an error + with pytest.raises(ValueError): + fmodel.set( + wind_speeds=[8.0, 8.0, 8.0, 8.0], + wind_directions=[240.0, 250.0, 260.0, 270.0], + ) + + # Changing the length of TI alone is not allowed + with pytest.raises(ValueError): + fmodel.set(turbulence_intensities=[0.12]) + + # Test that applying a float however raises an error + with pytest.raises(TypeError): + fmodel.set(turbulence_intensities=0.12) + +def test_calculate_planes(caplog): + fmodel = FlorisModel(configuration=YAML_INPUT) + + # The calculate_plane functions should run directly with the inputs as given + fmodel.calculate_horizontal_plane(90.0) + fmodel.calculate_y_plane(0.0) + fmodel.calculate_cross_plane(500.0) + + # No longer support setting new wind conditions, must be done with set() + fmodel.set( + wind_speeds = [8.0, 8.0, 8.0], + wind_directions = [270.0, 270.0, 270.0], + turbulence_intensities = [0.1, 0.1, 0.1], + ) + fmodel.calculate_horizontal_plane( + 90.0, + findex_for_viz=1 + ) + fmodel.calculate_y_plane( + 0.0, + findex_for_viz=1 + ) + fmodel.calculate_cross_plane( + 500.0, + findex_for_viz=1 + ) + + # Without specifying findex_for_viz should raise a logger warning. + with caplog.at_level(logging.WARNING): + fmodel.calculate_horizontal_plane(90.0) + assert caplog.text != "" # Checking not empty + caplog.clear() + with caplog.at_level(logging.WARNING): + fmodel.calculate_y_plane(0.0) + assert caplog.text != "" # Checking not empty + caplog.clear() + with caplog.at_level(logging.WARNING): + fmodel.calculate_cross_plane(500.0) + assert caplog.text != "" # Checking not empty + +def test_get_turbine_powers_with_WindRose(): + fmodel = FlorisModel(configuration=YAML_INPUT) + + wind_speeds = np.array([8.0, 10.0, 12.0, 8.0, 10.0, 12.0]) + wind_directions = np.array([270.0, 270.0, 270.0, 280.0, 280.0, 280.0]) + turbulence_intensities = 0.06 * np.ones_like(wind_speeds) + + fmodel.set( + wind_speeds=wind_speeds, + wind_directions=wind_directions, + turbulence_intensities=turbulence_intensities, + layout_x=[0, 1000, 2000, 3000], + layout_y=[0, 0, 0, 0] + ) + fmodel.run() + turbine_powers_simple = fmodel.get_turbine_powers() + + # Now declare a WindRose with 2 wind directions and 3 wind speeds + # uniform TI and frequency + wind_rose = WindRose( + wind_directions=np.unique(wind_directions), + wind_speeds=np.unique(wind_speeds), + ti_table=0.06 + ) + + # Set this wind rose, run + fmodel.set(wind_data=wind_rose) + fmodel.run() + + # Get the turbine powers in the wind rose + turbine_powers_windrose = fmodel.get_turbine_powers() + + # Turbine power should have shape (n_wind_directions, n_wind_speeds, n_turbines) + assert turbine_powers_windrose.shape == (2, 3, 4) + assert np.allclose(turbine_powers_simple.reshape(2, 3, 4), turbine_powers_windrose) + assert np.allclose(turbine_powers_simple, turbine_powers_windrose.reshape(2*3, 4)) + + # Test that if certain combinations in the wind rose have 0 frequency, the power in + # those locations is nan + wind_rose = WindRose( + wind_directions = np.array([270.0, 280.0]), + wind_speeds = np.array([8.0, 10.0, 12.0]), + ti_table=0.06, + freq_table=np.array([[0.25, 0.25, 0.0], [0.0, 0.0, 0.5]]) + ) + fmodel.set(wind_data=wind_rose) + fmodel.run() + turbine_powers = fmodel.get_turbine_powers() + assert np.isnan(turbine_powers[0, 2, 0]) + +def test_get_powers_with_wind_data(): + fmodel = FlorisModel(configuration=YAML_INPUT) + + wind_speeds = np.array([8.0, 10.0, 12.0, 8.0, 10.0, 12.0]) + wind_directions = np.array([270.0, 270.0, 270.0, 280.0, 280.0, 280.0]) + turbulence_intensities = 0.06 * np.ones_like(wind_speeds) + + fmodel.set( + wind_speeds=wind_speeds, + wind_directions=wind_directions, + turbulence_intensities=turbulence_intensities, + layout_x=[0, 1000, 2000, 3000], + layout_y=[0, 0, 0, 0] + ) + fmodel.run() + farm_power_simple = fmodel.get_farm_power() + + # Now declare a WindRose with 2 wind directions and 3 wind speeds + # uniform TI and frequency + wind_rose = WindRose( + wind_directions=np.unique(wind_directions), + wind_speeds=np.unique(wind_speeds), + ti_table=0.06 + ) + + # Set this wind rose, run + fmodel.set(wind_data=wind_rose) + fmodel.run() + + farm_power_windrose = fmodel.get_farm_power() + + # Check dimensions and that the farm power is the sum of the turbine powers + assert farm_power_windrose.shape == (2, 3) + assert np.allclose(farm_power_windrose, fmodel.get_turbine_powers().sum(axis=2)) + + # Check that simple and windrose powers are consistent + assert np.allclose(farm_power_simple.reshape(2, 3), farm_power_windrose) + assert np.allclose(farm_power_simple, farm_power_windrose.flatten()) + + # Test that if the last turbine's weight is set to 0, the farm power is the same as the + # sum of the first 3 turbines + turbine_weights = np.array([1.0, 1.0, 1.0, 0.0]) + farm_power_weighted = fmodel.get_farm_power(turbine_weights=turbine_weights) + + assert np.allclose(farm_power_weighted, fmodel.get_turbine_powers()[:,:,:-1].sum(axis=2)) + +def test_get_and_set_param(): + fmodel = FlorisModel(configuration=YAML_INPUT) + + # Get the wind speed + wind_speeds = fmodel.get_param(['flow_field', 'wind_speeds']) + assert wind_speeds[0] == 8.0 + + # Set the wind speed + fmodel.set_param(['flow_field', 'wind_speeds'], 10.0, param_idx=0) + wind_speed = fmodel.get_param(['flow_field', 'wind_speeds'], param_idx=0 ) + assert wind_speed == 10.0 + + # Repeat with wake parameter + fmodel.set_param(['wake', 'wake_velocity_parameters', 'gauss', 'alpha'], 0.1) + alpha = fmodel.get_param(['wake', 'wake_velocity_parameters', 'gauss', 'alpha']) + assert alpha == 0.1 + +def test_get_operation_model(): + fmodel = FlorisModel(configuration=YAML_INPUT) + assert fmodel.get_operation_model() == "cosine-loss" + +def test_set_operation_model(): + + fmodel = FlorisModel(configuration=YAML_INPUT) + fmodel.set_operation_model("simple-derating") + assert fmodel.get_operation_model() == "simple-derating" + + # Check multiple turbine types works + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000]) + fmodel.set_operation_model(["simple-derating", "cosine-loss"]) + assert fmodel.get_operation_model() == ["simple-derating", "cosine-loss"] + + # Check that setting a single turbine type, and then altering the operation model works + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000]) + fmodel.set(turbine_type=["nrel_5MW"]) + fmodel.set_operation_model("simple-derating") + assert fmodel.get_operation_model() == "simple-derating" + + # Check that setting over mutliple turbine types works + fmodel.set(turbine_type=["nrel_5MW", "iea_15MW"]) + fmodel.set_operation_model("simple-derating") + assert fmodel.get_operation_model() == "simple-derating" + fmodel.set_operation_model(["simple-derating", "cosine-loss"]) + assert fmodel.get_operation_model() == ["simple-derating", "cosine-loss"] + + # Check setting over single turbine type; then updating layout works + fmodel.set(turbine_type=["nrel_5MW"]) + fmodel.set_operation_model("simple-derating") + fmodel.set(layout_x=[0, 0, 0], layout_y=[0, 1000, 2000]) + assert fmodel.get_operation_model() == "simple-derating" + + # Check that setting for multiple turbine types and then updating layout breaks + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000]) + fmodel.set(turbine_type=["nrel_5MW"]) + fmodel.set_operation_model(["simple-derating", "cosine-loss"]) + assert fmodel.get_operation_model() == ["simple-derating", "cosine-loss"] + with pytest.raises(ValueError): + fmodel.set(layout_x=[0, 0, 0], layout_y=[0, 1000, 2000]) + + # Check one more variation + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000]) + fmodel.set(turbine_type=["nrel_5MW", "iea_15MW"]) + fmodel.set_operation_model("simple-derating") + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000]) + with pytest.raises(ValueError): + fmodel.set(layout_x=[0, 0, 0], layout_y=[0, 1000, 2000]) + +def test_set_operation(): + fmodel = FlorisModel(configuration=YAML_INPUT) + fmodel.set(layout_x=[0, 0], layout_y=[0, 1000]) + + # Check that not allowed to run(), then set_operation, then collect powers + fmodel.run() + fmodel.set_operation(yaw_angles=np.array([[25.0, 0.0]])) + with pytest.raises(RuntimeError): + fmodel.get_turbine_powers() + + # Check that no issue if run is called first + fmodel.run() + fmodel.get_turbine_powers() + + # Check that if arguments do not match number of turbines, raises error + with pytest.raises(ValueError): + fmodel.set_operation(yaw_angles=np.array([[25.0, 0.0, 20.0]])) + + # Check that if arguments do not match n_findex, raises error + with pytest.raises(ValueError): + fmodel.set_operation(yaw_angles=np.array([[25.0, 0.0], [25.0, 0.0]])) + fmodel.run() diff --git a/tests/floris_unit_test.py b/tests/floris_unit_test.py deleted file mode 100644 index 05c01f022..000000000 --- a/tests/floris_unit_test.py +++ /dev/null @@ -1,60 +0,0 @@ -# Copyright 2021 NREL -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - -from pathlib import Path - -import yaml - -from floris.simulation import ( - Farm, - Floris, - FlowField, - TurbineGrid, - WakeModelManager, -) - - -TEST_DATA = Path(__file__).resolve().parent / "data" -YAML_INPUT = TEST_DATA / "input_full_v3.yaml" -DICT_INPUT = yaml.load(open(YAML_INPUT, "r"), Loader=yaml.SafeLoader) - - -def test_read_yaml(): - fi = Floris.from_file(YAML_INPUT) - assert isinstance(fi, Floris) - - -def test_read_dict(): - fi = Floris.from_dict(DICT_INPUT) - assert isinstance(fi, Floris) - - -def test_init(): - fi = Floris.from_dict(DICT_INPUT) - assert isinstance(fi.farm, Farm) - assert isinstance(fi.wake, WakeModelManager) - assert isinstance(fi.flow_field, FlowField) - - -def test_asdict(turbine_grid_fixture: TurbineGrid): - - floris = Floris.from_dict(DICT_INPUT) - floris.flow_field.initialize_velocity_field(turbine_grid_fixture) - dict1 = floris.as_dict() - - new_floris = Floris.from_dict(dict1) - new_floris.flow_field.initialize_velocity_field(turbine_grid_fixture) - dict2 = new_floris.as_dict() - - assert dict1 == dict2 diff --git a/tests/flow_field_unit_test.py b/tests/flow_field_unit_test.py index 5b84403c7..260c1f8df 100644 --- a/tests/flow_field_unit_test.py +++ b/tests/flow_field_unit_test.py @@ -1,30 +1,13 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import numpy as np +import pytest -from floris.simulation import FlowField, TurbineGrid -from tests.conftest import N_TURBINES - - -def test_n_wind_speeds(flow_field_fixture): - assert flow_field_fixture.n_wind_speeds > 0 +from floris.core import FlowField, TurbineGrid +from tests.conftest import N_FINDEX, N_TURBINES -def test_n_wind_directions(flow_field_fixture): - assert flow_field_fixture.n_wind_directions > 0 +def test_n_findex(flow_field_fixture): + assert flow_field_fixture.n_findex == N_FINDEX def test_initialize_velocity_field(flow_field_fixture, turbine_grid_fixture: TurbineGrid): @@ -32,28 +15,24 @@ def test_initialize_velocity_field(flow_field_fixture, turbine_grid_fixture: Tur flow_field_fixture.initialize_velocity_field(turbine_grid_fixture) # Check the shape of the velocity arrays: u_initial, v_initial, w_initial and u, v, w - # Dimensions are (# wind speeds, # turbines, N grid points, M grid points) - assert np.shape(flow_field_fixture.u_sorted)[0] == flow_field_fixture.n_wind_directions - assert np.shape(flow_field_fixture.u_sorted)[1] == flow_field_fixture.n_wind_speeds - assert np.shape(flow_field_fixture.u_sorted)[2] == N_TURBINES + # Dimensions are (# findex, # turbines, N grid points, M grid points) + assert np.shape(flow_field_fixture.u_sorted)[0] == flow_field_fixture.n_findex + assert np.shape(flow_field_fixture.u_sorted)[1] == N_TURBINES + assert np.shape(flow_field_fixture.u_sorted)[2] == turbine_grid_fixture.grid_resolution assert np.shape(flow_field_fixture.u_sorted)[3] == turbine_grid_fixture.grid_resolution - assert np.shape(flow_field_fixture.u_sorted)[4] == turbine_grid_fixture.grid_resolution # Check that the wind speed profile was created correctly. By setting the shear # exponent to 1.0 above, the shear profile is a linear function of height and # the points on the turbine rotor are equally spaced about the rotor. # This means that their average should equal the wind speed at the center # which is the input wind speed. - shape = np.shape(flow_field_fixture.u_sorted[0, 0, 0, :, :]) + shape = np.shape(flow_field_fixture.u_sorted[0, 0, :, :]) n_elements = shape[0] * shape[1] average = ( - np.sum(flow_field_fixture.u_sorted[:, :, 0, :, :], axis=(-2, -1)) + np.sum(flow_field_fixture.u_sorted[:, 0, :, :], axis=(-2, -1)) / np.array([n_elements]) ) - baseline = np.reshape(flow_field_fixture.wind_speeds, (1, -1)) * np.ones( - (flow_field_fixture.n_wind_directions, flow_field_fixture.n_wind_speeds) - ) - assert np.array_equal(average, baseline) + assert np.array_equal(average, flow_field_fixture.wind_speeds) def test_asdict(flow_field_fixture: FlowField, turbine_grid_fixture: TurbineGrid): @@ -66,3 +45,76 @@ def test_asdict(flow_field_fixture: FlowField, turbine_grid_fixture: TurbineGrid dict2 = new_ff.as_dict() assert dict1 == dict2 + +def test_len_ws_equals_len_wd(flow_field_fixture: FlowField, turbine_grid_fixture: TurbineGrid): + + flow_field_fixture.initialize_velocity_field(turbine_grid_fixture) + dict1 = flow_field_fixture.as_dict() + + # Test that having the 3 equal in lenght raises no error + dict1['wind_directions'] = np.array([180, 180]) + dict1['wind_speeds'] = np.array([5., 6.]) + dict1['turbulence_intensities'] = np.array([175., 175.]) + + FlowField.from_dict(dict1) + + # Set the wind speeds as a different length of wind directions and turbulence_intensities + # And confirm error raised + dict1['wind_directions'] = np.array([180, 180]) + dict1['wind_speeds'] = np.array([5., 6., 7.]) + dict1['turbulence_intensities'] = np.array([175., 175.]) + + with pytest.raises(ValueError): + FlowField.from_dict(dict1) + + # Set the wind directions as a different length of wind speeds and turbulence_intensities + dict1['wind_directions'] = np.array([180, 180, 180.]) + # And confirm error raised + dict1['wind_speeds'] = np.array([5., 6.]) + dict1['turbulence_intensities'] = np.array([175., 175.]) + + with pytest.raises(ValueError): + FlowField.from_dict(dict1) + +def test_dim_ws_wd_ti(flow_field_fixture: FlowField, turbine_grid_fixture: TurbineGrid): + + flow_field_fixture.initialize_velocity_field(turbine_grid_fixture) + dict1 = flow_field_fixture.as_dict() + + # Test that having an extra dimension in wind_directions raises an error + with pytest.raises(ValueError): + dict1['wind_directions'] = np.array([[180, 180]]) + dict1['wind_speeds'] = np.array([5., 6.]) + dict1['turbulence_intensities'] = np.array([175., 175.]) + FlowField.from_dict(dict1) + + # Test that having an extra dimension in wind_speeds raises an error + with pytest.raises(ValueError): + dict1['wind_directions'] = np.array([180, 180]) + dict1['wind_speeds'] = np.array([[5., 6.]]) + dict1['turbulence_intensities'] = np.array([175., 175.]) + FlowField.from_dict(dict1) + + # Test that having an extra dimension in turbulence_intensities raises an error + with pytest.raises(ValueError): + dict1['wind_directions'] = np.array([180, 180]) + dict1['wind_speeds'] = np.array([5., 6.]) + dict1['turbulence_intensities'] = np.array([[175., 175.]]) + FlowField.from_dict(dict1) + + +def test_turbulence_intensities_to_n_findex(flow_field_fixture, turbine_grid_fixture): + # Assert tubulence intensity has same length as n_findex + assert len(flow_field_fixture.turbulence_intensities) == flow_field_fixture.n_findex + + # Assert turbulence_intensity_field is the correct shape + flow_field_fixture.initialize_velocity_field(turbine_grid_fixture) + assert flow_field_fixture.turbulence_intensity_field.shape == (N_FINDEX, N_TURBINES, 1, 1) + + # Assert that turbulence_intensity_field has values matched to turbulence_intensity + for findex in range(N_FINDEX): + for t in range(N_TURBINES): + assert ( + flow_field_fixture.turbulence_intensities[findex] + == flow_field_fixture.turbulence_intensity_field[findex, t, 0, 0] + ) diff --git a/tests/layout_optimization_integration_test.py b/tests/layout_optimization_integration_test.py new file mode 100644 index 000000000..0732b969c --- /dev/null +++ b/tests/layout_optimization_integration_test.py @@ -0,0 +1,72 @@ +import logging +from pathlib import Path + +import numpy as np +import pytest + +from floris import ( + FlorisModel, + TimeSeries, + WindRose, +) +from floris.optimization.layout_optimization.layout_optimization_base import ( + LayoutOptimization, +) +from floris.optimization.layout_optimization.layout_optimization_scipy import ( + LayoutOptimizationScipy, +) +from floris.wind_data import WindDataBase + + +TEST_DATA = Path(__file__).resolve().parent / "data" +YAML_INPUT = TEST_DATA / "input_full.yaml" + + +def test_base_class(caplog): + # Get a test fi + fmodel = FlorisModel(configuration=YAML_INPUT) + + # Set up a sample boundary + boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] + + # Now initiate layout optimization with a frequency matrix passed in the 3rd position + # (this should fail) + freq = np.ones((5, 5)) + freq = freq / freq.sum() + + # Check that warning is raised if fmodel does not contain wind_data + with caplog.at_level(logging.WARNING): + LayoutOptimization(fmodel, boundaries, 5) + assert caplog.text != "" # Checking not empty + + caplog.clear() + with caplog.at_level(logging.WARNING): + LayoutOptimization(fmodel=fmodel, boundaries=boundaries, min_dist=5,) + assert caplog.text != "" # Checking not empty + + time_series = TimeSeries( + wind_directions=fmodel.core.flow_field.wind_directions, + wind_speeds=fmodel.core.flow_field.wind_speeds, + turbulence_intensities=fmodel.core.flow_field.turbulence_intensities, + ) + fmodel.set(wind_data=time_series) + + caplog.clear() + with caplog.at_level(logging.WARNING): + LayoutOptimization(fmodel, boundaries, 5) + assert caplog.text != "" # Not empty, because get_farm_AEP called on TimeSeries + + # Passing without keyword arguments should work, or with keyword arguments + LayoutOptimization(fmodel, boundaries, 5) + LayoutOptimization(fmodel=fmodel, boundaries=boundaries, min_dist=5) + + # Check with WindRose on fmodel + fmodel.set(wind_data=time_series.to_WindRose()) + + caplog.clear() + with caplog.at_level(logging.WARNING): + LayoutOptimization(fmodel, boundaries, 5) + assert caplog.text == "" # Empty + + LayoutOptimization(fmodel, boundaries, 5) + LayoutOptimization(fmodel=fmodel, boundaries=boundaries, min_dist=5) diff --git a/tests/layout_visualization_test.py b/tests/layout_visualization_test.py new file mode 100644 index 000000000..055b15b1b --- /dev/null +++ b/tests/layout_visualization_test.py @@ -0,0 +1,47 @@ + +from pathlib import Path + +import matplotlib.pyplot as plt +import numpy as np + +import floris.layout_visualization as layoutviz +from floris import FlorisModel + + +TEST_DATA = Path(__file__).resolve().parent / "data" +YAML_INPUT = TEST_DATA / "input_full.yaml" + + +def test_get_wake_direction(): + # Turbine 0 wakes Turbine 1 at 270 degrees + assert np.isclose(layoutviz.get_wake_direction(0, 0, 1, 0), 270.0) + + # Turbine 0 wakes Turbine 1 at 0 degrees + assert np.isclose(layoutviz.get_wake_direction(0, 1, 0, 0), 0.0) + + # Winds from the south + assert np.isclose(layoutviz.get_wake_direction(0, -1, 0, 0), 180.0) + +def test_plotting_functions(): + + fmodel = FlorisModel(configuration=YAML_INPUT) + + ax = layoutviz.plot_turbine_points(fmodel=fmodel) + assert isinstance(ax, plt.Axes) + + ax = layoutviz.plot_turbine_labels(fmodel=fmodel) + assert isinstance(ax, plt.Axes) + + ax = layoutviz.plot_turbine_rotors(fmodel=fmodel) + assert isinstance(ax, plt.Axes) + + ax = layoutviz.plot_waking_directions(fmodel=fmodel) + assert isinstance(ax, plt.Axes) + + # Add additional turbines to test plot farm terrain + fmodel.set( + layout_x=[0, 1000, 0, 1000, 3000], + layout_y=[0, 0, 2000, 2000, 3000], + ) + ax = layoutviz.plot_farm_terrain(fmodel=fmodel) + assert isinstance(ax, plt.Axes) diff --git a/tests/parallel_floris_model_integration_test.py b/tests/parallel_floris_model_integration_test.py new file mode 100644 index 000000000..4b4d5aeec --- /dev/null +++ b/tests/parallel_floris_model_integration_test.py @@ -0,0 +1,140 @@ + +import copy + +import numpy as np + +from floris import ( + FlorisModel, + ParallelFlorisModel, + UncertainFlorisModel, +) +from tests.conftest import ( + assert_results_arrays, +) + + +DEBUG = False +VELOCITY_MODEL = "gauss" +DEFLECTION_MODEL = "gauss" + + +def test_parallel_turbine_powers(sample_inputs_fixture): + """ + The parallel computing interface behaves like the floris interface, but distributes + calculations among available cores to speep up the necessary computations. This test compares + the individual turbine powers computed with the parallel interface to those computed with + the serial floris interface. The expected result is that the turbine powers should be + exactly the same. + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + fmodel = FlorisModel(sample_inputs_fixture.core) + pfmodel_input = copy.deepcopy(fmodel) + fmodel.run() + + serial_turbine_powers = fmodel.get_turbine_powers() + + pfmodel = ParallelFlorisModel( + fmodel=pfmodel_input, + max_workers=2, + n_wind_condition_splits=2, + interface="concurrent", + print_timings=False, + ) + + parallel_turbine_powers = pfmodel.get_turbine_powers() + + if DEBUG: + print(serial_turbine_powers) + print(parallel_turbine_powers) + + assert_results_arrays(parallel_turbine_powers, serial_turbine_powers) + +def test_parallel_get_AEP(sample_inputs_fixture): + + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + freq=np.linspace(0, 1, 16)/8 + + fmodel = FlorisModel(sample_inputs_fixture.core) + pfmodel_input = copy.deepcopy(fmodel) + + fmodel.run() + serial_farm_AEP = fmodel.get_farm_AEP(freq=freq) + + pfmodel = ParallelFlorisModel( + fmodel=pfmodel_input, + max_workers=2, + n_wind_condition_splits=2, + interface="concurrent", + print_timings=False, + ) + + parallel_farm_AEP = pfmodel.get_farm_AEP(freq=freq) + + assert np.allclose(parallel_farm_AEP, serial_farm_AEP) + +def test_parallel_uncertain_turbine_powers(sample_inputs_fixture): + """ + + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + ufmodel = UncertainFlorisModel( + sample_inputs_fixture.core, + wd_sample_points=[-3, 0, 3], + wd_std=3 + ) + pfmodel_input = copy.deepcopy(ufmodel) + ufmodel.run() + + serial_turbine_powers = ufmodel.get_turbine_powers() + + pfmodel = ParallelFlorisModel( + fmodel=pfmodel_input, + max_workers=2, + n_wind_condition_splits=2, + interface="multiprocessing", + print_timings=False, + ) + + parallel_turbine_powers = pfmodel.get_turbine_powers() + + if DEBUG: + print(serial_turbine_powers) + print(parallel_turbine_powers) + + assert_results_arrays(parallel_turbine_powers, serial_turbine_powers) + +def test_parallel_uncertain_get_AEP(sample_inputs_fixture): + """ + + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + freq=np.linspace(0, 1, 16)/8 + + ufmodel = UncertainFlorisModel( + sample_inputs_fixture.core, + wd_sample_points=[-3, 0, 3], + wd_std=3 + ) + pfmodel_input = copy.deepcopy(ufmodel) + ufmodel.run() + serial_farm_AEP = ufmodel.get_farm_AEP(freq=freq) + + pfmodel = ParallelFlorisModel( + fmodel=pfmodel_input, + max_workers=2, + n_wind_condition_splits=2, + interface="multiprocessing", + print_timings=False, + ) + + parallel_farm_AEP = pfmodel.get_farm_AEP(freq=freq) + + assert np.allclose(parallel_farm_AEP, serial_farm_AEP) diff --git a/tests/reg_tests/cumulative_curl_regression_test.py b/tests/reg_tests/cumulative_curl_regression_test.py index 7cbffc561..6de08a83b 100644 --- a/tests/reg_tests/cumulative_curl_regression_test.py +++ b/tests/reg_tests/cumulative_curl_regression_test.py @@ -1,32 +1,18 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Ct, - Floris, + Core, power, rotor_effective_velocity, + thrust_coefficient, ) from tests.conftest import ( assert_results_arrays, + N_FINDEX, N_TURBINES, - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, print_test_values, ) @@ -39,27 +25,27 @@ [ # 8 m/s [ - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - [5.4838164, 0.8620156, 529225.9172271, 0.3142687], - [5.0221433, 0.8907283, 394126.6156555, 0.3347186], + [7.9736858, 0.7871515, 1753954.4591792, 0.2693224], + [5.4510872, 0.8920540, 554423.2959292, 0.3357243], + [5.0438692, 0.9152035, 418539.5184876, 0.3544008], ], # 9 m/s [ - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - [6.1712539, 0.8275295, 776795.0248898, 0.2923521], - [5.6500663, 0.8533298, 586018.0719934, 0.3085123], + [8.9703965, 0.7858774, 2496427.8618358, 0.2686331], + [6.1342847, 0.8547425, 797961.8242685, 0.3094367], + [5.6482366, 0.8808465, 620209.7062129, 0.3274069], ], # 10 m/s [ - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - [6.8779113, 0.7971705, 1085894.0434488, 0.2748170], - [6.2985764, 0.8216609, 828383.6208269, 0.2888489], + [9.9671073, 0.7838789, 3417797.0050916, 0.2675559], + [6.8191059, 0.8235980, 1105849.4970759, 0.2899988], + [6.2802136, 0.8481059, 863569.7643645, 0.3051320], ], # 11 m/s [ - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - [7.6258784, 0.7725938, 1482932.7552807, 0.2615643], - [6.9611771, 0.7938200, 1124649.7898263, 0.2729648], + [10.9638180, 0.7565157, 4519404.3072862, 0.2532794], + [7.5591728, 0.7958161, 1495578.0671426, 0.2740664], + [6.9317813, 0.8184737, 1156507.0595179, 0.2869705], ], ] ) @@ -68,27 +54,27 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [5.5274362, 0.8596051, 543479.0426304, 0.3126534], - [5.0310723, 0.8901730, 396739.4832795, 0.3342992], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [5.4955257, 0.8895278, 569251.8849842, 0.3338132], + [5.0512690, 0.9147828, 421008.7273674, 0.3540401], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.2202711, 0.8252701, 796655.8471824, 0.2909965], - [5.6617378, 0.8527326, 590066.7909898, 0.3081228], + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.1842430, 0.8524704, 820422.5044532, 0.3079521], + [5.6590417, 0.8802323, 623815.2315242, 0.3269626], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [6.9317633, 0.7950036, 1110959.2451850, 0.2736173], - [6.3125748, 0.8210156, 834055.5094286, 0.2884673], + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [6.8745497, 0.8210765, 1130776.3831297, 0.2885032], + [6.2938285, 0.8474867, 869690.8728188, 0.3047352], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [7.6832308, 0.7711112, 1517301.5142304, 0.2607884], - [6.9761726, 0.7932167, 1131629.3899797, 0.2726328], + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [7.6186441, 0.7939637, 1530927.6220300, 0.2730439], + [6.9469619, 0.8177833, 1163332.0650645, 0.2865657], ], ] ) @@ -97,27 +83,27 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [5.5431146, 0.8588028, 548917.6953551, 0.3121189], - [5.0453462, 0.8892852, 400916.4566323, 0.3336309], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [5.5123171, 0.8885732, 574854.9880625, 0.3330968], + [5.0653039, 0.9139850, 425692.0104596, 0.3533584], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.2378520, 0.8244598, 803779.2831349, 0.2905124], - [5.6785118, 0.8518742, 595885.4921489, 0.3075644], + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.2030677, 0.8516143, 828885.8701797, 0.3073957], + [5.6761588, 0.8792592, 629527.0166369, 0.3262611], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [6.9507085, 0.7942413, 1119777.2268361, 0.2731968], - [6.3312183, 0.8201563, 841609.4907163, 0.2879601], + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [6.8953509, 0.8201305, 1140128.3768208, 0.2879449], + [6.3135442, 0.8465900, 878554.8061141, 0.3041621], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [7.7025449, 0.7706119, 1528875.6023356, 0.2605276], - [6.9954994, 0.7924390, 1140624.9700319, 0.2722057], + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [7.6397253, 0.7933242, 1543688.6272448, 0.2726920], + [6.9675202, 0.8168483, 1172574.8397092, 0.2860189], ], ] ) @@ -126,31 +112,73 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [5.5274367, 0.8596051, 543479.2092235, 0.3126534], - [5.0364358, 0.8898394, 398309.0269631, 0.3340477], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [5.4955262, 0.8895278, 569252.0553799, 0.3338132], + [5.0564287, 0.9144895, 422730.4667041, 0.3537891], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.2202717, 0.8252701, 796656.0654567, 0.2909965], - [5.6680298, 0.8524106, 592249.4291781, 0.3079132], + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.1842436, 0.8524704, 820422.7619472, 0.3079521], + [5.6652985, 0.8798766, 625903.0435126, 0.3267059], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [6.9317639, 0.7950036, 1110959.5162103, 0.2736173], - [6.3196140, 0.8206912, 836907.6633514, 0.2882756], + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [6.8745503, 0.8210764, 1130776.6678583, 0.2885032], + [6.3010138, 0.8471599, 872921.3000764, 0.3045262], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [7.6832314, 0.7711112, 1517301.8723625, 0.2607884], - [6.9837299, 0.7929126, 1135146.9152189, 0.2724657], + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [7.6186447, 0.7939637, 1530928.0140962, 0.2730439], + [6.9547367, 0.8174297, 1166827.5280695, 0.2863588], ], ] ) +full_flow_baseline = np.array( + [ + [ + [ + [7.88772361, 8.00000000, 8.10178821], + [7.88772361, 8.00000000, 8.10178821], + [7.88772361, 8.00000000, 8.10178821], + [7.88772361, 8.00000000, 8.10178821], + [7.88772361, 8.00000000, 8.10178821], + ], + [ + [7.88772361, 8. , 8.10178821], + [7.85396979, 7.96487892, 8.06803439], + [4.19559099, 4.28925565, 4.40965558], + [7.85396979, 7.96487892, 8.06803439], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88769642, 7.99997223, 8.10176102], + [7.58415314, 7.69072103, 7.79821773], + [4.16725762, 4.26342392, 4.38132221], + [7.58415314, 7.69072103, 7.79821773], + [7.88769642, 7.99997223, 8.10176102], + ], + [ + [7.88513176, 7.99737618, 8.09919636], + [7.21888868, 7.32333558, 7.43301511], + [4.30201226, 4.40270245, 4.51689213], + [7.21888868, 7.32333558, 7.43301511], + [7.88513176, 7.99737618, 8.09919636], + ], + [ + [7.86539121, 7.97748824, 8.0794561 ], + [7.0723371 , 7.1790733 , 7.28645574], + [5.8436738 , 5.95178931, 6.05791862], + [7.0723371 , 7.1790733 , 7.28645574], + [7.86539121, 7.97748824, 8.0794561 ], + ] + ] + ] +) + # Note: compare the yawed vs non-yawed results. The upstream turbine # power should be lower in the yawed case. The following turbine @@ -161,75 +189,75 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -237,9 +265,10 @@ def test_regression_tandem(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4 ) - assert_results_arrays(test_results[0], baseline) + assert_results_arrays(test_results[0:4], baseline) def test_regression_rotation(sample_inputs_fixture): @@ -281,38 +310,39 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() farm_avg_velocities = average_velocity(floris.flow_field.u) - t0_270 = farm_avg_velocities[0, 0, 0] # upstream - t1_270 = farm_avg_velocities[0, 0, 1] # upstream - t2_270 = farm_avg_velocities[0, 0, 2] # waked - t3_270 = farm_avg_velocities[0, 0, 3] # waked + t0_270 = farm_avg_velocities[0, 0] # upstream + t1_270 = farm_avg_velocities[0, 1] # upstream + t2_270 = farm_avg_velocities[0, 2] # waked + t3_270 = farm_avg_velocities[0, 3] # waked - t0_360 = farm_avg_velocities[1, 0, 0] # waked - t1_360 = farm_avg_velocities[1, 0, 1] # upstream - t2_360 = farm_avg_velocities[1, 0, 2] # waked - t3_360 = farm_avg_velocities[1, 0, 3] # upstream + t0_360 = farm_avg_velocities[1, 0] # waked + t1_360 = farm_avg_velocities[1, 1] # upstream + t2_360 = farm_avg_velocities[1, 2] # waked + t3_360 = farm_avg_velocities[1, 3] # upstream assert np.allclose(t0_270, t1_360) assert np.allclose(t1_270, t3_360) @@ -324,80 +354,80 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -405,9 +435,10 @@ def test_regression_yaw(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4 ) - assert_results_arrays(test_results[0], yawed_baseline) + assert_results_arrays(test_results[0:4], yawed_baseline) def test_regression_yaw_added_recovery(sample_inputs_fixture): @@ -416,84 +447,84 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): correction enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = False - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = True + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = False + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -501,9 +532,10 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4 ) - assert_results_arrays(test_results[0], yaw_added_recovery_baseline) + assert_results_arrays(test_results[0:4], yaw_added_recovery_baseline) def test_regression_secondary_steering(sample_inputs_fixture): @@ -511,84 +543,84 @@ def test_regression_secondary_steering(sample_inputs_fixture): Tandem turbines with the upstream turbine yawed and secondary steering enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = True - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = False + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = True + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = False - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -596,13 +628,19 @@ def test_regression_secondary_steering(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4 ) - assert_results_arrays(test_results[0], secondary_steering_baseline) + assert_results_arrays(test_results[0:4], secondary_steering_baseline) def test_regression_small_grid_rotation(sample_inputs_fixture): """ + This utilizes a 5x5 wind farm with the layout in a regular grid oriented along the cardinal + directions. The wind direction in this test is from 285 degrees which is slightly north of + west. The objective of this test is to create a case with a very slight rotation of the wind + farm to target the rotation and masking routines. + Where wake models are masked based on the x-location of a turbine, numerical precision can cause masking to fail unexpectedly. For example, in the configuration here one of the turbines has these delta x values; @@ -617,8 +655,8 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -626,45 +664,72 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = np.ones((1, 1, len(X))) * floris.farm.ref_tilt_cp_cts + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) # A "column" is oriented parallel to the wind direction # Columns 1 - 4 should have the same power profile # Column 5 leading turbine is completely unwaked # and the rest of the turbines have a partial wake from their immediate upstream turbine - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,5:10]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,10:15]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,15:20]) - assert np.allclose(farm_powers[2,0,20], farm_powers[2,0,0]) - assert np.allclose(farm_powers[2,0,21], farm_powers[2,0,21:25]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,5:10]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,10:15]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,15:20]) + assert np.allclose(farm_powers[8,20], farm_powers[8,0]) + assert np.allclose(farm_powers[8,21], farm_powers[8,21:25]) + + +def test_full_flow_solver(sample_inputs_fixture): + """ + Full flow solver test with the flow field planar grid. + This requires one wind condition, and the grid is deliberately coarse to allow for + visually comparing results, as needed. + The u-component of velocity is compared, and the array has the shape + (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). + """ + + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { + "type": "flow_field_planar_grid", + "normal_vector": "z", + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], + "flow_field_grid_points": [5, 5], + "flow_field_bounds": [None, None], + } + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] + + floris = Core.from_dict(sample_inputs_fixture.core) + floris.solve_for_viz() + + velocities = floris.flow_field.u_sorted + + assert_results_arrays(velocities, full_flow_baseline) diff --git a/tests/reg_tests/empirical_gauss_regression_test.py b/tests/reg_tests/empirical_gauss_regression_test.py index 2a7c49127..392989076 100644 --- a/tests/reg_tests/empirical_gauss_regression_test.py +++ b/tests/reg_tests/empirical_gauss_regression_test.py @@ -1,32 +1,18 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Ct, - Floris, + Core, power, rotor_effective_velocity, + thrust_coefficient, ) from tests.conftest import ( assert_results_arrays, + N_FINDEX, N_TURBINES, - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, print_test_values, ) @@ -41,27 +27,27 @@ [ # 8 m/s [ - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - [5.8890878, 0.8410986, 668931.9953790, 0.3006878], - [5.9448342, 0.8382459, 688269.8273350, 0.2989067], + [7.9736858, 0.7871515, 1753954.4591792, 0.2693224], + [5.8239250, 0.8708590, 678834.8317748, 0.3203190], + [5.9004356, 0.8665095, 704365.4950630, 0.3173183], ], - # 9m/s + # 9 m/s [ - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - [6.6288143, 0.8071935, 969952.7378773, 0.2804513], - [6.7440713, 0.8025559, 1023598.6805729, 0.2778266], + [8.9703965, 0.7858774, 2496427.8618358, 0.2686331], + [6.5562701, 0.8355513, 987681.5731429, 0.2972386], + [6.6949231, 0.8292456, 1050018.3472064, 0.2933878], ], # 10 m/s [ - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - [7.4019251, 0.7790665, 1355562.9527211, 0.2649822], - [7.5493339, 0.7745724, 1437063.0620195, 0.2626039], + [9.9671073, 0.7838789, 3417797.0050916, 0.2675559], + [7.2923306, 0.8047024, 1343118.2404618, 0.2790376], + [7.4934722, 0.7978974, 1456951.3486441, 0.2752209], ], # 11 m/s [ - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - [8.2349756, 0.7622827, 1867008.5657835, 0.2562187], - [8.3523516, 0.7619629, 1946873.1634864, 0.2560548], + [10.9638180, 0.7565157, 4519404.3072862, 0.2532794], + [8.1353345, 0.7869536, 1872313.2273018, 0.2692152], + [8.2936951, 0.7867495, 1990669.8925423, 0.2691047], ], ] ) @@ -70,31 +56,132 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [5.9257102, 0.8392246, 681635.9273649, 0.2995159], - [5.9615388, 0.8373911, 694064.4542077, 0.2983761], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [5.8720857, 0.8681212, 694905.4822543, 0.3184244], + [5.9231111, 0.8652205, 711932.0521602, 0.3164383], + ], + # 9 m/s + [ + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.6102438, 0.8330967, 1011947.5002467, 0.2957310], + [6.7207579, 0.8280707, 1061633.3882586, 0.2926782], + ], + # 10 m/s + [ + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [7.3519418, 0.8026469, 1376375.4821341, 0.2778778], + [7.5221584, 0.7969827, 1473761.4857038, 0.2747128], + ], + # 11 m/s + [ + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [8.1956906, 0.7868758, 1917422.6059783, 0.2691731], + [8.3187504, 0.7867172, 2009395.8987459, 0.2690872], + ], + ] +) + +yaw_added_recovery_baseline = np.array( + [ + # 8 m/s + [ + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [5.8812867, 0.8675981, 697975.7537581, 0.3180646], + [5.9300836, 0.8648241, 714258.6740264, 0.3161686], + ], + # 9 m/s + [ + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.6205487, 0.8326280, 1016580.4631213, 0.2954444], + [6.7286194, 0.8277131, 1065167.8381647, 0.2924627], + ], + # 10 m/s + [ + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [7.3633114, 0.8022558, 1382735.2369962, 0.2776578], + [7.5308334, 0.7967093, 1478874.6141430, 0.2745612], + ], + # 11 m/s + [ + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [8.2070431, 0.7868612, 1925907.3101195, 0.2691652], + [8.3266654, 0.7867070, 2015311.4552010, 0.2690817], + ], + ] +) + +helix_added_recovery_baseline = np.array( + [ + # 8 m/s + [ + [7.9736858, 0.7871515, 1753954.4591792, 0.2693224], + [5.8239250, 0.8708590, 678834.8317748, 0.3203190], + [5.9004356, 0.8665095, 704365.4950630, 0.3173183], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.6698959, 0.8055405, 989074.0018995, 0.2795122], - [6.7631531, 0.8017881, 1032480.2286024, 0.2773950], + [8.9703965, 0.7858774, 2496427.8618358, 0.2686331], + [6.5562701, 0.8355513, 987681.5731429, 0.2972386], + [6.6949231, 0.8292456, 1050018.3472064, 0.2933878], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [7.4463751, 0.7776077, 1379101.8806016, 0.2642075], - [7.5701211, 0.7740351, 1449519.8581580, 0.2623212], + [9.9671073, 0.7838789, 3417797.0050916, 0.2675559], + [7.2923306, 0.8047024, 1343118.2404618, 0.2790376], + [7.4934722, 0.7978974, 1456951.3486441, 0.2752209], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [8.2809317, 0.7621575, 1898277.8462234, 0.2561545], - [8.3710828, 0.7619119, 1959618.1795131, 0.2560286], + [10.9638180, 0.7565157, 4519404.3072862, 0.2532794], + [8.1353345, 0.7869536, 1872313.2273018, 0.2692152], + [8.2936951, 0.7867495, 1990669.8925423, 0.2691047], ], ] ) +full_flow_baseline = np.array( + [ + [ + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772294, 7.99999928, 8.10178747], + [7.81880864, 7.9261404 , 8.02651415], + [4.66160854, 4.54241201, 4.57798522], + [7.81880864, 7.9261404 , 8.02651415], + [7.88772294, 7.99999928, 8.10178747], + ], + [ + [7.88733339, 7.99958656, 8.10136247], + [7.60765422, 7.70390457, 7.79791213], + [5.19792855, 5.15875115, 5.18986616], + [7.60765422, 7.70390457, 7.79791213], + [7.88733339, 7.99958656, 8.10136247], + ], + [ + [7.87220134, 7.98400571, 8.08549566], + [7.41124269, 7.50382311, 7.59416296], + [5.65108754, 5.65881944, 5.70295049], + [7.41124269, 7.50382311, 7.59416296], + [7.87220134, 7.98400571, 8.08549566], + ], + [ + [7.83300625, 7.94438006, 8.04560619], + [7.37461427, 7.47355048, 7.56659807], + [6.47381486, 6.53210142, 6.59762329], + [7.37461427, 7.47355048, 7.56659807], + [7.83300625, 7.94438006, 8.04560619], + ], + ] + ] +) + + # Note: compare the yawed vs non-yawed results. The upstream turbine # power should be lower in the yawed case. The following turbine # powers should higher in the yawed case. @@ -104,76 +191,76 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -181,9 +268,10 @@ def test_regression_tandem(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4 ) - assert_results_arrays(test_results[0], baseline) + assert_results_arrays(test_results[0:4], baseline) def test_regression_rotation(sample_inputs_fixture): @@ -225,39 +313,40 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() farm_avg_velocities = average_velocity(floris.flow_field.u) - t0_270 = farm_avg_velocities[0, 0, 0] # upstream - t1_270 = farm_avg_velocities[0, 0, 1] # upstream - t2_270 = farm_avg_velocities[0, 0, 2] # waked - t3_270 = farm_avg_velocities[0, 0, 3] # waked + t0_270 = farm_avg_velocities[0, 0] # upstream + t1_270 = farm_avg_velocities[0, 1] # upstream + t2_270 = farm_avg_velocities[0, 2] # waked + t3_270 = farm_avg_velocities[0, 3] # waked - t0_360 = farm_avg_velocities[1, 0, 0] # waked - t1_360 = farm_avg_velocities[1, 0, 1] # upstream - t2_360 = farm_avg_velocities[1, 0, 2] # waked - t3_360 = farm_avg_velocities[1, 0, 3] # upstream + t0_360 = farm_avg_velocities[1, 0] # waked + t1_360 = farm_avg_velocities[1, 1] # upstream + t2_360 = farm_avg_velocities[1, 2] # waked + t3_360 = farm_avg_velocities[1, 3] # upstream assert np.allclose(t0_270, t1_360) assert np.allclose(t1_270, t3_360) @@ -269,81 +358,258 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) + + farm_avg_velocities = average_velocity( + velocities, ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + farm_cts = thrust_coefficient( + velocities, + air_density, + yaw_angles, + tilt_angles, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, + floris.farm.turbine_tilt_interps, + floris.farm.correct_cp_ct_for_tilt, + floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, + ) + farm_powers = power( + velocities, + air_density, + floris.farm.turbine_power_functions, + yaw_angles, + tilt_angles, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_tilt_interps, + floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, + ) + farm_axial_inductions = axial_induction( + velocities, + air_density, + yaw_angles, + tilt_angles, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, + floris.farm.turbine_tilt_interps, + floris.farm.correct_cp_ct_for_tilt, + floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, + ) + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] + + if DEBUG: + print_test_values( + farm_avg_velocities, + farm_cts, + farm_powers, + farm_axial_inductions, + max_findex_print=4 + ) + + assert_results_arrays(test_results[0:4], yawed_baseline) + +def test_regression_yaw_added_recovery(sample_inputs_fixture): + """ + Tandem turbines with the upstream turbine yawed and yaw added recovery + correction enabled + """ + + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + + # Turn on yaw added recovery + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True + # First pass, leave at default value of 0; should then do nothing + + floris = Core.from_dict(sample_inputs_fixture.core) + + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 + floris.farm.yaw_angles = yaw_angles + + floris.initialize_domain() + floris.steady_state_atmospheric_condition() + + n_turbines = floris.farm.n_turbines + n_findex = floris.flow_field.n_findex + + velocities = floris.flow_field.u + air_density = floris.flow_field.air_density + yaw_angles = floris.farm.yaw_angles + tilt_angles = floris.farm.tilt_angles + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_tilt_interps, + floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, + ) + farm_axial_inductions = axial_induction( + velocities, + air_density, + yaw_angles, + tilt_angles, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, + floris.farm.turbine_tilt_interps, + floris.farm.correct_cp_ct_for_tilt, + floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, + ) + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] + + # Compare to case where enable_yaw_added_recovery = False, since + # default gains are 0. + assert_results_arrays(test_results[0:4], yawed_baseline) + + # Second pass, use nonzero gain + sample_inputs_fixture.core["wake"]["wake_deflection_parameters"]\ + ["empirical_gauss"]["yaw_added_mixing_gain"] = 0.1 + + floris = Core.from_dict(sample_inputs_fixture.core) + + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 + floris.farm.yaw_angles = yaw_angles + + floris.initialize_domain() + floris.steady_state_atmospheric_condition() + + n_turbines = floris.farm.n_turbines + n_findex = floris.flow_field.n_findex + + velocities = floris.flow_field.u + air_density = floris.flow_field.air_density + yaw_angles = floris.farm.yaw_angles + tilt_angles = floris.farm.tilt_angles + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) + + farm_avg_velocities = average_velocity( + velocities, + ) + farm_cts = thrust_coefficient( + velocities, + air_density, + yaw_angles, + tilt_angles, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, + velocities, + air_density, + floris.farm.turbine_power_functions, + yaw_angles, + tilt_angles, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_tilt_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -351,13 +617,111 @@ def test_regression_yaw(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4 ) - assert_results_arrays(test_results[0], yawed_baseline) + assert_results_arrays(test_results[0:4], yaw_added_recovery_baseline) + +def test_regression_helix(sample_inputs_fixture): + """ + Tandem turbines with the upstream turbine applying the helix + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + + floris = Core.from_dict(sample_inputs_fixture.core) + + awc_modes = np.array([["helix"]*N_TURBINES]*N_FINDEX) + awc_amplitudes = np.zeros((N_FINDEX, N_TURBINES)) + awc_amplitudes[:,0] = 5.0 + floris.farm.awc_amplitudes = awc_amplitudes + + floris.initialize_domain() + floris.steady_state_atmospheric_condition() + + n_turbines = floris.farm.n_turbines + n_findex = floris.flow_field.n_findex + + velocities = floris.flow_field.u + air_density = floris.flow_field.air_density + yaw_angles = floris.farm.yaw_angles + tilt_angles = floris.farm.tilt_angles + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) + + farm_avg_velocities = average_velocity( + velocities, + ) + farm_cts = thrust_coefficient( + velocities, + air_density, + yaw_angles, + tilt_angles, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, + floris.farm.turbine_tilt_interps, + floris.farm.correct_cp_ct_for_tilt, + floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, + ) + farm_powers = power( + velocities, + air_density, + floris.farm.turbine_power_functions, + yaw_angles, + tilt_angles, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_tilt_interps, + floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, + ) + farm_axial_inductions = axial_induction( + velocities, + air_density, + yaw_angles, + tilt_angles, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, + floris.farm.turbine_tilt_interps, + floris.farm.correct_cp_ct_for_tilt, + floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, + ) + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] + + if DEBUG: + print_test_values( + farm_avg_velocities, + farm_cts, + farm_powers, + farm_axial_inductions, + max_findex_print=4 + ) + + assert_results_arrays(test_results[0:4], helix_added_recovery_baseline) def test_regression_small_grid_rotation(sample_inputs_fixture): """ + This utilizes a 5x5 wind farm with the layout in a regular grid oriented along the cardinal + directions. The wind direction in this test is from 285 degrees which is slightly north of + west. The objective of this test is to create a case with a very slight rotation of the wind + farm to target the rotation and masking routines. + Where wake models are masked based on the x-location of a turbine, numerical precision can cause masking to fail unexpectedly. For example, in the configuration here one of the turbines has these delta x values; @@ -372,9 +736,9 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -382,44 +746,82 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u - yaw_angles = floris.farm.yaw_angles - tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = np.ones((1, 1, len(X))) * floris.farm.ref_tilt_cp_cts - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + # farm_eff_velocities = rotor_effective_velocity( + # floris.flow_field.air_density, + # floris.farm.ref_air_densities, + # velocities, + # yaw_angles, + # tilt_angles, + # floris.farm.ref_tilts, + # floris.farm.pPs, + # floris.farm.pTs, + # floris.farm.turbine_tilt_interps, + # floris.farm.correct_cp_ct_for_tilt, + # floris.farm.turbine_type_map, + # ) + farm_powers = power( velocities, - yaw_angles, - tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + floris.flow_field.air_density, + floris.farm.turbine_power_functions, + floris.farm.yaw_angles, + floris.farm.tilt_angles, + floris.farm.power_setpoints, + floris.farm.awc_modes, + floris.farm.awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) # A "column" is oriented parallel to the wind direction # Columns 1 - 4 should have the same power profile # Column 5 is completely unwaked in this model - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,5:10]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,10:15]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,15:20]) - assert np.allclose(farm_powers[2,0,20], farm_powers[2,0,0]) - assert np.allclose(farm_powers[2,0,21], farm_powers[2,0,21:25]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,5:10]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,10:15]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,15:20]) + assert np.allclose(farm_powers[8,20], farm_powers[8,0]) + assert np.allclose(farm_powers[8,21], farm_powers[8,21:25]) + + +def test_full_flow_solver(sample_inputs_fixture): + """ + Full flow solver test with the flow field planar grid. + This requires one wind condition, and the grid is deliberately coarse to allow for + visually comparing results, as needed. + The u-component of velocity is compared, and the array has the shape + (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). + """ + + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["turbulence_model"] = TURBULENCE_MODEL + sample_inputs_fixture.core["solver"] = { + "type": "flow_field_planar_grid", + "normal_vector": "z", + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], + "flow_field_grid_points": [5, 5], + "flow_field_bounds": [None, None], + } + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] + + floris = Core.from_dict(sample_inputs_fixture.core) + floris.solve_for_viz() + + velocities = floris.flow_field.u_sorted + + if DEBUG: + print(velocities) + + assert_results_arrays(velocities, full_flow_baseline) diff --git a/tests/reg_tests/floris_interface_regression_test.py b/tests/reg_tests/floris_interface_regression_test.py deleted file mode 100644 index ccf62350e..000000000 --- a/tests/reg_tests/floris_interface_regression_test.py +++ /dev/null @@ -1,155 +0,0 @@ -# Copyright 2023 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -import numpy as np - -from floris.simulation import ( - average_velocity, - axial_induction, - Ct, - power, -) -from floris.simulation.turbine import rotor_effective_velocity -from floris.tools import FlorisInterface -from tests.conftest import ( - assert_results_arrays, - N_TURBINES, - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, - print_test_values, -) - - -DEBUG = False -VELOCITY_MODEL = "gauss" -DEFLECTION_MODEL = "gauss" - -baseline = np.array( - [ - # 8 m/s - [ - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - ], - # 9 m/s - [ - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - ], - # 10 m/s - [ - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - ], - # 11 m/s - [ - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - ], - ] -) - - -def test_calculate_no_wake(sample_inputs_fixture): - """ - The calculate_no_wake function calculates the power production of a wind farm - assuming no wake losses. It does this by initializing and finalizing the - floris simulation while skipping the wake calculation. The power for all wind - turbines should be the same for a uniform wind condition. The chosen wake model - is not important since it will not actually be used. However, it is left enabled - instead of using "None" so that additional tests can be constructed here such - as one with yaw activated. - """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - - fi = FlorisInterface(sample_inputs_fixture.floris) - fi.calculate_no_wake() - - n_turbines = fi.floris.farm.n_turbines - n_wind_speeds = fi.floris.flow_field.n_wind_speeds - n_wind_directions = fi.floris.flow_field.n_wind_directions - - velocities = fi.floris.flow_field.u - yaw_angles = fi.floris.farm.yaw_angles - tilt_angles = fi.floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * fi.floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) - - farm_avg_velocities = average_velocity( - velocities, - ) - farm_eff_velocities = rotor_effective_velocity( - fi.floris.flow_field.air_density, - fi.floris.farm.ref_density_cp_cts, - velocities, - yaw_angles, - tilt_angles, - ref_tilt_cp_cts, - fi.floris.farm.pPs, - fi.floris.farm.pTs, - fi.floris.farm.turbine_tilt_interps, - fi.floris.farm.correct_cp_ct_for_tilt, - fi.floris.farm.turbine_type_map, - ) - farm_cts = Ct( - velocities, - yaw_angles, - tilt_angles, - ref_tilt_cp_cts, - fi.floris.farm.turbine_fCts, - fi.floris.farm.turbine_tilt_interps, - fi.floris.farm.correct_cp_ct_for_tilt, - fi.floris.farm.turbine_type_map, - ) - farm_powers = power( - fi.floris.farm.ref_density_cp_cts, - farm_eff_velocities, - fi.floris.farm.turbine_power_interps, - fi.floris.farm.turbine_type_map, - ) - farm_axial_inductions = axial_induction( - velocities, - yaw_angles, - tilt_angles, - ref_tilt_cp_cts, - fi.floris.farm.turbine_fCts, - fi.floris.farm.turbine_tilt_interps, - fi.floris.farm.correct_cp_ct_for_tilt, - fi.floris.farm.turbine_type_map, - ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] - - if DEBUG: - print_test_values( - farm_avg_velocities, - farm_cts, - farm_powers, - farm_axial_inductions, - ) - - assert_results_arrays(test_results[0], baseline) diff --git a/tests/reg_tests/gauss_regression_test.py b/tests/reg_tests/gauss_regression_test.py index a6a3dd5e7..cd3dcce0b 100644 --- a/tests/reg_tests/gauss_regression_test.py +++ b/tests/reg_tests/gauss_regression_test.py @@ -1,32 +1,18 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Ct, - Floris, + Core, power, rotor_effective_velocity, + thrust_coefficient, ) from tests.conftest import ( assert_results_arrays, + N_FINDEX, N_TURBINES, - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, print_test_values, ) @@ -39,27 +25,27 @@ [ # 8 m/s [ - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - [5.9535039, 0.8378023, 691277.2666766, 0.2986311], - [6.0197522, 0.8345126, 715409.4436445, 0.2965993], + [7.9736858, 0.7871515, 1753954.4591792, 0.2693224], + [5.9186455, 0.8654743, 710441.9192938, 0.3166113], + [6.0090150, 0.8604395, 741642.0177873, 0.3132110], ], # 9 m/s [ - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - [6.6995977, 0.8043454, 1002898.6210841, 0.2788357], - [6.8102318, 0.7998937, 1054392.8363310, 0.2763338], + [8.9703965, 0.7858774, 2496427.8618358, 0.2686331], + [6.6606465, 0.8308044, 1034608.0101396, 0.2943330], + [6.7947466, 0.8247058, 1094897.8563374, 0.2906592], ], # 10 m/s [ - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - [7.4637061, 0.7770389, 1388279.6564701, 0.2639062], - [7.5999706, 0.7732635, 1467407.3821931, 0.2619157], + [9.9671073, 0.7838789, 3417797.0050916, 0.2675559], + [7.4045198, 0.8008441, 1405853.7207176, 0.2768656], + [7.5868432, 0.7949439, 1511887.2179035, 0.2735844], ], # 11 m/s [ - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - [8.2622911, 0.7622083, 1885594.4958198, 0.2561805], - [8.3719551, 0.7619095, 1960211.6949745, 0.2560274], + [10.9638180, 0.7565157, 4519404.3072862, 0.2532794], + [8.2046271, 0.7868643, 1924101.6501936, 0.2691669], + [8.3491997, 0.7866780, 2032153.3223547, 0.2690660], ], ] ) @@ -68,31 +54,74 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [5.9856445, 0.8361576, 702426.4817361, 0.2976127], - [6.0238963, 0.8343216, 717088.5782753, 0.2964819], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [5.9521551, 0.8635694, 721623.6989382, 0.3153174], + [6.0131307, 0.8602523, 743492.3616581, 0.3130858], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.7356851, 0.8028933, 1019695.3621240, 0.2780165], - [6.8150684, 0.7996991, 1056644.0444495, 0.2762251], + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.6982609, 0.8290938, 1051519.0079315, 0.2932960], + [6.7996516, 0.8244827, 1097103.0727816, 0.2905261], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [7.5030787, 0.7757681, 1409344.3206494, 0.2632343], - [7.6053686, 0.7731239, 1470642.1508821, 0.2618425], + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [7.4461669, 0.7994645, 1429777.3846192, 0.2760940], + [7.5922658, 0.7947730, 1515083.3259879, 0.2734901], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [8.3037405, 0.7620954, 1913797.3425937, 0.2561227], - [8.3759415, 0.7618987, 1962924.0966747, 0.2560219], + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [8.2481957, 0.7868081, 1956664.2629680, 0.2691365], + [8.3531097, 0.7866729, 2035075.5955678, 0.2690633], ], ] ) +full_flow_baseline = np.array( + [ + [ + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772264, 7.99999899, 8.10178721], + [7.80183828, 7.91077933, 8.01357204], + [4.05787708, 4.02142188, 4.16800363], + [7.80183828, 7.91077933, 8.01357204], + [7.88772264, 7.99999899, 8.10178721], + ], + [ + [7.88365433, 7.9958357 , 8.09760849], + [7.54214774, 7.64551046, 7.74683377], + [4.99852407, 5.0247459 , 5.13417881], + [7.54214774, 7.64551046, 7.74683377], + [7.88365433, 7.9958357 , 8.09760849], + ], + [ + [7.85066049, 7.96222083, 8.06371923], + [7.39444624, 7.49602334, 7.5951238 ], + [5.50716692, 5.55540288, 5.65662569], + [7.39444624, 7.49602334, 7.5951238 ], + [7.85066049, 7.96222083, 8.06371923], + ], + [ + [7.79761973, 7.90832696, 8.009239 ], + [7.41896092, 7.52268669, 7.62030379], + [6.98565022, 7.0811275 , 7.17523349], + [7.41896092, 7.52268669, 7.62030379], + [7.79761973, 7.90832696, 8.009239 ], + ] + ] + ] +) + + """ # These are the results from v2.4 develop branch gch_baseline = np.array( @@ -159,27 +188,27 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [6.0012497, 0.8353654, 707912.6031236, 0.2971241], - [6.0458168, 0.8333112, 725970.3069204, 0.2958623], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [5.9689340, 0.8626155, 727222.6050018, 0.3146730], + [6.0360908, 0.8592082, 753814.9629960, 0.3123888], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.7531826, 0.8021893, 1027839.4859975, 0.2776204], - [6.8391301, 0.7987309, 1067843.4584263, 0.2756849], + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.7170645, 0.8282386, 1059972.8615898, 0.2927795], + [6.8249569, 0.8233319, 1108480.0451319, 0.2898405], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [7.5219279, 0.7752809, 1420639.8615893, 0.2629772], - [7.6309661, 0.7724622, 1485981.5768983, 0.2614954], + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [7.4669332, 0.7987766, 1441706.3550352, 0.2757103], + [7.6196359, 0.7939336, 1531527.9847411, 0.2730273], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [8.3229930, 0.7620429, 1926897.0262401, 0.2560958], - [8.4021717, 0.7618272, 1980771.5704442, 0.2559853], + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [8.2691610, 0.7867811, 1972333.4291742, 0.2691218], + [8.3808845, 0.7866371, 2055834.1618762, 0.2690439], ], ] ) @@ -188,27 +217,27 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [6.0012490, 0.8353654, 707912.3201655, 0.2971241], - [6.0404040, 0.8335607, 723777.1688957, 0.2960151], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [5.9689332, 0.8626156, 727222.3540334, 0.3146730], + [6.0305406, 0.8594606, 751319.6495844, 0.3125571], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.7531818, 0.8021893, 1027839.1215598, 0.2776204], - [6.8331381, 0.7989720, 1065054.4872236, 0.2758193], + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.7170636, 0.8282387, 1059972.4826657, 0.2927795], + [6.8187909, 0.8236123, 1105707.8700965, 0.2900073], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [7.5219271, 0.7752809, 1420639.3564230, 0.2629773], - [7.6244680, 0.7726302, 1482087.5389477, 0.2615835], + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [7.4669323, 0.7987766, 1441705.8203841, 0.2757103], + [7.6128912, 0.7941382, 1527445.2805280, 0.2731400], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [8.3229921, 0.7620429, 1926896.4413586, 0.2560958], - [8.3952439, 0.7618461, 1976057.7564083, 0.2559949], + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [8.2691601, 0.7867811, 1972332.7278100, 0.2691218], + [8.3736743, 0.7866464, 2050445.3384596, 0.2690489], ], ] ) @@ -217,27 +246,27 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [5.9856452, 0.8361576, 702426.7279908, 0.2976127], - [6.0294010, 0.8340678, 719318.9574833, 0.2963261], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [5.9521559, 0.8635693, 721623.9542957, 0.3153174], + [6.0187788, 0.8599955, 746031.6889128, 0.3129141], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.7356859, 0.8028933, 1019695.7325708, 0.2780165], - [6.8211610, 0.7994540, 1059479.8255425, 0.2760882], + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.6982618, 0.8290937, 1051519.3934629, 0.2932959], + [6.8059255, 0.8241974, 1099923.7444659, 0.2903559], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [7.5030795, 0.7757681, 1409344.8339510, 0.2632343], - [7.6119726, 0.7729532, 1474599.5989813, 0.2617529], + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [7.4461678, 0.7994645, 1429777.9285494, 0.2760940], + [7.5991268, 0.7945568, 1519127.2504621, 0.2733708], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [8.3037414, 0.7620954, 1913797.9363787, 0.2561227], - [8.3829757, 0.7618795, 1967710.2678086, 0.2560120], + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [8.2481967, 0.7868081, 1956664.9757307, 0.2691365], + [8.3604363, 0.7866635, 2040551.4040835, 0.2690582], ], ] ) @@ -252,76 +281,75 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -329,9 +357,10 @@ def test_regression_tandem(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4, ) - assert_results_arrays(test_results[0], baseline) + assert_results_arrays(test_results[0:4], baseline) def test_regression_rotation(sample_inputs_fixture): @@ -373,38 +402,40 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] + - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() farm_avg_velocities = average_velocity(floris.flow_field.u) - t0_270 = farm_avg_velocities[0, 0, 0] # upstream - t1_270 = farm_avg_velocities[0, 0, 1] # upstream - t2_270 = farm_avg_velocities[0, 0, 2] # waked - t3_270 = farm_avg_velocities[0, 0, 3] # waked + t0_270 = farm_avg_velocities[0, 0] # upstream + t1_270 = farm_avg_velocities[0, 1] # upstream + t2_270 = farm_avg_velocities[0, 2] # waked + t3_270 = farm_avg_velocities[0, 3] # waked - t0_360 = farm_avg_velocities[1, 0, 0] # waked - t1_360 = farm_avg_velocities[1, 0, 1] # upstream - t2_360 = farm_avg_velocities[1, 0, 2] # waked - t3_360 = farm_avg_velocities[1, 0, 3] # upstream + t0_360 = farm_avg_velocities[1, 0] # waked + t1_360 = farm_avg_velocities[1, 1] # upstream + t2_360 = farm_avg_velocities[1, 2] # waked + t3_360 = farm_avg_velocities[1, 3] # upstream assert np.allclose(t0_270, t1_360) assert np.allclose(t1_270, t3_360) @@ -416,80 +447,80 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -497,9 +528,10 @@ def test_regression_yaw(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4, ) - assert_results_arrays(test_results[0], yawed_baseline) + assert_results_arrays(test_results[0:4], yawed_baseline) def test_regression_gch(sample_inputs_fixture): @@ -507,82 +539,82 @@ def test_regression_gch(sample_inputs_fixture): Tandem turbines with the upstream turbine yawed, yaw added recovery correction enabled, and secondary steering enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL ### With GCH off (via conftest), GCH should be same as Gauss - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] # Don't use the test values here, gch is off! See the docstring. # if DEBUG: @@ -593,85 +625,85 @@ def test_regression_gch(sample_inputs_fixture): # farm_axial_inductions, # ) - assert_results_arrays(test_results[0], yawed_baseline) + assert_results_arrays(test_results[0:4], yawed_baseline) ### With GCH on, the results should change - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = True - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = True + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = True + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -679,9 +711,10 @@ def test_regression_gch(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4, ) - assert_results_arrays(test_results[0], gch_baseline) + assert_results_arrays(test_results[0:4], gch_baseline) def test_regression_yaw_added_recovery(sample_inputs_fixture): @@ -690,84 +723,84 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): correction enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = False - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = True + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = False + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = True - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -775,9 +808,10 @@ def test_regression_yaw_added_recovery(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4, ) - assert_results_arrays(test_results[0], yaw_added_recovery_baseline) + assert_results_arrays(test_results[0:4], yaw_added_recovery_baseline) def test_regression_secondary_steering(sample_inputs_fixture): @@ -785,84 +819,84 @@ def test_regression_secondary_steering(sample_inputs_fixture): Tandem turbines with the upstream turbine yawed and secondary steering enabled """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["enable_transverse_velocities"] = True - sample_inputs_fixture.floris["wake"]["enable_secondary_steering"] = True - sample_inputs_fixture.floris["wake"]["enable_yaw_added_recovery"] = False + sample_inputs_fixture.core["wake"]["enable_transverse_velocities"] = True + sample_inputs_fixture.core["wake"]["enable_secondary_steering"] = True + sample_inputs_fixture.core["wake"]["enable_yaw_added_recovery"] = False - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -870,13 +904,19 @@ def test_regression_secondary_steering(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4, ) - assert_results_arrays(test_results[0], secondary_steering_baseline) + assert_results_arrays(test_results[0:4], secondary_steering_baseline) def test_regression_small_grid_rotation(sample_inputs_fixture): """ + This utilizes a 5x5 wind farm with the layout in a regular grid oriented along the cardinal + directions. The wind direction in this test is from 285 degrees which is slightly north of + west. The objective of this test is to create a case with a very slight rotation of the wind + farm to target the rotation and masking routines. + Where wake models are masked based on the x-location of a turbine, numerical precision can cause masking to fail unexpectedly. For example, in the configuration here one of the turbines has these delta x values; @@ -891,8 +931,8 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -900,10 +940,10 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -911,34 +951,60 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): velocities = floris.flow_field.u yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = np.ones((1, 1, len(X))) * floris.farm.ref_tilt_cp_cts + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_powers = power( velocities, + floris.flow_field.air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) # A "column" is oriented parallel to the wind direction # Columns 1 - 4 should have the same power profile # Column 5 leading turbine is completely unwaked # and the rest of the turbines have a partial wake from their immediate upstream turbine - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,5:10]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,10:15]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,15:20]) - assert np.allclose(farm_powers[2,0,20], farm_powers[2,0,0]) - assert np.allclose(farm_powers[2,0,21], farm_powers[2,0,21:25]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,5:10]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,10:15]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,15:20]) + assert np.allclose(farm_powers[8,20], farm_powers[8,0]) + assert np.allclose(farm_powers[8,21], farm_powers[8,21:25]) + + +def test_full_flow_solver(sample_inputs_fixture): + """ + Full flow solver test with the flow field planar grid. + This requires one wind condition, and the grid is deliberately coarse to allow for + visually comparing results, as needed. + The u-component of velocity is compared, and the array has the shape + (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). + """ + + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { + "type": "flow_field_planar_grid", + "normal_vector": "z", + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], + "flow_field_grid_points": [5, 5], + "flow_field_bounds": [None, None], + } + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] + + floris = Core.from_dict(sample_inputs_fixture.core) + floris.solve_for_viz() + + velocities = floris.flow_field.u_sorted + + assert_results_arrays(velocities, full_flow_baseline) diff --git a/tests/reg_tests/jensen_jimenez_regression_test.py b/tests/reg_tests/jensen_jimenez_regression_test.py index 7d0f633ce..8c6a2accd 100644 --- a/tests/reg_tests/jensen_jimenez_regression_test.py +++ b/tests/reg_tests/jensen_jimenez_regression_test.py @@ -1,32 +1,18 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Ct, - Floris, + Core, power, rotor_effective_velocity, + thrust_coefficient, ) from tests.conftest import ( assert_results_arrays, + N_FINDEX, N_TURBINES, - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, print_test_values, ) @@ -40,27 +26,27 @@ [ # 8 m/s [ - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - [6.1528670, 0.8283770, 769344.9989547, 0.2928630], - [5.6590323, 0.8528710, 589128.2717851, 0.3082130], + [7.9736858, 0.7871515, 1753954.4591792, 0.2693224], + [6.0660565, 0.8578454, 767287.2198744, 0.3114830], + [5.5204712, 0.8881097, 577575.9208353, 0.3327500], ], # 9 m/s [ - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - [6.9262647, 0.7952248, 1108399.9545223, 0.2737395], - [6.5033542, 0.8122418, 911557.7945732, 0.2833446], + [8.9703965, 0.7858774, 2496427.8618358, 0.2686331], + [6.8298067, 0.8231113, 1110660.4518964, 0.2897093], + [6.3668912, 0.8441639, 902538.9934586, 0.3026196], ], # 10 m/s [ - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - [7.7391355, 0.7696661, 1550802.6855981, 0.2600344], - [7.3444882, 0.7809516, 1325146.7113373, 0.2659870], + [9.9671073, 0.7838789, 3417797.0050916, 0.2675559], + [7.5982117, 0.7945856, 1518587.8467982, 0.2733867], + [7.2042504, 0.8077903, 1294847.7809883, 0.2807914], ], # 11 m/s [ - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - [8.6200527, 0.7618150, 2139354.1087623, 0.2559790], - [8.1422116, 0.7625354, 1803890.3447532, 0.2563483], + [10.9638180, 0.7565157, 4519404.3072862, 0.2532794], + [8.4970746, 0.7864874, 2142673.1558338, 0.2689629], + [7.9997342, 0.7871282, 1770992.0756703, 0.2693098], ], ] ) @@ -69,31 +55,73 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [6.1670027, 0.8277254, 775072.5021192, 0.2924701], - [5.6650398, 0.8525636, 591212.2253601, 0.3080128], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [6.0816475, 0.8571363, 774296.7271893, 0.3110134], + [5.5272875, 0.8877222, 579850.4298177, 0.3324606], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.9420997, 0.7945877, 1115770.2903095, 0.2733878], - [6.5099782, 0.8119752, 914640.8879238, 0.2831909], + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.8472506, 0.8223180, 1118503.0309148, 0.2892383], + [6.3747452, 0.8438067, 906070.0511419, 0.3023935], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [7.7560617, 0.7692286, 1560945.8383104, 0.2598066], - [7.3508004, 0.7807445, 1328489.3723384, 0.2658764], + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [7.6174285, 0.7940006, 1530191.8035935, 0.2730642], + [7.2119500, 0.8075204, 1299067.3876318, 0.2806375], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [8.6371187, 0.7618512, 2152434.8973815, 0.2559975], - [8.1465243, 0.7625236, 1806824.8092631, 0.2563423], + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [8.5159500, 0.7864631, 2156780.3499849, 0.2689497], + [8.0047998, 0.7871218, 1774753.2988553, 0.2693064], ], ] ) +full_flow_baseline = np.array( + [ + [ + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [5.55736296, 5.63646825, 5.708184 ], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [5.11849406, 5.19135235, 5.25740466], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772361, 8. , 8.10178821], + [7.18032699, 7.28253407, 7.37519358], + [4.98829055, 5.05929547, 5.12366755], + [7.18032699, 7.28253407, 7.37519358], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772361, 8. , 8.10178821], + [6.97109947, 6.37648724, 7.16028784], + [6.28699612, 6.37648724, 6.45761864], + [6.97109947, 6.37648724, 7.16028784], + [7.88772361, 8. , 8.10178821], + ] + ] + ] +) + # Note: compare the yawed vs non-yawed results. The upstream turbine # power should be lower in the yawed case. The following turbine # powers should higher in the yawed case. @@ -103,75 +131,75 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -179,9 +207,10 @@ def test_regression_tandem(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4 ) - assert_results_arrays(test_results[0], baseline) + assert_results_arrays(test_results[0:4], baseline) def test_regression_rotation(sample_inputs_fixture): @@ -223,38 +252,39 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() farm_avg_velocities = average_velocity(floris.flow_field.u) - t0_270 = farm_avg_velocities[0, 0, 0] # upstream - t1_270 = farm_avg_velocities[0, 0, 1] # upstream - t2_270 = farm_avg_velocities[0, 0, 2] # waked - t3_270 = farm_avg_velocities[0, 0, 3] # waked + t0_270 = farm_avg_velocities[0, 0] # upstream + t1_270 = farm_avg_velocities[0, 1] # upstream + t2_270 = farm_avg_velocities[0, 2] # waked + t3_270 = farm_avg_velocities[0, 3] # waked - t0_360 = farm_avg_velocities[1, 0, 0] # waked - t1_360 = farm_avg_velocities[1, 0, 1] # upstream - t2_360 = farm_avg_velocities[1, 0, 2] # waked - t3_360 = farm_avg_velocities[1, 0, 3] # upstream + t0_360 = farm_avg_velocities[1, 0] # waked + t1_360 = farm_avg_velocities[1, 1] # upstream + t2_360 = farm_avg_velocities[1, 2] # waked + t3_360 = farm_avg_velocities[1, 3] # upstream assert np.allclose(t0_270, t1_360) assert np.allclose(t1_270, t3_360) @@ -266,80 +296,80 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -347,13 +377,19 @@ def test_regression_yaw(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4 ) - assert_results_arrays(test_results[0], yawed_baseline) + assert_results_arrays(test_results[0:4], yawed_baseline) def test_regression_small_grid_rotation(sample_inputs_fixture): """ + This utilizes a 5x5 wind farm with the layout in a regular grid oriented along the cardinal + directions. The wind direction in this test is from 285 degrees which is slightly north of + west. The objective of this test is to create a case with a very slight rotation of the wind + farm to target the rotation and masking routines. + Where wake models are masked based on the x-location of a turbine, numerical precision can cause masking to fail unexpectedly. For example, in the configuration here one of the turbines has these delta x values; @@ -368,8 +404,8 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -377,43 +413,83 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = np.ones((1, 1, len(X))) * floris.farm.ref_tilt_cp_cts - - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + + # farm_eff_velocities = rotor_effective_velocity( + # floris.flow_field.air_density, + # floris.farm.ref_air_densities, + # velocities, + # yaw_angles, + # tilt_angles, + # floris.farm.ref_tilts, + # floris.farm.pPs, + # floris.farm.pTs, + # floris.farm.turbine_tilt_interps, + # floris.farm.correct_cp_ct_for_tilt, + # floris.farm.turbine_type_map, + # ) + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) # A "column" is oriented parallel to the wind direction # Columns 1 - 4 should have the same power profile # Column 5 is completely unwaked in this model - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,5:10]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,10:15]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,15:20]) - assert np.allclose(farm_powers[2,0,20], farm_powers[2,0,20:25]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,5:10]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,10:15]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,15:20]) + assert np.allclose(farm_powers[8,20], farm_powers[8,20:25]) + + +def test_full_flow_solver(sample_inputs_fixture): + """ + Full flow solver test with the flow field planar grid. + This requires one wind condition, and the grid is deliberately coarse to allow for + visually comparing results, as needed. + The u-component of velocity is compared, and the array has the shape + (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). + """ + + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { + "type": "flow_field_planar_grid", + "normal_vector": "z", + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], + "flow_field_grid_points": [5, 5], + "flow_field_bounds": [None, None], + } + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] + + floris = Core.from_dict(sample_inputs_fixture.core) + floris.solve_for_viz() + + velocities = floris.flow_field.u_sorted + + assert_results_arrays(velocities, full_flow_baseline) diff --git a/tests/reg_tests/none_regression_test.py b/tests/reg_tests/none_regression_test.py index 787685c0e..d8b7e87f3 100644 --- a/tests/reg_tests/none_regression_test.py +++ b/tests/reg_tests/none_regression_test.py @@ -1,33 +1,19 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import numpy as np import pytest -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Ct, - Floris, + Core, power, rotor_effective_velocity, + thrust_coefficient, ) from tests.conftest import ( assert_results_arrays, + N_FINDEX, N_TURBINES, - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, print_test_values, ) @@ -41,27 +27,27 @@ [ # 8 m/s [ - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], + [7.9736858, 0.7871515, 1753954.4591792, 0.2693224], + [7.9736858, 0.7871515, 1753954.4591792, 0.2693224], + [7.9736858, 0.7871515, 1753954.4591792, 0.2693224], ], # 9 m/s [ - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], + [8.9703965, 0.7858774, 2496427.8618358, 0.2686331], + [8.9703965, 0.7858774, 2496427.8618358, 0.2686331], + [8.9703965, 0.7858774, 2496427.8618358, 0.2686331], ], # 10 m/s [ - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], + [9.9671073, 0.7838789, 3417797.0050916, 0.2675559], + [9.9671073, 0.7838789, 3417797.0050916, 0.2675559], + [9.9671073, 0.7838789, 3417797.0050916, 0.2675559], ], # 11 m/s [ - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], + [10.9638180, 0.7565157, 4519404.3072862, 0.2532794], + [10.9638180, 0.7565157, 4519404.3072862, 0.2532794], + [10.9638180, 0.7565157, 4519404.3072862, 0.2532794], ], ] ) @@ -95,6 +81,48 @@ ] ) +full_flow_baseline = np.array( + [ + [ + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + [ + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + [7.88772361, 8. , 8.10178821], + ], + ] + ] +) + # Note: compare the yawed vs non-yawed results. The upstream turbine # power should be lower in the yawed case. The following turbine # powers should higher in the yawed case. @@ -104,75 +132,75 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -180,9 +208,10 @@ def test_regression_tandem(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4, ) - assert_results_arrays(test_results[0], baseline) + assert_results_arrays(test_results[0:4], baseline) def test_regression_rotation(sample_inputs_fixture): @@ -224,38 +253,39 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() farm_avg_velocities = average_velocity(floris.flow_field.u) - t0_270 = farm_avg_velocities[0, 0, 0] # upstream - t1_270 = farm_avg_velocities[0, 0, 1] # upstream - t2_270 = farm_avg_velocities[0, 0, 2] # waked - t3_270 = farm_avg_velocities[0, 0, 3] # waked + t0_270 = farm_avg_velocities[0, 0] # upstream + t1_270 = farm_avg_velocities[0, 1] # upstream + t2_270 = farm_avg_velocities[0, 2] # waked + t3_270 = farm_avg_velocities[0, 3] # waked - t0_360 = farm_avg_velocities[1, 0, 0] # waked - t1_360 = farm_avg_velocities[1, 0, 1] # upstream - t2_360 = farm_avg_velocities[1, 0, 2] # waked - t3_360 = farm_avg_velocities[1, 0, 3] # upstream + t0_360 = farm_avg_velocities[1, 0] # waked + t1_360 = farm_avg_velocities[1, 1] # upstream + t2_360 = farm_avg_velocities[1, 2] # waked + t3_360 = farm_avg_velocities[1, 3] # upstream assert np.allclose(t0_270, t1_360) assert np.allclose(t1_270, t3_360) @@ -267,13 +297,13 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() @@ -283,6 +313,11 @@ def test_regression_yaw(sample_inputs_fixture): def test_regression_small_grid_rotation(sample_inputs_fixture): """ + This utilizes a 5x5 wind farm with the layout in a regular grid oriented along the cardinal + directions. The wind direction in this test is from 285 degrees which is slightly north of + west. The objective of this test is to create a case with a very slight rotation of the wind + farm to target the rotation and masking routines. + Where wake models are masked based on the x-location of a turbine, numerical precision can cause masking to fail unexpectedly. For example, in the configuration here one of the turbines has these delta x values; @@ -297,8 +332,8 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -306,43 +341,72 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() # farm_avg_velocities = average_velocity(floris.flow_field.u) velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = np.ones((1, 1, len(X))) * floris.farm.ref_tilt_cp_cts + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) # A "column" is oriented parallel to the wind direction # Columns 1 - 4 should have the same power profile - # Column 5 is completely unwaked in this model - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,5:10]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,10:15]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,15:20]) - assert np.allclose(farm_powers[2,0,20], farm_powers[2,0,20:25]) + # Column 5 leading turbine is completely unwaked + # and the rest of the turbines have a partial wake from their immediate upstream turbine + assert np.allclose(farm_powers[8,0:5], farm_powers[8,5:10]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,10:15]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,15:20]) + assert np.allclose(farm_powers[8,20], farm_powers[8,0]) + assert np.allclose(farm_powers[8,21], farm_powers[8,21:25]) + + +def test_full_flow_solver(sample_inputs_fixture): + """ + Full flow solver test with the flow field planar grid. + This requires one wind condition, and the grid is deliberately coarse to allow for + visually comparing results, as needed. + The u-component of velocity is compared, and the array has the shape + (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). + """ + + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { + "type": "flow_field_planar_grid", + "normal_vector": "z", + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], + "flow_field_grid_points": [5, 5], + "flow_field_bounds": [None, None], + } + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1] + + floris = Core.from_dict(sample_inputs_fixture.core) + floris.solve_for_viz() + + velocities = floris.flow_field.u_sorted + + assert_results_arrays(velocities, full_flow_baseline) diff --git a/tests/reg_tests/scipy_layout_opt_regression.py b/tests/reg_tests/scipy_layout_opt_regression.py new file mode 100644 index 000000000..1029dfd76 --- /dev/null +++ b/tests/reg_tests/scipy_layout_opt_regression.py @@ -0,0 +1,137 @@ + +import numpy as np +import pandas as pd + +from floris import FlorisModel, WindRose +from floris.optimization.layout_optimization.layout_optimization_scipy import ( + LayoutOptimizationScipy, +) +from tests.conftest import ( + assert_results_arrays, +) + + +DEBUG = False +VELOCITY_MODEL = "gauss" +DEFLECTION_MODEL = "gauss" + +baseline = np.array( + [ + [0.0, 495.37587653, 1000.0], + [5.0, 11.40800868, 24.93196392], + ] +) + +baseline_value = np.array( + [ + [8.68262334e+01, 1.04360964e-12, 4.00000000e+02, 2.36100415e+02], + [1.69954798e-14, 4.00000000e+02, 0.00000000e+00, 4.00000000e+02], + ] +) + + +def test_scipy_layout_opt(sample_inputs_fixture): + """ + The SciPy optimization method optimizes turbine layout using SciPy's minimize method. This test + compares the optimization results from the SciPy layout optimization for a simple farm with a + simple wind rose to stored baseline results. + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + opt_options = { + "maxiter": 5, + "disp": True, + "iprint": 2, + "ftol": 1e-12, + "eps": 0.01, + } + + boundaries = [(0.0, 0.0), (0.0, 1000.0), (1000.0, 1000.0), (1000.0, 0.0), (0.0, 0.0)] + + fmodel = FlorisModel(sample_inputs_fixture.core) + wd_array = np.arange(0, 360.0, 5.0) + ws_array = 8.0 * np.ones_like(wd_array) + ti_array = 0.1 * np.ones_like(wd_array) + D = 126.0 # Rotor diameter for the NREL 5 MW + fmodel.set( + layout_x=[0.0, 5 * D, 10 * D], + layout_y=[0.0, 0.0, 0.0], + wind_directions=wd_array, + wind_speeds=ws_array, + turbulence_intensities=ti_array, + ) + + layout_opt = LayoutOptimizationScipy(fmodel, boundaries, optOptions=opt_options) + sol = layout_opt.optimize() + locations_opt = np.array([sol[0], sol[1]]) + + if DEBUG: + print(baseline) + print(locations_opt) + + assert_results_arrays(locations_opt, baseline) + +def test_scipy_layout_opt_value(sample_inputs_fixture): + """ + This test compares the optimization results from the SciPy layout optimization for a simple + farm with a simple wind rose to stored baseline results, optimizing for annual value production + instead of AEP. The value of the energy produced depends on the wind direction, causing the + optimal layout to differ from the case where the objective is maximum AEP. In this case, because + the value is much higher when the wind is from the north or south, the turbines are staggered to + avoid wake interactions for northerly and southerly winds. + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + opt_options = { + "maxiter": 5, + "disp": True, + "iprint": 2, + "ftol": 1e-12, + "eps": 0.1, + } + + boundaries = [(0.0, 0.0), (0.0, 400.0), (400.0, 400.0), (400.0, 0.0), (0.0, 0.0)] + + fmodel = FlorisModel(sample_inputs_fixture.core) + + # set wind conditions and values using a WindData object with the default uniform frequency + wd_array = np.arange(0, 360.0, 5.0) + ws_array = np.array([8.0]) + + # Define the value table such that the value of the energy produced is + # significantly higher when the wind direction is close to the north or + # south, and zero when the wind is from the east or west. + value_table = (0.5 + 0.5*np.cos(2*np.radians(wd_array)))**10 + value_table = value_table.reshape((len(wd_array),1)) + + wind_rose = WindRose( + wind_directions=wd_array, + wind_speeds=ws_array, + ti_table=0.1, + value_table=value_table + ) + + # Start with a rectangular 4-turbine array with 2D spacing + D = 126.0 # Rotor diameter for the NREL 5 MW + fmodel.set( + layout_x=200 + np.array([-1 * D, -1 * D, 1 * D, 1 * D]), + layout_y=200 + np.array([-1* D, 1 * D, -1 * D, 1 * D]), + wind_data=wind_rose, + ) + + layout_opt = LayoutOptimizationScipy( + fmodel, + boundaries, + optOptions=opt_options, + use_value=True + ) + sol = layout_opt.optimize() + locations_opt = np.array([sol[0], sol[1]]) + + if DEBUG: + print(baseline) + print(locations_opt) + + assert_results_arrays(locations_opt, baseline_value) diff --git a/tests/reg_tests/turbopark_regression_test.py b/tests/reg_tests/turbopark_regression_test.py index acecaa6bc..397a8586c 100644 --- a/tests/reg_tests/turbopark_regression_test.py +++ b/tests/reg_tests/turbopark_regression_test.py @@ -1,32 +1,18 @@ -# Copyright 2022 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation import numpy as np -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Ct, - Floris, + Core, power, rotor_effective_velocity, + thrust_coefficient, ) from tests.conftest import ( assert_results_arrays, + N_FINDEX, N_TURBINES, - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, print_test_values, ) @@ -40,27 +26,27 @@ [ # 8 m/s [ - [7.9736330, 0.7636044, 1691326.6483808, 0.2568973], - [6.0583922, 0.8327316, 731065.6226282, 0.2955077], - [5.4067009, 0.8668116, 506659.6232808, 0.3175251], + [7.9736858, 0.7871515, 1753954.4591792, 0.2693224], + [6.0332948, 0.8593353, 752557.9240063, 0.3124735], + [5.4029800, 0.8947888, 538370.5108659, 0.3378186], ], # 9 m/s [ - [8.9703371, 0.7625570, 2407841.6718785, 0.2563594], - [6.8171892, 0.7996138, 1057631.1392858, 0.2761774], - [6.0917181, 0.8311955, 744568.6379292, 0.2945709], + [8.9703965, 0.7858774, 2496427.8618358, 0.2686331], + [6.7887441, 0.8249788, 1092199.1775234, 0.2908223], + [6.0678594, 0.8577634, 768097.7785191, 0.3114286], ], # 10 m/s [ - [9.9670412, 0.7529384, 3298067.1555604, 0.2514735], - [7.5908545, 0.7734991, 1461944.4626519, 0.2620395], - [6.7995666, 0.8003229, 1049428.7626183, 0.2765738], + [9.9671073, 0.7838789, 3417797.0050916, 0.2675559], + [7.5453629, 0.7962514, 1487438.4031455, 0.2743074], + [6.7548552, 0.8265200, 1076963.1412833, 0.2917453], ], # 11 m/s [ - [10.9637454, 0.7306256, 4363191.9880631, 0.2404936], - [8.3975139, 0.7618399, 1977602.3128807, 0.2559918], - [7.5196816, 0.7753389, 1419293.7479312, 0.2630079], + [10.9638180, 0.7565157, 4519404.3072862, 0.2532794], + [8.3436376, 0.7866851, 2027996.3027579, 0.2690699], + [7.4626804, 0.7989174, 1439263.3915910, 0.2757889], ], ] ) @@ -70,27 +56,27 @@ [ # 8 m/s [ - [7.9736330, 0.7606986, 1679924.0721706, 0.2549029], - [6.0772917, 0.8318604, 738723.3410291, 0.2949759], - [5.4215054, 0.8658908, 510991.8557577, 0.3168954], + [7.9736858, 0.7841561, 1741508.6722008, 0.2671213], + [6.0523119, 0.8584704, 761107.7639542, 0.3118979], + [5.4177841, 0.8939472, 543310.4550423, 0.3371713], ], # 9 m/s [ - [8.9703371, 0.7596552, 2391434.0080674, 0.2543734], - [6.8384389, 0.7987587, 1067521.7514783, 0.2757004], - [6.1089600, 0.8304008, 751554.7217137, 0.2940879], + [8.9703965, 0.7828869, 2480428.8963141, 0.2664440], + [6.8101438, 0.8240055, 1101820.2623232, 0.2902415], + [6.0851644, 0.8569764, 775877.8906008, 0.3109077], ], # 10 m/s [ - [9.9670412, 0.7500732, 3275671.6727516, 0.2495630], - [7.6142906, 0.7728933, 1475988.7044752, 0.2617214], - [6.8186733, 0.7995541, 1058321.9413265, 0.2761440], + [9.9671073, 0.7808960, 3395681.0032992, 0.2653854], + [7.5691494, 0.7955016, 1501458.3309846, 0.2738925], + [6.7745474, 0.8256244, 1085816.5021615, 0.2912085], ], # 11 m/s [ - [10.9637454, 0.7278454, 4333842.6695283, 0.2387424], - [8.4226213, 0.7617715, 1994685.7970084, 0.2559567], - [7.5392355, 0.7748335, 1431011.5054545, 0.2627414], + [10.9638180, 0.7536370, 4488242.9153943, 0.2513413], + [8.3695194, 0.7866518, 2047340.0279521, 0.2690518], + [7.4830530, 0.7982426, 1450966.1620998, 0.2754129], ], ] ) @@ -104,76 +90,76 @@ def test_regression_tandem(sample_inputs_fixture): """ Tandem turbines """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -181,9 +167,10 @@ def test_regression_tandem(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4, ) - assert_results_arrays(test_results[0], baseline) + assert_results_arrays(test_results[0:4], baseline) def test_regression_rotation(sample_inputs_fixture): @@ -225,39 +212,40 @@ def test_regression_rotation(sample_inputs_fixture): """ TURBINE_DIAMETER = 126.0 - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL - sample_inputs_fixture.floris["farm"]["layout_x"] = [ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL + sample_inputs_fixture.core["farm"]["layout_x"] = [ 0.0, 0.0, 5 * TURBINE_DIAMETER, 5 * TURBINE_DIAMETER, ] - sample_inputs_fixture.floris["farm"]["layout_y"] = [ + sample_inputs_fixture.core["farm"]["layout_y"] = [ 0.0, 5 * TURBINE_DIAMETER, 0.0, 5 * TURBINE_DIAMETER ] - sample_inputs_fixture.floris["flow_field"]["wind_directions"] = [270.0, 360.0] - sample_inputs_fixture.floris["flow_field"]["wind_speeds"] = [8.0] + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0, 360.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0, 8.0] + sample_inputs_fixture.core["flow_field"]["turbulence_intensities"] = [0.1, 0.1] - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() farm_avg_velocities = average_velocity(floris.flow_field.u) - t0_270 = farm_avg_velocities[0, 0, 0] # upstream - t1_270 = farm_avg_velocities[0, 0, 1] # upstream - t2_270 = farm_avg_velocities[0, 0, 2] # waked - t3_270 = farm_avg_velocities[0, 0, 3] # waked + t0_270 = farm_avg_velocities[0, 0] # upstream + t1_270 = farm_avg_velocities[0, 1] # upstream + t2_270 = farm_avg_velocities[0, 2] # waked + t3_270 = farm_avg_velocities[0, 3] # waked - t0_360 = farm_avg_velocities[1, 0, 0] # waked - t1_360 = farm_avg_velocities[1, 0, 1] # upstream - t2_360 = farm_avg_velocities[1, 0, 2] # waked - t3_360 = farm_avg_velocities[1, 0, 3] # upstream + t0_360 = farm_avg_velocities[1, 0] # waked + t1_360 = farm_avg_velocities[1, 1] # upstream + t2_360 = farm_avg_velocities[1, 2] # waked + t3_360 = farm_avg_velocities[1, 3] # upstream assert np.allclose(t0_270, t1_360) assert np.allclose(t1_270, t3_360) @@ -269,80 +257,80 @@ def test_regression_yaw(sample_inputs_fixture): """ Tandem turbines with the upstream turbine yawed """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) - yaw_angles = np.zeros((N_WIND_DIRECTIONS, N_WIND_SPEEDS, N_TURBINES)) - yaw_angles[:,:,0] = 5.0 + yaw_angles = np.zeros((N_FINDEX, N_TURBINES)) + yaw_angles[:,0] = 5.0 floris.farm.yaw_angles = yaw_angles floris.initialize_domain() floris.steady_state_atmospheric_condition() n_turbines = floris.farm.n_turbines - n_wind_speeds = floris.flow_field.n_wind_speeds - n_wind_directions = floris.flow_field.n_wind_directions + n_findex = floris.flow_field.n_findex velocities = floris.flow_field.u + air_density = floris.flow_field.air_density yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = ( - np.ones((n_wind_directions, n_wind_speeds, n_turbines)) - * floris.farm.ref_tilt_cp_cts - ) - test_results = np.zeros((n_wind_directions, n_wind_speeds, n_turbines, 4)) + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes + test_results = np.zeros((n_findex, n_turbines, 4)) farm_avg_velocities = average_velocity( velocities, ) - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_cts = thrust_coefficient( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_thrust_coefficient_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - farm_cts = Ct( + farm_powers = power( velocities, + air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) farm_axial_inductions = axial_induction( velocities, + air_density, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.turbine_fCts, + power_setpoints, + awc_modes, + awc_amplitudes, + floris.farm.turbine_axial_induction_functions, floris.farm.turbine_tilt_interps, floris.farm.correct_cp_ct_for_tilt, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) - for i in range(n_wind_directions): - for j in range(n_wind_speeds): - for k in range(n_turbines): - test_results[i, j, k, 0] = farm_avg_velocities[i, j, k] - test_results[i, j, k, 1] = farm_cts[i, j, k] - test_results[i, j, k, 2] = farm_powers[i, j, k] - test_results[i, j, k, 3] = farm_axial_inductions[i, j, k] + for i in range(n_findex): + for j in range(n_turbines): + test_results[i, j, 0] = farm_avg_velocities[i, j] + test_results[i, j, 1] = farm_cts[i, j] + test_results[i, j, 2] = farm_powers[i, j] + test_results[i, j, 3] = farm_axial_inductions[i, j] if DEBUG: print_test_values( @@ -350,10 +338,10 @@ def test_regression_yaw(sample_inputs_fixture): farm_cts, farm_powers, farm_axial_inductions, + max_findex_print=4, ) - assert_results_arrays(test_results[0], yawed_baseline) - + assert_results_arrays(test_results[0:4], yawed_baseline) def test_regression_small_grid_rotation(sample_inputs_fixture): """ @@ -371,9 +359,9 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): turbine to be affected by its own wake. This test requires that at least in this particular configuration the masking correctly filters grid points. """ - sample_inputs_fixture.floris["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL - sample_inputs_fixture.floris["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["combination_model"] = COMBINATION_MODEL X, Y = np.meshgrid( 6.0 * 126.0 * np.arange(0, 5, 1), 6.0 * 126.0 * np.arange(0, 5, 1) @@ -381,10 +369,10 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): X = X.flatten() Y = Y.flatten() - sample_inputs_fixture.floris["farm"]["layout_x"] = X - sample_inputs_fixture.floris["farm"]["layout_y"] = Y + sample_inputs_fixture.core["farm"]["layout_x"] = X + sample_inputs_fixture.core["farm"]["layout_y"] = Y - floris = Floris.from_dict(sample_inputs_fixture.floris) + floris = Core.from_dict(sample_inputs_fixture.core) floris.initialize_domain() floris.steady_state_atmospheric_condition() @@ -392,34 +380,61 @@ def test_regression_small_grid_rotation(sample_inputs_fixture): velocities = floris.flow_field.u yaw_angles = floris.farm.yaw_angles tilt_angles = floris.farm.tilt_angles - ref_tilt_cp_cts = np.ones((1, 1, len(X))) * floris.farm.ref_tilt_cp_cts + power_setpoints = floris.farm.power_setpoints + awc_modes = floris.farm.awc_modes + awc_amplitudes = floris.farm.awc_amplitudes - farm_eff_velocities = rotor_effective_velocity( - floris.flow_field.air_density, - floris.farm.ref_density_cp_cts, + farm_powers = power( velocities, + floris.flow_field.air_density, + floris.farm.turbine_power_functions, yaw_angles, tilt_angles, - ref_tilt_cp_cts, - floris.farm.pPs, - floris.farm.pTs, + power_setpoints, + awc_modes, + awc_amplitudes, floris.farm.turbine_tilt_interps, - floris.farm.correct_cp_ct_for_tilt, - floris.farm.turbine_type_map, - ) - farm_powers = power( - floris.farm.ref_density_cp_cts, - farm_eff_velocities, - floris.farm.turbine_power_interps, floris.farm.turbine_type_map, + floris.farm.turbine_power_thrust_tables, ) # A "column" is oriented parallel to the wind direction # Columns 1 - 4 should have the same power profile # Column 5 leading turbine is completely unwaked # and the rest of the turbines have a partial wake from their immediate upstream turbine - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,5:10]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,10:15]) - assert np.allclose(farm_powers[2,0,0:5], farm_powers[2,0,15:20]) - assert np.allclose(farm_powers[2,0,20], farm_powers[2,0,0]) - assert np.allclose(farm_powers[2,0,21], farm_powers[2,0,21:25]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,5:10]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,10:15]) + assert np.allclose(farm_powers[8,0:5], farm_powers[8,15:20]) + assert np.allclose(farm_powers[8,20], farm_powers[8,0]) + assert np.allclose(farm_powers[8,21], farm_powers[8,21:25]) + +''' +## Not implemented in TurbOPark +def test_full_flow_solver(sample_inputs_fixture): + """ + Full flow solver test with the flow field planar grid. + This requires one wind condition, and the grid is deliberately coarse to allow for + visually comparing results, as needed. + The u-component of velocity is compared, and the array has the shape + (n_findex, n_turbines, n grid points in x, n grid points in y, 3 grid points in z). + """ + + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + sample_inputs_fixture.core["solver"] = { + "type": "flow_field_planar_grid", + "normal_vector": "z", + "planar_coordinate": sample_inputs_fixture.core["farm"]["turbine_type"][0]["hub_height"], + "flow_field_grid_points": [5, 5], + "flow_field_bounds": [None, None], + } + sample_inputs_fixture.core["flow_field"]["wind_directions"] = [270.0] + sample_inputs_fixture.core["flow_field"]["wind_speeds"] = [8.0] + + floris = Core.from_dict(sample_inputs_fixture.core) + floris.solve_for_viz() + + velocities = floris.flow_field.u_sorted + print(velocities) + assert_results_arrays(velocities, full_flow_baseline) +''' diff --git a/tests/reg_tests/yaw_optimization_regression_test.py b/tests/reg_tests/yaw_optimization_regression_test.py new file mode 100644 index 000000000..203856646 --- /dev/null +++ b/tests/reg_tests/yaw_optimization_regression_test.py @@ -0,0 +1,186 @@ + +import numpy as np +import pandas as pd + +from floris import FlorisModel +from floris.optimization.yaw_optimization.yaw_optimizer_geometric import ( + YawOptimizationGeometric, +) +from floris.optimization.yaw_optimization.yaw_optimizer_scipy import YawOptimizationScipy +from floris.optimization.yaw_optimization.yaw_optimizer_sr import YawOptimizationSR + + +DEBUG = False +VELOCITY_MODEL = "gauss" +DEFLECTION_MODEL = "gauss" + +# These inputs and baseline power are common for all optimization methods +WIND_DIRECTIONS = [0.0, 90.0, 180.0, 270.0] +WIND_SPEEDS = [8.0] * 4 +TURBULENCE_INTENSITIES = [0.1] * 4 +FARM_POWER_BASELINE = [5.261863e+06, 3.206038e+06, 5.261863e+06, 3.206038e+06] + +# These are the input data structures for each optimization method along with the output +# optimized yaw angles +baseline_serial_refine = pd.DataFrame( + { + "wind_direction": WIND_DIRECTIONS, + "wind_speed": WIND_SPEEDS, + "turbulence_intensity": TURBULENCE_INTENSITIES, + "yaw_angles_opt": [ + [0.0, 0.0, 0.0], + [0.0, 25.0, 15.625], + [0.0, 0.0, 0.0], + [15.625, 25.0, 0.0], + ], + "farm_power_opt": [5.261863e+06, 3.262218e+06, 5.261863e+06, 3.262218e+06], + "farm_power_baseline": FARM_POWER_BASELINE, + } +) + +baseline_geometric_yaw = pd.DataFrame( + { + "wind_direction": WIND_DIRECTIONS, + "wind_speed": WIND_SPEEDS, + "turbulence_intensity": TURBULENCE_INTENSITIES, + "yaw_angles_opt": [ + [0.0, 0.0, 0.0], + [0.0, 19.9952335557674, 19.9952335557674], + [0.0, 0.0, 0.0], + [19.9952335557674, 19.9952335557674, 0.0], + ], + "farm_power_opt": [5.261863e+06, 3.252509e+06, 5.261863e+06, 3.252509e+06], + "farm_power_baseline": FARM_POWER_BASELINE, + } +) + +baseline_scipy = pd.DataFrame( + { + "wind_direction": WIND_DIRECTIONS, + "wind_speed": WIND_SPEEDS, + "turbulence_intensity": TURBULENCE_INTENSITIES, + "yaw_angles_opt": [ + [0.0, 0.0, 0.0], + [0.0, 24.999999999999982, 12.165643400939755], + [0.0, 0.0, 0.0], + [12.165643399558299, 25.0, 0.0], + ], + "farm_power_opt": [5.261863e+06, 3.264975e+06, 5.261863e+06, 3.264975e+06], + "farm_power_baseline": FARM_POWER_BASELINE, + } +) + + +def test_serial_refine(sample_inputs_fixture): + """ + The Serial Refine (SR) method optimizes yaw angles based on a sequential, iterative yaw + optimization scheme. This test compares the optimization results from the SR method for + a simple farm with a simple wind rose to stored baseline results. + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + fmodel = FlorisModel(sample_inputs_fixture.core) + wd_array = np.arange(0.0, 360.0, 90.0) + ws_array = 8.0 * np.ones_like(wd_array) + ti_array = 0.1 * np.ones_like(wd_array) + + D = 126.0 # Rotor diameter for the NREL 5 MW + fmodel.set( + layout_x=[0.0, 5 * D, 10 * D], + layout_y=[0.0, 0.0, 0.0], + wind_directions=wd_array, + wind_speeds=ws_array, + turbulence_intensities=ti_array, + ) + + yaw_opt = YawOptimizationSR(fmodel) + df_opt = yaw_opt.optimize() + + if DEBUG: + print(baseline_serial_refine.to_string()) + print(df_opt.to_string()) + + pd.testing.assert_frame_equal(df_opt, baseline_serial_refine) + + +def test_geometric_yaw(sample_inputs_fixture): + """ + The Geometric Yaw optimization method optimizes yaw angles using geometric data and derived + optimal yaw relationships. This test compares the optimization results from the Geometric Yaw + optimization for a simple farm with a simple wind rose to stored baseline results. + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + fmodel = FlorisModel(sample_inputs_fixture.core) + wd_array = np.arange(0.0, 360.0, 90.0) + ws_array = 8.0 * np.ones_like(wd_array) + ti_array = 0.1 * np.ones_like(wd_array) + D = 126.0 # Rotor diameter for the NREL 5 MW + fmodel.set( + layout_x=[0.0, 5 * D, 10 * D], + layout_y=[0.0, 0.0, 0.0], + wind_directions=wd_array, + wind_speeds=ws_array, + turbulence_intensities=ti_array, + ) + fmodel.run() + baseline_farm_power = fmodel.get_farm_power().squeeze() + + yaw_opt = YawOptimizationGeometric(fmodel) + df_opt = yaw_opt.optimize() + + yaw_angles_opt_geo = np.vstack(yaw_opt.yaw_angles_opt) + fmodel.set(yaw_angles=yaw_angles_opt_geo) + fmodel.run() + geo_farm_power = fmodel.get_farm_power().squeeze() + + df_opt['farm_power_baseline'] = baseline_farm_power + df_opt['farm_power_opt'] = geo_farm_power + + if DEBUG: + print(baseline_geometric_yaw.to_string()) + print(df_opt.to_string()) + + pd.testing.assert_frame_equal(df_opt, baseline_geometric_yaw) + + +def test_scipy_yaw_opt(sample_inputs_fixture): + """ + The SciPy optimization method optimizes yaw angles using SciPy's minimize method. This test + compares the optimization results from the SciPy yaw optimization for a simple farm with a + simple wind rose to stored baseline results. + """ + sample_inputs_fixture.core["wake"]["model_strings"]["velocity_model"] = VELOCITY_MODEL + sample_inputs_fixture.core["wake"]["model_strings"]["deflection_model"] = DEFLECTION_MODEL + + opt_options = { + "maxiter": 5, + "disp": True, + "iprint": 2, + "ftol": 1e-12, + "eps": 0.5, + } + + fmodel = FlorisModel(sample_inputs_fixture.core) + wd_array = np.arange(0.0, 360.0, 90.0) + ws_array = 8.0 * np.ones_like(wd_array) + ti_array = 0.1 * np.ones_like(wd_array) + D = 126.0 # Rotor diameter for the NREL 5 MW + fmodel.set( + layout_x=[0.0, 5 * D, 10 * D], + layout_y=[0.0, 0.0, 0.0], + wind_directions=wd_array, + wind_speeds=ws_array, + turbulence_intensities=ti_array, + ) + + yaw_opt = YawOptimizationScipy(fmodel, opt_options=opt_options) + df_opt = yaw_opt.optimize() + + if DEBUG: + print(baseline_scipy.to_string()) + print(df_opt.to_string()) + + pd.testing.assert_frame_equal(df_opt, baseline_scipy) diff --git a/tests/rotor_velocity_unit_test.py b/tests/rotor_velocity_unit_test.py new file mode 100644 index 000000000..a83ed219e --- /dev/null +++ b/tests/rotor_velocity_unit_test.py @@ -0,0 +1,226 @@ +import numpy as np + +from floris.core import Turbine +from floris.core.rotor_velocity import ( + average_velocity, + compute_tilt_angles_for_floating_turbines, + compute_tilt_angles_for_floating_turbines_map, + cubic_cubature, + rotor_velocity_air_density_correction, + rotor_velocity_tilt_cosine_correction, + rotor_velocity_yaw_cosine_correction, + simple_cubature, +) +from tests.conftest import SampleInputs, WIND_SPEEDS + + +def test_rotor_velocity_air_density_correction(): + + wind_speed = 10. + ref_air_density = 1.225 + test_density = 1.2 + + test_speed = rotor_velocity_air_density_correction(wind_speed, ref_air_density, ref_air_density) + assert test_speed == wind_speed + + test_speed = rotor_velocity_air_density_correction(wind_speed, test_density, test_density) + assert test_speed == wind_speed + + test_speed = rotor_velocity_air_density_correction(0., test_density, ref_air_density) + assert test_speed == 0. + + test_speed = rotor_velocity_air_density_correction(wind_speed, test_density, ref_air_density) + assert np.allclose((test_speed/wind_speed)**3, test_density/ref_air_density) + + +def test_rotor_velocity_yaw_cosine_correction(): + N_TURBINES = 4 + + wind_speed = average_velocity(10.0 * np.ones((1, 1, 3, 3))) + wind_speed_N_TURBINES = average_velocity(10.0 * np.ones((1, N_TURBINES, 3, 3))) + + # Test a single turbine for zero yaw + yaw_corrected_velocities = rotor_velocity_yaw_cosine_correction( + cosine_loss_exponent_yaw=3.0, + yaw_angles=0.0, + rotor_effective_velocities=wind_speed, + ) + np.testing.assert_allclose(yaw_corrected_velocities, wind_speed) + + # Test a single turbine for non-zero yaw + yaw_corrected_velocities = rotor_velocity_yaw_cosine_correction( + cosine_loss_exponent_yaw=3.0, + yaw_angles=60.0, + rotor_effective_velocities=wind_speed, + ) + np.testing.assert_allclose(yaw_corrected_velocities, 0.5 * wind_speed) + + # Test multiple turbines for zero yaw + yaw_corrected_velocities = rotor_velocity_yaw_cosine_correction( + cosine_loss_exponent_yaw=3.0, + yaw_angles=np.zeros((1, N_TURBINES)), + rotor_effective_velocities=wind_speed_N_TURBINES, + ) + np.testing.assert_allclose(yaw_corrected_velocities, wind_speed_N_TURBINES) + + # Test multiple turbines for non-zero yaw + yaw_corrected_velocities = rotor_velocity_yaw_cosine_correction( + cosine_loss_exponent_yaw=3.0, + yaw_angles=np.ones((1, N_TURBINES)) * 60.0, + rotor_effective_velocities=wind_speed_N_TURBINES, + ) + np.testing.assert_allclose(yaw_corrected_velocities, 0.5 * wind_speed_N_TURBINES) + + +def test_rotor_velocity_tilt_cosine_correction(): + N_TURBINES = 4 + + wind_speed = average_velocity(10.0 * np.ones((1, 1, 3, 3))) + wind_speed_N_TURBINES = average_velocity(10.0 * np.ones((1, N_TURBINES, 3, 3))) + + turbine_data = SampleInputs().turbine + turbine_floating_data = SampleInputs().turbine_floating + turbine = Turbine.from_dict(turbine_data) + turbine_floating = Turbine.from_dict(turbine_floating_data) + turbine_type_map = np.array(N_TURBINES * [turbine.turbine_type]) + turbine_type_map = turbine_type_map[None, :] + + # Test single non-floating turbine + tilt_corrected_velocities = rotor_velocity_tilt_cosine_correction( + #turbine_type_map=np.array([turbine_type_map[:, 0]]), + tilt_angles=5.0*np.ones((1, 1)), + ref_tilt=np.array([turbine.power_thrust_table["ref_tilt"]]), + cosine_loss_exponent_tilt=np.array( + [turbine.power_thrust_table["cosine_loss_exponent_tilt"]] + ), + tilt_interp=turbine.tilt_interp, + correct_cp_ct_for_tilt=np.array([[False]]), + rotor_effective_velocities=wind_speed, + ) + + np.testing.assert_allclose(tilt_corrected_velocities, wind_speed) + + # Test multiple non-floating turbines + tilt_corrected_velocities = rotor_velocity_tilt_cosine_correction( + #turbine_type_map=turbine_type_map, + tilt_angles=5.0*np.ones((1, N_TURBINES)), + ref_tilt=np.array([turbine.power_thrust_table["ref_tilt"]] * N_TURBINES), + cosine_loss_exponent_tilt=np.array( + [turbine.power_thrust_table["cosine_loss_exponent_tilt"]] * N_TURBINES + ), + tilt_interp=turbine.tilt_interp, + correct_cp_ct_for_tilt=np.array([[False] * N_TURBINES]), + rotor_effective_velocities=wind_speed_N_TURBINES, + ) + + np.testing.assert_allclose(tilt_corrected_velocities, wind_speed_N_TURBINES) + + # Test single floating turbine + tilt_corrected_velocities = rotor_velocity_tilt_cosine_correction( + #turbine_type_map=np.array([turbine_type_map[:, 0]]), + tilt_angles=5.0*np.ones((1, 1)), + ref_tilt=np.array([turbine_floating.power_thrust_table["ref_tilt"]]), + cosine_loss_exponent_tilt=np.array( + [turbine_floating.power_thrust_table["cosine_loss_exponent_tilt"]] + ), + tilt_interp=turbine_floating.tilt_interp, + correct_cp_ct_for_tilt=np.array([[True]]), + rotor_effective_velocities=wind_speed, + ) + + np.testing.assert_allclose(tilt_corrected_velocities, wind_speed) + + # Test multiple floating turbines + tilt_corrected_velocities = rotor_velocity_tilt_cosine_correction( + #turbine_type_map, + tilt_angles=5.0*np.ones((1, N_TURBINES)), + ref_tilt=np.array([turbine_floating.power_thrust_table["ref_tilt"]] * N_TURBINES), + cosine_loss_exponent_tilt=np.array( + [turbine_floating.power_thrust_table["cosine_loss_exponent_tilt"]] * N_TURBINES + ), + tilt_interp=turbine_floating.tilt_interp, + correct_cp_ct_for_tilt=np.array([[True] * N_TURBINES]), + rotor_effective_velocities=wind_speed_N_TURBINES, + ) + + np.testing.assert_allclose(tilt_corrected_velocities, wind_speed_N_TURBINES) + +def test_compute_tilt_angles_for_floating_turbines(): + N_TURBINES = 4 + + wind_speed = 25.0 + rotor_effective_velocities = average_velocity(wind_speed * np.ones((1, 1, 3, 3))) + rotor_effective_velocities_N_TURBINES = average_velocity( + wind_speed * np.ones((1, N_TURBINES, 3, 3)) + ) + + turbine_floating_data = SampleInputs().turbine_floating + turbine_floating = Turbine.from_dict(turbine_floating_data) + turbine_type_map = np.array(N_TURBINES * [turbine_floating.turbine_type]) + turbine_type_map = turbine_type_map[None, :] + + # Single turbine + tilt = compute_tilt_angles_for_floating_turbines( + #turbine_type_map=np.array([turbine_type_map[:, 0]]), + tilt_angles=5.0*np.ones((1, 1)), + tilt_interp=turbine_floating.tilt_interp, + rotor_effective_velocities=rotor_effective_velocities, + ) + + # calculate tilt again + truth_index = turbine_floating_data["floating_tilt_table"]["wind_speed"].index(wind_speed) + tilt_truth = turbine_floating_data["floating_tilt_table"]["tilt"][truth_index] + np.testing.assert_allclose(tilt, tilt_truth) + + # Multiple turbines + tilt_N_turbines = compute_tilt_angles_for_floating_turbines_map( + turbine_type_map=np.array(turbine_type_map), + tilt_angles=5.0*np.ones((1, N_TURBINES)), + tilt_interps={turbine_floating.turbine_type: turbine_floating.tilt_interp}, + rotor_effective_velocities=rotor_effective_velocities_N_TURBINES, + ) + + # calculate tilt again + truth_index = turbine_floating_data["floating_tilt_table"]["wind_speed"].index(wind_speed) + tilt_truth = turbine_floating_data["floating_tilt_table"]["tilt"][truth_index] + np.testing.assert_allclose(tilt_N_turbines, [[tilt_truth] * N_TURBINES]) + +def test_simple_cubature(): + + # Define a velocity array + velocities = np.ones((1, 1, 3, 3)) + + # Define sample cubature weights + cubature_weights = np.array([1., 1., 1.]) + + # Define the axis as last 2 dimensions + axis = (velocities.ndim-2, velocities.ndim-1) + + # Calculate expected output based on the given inputs + expected_output = 1.0 + + # Call the function with the given inputs + result = simple_cubature(velocities, cubature_weights, axis) + + # Check if the result matches the expected output + np.testing.assert_allclose(result, expected_output) + +def test_cubic_cubature(): + + # Define a velocity array + velocities = np.ones((1, 1, 3, 3)) + + # Define sample cubature weights + cubature_weights = np.array([1., 1., 1.]) + + # Define the axis as last 2 dimensions + axis = (velocities.ndim-2, velocities.ndim-1) + + # Calculate expected output based on the given inputs + expected_output = 1.0 + + # Call the function with the given inputs + result = cubic_cubature(velocities, cubature_weights, axis) + + # Check if the result matches the expected output + np.testing.assert_allclose(result, expected_output) diff --git a/tests/turbine_grid_unit_test.py b/tests/turbine_grid_unit_test.py index 08c7371bd..3d9b01961 100644 --- a/tests/turbine_grid_unit_test.py +++ b/tests/turbine_grid_unit_test.py @@ -1,25 +1,10 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import numpy as np -from floris.simulation import TurbineGrid +from floris.core import TurbineGrid from tests.conftest import ( + N_FINDEX, N_TURBINES, - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, TURBINE_GRID_RESOLUTION, ) @@ -51,29 +36,36 @@ def test_set_grid(turbine_grid_fixture): # then, search for any elements that are true and negate the results # if an element is zero, the not will return true # if an element is non-zero, the not will return false - np.testing.assert_array_equal(turbine_grid_fixture.x_sorted[0, 0], expected_x_grid) - np.testing.assert_array_equal(turbine_grid_fixture.y_sorted[0, 0], expected_y_grid) - np.testing.assert_array_equal(turbine_grid_fixture.z_sorted[0, 0], expected_z_grid) + np.testing.assert_array_equal(turbine_grid_fixture.x_sorted[0], expected_x_grid) + np.testing.assert_array_equal(turbine_grid_fixture.y_sorted[0], expected_y_grid) + np.testing.assert_array_equal(turbine_grid_fixture.z_sorted[0], expected_z_grid) + + # These should have the following shape: + # (n findex, n turbines, grid resolution, grid resolution) + expected_shape = (N_FINDEX,N_TURBINES,TURBINE_GRID_RESOLUTION,TURBINE_GRID_RESOLUTION) + assert np.shape(turbine_grid_fixture.x_sorted) == expected_shape + assert np.shape(turbine_grid_fixture.y_sorted) == expected_shape + assert np.shape(turbine_grid_fixture.z_sorted) == expected_shape + assert np.shape(turbine_grid_fixture.x_sorted_inertial_frame) == expected_shape + assert np.shape(turbine_grid_fixture.y_sorted_inertial_frame) == expected_shape + assert np.shape(turbine_grid_fixture.z_sorted_inertial_frame) == expected_shape def test_dimensions(turbine_grid_fixture): assert np.shape(turbine_grid_fixture.x_sorted) == ( - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, + N_FINDEX, N_TURBINES, TURBINE_GRID_RESOLUTION, TURBINE_GRID_RESOLUTION ) assert np.shape(turbine_grid_fixture.y_sorted) == ( - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, + N_FINDEX, N_TURBINES, TURBINE_GRID_RESOLUTION, TURBINE_GRID_RESOLUTION ) assert np.shape(turbine_grid_fixture.z_sorted) == ( - N_WIND_DIRECTIONS, - N_WIND_SPEEDS, + N_FINDEX, N_TURBINES, TURBINE_GRID_RESOLUTION, TURBINE_GRID_RESOLUTION @@ -82,8 +74,7 @@ def test_dimensions(turbine_grid_fixture): def test_dynamic_properties(turbine_grid_fixture): assert turbine_grid_fixture.n_turbines == N_TURBINES - assert turbine_grid_fixture.n_wind_speeds == N_WIND_SPEEDS - assert turbine_grid_fixture.n_wind_directions == N_WIND_DIRECTIONS + assert turbine_grid_fixture.n_findex == N_FINDEX turbine_grid_fixture.turbine_coordinates = np.append( turbine_grid_fixture.turbine_coordinates, @@ -92,8 +83,5 @@ def test_dynamic_properties(turbine_grid_fixture): ) assert turbine_grid_fixture.n_turbines == N_TURBINES + 1 - turbine_grid_fixture.wind_speeds = [*turbine_grid_fixture.wind_speeds, 0.0] - assert turbine_grid_fixture.n_wind_speeds == N_WIND_SPEEDS + 1 - turbine_grid_fixture.wind_directions = [*turbine_grid_fixture.wind_directions, 0.0] - assert turbine_grid_fixture.n_wind_directions == N_WIND_DIRECTIONS + 1 + assert turbine_grid_fixture.n_findex == N_FINDEX + 1 diff --git a/tests/turbine_multi_dim_unit_test.py b/tests/turbine_multi_dim_unit_test.py index 05c91ebc3..8a429a74c 100644 --- a/tests/turbine_multi_dim_unit_test.py +++ b/tests/turbine_multi_dim_unit_test.py @@ -1,17 +1,3 @@ -# Copyright 2023 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - from pathlib import Path @@ -19,99 +5,66 @@ import pandas as pd import pytest -from floris.simulation import ( +from floris.core import ( Turbine, - TurbineMultiDimensional, ) -from floris.simulation.turbine_multi_dim import ( - axial_induction_multidim, - Ct_multidim, - multidim_Ct_down_select, - multidim_power_down_select, - MultiDimensionalPowerThrustTable, - power_multidim, +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT +from floris.core.turbine.turbine import ( + axial_induction, + power, + thrust_coefficient, ) from tests.conftest import SampleInputs, WIND_SPEEDS -TEST_DATA = Path(__file__).resolve().parent.parent / "floris" / "turbine_library" -CSV_INPUT = TEST_DATA / "iea_15MW_multi_dim_Tp_Hs.csv" +# size 16 x 1 x 1 x 1 +# 16 wind speed and wind direction combinations from conftest +WIND_CONDITION_BROADCAST = np.reshape(np.array(WIND_SPEEDS), (-1, 1, 1, 1)) - -# size 3 x 4 x 1 x 1 x 1 -WIND_CONDITION_BROADCAST = np.stack( - ( - np.reshape(np.array(WIND_SPEEDS), (-1, 1, 1, 1)), # Wind direction 0 - np.reshape(np.array(WIND_SPEEDS), (-1, 1, 1, 1)), # Wind direction 1 - np.reshape(np.array(WIND_SPEEDS), (-1, 1, 1, 1)), # Wind direction 2 - ), - axis=0, -) INDEX_FILTER = [0, 2] - -def test_multidim_Ct_down_select(): - CONDITIONS = {'Tp': 2, 'Hs': 1} - - turbine_data = SampleInputs().turbine_multi_dim - turbine_data["power_thrust_data_file"] = CSV_INPUT - turbine = TurbineMultiDimensional.from_dict(turbine_data) - turbine_type_map = np.array([turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] - - downselect_turbine_fCts = multidim_Ct_down_select([[[turbine.fCt_interp]]], CONDITIONS) - - assert downselect_turbine_fCts == turbine.fCt_interp[(2, 1)] - - -def test_multidim_power_down_select(): - CONDITIONS = {'Tp': 2, 'Hs': 1} - - turbine_data = SampleInputs().turbine_multi_dim - turbine_data["power_thrust_data_file"] = CSV_INPUT - turbine = TurbineMultiDimensional.from_dict(turbine_data) - turbine_type_map = np.array([turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] - - downselect_power_interps = multidim_power_down_select([[[turbine.power_interp]]], CONDITIONS) - - assert downselect_power_interps == turbine.power_interp[(2, 1)] - - -def test_multi_dimensional_power_thrust_table(): - turbine_data = SampleInputs().turbine_multi_dim - turbine_data["power_thrust_data_file"] = CSV_INPUT - df_data = pd.read_csv(turbine_data["power_thrust_data_file"]) - flattened_dict = MultiDimensionalPowerThrustTable.from_dataframe(df_data) - flattened_dict_base = { - ('Tp', '2', 'Hs', '1'): [], - ('Tp', '2', 'Hs', '5'): [], - ('Tp', '4', 'Hs', '1'): [], - ('Tp', '4', 'Hs', '5'): [], - } - assert flattened_dict == flattened_dict_base - - # Test for initialization errors - for el in ("ws", "Cp", "Ct"): - df_data = pd.read_csv(turbine_data["power_thrust_data_file"]) - df = df_data.drop(el, axis=1) - with pytest.raises(ValueError): - MultiDimensionalPowerThrustTable.from_dataframe(df) +# NOTE: MultiDimensionalPowerThrustTable not used anywhere, so I'm commenting +# this out. + +# def test_multi_dimensional_power_thrust_table(): +# turbine_data = SampleInputs().turbine_multi_dim +# turbine_data["power_thrust_data_file"] = CSV_INPUT +# df_data = pd.read_csv(turbine_data["power_thrust_data_file"]) +# flattened_dict = MultiDimensionalPowerThrustTable.from_dataframe(df_data) +# flattened_dict_base = { +# ('Tp', '2', 'Hs', '1'): [], +# ('Tp', '2', 'Hs', '5'): [], +# ('Tp', '4', 'Hs', '1'): [], +# ('Tp', '4', 'Hs', '5'): [], +# } +# assert flattened_dict == flattened_dict_base + +# # Test for initialization errors +# for el in ("ws", "Cp", "Ct"): +# df_data = pd.read_csv(turbine_data["power_thrust_data_file"]) +# df = df_data.drop(el, axis=1) +# with pytest.raises(ValueError): +# MultiDimensionalPowerThrustTable.from_dataframe(df) def test_turbine_init(): turbine_data = SampleInputs().turbine_multi_dim - turbine_data["power_thrust_data_file"] = CSV_INPUT - turbine = TurbineMultiDimensional.from_dict(turbine_data) + turbine = Turbine.from_dict(turbine_data) + condition = (2, 1) assert turbine.rotor_diameter == turbine_data["rotor_diameter"] assert turbine.hub_height == turbine_data["hub_height"] - assert turbine.pP == turbine_data["pP"] - assert turbine.pT == turbine_data["pT"] - assert turbine.generator_efficiency == turbine_data["generator_efficiency"] + assert ( + turbine.power_thrust_table[condition]["cosine_loss_exponent_yaw"] + == turbine_data["power_thrust_table"]["cosine_loss_exponent_yaw"] + ) + assert ( + turbine.power_thrust_table[condition]["cosine_loss_exponent_tilt"] + == turbine_data["power_thrust_table"]["cosine_loss_exponent_tilt"] + ) - assert isinstance(turbine.power_thrust_data, dict) - assert isinstance(turbine.fCt_interp, dict) - assert isinstance(turbine.power_interp, dict) + assert isinstance(turbine.power_thrust_table, dict) + assert callable(turbine.thrust_coefficient_function) + assert callable(turbine.power_function) assert turbine.rotor_radius == turbine_data["rotor_diameter"] / 2.0 @@ -119,135 +72,134 @@ def test_ct(): N_TURBINES = 4 turbine_data = SampleInputs().turbine_multi_dim - turbine_data["power_thrust_data_file"] = CSV_INPUT - turbine = TurbineMultiDimensional.from_dict(turbine_data) + turbine = Turbine.from_dict(turbine_data) turbine_type_map = np.array(N_TURBINES * [turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] + turbine_type_map = turbine_type_map[None, :] + condition = (2, 1) # Single turbine # yaw angle / fCt are (n wind direction, n wind speed, n turbine) wind_speed = 10.0 - thrust = Ct_multidim( - velocities=wind_speed * np.ones((1, 1, 1, 3, 3)), - yaw_angle=np.zeros((1, 1, 1)), - tilt_angle=np.ones((1, 1, 1)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, 1)) * 5.0, - fCt=np.array([[[turbine.fCt_interp[(2, 1)]]]]), - tilt_interp={turbine.turbine_type: None}, - correct_cp_ct_for_tilt=np.array([[[False]]]), - turbine_type_map=turbine_type_map[:,:,0] + thrust = thrust_coefficient( + velocities=wind_speed * np.ones((1, 1, 3, 3)), + air_density=None, + yaw_angles=np.zeros((1, 1)), + tilt_angles=np.ones((1, 1)) * 5.0, + power_setpoints=np.ones((1, 1)) * POWER_SETPOINT_DEFAULT,\ + awc_modes=np.array([["baseline"]*N_TURBINES]*1), + awc_amplitudes=np.zeros((1, 1)), + thrust_coefficient_functions={turbine.turbine_type: turbine.thrust_coefficient_function}, + tilt_interps={turbine.turbine_type: None}, + correct_cp_ct_for_tilt=np.array([[False]]), + turbine_type_map=turbine_type_map[:,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, + multidim_condition=condition ) - np.testing.assert_allclose(thrust, np.array([[[0.77853469]]])) + np.testing.assert_allclose(thrust, np.array([[0.77815736]])) # Multiple turbines with index filter # 4 turbines with 3 x 3 grid arrays - thrusts = Ct_multidim( - velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 3 x 4 x 4 x 3 x 3 - yaw_angle=np.zeros((1, 1, N_TURBINES)), - tilt_angle=np.ones((1, 1, N_TURBINES)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, N_TURBINES)) * 5.0, - fCt=np.tile( - [turbine.fCt_interp[(2, 1)]], - ( - np.shape(WIND_CONDITION_BROADCAST)[0], - np.shape(WIND_CONDITION_BROADCAST)[1], - N_TURBINES, - ) - ), - tilt_interp={turbine.turbine_type: None}, - correct_cp_ct_for_tilt=np.array([[[False] * N_TURBINES]]), + thrusts = thrust_coefficient( + velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 16 x 4 x 3 x 3 + air_density=None, + yaw_angles=np.zeros((1, N_TURBINES)), + tilt_angles=np.ones((1, N_TURBINES)) * 5.0, + power_setpoints=np.ones((1, N_TURBINES)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array([["baseline"]*N_TURBINES]*1), + awc_amplitudes=np.zeros((1, N_TURBINES)), + thrust_coefficient_functions={turbine.turbine_type: turbine.thrust_coefficient_function}, + tilt_interps={turbine.turbine_type: None}, + correct_cp_ct_for_tilt=np.array([[False] * N_TURBINES]), turbine_type_map=turbine_type_map, ix_filter=INDEX_FILTER, + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, + multidim_condition=condition ) - assert len(thrusts[0, 0]) == len(INDEX_FILTER) - - thrusts_truth = [ - [ - [0.77853469, 0.77853469], - [0.77853469, 0.77853469], - [0.77853469, 0.77853469], - [0.6957943, 0.6957943 ], - ], - [ - [0.77853469, 0.77853469], - [0.77853469, 0.77853469], - [0.77853469, 0.77853469], - [0.6957943, 0.6957943 ], - ], - [ - [0.77853469, 0.77853469], - [0.77853469, 0.77853469], - [0.77853469, 0.77853469], - [0.6957943, 0.6957943 ], - ], - ] - + assert len(thrusts[0]) == len(INDEX_FILTER) + + thrusts_truth = np.array([ + [0.77815736, 0.77815736], + [0.77815736, 0.77815736], + [0.77815736, 0.77815736], + [0.66626835, 0.66626835 ], + + [0.77815736, 0.77815736], + [0.77815736, 0.77815736], + [0.77815736, 0.77815736], + [0.66626835, 0.66626835 ], + + [0.77815736, 0.77815736], + [0.77815736, 0.77815736], + [0.77815736, 0.77815736], + [0.66626835, 0.66626835 ], + + [0.77815736, 0.77815736], + [0.77815736, 0.77815736], + [0.77815736, 0.77815736], + [0.66626835, 0.66626835 ], + ]) np.testing.assert_allclose(thrusts, thrusts_truth) - def test_power(): N_TURBINES = 4 AIR_DENSITY = 1.225 turbine_data = SampleInputs().turbine_multi_dim - turbine_data["power_thrust_data_file"] = CSV_INPUT - turbine = TurbineMultiDimensional.from_dict(turbine_data) + turbine = Turbine.from_dict(turbine_data) turbine_type_map = np.array(N_TURBINES * [turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] + turbine_type_map = turbine_type_map[None, :] + condition = (2, 1) # Single turbine wind_speed = 10.0 - p = power_multidim( - ref_density_cp_ct=AIR_DENSITY, - rotor_effective_velocities=wind_speed * np.ones((1, 1, 1, 3, 3)), - power_interp=np.array([[[turbine.power_interp[(2, 1)]]]]), + p = power( + velocities=wind_speed * np.ones((1, 1, 3, 3)), + air_density=AIR_DENSITY, + power_functions={turbine.turbine_type: turbine.power_function}, + yaw_angles=np.zeros((1, 1)), # 1 findex, 1 turbine + tilt_angles=turbine.power_thrust_table[condition]["ref_tilt"] * np.ones((1, 1)), + power_setpoints=np.ones((1, 1)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array([["baseline"]*N_TURBINES]*1), + awc_amplitudes=np.zeros((1, 1)), + tilt_interps={turbine.turbine_type: turbine.tilt_interp}, + turbine_type_map=turbine_type_map[:,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, + multidim_condition=condition ) - power_truth = [ - [ - [ - [ - [3215682.686486, 3215682.686486, 3215682.686486], - [3215682.686486, 3215682.686486, 3215682.686486], - [3215682.686486, 3215682.686486, 3215682.686486], - ] - ] - ] - ] + power_truth = 12424759.67683091 - np.testing.assert_allclose(p, power_truth ) + np.testing.assert_allclose(p, power_truth) # Multiple turbines with ix filter - rotor_effective_velocities = np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST - p = power_multidim( - ref_density_cp_ct=AIR_DENSITY, - rotor_effective_velocities=rotor_effective_velocities, - power_interp=np.tile( - [turbine.power_interp[(2, 1)]], - ( - np.shape(WIND_CONDITION_BROADCAST)[0], - np.shape(WIND_CONDITION_BROADCAST)[1], - N_TURBINES, - ) - ), + velocities = np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST + p = power( + velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 16 x 4 x 3 x 3 + air_density=AIR_DENSITY, + power_functions={turbine.turbine_type: turbine.power_function}, + yaw_angles=np.zeros((1, N_TURBINES)), + tilt_angles=np.ones((1, N_TURBINES)) * 5.0, + power_setpoints=np.ones((1, N_TURBINES)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array([["baseline"]*N_TURBINES]*1), + awc_amplitudes=np.zeros((1, N_TURBINES)), + tilt_interps={turbine.turbine_type: turbine.tilt_interp}, + turbine_type_map=turbine_type_map, ix_filter=INDEX_FILTER, + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, + multidim_condition=condition ) - assert len(p[0, 0]) == len(INDEX_FILTER) - - unique_power = turbine.power_interp[(2, 1)]( - np.unique(rotor_effective_velocities) - ) * AIR_DENSITY - - power_truth = np.zeros_like(rotor_effective_velocities) - for i in range(3): - for j in range(4): - for k in range(4): - for m in range(3): - for n in range(3): - power_truth[i, j, k, m, n] = unique_power[j] - - np.testing.assert_allclose(p, power_truth[:, :, INDEX_FILTER[0]:INDEX_FILTER[1], :, :]) + assert len(p[0]) == len(INDEX_FILTER) + + power_truth = turbine.power_function( + power_thrust_table=turbine.power_thrust_table[condition], + velocities=velocities, + air_density=AIR_DENSITY, + yaw_angles=np.zeros((1, N_TURBINES)), + tilt_angles=np.ones((1, N_TURBINES)) * 5.0, + tilt_interp=turbine.tilt_interp, + ) + np.testing.assert_allclose(p, power_truth[:, INDEX_FILTER[0]:INDEX_FILTER[1]]) def test_axial_induction(): @@ -255,51 +207,54 @@ def test_axial_induction(): N_TURBINES = 4 turbine_data = SampleInputs().turbine_multi_dim - turbine_data["power_thrust_data_file"] = CSV_INPUT - turbine = TurbineMultiDimensional.from_dict(turbine_data) + turbine = Turbine.from_dict(turbine_data) turbine_type_map = np.array(N_TURBINES * [turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] + turbine_type_map = turbine_type_map[None, :] + condition = (2, 1) - baseline_ai = 0.2646995 + baseline_ai = np.array([[0.26447651]]) # Single turbine wind_speed = 10.0 - ai = axial_induction_multidim( - velocities=wind_speed * np.ones((1, 1, 1, 3, 3)), - yaw_angle=np.zeros((1, 1, 1)), - tilt_angle=np.ones((1, 1, 1)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, 1)) * 5.0, - fCt=np.array([[[turbine.fCt_interp[(2, 1)]]]]), - tilt_interp={turbine.turbine_type: None}, - correct_cp_ct_for_tilt=np.array([[[False]]]), - turbine_type_map=turbine_type_map[0,0,0], + ai = axial_induction( + velocities=wind_speed * np.ones((1, 1, 3, 3)), + air_density=None, + yaw_angles=np.zeros((1, 1)), + tilt_angles=np.ones((1, 1)) * 5.0, + power_setpoints = np.ones((1, 1)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array([["baseline"]*N_TURBINES]*1), + awc_amplitudes=np.zeros((1, 1)), + axial_induction_functions={turbine.turbine_type: turbine.axial_induction_function}, + tilt_interps={turbine.turbine_type: None}, + correct_cp_ct_for_tilt=np.array([[False]]), + turbine_type_map=turbine_type_map[0,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, + multidim_condition=condition ) np.testing.assert_allclose(ai, baseline_ai) # Multiple turbines with ix filter - ai = axial_induction_multidim( - velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 3 x 4 x 4 x 3 x 3 - yaw_angle=np.zeros((1, 1, N_TURBINES)), - tilt_angle=np.ones((1, 1, N_TURBINES)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, N_TURBINES)) * 5.0, - fCt=np.tile( - [turbine.fCt_interp[(2, 1)]], - ( - np.shape(WIND_CONDITION_BROADCAST)[0], - np.shape(WIND_CONDITION_BROADCAST)[1], - N_TURBINES, - ) - ), - tilt_interp={turbine.turbine_type: None}, - correct_cp_ct_for_tilt=np.array([[[False] * N_TURBINES]]), + ai = axial_induction( + velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 16 x 4 x 3 x 3 + air_density=None, + yaw_angles=np.zeros((1, N_TURBINES)), + tilt_angles=np.ones((1, N_TURBINES)) * 5.0, + power_setpoints=np.ones((1, N_TURBINES)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array([["baseline"]*N_TURBINES]*1), + awc_amplitudes=np.zeros((1, N_TURBINES)), + axial_induction_functions={turbine.turbine_type: turbine.axial_induction_function}, + tilt_interps={turbine.turbine_type: None}, + correct_cp_ct_for_tilt=np.array([[False] * N_TURBINES]), turbine_type_map=turbine_type_map, ix_filter=INDEX_FILTER, + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, + multidim_condition=condition ) - assert len(ai[0, 0]) == len(INDEX_FILTER) + assert len(ai[0]) == len(INDEX_FILTER) # Test the 10 m/s wind speed to use the same baseline as above - np.testing.assert_allclose(ai[0,2], baseline_ai) + np.testing.assert_allclose(ai[2][0], baseline_ai) def test_asdict(sample_inputs_fixture: SampleInputs): diff --git a/tests/turbine_operation_models_integration_test.py b/tests/turbine_operation_models_integration_test.py new file mode 100644 index 000000000..db4f0cc41 --- /dev/null +++ b/tests/turbine_operation_models_integration_test.py @@ -0,0 +1,564 @@ +import numpy as np +import pytest + +from floris.core.turbine.operation_models import ( + AWCTurbine, + CosineLossTurbine, + MixedOperationTurbine, + POWER_SETPOINT_DEFAULT, + SimpleDeratingTurbine, + SimpleTurbine, +) +from floris.utilities import cosd +from tests.conftest import SampleInputs, WIND_SPEEDS + + +def test_submodel_attributes(): + + assert hasattr(SimpleTurbine, "power") + assert hasattr(SimpleTurbine, "thrust_coefficient") + assert hasattr(SimpleTurbine, "axial_induction") + + assert hasattr(CosineLossTurbine, "power") + assert hasattr(CosineLossTurbine, "thrust_coefficient") + assert hasattr(CosineLossTurbine, "axial_induction") + + assert hasattr(SimpleDeratingTurbine, "power") + assert hasattr(SimpleDeratingTurbine, "thrust_coefficient") + assert hasattr(SimpleDeratingTurbine, "axial_induction") + + assert hasattr(MixedOperationTurbine, "power") + assert hasattr(MixedOperationTurbine, "thrust_coefficient") + assert hasattr(MixedOperationTurbine, "axial_induction") + + assert hasattr(AWCTurbine, "power") + assert hasattr(AWCTurbine, "thrust_coefficient") + assert hasattr(AWCTurbine, "axial_induction") + +def test_SimpleTurbine(): + + n_turbines = 1 + wind_speed = 10.0 + turbine_data = SampleInputs().turbine + + # Check that power works as expected + test_power = SimpleTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], # Matches ref_air_density + ) + truth_index = turbine_data["power_thrust_table"]["wind_speed"].index(wind_speed) + baseline_power = turbine_data["power_thrust_table"]["power"][truth_index] * 1000 + assert np.allclose(baseline_power, test_power) + + # Check that yaw and tilt angle have no effect + test_power = SimpleTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], # Matches ref_air_density + yaw_angles=20 * np.ones((1, n_turbines)), + tilt_angles=5 * np.ones((1, n_turbines)) + ) + assert np.allclose(baseline_power, test_power) + + # Check that a lower air density decreases power appropriately + test_power = SimpleTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, + ) + assert test_power < baseline_power + + + # Check that thrust coefficient works as expected + test_Ct = SimpleTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, # Unused + ) + baseline_Ct = turbine_data["power_thrust_table"]["thrust_coefficient"][truth_index] + assert np.allclose(baseline_Ct, test_Ct) + + # Check that yaw and tilt angle have no effect + test_Ct = SimpleTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, # Unused + yaw_angles=20 * np.ones((1, n_turbines)), + tilt_angles=5 * np.ones((1, n_turbines)) + ) + assert np.allclose(baseline_Ct, test_Ct) + + + # Check that axial induction works as expected + test_ai = SimpleTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, # Unused + ) + baseline_ai = ( + 1 - np.sqrt(1 - turbine_data["power_thrust_table"]["thrust_coefficient"][truth_index]) + )/2 + assert np.allclose(baseline_ai, test_ai) + + # Check that yaw and tilt angle have no effect + test_ai = SimpleTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, # Unused + yaw_angles=20 * np.ones((1, n_turbines)), + tilt_angles=5 * np.ones((1, n_turbines)) + ) + assert np.allclose(baseline_ai, test_ai) + +def test_CosineLossTurbine(): + + n_turbines = 1 + wind_speed = 10.0 + turbine_data = SampleInputs().turbine + + yaw_angles_nom = 0 * np.ones((1, n_turbines)) + tilt_angles_nom = turbine_data["power_thrust_table"]["ref_tilt"] * np.ones((1, n_turbines)) + yaw_angles_test = 20 * np.ones((1, n_turbines)) + tilt_angles_test = 0 * np.ones((1, n_turbines)) + + + # Check that power works as expected + test_power = CosineLossTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], # Matches ref_air_density + yaw_angles=yaw_angles_nom, + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + truth_index = turbine_data["power_thrust_table"]["wind_speed"].index(wind_speed) + baseline_power = turbine_data["power_thrust_table"]["power"][truth_index] * 1000 + assert np.allclose(baseline_power, test_power) + + # Check that yaw and tilt angle have an effect + test_power = CosineLossTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], # Matches ref_air_density + yaw_angles=yaw_angles_test, + tilt_angles=tilt_angles_test, + tilt_interp=None + ) + assert test_power < baseline_power + + # Check that a lower air density decreases power appropriately + test_power = CosineLossTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, + yaw_angles=yaw_angles_nom, + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + assert test_power < baseline_power + + + # Check that thrust coefficient works as expected + test_Ct = CosineLossTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, # Unused + yaw_angles=yaw_angles_nom, + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + baseline_Ct = turbine_data["power_thrust_table"]["thrust_coefficient"][truth_index] + assert np.allclose(baseline_Ct, test_Ct) + + # Check that yaw and tilt angle have the expected effect + test_Ct = CosineLossTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, # Unused + yaw_angles=yaw_angles_test, + tilt_angles=tilt_angles_test, + tilt_interp=None + ) + absolute_tilt = tilt_angles_test - turbine_data["power_thrust_table"]["ref_tilt"] + assert test_Ct == baseline_Ct * cosd(yaw_angles_test) * cosd(absolute_tilt) + + + # Check that thrust coefficient works as expected + test_ai = CosineLossTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, # Unused + yaw_angles=yaw_angles_nom, + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + baseline_misalignment_loss = ( + cosd(yaw_angles_nom) + * cosd(tilt_angles_nom - turbine_data["power_thrust_table"]["ref_tilt"]) + ) + baseline_ai = ( + 1 - np.sqrt(1 - turbine_data["power_thrust_table"]["thrust_coefficient"][truth_index]) + ) / 2 / baseline_misalignment_loss + assert np.allclose(baseline_ai, test_ai) + + # Check that yaw and tilt angle have the expected effect + test_ai = CosineLossTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=1.1, # Unused + yaw_angles=yaw_angles_test, + tilt_angles=tilt_angles_test, + tilt_interp=None + ) + absolute_tilt = tilt_angles_test - turbine_data["power_thrust_table"]["ref_tilt"] + assert test_Ct == baseline_Ct * cosd(yaw_angles_test) * cosd(absolute_tilt) + + +def test_SimpleDeratingTurbine(): + + n_turbines = 1 + wind_speed = 10.0 + turbine_data = SampleInputs().turbine + + + # Check that for no specified derating, matches SimpleTurbine + test_Ct = SimpleDeratingTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=None, + ) + base_Ct = SimpleTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + ) + assert np.allclose(test_Ct, base_Ct) + + test_power = SimpleDeratingTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=None, + ) + base_power = SimpleTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + ) + assert np.allclose(test_power, base_power) + + test_ai = SimpleDeratingTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=None, + ) + base_ai = SimpleTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + ) + assert np.allclose(test_ai, base_ai) + + # When power_setpoints are 0, turbine is shut down. + test_Ct = SimpleDeratingTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.zeros((1, n_turbines)), + ) + assert np.allclose(test_Ct, 0) + + test_power = SimpleDeratingTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.zeros((1, n_turbines)), + ) + assert np.allclose(test_power, 0) + + test_ai = SimpleDeratingTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.zeros((1, n_turbines)), + ) + assert np.allclose(test_ai, 0) + + # When power setpoints are less than available, results should be less than when no setpoint + wind_speed = 20 # High, so that turbine is above rated nominally + derated_power = 4.0e6 + rated_power = 5.0e6 + test_power = SimpleDeratingTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=derated_power * np.ones((1, n_turbines)), + ) + + rated_power = 5.0e6 + test_Ct = SimpleDeratingTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=derated_power * np.ones((1, n_turbines)), + ) + base_Ct = SimpleTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=derated_power * np.ones((1, n_turbines)), + ) + assert np.allclose(test_Ct, derated_power/rated_power * base_Ct) # Is this correct? + + # Mixed below and above rated + n_turbines = 2 + wind_speeds_test = np.ones((1, n_turbines, 3, 3)) + wind_speeds_test[0,0,:,:] = 20.0 # Above rated + wind_speeds_test[0,1,:,:] = 5.0 # Well below eated + test_power = SimpleDeratingTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speeds_test, # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=derated_power * np.ones((1, n_turbines)), + ) + base_power = SimpleTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speeds_test, # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=derated_power * np.ones((1, n_turbines)), + ) + + assert test_power[0,0] < base_power[0,0] + assert test_power[0,0] == derated_power + + assert test_power[0,1] == base_power[0,1] + assert test_power[0,1] < derated_power + +def test_MixedOperationTurbine(): + + n_turbines = 1 + wind_speed = 10.0 + turbine_data = SampleInputs().turbine + tilt_angles_nom = turbine_data["power_thrust_table"]["ref_tilt"] * np.ones((1, n_turbines)) + + # Check that for no specified derating or yaw angle, matches SimpleTurbine + test_Ct = MixedOperationTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=POWER_SETPOINT_DEFAULT * np.ones((1, n_turbines)), + yaw_angles=np.zeros((1, n_turbines)), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + base_Ct = SimpleTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + ) + + assert np.allclose(test_Ct, base_Ct) + + test_power = MixedOperationTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=POWER_SETPOINT_DEFAULT * np.ones((1, n_turbines)), + yaw_angles=np.zeros((1, n_turbines)), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + base_power = SimpleTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + ) + assert np.allclose(test_power, base_power) + + test_ai = MixedOperationTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=POWER_SETPOINT_DEFAULT * np.ones((1, n_turbines)), + yaw_angles=np.zeros((1, n_turbines)), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + base_ai = SimpleTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + ) + assert np.allclose(test_ai, base_ai) + + # Check that when power_setpoints are set, matches SimpleDeratingTurbine, + # while when yaw angles are set, matches CosineLossTurbine + n_turbines = 2 + derated_power = 2.0e6 + + test_Ct = MixedOperationTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.array([[POWER_SETPOINT_DEFAULT, derated_power]]), + yaw_angles=np.array([[20.0, 0.0]]), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + base_Ct_dr = SimpleDeratingTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.array([[POWER_SETPOINT_DEFAULT, derated_power]]), + ) + base_Ct_yaw = CosineLossTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + yaw_angles=np.array([[20.0, 0.0]]), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + base_Ct = np.array([[base_Ct_yaw[0,0], base_Ct_dr[0,1]]]) + assert np.allclose(test_Ct, base_Ct) + + # Do the same as above for power() + test_power = MixedOperationTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.array([[POWER_SETPOINT_DEFAULT, derated_power]]), + yaw_angles=np.array([[20.0, 0.0]]), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + base_power_dr = SimpleDeratingTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.array([[POWER_SETPOINT_DEFAULT, derated_power]]), + ) + base_power_yaw = CosineLossTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + yaw_angles=np.array([[20.0, 0.0]]), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + base_power = np.array([[base_power_yaw[0,0], base_power_dr[0,1]]]) + assert np.allclose(test_power, base_power) + + # Finally, check axial induction + test_ai = MixedOperationTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.array([[POWER_SETPOINT_DEFAULT, derated_power]]), + yaw_angles=np.array([[20.0, 0.0]]), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + base_ai_dr = SimpleDeratingTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.array([[POWER_SETPOINT_DEFAULT, derated_power]]), + ) + base_ai_yaw = CosineLossTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + yaw_angles=np.array([[20.0, 0.0]]), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + base_ai = np.array([[base_ai_yaw[0,0], base_ai_dr[0,1]]]) + assert np.allclose(test_ai, base_ai) + + # Check error raised when both yaw and power setpoints are set + with pytest.raises(ValueError): + # Second turbine has both a power setpoint and a yaw angle + MixedOperationTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + power_setpoints=np.array([[POWER_SETPOINT_DEFAULT, derated_power]]), + yaw_angles=np.array([[0.0, 20.0]]), + tilt_angles=tilt_angles_nom, + tilt_interp=None + ) + +def test_AWCTurbine(): + + n_turbines = 1 + wind_speed = 10.0 + turbine_data = SampleInputs().turbine + + # Baseline + base_Ct = SimpleTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + ) + base_power = SimpleTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + ) + base_ai = SimpleTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + ) + + # Test no change to Ct, power, or ai when helix amplitudes are 0 + test_Ct = AWCTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + awc_modes=np.array([["helix"]*n_turbines]*1), + awc_amplitudes=np.zeros((1, n_turbines)), + ) + assert np.allclose(test_Ct, base_Ct) + + test_power = AWCTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + awc_modes=np.array([["helix"]*n_turbines]*1), + awc_amplitudes=np.zeros((1, n_turbines)), + ) + assert np.allclose(test_power, base_power) + + test_ai = AWCTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + awc_modes=np.array([["helix"]*n_turbines]*1), + awc_amplitudes=np.zeros((1, n_turbines)), + ) + assert np.allclose(test_ai, base_ai) + + # Test that Ct, power, and ai all decrease when helix amplitudes are non-zero + test_Ct = AWCTurbine.thrust_coefficient( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + awc_modes=np.array([["helix"]*n_turbines]*1), + awc_amplitudes=2*np.ones((1, n_turbines)), + ) + assert test_Ct < base_Ct + assert test_Ct > 0 + + test_power = AWCTurbine.power( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine_data["power_thrust_table"]["ref_air_density"], + awc_modes=np.array([["helix"]*n_turbines]*1), + awc_amplitudes=2*np.ones((1, n_turbines)), + ) + assert test_power < base_power + assert test_power > 0 + + test_ai = AWCTurbine.axial_induction( + power_thrust_table=turbine_data["power_thrust_table"], + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + awc_modes=np.array([["helix"]*n_turbines]*1), + awc_amplitudes=2*np.ones((1, n_turbines)), + ) + assert test_ai < base_ai + assert test_ai > 0 diff --git a/tests/turbine_unit_test.py b/tests/turbine_unit_test.py index a3f03e674..ca5e73777 100644 --- a/tests/turbine_unit_test.py +++ b/tests/turbine_unit_test.py @@ -1,17 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - import os from pathlib import Path @@ -20,33 +6,22 @@ import numpy as np import pytest import yaml -from scipy.interpolate import interp1d -from floris.simulation import ( +from floris.core import ( average_velocity, axial_induction, - Ct, power, + thrust_coefficient, Turbine, ) -from floris.simulation.turbine import ( - _rotor_velocity_tilt_correction, - _rotor_velocity_yaw_correction, - compute_tilt_angles_for_floating_turbines, -) -from floris.turbine_library import build_turbine_dict +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT from tests.conftest import SampleInputs, WIND_SPEEDS -# size 3 x 4 x 1 x 1 x 1 -WIND_CONDITION_BROADCAST = np.stack( - ( - np.reshape(np.array(WIND_SPEEDS), (-1, 1, 1, 1)), # Wind direction 0 - np.reshape(np.array(WIND_SPEEDS), (-1, 1, 1, 1)), # Wind direction 1 - np.reshape(np.array(WIND_SPEEDS), (-1, 1, 1, 1)), # Wind direction 2 - ), - axis=0, -) +# size 16 x 1 x 1 x 1 +# 16 wind speed and wind direction combinations from conftest +WIND_CONDITION_BROADCAST = np.reshape(np.array(WIND_SPEEDS), (-1, 1, 1, 1)) + INDEX_FILTER = [0, 2] @@ -56,12 +31,20 @@ def test_turbine_init(): assert turbine.turbine_type == turbine_data["turbine_type"] assert turbine.rotor_diameter == turbine_data["rotor_diameter"] assert turbine.hub_height == turbine_data["hub_height"] - assert turbine.pP == turbine_data["pP"] - assert turbine.pT == turbine_data["pT"] + assert ( + turbine.power_thrust_table["cosine_loss_exponent_yaw"] + == turbine_data["power_thrust_table"]["cosine_loss_exponent_yaw"] + ) + assert ( + turbine.power_thrust_table["cosine_loss_exponent_tilt"] + == turbine_data["power_thrust_table"]["cosine_loss_exponent_tilt"] + ) assert turbine.TSR == turbine_data["TSR"] - assert turbine.generator_efficiency == turbine_data["generator_efficiency"] - assert turbine.ref_density_cp_ct == turbine_data["ref_density_cp_ct"] - assert turbine.ref_tilt_cp_ct == turbine_data["ref_tilt_cp_ct"] + assert ( + turbine.power_thrust_table["ref_air_density"] + == turbine_data["power_thrust_table"]["ref_air_density"] + ) + assert turbine.power_thrust_table["ref_tilt"] == turbine_data["power_thrust_table"]["ref_tilt"] assert np.array_equal( turbine.power_thrust_table["wind_speed"], turbine_data["power_thrust_table"]["wind_speed"] @@ -71,20 +54,14 @@ def test_turbine_init(): turbine_data["power_thrust_table"]["power"] ) assert np.array_equal( - turbine.power_thrust_table["thrust"], - turbine_data["power_thrust_table"]["thrust"] + turbine.power_thrust_table["thrust_coefficient"], + turbine_data["power_thrust_table"]["thrust_coefficient"] ) assert turbine.rotor_radius == turbine.rotor_diameter / 2.0 assert turbine.rotor_area == np.pi * turbine.rotor_radius ** 2.0 - # TODO: test these explicitly. - # Test create a simpler interpolator and test that you get the values you expect - # fCt_interp: interp1d = field(init=False) - # power_interp: interp1d = field(init=False) - # tilt_interp: interp1d = field(init=False, default=None) - - assert isinstance(turbine.fCt_interp, interp1d) - assert isinstance(turbine.power_interp, interp1d) + assert callable(turbine.thrust_coefficient_function) + assert callable(turbine.power_function) def test_rotor_radius(): @@ -122,61 +99,61 @@ def test_rotor_area(): def test_average_velocity(): # TODO: why do we use cube root - mean - cube (like rms) instead of a simple average (np.mean)? - # Dimensions are (n wind directions, n wind speeds, n turbines, grid x, grid y) - velocities = np.ones((1, 1, 1, 5, 5)) + # Dimensions are (n_findex, n turbines, grid x, grid y) + velocities = np.ones((1, 1, 5, 5)) assert average_velocity(velocities, method="cubic-mean") == 1 - # Constructs an array of shape 1 x 1 x 2 x 3 x 3 with finrst turbie all 1, second turbine all 2 + # Constructs an array of shape 1 x 2 x 3 x 3 with first turbine all 1, second turbine all 2 velocities = np.stack( ( - np.ones((1, 1, 3, 3)), # The first dimension here is the wind direction and the second - 2 * np.ones((1, 1, 3, 3)), # is the wind speed since we are stacking on axis=2 + np.ones((1, 3, 3)), # The first dimension here is the findex dimension and the second + 2 * np.ones((1, 3, 3)), # is the n turbine since we are stacking on axis=1 ), - axis=2, + axis=1, ) - # Pull out the first wind speed for the test + # Pull out the first findex for the test np.testing.assert_array_equal( - average_velocity(velocities, method="cubic-mean")[0, 0], + average_velocity(velocities, method="cubic-mean")[0], np.array([1, 2]) ) # Test boolean filter ix_filter = [True, False, True, False] - velocities = np.stack( # 4 turbines with 3 x 3 velocity array; shape (1,1,4,3,3) - [i * np.ones((1, 1, 3, 3)) for i in range(1,5)], + velocities = np.stack( # 4 turbines with 3 x 3 velocity array; shape (1,4,3,3) + [i * np.ones((1, 3, 3)) for i in range(1,5)], # ( - # # The first dimension here is the wind direction - # # and second is the wind speed since we are stacking on axis=2 + # # The first dimension here is the findex dimension + # # and second is the turbine dimension since we are stacking on axis=1 # np.ones( - # (1, 1, 3, 3) + # (1, 3, 3) # ), - # 2 * np.ones((1, 1, 3, 3)), - # 3 * np.ones((1, 1, 3, 3)), - # 4 * np.ones((1, 1, 3, 3)), + # 2 * np.ones((1, 3, 3)), + # 3 * np.ones((1, 3, 3)), + # 4 * np.ones((1, 3, 3)), # ), - axis=2, + axis=1, ) avg = average_velocity(velocities, ix_filter, method="cubic-mean") - assert avg.shape == (1, 1, 2) # 1 wind direction, 1 wind speed, 2 turbines filtered + assert avg.shape == (1, 2) # 1 = n_findex, 2 turbines filtered - # Pull out the first wind direction and wind speed for the comparison - assert np.allclose(avg[0, 0], np.array([1.0, 3.0])) + # Pull out the first findex for the comparison + assert np.allclose(avg[0], np.array([1.0, 3.0])) # This fails in GitHub Actions due to a difference in precision: # E assert 3.0000000000000004 == 3.0 # np.testing.assert_array_equal(avg[0], np.array([1.0, 3.0])) # Test integer array filter # np.arange(1, 5).reshape((-1,1,1)) * np.ones((1, 1, 3, 3)) - velocities = np.stack( # 4 turbines with 3 x 3 velocity array; shape (1,1,4,3,3) - [i * np.ones((1, 1, 3, 3)) for i in range(1,5)], - axis=2, + velocities = np.stack( # 4 turbines with 3 x 3 velocity array; shape (1,4,3,3) + [i * np.ones((1, 3, 3)) for i in range(1,5)], + axis=1, ) avg = average_velocity(velocities, INDEX_FILTER, method="cubic-mean") - assert avg.shape == (1, 1, 2) # 1 wind direction, 1 wind speed, 2 turbines filtered + assert avg.shape == (1, 2) # 1 findex, 2 turbines filtered - # Pull out the first wind direction and wind speed for the comparison - assert np.allclose(avg[0, 0], np.array([1.0, 3.0])) + # Pull out the first findex for the comparison + assert np.allclose(avg[0], np.array([1.0, 3.0])) def test_ct(): @@ -187,68 +164,87 @@ def test_ct(): turbine = Turbine.from_dict(turbine_data) turbine_floating = Turbine.from_dict(turbine_floating_data) turbine_type_map = np.array(N_TURBINES * [turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] + + # Add the findex (0th) dimension + turbine_type_map = turbine_type_map[None, :] # Single turbine - # yaw angle / fCt are (n wind direction, n wind speed, n turbine) + # yaw angle / fCt are (n_findex, n turbine) wind_speed = 10.0 - thrust = Ct( - velocities=wind_speed * np.ones((1, 1, 1, 3, 3)), - yaw_angle=np.zeros((1, 1, 1)), - tilt_angle=np.ones((1, 1, 1)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, 1)) * 5.0, - fCt={turbine.turbine_type: turbine.fCt_interp}, - tilt_interp={turbine.turbine_type: None}, - correct_cp_ct_for_tilt=np.array([[[False]]]), - turbine_type_map=turbine_type_map[:,:,0] + thrust = thrust_coefficient( + velocities=wind_speed * np.ones((1, 1, 3, 3)), + air_density=None, + yaw_angles=np.zeros((1, 1)), + tilt_angles=np.ones((1, 1)) * 5.0, + power_setpoints=np.ones((1, 1)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array("baseline"), + awc_amplitudes=np.zeros((1, 1)), + thrust_coefficient_functions={turbine.turbine_type: turbine.thrust_coefficient_function}, + tilt_interps={turbine.turbine_type: None}, + correct_cp_ct_for_tilt=np.array([[False]]), + turbine_type_map=turbine_type_map[:,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ) truth_index = turbine_data["power_thrust_table"]["wind_speed"].index(wind_speed) - np.testing.assert_allclose(thrust, turbine_data["power_thrust_table"]["thrust"][truth_index]) + np.testing.assert_allclose( + thrust, + turbine_data["power_thrust_table"]["thrust_coefficient"][truth_index] + ) # Multiple turbines with index filter # 4 turbines with 3 x 3 grid arrays - thrusts = Ct( - velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 3 x 4 x 4 x 3 x 3 - yaw_angle=np.zeros((1, 1, N_TURBINES)), - tilt_angle=np.ones((1, 1, N_TURBINES)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, N_TURBINES)) * 5.0, - fCt={turbine.turbine_type: turbine.fCt_interp}, - tilt_interp={turbine.turbine_type: None}, - correct_cp_ct_for_tilt=np.array([[[False] * N_TURBINES]]), + thrusts = thrust_coefficient( + velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 12 x 4 x 3 x 3 + air_density=None, + yaw_angles=np.zeros((1, N_TURBINES)), + tilt_angles=np.ones((1, N_TURBINES)) * 5.0, + power_setpoints=np.ones((1, N_TURBINES)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array([["baseline"]*N_TURBINES]*1), + awc_amplitudes=np.zeros((1, N_TURBINES)), + thrust_coefficient_functions={turbine.turbine_type: turbine.thrust_coefficient_function}, + tilt_interps={turbine.turbine_type: None}, + correct_cp_ct_for_tilt=np.array([[False] * N_TURBINES]), turbine_type_map=turbine_type_map, + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ix_filter=INDEX_FILTER, ) - assert len(thrusts[0, 0]) == len(INDEX_FILTER) + assert len(thrusts[0]) == len(INDEX_FILTER) for i in range(len(INDEX_FILTER)): truth_index = turbine_data["power_thrust_table"]["wind_speed"].index(WIND_SPEEDS[0]) np.testing.assert_allclose( - thrusts[0, 0, i], - turbine_data["power_thrust_table"]["thrust"][truth_index] + thrusts[0, i], + turbine_data["power_thrust_table"]["thrust_coefficient"][truth_index] ) # Single floating turbine; note that 'tilt_interp' is not set to None - thrust = Ct( - velocities=wind_speed * np.ones((1, 1, 1, 3, 3)), - yaw_angle=np.zeros((1, 1, 1)), - tilt_angle=np.ones((1, 1, 1)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, 1)) * 5.0, - fCt={turbine.turbine_type: turbine_floating.fCt_interp}, - tilt_interp={turbine_floating.turbine_type: turbine_floating.tilt_interp}, - correct_cp_ct_for_tilt=np.array([[[True]]]), - turbine_type_map=turbine_type_map[:,:,0] + thrust = thrust_coefficient( + velocities=wind_speed * np.ones((1, 1, 3, 3)), # One findex, one turbine + air_density=None, + yaw_angles=np.zeros((1, 1)), + tilt_angles=np.ones((1, 1)) * 5.0, + power_setpoints=np.ones((1, 1)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array("baseline"), + awc_amplitudes=np.zeros((1, 1)), + thrust_coefficient_functions={ + turbine.turbine_type: turbine_floating.thrust_coefficient_function + }, + tilt_interps={turbine_floating.turbine_type: turbine_floating.tilt_interp}, + correct_cp_ct_for_tilt=np.array([[True]]), + turbine_type_map=turbine_type_map[:,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ) truth_index = turbine_floating_data["power_thrust_table"]["wind_speed"].index(wind_speed) np.testing.assert_allclose( thrust, - turbine_floating_data["power_thrust_table"]["thrust"][truth_index] + turbine_floating_data["power_thrust_table"]["thrust_coefficient"][truth_index] ) def test_power(): - AIR_DENSITY = 1.225 + # AIR_DENSITY = 1.225 # Test that power is computed as expected for a single turbine n_turbines = 1 @@ -256,35 +252,41 @@ def test_power(): turbine_data = SampleInputs().turbine turbine = Turbine.from_dict(turbine_data) turbine_type_map = np.array(n_turbines * [turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] + turbine_type_map = turbine_type_map[None, :] test_power = power( - ref_density_cp_ct=AIR_DENSITY, - rotor_effective_velocities=wind_speed * np.ones((1, 1, 1)), - power_interp={turbine.turbine_type: turbine.power_interp}, - turbine_type_map=turbine_type_map[:,:,0] - ) - - # Recompute using the provided Cp table + velocities=wind_speed * np.ones((1, 1, 3, 3)), # 1 findex, 1 turbine, 3x3 grid + air_density=turbine.power_thrust_table["ref_air_density"], + power_functions={turbine.turbine_type: turbine.power_function}, + yaw_angles=np.zeros((1, 1)), # 1 findex, 1 turbine + power_setpoints=np.ones((1, 1)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array("baseline"), + awc_amplitudes=np.zeros((1, 1)), + tilt_angles=turbine.power_thrust_table["ref_tilt"] * np.ones((1, 1)), + tilt_interps={turbine.turbine_type: turbine.tilt_interp}, + turbine_type_map=turbine_type_map[:,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, + ) + + # Recompute using the provided power truth_index = turbine_data["power_thrust_table"]["wind_speed"].index(wind_speed) - cp_truth = turbine_data["power_thrust_table"]["power"][truth_index] - baseline_power = ( - 0.5 - * cp_truth - * AIR_DENSITY - * turbine.rotor_area - * wind_speed ** 3 - * turbine.generator_efficiency - ) + baseline_power = turbine_data["power_thrust_table"]["power"][truth_index] * 1000 assert np.allclose(baseline_power, test_power) # At rated, the power calculated should be 5MW since the test data is the NREL 5MW turbine wind_speed = 18.0 rated_power = power( - ref_density_cp_ct=AIR_DENSITY, - rotor_effective_velocities=wind_speed * np.ones((1, 1, 1)), - power_interp={turbine.turbine_type: turbine.power_interp}, - turbine_type_map=turbine_type_map[:,:,0] + velocities=wind_speed * np.ones((1, 1, 3, 3)), + air_density=turbine.power_thrust_table["ref_air_density"], + power_functions={turbine.turbine_type: turbine.power_function}, + yaw_angles=np.zeros((1, 1)), # 1 findex, 1 turbine + tilt_angles=turbine.power_thrust_table["ref_tilt"] * np.ones((1, 1)), + power_setpoints=np.ones((1, 1)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array("baseline"), + awc_amplitudes=np.zeros((1, 1)), + tilt_interps={turbine.turbine_type: turbine.tilt_interp}, + turbine_type_map=turbine_type_map[:,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ) assert np.allclose(rated_power, 5e6) @@ -292,10 +294,17 @@ def test_power(): # At wind speed = 0.0, the power should be 0 based on the provided Cp curve wind_speed = 0.0 zero_power = power( - ref_density_cp_ct=AIR_DENSITY, - rotor_effective_velocities=wind_speed * np.ones((1, 1, 1)), - power_interp={turbine.turbine_type: turbine.power_interp}, - turbine_type_map=turbine_type_map[:,:,0] + velocities=wind_speed * np.ones((1, 1, 3, 3)), + air_density=turbine.power_thrust_table["ref_air_density"], + power_functions={turbine.turbine_type: turbine.power_function}, + yaw_angles=np.zeros((1, 1)), # 1 findex, 1 turbine + tilt_angles=turbine.power_thrust_table["ref_tilt"] * np.ones((1, 1)), + power_setpoints=np.ones((1, 1)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array("baseline"), + awc_amplitudes=np.zeros((1, 1)), + tilt_interps={turbine.turbine_type: turbine.tilt_interp}, + turbine_type_map=turbine_type_map[:,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ) assert np.allclose(zero_power, 0.0) @@ -306,30 +315,44 @@ def test_power(): turbine_data = SampleInputs().turbine turbine = Turbine.from_dict(turbine_data) turbine_type_map = np.array(n_turbines * [turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] + turbine_type_map = turbine_type_map[None, :] test_4_power = power( - ref_density_cp_ct=AIR_DENSITY, - rotor_effective_velocities=wind_speed * np.ones((1, 1, n_turbines)), - power_interp={turbine.turbine_type: turbine.power_interp}, - turbine_type_map=turbine_type_map + velocities=wind_speed * np.ones((1, n_turbines, 3, 3)), + air_density=turbine.power_thrust_table["ref_air_density"], + power_functions={turbine.turbine_type: turbine.power_function}, + yaw_angles=np.zeros((1, n_turbines)), + tilt_angles=turbine.power_thrust_table["ref_tilt"] * np.ones((1, n_turbines)), + power_setpoints=np.ones((1, n_turbines)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array([["baseline"]*n_turbines]*1), + awc_amplitudes=np.zeros((1, n_turbines)), + tilt_interps={turbine.turbine_type: turbine.tilt_interp}, + turbine_type_map=turbine_type_map, + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ) - baseline_4_power = baseline_power * np.ones((1, 1, n_turbines)) + baseline_4_power = baseline_power * np.ones((1, n_turbines)) assert np.allclose(baseline_4_power, test_4_power) assert np.shape(baseline_4_power) == np.shape(test_4_power) - # Same as above but with the grid expanded in the velocities array + # Same as above but with the grid collapsed in the velocities array turbine_data = SampleInputs().turbine turbine = Turbine.from_dict(turbine_data) turbine_type_map = np.array(n_turbines * [turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] + turbine_type_map = turbine_type_map[None, :] test_grid_power = power( - ref_density_cp_ct=AIR_DENSITY, - rotor_effective_velocities=wind_speed * np.ones((1, 1, n_turbines, 3, 3)), - power_interp={turbine.turbine_type: turbine.power_interp}, - turbine_type_map=turbine_type_map[:,:,0] + velocities=wind_speed * np.ones((1, n_turbines, 1)), + air_density=turbine.power_thrust_table["ref_air_density"], + power_functions={turbine.turbine_type: turbine.power_function}, + yaw_angles=np.zeros((1, n_turbines)), + tilt_angles=turbine.power_thrust_table["ref_tilt"] * np.ones((1, n_turbines)), + power_setpoints=np.ones((1, n_turbines)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array([["baseline"]*n_turbines]*1), + awc_amplitudes=np.zeros((1, n_turbines)), + tilt_interps={turbine.turbine_type: turbine.tilt_interp}, + turbine_type_map=turbine_type_map, + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ) - baseline_grid_power = baseline_power * np.ones((1, 1, n_turbines, 3, 3)) + baseline_grid_power = baseline_power * np.ones((1, n_turbines)) assert np.allclose(baseline_grid_power, test_grid_power) assert np.shape(baseline_grid_power) == np.shape(test_grid_power) @@ -343,202 +366,68 @@ def test_axial_induction(): turbine = Turbine.from_dict(turbine_data) turbine_floating = Turbine.from_dict(turbine_floating_data) turbine_type_map = np.array(N_TURBINES * [turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] + turbine_type_map = turbine_type_map[None, :] - baseline_ai = 0.25116283939089806 + baseline_ai = 0.26752001107622186415 # Single turbine wind_speed = 10.0 ai = axial_induction( - velocities=wind_speed * np.ones((1, 1, 1, 3, 3)), - yaw_angle=np.zeros((1, 1, 1)), - tilt_angle=np.ones((1, 1, 1)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, 1)) * 5.0, - fCt={turbine.turbine_type: turbine.fCt_interp}, - tilt_interp={turbine.turbine_type: None}, - correct_cp_ct_for_tilt=np.array([[[False]]]), - turbine_type_map=turbine_type_map[0,0,0], + velocities=wind_speed * np.ones((1, 1, 3, 3)), # 1 findex, 1 Turbine + air_density=None, + yaw_angles=np.zeros((1, 1)), + tilt_angles=np.ones((1, 1)) * 5.0, + power_setpoints=np.ones((1, 1)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array("baseline"), + awc_amplitudes=np.zeros((1, 1)), + axial_induction_functions={turbine.turbine_type: turbine.axial_induction_function}, + tilt_interps={turbine.turbine_type: None}, + correct_cp_ct_for_tilt=np.array([[False]]), + turbine_type_map=turbine_type_map[0,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ) np.testing.assert_allclose(ai, baseline_ai) # Multiple turbines with ix filter ai = axial_induction( - velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 3 x 4 x 4 x 3 x 3 - yaw_angle=np.zeros((1, 1, N_TURBINES)), - tilt_angle=np.ones((1, 1, N_TURBINES)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, N_TURBINES)) * 5.0, - fCt={turbine.turbine_type: turbine.fCt_interp}, - tilt_interp={turbine.turbine_type: None}, - correct_cp_ct_for_tilt=np.array([[[False] * N_TURBINES]]), + velocities=np.ones((N_TURBINES, 3, 3)) * WIND_CONDITION_BROADCAST, # 12 x 4 x 3 x 3 + air_density=None, + yaw_angles=np.zeros((1, N_TURBINES)), + tilt_angles=np.ones((1, N_TURBINES)) * 5.0, + power_setpoints=np.ones((1, N_TURBINES)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array([["baseline"]*N_TURBINES]*1), + awc_amplitudes=np.zeros((1, N_TURBINES)), + axial_induction_functions={turbine.turbine_type: turbine.axial_induction_function}, + tilt_interps={turbine.turbine_type: None}, + correct_cp_ct_for_tilt=np.array([[False] * N_TURBINES]), turbine_type_map=turbine_type_map, + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ix_filter=INDEX_FILTER, ) - assert len(ai[0, 0]) == len(INDEX_FILTER) + assert len(ai[0]) == len(INDEX_FILTER) # Test the 10 m/s wind speed to use the same baseline as above - np.testing.assert_allclose(ai[0,2], baseline_ai) + np.testing.assert_allclose(ai[2], baseline_ai) # Single floating turbine; note that 'tilt_interp' is not set to None ai = axial_induction( - velocities=wind_speed * np.ones((1, 1, 1, 3, 3)), - yaw_angle=np.zeros((1, 1, 1)), - tilt_angle=np.ones((1, 1, 1)) * 5.0, - ref_tilt_cp_ct=np.ones((1, 1, 1)) * 5.0, - fCt={turbine.turbine_type: turbine_floating.fCt_interp}, - tilt_interp={turbine_floating.turbine_type: turbine_floating.tilt_interp}, - correct_cp_ct_for_tilt=np.array([[[True]]]), - turbine_type_map=turbine_type_map[0,0,0], + velocities=wind_speed * np.ones((1, 1, 3, 3)), + air_density=None, + yaw_angles=np.zeros((1, 1)), + tilt_angles=np.ones((1, 1)) * 5.0, + power_setpoints=np.ones((1, 1)) * POWER_SETPOINT_DEFAULT, + awc_modes=np.array("baseline"), + awc_amplitudes=np.zeros((1, 1)), + axial_induction_functions={turbine.turbine_type: turbine.axial_induction_function}, + tilt_interps={turbine_floating.turbine_type: turbine_floating.tilt_interp}, + correct_cp_ct_for_tilt=np.array([[True]]), + turbine_type_map=turbine_type_map[0,0], + turbine_power_thrust_tables={turbine.turbine_type: turbine.power_thrust_table}, ) np.testing.assert_allclose(ai, baseline_ai) -def test_rotor_velocity_yaw_correction(): - N_TURBINES = 4 - - wind_speed = average_velocity(10.0 * np.ones((1, 1, 1, 3, 3))) - wind_speed_N_TURBINES = average_velocity(10.0 * np.ones((1, 1, N_TURBINES, 3, 3))) - - # Test a single turbine for zero yaw - yaw_corrected_velocities = _rotor_velocity_yaw_correction( - pP=3.0, - yaw_angle=0.0, - rotor_effective_velocities=wind_speed, - ) - np.testing.assert_allclose(yaw_corrected_velocities, wind_speed) - - # Test a single turbine for non-zero yaw - yaw_corrected_velocities = _rotor_velocity_yaw_correction( - pP=3.0, - yaw_angle=60.0, - rotor_effective_velocities=wind_speed, - ) - np.testing.assert_allclose(yaw_corrected_velocities, 0.5 * wind_speed) - - # Test multiple turbines for zero yaw - yaw_corrected_velocities = _rotor_velocity_yaw_correction( - pP=3.0, - yaw_angle=np.zeros((1, 1, N_TURBINES)), - rotor_effective_velocities=wind_speed_N_TURBINES, - ) - np.testing.assert_allclose(yaw_corrected_velocities, wind_speed_N_TURBINES) - - # Test multiple turbines for non-zero yaw - yaw_corrected_velocities = _rotor_velocity_yaw_correction( - pP=3.0, - yaw_angle=np.ones((1, 1, N_TURBINES)) * 60.0, - rotor_effective_velocities=wind_speed_N_TURBINES, - ) - np.testing.assert_allclose(yaw_corrected_velocities, 0.5 * wind_speed_N_TURBINES) - - -def test_rotor_velocity_tilt_correction(): - N_TURBINES = 4 - - wind_speed = average_velocity(10.0 * np.ones((1, 1, 1, 3, 3))) - wind_speed_N_TURBINES = average_velocity(10.0 * np.ones((1, 1, N_TURBINES, 3, 3))) - - turbine_data = SampleInputs().turbine - turbine_floating_data = SampleInputs().turbine_floating - turbine = Turbine.from_dict(turbine_data) - turbine_floating = Turbine.from_dict(turbine_floating_data) - turbine_type_map = np.array(N_TURBINES * [turbine.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] - - # Test single non-floating turbine - tilt_corrected_velocities = _rotor_velocity_tilt_correction( - turbine_type_map=np.array([turbine_type_map[:, :, 0]]), - tilt_angle=5.0*np.ones((1, 1, 1)), - ref_tilt_cp_ct=np.array([turbine.ref_tilt_cp_ct]), - pT=np.array([turbine.pT]), - tilt_interp={turbine.turbine_type: turbine.tilt_interp}, - correct_cp_ct_for_tilt=np.array([[[False]]]), - rotor_effective_velocities=wind_speed, - ) - - np.testing.assert_allclose(tilt_corrected_velocities, wind_speed) - - # Test multiple non-floating turbines - tilt_corrected_velocities = _rotor_velocity_tilt_correction( - turbine_type_map=turbine_type_map, - tilt_angle=5.0*np.ones((1, 1, N_TURBINES)), - ref_tilt_cp_ct=np.array([turbine.ref_tilt_cp_ct] * N_TURBINES), - pT=np.array([turbine.pT] * N_TURBINES), - tilt_interp={turbine.turbine_type: turbine.tilt_interp}, - correct_cp_ct_for_tilt=np.array([[[False] * N_TURBINES]]), - rotor_effective_velocities=wind_speed_N_TURBINES, - ) - - np.testing.assert_allclose(tilt_corrected_velocities, wind_speed_N_TURBINES) - - # Test single floating turbine - tilt_corrected_velocities = _rotor_velocity_tilt_correction( - turbine_type_map=np.array([turbine_type_map[:, :, 0]]), - tilt_angle=5.0*np.ones((1, 1, 1)), - ref_tilt_cp_ct=np.array([turbine_floating.ref_tilt_cp_ct]), - pT=np.array([turbine_floating.pT]), - tilt_interp={turbine_floating.turbine_type: turbine_floating.tilt_interp}, - correct_cp_ct_for_tilt=np.array([[[True]]]), - rotor_effective_velocities=wind_speed, - ) - - np.testing.assert_allclose(tilt_corrected_velocities, wind_speed) - - # Test multiple floating turbines - tilt_corrected_velocities = _rotor_velocity_tilt_correction( - turbine_type_map, - tilt_angle=5.0*np.ones((1, 1, N_TURBINES)), - ref_tilt_cp_ct=np.array([turbine_floating.ref_tilt_cp_ct] * N_TURBINES), - pT=np.array([turbine_floating.pT] * N_TURBINES), - tilt_interp={turbine_floating.turbine_type: turbine_floating.tilt_interp}, - correct_cp_ct_for_tilt=np.array([[[True] * N_TURBINES]]), - rotor_effective_velocities=wind_speed_N_TURBINES, - ) - - np.testing.assert_allclose(tilt_corrected_velocities, wind_speed_N_TURBINES) - - -def test_compute_tilt_angles_for_floating_turbines(): - N_TURBINES = 4 - - wind_speed = 25.0 - rotor_effective_velocities = average_velocity(wind_speed * np.ones((1, 1, 1, 3, 3))) - rotor_effective_velocities_N_TURBINES = average_velocity( - wind_speed * np.ones((1, 1, N_TURBINES, 3, 3)) - ) - - turbine_floating_data = SampleInputs().turbine_floating - turbine_floating = Turbine.from_dict(turbine_floating_data) - turbine_type_map = np.array(N_TURBINES * [turbine_floating.turbine_type]) - turbine_type_map = turbine_type_map[None, None, :] - - # Single turbine - tilt = compute_tilt_angles_for_floating_turbines( - turbine_type_map=np.array([turbine_type_map[:, :, 0]]), - tilt_angle=5.0*np.ones((1, 1, 1)), - tilt_interp={turbine_floating.turbine_type: turbine_floating.tilt_interp}, - rotor_effective_velocities=rotor_effective_velocities, - ) - - # calculate tilt again - truth_index = turbine_floating_data["floating_tilt_table"]["wind_speed"].index(wind_speed) - tilt_truth = turbine_floating_data["floating_tilt_table"]["tilt"][truth_index] - np.testing.assert_allclose(tilt, tilt_truth) - - # Multiple turbines - tilt_N_turbines = compute_tilt_angles_for_floating_turbines( - turbine_type_map=np.array(turbine_type_map), - tilt_angle=5.0*np.ones((1, 1, N_TURBINES)), - tilt_interp={turbine_floating.turbine_type: turbine_floating.tilt_interp}, - rotor_effective_velocities=rotor_effective_velocities_N_TURBINES, - ) - - # calculate tilt again - truth_index = turbine_floating_data["floating_tilt_table"]["wind_speed"].index(wind_speed) - tilt_truth = turbine_floating_data["floating_tilt_table"]["tilt"][truth_index] - np.testing.assert_allclose(tilt_N_turbines, [[[tilt_truth] * N_TURBINES]]) - - def test_asdict(sample_inputs_fixture: SampleInputs): turbine = Turbine.from_dict(sample_inputs_fixture.turbine) @@ -548,88 +437,3 @@ def test_asdict(sample_inputs_fixture: SampleInputs): dict2 = new_turb.as_dict() assert dict1 == dict2 - -def test_build_turbine_dict(): - - orig_file_path = Path(__file__).resolve().parent / "data" / "nrel_5MW_custom.yaml" - test_turb_name = "test_turbine_export" - test_file_path = "." - - in_dict = yaml.safe_load( open(orig_file_path, "r") ) - - # Mocked up turbine data - turbine_data_dict = { - "wind_speed":in_dict["power_thrust_table"]["wind_speed"], - "power_coefficient":in_dict["power_thrust_table"]["power"], - "thrust_coefficient":in_dict["power_thrust_table"]["thrust"] - } - - build_turbine_dict( - turbine_data_dict, - test_turb_name, - file_path=test_file_path, - generator_efficiency=in_dict["generator_efficiency"], - hub_height=in_dict["hub_height"], - pP=in_dict["pP"], - pT=in_dict["pT"], - rotor_diameter=in_dict["rotor_diameter"], - TSR=in_dict["TSR"], - air_density=in_dict["ref_density_cp_ct"], - ref_tilt_cp_ct=in_dict["ref_tilt_cp_ct"] - ) - - test_dict = yaml.safe_load( - open(os.path.join(test_file_path, test_turb_name+".yaml"), "r") - ) - - # Correct intended difference for test; assert equal - test_dict["turbine_type"] = in_dict["turbine_type"] - assert list(in_dict.keys()) == list(test_dict.keys()) - assert in_dict == test_dict - - # Now, in absolute values - Cp = np.array(in_dict["power_thrust_table"]["power"]) - Ct = np.array(in_dict["power_thrust_table"]["thrust"]) - ws = np.array(in_dict["power_thrust_table"]["wind_speed"]) - - P = 0.5 * in_dict["ref_density_cp_ct"] * (np.pi * in_dict["rotor_diameter"]**2/4) \ - * Cp * ws**3 - T = 0.5 * in_dict["ref_density_cp_ct"] * (np.pi * in_dict["rotor_diameter"]**2/4) \ - * Ct * ws**2 - - turbine_data_dict = { - "wind_speed":in_dict["power_thrust_table"]["wind_speed"], - "power_absolute": P/1000, - "thrust_absolute": T/1000 - } - - build_turbine_dict( - turbine_data_dict, - test_turb_name, - file_path=test_file_path, - generator_efficiency=in_dict["generator_efficiency"], - hub_height=in_dict["hub_height"], - pP=in_dict["pP"], - pT=in_dict["pT"], - rotor_diameter=in_dict["rotor_diameter"], - TSR=in_dict["TSR"], - air_density=in_dict["ref_density_cp_ct"], - ref_tilt_cp_ct=in_dict["ref_tilt_cp_ct"] - ) - - test_dict = yaml.safe_load( - open(os.path.join(test_file_path, test_turb_name+".yaml"), "r") - ) - - test_dict["turbine_type"] = in_dict["turbine_type"] - assert list(in_dict.keys()) == list(test_dict.keys()) - for k in in_dict.keys(): - if type(in_dict[k]) is dict: - for k2 in in_dict[k].keys(): - assert np.allclose(in_dict[k][k2], test_dict[k][k2]) - elif type(in_dict[k]) is str: - assert in_dict[k] == test_dict[k] - else: - assert np.allclose(in_dict[k], test_dict[k]) - - os.remove( os.path.join(test_file_path, test_turb_name+".yaml") ) diff --git a/tests/turbine_utilities_unit_test.py b/tests/turbine_utilities_unit_test.py new file mode 100644 index 000000000..44a8297b9 --- /dev/null +++ b/tests/turbine_utilities_unit_test.py @@ -0,0 +1,123 @@ + +import os +from pathlib import Path + +import numpy as np +import pytest +import yaml + +from floris.turbine_library import build_cosine_loss_turbine_dict, check_smooth_power_curve +from tests.conftest import SampleInputs + + +def test_build_turbine_dict(): + + turbine_data_v3 = SampleInputs().v3type_turbine + + # Mocked up turbine data + turbine_data_dict = { + "wind_speed":turbine_data_v3["power_thrust_table"]["wind_speed"], + "power_coefficient":turbine_data_v3["power_thrust_table"]["power"], + "thrust_coefficient":turbine_data_v3["power_thrust_table"]["thrust"] + } + + test_dict = build_cosine_loss_turbine_dict( + turbine_data_dict, + "test_turbine", + generator_efficiency=turbine_data_v3["generator_efficiency"], + hub_height=turbine_data_v3["hub_height"], + cosine_loss_exponent_yaw=turbine_data_v3["pP"], + cosine_loss_exponent_tilt=turbine_data_v3["pT"], + rotor_diameter=turbine_data_v3["rotor_diameter"], + TSR=turbine_data_v3["TSR"], + ref_air_density=turbine_data_v3["ref_density_cp_ct"], + ref_tilt=turbine_data_v3["ref_tilt_cp_ct"] + ) + + # Test correct error raised if power_coefficient version passed and generator efficiency + # not specified + with pytest.raises(KeyError): + build_cosine_loss_turbine_dict( + turbine_data_dict, + "test_turbine", + #generator_efficiency=turbine_data_v3["generator_efficiency"], + hub_height=turbine_data_v3["hub_height"], + cosine_loss_exponent_yaw=turbine_data_v3["pP"], + cosine_loss_exponent_tilt=turbine_data_v3["pT"], + rotor_diameter=turbine_data_v3["rotor_diameter"], + TSR=turbine_data_v3["TSR"], + ref_air_density=turbine_data_v3["ref_density_cp_ct"], + ref_tilt=turbine_data_v3["ref_tilt_cp_ct"] + ) + + # Directly compute power, thrust values + Cp = np.array(turbine_data_v3["power_thrust_table"]["power"]) + Ct = np.array(turbine_data_v3["power_thrust_table"]["thrust"]) + ws = np.array(turbine_data_v3["power_thrust_table"]["wind_speed"]) + + P = ( + 0.5 * turbine_data_v3["ref_density_cp_ct"] + * turbine_data_v3["generator_efficiency"] + * (np.pi * turbine_data_v3["rotor_diameter"]**2/4) + * Cp * ws**3 + ) + T = ( + 0.5 * turbine_data_v3["ref_density_cp_ct"] + * (np.pi * turbine_data_v3["rotor_diameter"]**2/4) + * Ct * ws**2 + ) + + # Compare direct computation to those generated by build_cosine_loss_turbine_dict + assert np.allclose(Ct, test_dict["power_thrust_table"]["thrust_coefficient"]) + assert np.allclose(P/1000, test_dict["power_thrust_table"]["power"]) + + # Check that dict keys match the v4 structure + turbine_data_v4 = SampleInputs().turbine + assert set(turbine_data_v4.keys()) >= set(test_dict.keys()) + assert ( + set(turbine_data_v4["power_thrust_table"].keys()) + >= set(test_dict["power_thrust_table"].keys()) + ) + + # Check thrust conversion from absolute value + turbine_data_dict = { + "wind_speed":turbine_data_v3["power_thrust_table"]["wind_speed"], + "power": P/1000, + "thrust": T/1000 + } + + test_dict_2 = build_cosine_loss_turbine_dict( + turbine_data_dict, + "test_turbine", + hub_height=turbine_data_v4["hub_height"], + cosine_loss_exponent_yaw=turbine_data_v4["power_thrust_table"]["cosine_loss_exponent_yaw"], + cosine_loss_exponent_tilt=turbine_data_v4["power_thrust_table"]["cosine_loss_exponent_tilt"], + rotor_diameter=turbine_data_v4["rotor_diameter"], + TSR=turbine_data_v4["TSR"], + ref_air_density=turbine_data_v4["power_thrust_table"]["ref_air_density"], + ref_tilt=turbine_data_v4["power_thrust_table"]["ref_tilt"] + ) + assert np.allclose(Ct, test_dict_2["power_thrust_table"]["thrust_coefficient"]) + + +def test_check_smooth_power_curve(): + + p1 = np.array([0, 1, 2, 3, 3, 3, 3, 2, 1], dtype=float)*1000 # smooth + p2 = np.array([0, 1, 2, 3, 2.99, 3.01, 3, 2, 1], dtype=float)*1000 # non-smooth + + p3 = p1.copy() + p3[5] = p3[5] + 9e-4 # just smooth enough + + p4 = p1.copy() + p4[5] = p4[5] + 1.1e-3 # just not smooth enough + + # Without a shutdown region + p5 = p1[:-3] # smooth + p6 = p2[:-3] # non-smooth + + assert check_smooth_power_curve(p1) + assert not check_smooth_power_curve(p2) + assert check_smooth_power_curve(p3) + assert not check_smooth_power_curve(p4) + assert check_smooth_power_curve(p5) + assert not check_smooth_power_curve(p6) diff --git a/tests/type_dec_unit_test.py b/tests/type_dec_unit_test.py index 641f207dc..5cc385d9d 100644 --- a/tests/type_dec_unit_test.py +++ b/tests/type_dec_unit_test.py @@ -1,16 +1,3 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation from pathlib import Path from typing import List @@ -22,6 +9,7 @@ from floris.type_dec import ( convert_to_path, floris_array_converter, + floris_numeric_dict_converter, FromDictMixin, iter_validator, ) @@ -116,7 +104,7 @@ def test_iter_validator(): AttrsDemoClass(w=0, x=1, liststr=("a", "b")) -def test_attrs_array_converter(): +def test_array_converter(): array_input = [[1, 2, 3], [4.5, 6.3, 2.2]] test_array = np.array(array_input) @@ -124,10 +112,53 @@ def test_attrs_array_converter(): cls = AttrsDemoClass(w=0, x=1, array=array_input) np.testing.assert_allclose(test_array, cls.array) - # Test converstion on reset + # Test conversion on reset cls.array = array_input np.testing.assert_allclose(test_array, cls.array) + # Test that a non-iterable item like a scalar number fails + with pytest.raises(TypeError): + cls.array = 1 + + +def test_numeric_dict_converter(): + """ + This function converts data in a dictionary to a numeric type. + If it can't convert the data, it will raise a TypeError. + It should support scalar, list, and numpy array types + for values in the dictionary. + """ + test_dict = { + "scalar_string": "1", + "scalar_int": 1, + "scalar_float": 1.0, + "list_string": ["1", "2", "3"], + "list_int": [1, 2, 3], + "list_float": [1.0, 2.0, 3.0], + "array_string": np.array(["1", "2", "3"]), + "array_int": np.array([1, 2, 3]), + "array_float": np.array([1.0, 2.0, 3.0]), + } + numeric_dict = floris_numeric_dict_converter(test_dict) + assert numeric_dict["scalar_string"] == 1 + assert numeric_dict["scalar_int"] == 1 + assert numeric_dict["scalar_float"] == 1.0 + np.testing.assert_allclose(numeric_dict["list_string"], [1, 2, 3]) + np.testing.assert_allclose(numeric_dict["list_int"], [1, 2, 3]) + np.testing.assert_allclose(numeric_dict["list_float"], [1.0, 2.0, 3.0]) + np.testing.assert_allclose(numeric_dict["array_string"], [1, 2, 3]) + np.testing.assert_allclose(numeric_dict["array_int"], [1, 2, 3]) + np.testing.assert_allclose(numeric_dict["array_float"], [1.0, 2.0, 3.0]) + + test_dict = {"scalar_fail": "a"} + with pytest.raises(TypeError): + floris_numeric_dict_converter(test_dict) + test_dict = {"list_fail": ["a", "2", "3"]} + with pytest.raises(TypeError): + floris_numeric_dict_converter(test_dict) + test_dict = {"array_fail": np.array(["a", "2", "3"])} + with pytest.raises(TypeError): + floris_numeric_dict_converter(test_dict) def test_convert_to_path(): str_input = "../tests" diff --git a/tests/uncertain_floris_model_integration_test.py b/tests/uncertain_floris_model_integration_test.py new file mode 100644 index 000000000..cdf3374c4 --- /dev/null +++ b/tests/uncertain_floris_model_integration_test.py @@ -0,0 +1,300 @@ +from pathlib import Path + +import numpy as np +import pytest +import yaml + +from floris import FlorisModel, TimeSeries +from floris.core.turbine.operation_models import POWER_SETPOINT_DEFAULT +from floris.uncertain_floris_model import ( + ApproxFlorisModel, + UncertainFlorisModel, + WindRose, +) + + +TEST_DATA = Path(__file__).resolve().parent / "data" +YAML_INPUT = TEST_DATA / "input_full.yaml" + + +def test_read_yaml(): + ufmodel = UncertainFlorisModel(configuration=YAML_INPUT) + assert isinstance(ufmodel, UncertainFlorisModel) + + +def test_rounded_inputs(): + ufmodel = UncertainFlorisModel(configuration=YAML_INPUT) + + # Using defaults + # Example input array + input_array = np.array([[45.3, 7.6, 0.24, 90.7, 749], [60.1, 8.2, 0.3, 95.3, 751]]) + + # Expected output array after rounding + expected_output = np.array([[45.0, 8.0, 0.25, 91.0, 700.0], [60.0, 8.0, 0.3, 95.0, 800.0]]) + + # Call the function + rounded_inputs = ufmodel._get_rounded_inputs(input_array) + + np.testing.assert_almost_equal(rounded_inputs, expected_output) + + +def test_expand_wind_directions(): + ufmodel = UncertainFlorisModel(configuration=YAML_INPUT) + + input_array = np.array( + [[1, 20, 30], [40, 50, 60], [70, 80, 90], [100, 110, 120], [359, 140, 150]] + ) + + # Test even length + with pytest.raises(ValueError): + wd_sample_points = [-15, -10, -5, 5, 10, 15] # Even lenght + ufmodel._expand_wind_directions(input_array, wd_sample_points) + + # Test middle element not 0 + with pytest.raises(ValueError): + wd_sample_points = [-15, -10, -5, 1, 5, 10, 15] # Odd length, not 0 at the middle + ufmodel._expand_wind_directions(input_array, wd_sample_points) + + # Test correction operations + wd_sample_points = [-15, -10, -5, 0, 5, 10, 15] # Odd length, 0 at the middle + output_array = ufmodel._expand_wind_directions(input_array, wd_sample_points) + + # Check if output shape is correct + assert output_array.shape[0] == 35 + + # Check 360 wrapping + # 1 - 15 = -14 -> 346 + np.testing.assert_almost_equal(output_array[0, 0], 346.0) + + # Check 360 wrapping + # 359 + 15 = 374 -> 14 + np.testing.assert_almost_equal(output_array[-1, 0], 14.0) + + +def test_expand_wind_directions_with_yaw_nom(): + ufmodel = UncertainFlorisModel(configuration=YAML_INPUT) + + # Assume 2 turbine + n_turbines = 2 + + # Assume n_findex = 2 + input_array = np.array( + [[270.0, 8.0, 0.6, 0.0, 0.0, 0.0, 0.0], [270.0, 8.0, 0.6, 0.0, 2.0, 0.0, 0.0]] + ) + + # 3 sample points + wd_sample_points = [-3, 0, 3] + + # Test correction operations + output_array = ufmodel._expand_wind_directions(input_array, wd_sample_points, True, n_turbines) + + # Check the first direction + np.testing.assert_almost_equal(output_array[0, 0], 267) + + # Check the first yaw + np.testing.assert_almost_equal(output_array[0, 4], -3) + + # Rerun with fix_yaw_to_nominal_direction = False, and now the yaw should be 0 + output_array = ufmodel._expand_wind_directions(input_array, wd_sample_points, False, n_turbines) + + # Check the first direction + np.testing.assert_almost_equal(output_array[0, 0], 267) + + # Check the first yaw + np.testing.assert_almost_equal(output_array[0, 4], 0) + + +def test_get_unique_inputs(): + ufmodel = UncertainFlorisModel(configuration=YAML_INPUT) + + input_array = np.array( + [ + [0, 1], + [0, 2], + [0, 1], + [1, 1], + [0, 1], + ] + ) + + expected_unique_inputs = np.array([[0, 1], [0, 2], [1, 1]]) + + unique_inputs, map_to_expanded_inputs = ufmodel._get_unique_inputs(input_array) + + # test expected result + assert np.array_equal(unique_inputs, expected_unique_inputs) + + # Test gets back to original + assert np.array_equal(unique_inputs[map_to_expanded_inputs], input_array) + + +def test_get_weights(): + ufmodel = UncertainFlorisModel(configuration=YAML_INPUT) + weights = ufmodel._get_weights(3.0, [-6, -3, 0, 3, 6]) + np.testing.assert_allclose( + weights, np.array([0.05448868, 0.24420134, 0.40261995, 0.24420134, 0.05448868]) + ) + + +def test_uncertain_floris_model(): + # Recompute uncertain result using certain result with 1 deg + + fmodel = FlorisModel(configuration=YAML_INPUT) + ufmodel = UncertainFlorisModel(configuration=YAML_INPUT, wd_sample_points=[-3, 0, 3], wd_std=3) + + fmodel.set( + layout_x=[0, 300], + layout_y=[0, 0], + wind_speeds=[8.0, 8.0, 8.0], + wind_directions=[267.0, 270.0, 273], + turbulence_intensities=[0.06, 0.06, 0.06], + ) + + ufmodel.set( + layout_x=[0, 300], + layout_y=[0, 0], + wind_speeds=[8.0], + wind_directions=[270.0], + turbulence_intensities=[0.06], + ) + + fmodel.run() + ufmodel.run() + + nom_powers = fmodel.get_turbine_powers()[:, 1].flatten() + unc_powers = ufmodel.get_turbine_powers()[:, 1].flatten() + + weights = ufmodel.weights + + np.testing.assert_allclose(np.sum(nom_powers * weights), unc_powers) + + +def test_uncertain_floris_model_setpoints(): + fmodel = FlorisModel(configuration=YAML_INPUT) + ufmodel = UncertainFlorisModel(configuration=YAML_INPUT, wd_sample_points=[-3, 0, 3], wd_std=3) + + fmodel.set( + layout_x=[0, 300], + layout_y=[0, 0], + wind_speeds=[8.0, 8.0, 8.0], + wind_directions=[267.0, 270.0, 273], + turbulence_intensities=[0.06, 0.06, 0.06], + ) + + ufmodel.set( + layout_x=[0, 300], + layout_y=[0, 0], + wind_speeds=[8.0], + wind_directions=[270.0], + turbulence_intensities=[0.06], + ) + weights = ufmodel.weights + + # Check setpoints dimensions are respected and reset_operation works + # Note that fmodel.set() does NOT raise ValueError---an AttributeError is raised only at + # fmodel.run()---whereas ufmodel.set raises ValueError immediately. + # fmodel.set(yaw_angles=np.array([[0.0, 0.0]])) + # with pytest.raises(AttributeError): + # fmodel.run() + # with pytest.raises(ValueError): + # ufmodel.set(yaw_angles=np.array([[0.0, 0.0]])) + + fmodel.set(yaw_angles=np.array([[20.0, 0.0], [20.0, 0.0], [20.0, 0.0]])) + fmodel.run() + nom_powers = fmodel.get_turbine_powers()[:, 1].flatten() + + ufmodel.set(yaw_angles=np.array([[20.0, 0.0]])) + ufmodel.run() + unc_powers = ufmodel.get_turbine_powers()[:, 1].flatten() + + np.testing.assert_allclose(np.sum(nom_powers * weights), unc_powers) + + # Drop yaw setpoints and rerun + fmodel.reset_operation() + fmodel.run() + nom_powers = fmodel.get_turbine_powers()[:, 1].flatten() + + ufmodel.reset_operation() + ufmodel.run() + unc_powers = ufmodel.get_turbine_powers()[:, 1].flatten() + + np.testing.assert_allclose(np.sum(nom_powers * weights), unc_powers) + + +def test_get_powers_with_wind_data(): + ufmodel = UncertainFlorisModel(configuration=YAML_INPUT) + + wind_speeds = np.array([8.0, 10.0, 12.0, 8.0, 10.0, 12.0]) + wind_directions = np.array([270.0, 270.0, 270.0, 280.0, 280.0, 280.0]) + turbulence_intensities = 0.06 * np.ones_like(wind_speeds) + + ufmodel.set( + wind_speeds=wind_speeds, + wind_directions=wind_directions, + turbulence_intensities=turbulence_intensities, + layout_x=[0, 1000, 2000, 3000], + layout_y=[0, 0, 0, 0] + ) + ufmodel.run() + farm_power_simple = ufmodel.get_farm_power() + + # Now declare a WindRose with 2 wind directions and 3 wind speeds + # uniform TI and frequency + wind_rose = WindRose( + wind_directions=np.unique(wind_directions), + wind_speeds=np.unique(wind_speeds), + ti_table=0.06 + ) + + # Set this wind rose, run + ufmodel.set(wind_data=wind_rose) + ufmodel.run() + + farm_power_windrose = ufmodel.get_farm_power() + + # Check dimensions and that the farm power is the sum of the turbine powers + assert farm_power_windrose.shape == (2, 3) + assert np.allclose(farm_power_windrose, ufmodel.get_turbine_powers().sum(axis=2)) + + # Check that simple and windrose powers are consistent + assert np.allclose(farm_power_simple.reshape(2, 3), farm_power_windrose) + assert np.allclose(farm_power_simple, farm_power_windrose.flatten()) + + # Test that if the last turbine's weight is set to 0, the farm power is the same as the + # sum of the first 3 turbines + turbine_weights = np.array([1.0, 1.0, 1.0, 0.0]) + farm_power_weighted = ufmodel.get_farm_power(turbine_weights=turbine_weights) + + assert np.allclose(farm_power_weighted, ufmodel.get_turbine_powers()[:,:,:-1].sum(axis=2)) + +def test_approx_floris_model(): + + afmodel = ApproxFlorisModel(configuration=YAML_INPUT, wd_resolution=1.0) + + time_series = TimeSeries( + wind_directions = np.array([270.0, 270.1,271.0, 271.1]), + wind_speeds=8.0, + turbulence_intensities=0.06) + + afmodel.set(layout_x = np.array([0, 500]), layout_y = np.array([0, 0]), wind_data = time_series) + + # Test that 0th and 1th values are the same, as are the 2nd and 3rd + afmodel.run() + power = afmodel.get_farm_power() + np.testing.assert_almost_equal(power[0], power[1]) + np.testing.assert_almost_equal(power[2], power[3]) + + # Test with wind direction and wind speed varying + afmodel = ApproxFlorisModel(configuration=YAML_INPUT, wd_resolution=1.0, ws_resolution=1.0) + time_series = TimeSeries( + wind_directions = np.array([270.0, 270.1,271.0, 271.1]), + wind_speeds=np.array([8.0, 8.1, 8.0, 9.0]), + turbulence_intensities=0.06) + + afmodel.set(layout_x = np.array([0, 500]), layout_y = np.array([0, 0]), wind_data = time_series) + afmodel.run() + + # In this case the 0th and 1st should be the same, but not the 2nd and 3rd + power = afmodel.get_farm_power() + np.testing.assert_almost_equal(power[0], power[1]) + assert not np.allclose(power[2], power[3]) diff --git a/tests/utilities_unit_test.py b/tests/utilities_unit_test.py index 4ec7e9d3c..f58ca5c64 100644 --- a/tests/utilities_unit_test.py +++ b/tests/utilities_unit_test.py @@ -1,19 +1,5 @@ -# Copyright 2021 NREL - -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - - +from pathlib import Path import attr import numpy as np @@ -21,6 +7,9 @@ from floris.utilities import ( cosd, + nested_get, + nested_set, + reverse_rotate_coordinates_rel_west, rotate_coordinates_rel_west, sind, tand, @@ -35,6 +24,10 @@ ) +TEST_DATA = Path(__file__).resolve().parent / "data" +YAML_INPUT = TEST_DATA / "input_full.yaml" + + def test_cosd(): assert pytest.approx(cosd(0.0)) == 1.0 assert pytest.approx(cosd(90.0)) == 0.0 @@ -86,8 +79,7 @@ def test_wind_delta(): def test_rotate_coordinates_rel_west(): - - coordinates = np.array([ [x,y,z] for x,y,z in zip(X_COORDS, Y_COORDS, Z_COORDS)]) + coordinates = np.array(list(zip(X_COORDS, Y_COORDS, Z_COORDS))) # For 270, the coordinates should not change. wind_directions = np.array([270.0]) @@ -96,9 +88,13 @@ def test_rotate_coordinates_rel_west(): coordinates ) - np.testing.assert_array_equal( X_COORDS, x_rotated[0,0] ) - np.testing.assert_array_equal( Y_COORDS, y_rotated[0,0] ) - np.testing.assert_array_equal( Z_COORDS, z_rotated[0,0] ) + # Test that x_rotated has 2 dimensions + np.testing.assert_equal(np.ndim(x_rotated), 2) + + # Assert the rotating to 270 doesn't change coordinates + np.testing.assert_array_equal(X_COORDS, x_rotated[0]) + np.testing.assert_array_equal(Y_COORDS, y_rotated[0]) + np.testing.assert_array_equal(Z_COORDS, z_rotated[0]) # For 360, the coordinates should be rotated 90 degrees counter clockwise # from looking fown at the wind farm from above. The series of turbines @@ -114,18 +110,80 @@ def test_rotate_coordinates_rel_west(): wind_directions, coordinates ) - np.testing.assert_almost_equal( Y_COORDS, x_rotated[0,0] - np.min(x_rotated[0,0])) - np.testing.assert_almost_equal( X_COORDS, y_rotated[0,0] - np.min(y_rotated[0,0])) + np.testing.assert_almost_equal(Y_COORDS, x_rotated[0] - np.min(x_rotated[0])) + np.testing.assert_almost_equal(X_COORDS, y_rotated[0] - np.min(y_rotated[0])) np.testing.assert_almost_equal( Z_COORDS + np.min(Z_COORDS), - z_rotated[0,0] + np.min(z_rotated[0,0]) + z_rotated[0] + np.min(z_rotated[0]) ) wind_directions = np.array([90.0]) x_rotated, y_rotated, z_rotated, _, _ = rotate_coordinates_rel_west( + wind_directions, coordinates + ) + np.testing.assert_almost_equal(X_COORDS[-1:-4:-1], x_rotated[0]) + np.testing.assert_almost_equal(Y_COORDS, y_rotated[0]) + np.testing.assert_almost_equal(Z_COORDS, z_rotated[0]) + + +def test_reverse_rotate_coordinates_rel_west(): + # Test that appplying the rotation, and then the reverse produces the original coordinates + + # Test the reverse rotation + coordinates = np.array([[x, y, z] for x, y, z in zip(X_COORDS, Y_COORDS, Z_COORDS)]) + + # Rotate to 360 (as in above function) + wind_directions = np.array([360.0]) + + # Get the rotated coordinates + ( + x_rotated, + y_rotated, + z_rotated, + x_center_of_rotation, + y_center_of_rotation, + ) = rotate_coordinates_rel_west(wind_directions, coordinates) + + # Go up to 4 dimensions (reverse function is expecting grid) + grid_x = x_rotated[:, :, None, None] + grid_y = y_rotated[:, :, None, None] + grid_z = z_rotated[:, :, None, None] + + # Perform reverse rotation + grid_x_reversed, grid_y_reversed, grid_z_reversed = reverse_rotate_coordinates_rel_west( wind_directions, - coordinates + grid_x, + grid_y, + grid_z, + x_center_of_rotation, + y_center_of_rotation, ) - np.testing.assert_almost_equal( X_COORDS[-1:-4:-1], x_rotated[0,0] ) - np.testing.assert_almost_equal( Y_COORDS, y_rotated[0,0] ) - np.testing.assert_almost_equal( Z_COORDS, z_rotated[0,0] ) + + np.testing.assert_almost_equal(grid_x_reversed.squeeze(), coordinates[:,0].squeeze()) + np.testing.assert_almost_equal(grid_y_reversed.squeeze(), coordinates[:,1].squeeze()) + np.testing.assert_almost_equal(grid_z_reversed.squeeze(), coordinates[:,2].squeeze()) + + +def test_nested_get(): + example_dict = { + 'a': { + 'b': { + 'c': 10 + } + } + } + + assert nested_get(example_dict, ['a', 'b', 'c']) == 10 + + +def test_nested_set(): + example_dict = { + 'a': { + 'b': { + 'c': 10 + } + } + } + + nested_set(example_dict, ['a', 'b', 'c'], 20) + assert nested_get(example_dict, ['a', 'b', 'c']) == 20 diff --git a/tests/wake_unit_tests.py b/tests/wake_unit_tests.py index 69bbcf2f5..90f66057e 100644 --- a/tests/wake_unit_tests.py +++ b/tests/wake_unit_tests.py @@ -1,18 +1,5 @@ -# Copyright 2021 NREL -# Licensed under the Apache License, Version 2.0 (the "License"); you may not -# use this file except in compliance with the License. You may obtain a copy of -# the License at http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations under -# the License. - -# See https://floris.readthedocs.io for documentation - -from floris.simulation import WakeModelManager +from floris.core import WakeModelManager from tests.conftest import SampleInputs diff --git a/tests/wind_data_integration_test.py b/tests/wind_data_integration_test.py new file mode 100644 index 000000000..b2104abb2 --- /dev/null +++ b/tests/wind_data_integration_test.py @@ -0,0 +1,804 @@ +import copy +from pathlib import Path + +import numpy as np +import pytest + +from floris import ( + TimeSeries, + WindRose, + WindTIRose, +) +from floris.wind_data import WindDataBase + + +TEST_DATA = Path(__file__).resolve().parent / "data" + + +class ChildClassTest(WindDataBase): + def __init__(self): + pass + + +def test_bad_inheritance(): + """ + Verifies that a child class of WindDataBase must implement the unpack method. + """ + test_class = ChildClassTest() + with pytest.raises(NotImplementedError): + test_class.unpack() + + +def test_time_series_instantiation(): + wind_directions = np.array([270, 280, 290]) + wind_speeds = np.array([5, 5, 5]) + + # Test that TI require + with pytest.raises(TypeError): + TimeSeries(wind_directions, wind_speeds) + + # Test that passing a float TI returns a list of length matched to wind directions + time_series = TimeSeries(wind_directions, wind_speeds, turbulence_intensities=0.06) + np.testing.assert_allclose(time_series.turbulence_intensities, [0.06, 0.06, 0.06]) + + # Test that passing floats to wind directions and wind speeds returns a list of + # length turbulence intensities + time_series = TimeSeries(270.0, 8.0, turbulence_intensities=np.array([0.06, 0.07, 0.08])) + np.testing.assert_allclose(time_series.wind_directions, [270, 270, 270]) + np.testing.assert_allclose(time_series.wind_speeds, [8, 8, 8]) + + # Test that passing in all floats raises a type error + with pytest.raises(TypeError): + TimeSeries(270.0, 8.0, 0.06) + + # Test casting of both wind speeds and TI + time_series = TimeSeries(wind_directions, 8.0, 0.06) + np.testing.assert_allclose(time_series.wind_speeds, [8, 8, 8]) + np.testing.assert_allclose(time_series.turbulence_intensities, [0.06, 0.06, 0.06]) + + # Test the passing in a 1D array of turbulence intensities which is longer than the + # wind directions and wind speeds raises an error + with pytest.raises(ValueError): + TimeSeries( + wind_directions, wind_speeds, turbulence_intensities=np.array([0.06, 0.07, 0.08, 0.09]) + ) + + +def test_wind_rose_init(): + """ + The wind directions and wind speeds can have any length, but the frequency + array must have shape (n wind directions, n wind speeds) + """ + wind_directions = np.array([270, 280, 290]) + wind_speeds = np.array([6, 7]) + + # Pass ti_table in as a single float and confirm it is broadcast to the correct shape + wind_rose = WindRose(wind_directions, wind_speeds, ti_table=0.06) + np.testing.assert_allclose( + wind_rose.ti_table, np.array([[0.06, 0.06], [0.06, 0.06], [0.06, 0.06]]) + ) + + # Pass ti_table in as a 2D array and confirm it is used as is + ti_table = np.array([[0.06, 0.06], [0.06, 0.06], [0.06, 0.06]]) + wind_rose = WindRose(wind_directions, wind_speeds, ti_table=ti_table) + np.testing.assert_allclose(wind_rose.ti_table, ti_table) + + # Confirm passing in a ti_table that is 1D raises an error + with pytest.raises(ValueError): + WindRose( + wind_directions, wind_speeds, ti_table=np.array([0.06, 0.06, 0.06, 0.06, 0.06, 0.06]) + ) + + # Confirm passing in a ti_table that is wrong dimensions raises an error + with pytest.raises(ValueError): + WindRose(wind_directions, wind_speeds, ti_table=np.ones((3, 3))) + + # This should be ok since the frequency array shape matches the wind directions + # and wind speeds + _ = WindRose(wind_directions, wind_speeds, ti_table=0.06, freq_table=np.ones((3, 2))) + + # This should raise an error since the frequency array shape does not + # match the wind directions and wind speeds + with pytest.raises(ValueError): + WindRose(wind_directions, wind_speeds, 0.06, np.ones((3, 3))) + + +def test_wind_rose_grid(): + wind_directions = np.array([270, 280, 290]) + wind_speeds = np.array([6, 7]) + + wind_rose = WindRose(wind_directions, wind_speeds, 0.06) + + # Wind direction grid has the same dimensions as the frequency table + assert wind_rose.wd_grid.shape == wind_rose.freq_table.shape + + # Flattening process occurs wd first + # This is each wind direction for each wind speed: + np.testing.assert_allclose(wind_rose.wd_flat, [270, 270, 280, 280, 290, 290]) + + +def test_wind_rose_unpack(): + wind_directions = np.array([270, 280, 290]) + wind_speeds = np.array([6, 7]) + freq_table = np.array([[1.0, 0.0], [0, 1.0], [0, 0]]) + + # First test using default assumption only non-zero frequency cases computed + wind_rose = WindRose(wind_directions, wind_speeds, 0.06, freq_table) + + ( + wind_directions_unpack, + wind_speeds_unpack, + ti_table_unpack, + freq_table_unpack, + value_table_unpack, + heterogeneous_inflow_config, + ) = wind_rose.unpack() + + # Given the above frequency table with zeros for a few elements, + # we expect only the (270 deg, 6 m/s) and (280 deg, 7 m/s) rows + np.testing.assert_allclose(wind_directions_unpack, [270, 280]) + np.testing.assert_allclose(wind_speeds_unpack, [6, 7]) + np.testing.assert_allclose(ti_table_unpack, [0.06, 0.06]) + np.testing.assert_allclose(freq_table_unpack, [0.5, 0.5]) + + # In this case n_findex is the length of the wind combinations that are + # non-zero frequency + assert wind_rose.n_findex == 2 + + # Now test computing 0-freq cases too + wind_rose = WindRose( + wind_directions, wind_speeds, freq_table, compute_zero_freq_occurrence=True + ) + + ( + wind_directions_unpack, + wind_speeds_unpack, + ti_table_unpack, + freq_table_unpack, + value_table_unpack, + heterogeneous_inflow_config, + ) = wind_rose.unpack() + + # Expect now to compute all combinations + np.testing.assert_allclose(wind_directions_unpack, [270, 270, 280, 280, 290, 290]) + + # In this case n_findex is the total number of wind combinations + assert wind_rose.n_findex == 6 + + +def test_unpack_for_reinitialize(): + wind_directions = np.array([270, 280, 290]) + wind_speeds = np.array([6, 7]) + freq_table = np.array([[1.0, 0.0], [0, 1.0], [0, 0]]) + + # First test using default assumption only non-zero frequency cases computed + wind_rose = WindRose(wind_directions, wind_speeds, 0.06, freq_table) + + ( + wind_directions_unpack, + wind_speeds_unpack, + ti_table_unpack, + heterogeneous_inflow_config, + ) = wind_rose.unpack_for_reinitialize() + + # Given the above frequency table, would only expect the + # (270 deg, 6 m/s) and (280 deg, 7 m/s) rows + np.testing.assert_allclose(wind_directions_unpack, [270, 280]) + np.testing.assert_allclose(wind_speeds_unpack, [6, 7]) + np.testing.assert_allclose(ti_table_unpack, [0.06, 0.06]) + + +def test_wind_rose_aggregate(): + wind_directions = np.array([0, 2, 4, 6, 8, 10]) + wind_speeds = np.array([8]) + freq_table = np.array([[1.0], [1.0], [1.0], [1.0], [1.0], [1.0]]) + + wind_rose = WindRose(wind_directions, wind_speeds, ti_table=0.06, freq_table=freq_table) + + # Test that aggregating without specifying new steps returns the same + wind_rose_aggregate = wind_rose.aggregate(inplace=False) + + np.testing.assert_allclose(wind_rose.wind_directions, wind_rose_aggregate.wind_directions) + np.testing.assert_allclose(wind_rose.wind_speeds, wind_rose_aggregate.wind_speeds) + np.testing.assert_allclose(wind_rose.freq_table_flat, wind_rose_aggregate.freq_table_flat) + + # Now test aggregating the wind direction to 5 deg bins + wind_rose_aggregate = wind_rose.aggregate(wd_step=5.0, inplace=False) + np.testing.assert_allclose(wind_rose_aggregate.wind_directions, [0, 5, 10]) + np.testing.assert_allclose(wind_rose_aggregate.freq_table_flat, [2 / 6, 2 / 6, 2 / 6]) + + # Test that the default inplace behavior is to modifies the original object as expected + wind_rose_2 = copy.deepcopy(wind_rose) + wind_rose_2.aggregate(inplace=True) + np.testing.assert_allclose(wind_rose.wind_directions, wind_rose_2.wind_directions) + np.testing.assert_allclose(wind_rose.wind_speeds, wind_rose_2.wind_speeds) + np.testing.assert_allclose(wind_rose.freq_table_flat, wind_rose_2.freq_table_flat) + + wind_rose_2.aggregate(wd_step=5.0, inplace=True) + np.testing.assert_allclose(wind_rose_aggregate.wind_directions, wind_rose_2.wind_directions) + np.testing.assert_allclose(wind_rose_aggregate.wind_speeds, wind_rose_2.wind_speeds) + np.testing.assert_allclose(wind_rose_aggregate.freq_table_flat, wind_rose_2.freq_table_flat) + + +def test_resample_by_interpolation(): + wind_directions = np.array([0, 2, 4, 6, 8, 10]) + wind_speeds = np.array([8, 10]) + freq_table = np.ones((6, 2)) + freq_table = freq_table / np.sum(freq_table) + + wind_rose = WindRose(wind_directions, wind_speeds, ti_table=0.06, freq_table=freq_table) + + # Test that interpolating without specifying new steps returns the same + wind_rose_resample = wind_rose.resample_by_interpolation(inplace=False) + + np.testing.assert_allclose(wind_rose.wind_directions, wind_rose_resample.wind_directions) + np.testing.assert_allclose(wind_rose.wind_speeds, wind_rose_resample.wind_speeds) + np.testing.assert_allclose(wind_rose.freq_table_flat, wind_rose_resample.freq_table_flat) + + # Test interpolating TI along the wind direction axis + wind_directions = np.array([270, 280]) + wind_speeds = np.array([6, 7]) + ti_table = np.array([[0.06, 0.06], [0.07, 0.07]]) + wind_rose = WindRose(wind_directions, wind_speeds, ti_table=ti_table) + + wind_rose_resample = wind_rose.resample_by_interpolation( + wd_step=5.0, ws_step=1.0, inplace=False + ) + + # Check that the resample ti_table is correct + np.testing.assert_allclose(wind_rose_resample.wind_directions, [270, 275, 280]) + np.testing.assert_allclose(wind_rose_resample.wind_speeds, [6, 7]) + np.testing.assert_allclose( + wind_rose_resample.ti_table, np.array([[0.06, 0.06], [0.065, 0.065], [0.07, 0.07]]) + ) + + # Test interpolating frequency along the wind speed axis + freq_table = np.array([[1 / 6, 2 / 6], [1 / 6, 2 / 6]]) + wind_rose = WindRose(wind_directions, wind_speeds, ti_table=0.06, freq_table=freq_table) + + wind_rose_resample = wind_rose.resample_by_interpolation( + wd_step=10.0, ws_step=0.5, inplace=False + ) + + freq_table_expected = np.array([[1 / 6, 1.5 / 6, 2 / 6], [1 / 6, 1.5 / 6, 2 / 6]]) + freq_table_expected = freq_table_expected / np.sum(freq_table_expected) + + # Check that the resample freq_table is correct + np.testing.assert_allclose(wind_rose_resample.wind_directions, [270, 280]) + np.testing.assert_allclose(wind_rose_resample.wind_speeds, [6, 6.5, 7]) + np.testing.assert_allclose(wind_rose_resample.freq_table, freq_table_expected) + + # Test resampling both wind speed and wind directions + ti_table = np.array([[0.01, 0.02], [0.03, 0.04]]) + wind_rose = WindRose(wind_directions, wind_speeds, ti_table=ti_table) + wind_rose_resample = wind_rose.resample_by_interpolation( + wd_step=5.0, ws_step=0.5, inplace=False + ) + + # Check that the resample ti_table is correct + ti_table_expected = np.array([[0.01, 0.015, 0.02], [0.02, 0.025, 0.03], [0.03, 0.035, 0.04]]) + np.testing.assert_allclose(wind_rose_resample.wind_directions, [270, 275, 280]) + np.testing.assert_allclose(wind_rose_resample.wind_speeds, [6, 6.5, 7]) + np.testing.assert_allclose(wind_rose_resample.ti_table, ti_table_expected) + + # Test resampling wind directions when wind speeds is 1D + wind_directions = np.array([270, 280]) + wind_speeds = np.array([6]) + ti_table = np.array([[0.06], [0.07]]) + wind_rose = WindRose(wind_directions, wind_speeds, ti_table=ti_table) + wind_rose_resample = wind_rose.resample_by_interpolation(wd_step=5.0, inplace=False) + + # Check that the resample ti_table is correct + np.testing.assert_allclose(wind_rose_resample.wind_directions, [270, 275, 280]) + np.testing.assert_allclose(wind_rose_resample.wind_speeds, [6]) + np.testing.assert_allclose(wind_rose_resample.ti_table, np.array([[0.06], [0.065], [0.07]])) + + # Test resampling wind speeds when wind directions is 1D + wind_directions = np.array([270]) + wind_speeds = np.array([6, 7]) + ti_table = np.array([[0.06, 0.07]]) + wind_rose = WindRose(wind_directions, wind_speeds, ti_table=ti_table) + wind_rose_resample = wind_rose.resample_by_interpolation(ws_step=0.5, inplace=False) + + # Check that the resample ti_table is correct + np.testing.assert_allclose(wind_rose_resample.wind_directions, [270]) + np.testing.assert_allclose(wind_rose_resample.wind_speeds, [6, 6.5, 7]) + np.testing.assert_allclose(wind_rose_resample.ti_table, np.array([[0.06, 0.065, 0.07]])) + + +def test_resample_by_interpolation_ti_rose(): + wind_directions = np.array([0, 2, 4, 6, 8, 10]) + wind_speeds = np.array([8, 10]) + turbulence_intensities = np.array([0.05, 0.1]) + freq_table = np.ones((6, 2, 2)) + freq_table = freq_table / np.sum(freq_table) + + wind_ti_rose = WindTIRose( + wind_directions, wind_speeds, turbulence_intensities, freq_table=freq_table + ) + + # Test that interpolating without specifying new steps returns the same + wind_ti_rose_resample = wind_ti_rose.resample_by_interpolation(inplace=False) + + np.testing.assert_allclose(wind_ti_rose.wind_directions, wind_ti_rose_resample.wind_directions) + np.testing.assert_allclose(wind_ti_rose.wind_speeds, wind_ti_rose_resample.wind_speeds) + np.testing.assert_allclose( + wind_ti_rose.turbulence_intensities, wind_ti_rose_resample.turbulence_intensities + ) + np.testing.assert_allclose(wind_ti_rose.freq_table_flat, wind_ti_rose_resample.freq_table_flat) + + # Test interpolating frequency along the wind speed axis + wind_directions = np.array([270, 280]) + wind_speeds = np.array([6, 7]) + turbulence_intensities = np.array([0.05, 0.1]) + freq_table = np.ones((2, 2, 2)) + freq_table[:, 1, :] = 2.0 + freq_table = freq_table / np.sum(freq_table) + wind_ti_rose = WindTIRose( + wind_directions, wind_speeds, turbulence_intensities, freq_table=freq_table + ) + + wind_ti_rose_resample = wind_ti_rose.resample_by_interpolation( + wd_step=10.0, ws_step=0.5, ti_step=0.05, inplace=False + ) + + freq_table_expected = np.ones((2, 3, 2)) + freq_table_expected[:, 2, :] = 2.0 + freq_table_expected[:, 1, :] = 1.5 + freq_table_expected = freq_table_expected / np.sum(freq_table_expected) + + # Check that the resample freq_table is correct + np.testing.assert_allclose(wind_ti_rose_resample.wind_directions, [270, 280]) + np.testing.assert_allclose(wind_ti_rose_resample.wind_speeds, [6, 6.5, 7]) + np.testing.assert_allclose(wind_ti_rose_resample.turbulence_intensities, [0.05, 0.1]) + np.testing.assert_allclose(wind_ti_rose_resample.freq_table, freq_table_expected) + + # # Test resampling wind directions when wind speeds and TI are 1D + wind_directions = np.array([270, 280]) + wind_speeds = np.array([6]) + turbulence_intensities = np.array([0.05]) + freq_table = np.ones((2, 1, 1)) + freq_table[1, :, :] = 2.0 + freq_table = freq_table / np.sum(freq_table) + wind_ti_rose = WindTIRose( + wind_directions, wind_speeds, turbulence_intensities, freq_table=freq_table + ) + wind_ti_rose_resample = wind_ti_rose.resample_by_interpolation(wd_step=5.0, inplace=False) + + excepted_freq_table = np.ones((3, 1, 1)) + excepted_freq_table[1, :, :] = 1.5 + excepted_freq_table[2, :, :] = 2.0 + excepted_freq_table = excepted_freq_table / np.sum(excepted_freq_table) + + # Check that the resample ti_table is correct + np.testing.assert_allclose(wind_ti_rose_resample.wind_directions, [270, 275, 280]) + np.testing.assert_allclose(wind_ti_rose_resample.wind_speeds, [6]) + np.testing.assert_allclose(wind_ti_rose_resample.turbulence_intensities, [0.05]) + np.testing.assert_allclose(wind_ti_rose_resample.freq_table, excepted_freq_table) + + +def test_wrap_wind_directions_near_360(): + wd_step = 5.0 + wd_values = np.array([0, 180, 357, 357.5, 358]) + time_series = TimeSeries(np.array([0]), np.array([0]), 0.06) + + wd_wrapped = time_series._wrap_wind_directions_near_360(wd_values, wd_step) + + expected_result = np.array([0, 180, 357, -wd_step / 2.0, -2.0]) + assert np.allclose(wd_wrapped, expected_result) + + +def test_time_series_to_WindRose(): + # Test just 1 wind speed + wind_directions = np.array([259.8, 260.2, 264.3]) + wind_speeds = np.array([5.0, 5.0, 5.1]) + time_series = TimeSeries(wind_directions, wind_speeds, 0.06) + wind_rose = time_series.to_WindRose(wd_step=2.0, ws_step=1.0) + + # The wind directions should be 260, 262 and 264 because they're binned + # to the nearest 2 deg increment + assert np.allclose(wind_rose.wind_directions, [260, 262, 264]) + + # Freq table should have dimension of 3 wd x 1 ws because the wind speeds + # are all binned to the same value given the `ws_step` size + freq_table = wind_rose.freq_table + assert freq_table.shape[0] == 3 + assert freq_table.shape[1] == 1 + + # The frequencies should [2/3, 0, 1/3] given that 2 of the data points + # fall in the 260 deg bin, 0 in the 262 deg bin and 1 in the 264 deg bin + assert np.allclose(freq_table.squeeze(), [2 / 3, 0, 1 / 3]) + + # Test just 2 wind speeds + wind_directions = np.array([259.8, 260.2, 264.3]) + wind_speeds = np.array([5.0, 5.0, 6.1]) + time_series = TimeSeries(wind_directions, wind_speeds, 0.06) + wind_rose = time_series.to_WindRose(wd_step=2.0, ws_step=1.0) + + # The wind directions should be 260, 262 and 264 + assert np.allclose(wind_rose.wind_directions, [260, 262, 264]) + + # The wind speeds should be 5 and 6 + assert np.allclose(wind_rose.wind_speeds, [5, 6]) + + # Freq table should have dimension of 3 wd x 2 ws + freq_table = wind_rose.freq_table + assert freq_table.shape[0] == 3 + assert freq_table.shape[1] == 2 + + # The frequencies should [2/3, 0, 1/3] + assert freq_table[0, 0] == 2 / 3 + assert freq_table[2, 1] == 1 / 3 + + # The turbulence intensity table should be 0.06 for all bins + ti_table = wind_rose.ti_table + + # Assert that table entires which are not nan are equal to 0.06 + assert np.allclose(ti_table[~np.isnan(ti_table)], 0.06) + + +def test_time_series_to_WindRose_wrapping(): + wind_directions = np.arange(0.0, 360.0, 0.25) + wind_speeds = 8.0 * np.ones_like(wind_directions) + time_series = TimeSeries(wind_directions, wind_speeds, 0.06) + wind_rose = time_series.to_WindRose(wd_step=2.0, ws_step=1.0) + + # Expert for the first bin in this case to be 0, and the final to be 358 + # and both to have equal numbers of points + np.testing.assert_almost_equal(wind_rose.wind_directions[0], 0) + np.testing.assert_almost_equal(wind_rose.wind_directions[-1], 358) + np.testing.assert_almost_equal(wind_rose.freq_table[0, 0], wind_rose.freq_table[-1, 0]) + + +def test_time_series_to_WindRose_with_ti(): + wind_directions = np.array([259.8, 260.2, 260.3, 260.1]) + wind_speeds = np.array([5.0, 5.0, 5.1, 7.2]) + turbulence_intensities = np.array([0.5, 1.0, 1.5, 2.0]) + time_series = TimeSeries( + wind_directions, + wind_speeds, + turbulence_intensities=turbulence_intensities, + ) + wind_rose = time_series.to_WindRose(wd_step=2.0, ws_step=1.0) + + # Turbulence intensity should average to 1 in the 5 m/s bin and 2 in the 7 m/s bin + ti_table = wind_rose.ti_table + np.testing.assert_almost_equal(ti_table[0, 0], 1) + np.testing.assert_almost_equal(ti_table[0, 2], 2) + + # The 6 m/s bin should be empty + freq_table = wind_rose.freq_table + np.testing.assert_almost_equal(freq_table[0, 1], 0) + + +def test_wind_ti_rose_init(): + """ + The wind directions, wind speeds, and turbulence intensities can have any + length, but the frequency array must have shape (n wind directions, + n wind speeds, n turbulence intensities) + """ + wind_directions = np.array([270, 280, 290, 300]) + wind_speeds = np.array([6, 7, 8]) + turbulence_intensities = np.array([0.05, 0.1]) + + # This should be ok + _ = WindTIRose(wind_directions, wind_speeds, turbulence_intensities) + + # This should be ok since the frequency array shape matches the wind directions + # and wind speeds + _ = WindTIRose(wind_directions, wind_speeds, turbulence_intensities, np.ones((4, 3, 2))) + + # This should raise an error since the frequency array shape does not + # match the wind directions and wind speeds + with pytest.raises(ValueError): + WindTIRose(wind_directions, wind_speeds, turbulence_intensities, np.ones((3, 3, 3))) + + +def test_wind_ti_rose_grid(): + wind_directions = np.array([270, 280, 290, 300]) + wind_speeds = np.array([6, 7, 8]) + turbulence_intensities = np.array([0.05, 0.1]) + + wind_rose = WindTIRose(wind_directions, wind_speeds, turbulence_intensities) + + # Wind direction grid has the same dimensions as the frequency table + assert wind_rose.wd_grid.shape == wind_rose.freq_table.shape + + # Flattening process occurs wd first + # This is each wind direction for each wind speed: + np.testing.assert_allclose(wind_rose.wd_flat, 6 * [270] + 6 * [280] + 6 * [290] + 6 * [300]) + + +def test_wind_ti_rose_unpack(): + wind_directions = np.array([270, 280, 290, 300]) + wind_speeds = np.array([6, 7, 8]) + turbulence_intensities = np.array([0.05, 0.1]) + freq_table = np.array( + [ + [[1.0, 0.0], [1.0, 0.0], [0.0, 0.0]], + [[1.0, 0.0], [1.0, 0.0], [0.0, 0.0]], + [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]], + [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]], + ] + ) + + # First test using default assumption only non-zero frequency cases computed + wind_rose = WindTIRose(wind_directions, wind_speeds, turbulence_intensities, freq_table) + + ( + wind_directions_unpack, + wind_speeds_unpack, + turbulence_intensities_unpack, + freq_table_unpack, + value_table_unpack, + heterogeneous_inflow_config, + ) = wind_rose.unpack() + + # Given the above frequency table with zeros for a few elements, + # we expect only combinations of wind directions of 270 and 280 deg, + # wind speeds of 6 and 7 m/s, and a TI of 5% + np.testing.assert_allclose(wind_directions_unpack, [270, 270, 280, 280]) + np.testing.assert_allclose(wind_speeds_unpack, [6, 7, 6, 7]) + np.testing.assert_allclose(turbulence_intensities_unpack, [0.05, 0.05, 0.05, 0.05]) + np.testing.assert_allclose(freq_table_unpack, [0.25, 0.25, 0.25, 0.25]) + + # In this case n_findex is the length of the wind combinations that are + # non-zero frequency + assert wind_rose.n_findex == 4 + + # Now test computing 0-freq cases too + wind_rose = WindTIRose( + wind_directions, + wind_speeds, + turbulence_intensities, + freq_table, + compute_zero_freq_occurrence=True, + ) + + ( + wind_directions_unpack, + wind_speeds_unpack, + turbulence_intensities_unpack, + freq_table_unpack, + value_table_unpack, + heterogeneous_inflow_config, + ) = wind_rose.unpack() + + # Expect now to compute all combinations + np.testing.assert_allclose( + wind_directions_unpack, 6 * [270] + 6 * [280] + 6 * [290] + 6 * [300] + ) + + # In this case n_findex is the total number of wind combinations + assert wind_rose.n_findex == 24 + + +def test_wind_ti_rose_unpack_for_reinitialize(): + wind_directions = np.array([270, 280, 290, 300]) + wind_speeds = np.array([6, 7, 8]) + turbulence_intensities = np.array([0.05, 0.1]) + freq_table = np.array( + [ + [[1.0, 0.0], [1.0, 0.0], [0.0, 0.0]], + [[1.0, 0.0], [1.0, 0.0], [0.0, 0.0]], + [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]], + [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0]], + ] + ) + + # First test using default assumption only non-zero frequency cases computed + wind_rose = WindTIRose(wind_directions, wind_speeds, turbulence_intensities, freq_table) + + ( + wind_directions_unpack, + wind_speeds_unpack, + turbulence_intensities_unpack, + heterogeneous_inflow_config, + ) = wind_rose.unpack_for_reinitialize() + + # Given the above frequency table with zeros for a few elements, + # we expect only combinations of wind directions of 270 and 280 deg, + # wind speeds of 6 and 7 m/s, and a TI of 5% + np.testing.assert_allclose(wind_directions_unpack, [270, 270, 280, 280]) + np.testing.assert_allclose(wind_speeds_unpack, [6, 7, 6, 7]) + np.testing.assert_allclose(turbulence_intensities_unpack, [0.05, 0.05, 0.05, 0.05]) + + +def test_wind_ti_rose_aggregate(): + wind_directions = np.array([0, 2, 4, 6, 8, 10]) + wind_speeds = np.array([7, 8]) + turbulence_intensities = np.array([0.02, 0.04, 0.06, 0.08, 0.1]) + freq_table = np.ones((6, 2, 5)) + + wind_rose = WindTIRose(wind_directions, wind_speeds, turbulence_intensities, freq_table) + + # Test that resampling with a new step size returns the same + wind_rose_aggregate = wind_rose.aggregate() + + np.testing.assert_allclose(wind_rose.wind_directions, wind_rose_aggregate.wind_directions) + np.testing.assert_allclose(wind_rose.wind_speeds, wind_rose_aggregate.wind_speeds) + np.testing.assert_allclose( + wind_rose.turbulence_intensities, wind_rose_aggregate.turbulence_intensities + ) + np.testing.assert_allclose(wind_rose.freq_table_flat, wind_rose_aggregate.freq_table_flat) + + # Now test resampling the turbulence intensities to 4% bins + wind_rose_aggregate = wind_rose.aggregate(ti_step=0.04) + np.testing.assert_allclose(wind_rose_aggregate.turbulence_intensities, [0.04, 0.08, 0.12]) + np.testing.assert_allclose( + wind_rose_aggregate.freq_table_flat, (1 / 60) * np.array(12 * [2, 2, 1]) + ) + + # Test tha that inplace behavior is to modify the original object as expected + wind_rose_2 = copy.deepcopy(wind_rose) + wind_rose_2.aggregate(inplace=True) + np.testing.assert_allclose(wind_rose.wind_directions, wind_rose_2.wind_directions) + np.testing.assert_allclose(wind_rose.wind_speeds, wind_rose_2.wind_speeds) + np.testing.assert_allclose(wind_rose.turbulence_intensities, wind_rose_2.turbulence_intensities) + + wind_rose_2.aggregate(ti_step=0.04, inplace=True) + np.testing.assert_allclose( + wind_rose_aggregate.turbulence_intensities, wind_rose_2.turbulence_intensities + ) + np.testing.assert_allclose(wind_rose_aggregate.freq_table_flat, wind_rose_2.freq_table_flat) + + +def test_time_series_to_WindTIRose(): + wind_directions = np.array([259.8, 260.2, 260.3, 260.1]) + wind_speeds = np.array([5.0, 5.0, 5.1, 7.2]) + turbulence_intensities = np.array([0.05, 0.1, 0.15, 0.2]) + time_series = TimeSeries( + wind_directions, + wind_speeds, + turbulence_intensities=turbulence_intensities, + ) + wind_rose = time_series.to_WindTIRose(wd_step=2.0, ws_step=1.0, ti_step=0.1) + + # The binning should result in turbulence intensity bins of 0.1 and 0.2 + tis_windrose = wind_rose.turbulence_intensities + np.testing.assert_almost_equal(tis_windrose, [0.1, 0.2]) + + # The 6 m/s bin should be empty + freq_table = wind_rose.freq_table + np.testing.assert_almost_equal(freq_table[0, 1, :], [0, 0]) + + +def test_get_speed_multipliers_by_wd(): + heterogeneous_inflow_config_by_wd = { + "speed_multipliers": np.array( + [ + [1.0, 1.1, 1.2], + [1.1, 1.1, 1.1], + [1.3, 1.4, 1.5], + ] + ), + "wind_directions": np.array([0, 90, 270]), + } + + # Check for correctness + wind_directions = np.array([240, 80, 15]) + expected_output = np.array([[1.3, 1.4, 1.5], [1.1, 1.1, 1.1], [1.0, 1.1, 1.2]]) + wind_data = WindDataBase() + result = wind_data.get_speed_multipliers_by_wd( + heterogeneous_inflow_config_by_wd, wind_directions + ) + assert np.allclose(result, expected_output) + + # Confirm wrapping behavior + wind_directions = np.array([350, 10]) + expected_output = np.array([[1.0, 1.1, 1.2], [1.0, 1.1, 1.2]]) + result = wind_data.get_speed_multipliers_by_wd( + heterogeneous_inflow_config_by_wd, wind_directions + ) + assert np.allclose(result, expected_output) + + # Confirm can expand the result to match wind directions + wind_directions = np.arange(0.0, 360.0, 10.0) + num_wd = len(wind_directions) + result = wind_data.get_speed_multipliers_by_wd( + heterogeneous_inflow_config_by_wd, wind_directions + ) + assert result.shape[0] == num_wd + + +def test_gen_heterogeneous_inflow_config(): + wind_directions = np.array([259.8, 260.2, 260.3, 260.1, 270.0]) + wind_speeds = 8 + turbulence_intensities = 0.06 + + heterogeneous_inflow_config_by_wd = { + "speed_multipliers": np.array( + [ + [0.9, 0.9], + [1.0, 1.0], + [1.1, 1.2], + ] + ), + "wind_directions": np.array([250, 260, 270]), + "x": np.array([0, 1000]), + "y": np.array([0, 0]), + } + + time_series = TimeSeries( + wind_directions, + wind_speeds, + turbulence_intensities=turbulence_intensities, + heterogeneous_inflow_config_by_wd=heterogeneous_inflow_config_by_wd, + ) + + (_, _, _, _, _, heterogeneous_inflow_config) = time_series.unpack() + + expected_result = np.array([[1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.0, 1.0], [1.1, 1.2]]) + np.testing.assert_allclose(heterogeneous_inflow_config["speed_multipliers"], expected_result) + np.testing.assert_allclose( + heterogeneous_inflow_config["x"], heterogeneous_inflow_config_by_wd["x"] + ) + + +def test_read_csv_long(): + # Read in the wind rose data from the csv file + + # First confirm that the data raises value error when wrong columns passed + with pytest.raises(ValueError): + wind_rose = WindRose.read_csv_long(TEST_DATA / "wind_rose.csv") + + # Since TI not specified in table, not giving a fixed TI should raise an error + with pytest.raises(ValueError): + wind_rose = WindRose.read_csv_long( + TEST_DATA / "wind_rose.csv", wd_col="wd", ws_col="ws", freq_col="freq_val" + ) + + # Now read in with correct columns + wind_rose = WindRose.read_csv_long( + TEST_DATA / "wind_rose.csv", + wd_col="wd", + ws_col="ws", + freq_col="freq_val", + ti_col_or_value=0.06, + ) + + # Confirm that data read in correctly, and the missing wd/ws bins are filled with zeros + expected_result = np.array([[0.25, 0.25], [0.5, 0]]) + np.testing.assert_allclose(wind_rose.freq_table, expected_result) + + # Confirm expected wind direction and wind speed values + expected_result = np.array([270, 280]) + np.testing.assert_allclose(wind_rose.wind_directions, expected_result) + + expected_result = np.array([8, 9]) + np.testing.assert_allclose(wind_rose.wind_speeds, expected_result) + + # Confirm expected TI values + expected_result = np.array([[0.06, 0.06], [0.06, np.nan]]) + + # Confirm all elements which aren't nan are close + np.testing.assert_allclose( + wind_rose.ti_table[~np.isnan(wind_rose.ti_table)], + expected_result[~np.isnan(expected_result)], + ) + + +def test_read_csv_long_ti(): + # Read in the wind rose data from the csv file + + # Now read in with correct columns + wind_ti_rose = WindTIRose.read_csv_long( + TEST_DATA / "wind_ti_rose.csv", + wd_col="wd", + ws_col="ws", + ti_col="ti", + freq_col="freq_val", + ) + + # Confirm the shape of the frequency table + assert wind_ti_rose.freq_table.shape == (2, 2, 2) + + # Confirm expected wind direction and wind speed values + expected_result = np.array([270, 280]) + np.testing.assert_allclose(wind_ti_rose.wind_directions, expected_result) + + expected_result = np.array([8, 9]) + np.testing.assert_allclose(wind_ti_rose.wind_speeds, expected_result) + + expected_result = np.array([0.06, 0.07]) + np.testing.assert_allclose(wind_ti_rose.turbulence_intensities, expected_result)