Adding FLOWERS to aero models, take 2

.coveragerc

@@ -1,5 +1,7 @@
 [run]
-omit = 
+omit =
     ard/utils/test_utils.py
     ard/farm_aero/placeholder.py
-
+    flowers/visualization.py
+    flowers/optimization/optimization_interface.py
+    flowers/optimization/model_interface.py

.github/workflows/python-tests-consolidated.yaml

@@ -46,8 +46,8 @@ jobs:
       run: |
         pip install .[dev]
 
-  test-unit:
-    name: Run unit tests
+  test-ard-unit:
+    name: Run Ard unit tests
     needs: setup-install
     strategy:
       matrix:
@@ -86,9 +86,9 @@ jobs:
       run: |
         pytest --cov=ard --cov-fail-under=80 test/ard/unit
 
-  test-system:
-    name: Run system tests
-    needs: test-unit
+  test-ard-system:
+    name: Run Ard system tests
+    needs: test-ard-unit
     strategy:
       matrix:
         python-version: [3.12] # ["3.10", "3.11", "3.12", "3.13"]
@@ -127,9 +127,90 @@ jobs:
         pytest --cov=ard --cov-fail-under=50 test/ard/system
         # pytest --cov=ard --cov-fail-under=80 test/ard/system
 
+  test-flowers-unit:
+    name: Run FLOWERS unit tests
+    needs: setup-install
+    strategy:
+      matrix:
+        python-version: [3.12] # ["3.10", "3.11", "3.12", "3.13"]
+        os: [macos-latest, ubuntu-latest, windows-latest]
+        include:
+        - os: ubuntu-latest
+          path: ~/.cache/pip
+        - os: macos-latest
+          path: ~/Library/Caches/pip
+        - os: windows-latest
+          path: ~\AppData\Local\pip\Cache
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Get cache dependencies
+      id: cache
+      uses: actions/cache@v4
+      with:
+        path: ${{ matrix.path }}
+        key: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }}
+        restore-keys:
+          ${{ runner.os }}-pip-
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+    - name: Install Ard
+      run: |
+        pip install .[dev]
+    - name: Run unit tests with coverage
+      run: |
+        pytest --cov=flowers --cov-fail-under=80 test/flowers/unit
+
+  test-flowers-system:
+    name: Run FLOWERS system tests
+    needs: test-flowers-unit
+    strategy:
+      matrix:
+        python-version: [3.12] # ["3.10", "3.11", "3.12", "3.13"]
+        os: [macos-latest, ubuntu-latest, windows-latest]
+        include:
+        - os: ubuntu-latest
+          path: ~/.cache/pip
+        - os: macos-latest
+          path: ~/Library/Caches/pip
+        - os: windows-latest
+          path: ~\AppData\Local\pip\Cache
+    runs-on: ${{ matrix.os }}
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Get cache dependencies
+      id: cache
+      uses: actions/cache@v4
+      with:
+        path: ${{ matrix.path }}
+        key: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }}
+        restore-keys:
+          ${{ runner.os }}-pip-
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+    - name: Install Ard
+      run: |
+        pip install .[dev]
+    - name: Run system tests with coverage
+      run: |
+        pytest --cov=flowers --cov-fail-under=50 test/flowers/system
+        # pytest --cov=flowers --cov-fail-under=80 test/flowers/system
+
   find-examples:
     name: Find all examples
-    needs: [test-unit, test-system]
+    needs: [test-ard-unit, test-ard-system, test-flowers-unit, test-flowers-system]
     runs-on: ubuntu-latest
     steps:
     - name: Checkout code
@@ -142,7 +223,7 @@ jobs:
       id: find_scripts
       run: |
         echo "scripts<<EOF" >> $GITHUB_OUTPUT
-        find examples -mindepth 2 -maxdepth 2 -name "*.py" | jq -R -s -c 'split("\n")[:-1]' >> $GITHUB_OUTPUT
+        find examples -mindepth 3 -maxdepth 3 -name "*.py" | jq -R -s -c 'split("\n")[:-1]' >> $GITHUB_OUTPUT
         echo "EOF" >> $GITHUB_OUTPUT
     outputs:
       scripts: ${{ steps.find_scripts.outputs.scripts }}
@@ -207,7 +288,7 @@ jobs:
 
   find-examples_nb:
     name: Find all example notebooks
-    needs: [test-unit, test-system]
+    needs: [test-ard-unit, test-ard-system, test-flowers-unit, test-flowers-system]
     if: needs.find-examples_nb.outputs.scripts != '[]'  # skip empty
     runs-on: ubuntu-latest
     steps:
@@ -221,10 +302,10 @@ jobs:
       id: find_notebooks
       run: |
         echo "scripts<<EOF"
-        find examples -mindepth 2 -maxdepth 2 -name "*.ipynb" | jq -R -s -c 'split("\n")[:-1]'
+        find examples -mindepth 3 -maxdepth 3 -name "*.ipynb" | jq -R -s -c 'split("\n")[:-1]'
         echo "EOF"
         echo "scripts<<EOF" >> $GITHUB_OUTPUT
-        find examples -mindepth 2 -maxdepth 2 -name "*.ipynb" | jq -R -s -c 'split("\n")[:-1]' >> $GITHUB_OUTPUT
+        find examples -mindepth 3 -maxdepth 3 -name "*.ipynb" | jq -R -s -c 'split("\n")[:-1]' >> $GITHUB_OUTPUT
         echo "EOF" >> $GITHUB_OUTPUT
     outputs:
       scripts: ${{ steps.find_notebooks.outputs.scripts }}

.gitignore

@@ -1,5 +1,5 @@
 
-### ARD DEVELOPMENT IGNORES 
+### ARD DEVELOPMENT IGNORES
 
 .vscode
 case_files

ard/farm_aero/flowers.py

@@ -0,0 +1,169 @@
+import os
+
+import numpy as np
+import pandas as pd
+
+from ard.farm_aero.floris import create_FLORIS_turbine_from_windIO
+from flowers import FlowersModel
+
+import ard.farm_aero.templates as templates
+
+
+class FLOWERSAEP(templates.FarmAEPTemplate):
+    """
+    Component class for computing an AEP analysis using FLOWERS.
+
+    A component class that evaluates a series of farm power and associated
+    quantities using FLOWERS with a wind rose to make an AEP estimate. Inherits
+    the interface from `templates.FarmAEPTemplate`.
+
+    Options
+    -------
+    modeling_options : dict
+        a modeling options dictionary (inherited via
+        `templates.FarmAEPTemplate`)
+    data_path: str
+        not used for FLOWERS (inherited via `templates.FarmAEPTemplate`)
+
+    Inputs
+    ------
+    x_turbines : np.ndarray
+        a 1D numpy array indicating the x-dimension locations of the turbines,
+        with length `N_turbines` (inherited via `templates.FarmAEPTemplate`)
+    y_turbines : np.ndarray
+        a 1D numpy array indicating the y-dimension locations of the turbines,
+        with length `N_turbines` (inherited via `templates.FarmAEPTemplate`)
+    yaw_turbines : np.ndarray
+        not used for FLOWERS (inherited via `templates.FarmAEPTemplate`)
+
+    Outputs
+    -------
+    AEP_farm : float
+        the AEP of the farm given by the analysis (inherited from
+        `templates.FarmAEPTemplate`)
+    power_farm : np.ndarray
+        an array of the farm power for each of the wind conditions that have
+        been queried (inherited from `templates.FarmAEPTemplate`)
+    # power_turbines : np.ndarray
+    #     an array of the farm power for each of the turbines in the farm across
+    #     all of the conditions that have been queried on the wind rose
+    #     (`N_turbines`, `N_wind_conditions`) (inherited from
+    #     `templates.FarmAEPTemplate`)
+    # thrust_turbines : np.ndarray
+    #     an array of the wind turbine thrust for each of the turbines in the farm
+    #     across all of the conditions that have been queried on the wind rose
+    #     (`N_turbines`, `N_wind_conditions`) (inherited from
+    #     `templates.FarmAEPTemplate`)
+    """
+
+    def initialize(self):
+        super().initialize()  # run super class script first!
+
+    def setup(self):
+
+        # override template to allow for input omission
+
+        # load modeling options
+        self.modeling_options = self.options["modeling_options"]
+        self.windIO = self.modeling_options["windIO_plant"]
+        self.N_turbines = self.modeling_options["layout"]["N_turbines"]
+
+        # set up inputs and outputs for farm layout
+        self.add_input("x_turbines", np.zeros((self.N_turbines,)), units="m")
+        self.add_input("y_turbines", np.zeros((self.N_turbines,)), units="m")
+        self.add_output("AEP_farm", 0.0, units="W*h")
+
+        # grab the windrose from the windIO data
+        windrose_floris = templates.create_windresource_from_windIO(
+            self.windIO,
+            resource_type="probability",
+        )
+        windrose_resample = self.modeling_options.get("flowers", {}).get(
+            "windrose_resample",
+            self.modeling_options.get("wind_rose", {}).get("windrose_resample"),
+        )
+        if windrose_resample is not None:
+            windrose_floris.resample_by_interpolation(
+                **windrose_resample,
+                inplace=True,
+            )
+        # extract to a dataframe
+        self.wind_data = pd.DataFrame(
+            {
+                "wd": windrose_floris.wd_flat,
+                "ws": windrose_floris.ws_flat,
+                "freq_val": windrose_floris.freq_table_flat,
+            }
+        )
+
+    def setup_partials(self):
+        self.declare_partials("AEP_farm", ["x_turbines", "y_turbines"], method="exact")
+
+    def compute(self, inputs, outputs):
+
+        # extract the key inputs
+        layout_x = inputs["x_turbines"]
+        layout_y = inputs["y_turbines"]
+        num_terms = self.modeling_options["flowers"]["num_terms"]
+        k_wake_expansion = self.modeling_options["flowers"]["k"]
+
+        # use the floris turbine as an intermediary to cover off windIO variants
+        self.floris_turbine = create_FLORIS_turbine_from_windIO(self.windIO)
+
+        rho_density_air = self.floris_turbine["power_thrust_table"][
+            "ref_air_density"
+        ]  # kg/m^3
+        area_rotor = np.pi / 4 * self.floris_turbine["rotor_diameter"] ** 2  # m^2
+        V_table = np.array(self.floris_turbine["power_thrust_table"]["wind_speed"])
+        P_table = 1.0e3 * np.array(self.floris_turbine["power_thrust_table"]["power"])
+        CT_table = np.array(
+            self.floris_turbine["power_thrust_table"]["thrust_coefficient"]
+        )
+        CP_table = np.where(
+            V_table == 0.0,
+            0.0,
+            P_table / (0.5 * rho_density_air * area_rotor * V_table**3),
+        )
+
+        turbine_type = {
+            "D": self.windIO["wind_farm"]["turbine"]["rotor_diameter"],
+            "U": self.windIO["wind_farm"]["turbine"]["performance"].get(
+                "cutout_wind_speed", 25.0
+            ),
+            "ct": CT_table,
+            "u_ct": V_table,
+            "cp": CP_table,
+            "u_cp": V_table,
+        }
+
+        # create the flowers model
+        self.flowers_model = FlowersModel(
+            self.wind_data,
+            layout_x,
+            layout_y,
+            num_terms,
+            k_wake_expansion,
+            turbine_type,
+        )
+
+        # FLOWERS computes the powers
+        outputs["AEP_farm"] = self.flowers_model.calculate_aep(
+            rho_density=rho_density_air
+        )
+        # outputs["power_farm"] = FLOWERSFarmComponent.get_power_farm(self)
+        # outputs["power_turbines"] = FLOWERSFarmComponent.get_power_turbines(self)
+        # outputs["thrust_turbines"] = FLOWERSFarmComponent.get_thrust_turbines(self)
+
+    def compute_partials(self, inputs, partials):
+
+        # grab dependencies
+        rho_density_air = self.floris_turbine["power_thrust_table"][
+            "ref_air_density"
+        ]  # kg/m^3
+
+        # compute the gradients and extract to the right places
+        _, gradient = self.flowers_model.calculate_aep(
+            rho_density=rho_density_air, gradient=True
+        )
+        partials["AEP_farm", "x_turbines"] = gradient[:, 0]
+        partials["AEP_farm", "y_turbines"] = gradient[:, 1]

ard/farm_aero/templates.py

@@ -441,6 +441,16 @@ def setup(self):
             "probability",
         )
 
+        # if requested, resample the wind rose
+        windrose_resample = self.modeling_options.get("wind_rose", {}).get(
+            "windrose_resample"
+        )
+        if windrose_resample is not None:
+            self.wind_query.resample_by_interpolation(
+                **windrose_resample,
+                inplace=True,
+            )
+
         if data_path is None:
             data_path = ""
 

assets/logomaker/inputs/windio.yaml

@@ -3303,7 +3303,7 @@ site:
                 - 511.7766126774107
     energy_resource:
         name: Example energy resource
-        wind_resource: !include ../../../examples/data/windIO-plant_wind-resource_wrg-example.yaml
+        wind_resource: !include ../../../examples/ard/data/windIO-plant_wind-resource_wrg-example.yaml
 wind_farm:
     name: LogoFarm
     layouts:
@@ -3322,7 +3322,7 @@ wind_farm:
                  1250.0,  1250.0,  1250.0,  1250.0,  1250.0,
                  2500.0,  2500.0,  2500.0,  2500.0,  2500.0
             ]
-    turbine: !include ../../../examples/data/windIO-plant_turbine_IEA-3.4MW-130m-RWT.yaml
+    turbine: !include ../../../examples/ard/data/windIO-plant_turbine_IEA-3.4MW-130m-RWT.yaml
     electrical_substations:
         - electrical_substation:
             coordinates:

examples/flowers/_archive/compute_AEP.py

@@ -0,0 +1,23 @@
+import numpy as np
+import pandas as pd
+
+from flowers import FlowersModel
+
+# Create generic layout
+D = 126.0
+layout_x = D * np.array(
+    [0.0, 0.0, 0.0, 7.0, 7.0, 7.0, 14.0, 14.0, 14.0, 21.0, 21.0, 21.0, 28.0, 28.0, 28.0]
+)
+layout_y = D * np.array(
+    [0.0, 7.0, 14.0, 0.0, 7.0, 14.0, 0.0, 7.0, 14.0, 0.0, 7.0, 14.0, 0.0, 7.0, 14.0]
+)
+
+# Load in wind data
+df = pd.read_csv("../data/HKW_wind_rose.csv")
+
+# Setup FLOWERS model
+flowers_model = FlowersModel(df, layout_x, layout_y)
+
+# Calculate the AEP
+aep = flowers_model.calculate_aep()
+print(aep)