From 68368dc21983e9d537134d0ee6a3566289f26e3a Mon Sep 17 00:00:00 2001 From: dmulash Date: Mon, 9 Sep 2024 10:41:32 -0600 Subject: [PATCH 01/23] energy_loss update --- waves/project.py | 205 ++++++++++++++++++++++++++++++++++++----------- 1 file changed, 158 insertions(+), 47 deletions(-) diff --git a/waves/project.py b/waves/project.py index 9f44d3a..97a771f 100644 --- a/waves/project.py +++ b/waves/project.py @@ -181,9 +181,6 @@ class Project(FromDictMixin): Interest rate paid on the cash flows. Defaults to None. reinvestment_rate : float, optional Interest rate paid on the cash flows upon reinvestment. Defaults to None. - loss_ratio : float, optional - Additional non-wake losses to deduct from the total energy production. Should be - represented as a decimal in the range of [0, 1]. Defaults to None. orbit_start_date : str | None The date to use for installation phase start timings that are set to "0" in the ``install_phases`` configuration. If None the raw configuration data will be used. @@ -271,9 +268,6 @@ class Project(FromDictMixin): reinvestment_rate: float = field( default=None, validator=attrs.validators.instance_of((float, type(None))) ) - loss_ratio: float = field( - default=None, validator=attrs.validators.instance_of((float, type(None))) - ) soft_capex_date: tuple[int, int] | list[tuple[int, int]] | None = field( default=None, converter=partial(convert_to_multi_index, name="soft_capex_date") ) @@ -1332,7 +1326,7 @@ def energy_potential( aep: bool = False, ) -> pd.DataFrame | float: """Computes the potential energy production, or annual potential energy production, in GWh, - for the simulation by extrapolating the monthly contributions to AEP if FLORIS (wtihout + for the simulation by extrapolating the monthly contributions to AEP if FLORIS (without wakes) results were computed by a wind rose, or using the time series results. Parameters @@ -1425,13 +1419,11 @@ def energy_production( units: str = "gw", per_capacity: str | None = None, with_losses: bool = False, - loss_ratio: float | None = None, aep: bool = False, ) -> pd.DataFrame | float: """Computes the energy production, or annual energy production, in GWh, for the simulation by extrapolating the monthly contributions to AEP if FLORIS (with wakes) results were - computed by a wind rose, or using the time series results, and multiplying it by the WOMBAT - monthly availability (``Metrics.production_based_availability``). + computed by a wind rose, or using the time series results. Parameters ---------- @@ -1446,13 +1438,10 @@ def energy_production( units. If None, then the unnormalized energy production is returned, otherwise it must be one of "kw", "mw", or "gw". Defaults to None. with_losses : bool, optional - Use the :py:attr:`loss_ratio` or :py:attr:`Project.loss_ratio` to post-hoc - consider non-wake and non-availability losses in the energy production aggregation. + Use the :py:attr:`Project.total_loss_ratio` to post-hoc + consider environmental, availability, wake, technical, and electrical losses in the energy + production aggregation. Defaults to False. - loss_ratio : float, optional - The decimal non-wake and non-availability losses ratio to apply to the energy - production. If None, then it will attempt to use the :py:attr:`loss_ratio` provided - in the Project configuration. Defaults to None. aep : bool, optional Flag to return the energy production normalized by the number of years the plan is in operation. Note that :py:attr:`frequency` must be "project" for this to be computed. @@ -1474,6 +1463,9 @@ def energy_production( # For the wind rose outputs, only consider project-level availability because # wind rose AEP is a long-term estimation of energy production + + # commenting availability out as we are trying to calculate aep just based on wakes + availability = self.wombat.metrics.production_based_availability( frequency="month-year", by="turbine" ).loc[:, self.floris_turbine_order] @@ -1485,7 +1477,8 @@ def energy_production( left_on="month", right_index=True, ).drop(labels=["drop"], axis=1) - energy_gwh = availability * power / 1000 + # energy_gwh = availability * power / 1000 + energy_gwh = power / 1000 if self.floris_results_type == "time_series": energy_gwh = self.turbine_aep_mwh / 1000 @@ -1513,16 +1506,9 @@ def energy_production( energy_gwh = energy_gwh.values.sum() if with_losses: - # Check that a loss_ratio exists - if loss_ratio is None: - if (loss_ratio := self.loss_ratio) is None: - raise ValueError( - "`loss_ratio` wasn't defined in the Project settings or in the method" - " keyword arguments." - ) # Get the base production numbers from WOMBAT base_production = self.energy_potential(frequency=frequency, by=by, units="gw") - energy_gwh -= base_production * loss_ratio + energy_gwh = base_production * (1 - self.total_loss_ratio()) if aep: if frequency != "project": @@ -1548,8 +1534,8 @@ def energy_losses( units: str = "gw", per_capacity: str | None = None, with_losses: bool = False, - loss_ratio: float | None = None, aep: bool = False, + losses_breakdown: bool = False, ) -> pd.DataFrame: """Computes the energy losses for the simulation by subtracting the energy production from the potential energy production. @@ -1567,13 +1553,10 @@ def energy_losses( units. If None, then the unnormalized energy production is returned, otherwise it must be one of "kw", "mw", or "gw". Defaults to None. with_losses : bool, optional - Use the :py:attr:`loss_ratio` or :py:attr:`Project.loss_ratio` to post-hoc - consider non-wake and non-availability losses in the energy production aggregation. + Use the :py:attr:`Project.total_loss_ratio` to post-hoc + consider environmental, availability, wake, technical, and electrical losses in the energy + production aggregation. Defaults to False. - loss_ratio : float, optional - The decimal non-wake and non-availability losses ratio to apply to the energy - production. If None, then it will attempt to use the :py:attr:`loss_ratio` provided - in the Project configuration. Defaults to None. aep : bool, optional AEP for the annualized losses. Only used for :py:attr:`frequency` = "project". @@ -1592,19 +1575,26 @@ def energy_losses( by="turbine", units="kw", ) - production = self.energy_production( # type: ignore + + production = self.energy_production( "month-year", by="turbine", units="kw", with_losses=with_losses, - loss_ratio=loss_ratio, )[self.wombat.metrics.turbine_id] + losses = potential - production + # Compute total loss ratio + total_loss_ratio = self.total_loss_ratio() + + # display loss breakdown + if losses_breakdown: + return self.losses_breakdown() + unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} if by == "windfarm": losses = losses.sum(axis=1).to_frame(f"Energy Losses ({unit_map[units]})") - if frequency == "project": losses = losses.sum(axis=0) if by == "windfarm": @@ -1613,7 +1603,6 @@ def energy_losses( losses /= self.operations_years elif frequency == "annual": losses = losses.groupby("year").sum() - if units == "mw": losses /= 1e3 elif units == "gw": @@ -1624,6 +1613,136 @@ def energy_losses( return losses / self.capacity(per_capacity) + def wake_loss_ratio(self) -> float: + """Calculate wake losses using FLORIS outputs. + + Returns + ------- + float + The wake loss ratio. + """ + potential = self.energy_potential( + "month-year", + by="turbine", + units="kw", + ) + + production = self.energy_production( + "month-year", + by="turbine", + units="kw", + with_losses=False, + )[self.wombat.metrics.turbine_id] + + losses = potential - production + + return losses.sum(axis=0).sum() / potential.sum(axis=0).sum() + + def technical_loss_ratio(self) -> float: + """Calculate technical losses based on the project type. + + Returns + ------- + float + The technical loss ratio. + """ + # if "Mooring" is in the design phases of the ORBIT config, it is a floating project, if not, it is fixed-bottom + + floating_substring = "Mooring" + if any( + floating_substring.lower() in item.lower() + for item in self.orbit_config_dict["design_phases"] + ): + return 1 - (1 - 0.01) * (1 - 0.001) * ( + 1 - 0.001 + ) # ORCA -> Hysteresis (1%), Onboard Equip. (0.1%), Rotor Misalignment (0.1%) for a flating project + else: + return 0.01 # ORCA -> Hysterisis (1%) for a fixed-bottom project + + def electrical_loss_ratio(self) -> float: + """Calculate electrical losses based on ORBIT parameters. + + Returns + ------- + float + The electrical loss ratio. + + """ + depth = self.orbit_config_dict["site"]["depth"] + distance_to_landfall = self.orbit_config_dict["site"]["distance_to_landfall"] + # ORCA formula + electrical_loss_ratio = ( + 2.20224112 + + 0.000604121 * depth + + 0.0407303367321603 * distance_to_landfall + + -0.0003712532582 * distance_to_landfall**2 + + 0.0000016525338 * distance_to_landfall**3 + + -0.000000003547544 * distance_to_landfall**4 + + 0.0000000000029271 * distance_to_landfall**5 + ) / 100 + + return electrical_loss_ratio + + def environmental_loss_ratio(self) -> float: + """Set environmental loss assumption from ORCA. + + Returns + ------- + float + The environmental loss ratio. + """ + return 0.0159 + + def total_loss_ratio(self) -> float: + """Calculate total losses based on environmental, availability, wake, technical, and electrical losses. + + Returns + ------- + float + The total loss ratio. + + """ + total_loss_ratio = 1 - ( + (1 - self.environmental_loss_ratio()) + * (1 - (1 - self.availability(which="energy", frequency="project", by="windfarm"))) + * (1 - self.wake_loss_ratio()) + * (1 - self.technical_loss_ratio()) + * (1 - self.electrical_loss_ratio()) + ) + + return total_loss_ratio + + def losses_breakdown(self) -> float: + """Provide a categorical breakout of each of the above loss categories, and the total. + + Returns + ------- + pd.DataFrame + Breakdown of all losses types considered and total losses in percentages. + + """ + loss_types = [ + "Environmental Losses", + "Availability Losses", + "Wake Losses", + "Technical Losses", + "Electrical Losses", + "Total Losses", + ] + + values = [ + self.environmental_loss_ratio() * 100, + (1 - self.availability(which="energy", frequency="project", by="windfarm")) * 100, + self.wake_loss_ratio() * 100, + self.technical_loss_ratio() * 100, + self.electrical_loss_ratio() * 100, + self.total_loss_ratio() * 100, + ] + + losses_breakdown = pd.DataFrame({"Loss Type": loss_types, "Value (%)": values}) + + return losses_breakdown + def availability( self, which: str, frequency: str = "project", by: str = "windfarm" ) -> pd.DataFrame | float: @@ -1675,7 +1794,6 @@ def capacity_factor( frequency: str = "project", by: str = "windfarm", with_losses: bool = False, - loss_ratio: float | None = None, ) -> pd.DataFrame | float: """Calculates the capacity factor over a project's lifetime as a single value, annual average, or monthly average for the whole windfarm or by turbine. @@ -1690,19 +1808,13 @@ def capacity_factor( by : str One of "windfarm" or "turbine". Defaults to "windfarm". with_losses : bool, optional - Use the :py:attr:`loss_ratio` or :py:attr:`Project.loss_ratio` to post-hoc - consider non-wake and non-availability losses in the energy production aggregation. + Use the :py:attr:`Project.total_loss_ratio` to post-hoc + consider environmental, availability, wake, technical, and electrical losses in the energy + production aggregation. Defaults to False. .. note:: This will only be checked for :py:attr:`which` = "net". - loss_ratio : float, optional - The decimal non-wake and non-availability losses ratio to apply to the energy - production. If None, then it will attempt to use the :py:attr:`loss_ratio` provided - in the Project configuration. Defaults to None. - - .. note:: This will only be used when for :py:attr:`which` = "net". - Returns ------- pd.DataFrame | float @@ -1727,7 +1839,6 @@ def capacity_factor( by="turbine", units="kw", with_losses=with_losses, - loss_ratio=loss_ratio, ) else: numerator = self.energy_potential( From 12ac8ec444f7cd71d556ccd6f215e599dfcae30c Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 9 Sep 2024 14:16:22 -0700 Subject: [PATCH 02/23] fix line lengths, typos, typing, and add input. --- waves/project.py | 76 ++++++++++++++++++++++++++++++------------------ 1 file changed, 47 insertions(+), 29 deletions(-) diff --git a/waves/project.py b/waves/project.py index 97a771f..79189f5 100644 --- a/waves/project.py +++ b/waves/project.py @@ -126,6 +126,8 @@ class Project(FromDictMixin): ---------- library_path : str | pathlib.Path The file path where the configuration data for ORBIT, WOMBAT, and FLORIS can be found. + turbine_type : str + The type of wind turbine used. Must be one of "land", "fixed", or "floating". weather_profile : str | pathlib.Path The file path where the weather profile data is located, with the following column requirements: @@ -225,6 +227,7 @@ class Project(FromDictMixin): """ library_path: Path = field(converter=resolve_path) + turbine_type: str = field(converter=str.lower, validator=attrs.validators.instance_of(str)) weather_profile: str = field(converter=str) orbit_config: str | Path | dict | None = field( default=None, validator=attrs.validators.instance_of((str, Path, dict, type(None))) @@ -345,6 +348,25 @@ def library_exists(self, attribute: attrs.Attribute, value: Path) -> None: if not value.is_dir(): raise ValueError(f"The input path to {attribute.name}: {value} is not a directory.") + @turbine_type.validator # type: ignore + def validate_turbine_type(self, attribute: attrs.Attribute, value: str) -> None: + """Validates that :py:attr`turbine_type` is one of "land", "fixed", or "floating". + + Parameters + ---------- + attribute : attrs.Attribute + The attrs Attribute information/metadata/configuration. + value : str + The user input. + + Raises + ------ + ValueError + Raised if not one of "land", "fixed", or "floating". + """ + if value not in ("land", "fixed", "floating"): + raise ValueError(f"{attribute.name} must be one 'land', 'fixed', or floating'.") + @report_config.validator # type: ignore def validate_report_config(self, attribute: attrs.Attribute, value: dict | None) -> None: """Validates the user input for :py:attr:`report_config`. @@ -370,7 +392,9 @@ def validate_report_config(self, attribute: attrs.Attribute, value: dict | None) raise ValueError("`report_config` must be a dictionary, if provided") if "name" not in value: - raise KeyError("A key, value pair for `name` must be provided.") + raise KeyError( + f"A key, value pair for `name` must be provided for the {attribute.name}." + ) # ********************************************************************************************** # Configuration methods @@ -1438,10 +1462,9 @@ def energy_production( units. If None, then the unnormalized energy production is returned, otherwise it must be one of "kw", "mw", or "gw". Defaults to None. with_losses : bool, optional - Use the :py:attr:`Project.total_loss_ratio` to post-hoc - consider environmental, availability, wake, technical, and electrical losses in the energy - production aggregation. - Defaults to False. + Use the :py:attr:`Project.total_loss_ratio` to post-hoc consider environmental, + availability, wake, technical, and electrical losses in the energy production + aggregation. Defaults to False. aep : bool, optional Flag to return the energy production normalized by the number of years the plan is in operation. Note that :py:attr:`frequency` must be "project" for this to be computed. @@ -1553,10 +1576,9 @@ def energy_losses( units. If None, then the unnormalized energy production is returned, otherwise it must be one of "kw", "mw", or "gw". Defaults to None. with_losses : bool, optional - Use the :py:attr:`Project.total_loss_ratio` to post-hoc - consider environmental, availability, wake, technical, and electrical losses in the energy - production aggregation. - Defaults to False. + Use the :py:attr:`Project.total_loss_ratio` to post-hoc consider environmental, + availability, wake, technical, and electrical losses in the energy production + aggregation. Defaults to False. aep : bool, optional AEP for the annualized losses. Only used for :py:attr:`frequency` = "project". @@ -1576,7 +1598,7 @@ def energy_losses( units="kw", ) - production = self.energy_production( + production = self.energy_production( # type: ignore "month-year", by="turbine", units="kw", @@ -1627,7 +1649,7 @@ def wake_loss_ratio(self) -> float: units="kw", ) - production = self.energy_production( + production = self.energy_production( # type: ignore "month-year", by="turbine", units="kw", @@ -1636,28 +1658,24 @@ def wake_loss_ratio(self) -> float: losses = potential - production - return losses.sum(axis=0).sum() / potential.sum(axis=0).sum() + return losses.sum(axis=0).sum() / potential.sum(axis=0).sum() # type: ignore def technical_loss_ratio(self) -> float: """Calculate technical losses based on the project type. + This method is adopted from ORCA where a 1% hysterisis loss is applied for fixed-bottom + turbines. For floating turbines, this is 1% hysterisis, 0.1% for onboard equipment, and 0.1% + for rotor misalignment (0.01197901 total). + Returns ------- float The technical loss ratio. """ - # if "Mooring" is in the design phases of the ORBIT config, it is a floating project, if not, it is fixed-bottom - - floating_substring = "Mooring" - if any( - floating_substring.lower() in item.lower() - for item in self.orbit_config_dict["design_phases"] - ): - return 1 - (1 - 0.01) * (1 - 0.001) * ( - 1 - 0.001 - ) # ORCA -> Hysteresis (1%), Onboard Equip. (0.1%), Rotor Misalignment (0.1%) for a flating project + if self.turbine_type == "floating": + return 1 - (1 - 0.01) * (1 - 0.001) * (1 - 0.001) else: - return 0.01 # ORCA -> Hysterisis (1%) for a fixed-bottom project + return 0.01 def electrical_loss_ratio(self) -> float: """Calculate electrical losses based on ORBIT parameters. @@ -1694,7 +1712,8 @@ def environmental_loss_ratio(self) -> float: return 0.0159 def total_loss_ratio(self) -> float: - """Calculate total losses based on environmental, availability, wake, technical, and electrical losses. + """Calculate total losses based on environmental, availability, wake, technical, and + electrical losses. Returns ------- @@ -1808,10 +1827,9 @@ def capacity_factor( by : str One of "windfarm" or "turbine". Defaults to "windfarm". with_losses : bool, optional - Use the :py:attr:`Project.total_loss_ratio` to post-hoc - consider environmental, availability, wake, technical, and electrical losses in the energy - production aggregation. - Defaults to False. + Use the :py:attr:`Project.total_loss_ratio` to post-hoc consider environmental, + availability, wake, technical, and electrical losses in the energy production + aggregation. Defaults to False. .. note:: This will only be checked for :py:attr:`which` = "net". @@ -2196,7 +2214,7 @@ def capex_breakdown( elif frequency == "project": capex_df = capex_df.sum(axis=0).to_frame(name="Cash Flow").T - capex_df["Capex"] = capex_df.sum(axis=1).sort_index() + capex_df["CapEx"] = capex_df.sum(axis=1).sort_index() if breakdown: return capex_df return capex_df.CapEx.to_frame() From e47a4fe4837881c8f761a50845889209272ad081 Mon Sep 17 00:00:00 2001 From: dmulash Date: Wed, 11 Sep 2024 16:14:15 -0600 Subject: [PATCH 03/23] environmental_loss_ratio, detailed wake_losses, eliminate with_losses --- examples/waves_example.ipynb | 2139 +++++++++-------- .../config/base_fixed_bottom_2022.yaml | 3 + .../project/config/base_floating_2022.yaml | 3 + waves/project.py | 209 +- 4 files changed, 1294 insertions(+), 1060 deletions(-) diff --git a/examples/waves_example.ipynb b/examples/waves_example.ipynb index 027888a..17cc19d 100644 --- a/examples/waves_example.ipynb +++ b/examples/waves_example.ipynb @@ -1,1038 +1,1173 @@ { - "cells": [ + "cells": [ + { + "cell_type": "markdown", + "id": "603c870f", + "metadata": {}, + "source": [ + "(example_cower_2022)=\n", + "# Cost of Wind Energy Review 2022\n", + "\n", + "Be sure to install `pip install \"waves[examples]\"` (or `pip install \".[examples]\"`) to work with\n", + "this example.\n", + "\n", + "This example will walk through the process of running a subset of the 2022 Cost of Wind Energy\n", + "Review (COWER) analysis to demonstrate an analysis workflow. Please note, that this is not the exact\n", + "workflow because it has been broken down to highlight some of the key features of WAVES. Similarly,\n", + "this will stay up to date with WAVES's dependencies, namely ORBIT, WOMBAT, and FLORIS, so results\n", + "may change slightly between this *example* relying on the configurations and the published results.\n", + "\n", + "````{note}\n", + "To run these examples from the command line, the below command can be used, which will dipslay and\n", + "save the results by default, with an option to turn those features off. Use `waves --help` for more\n", + "information in the command line wherever WAVES is installed.\n", + "\n", + "```bash\n", + "# NOTE: This is run from the top level of WAVES/\n", + "\n", + "# Run one example\n", + "waves library/base_2022 base_fixed_bottom_2022.yaml\n", + "\n", + "# Run both examples, but don't save the results\n", + "waves library/base_2022 base_fixed_bottom_2022.yaml base_floating_2022.yaml --no-save-report\n", + "```\n", + "````\n", + "\n", + "## Imports and Styling" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7faae12c", + "metadata": {}, + "outputs": [], + "source": [ + "from time import perf_counter\n", + "from pathlib import Path\n", + "\n", + "import pandas as pd\n", + "\n", + "from waves import Project\n", + "from waves.utilities import load_yaml\n", + "\n", + "# Update core Pandas display settings\n", + "pd.options.display.float_format = \"{:,.2f}\".format\n", + "pd.options.display.max_columns = 100\n", + "pd.options.display.max_rows = 100" + ] + }, + { + "cell_type": "markdown", + "id": "aa374818", + "metadata": {}, + "source": [ + "## Configuration\n", + "\n", + "First, we need to set the library path, and then we'll load the configuration file, to show some of\n", + "the configurations. For a complete guide and definition, please see either the\n", + "[API documentation](https://nrel.github.io/WAVES/api.html) or the\n", + "[How to use WAVES guide](https://nrel.github.io/WAVES/getting_started.html#configuring).\n", + "\n", + "````{warning}\n", + "If your FLORIS installation is <3.6, then the FLORIS configuration files in\n", + "`library/base_2022/project/config/` will have to be updated so that line 107 (same line number for\n", + "fixed bottom and floating) is using an absolute path like the example below.\n", + "\n", + "```yaml\n", + "# original, set to work with FLORIS >= 3.6\n", + "turbine_library_path: ../../turbines\n", + "\n", + "# updated absolute path, replace in your own files\n", + "turbine_library_path: /WAVES/library/base_2022/turbines/\n", + "```\n", + "````" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3ba1216a", + "metadata": {}, + "outputs": [], + "source": [ + "library_path = Path(\"../library/base_2022/\")\n", + "config_fixed = load_yaml(library_path / \"project/config\", \"base_fixed_bottom_2022.yaml\")\n", + "config_floating = load_yaml(library_path / \"project/config\", \"base_floating_2022.yaml\")\n", + "\n", + "# This example was designed prior to the FLORIS 3.6 release, so the path to the turbine library in\n", + "# FLORIS must be manually updated, but this example must work for all users, so a dynamic method\n", + "# is used below, ensuring this works for all users.\n", + "config_fixed[\"floris_config\"] = load_yaml(library_path / \"project/config\", config_fixed[\"floris_config\"])\n", + "config_floating[\"floris_config\"] = load_yaml(library_path / \"project/config\", config_floating[\"floris_config\"])\n", + "\n", + "config_fixed[\"floris_config\"][\"farm\"][\"turbine_library_path\"] = library_path / \"turbines\"\n", + "config_floating[\"floris_config\"][\"farm\"][\"turbine_library_path\"] = library_path / \"turbines\"" + ] + }, + { + "cell_type": "markdown", + "id": "e5242608", + "metadata": {}, + "source": [ + "Now, we'll create a Project for each of the fixed bottom and floating offshore scenarios, showing\n", + "the time it takes to initialize each project. Note that we're initializing using the\n", + "`Project.from_dict()` `classmethod` because the configurations are designed to also work with the\n", + "WAVES command line interface (CLI)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "693a50db", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "603c870f", - "metadata": {}, - "source": [ - "(example_cower_2022)=\n", - "# Cost of Wind Energy Review 2022\n", - "\n", - "Be sure to install `pip install \"waves[examples]\"` (or `pip install \".[examples]\"`) to work with\n", - "this example.\n", - "\n", - "This example will walk through the process of running a subset of the 2022 Cost of Wind Energy\n", - "Review (COWER) analysis to demonstrate an analysis workflow. Please note, that this is not the exact\n", - "workflow because it has been broken down to highlight some of the key features of WAVES. Similarly,\n", - "this will stay up to date with WAVES's dependencies, namely ORBIT, WOMBAT, and FLORIS, so results\n", - "may change slightly between this *example* relying on the configurations and the published results.\n", - "\n", - "````{note}\n", - "To run these examples from the command line, the below command can be used, which will dipslay and\n", - "save the results by default, with an option to turn those features off. Use `waves --help` for more\n", - "information in the command line wherever WAVES is installed.\n", - "\n", - "```bash\n", - "# NOTE: This is run from the top level of WAVES/\n", - "\n", - "# Run one example\n", - "waves library/base_2022 base_fixed_bottom_2022.yaml\n", - "\n", - "# Run both examples, but don't save the results\n", - "waves library/base_2022 base_fixed_bottom_2022.yaml base_floating_2022.yaml --no-save-report\n", - "```\n", - "````\n", - "\n", - "## Imports and Styling" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "FutureWarning: C:\\WAVES_losses\\WAVES\\waves\\project.py:114\n", + "'H' is deprecated and will be removed in a future version, please use 'h' instead." + ] }, { - "cell_type": "code", - "execution_count": 1, - "id": "7faae12c", - "metadata": {}, - "outputs": [], - "source": [ - "from time import perf_counter\n", - "from pathlib import Path\n", - "\n", - "import pandas as pd\n", - "\n", - "from waves import Project\n", - "from waves.utilities import load_yaml\n", - "\n", - "# Update core Pandas display settings\n", - "pd.options.display.float_format = \"{:,.2f}\".format\n", - "pd.options.display.max_columns = 100\n", - "pd.options.display.max_rows = 100" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "ORBIT library intialized at 'C:\\WAVES_losses\\WAVES\\library\\base_2022'\n" + ] }, { - "cell_type": "markdown", - "id": "aa374818", - "metadata": {}, - "source": [ - "## Configuration\n", - "\n", - "First, we need to set the library path, and then we'll load the configuration file, to show some of\n", - "the configurations. For a complete guide and definition, please see either the\n", - "[API documentation](https://nrel.github.io/WAVES/api.html) or the\n", - "[How to use WAVES guide](https://nrel.github.io/WAVES/getting_started.html#configuring).\n", - "\n", - "````{warning}\n", - "If your FLORIS installation is <3.6, then the FLORIS configuration files in\n", - "`library/base_2022/project/config/` will have to be updated so that line 107 (same line number for\n", - "fixed bottom and floating) is using an absolute path like the example below.\n", - "\n", - "```yaml\n", - "# original, set to work with FLORIS >= 3.6\n", - "turbine_library_path: ../../turbines\n", - "\n", - "# updated absolute path, replace in your own files\n", - "turbine_library_path: /WAVES/library/base_2022/turbines/\n", - "```\n", - "````" - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: C:\\Users\\dmulash\\.conda\\envs\\WAVES_losses\\lib\\site-packages\\ORBIT\\phases\\design\\array_system_design.py:906\n", + "Missing data in columns ['bury_speed']; all values will be calculated.FutureWarning: C:\\WAVES_losses\\WAVES\\waves\\project.py:114\n", + "'H' is deprecated and will be removed in a future version, please use 'h' instead." + ] }, { - "cell_type": "code", - "execution_count": 2, - "id": "3ba1216a", - "metadata": {}, - "outputs": [], - "source": [ - "library_path = Path(\"../library/base_2022/\")\n", - "config_fixed = load_yaml(library_path / \"project/config\", \"base_fixed_bottom_2022.yaml\")\n", - "config_floating = load_yaml(library_path / \"project/config\", \"base_floating_2022.yaml\")\n", - "\n", - "# This example was designed prior to the FLORIS 3.6 release, so the path to the turbine library in\n", - "# FLORIS must be manually updated, but this example must work for all users, so a dynamic method\n", - "# is used below, ensuring this works for all users.\n", - "config_fixed[\"floris_config\"] = load_yaml(library_path / \"project/config\", config_fixed[\"floris_config\"])\n", - "config_floating[\"floris_config\"] = load_yaml(library_path / \"project/config\", config_floating[\"floris_config\"])\n", - "\n", - "config_fixed[\"floris_config\"][\"farm\"][\"turbine_library_path\"] = library_path / \"turbines\"\n", - "config_floating[\"floris_config\"][\"farm\"][\"turbine_library_path\"] = library_path / \"turbines\"" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Fixed bottom loading time: 11.12 seconds\n", + "Floating loading time: 11.56 seconds\n" + ] }, { - "cell_type": "markdown", - "id": "e5242608", - "metadata": {}, - "source": [ - "Now, we'll create a Project for each of the fixed bottom and floating offshore scenarios, showing\n", - "the time it takes to initialize each project. Note that we're initializing using the\n", - "`Project.from_dict()` `classmethod` because the configurations are designed to also work with the\n", - "WAVES command line interface (CLI)." - ] - }, + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: C:\\Users\\dmulash\\.conda\\envs\\WAVES_losses\\lib\\site-packages\\ORBIT\\phases\\design\\array_system_design.py:906\n", + "Missing data in columns ['bury_speed']; all values will be calculated." + ] + } + ], + "source": [ + "# Add in the library path for both configurations\n", + "config_fixed.update({\"library_path\": library_path,})\n", + "config_floating.update({\"library_path\": library_path,})\n", + "\n", + "start1 = perf_counter()\n", + "\n", + "project_fixed = Project.from_dict(config_fixed)\n", + "\n", + "end1 = perf_counter()\n", + "\n", + "start2 = perf_counter()\n", + "\n", + "project_floating = Project.from_dict(config_floating)\n", + "\n", + "end2 = perf_counter()\n", + "print(f\"Fixed bottom loading time: {(end1-start1):,.2f} seconds\")\n", + "print(f\"Floating loading time: {(end2-start2):,.2f} seconds\")" + ] + }, + { + "cell_type": "markdown", + "id": "20a735c0", + "metadata": {}, + "source": [ + "### Visualize the wind farm\n", + "\n", + "Both projects use the same layout, so we'll plot just the fixed bottom plant, noting that the self-connected line at the \"OSS1\" indicates the unmodeled interconnection point via a modeled export cable." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f1c9f994", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 3, - "id": "693a50db", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ORBIT library intialized at '/Users/rhammond/GitHub_Public/WAVES/library/base_2022'\n", - "Fixed bottom loading time: 1.10 seconds\n", - "Floating loading time: 1.13 seconds\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: /Users/rhammond/miniforge3/envs/waves/lib/python3.10/site-packages/ORBIT/phases/design/array_system_design.py:906\n", - "Missing data in columns ['bury_speed']; all values will be calculated.UserWarning: /Users/rhammond/miniforge3/envs/waves/lib/python3.10/site-packages/ORBIT/phases/design/array_system_design.py:906\n", - "Missing data in columns ['bury_speed']; all values will be calculated." - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Fixed bottom loading time: 1.10 seconds\n", - "Floating loading time: 1.13 seconds\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: /Users/rhammond/miniforge3/envs/waves/lib/python3.10/site-packages/ORBIT/phases/design/array_system_design.py:906\n", - "Missing data in columns ['bury_speed']; all values will be calculated." - ] - } - ], - "source": [ - "# Add in the library path for both configurations\n", - "config_fixed.update({\"library_path\": library_path,})\n", - "config_floating.update({\"library_path\": library_path,})\n", - "\n", - "start1 = perf_counter()\n", - "\n", - "project_fixed = Project.from_dict(config_fixed)\n", - "\n", - "end1 = perf_counter()\n", - "\n", - "start2 = perf_counter()\n", - "\n", - "project_floating = Project.from_dict(config_floating)\n", - "\n", - "end2 = perf_counter()\n", - "print(f\"Fixed bottom loading time: {(end1-start1):,.2f} seconds\")\n", - "print(f\"Floating loading time: {(end2-start2):,.2f} seconds\")" + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "project_fixed.plot_farm()" + ] + }, + { + "cell_type": "markdown", + "id": "729aabb9", + "metadata": {}, + "source": [ + "## Run the Projects\n", + "\n", + "Now we'll, run all both the fixed-bottom and floating offshore wind scenarios. Notice that there are\n", + "additional parameters to use for running the FLORIS model in WAVES: `\"wind_rose\"` and\n", + "`\"time_series\"`. While time series is more accurate, it can take multiple hours to run for a\n", + "20-year, hourly timeseries, and lead to similar results, so we choose the model that will take only\n", + "a few minutes to run, instead.\n", + "\n", + "Additionally, the wind rose can be computed based on the full weather profile,\n", + "`full_wind_rose=True`, for little added computation since WAVES computes a wind rose for each month\n", + "of the year, for a more accurate energy output. However, we're using just the weather profile used\n", + "in the O&M phase: `full_wind_rose=False`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6a63ca2f", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "20a735c0", - "metadata": {}, - "source": [ - "### Visualize the wind farm\n", - "\n", - "Both projects use the same layout, so we'll plot just the fixed bottom plant, noting that the self-connected line at the \"OSS1\" indicates the unmodeled interconnection point via a modeled export cable." - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: C:\\Users\\dmulash\\.conda\\envs\\WAVES_losses\\lib\\site-packages\\ORBIT\\phases\\design\\array_system_design.py:906\n", + "Missing data in columns ['bury_speed']; all values will be calculated." + ] }, { - "cell_type": "code", - "execution_count": 4, - "id": "f1c9f994", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "project_fixed.plot_farm()" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n" + ] }, { - "cell_type": "markdown", - "id": "729aabb9", - "metadata": {}, - "source": [ - "## Run the Projects\n", - "\n", - "Now we'll, run all both the fixed-bottom and floating offshore wind scenarios. Notice that there are\n", - "additional parameters to use for running the FLORIS model in WAVES: `\"wind_rose\"` and\n", - "`\"time_series\"`. While time series is more accurate, it can take multiple hours to run for a\n", - "20-year, hourly timeseries, and lead to similar results, so we choose the model that will take only\n", - "a few minutes to run, instead.\n", - "\n", - "Additionally, the wind rose can be computed based on the full weather profile,\n", - "`full_wind_rose=True`, for little added computation since WAVES computes a wind rose for each month\n", - "of the year, for a more accurate energy output. However, we're using just the weather profile used\n", - "in the O&M phase: `full_wind_rose=False`." - ] + "name": "stderr", + "output_type": "stream", + "text": [ + "UserWarning: C:\\Users\\dmulash\\.conda\\envs\\WAVES_losses\\lib\\site-packages\\ORBIT\\phases\\design\\array_system_design.py:906\n", + "Missing data in columns ['bury_speed']; all values will be calculated." + ] }, { - "cell_type": "code", - "execution_count": 5, - "id": "6a63ca2f", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: /Users/rhammond/miniforge3/envs/waves/lib/python3.10/site-packages/ORBIT/phases/design/array_system_design.py:906\n", - "Missing data in columns ['bury_speed']; all values will be calculated.UserWarning: /Users/rhammond/miniforge3/envs/waves/lib/python3.10/site-packages/ORBIT/phases/design/array_system_design.py:906\n", - "Missing data in columns ['bury_speed']; all values will be calculated." - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "-----------------------------\n", - "Fixed run time: 47.16 seconds\n", - "Floating run time: 123.60 seconds\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "UserWarning: /Users/rhammond/miniforge3/envs/waves/lib/python3.10/site-packages/ORBIT/phases/design/array_system_design.py:906\n", - "Missing data in columns ['bury_speed']; all values will be calculated." - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n", - "Correcting negative Overhang:-2.5\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "-----------------------------\n", - "Fixed run time: 47.16 seconds\n", - "Floating run time: 123.60 seconds\n" - ] - } - ], - "source": [ - "start1 = perf_counter()\n", - "project_fixed.run(\n", - " which_floris=\"wind_rose\", # month-based wind rose wake analysis\n", - " full_wind_rose=False, # use the WOMBAT date range\n", - " floris_reinitialize_kwargs={\"cut_in_wind_speed\": 3.0, \"cut_out_wind_speed\": 25.0} # standard ws range\n", - ")\n", - "project_fixed.wombat.env.cleanup_log_files() # Delete logging data from the WOMBAT simulations\n", - "end1 = perf_counter()\n", - "\n", - "start2 = perf_counter()\n", - "project_floating.run(\n", - " which_floris=\"wind_rose\",\n", - " full_wind_rose=False,\n", - " floris_reinitialize_kwargs=dict(cut_in_wind_speed=3.0, cut_out_wind_speed=25.0)\n", - ")\n", - "project_floating.wombat.env.cleanup_log_files() # Delete logging data from the WOMBAT simulations\n", - "end2 = perf_counter()\n", - "\n", - "print(\"-\" * 29) # separate our timing from the ORBIT and FLORIS run-time warnings\n", - "print(f\"Fixed run time: {end1 - start1:,.2f} seconds\")\n", - "print(f\"Floating run time: {end2 - start2:,.2f} seconds\")" - ] - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "Correcting negative Overhang:-2.5\n", + "-----------------------------\n", + "Fixed run time: 189.04 seconds\n", + "Floating run time: 360.30 seconds\n" + ] + } + ], + "source": [ + "start1 = perf_counter()\n", + "project_fixed.run(\n", + " which_floris=\"wind_rose\", # month-based wind rose wake analysis\n", + " full_wind_rose=False, # use the WOMBAT date range\n", + " floris_reinitialize_kwargs={\"cut_in_wind_speed\": 3.0, \"cut_out_wind_speed\": 25.0} # standard ws range\n", + ")\n", + "project_fixed.wombat.env.cleanup_log_files() # Delete logging data from the WOMBAT simulations\n", + "end1 = perf_counter()\n", + "\n", + "start2 = perf_counter()\n", + "project_floating.run(\n", + " which_floris=\"wind_rose\",\n", + " full_wind_rose=False,\n", + " floris_reinitialize_kwargs=dict(cut_in_wind_speed=3.0, cut_out_wind_speed=25.0)\n", + ")\n", + "project_floating.wombat.env.cleanup_log_files() # Delete logging data from the WOMBAT simulations\n", + "end2 = perf_counter()\n", + "\n", + "print(\"-\" * 29) # separate our timing from the ORBIT and FLORIS run-time warnings\n", + "print(f\"Fixed run time: {end1 - start1:,.2f} seconds\")\n", + "print(f\"Floating run time: {end2 - start2:,.2f} seconds\")" + ] + }, + { + "cell_type": "markdown", + "id": "929a2c5a", + "metadata": {}, + "source": [ + "Both of these examples can also be run via the CLI, though the FLORIS `turbine_library_path`\n", + "configuration will have to be manually updated in each file to ensure the examples run.\n", + "\n", + "```console\n", + "waves path/to/library/base_2022/ base_fixed_bottom_2022.yaml base_floating_bottom_2022.yaml --no-save-report\n", + "```\n", + "\n", + "(example_cower_2022:results)=\n", + "## Gather the results\n", + "\n", + "Another of the conveniences with using WAVES to run all three models is that some of the core\n", + "metrics are wrapped in the `Project` API, with the ability to generate a report of a selection of\n", + "the metrics.\n", + "\n", + "Below, we define the inputs for the report by the following paradigm, where the `\"metric\"` and\n", + "`\"kwargs\"` keys must not be changed to ensure their values are read correctly. See the following\n", + "setup for details.\n", + "\n", + "```python\n", + "configuration_dictionary = {\n", + " \"Descriptive Name of Metric\": {\n", + " \"metric\": \"metric_method_name\",\n", + " \"kwargs\": {\n", + " \"metric_kwarg_1\": \"kwarg_1_value\", ...\n", + " }\n", + " }\n", + "}\n", + "```\n", + "\n", + "Below, it can be seen that many metrics do not have the `\"kwargs\"` dictionary item. This is because\n", + "an empty dictionary can be assumed to be used when no values need to be configured. In other words,\n", + "the default method configurations will be relied on, if not otherwise specified." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0986321e", + "metadata": {}, + "outputs": [], + "source": [ + "metrics_configuration = {\n", + " \"# Turbines\": {\"metric\": \"n_turbines\"},\n", + " \"Turbine Rating (MW)\": {\"metric\": \"turbine_rating\"},\n", + " \"Project Capacity (MW)\": {\n", + " \"metric\": \"capacity\",\n", + " \"kwargs\": {\"units\": \"mw\"}\n", + " },\n", + " \"# OSS\": {\"metric\": \"n_substations\"},\n", + " \"Total Export Cable Length (km)\": {\"metric\": \"export_system_total_cable_length\"},\n", + " \"Total Array Cable Length (km)\": {\"metric\": \"array_system_total_cable_length\"},\n", + " \"CapEx ($)\": {\"metric\": \"capex\"},\n", + " \"CapEx per kW ($/kW)\": {\n", + " \"metric\": \"capex\",\n", + " \"kwargs\": {\"per_capacity\": \"kw\"}\n", + " },\n", + " \"OpEx ($)\": {\"metric\": \"opex\"},\n", + " \"OpEx per kW ($/kW)\": {\"metric\": \"opex\", \"kwargs\": {\"per_capacity\": \"kw\"}},\n", + " \"AEP (MWh)\": {\n", + " \"metric\": \"energy_production\",\n", + " \"kwargs\": {\"units\": \"mw\", \"aep\": True}\n", + " },\n", + " \"AEP per kW (MWh/kW)\": {\n", + " \"metric\": \"energy_production\",\n", + " \"kwargs\": {\"units\": \"mw\", \"per_capacity\": \"kw\", \"aep\": True}\n", + " },\n", + " \"Net Capacity Factor With All Losses (%)\": {\n", + " \"metric\": \"capacity_factor\",\n", + " \"kwargs\": {\"which\": \"net\"}\n", + " },\n", + " \"Gross Capacity Factor (%)\": {\n", + " \"metric\": \"capacity_factor\",\n", + " \"kwargs\": {\"which\": \"gross\"}\n", + " },\n", + " \"Energy Availability (%)\": {\n", + " \"metric\": \"availability\",\n", + " \"kwargs\": {\"which\": \"energy\"}\n", + " },\n", + " \"LCOE ($/MWh)\": {\"metric\": \"lcoe\"},\n", + "}\n", + "\n", + "\n", + "# Define the final order of the metrics in the resulting dataframes\n", + "metrics_order = [\n", + " \"# Turbines\",\n", + " \"Turbine Rating (MW)\",\n", + " \"Project Capacity (MW)\",\n", + " \"# OSS\",\n", + " \"Total Export Cable Length (km)\",\n", + " \"Total Array Cable Length (km)\",\n", + " \"FCR (%)\",\n", + " \"Offtake Price ($/MWh)\",\n", + " \"CapEx ($)\",\n", + " \"CapEx per kW ($/kW)\",\n", + " \"OpEx ($)\",\n", + " \"OpEx per kW ($/kW)\",\n", + " \"Annual OpEx per kW ($/kW)\",\n", + " \"Energy Availability (%)\",\n", + " \"Gross Capacity Factor (%)\",\n", + " \"Net Capacity Factor With All Losses (%)\",\n", + " \"AEP (MWh)\",\n", + " \"AEP per kW (MWh/kW)\",\n", + " \"LCOE ($/MWh)\",\n", + "]\n", + "\n", + "capex_order = [\n", + " \"Array System\",\n", + " \"Export System\",\n", + " \"Offshore Substation\",\n", + " \"Substructure\",\n", + " \"Scour Protection\",\n", + " \"Mooring System\",\n", + " \"Turbine\",\n", + " \"Array System Installation\",\n", + " \"Export System Installation\",\n", + " \"Offshore Substation Installation\",\n", + " \"Substructure Installation\",\n", + " \"Scour Protection Installation\",\n", + " \"Mooring System Installation\",\n", + " \"Turbine Installation\",\n", + " \"Soft\",\n", + " \"Project\",\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "7e4e095b", + "metadata": {}, + "source": [ + "Before we generate the report, let's see a CapEx breakdown of each scenario. To do this, we'll\n", + "access ORBIT's `ProjectManager` object directly to access model-specific functionality. This is\n", + "available for each model via:\n", + "\n", + "- `project.orbit`: provides access to ORBIT's `ProjectManager`\n", + "- `project.wombat` provides access to WOMBAT's `Simulation`\n", + "- `project.floris` provides access to FLORIS's `FlorisInterface`" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "40f7fc6c", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "929a2c5a", - "metadata": {}, - "source": [ - "Both of these examples can also be run via the CLI, though the FLORIS `turbine_library_path`\n", - "configuration will have to be manually updated in each file to ensure the examples run.\n", - "\n", - "```console\n", - "waves path/to/library/base_2022/ base_fixed_bottom_2022.yaml base_floating_bottom_2022.yaml --no-save-report\n", - "```\n", - "\n", - "(example_cower_2022:results)=\n", - "## Gather the results\n", - "\n", - "Another of the conveniences with using WAVES to run all three models is that some of the core\n", - "metrics are wrapped in the `Project` API, with the ability to generate a report of a selection of\n", - "the metrics.\n", - "\n", - "Below, we define the inputs for the report by the following paradigm, where the `\"metric\"` and\n", - "`\"kwargs\"` keys must not be changed to ensure their values are read correctly. See the following\n", - "setup for details.\n", - "\n", - "```python\n", - "configuration_dictionary = {\n", - " \"Descriptive Name of Metric\": {\n", - " \"metric\": \"metric_method_name\",\n", - " \"kwargs\": {\n", - " \"metric_kwarg_1\": \"kwarg_1_value\", ...\n", - " }\n", - " }\n", - "}\n", - "```\n", - "\n", - "Below, it can be seen that many metrics do not have the `\"kwargs\"` dictionary item. This is because\n", - "an empty dictionary can be assumed to be used when no values need to be configured. In other words,\n", - "the default method configurations will be relied on, if not otherwise specified." + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CapEx ($) - FixedCapEx ($/kW) - FixedCapEx ($) - FloatingCapEx ($/kW) - Floating
Component
Array System111,193,235.71185.32133,234,144.17222.06
Export System100,357,800.00167.2675,794,538.61126.32
Offshore Substation99,479,100.00165.8099,479,100.00165.80
Substructure307,153,308.59511.92630,709,636.601,051.18
Scour Protection10,242,000.0017.070.000.00
Mooring System0.000.00275,612,740.33459.35
Turbine1,020,000,000.001,700.001,020,000,000.001,700.00
Array System Installation64,007,716.58106.6888,227,606.73147.05
Export System Installation135,777,423.05226.30144,141,926.89240.24
Offshore Substation Installation7,424,892.5012.3715,152,770.8525.25
Substructure Installation44,655,354.5574.4388,975,886.55148.29
Scour Protection Installation44,131,310.5073.550.000.00
Mooring System Installation0.000.0069,384,372.60115.64
Turbine Installation58,007,701.6196.680.000.00
Soft325,896,000.00543.16325,896,000.00543.16
Project151,250,000.00252.08151,250,000.00252.08
\n", + "
" + ], + "text/plain": [ + " CapEx ($) - Fixed CapEx ($/kW) - Fixed \\\n", + "Component \n", + "Array System 111,193,235.71 185.32 \n", + "Export System 100,357,800.00 167.26 \n", + "Offshore Substation 99,479,100.00 165.80 \n", + "Substructure 307,153,308.59 511.92 \n", + "Scour Protection 10,242,000.00 17.07 \n", + "Mooring System 0.00 0.00 \n", + "Turbine 1,020,000,000.00 1,700.00 \n", + "Array System Installation 64,007,716.58 106.68 \n", + "Export System Installation 135,777,423.05 226.30 \n", + "Offshore Substation Installation 7,424,892.50 12.37 \n", + "Substructure Installation 44,655,354.55 74.43 \n", + "Scour Protection Installation 44,131,310.50 73.55 \n", + "Mooring System Installation 0.00 0.00 \n", + "Turbine Installation 58,007,701.61 96.68 \n", + "Soft 325,896,000.00 543.16 \n", + "Project 151,250,000.00 252.08 \n", + "\n", + " CapEx ($) - Floating \\\n", + "Component \n", + "Array System 133,234,144.17 \n", + "Export System 75,794,538.61 \n", + "Offshore Substation 99,479,100.00 \n", + "Substructure 630,709,636.60 \n", + "Scour Protection 0.00 \n", + "Mooring System 275,612,740.33 \n", + "Turbine 1,020,000,000.00 \n", + "Array System Installation 88,227,606.73 \n", + "Export System Installation 144,141,926.89 \n", + "Offshore Substation Installation 15,152,770.85 \n", + "Substructure Installation 88,975,886.55 \n", + "Scour Protection Installation 0.00 \n", + "Mooring System Installation 69,384,372.60 \n", + "Turbine Installation 0.00 \n", + "Soft 325,896,000.00 \n", + "Project 151,250,000.00 \n", + "\n", + " CapEx ($/kW) - Floating \n", + "Component \n", + "Array System 222.06 \n", + "Export System 126.32 \n", + "Offshore Substation 165.80 \n", + "Substructure 1,051.18 \n", + "Scour Protection 0.00 \n", + "Mooring System 459.35 \n", + "Turbine 1,700.00 \n", + "Array System Installation 147.05 \n", + "Export System Installation 240.24 \n", + "Offshore Substation Installation 25.25 \n", + "Substructure Installation 148.29 \n", + "Scour Protection Installation 0.00 \n", + "Mooring System Installation 115.64 \n", + "Turbine Installation 0.00 \n", + "Soft 543.16 \n", + "Project 252.08 " ] - }, + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Capture the CapEx breakdown from each scenario\n", + "df_capex_fixed = pd.DataFrame(\n", + " project_fixed.orbit.capex_breakdown.items(),\n", + " columns=[\"Component\", \"CapEx ($) - Fixed\"]\n", + ")\n", + "df_capex_floating = pd.DataFrame(\n", + " project_floating.orbit.capex_breakdown.items(),\n", + " columns=[\"Component\", \"CapEx ($) - Floating\"]\n", + ")\n", + "\n", + "# Compute the normalized CapEx for each scenario\n", + "df_capex_fixed[\"CapEx ($/kW) - Fixed\"] = df_capex_fixed[\"CapEx ($) - Fixed\"] / project_fixed.capacity(\"kw\")\n", + "df_capex_floating[\"CapEx ($/kW) - Floating\"] = df_capex_floating[\"CapEx ($) - Floating\"] / project_floating.capacity(\"kw\")\n", + "\n", + "# Combine the results into one, easy to view dataframe\n", + "df_capex = df_capex_fixed.merge(\n", + " df_capex_floating,\n", + " on=\"Component\",\n", + " how=\"outer\",\n", + ").fillna(0.0).set_index(\"Component\")\n", + "df_capex = df_capex.iloc[pd.Categorical(df_capex.index, capex_order).argsort()]\n", + "df_capex" + ] + }, + { + "cell_type": "markdown", + "id": "fdcc8d6a", + "metadata": {}, + "source": [ + "Now, let's generate the report, and then add in some additional reporting variables." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d2383f64", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "execution_count": 6, - "id": "0986321e", - "metadata": {}, - "outputs": [], - "source": [ - "metrics_configuration = {\n", - " \"# Turbines\": {\"metric\": \"n_turbines\"},\n", - " \"Turbine Rating (MW)\": {\"metric\": \"turbine_rating\"},\n", - " \"Project Capacity (MW)\": {\n", - " \"metric\": \"capacity\",\n", - " \"kwargs\": {\"units\": \"mw\"}\n", - " },\n", - " \"# OSS\": {\"metric\": \"n_substations\"},\n", - " \"Total Export Cable Length (km)\": {\"metric\": \"export_system_total_cable_length\"},\n", - " \"Total Array Cable Length (km)\": {\"metric\": \"array_system_total_cable_length\"},\n", - " \"CapEx ($)\": {\"metric\": \"capex\"},\n", - " \"CapEx per kW ($/kW)\": {\n", - " \"metric\": \"capex\",\n", - " \"kwargs\": {\"per_capacity\": \"kw\"}\n", - " },\n", - " \"OpEx ($)\": {\"metric\": \"opex\"},\n", - " \"OpEx per kW ($/kW)\": {\"metric\": \"opex\", \"kwargs\": {\"per_capacity\": \"kw\"}},\n", - " \"AEP (MWh)\": {\n", - " \"metric\": \"energy_production\",\n", - " \"kwargs\": {\"units\": \"mw\", \"aep\": True, \"with_losses\": True}\n", - " },\n", - " \"AEP per kW (MWh/kW)\": {\n", - " \"metric\": \"energy_production\",\n", - " \"kwargs\": {\"units\": \"mw\", \"per_capacity\": \"kw\", \"aep\": True, \"with_losses\": True}\n", - " },\n", - " \"Net Capacity Factor With Wake Losses (%)\": {\n", - " \"metric\": \"capacity_factor\",\n", - " \"kwargs\": {\"which\": \"net\"}\n", - " },\n", - " \"Net Capacity Factor With All Losses (%)\": {\n", - " \"metric\": \"capacity_factor\",\n", - " \"kwargs\": {\"which\": \"net\", \"with_losses\": True}\n", - " },\n", - " \"Gross Capacity Factor (%)\": {\n", - " \"metric\": \"capacity_factor\",\n", - " \"kwargs\": {\"which\": \"gross\"}\n", - " },\n", - " \"Energy Availability (%)\": {\n", - " \"metric\": \"availability\",\n", - " \"kwargs\": {\"which\": \"energy\"}\n", - " },\n", - " \"LCOE ($/MWh)\": {\"metric\": \"lcoe\"},\n", - "}\n", - "\n", - "\n", - "# Define the final order of the metrics in the resulting dataframes\n", - "metrics_order = [\n", - " \"# Turbines\",\n", - " \"Turbine Rating (MW)\",\n", - " \"Project Capacity (MW)\",\n", - " \"# OSS\",\n", - " \"Total Export Cable Length (km)\",\n", - " \"Total Array Cable Length (km)\",\n", - " \"FCR (%)\",\n", - " \"Offtake Price ($/MWh)\",\n", - " \"CapEx ($)\",\n", - " \"CapEx per kW ($/kW)\",\n", - " \"OpEx ($)\",\n", - " \"OpEx per kW ($/kW)\",\n", - " \"Annual OpEx per kW ($/kW)\",\n", - " \"Energy Availability (%)\",\n", - " \"Gross Capacity Factor (%)\",\n", - " \"Net Capacity Factor With Wake Losses (%)\",\n", - " \"Net Capacity Factor With All Losses (%)\",\n", - " \"AEP (MWh)\",\n", - " \"AEP per kW (MWh/kW)\",\n", - " \"LCOE ($/MWh)\",\n", - "]\n", - "\n", - "capex_order = [\n", - " \"Array System\",\n", - " \"Export System\",\n", - " \"Offshore Substation\",\n", - " \"Substructure\",\n", - " \"Scour Protection\",\n", - " \"Mooring System\",\n", - " \"Turbine\",\n", - " \"Array System Installation\",\n", - " \"Export System Installation\",\n", - " \"Offshore Substation Installation\",\n", - " \"Substructure Installation\",\n", - " \"Scour Protection Installation\",\n", - " \"Mooring System Installation\",\n", - " \"Turbine Installation\",\n", - " \"Soft\",\n", - " \"Project\",\n", - "]" + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
COE 2022 - FixedCOE 2022 - Floating
Metrics
# OSS1.001.00
# Turbines50.0050.00
AEP (MWh)2,575,339.722,940,264.39
AEP per kW (MWh/kW)4.294.90
Annual OpEx per kW ($/kW)62.1973.33
CapEx ($)2,479,575,843.103,117,858,723.33
CapEx per kW ($/kW)4,132.635,196.43
Energy Availability (%)95.5891.24
FCR (%)6.486.48
Gross Capacity Factor (%)52.9159.35
LCOE ($/MWh)76.8883.68
Net Capacity Factor With All Losses (%)43.9947.76
Offtake Price ($/MWh)83.3083.30
OpEx ($)783,622,746.27923,960,818.16
OpEx per kW ($/kW)1,306.041,539.93
Project Capacity (MW)600.00600.00
Total Array Cable Length (km)277.98333.09
Total Export Cable Length (km)118.0789.17
Turbine Rating (MW)12.0012.00
\n", + "
" + ], + "text/plain": [ + " COE 2022 - Fixed COE 2022 - Floating\n", + "Metrics \n", + "# OSS 1.00 1.00\n", + "# Turbines 50.00 50.00\n", + "AEP (MWh) 2,575,339.72 2,940,264.39\n", + "AEP per kW (MWh/kW) 4.29 4.90\n", + "Annual OpEx per kW ($/kW) 62.19 73.33\n", + "CapEx ($) 2,479,575,843.10 3,117,858,723.33\n", + "CapEx per kW ($/kW) 4,132.63 5,196.43\n", + "Energy Availability (%) 95.58 91.24\n", + "FCR (%) 6.48 6.48\n", + "Gross Capacity Factor (%) 52.91 59.35\n", + "LCOE ($/MWh) 76.88 83.68\n", + "Net Capacity Factor With All Losses (%) 43.99 47.76\n", + "Offtake Price ($/MWh) 83.30 83.30\n", + "OpEx ($) 783,622,746.27 923,960,818.16\n", + "OpEx per kW ($/kW) 1,306.04 1,539.93\n", + "Project Capacity (MW) 600.00 600.00\n", + "Total Array Cable Length (km) 277.98 333.09\n", + "Total Export Cable Length (km) 118.07 89.17\n", + "Turbine Rating (MW) 12.00 12.00" ] - }, + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project_name_fixed = \"COE 2022 - Fixed\"\n", + "project_name_floating = \"COE 2022 - Floating\"\n", + "\n", + "# Generate the reports using WAVES and the above configurations\n", + "# NOTE: the results are transposed to view them more easily for the example, otherwise\n", + "# each row would be a project, which is helpful for combining the results of many scenarios\n", + "report_df_fixed = project_fixed.generate_report(metrics_configuration, project_name_fixed).T\n", + "report_df_floating = project_floating.generate_report(metrics_configuration, project_name_floating).T\n", + "\n", + "# Gather some additional metadata and results from the projects\n", + "n_years_fixed = project_fixed.operations_years\n", + "n_years_floating = project_floating.operations_years\n", + "additional_reporting_fixed = pd.DataFrame(\n", + " [\n", + " [\"FCR (%)\", project_fixed.fixed_charge_rate],\n", + " [\"Offtake Price ($/MWh)\", project_fixed.offtake_price],\n", + " [\n", + " \"Annual OpEx per kW ($/kW)\",\n", + " report_df_fixed.loc[\"OpEx per kW ($/kW)\", project_name_fixed] / n_years_fixed\n", + " ],\n", + " ],\n", + " columns=[\"Project\"] + report_df_fixed.columns.tolist(),\n", + ").set_index(\"Project\")\n", + "\n", + "additional_reporting_floating = pd.DataFrame(\n", + " [\n", + " [\"FCR (%)\", project_floating.fixed_charge_rate],\n", + " [\"Offtake Price ($/MWh)\", project_floating.offtake_price],\n", + " [\n", + " \"Annual OpEx per kW ($/kW)\",\n", + " report_df_floating.loc[\"OpEx per kW ($/kW)\", project_name_floating] / n_years_floating\n", + " ],\n", + " ],\n", + " columns=[\"Project\"] + report_df_floating.columns.tolist(),\n", + ").set_index(\"Project\")\n", + "\n", + "# Combine the additional metrics to the generated report\n", + "report_df_fixed = pd.concat((report_df_fixed, additional_reporting_fixed), axis=0).loc[metrics_order]\n", + "report_df_floating = pd.concat((report_df_floating, additional_reporting_floating), axis=0).loc[metrics_order]\n", + "\n", + "# Combine both reports into one, easy to view dataframe\n", + "report_df = report_df_fixed.join(\n", + " report_df_floating,\n", + " how=\"outer\",\n", + ").fillna(0.0)\n", + "report_df.index.name = \"Metrics\"\n", + "\n", + "# Format percent-based rows to show as such, not as decimals\n", + "report_df.loc[report_df.index.str.contains(\"%\")] *= 100\n", + "\n", + "report_df" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "93cf7c30-232b-4545-96e4-a2796e220a14", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "7e4e095b", - "metadata": {}, - "source": [ - "Before we generate the report, let's see a CapEx breakdown of each scenario. To do this, we'll\n", - "access ORBIT's `ProjectManager` object directly to access model-specific functionality. This is\n", - "available for each model via:\n", - "\n", - "- `project.orbit`: provides access to ORBIT's `ProjectManager`\n", - "- `project.wombat` provides access to WOMBAT's `Simulation`\n", - "- `project.floris` provides access to FLORIS's `FlorisInterface`" - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss Breakdown Fixed-Bottom\n" + ] }, { - "cell_type": "code", - "execution_count": 7, - "id": "40f7fc6c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
CapEx ($) - FixedCapEx ($/kW) - FixedCapEx ($) - FloatingCapEx ($/kW) - Floating
Component
Array System111,193,235.71185.32133,234,144.17222.06
Export System100,357,800.00167.2675,794,538.61126.32
Offshore Substation99,479,100.00165.8099,479,100.00165.80
Substructure307,153,308.59511.92630,709,636.601,051.18
Scour Protection10,242,000.0017.070.000.00
Mooring System0.000.00275,612,740.33459.35
Turbine1,020,000,000.001,700.001,020,000,000.001,700.00
Array System Installation108,761,352.72181.27167,028,845.71278.38
Export System Installation135,777,423.05226.30144,141,926.89240.24
Offshore Substation Installation7,424,892.5012.3715,152,770.8525.25
Substructure Installation44,655,354.5574.4388,975,886.55148.29
Scour Protection Installation44,131,310.5073.550.000.00
Mooring System Installation0.000.0069,384,372.60115.64
Turbine Installation58,007,701.6196.680.000.00
Soft325,896,000.00543.16325,896,000.00543.16
Project151,250,000.00252.08151,250,000.00252.08
\n", - "
" - ], - "text/plain": [ - " CapEx ($) - Fixed CapEx ($/kW) - Fixed \\\n", - "Component \n", - "Array System 111,193,235.71 185.32 \n", - "Export System 100,357,800.00 167.26 \n", - "Offshore Substation 99,479,100.00 165.80 \n", - "Substructure 307,153,308.59 511.92 \n", - "Scour Protection 10,242,000.00 17.07 \n", - "Mooring System 0.00 0.00 \n", - "Turbine 1,020,000,000.00 1,700.00 \n", - "Array System Installation 108,761,352.72 181.27 \n", - "Export System Installation 135,777,423.05 226.30 \n", - "Offshore Substation Installation 7,424,892.50 12.37 \n", - "Substructure Installation 44,655,354.55 74.43 \n", - "Scour Protection Installation 44,131,310.50 73.55 \n", - "Mooring System Installation 0.00 0.00 \n", - "Turbine Installation 58,007,701.61 96.68 \n", - "Soft 325,896,000.00 543.16 \n", - "Project 151,250,000.00 252.08 \n", - "\n", - " CapEx ($) - Floating \\\n", - "Component \n", - "Array System 133,234,144.17 \n", - "Export System 75,794,538.61 \n", - "Offshore Substation 99,479,100.00 \n", - "Substructure 630,709,636.60 \n", - "Scour Protection 0.00 \n", - "Mooring System 275,612,740.33 \n", - "Turbine 1,020,000,000.00 \n", - "Array System Installation 167,028,845.71 \n", - "Export System Installation 144,141,926.89 \n", - "Offshore Substation Installation 15,152,770.85 \n", - "Substructure Installation 88,975,886.55 \n", - "Scour Protection Installation 0.00 \n", - "Mooring System Installation 69,384,372.60 \n", - "Turbine Installation 0.00 \n", - "Soft 325,896,000.00 \n", - "Project 151,250,000.00 \n", - "\n", - " CapEx ($/kW) - Floating \n", - "Component \n", - "Array System 222.06 \n", - "Export System 126.32 \n", - "Offshore Substation 165.80 \n", - "Substructure 1,051.18 \n", - "Scour Protection 0.00 \n", - "Mooring System 459.35 \n", - "Turbine 1,700.00 \n", - "Array System Installation 278.38 \n", - "Export System Installation 240.24 \n", - "Offshore Substation Installation 25.25 \n", - "Substructure Installation 148.29 \n", - "Scour Protection Installation 0.00 \n", - "Mooring System Installation 115.64 \n", - "Turbine Installation 0.00 \n", - "Soft 543.16 \n", - "Project 252.08 " - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Loss TypeValue (%)
0Environmental Losses1.59
1Availability Losses4.42
2Wake Losses7.47
3Technical Losses1.00
4Electrical Losses3.52
5Total Losses16.86
\n", + "
" ], - "source": [ - "# Capture the CapEx breakdown from each scenario\n", - "df_capex_fixed = pd.DataFrame(\n", - " project_fixed.orbit.capex_breakdown.items(),\n", - " columns=[\"Component\", \"CapEx ($) - Fixed\"]\n", - ")\n", - "df_capex_floating = pd.DataFrame(\n", - " project_floating.orbit.capex_breakdown.items(),\n", - " columns=[\"Component\", \"CapEx ($) - Floating\"]\n", - ")\n", - "\n", - "# Compute the normalized CapEx for each scenario\n", - "df_capex_fixed[\"CapEx ($/kW) - Fixed\"] = df_capex_fixed[\"CapEx ($) - Fixed\"] / project_fixed.capacity(\"kw\")\n", - "df_capex_floating[\"CapEx ($/kW) - Floating\"] = df_capex_floating[\"CapEx ($) - Floating\"] / project_floating.capacity(\"kw\")\n", - "\n", - "# Combine the results into one, easy to view dataframe\n", - "df_capex = df_capex_fixed.merge(\n", - " df_capex_floating,\n", - " on=\"Component\",\n", - " how=\"outer\",\n", - ").fillna(0.0).set_index(\"Component\")\n", - "df_capex = df_capex.iloc[pd.Categorical(df_capex.index, capex_order).argsort()]\n", - "df_capex" + "text/plain": [ + " Loss Type Value (%)\n", + "0 Environmental Losses 1.59\n", + "1 Availability Losses 4.42\n", + "2 Wake Losses 7.47\n", + "3 Technical Losses 1.00\n", + "4 Electrical Losses 3.52\n", + "5 Total Losses 16.86" ] - }, + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(\"Loss Breakdown Fixed-Bottom\")\n", + "project_fixed.energy_losses(losses_breakdown = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a2f99daa-5d65-4cc3-ae33-eb1be7cbdd8f", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "fdcc8d6a", - "metadata": {}, - "source": [ - "Now, let's generate the report, and then add in some additional reporting variables." - ] + "name": "stdout", + "output_type": "stream", + "text": [ + "Loss Breakdown Floating\n" + ] }, { - "cell_type": "code", - "execution_count": 8, - "id": "d2383f64", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
COE 2022 - FixedCOE 2022 - Floating
Metrics
# Turbines50.0050.00
Turbine Rating (MW)12.0012.00
Project Capacity (MW)600.00600.00
# OSS1.001.00
Total Export Cable Length (km)118.0789.17
Total Array Cable Length (km)277.98333.09
FCR (%)6.486.48
Offtake Price ($/MWh)83.3083.30
CapEx ($)2,524,329,479.243,196,659,962.31
CapEx per kW ($/kW)4,207.225,327.77
OpEx ($)1,060,154,836.28972,561,379.04
OpEx per kW ($/kW)1,766.921,620.94
Annual OpEx per kW ($/kW)84.1477.19
Energy Availability (%)94.5890.34
Gross Capacity Factor (%)52.9159.35
Net Capacity Factor With Wake Losses (%)46.7551.04
Net Capacity Factor With All Losses (%)41.4645.11
AEP (MWh)2,181,019.942,372,504.25
AEP per kW (MWh/kW)3.643.95
LCOE ($/MWh)98.15106.83
\n", - "
" - ], - "text/plain": [ - " COE 2022 - Fixed \\\n", - "Metrics \n", - "# Turbines 50.00 \n", - "Turbine Rating (MW) 12.00 \n", - "Project Capacity (MW) 600.00 \n", - "# OSS 1.00 \n", - "Total Export Cable Length (km) 118.07 \n", - "Total Array Cable Length (km) 277.98 \n", - "FCR (%) 6.48 \n", - "Offtake Price ($/MWh) 83.30 \n", - "CapEx ($) 2,524,329,479.24 \n", - "CapEx per kW ($/kW) 4,207.22 \n", - "OpEx ($) 1,060,154,836.28 \n", - "OpEx per kW ($/kW) 1,766.92 \n", - "Annual OpEx per kW ($/kW) 84.14 \n", - "Energy Availability (%) 94.58 \n", - "Gross Capacity Factor (%) 52.91 \n", - "Net Capacity Factor With Wake Losses (%) 46.75 \n", - "Net Capacity Factor With All Losses (%) 41.46 \n", - "AEP (MWh) 2,181,019.94 \n", - "AEP per kW (MWh/kW) 3.64 \n", - "LCOE ($/MWh) 98.15 \n", - "\n", - " COE 2022 - Floating \n", - "Metrics \n", - "# Turbines 50.00 \n", - "Turbine Rating (MW) 12.00 \n", - "Project Capacity (MW) 600.00 \n", - "# OSS 1.00 \n", - "Total Export Cable Length (km) 89.17 \n", - "Total Array Cable Length (km) 333.09 \n", - "FCR (%) 6.48 \n", - "Offtake Price ($/MWh) 83.30 \n", - "CapEx ($) 3,196,659,962.31 \n", - "CapEx per kW ($/kW) 5,327.77 \n", - "OpEx ($) 972,561,379.04 \n", - "OpEx per kW ($/kW) 1,620.94 \n", - "Annual OpEx per kW ($/kW) 77.19 \n", - "Energy Availability (%) 90.34 \n", - "Gross Capacity Factor (%) 59.35 \n", - "Net Capacity Factor With Wake Losses (%) 51.04 \n", - "Net Capacity Factor With All Losses (%) 45.11 \n", - "AEP (MWh) 2,372,504.25 \n", - "AEP per kW (MWh/kW) 3.95 \n", - "LCOE ($/MWh) 106.83 " - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Loss TypeValue (%)
0Environmental Losses1.59
1Availability Losses8.76
2Wake Losses5.81
3Technical Losses1.20
4Electrical Losses3.71
5Total Losses19.54
\n", + "
" ], - "source": [ - "project_name_fixed = \"COE 2022 - Fixed\"\n", - "project_name_floating = \"COE 2022 - Floating\"\n", - "\n", - "# Generate the reports using WAVES and the above configurations\n", - "# NOTE: the results are transposed to view them more easily for the example, otherwise\n", - "# each row would be a project, which is helpful for combining the results of many scenarios\n", - "report_df_fixed = project_fixed.generate_report(metrics_configuration, project_name_fixed).T\n", - "report_df_floating = project_floating.generate_report(metrics_configuration, project_name_floating).T\n", - "\n", - "# Gather some additional metadata and results from the projects\n", - "n_years_fixed = project_fixed.operations_years\n", - "n_years_floating = project_floating.operations_years\n", - "additional_reporting_fixed = pd.DataFrame(\n", - " [\n", - " [\"FCR (%)\", project_fixed.fixed_charge_rate],\n", - " [\"Offtake Price ($/MWh)\", project_fixed.offtake_price],\n", - " [\n", - " \"Annual OpEx per kW ($/kW)\",\n", - " report_df_fixed.loc[\"OpEx per kW ($/kW)\", project_name_fixed] / n_years_fixed\n", - " ],\n", - " ],\n", - " columns=[\"Project\"] + report_df_fixed.columns.tolist(),\n", - ").set_index(\"Project\")\n", - "\n", - "additional_reporting_floating = pd.DataFrame(\n", - " [\n", - " [\"FCR (%)\", project_floating.fixed_charge_rate],\n", - " [\"Offtake Price ($/MWh)\", project_floating.offtake_price],\n", - " [\n", - " \"Annual OpEx per kW ($/kW)\",\n", - " report_df_floating.loc[\"OpEx per kW ($/kW)\", project_name_floating] / n_years_floating\n", - " ],\n", - " ],\n", - " columns=[\"Project\"] + report_df_floating.columns.tolist(),\n", - ").set_index(\"Project\")\n", - "\n", - "# Combine the additional metrics to the generated report\n", - "report_df_fixed = pd.concat((report_df_fixed, additional_reporting_fixed), axis=0).loc[metrics_order]\n", - "report_df_floating = pd.concat((report_df_floating, additional_reporting_floating), axis=0).loc[metrics_order]\n", - "\n", - "# Combine both reports into one, easy to view dataframe\n", - "report_df = report_df_fixed.join(\n", - " report_df_floating,\n", - " how=\"outer\",\n", - ").fillna(0.0)\n", - "report_df.index.name = \"Metrics\"\n", - "\n", - "# Format percent-based rows to show as such, not as decimals\n", - "report_df.loc[report_df.index.str.contains(\"%\")] *= 100\n", - "\n", - "report_df" + "text/plain": [ + " Loss Type Value (%)\n", + "0 Environmental Losses 1.59\n", + "1 Availability Losses 8.76\n", + "2 Wake Losses 5.81\n", + "3 Technical Losses 1.20\n", + "4 Electrical Losses 3.71\n", + "5 Total Losses 19.54" ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" } - ], - "metadata": { - "jupytext": { - "text_representation": { - "extension": ".md", - "format_name": "myst" - } - }, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.13" - }, - "source_map": [ - 10, - 42, - 55, - 78, - 91, - 98, - 116, - 122, - 124, - 139, - 161, - 196, - 284, - 294, - 317, - 321 - ] + ], + "source": [ + "print(\"Loss Breakdown Floating\")\n", + "project_floating.energy_losses(losses_breakdown = True)" + ] + } + ], + "metadata": { + "jupytext": { + "text_representation": { + "extension": ".md", + "format_name": "myst" + } + }, + "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.14" }, - "nbformat": 4, - "nbformat_minor": 5 + "source_map": [ + 10, + 42, + 55, + 78, + 91, + 98, + 116, + 122, + 124, + 139, + 161, + 196, + 284, + 294, + 317, + 321 + ] + }, + "nbformat": 4, + "nbformat_minor": 5 } diff --git a/library/base_2022/project/config/base_fixed_bottom_2022.yaml b/library/base_2022/project/config/base_fixed_bottom_2022.yaml index 7b9c899..1248802 100644 --- a/library/base_2022/project/config/base_fixed_bottom_2022.yaml +++ b/library/base_2022/project/config/base_fixed_bottom_2022.yaml @@ -1,3 +1,6 @@ +#project type, can be "fixed", "floating" or "land" +turbine_type: fixed + # Primary model configurations orbit_config: base_fixed_bottom_2022_install.yaml wombat_config: base_fixed_bottom_2022_operations.yaml diff --git a/library/base_2022/project/config/base_floating_2022.yaml b/library/base_2022/project/config/base_floating_2022.yaml index 45a5589..c90e18a 100644 --- a/library/base_2022/project/config/base_floating_2022.yaml +++ b/library/base_2022/project/config/base_floating_2022.yaml @@ -1,3 +1,6 @@ +#project type, can be "fixed", "floating" or "land" +turbine_type: floating + # Primary model configurations orbit_config: base_floating_2022_install.yaml wombat_config: base_floating_2022_operations.yaml diff --git a/waves/project.py b/waves/project.py index 79189f5..275e2c0 100644 --- a/waves/project.py +++ b/waves/project.py @@ -262,6 +262,9 @@ class Project(FromDictMixin): fixed_charge_rate: float = field( default=0.0582, validator=attrs.validators.instance_of((float, type(None))) ) + environmental_loss_ratio: float = field( + default=0.0159, validator=attrs.validators.instance_of((float, type(None))) + ) discount_rate: float = field( default=None, validator=attrs.validators.instance_of((float, type(None))) ) @@ -1442,7 +1445,7 @@ def energy_production( by: str = "windfarm", units: str = "gw", per_capacity: str | None = None, - with_losses: bool = False, + environmental_loss_ratio: float | None = None, aep: bool = False, ) -> pd.DataFrame | float: """Computes the energy production, or annual energy production, in GWh, for the simulation @@ -1461,10 +1464,10 @@ def energy_production( Provide the energy production normalized by the project's capacity, in the desired units. If None, then the unnormalized energy production is returned, otherwise it must be one of "kw", "mw", or "gw". Defaults to None. - with_losses : bool, optional - Use the :py:attr:`Project.total_loss_ratio` to post-hoc consider environmental, - availability, wake, technical, and electrical losses in the energy production - aggregation. Defaults to False. + environmental_loss_ratio : float, optional + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + configuration. Defaults to 0.0159. aep : bool, optional Flag to return the energy production normalized by the number of years the plan is in operation. Note that :py:attr:`frequency` must be "project" for this to be computed. @@ -1487,8 +1490,6 @@ def energy_production( # For the wind rose outputs, only consider project-level availability because # wind rose AEP is a long-term estimation of energy production - # commenting availability out as we are trying to calculate aep just based on wakes - availability = self.wombat.metrics.production_based_availability( frequency="month-year", by="turbine" ).loc[:, self.floris_turbine_order] @@ -1500,7 +1501,6 @@ def energy_production( left_on="month", right_index=True, ).drop(labels=["drop"], axis=1) - # energy_gwh = availability * power / 1000 energy_gwh = power / 1000 if self.floris_results_type == "time_series": @@ -1527,12 +1527,6 @@ def energy_production( energy_gwh = energy_gwh.sum(axis=0).to_frame(name="Energy Production (GWh)").T else: energy_gwh = energy_gwh.values.sum() - - if with_losses: - # Get the base production numbers from WOMBAT - base_production = self.energy_potential(frequency=frequency, by=by, units="gw") - energy_gwh = base_production * (1 - self.total_loss_ratio()) - if aep: if frequency != "project": raise ValueError("`aep` can only be set to True, if `frequency`='project'.") @@ -1556,7 +1550,7 @@ def energy_losses( by: str = "windfarm", units: str = "gw", per_capacity: str | None = None, - with_losses: bool = False, + environmental_loss_ratio: float | None = None, aep: bool = False, losses_breakdown: bool = False, ) -> pd.DataFrame: @@ -1575,12 +1569,15 @@ def energy_losses( Provide the energy production normalized by the project's capacity, in the desired units. If None, then the unnormalized energy production is returned, otherwise it must be one of "kw", "mw", or "gw". Defaults to None. - with_losses : bool, optional - Use the :py:attr:`Project.total_loss_ratio` to post-hoc consider environmental, - availability, wake, technical, and electrical losses in the energy production - aggregation. Defaults to False. + environmental_loss_ratio : float, optional + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + configuration. Defaults to 0.0159. aep : bool, optional AEP for the annualized losses. Only used for :py:attr:`frequency` = "project". + losses_breakdown : bool, optional + Flag to return the losses breakdown including environmental, availability, wake, + technical, electrical losses, and total losses. Raises ------ @@ -1602,17 +1599,16 @@ def energy_losses( "month-year", by="turbine", units="kw", - with_losses=with_losses, )[self.wombat.metrics.turbine_id] losses = potential - production # Compute total loss ratio - total_loss_ratio = self.total_loss_ratio() + total_loss_ratio = self.total_loss_ratio(environmental_loss_ratio = environmental_loss_ratio) # display loss breakdown if losses_breakdown: - return self.losses_breakdown() + return self.losses_breakdown(environmental_loss_ratio = environmental_loss_ratio) unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} if by == "windfarm": @@ -1635,17 +1631,52 @@ def energy_losses( return losses / self.capacity(per_capacity) - def wake_loss_ratio(self) -> float: - """Calculate wake losses using FLORIS outputs. + def wake_losses( + self, + frequency: str = "project", + by: str = "windfarm", + units: str = "kw", + per_capacity: str | None = None, + aep: bool = False, + ratio: bool = False, + ) -> pd.DataFrame | float: + """Computes the wake losses, in GWh, for the simulation by extrapolating the + monthly wake loss contributions to AEP if FLORIS (with wakes) results were + computed by a wind rose, or using the time series results. + + Parameters + ---------- + frequency : str, optional + One of "project" (project total), "annual" (annual total), or "month-year" + (monthly totals for each year). + by : str, optional + One of "windfarm" (project level) or "turbine" (turbine level) to + indicate what level to calculate the wake losses. + per_capacity : str, optional + Provide the wake losses normalized by the project's capacity, in the desired + units. If None, then the unnormalized energy production is returned, otherwise it must + be one of "kw", "mw", or "gw". Defaults to None. + aep : bool, optional + Flag to return the wake losses normalized by the number of years the plan is in + operation. Note that :py:attr:`frequency` must be "project" for this to be computed. + ratio : bool, optional + Flag to return the wake loss ratio or the ratio of wake losses to the potential energy + generation. + + Raises + ------ + ValueError + Raised if ``frequency`` is not one of: "project", "annual", "month-year". Returns ------- - float - The wake loss ratio. + pd.DataFrame | float + The wind farm-level losses, in GWh, for the desired ``frequency``. """ + potential = self.energy_potential( - "month-year", - by="turbine", + frequency = "month-year", + by= "turbine", units="kw", ) @@ -1653,12 +1684,44 @@ def wake_loss_ratio(self) -> float: "month-year", by="turbine", units="kw", - with_losses=False, )[self.wombat.metrics.turbine_id] losses = potential - production - return losses.sum(axis=0).sum() / potential.sum(axis=0).sum() # type: ignore + if ratio == True: + return losses.sum(axis=0).sum() / potential.sum(axis=0).sum() + + if units == "kw": + losses = losses + if units == "mw": + losses = losses / 1e3 + if units == "gw": + losses = losses / 1e6 + + unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} + if by == "windfarm": + losses = losses.sum(axis=1).to_frame(f"Energy Losses ({unit_map[units]})") + + # Aggregate to the desired frequency level (nothing required for month-year) + if frequency == "annual": + losses = ( + losses.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) + ) + elif frequency == "project": + if by == "turbine": + losses = ( + losses.sum(axis=0).to_frame(name=f"Energy Losses ({unit_map[units]})").T + ) + else: + losses = losses.values.sum() + if aep: + if frequency != "project": + raise ValueError("`aep` can only be set to True, if `frequency`='project'.") + losses /= self.operations_years + + if per_capacity is None: + return losses + return losses / self.capacity(per_capacity) def technical_loss_ratio(self) -> float: """Calculate technical losses based on the project type. @@ -1701,19 +1764,19 @@ def electrical_loss_ratio(self) -> float: return electrical_loss_ratio - def environmental_loss_ratio(self) -> float: - """Set environmental loss assumption from ORCA. - - Returns - ------- - float - The environmental loss ratio. - """ - return 0.0159 - - def total_loss_ratio(self) -> float: + def total_loss_ratio( + self, + environmental_loss_ratio: float | None = None, + ) -> float: """Calculate total losses based on environmental, availability, wake, technical, and electrical losses. + + Parameters + ---------- + environmental_loss_ratio : float, optional + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + configuration. Defaults to 0.0159. Returns ------- @@ -1721,19 +1784,39 @@ def total_loss_ratio(self) -> float: The total loss ratio. """ + + # Check that the environmental loos ratio exists + if environmental_loss_ratio is None: + if (environmental_loss_ratio := self.environmental_loss_ratio) is None: + raise ValueError( + "`environmental_loss_ratio` wasn't defined in the Project settings or in the method" + " keyword arguments." + ) + + total_loss_ratio = 1 - ( - (1 - self.environmental_loss_ratio()) + (1 - environmental_loss_ratio) * (1 - (1 - self.availability(which="energy", frequency="project", by="windfarm"))) - * (1 - self.wake_loss_ratio()) + * (1 - self.wake_losses(ratio = True)) * (1 - self.technical_loss_ratio()) * (1 - self.electrical_loss_ratio()) ) return total_loss_ratio - def losses_breakdown(self) -> float: + def losses_breakdown( + self, + environmental_loss_ratio: float | None = None, + ) -> float: """Provide a categorical breakout of each of the above loss categories, and the total. + Parameters + ---------- + environmental_loss_ratio : float, optional + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + configuration. Defaults to 0.0159. + Returns ------- pd.DataFrame @@ -1749,13 +1832,21 @@ def losses_breakdown(self) -> float: "Total Losses", ] + # Check that the environmental loos ratio exists + if environmental_loss_ratio is None: + if (environmental_loss_ratio := self.environmental_loss_ratio) is None: + raise ValueError( + "`environmental_loss_ratio` wasn't defined in the Project settings or in the method" + " keyword arguments." + ) + values = [ - self.environmental_loss_ratio() * 100, + environmental_loss_ratio * 100, (1 - self.availability(which="energy", frequency="project", by="windfarm")) * 100, - self.wake_loss_ratio() * 100, + self.wake_losses(ratio = True) * 100, self.technical_loss_ratio() * 100, self.electrical_loss_ratio() * 100, - self.total_loss_ratio() * 100, + self.total_loss_ratio(environmental_loss_ratio = environmental_loss_ratio) * 100, ] losses_breakdown = pd.DataFrame({"Loss Type": loss_types, "Value (%)": values}) @@ -1812,7 +1903,7 @@ def capacity_factor( which: str, frequency: str = "project", by: str = "windfarm", - with_losses: bool = False, + environmental_loss_ratio: float | None = None, ) -> pd.DataFrame | float: """Calculates the capacity factor over a project's lifetime as a single value, annual average, or monthly average for the whole windfarm or by turbine. @@ -1826,12 +1917,12 @@ def capacity_factor( One of "project", "annual", "monthly", or "month-year". Defaults to "project". by : str One of "windfarm" or "turbine". Defaults to "windfarm". - with_losses : bool, optional - Use the :py:attr:`Project.total_loss_ratio` to post-hoc consider environmental, - availability, wake, technical, and electrical losses in the energy production - aggregation. Defaults to False. .. note:: This will only be checked for :py:attr:`which` = "net". + environmental_loss_ratio : float, optional + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + configuration. Defaults to 0.0159. Returns ------- @@ -1852,12 +1943,14 @@ def capacity_factor( by_turbine = by == "turbine" if which == "net": - numerator = self.energy_production( - frequency="month-year", - by="turbine", - units="kw", - with_losses=with_losses, + numerator = (1 - self.total_loss_ratio( + environmental_loss_ratio = environmental_loss_ratio ) + ) * self.energy_potential( + frequency="month-year", + by="turbine", + units="kw", + ) else: numerator = self.energy_potential( frequency="month-year", @@ -2613,7 +2706,7 @@ def lcoe( capex = self.capex(per_capacity="kw") if capex is None else capex opex = self.opex(per_capacity="kw") if opex is None else opex if aep is None: - aep = self.energy_production(units="mw", per_capacity="mw", aep=True, with_losses=True) + aep = self.energy_production(units="mw", per_capacity="mw", aep=True) if TYPE_CHECKING: assert isinstance(capex, float) and isinstance(opex, float) and isinstance(aep, float) return (capex * self.fixed_charge_rate + opex / self.operations_years) / (aep / 1000) From a6164679422535c204c83b1c7f9e9837f639f5c2 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 16 Sep 2024 09:49:44 -0700 Subject: [PATCH 04/23] add missing docstring and run pre-commit --- waves/project.py | 77 ++++++++++++++++++++++-------------------------- 1 file changed, 35 insertions(+), 42 deletions(-) diff --git a/waves/project.py b/waves/project.py index 275e2c0..373ebfa 100644 --- a/waves/project.py +++ b/waves/project.py @@ -183,6 +183,9 @@ class Project(FromDictMixin): Interest rate paid on the cash flows. Defaults to None. reinvestment_rate : float, optional Interest rate paid on the cash flows upon reinvestment. Defaults to None. + environmental_loss_ratio : float, optional + Percentage of environmental losses to deduct from the total energy production. Should be + represented as a decimal in the range of [0, 1]. Defaults to 0.0159. orbit_start_date : str | None The date to use for installation phase start timings that are set to "0" in the ``install_phases`` configuration. If None the raw configuration data will be used. @@ -395,9 +398,7 @@ def validate_report_config(self, attribute: attrs.Attribute, value: dict | None) raise ValueError("`report_config` must be a dictionary, if provided") if "name" not in value: - raise KeyError( - f"A key, value pair for `name` must be provided for the {attribute.name}." - ) + raise KeyError("A key, value pair for `name` must be provided for the simulation name.") # ********************************************************************************************** # Configuration methods @@ -1465,8 +1466,8 @@ def energy_production( units. If None, then the unnormalized energy production is returned, otherwise it must be one of "kw", "mw", or "gw". Defaults to None. environmental_loss_ratio : float, optional - The decimal environmental loss ratio to apply to the energy production. If None, then - it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project configuration. Defaults to 0.0159. aep : bool, optional Flag to return the energy production normalized by the number of years the plan is in @@ -1570,13 +1571,13 @@ def energy_losses( units. If None, then the unnormalized energy production is returned, otherwise it must be one of "kw", "mw", or "gw". Defaults to None. environmental_loss_ratio : float, optional - The decimal environmental loss ratio to apply to the energy production. If None, then - it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project configuration. Defaults to 0.0159. aep : bool, optional AEP for the annualized losses. Only used for :py:attr:`frequency` = "project". losses_breakdown : bool, optional - Flag to return the losses breakdown including environmental, availability, wake, + Flag to return the losses breakdown including environmental, availability, wake, technical, electrical losses, and total losses. Raises @@ -1604,11 +1605,11 @@ def energy_losses( losses = potential - production # Compute total loss ratio - total_loss_ratio = self.total_loss_ratio(environmental_loss_ratio = environmental_loss_ratio) + total_loss_ratio = self.total_loss_ratio(environmental_loss_ratio=environmental_loss_ratio) # display loss breakdown if losses_breakdown: - return self.losses_breakdown(environmental_loss_ratio = environmental_loss_ratio) + return self.losses_breakdown(environmental_loss_ratio=environmental_loss_ratio) unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} if by == "windfarm": @@ -1632,7 +1633,7 @@ def energy_losses( return losses / self.capacity(per_capacity) def wake_losses( - self, + self, frequency: str = "project", by: str = "windfarm", units: str = "kw", @@ -1640,8 +1641,8 @@ def wake_losses( aep: bool = False, ratio: bool = False, ) -> pd.DataFrame | float: - """Computes the wake losses, in GWh, for the simulation by extrapolating the - monthly wake loss contributions to AEP if FLORIS (with wakes) results were + """Computes the wake losses, in GWh, for the simulation by extrapolating the + monthly wake loss contributions to AEP if FLORIS (with wakes) results were computed by a wind rose, or using the time series results. Parameters @@ -1660,7 +1661,7 @@ def wake_losses( Flag to return the wake losses normalized by the number of years the plan is in operation. Note that :py:attr:`frequency` must be "project" for this to be computed. ratio : bool, optional - Flag to return the wake loss ratio or the ratio of wake losses to the potential energy + Flag to return the wake loss ratio or the ratio of wake losses to the potential energy generation. Raises @@ -1673,10 +1674,9 @@ def wake_losses( pd.DataFrame | float The wind farm-level losses, in GWh, for the desired ``frequency``. """ - potential = self.energy_potential( - frequency = "month-year", - by= "turbine", + frequency="month-year", + by="turbine", units="kw", ) @@ -1704,14 +1704,10 @@ def wake_losses( # Aggregate to the desired frequency level (nothing required for month-year) if frequency == "annual": - losses = ( - losses.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) - ) + losses = losses.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) elif frequency == "project": if by == "turbine": - losses = ( - losses.sum(axis=0).to_frame(name=f"Energy Losses ({unit_map[units]})").T - ) + losses = losses.sum(axis=0).to_frame(name=f"Energy Losses ({unit_map[units]})").T else: losses = losses.values.sum() if aep: @@ -1770,12 +1766,12 @@ def total_loss_ratio( ) -> float: """Calculate total losses based on environmental, availability, wake, technical, and electrical losses. - + Parameters ---------- environmental_loss_ratio : float, optional - The decimal environmental loss ratio to apply to the energy production. If None, then - it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project configuration. Defaults to 0.0159. Returns @@ -1784,7 +1780,6 @@ def total_loss_ratio( The total loss ratio. """ - # Check that the environmental loos ratio exists if environmental_loss_ratio is None: if (environmental_loss_ratio := self.environmental_loss_ratio) is None: @@ -1793,11 +1788,10 @@ def total_loss_ratio( " keyword arguments." ) - total_loss_ratio = 1 - ( (1 - environmental_loss_ratio) * (1 - (1 - self.availability(which="energy", frequency="project", by="windfarm"))) - * (1 - self.wake_losses(ratio = True)) + * (1 - self.wake_losses(ratio=True)) * (1 - self.technical_loss_ratio()) * (1 - self.electrical_loss_ratio()) ) @@ -1813,8 +1807,8 @@ def losses_breakdown( Parameters ---------- environmental_loss_ratio : float, optional - The decimal environmental loss ratio to apply to the energy production. If None, then - it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project configuration. Defaults to 0.0159. Returns @@ -1843,10 +1837,10 @@ def losses_breakdown( values = [ environmental_loss_ratio * 100, (1 - self.availability(which="energy", frequency="project", by="windfarm")) * 100, - self.wake_losses(ratio = True) * 100, + self.wake_losses(ratio=True) * 100, self.technical_loss_ratio() * 100, self.electrical_loss_ratio() * 100, - self.total_loss_ratio(environmental_loss_ratio = environmental_loss_ratio) * 100, + self.total_loss_ratio(environmental_loss_ratio=environmental_loss_ratio) * 100, ] losses_breakdown = pd.DataFrame({"Loss Type": loss_types, "Value (%)": values}) @@ -1920,8 +1914,8 @@ def capacity_factor( .. note:: This will only be checked for :py:attr:`which` = "net". environmental_loss_ratio : float, optional - The decimal environmental loss ratio to apply to the energy production. If None, then - it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project + The decimal environmental loss ratio to apply to the energy production. If None, then + it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project configuration. Defaults to 0.0159. Returns @@ -1943,14 +1937,13 @@ def capacity_factor( by_turbine = by == "turbine" if which == "net": - numerator = (1 - self.total_loss_ratio( - environmental_loss_ratio = environmental_loss_ratio + numerator = ( + 1 - self.total_loss_ratio(environmental_loss_ratio=environmental_loss_ratio) + ) * self.energy_potential( + frequency="month-year", + by="turbine", + units="kw", ) - ) * self.energy_potential( - frequency="month-year", - by="turbine", - units="kw", - ) else: numerator = self.energy_potential( frequency="month-year", From c51bfa032af16e0a9271fa458cbc99f363ae0f10 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 16 Sep 2024 10:15:30 -0700 Subject: [PATCH 05/23] fix error message --- waves/project.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/waves/project.py b/waves/project.py index 373ebfa..a1f5aad 100644 --- a/waves/project.py +++ b/waves/project.py @@ -398,7 +398,9 @@ def validate_report_config(self, attribute: attrs.Attribute, value: dict | None) raise ValueError("`report_config` must be a dictionary, if provided") if "name" not in value: - raise KeyError("A key, value pair for `name` must be provided for the simulation name.") + raise KeyError( + "A key, value pair for `name` must be provided for the simulation name." + ) # ********************************************************************************************** # Configuration methods @@ -1490,7 +1492,6 @@ def energy_production( # For the wind rose outputs, only consider project-level availability because # wind rose AEP is a long-term estimation of energy production - availability = self.wombat.metrics.production_based_availability( frequency="month-year", by="turbine" ).loc[:, self.floris_turbine_order] From ae8322a9e7996d7402578766514a84846a948b8e Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 16 Sep 2024 10:17:56 -0700 Subject: [PATCH 06/23] fix verbose bool check --- waves/project.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/waves/project.py b/waves/project.py index a1f5aad..8653ee7 100644 --- a/waves/project.py +++ b/waves/project.py @@ -398,9 +398,7 @@ def validate_report_config(self, attribute: attrs.Attribute, value: dict | None) raise ValueError("`report_config` must be a dictionary, if provided") if "name" not in value: - raise KeyError( - "A key, value pair for `name` must be provided for the simulation name." - ) + raise KeyError("A key, value pair for `name` must be provided for the simulation name.") # ********************************************************************************************** # Configuration methods @@ -1689,7 +1687,7 @@ def wake_losses( losses = potential - production - if ratio == True: + if ratio: return losses.sum(axis=0).sum() / potential.sum(axis=0).sum() if units == "kw": From ebb07ec6453e238e3f244b1b560d0f6ae8fea3b8 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 16 Sep 2024 10:46:22 -0700 Subject: [PATCH 07/23] fix typo in cable naming --- .../project/config/base_fixed_bottom_2022_install.yaml | 2 +- .../base_2022/project/config/base_floating_2022_install.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/library/base_2022/project/config/base_fixed_bottom_2022_install.yaml b/library/base_2022/project/config/base_fixed_bottom_2022_install.yaml index 24186a0..165a696 100644 --- a/library/base_2022/project/config/base_fixed_bottom_2022_install.yaml +++ b/library/base_2022/project/config/base_fixed_bottom_2022_install.yaml @@ -42,7 +42,7 @@ array_system_design: - XLPE_630mm_66kV location_data: base_fixed_bottom_2022_layout export_system_design: - cables: XLPE_1000m_220kV + cables: XLPE_1000mm_220kV percent_added_length: 0.0 OffshoreSubstationInstallation: feeder: demand_adjusted_heavy_feeder_vessel diff --git a/library/base_2022/project/config/base_floating_2022_install.yaml b/library/base_2022/project/config/base_floating_2022_install.yaml index 84edb27..c513dac 100644 --- a/library/base_2022/project/config/base_floating_2022_install.yaml +++ b/library/base_2022/project/config/base_floating_2022_install.yaml @@ -45,7 +45,7 @@ array_system_design: - XLPE_630mm_66kV location_data: base_floating_2022_layout export_system_design: - cables: XLPE_1000m_220kV + cables: XLPE_1000mm_220kV percent_added_length: 0.0 # Configured Phases design_phases: From 45aff5fca5a4a0850fcfb806aa55bd9eda213ac6 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 16 Sep 2024 10:51:21 -0700 Subject: [PATCH 08/23] update for ORBIT v1.1 compatibility --- library/base_2022/project/config/base_floating_2022_install.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/library/base_2022/project/config/base_floating_2022_install.yaml b/library/base_2022/project/config/base_floating_2022_install.yaml index c513dac..5a970b1 100644 --- a/library/base_2022/project/config/base_floating_2022_install.yaml +++ b/library/base_2022/project/config/base_floating_2022_install.yaml @@ -28,6 +28,7 @@ export_cable_install_vessel: demand_adjusted_cable_lay_vessel mooring_install_vessel: demand_adjusted_support_vessel oss_install_vessel: demand_adjusted_floating_heavy_lift_vessel support_vessel: demand_adjusted_support_vessel +ahts_vessel: example_ahts_vessel towing_vessel: demand_adjusted_towing_vessel towing_vessel_groups: num_groups : 1 # note these numbers are different than the default for ORBIT- I believe ORCA assumes only one installation group of 3 vessels total for floating From a036a0838d4abd7f08cf879aae16fd602c042446 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 16 Sep 2024 14:37:32 -0700 Subject: [PATCH 09/23] fix missing turbine potential bug in timeseries --- waves/utilities/floris_runners.py | 37 ++++++++++++++++++++----------- 1 file changed, 24 insertions(+), 13 deletions(-) diff --git a/waves/utilities/floris_runners.py b/waves/utilities/floris_runners.py index 183d371..4b1ac9f 100644 --- a/waves/utilities/floris_runners.py +++ b/waves/utilities/floris_runners.py @@ -19,7 +19,7 @@ def run_chunked_time_series_floris( args: tuple, -) -> tuple[tuple[int, int], FlorisInterface, pd.DataFrame]: +) -> tuple[tuple[int, int], FlorisInterface, pd.DataFrame, pd.DataFrame]: """Runs ``fi.calculate_wake()`` over a chunk of a larger time series analysis and returns the individual turbine powers for each corresponding time. @@ -39,9 +39,10 @@ def run_chunked_time_series_floris( Returns ------- - tuple[tuple[int, int], FlorisInterface, pd.DataFrame] + tuple[tuple[int, int], FlorisInterface, pd.DataFrame, pd.DataFrame] The ``chunk_id``, a reinitialized ``fi`` using the appropriate wind parameters - that can be used for further post-processing, and the resulting turbine powers. + that can be used for further post-processing, and the resulting turbine potential and + production powers. """ fi: FlorisInterface = args[0] weather: pd.DataFrame = args[1] @@ -49,18 +50,25 @@ def run_chunked_time_series_floris( reinit_kwargs: dict = args[3] run_kwargs: dict = args[4] + # Reinitialize the FLORIS interface reinit_kwargs["wind_directions"] = weather.wind_direction.values reinit_kwargs["wind_speeds"] = weather.windspeed.values fi.reinitialize(time_series=True, **reinit_kwargs) + + # Calculate energy potential + fi.calculate_no_wake(**run_kwargs) + potential_df = pd.DataFrame(fi.get_turbine_powers()[:, 0, :], index=weather.index) + + # Calculate waked energy production fi.calculate_wake(**run_kwargs) - power_df = pd.DataFrame(fi.get_turbine_powers()[:, 0, :], index=weather.index) - return chunk_id, fi, power_df + production_df = pd.DataFrame(fi.get_turbine_powers()[:, 0, :], index=weather.index) + return chunk_id, fi, potential_df, production_df def run_parallel_time_series_floris( args_list: list[tuple[FlorisInterface, pd.DataFrame, tuple[int, int], dict, dict]], nodes: int = -1, -) -> tuple[dict[tuple[int, int], FlorisInterface], pd.DataFrame]: +) -> tuple[dict[tuple[int, int], FlorisInterface], pd.DataFrame, pd.DataFrame]: """Runs the time series floris calculations in parallel. Parameters @@ -76,21 +84,24 @@ def run_parallel_time_series_floris( ------- tuple[dict[tuple[int, int], FlorisInterface], pd.DataFrame] A dictionary of the ``chunk_id`` and ``FlorisInterface`` object, and the full turbine power - dataframe (without renamed columns). + potential and production dataframes (without renamed columns). """ nodes = int(mp.cpu_count() * 0.7) if nodes == -1 else nodes with mp.Pool(nodes) as pool: with tqdm(total=len(args_list), desc="Time series energy calculation") as pbar: - df_list = [] + df_potential_list = [] + df_production_list = [] fi_dict = {} - for chunk_id, fi, df in pool.imap_unordered(run_chunked_time_series_floris, args_list): - df_list.append(df) - fi_dict[chunk_id] = fi + for i, fi, df1, df2 in pool.imap_unordered(run_chunked_time_series_floris, args_list): + df_potential_list.append(df1) + df_production_list.append(df2) + fi_dict[i] = fi pbar.update() fi_dict = dict(sorted(fi_dict.items())) - turbine_power_df = pd.concat(df_list).sort_index() - return fi_dict, turbine_power_df + turbine_potential_df = pd.concat(df_potential_list).sort_index() + turbine_production_df = pd.concat(df_production_list).sort_index() + return fi_dict, turbine_potential_df, turbine_production_df # ************************************************************************************************** From f9fca8adc64a0a1bfd04a9f7d236e2b186ae9e33 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Tue, 17 Sep 2024 08:28:52 -0700 Subject: [PATCH 10/23] apply intended changes and bug fixes to wake_losses --- waves/project.py | 117 +++++++++++++++++++++++++++++++++++++---------- 1 file changed, 93 insertions(+), 24 deletions(-) diff --git a/waves/project.py b/waves/project.py index 8653ee7..c599839 100644 --- a/waves/project.py +++ b/waves/project.py @@ -735,9 +735,9 @@ def preprocess_monthly_floris( ) zero_power_filter = np.full((weather.shape[0]), True) if cut_out_wind_speed is not None: - zero_power_filter = weather.windspeed < cut_out_wind_speed + zero_power_filter = weather.windspeed.to_numpy() < cut_out_wind_speed if cut_in_wind_speed is not None: - zero_power_filter &= weather.windspeed >= cut_in_wind_speed + zero_power_filter &= weather.windspeed.to_numpy() >= cut_in_wind_speed args = [ ( @@ -954,20 +954,20 @@ def run_floris( self.floris_results_type = "wind_rose" elif which == "time_series": + self.connect_floris_to_turbines(x_col=self.floris_x_col, y_col=self.floris_y_col) parallel_args, zero_power_filter = self.preprocess_monthly_floris( reinitialize_kwargs, run_kwargs, cut_in_wind_speed, cut_out_wind_speed ) - fi_dict, turbine_powers = run_parallel_time_series_floris(parallel_args, nodes) + fi_dict, potential, production = run_parallel_time_series_floris(parallel_args, nodes) self._fi_dict = fi_dict - self.turbine_aep_mwh = turbine_powers - self.connect_floris_to_turbines(x_col=self.floris_x_col, y_col=self.floris_y_col) + self.turbine_potential_energy = potential self.turbine_potential_energy.columns = self.floris_turbine_order self.turbine_potential_energy = ( self.turbine_potential_energy.where( np.repeat( zero_power_filter.reshape(-1, 1), - self.turbine_aep_mwh.shape[1], + self.turbine_potential_energy.shape[1], axis=1, ), 0.0, @@ -977,6 +977,22 @@ def run_floris( n_years = self.turbine_potential_energy.index.year.unique().size self.project_potential_energy = self.turbine_potential_energy.values.sum() / n_years + + self.turbine_production_energy = production + self.connect_floris_to_turbines(x_col=self.floris_x_col, y_col=self.floris_y_col) + self.turbine_production_energy.columns = self.floris_turbine_order + self.turbine_production_energy = ( + self.turbine_production_energy.where( + np.repeat( + zero_power_filter.reshape(-1, 1), + self.turbine_production_energy.shape[1], + axis=1, + ), + 0.0, + ) + / 1e6 + ) + self.project_production_energy = self.turbine_production_energy.values.sum() / n_years self.floris_results_type = "time_series" else: raise ValueError(f"`which` must be one of: 'wind_rose' or 'time_series', not: {which}") @@ -1673,42 +1689,95 @@ def wake_losses( pd.DataFrame | float The wind farm-level losses, in GWh, for the desired ``frequency``. """ - potential = self.energy_potential( - frequency="month-year", - by="turbine", - units="kw", - ) + # Use WOMBAT availability for the base index + availability = self.wombat.metrics.production_based_availability( + frequency="month-year", by="turbine" + ).loc[:, self.floris_turbine_order] - production = self.energy_production( # type: ignore - "month-year", - by="turbine", - units="kw", - )[self.wombat.metrics.turbine_id] + # Retrieve the energy potential and and waked energy based on the appropriate FLORIS method + if self.floris_results_type == "wind_rose": + potential_energy_gwh = pd.DataFrame( + 0.0, dtype=float, index=availability.index, columns=["drop"] + ) + potential_energy_gwh = potential_energy_gwh.merge( + self.turbine_potential_energy, + how="left", + left_on="month", + right_index=True, + ).drop(labels=["drop"], axis=1) + potential_energy_gwh = potential_energy_gwh / 1000 - losses = potential - production + waked_energy_gwh = pd.DataFrame( + 0.0, dtype=float, index=availability.index, columns=["drop"] + ) + waked_energy_gwh = waked_energy_gwh.merge( + self.turbine_production_energy, + how="left", + left_on="month", + right_index=True, + ).drop(labels=["drop"], axis=1) + waked_energy_gwh = waked_energy_gwh / 1000 + + elif self.floris_results_type == "time_series": + potential_energy_gwh = ( + self.turbine_potential_energy.groupby( + [ + self.turbine_potential_energy.index.year, + self.turbine_potential_energy.index.month, + ] + ) + .sum() + .loc[availability.index] + ) / 1000 + potential_energy_gwh.index.names = ["year", "month"] + + waked_energy_gwh = ( + self.turbine_production_energy.groupby( + [ + self.turbine_production_energy.index.year, + self.turbine_production_energy.index.month, + ] + ) + .sum() + .loc[availability.index] + ) / 1000 + waked_energy_gwh.index.names = ["year", "month"] - if ratio: - return losses.sum(axis=0).sum() / potential.sum(axis=0).sum() + losses = potential_energy_gwh - waked_energy_gwh if units == "kw": - losses = losses + losses = losses * 1e6 + potential = potential_energy_gwh * 1e6 if units == "mw": - losses = losses / 1e3 + losses = losses * 1e3 + potential = potential_energy_gwh * 1e3 if units == "gw": - losses = losses / 1e6 + losses = losses + potential = potential_energy_gwh unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} + name = f"Energy Losses ({'%' if not ratio else unit_map[units]})" if by == "windfarm": - losses = losses.sum(axis=1).to_frame(f"Energy Losses ({unit_map[units]})") + losses = losses.sum(axis=1).to_frame(name) + potential = potential.sum(axis=1).to_frame(name) # Aggregate to the desired frequency level (nothing required for month-year) if frequency == "annual": losses = losses.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) + potential = ( + potential.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) + ) elif frequency == "project": if by == "turbine": - losses = losses.sum(axis=0).to_frame(name=f"Energy Losses ({unit_map[units]})").T + losses = losses.sum(axis=0).to_frame(name).T + potential = potential.sum(axis=0).to_frame(name).T else: losses = losses.values.sum() + potential = potential.values.sum() + + if ratio: + return losses / potential + if aep: if frequency != "project": raise ValueError("`aep` can only be set to True, if `frequency`='project'.") From 601824a78bb3ca2d0d5b8a06b7bcc4968aa468a1 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Tue, 17 Sep 2024 08:56:00 -0700 Subject: [PATCH 11/23] fix remaining floris energy potential/production method issues --- waves/project.py | 60 ++++++++++++++++++++++++++---------------------- 1 file changed, 33 insertions(+), 27 deletions(-) diff --git a/waves/project.py b/waves/project.py index c599839..4dc56b4 100644 --- a/waves/project.py +++ b/waves/project.py @@ -1399,33 +1399,37 @@ def energy_potential( pd.DataFrame | float The wind farm-level energy prodcution, in GWh, for the desired ``frequency``. """ + # Use WOMBAT availability for the base index availability = self.wombat.metrics.production_based_availability( frequency="month-year", by="turbine" ).loc[:, self.floris_turbine_order] + if self.floris_results_type == "wind_rose": - power = pd.DataFrame(0.0, dtype=float, index=availability.index, columns=["drop"]) - power = power.merge( + energy_gwh = pd.DataFrame(0.0, dtype=float, index=availability.index, columns=["drop"]) + energy_gwh = energy_gwh.merge( self.turbine_potential_energy, how="left", left_on="month", right_index=True, ).drop(labels=["drop"], axis=1) - energy_gwh = power / 1000 + energy_gwh = energy_gwh / 1000 - if self.floris_results_type == "time_series": - energy_gwh = self.turbine_aep_mwh / 1000 - energy_gwh *= ( - self.turbine_potential_energy.assign( - year=energy_gwh.index.year, month=energy_gwh.index.month + elif self.floris_results_type == "time_series": + energy_gwh = ( + self.turbine_potential_energy.groupby( + [ + self.turbine_potential_energy.index.year, + self.turbine_potential_energy.index.month, + ] ) - .groupby(["year", "month"]) .sum() - .loc[energy_gwh.index] - ) + .loc[availability.index] + ) / 1000 + energy_gwh.index.names = ["year", "month"] unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} if by == "windfarm": - energy_gwh = energy_gwh.sum(axis=1).to_frame(f"Energy Losses ({unit_map[units]})") + energy_gwh = energy_gwh.sum(axis=1).to_frame(f"Energy Potential ({unit_map[units]})") # Aggregate to the desired frequency level (nothing required for month-year) if frequency == "annual": @@ -1435,7 +1439,7 @@ def energy_potential( elif frequency == "project": if by == "turbine": energy_gwh = ( - energy_gwh.sum(axis=0).to_frame(name=f"Energy Losses ({unit_map[units]})").T + energy_gwh.sum(axis=0).to_frame(name=f"Energy Potential ({unit_map[units]})").T ) else: energy_gwh = energy_gwh.values.sum() @@ -1504,31 +1508,33 @@ def energy_production( if frequency not in opts: raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore - # For the wind rose outputs, only consider project-level availability because - # wind rose AEP is a long-term estimation of energy production + # Use WOMBAT availability for the base index availability = self.wombat.metrics.production_based_availability( frequency="month-year", by="turbine" ).loc[:, self.floris_turbine_order] + if self.floris_results_type == "wind_rose": - power = pd.DataFrame(0.0, dtype=float, index=availability.index, columns=["drop"]) - power = power.merge( + energy_gwh = pd.DataFrame(0.0, dtype=float, index=availability.index, columns=["drop"]) + energy_gwh = energy_gwh.merge( self.turbine_production_energy, how="left", left_on="month", right_index=True, ).drop(labels=["drop"], axis=1) - energy_gwh = power / 1000 + energy_gwh = energy_gwh / 1000 - if self.floris_results_type == "time_series": - energy_gwh = self.turbine_aep_mwh / 1000 - energy_gwh *= ( - self.turbine_potential_energy.assign( - year=energy_gwh.index.year, month=energy_gwh.index.month + elif self.floris_results_type == "time_series": + energy_gwh = ( + self.turbine_production_energy.groupby( + [ + self.turbine_production_energy.index.year, + self.turbine_production_energy.index.month, + ] ) - .groupby(["year", "month"]) .sum() - .loc[energy_gwh.index] - ) + .loc[availability.index] + ) / 1000 + energy_gwh.index.names = ["year", "month"] if by == "windfarm": energy_gwh = energy_gwh.sum(axis=1).to_frame("Energy Production (GWh)") @@ -2013,7 +2019,7 @@ def capacity_factor( units="kw", ) else: - numerator = self.energy_potential( + numerator: pd.DataFrame = self.energy_potential( frequency="month-year", by="turbine", units="kw", From 93354065d7c14b7813ea758f5cd4798002af6f8e Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Tue, 17 Sep 2024 10:59:15 -0700 Subject: [PATCH 12/23] update error message --- waves/project.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/waves/project.py b/waves/project.py index 4dc56b4..0e14273 100644 --- a/waves/project.py +++ b/waves/project.py @@ -1858,8 +1858,8 @@ def total_loss_ratio( if environmental_loss_ratio is None: if (environmental_loss_ratio := self.environmental_loss_ratio) is None: raise ValueError( - "`environmental_loss_ratio` wasn't defined in the Project settings or in the method" - " keyword arguments." + "`environmental_loss_ratio` wasn neither defined in the Project settings nor" + " provided in the keyword arguments." ) total_loss_ratio = 1 - ( From 9fe330638613aaf49ce36d4e7c7edf38c5bac87f Mon Sep 17 00:00:00 2001 From: dmulash Date: Fri, 20 Sep 2024 13:09:07 -0600 Subject: [PATCH 13/23] Addressed feedback from RHammond2: energy_losses = potential * total_loss_ratio and descriptive note for total_loss_ratio method --- waves/project.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/waves/project.py b/waves/project.py index 0e14273..0f8dc1d 100644 --- a/waves/project.py +++ b/waves/project.py @@ -1617,17 +1617,11 @@ def energy_losses( units="kw", ) - production = self.energy_production( # type: ignore - "month-year", - by="turbine", - units="kw", - )[self.wombat.metrics.turbine_id] - - losses = potential - production - # Compute total loss ratio total_loss_ratio = self.total_loss_ratio(environmental_loss_ratio=environmental_loss_ratio) + losses = potential * total_loss_ratio + # display loss breakdown if losses_breakdown: return self.losses_breakdown(environmental_loss_ratio=environmental_loss_ratio) @@ -1841,6 +1835,9 @@ def total_loss_ratio( """Calculate total losses based on environmental, availability, wake, technical, and electrical losses. + .. note:: This method treats different types of losses as efficiencies and is applied + as in Equation 1 from Beiter et al. 2020 (https://www.nrel.gov/docs/fy21osti/77384.pdf). + Parameters ---------- environmental_loss_ratio : float, optional From 31acc7da62e76dc3a53fe33562c8ee652812fa3a Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 2 Dec 2024 13:29:52 -0800 Subject: [PATCH 14/23] udpate pre-commit configuration --- .pre-commit-config.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 73572b7..bbba346 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -6,14 +6,14 @@ repos: hooks: - id: isort name: isort - stages: [commit] + stages: [pre-commit] - repo: https://github.com/psf/black rev: 23.11.0 hooks: - id: black name: black - stages: [commit] + stages: [pre-commit] - repo: https://github.com/pre-commit/mirrors-mypy rev: 'v1.7.0' # Use the sha / tag you want to point at From 450e7e7ed0dc3d417f16f0a5a0f6bcc1b7cfdd5b Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 2 Dec 2024 13:30:26 -0800 Subject: [PATCH 15/23] shorten argument and run pre-commit --- waves/project.py | 22 +++++++++++++++------- 1 file changed, 15 insertions(+), 7 deletions(-) diff --git a/waves/project.py b/waves/project.py index 0f8dc1d..d29eca1 100644 --- a/waves/project.py +++ b/waves/project.py @@ -5,6 +5,7 @@ from __future__ import annotations import json +import warnings from copy import deepcopy from typing import TYPE_CHECKING from pathlib import Path @@ -1574,7 +1575,7 @@ def energy_losses( per_capacity: str | None = None, environmental_loss_ratio: float | None = None, aep: bool = False, - losses_breakdown: bool = False, + breakdown: bool = False, ) -> pd.DataFrame: """Computes the energy losses for the simulation by subtracting the energy production from the potential energy production. @@ -1597,10 +1598,13 @@ def energy_losses( configuration. Defaults to 0.0159. aep : bool, optional AEP for the annualized losses. Only used for :py:attr:`frequency` = "project". - losses_breakdown : bool, optional + breakdown : bool, optional Flag to return the losses breakdown including environmental, availability, wake, technical, electrical losses, and total losses. + .. note:: Returns the project-level breakdown only, regardless of :py:arg:`frequency` + input. + Raises ------ ValueError @@ -1621,9 +1625,12 @@ def energy_losses( total_loss_ratio = self.total_loss_ratio(environmental_loss_ratio=environmental_loss_ratio) losses = potential * total_loss_ratio + assert isinstance(losses, pd.DataFrame) # display loss breakdown - if losses_breakdown: + if breakdown: + if frequency != "project": + warnings.warn("`frequency` must be 'project' when `breakdown=True`") return self.losses_breakdown(environmental_loss_ratio=environmental_loss_ratio) unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} @@ -1835,7 +1842,7 @@ def total_loss_ratio( """Calculate total losses based on environmental, availability, wake, technical, and electrical losses. - .. note:: This method treats different types of losses as efficiencies and is applied + .. note:: This method treats different types of losses as efficiencies and is applied as in Equation 1 from Beiter et al. 2020 (https://www.nrel.gov/docs/fy21osti/77384.pdf). Parameters @@ -1901,8 +1908,8 @@ def losses_breakdown( if environmental_loss_ratio is None: if (environmental_loss_ratio := self.environmental_loss_ratio) is None: raise ValueError( - "`environmental_loss_ratio` wasn't defined in the Project settings or in the method" - " keyword arguments." + "`environmental_loss_ratio` wasn't defined in the Project settings or in the" + " method keyword arguments." ) values = [ @@ -2007,6 +2014,7 @@ def capacity_factor( raise ValueError('``by`` must be one of "windfarm" or "turbine".') by_turbine = by == "turbine" + numerator: pd.DataFrame if which == "net": numerator = ( 1 - self.total_loss_ratio(environmental_loss_ratio=environmental_loss_ratio) @@ -2016,7 +2024,7 @@ def capacity_factor( units="kw", ) else: - numerator: pd.DataFrame = self.energy_potential( + numerator = self.energy_potential( frequency="month-year", by="turbine", units="kw", From cb02d4b9e320dce756a8c22dc247050241246a86 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 2 Dec 2024 16:19:53 -0800 Subject: [PATCH 16/23] remove redundancies and fix small calculation issues --- waves/project.py | 234 ++++++++++++++++++----------------------------- 1 file changed, 91 insertions(+), 143 deletions(-) diff --git a/waves/project.py b/waves/project.py index d29eca1..3944e6d 100644 --- a/waves/project.py +++ b/waves/project.py @@ -5,7 +5,6 @@ from __future__ import annotations import json -import warnings from copy import deepcopy from typing import TYPE_CHECKING from pathlib import Path @@ -977,7 +976,7 @@ def run_floris( ) n_years = self.turbine_potential_energy.index.year.unique().size - self.project_potential_energy = self.turbine_potential_energy.values.sum() / n_years + self.project_potential_energy = self.turbine_potential_energy.values.sum() self.turbine_production_energy = production self.connect_floris_to_turbines(x_col=self.floris_x_col, y_col=self.floris_y_col) @@ -1382,6 +1381,8 @@ def energy_potential( by : str, optional One of "windfarm" (project level) or "turbine" (turbine level) to indicate what level to calculate the energy production. + units : str, optional + One of "gw", "mw", or "kw" to determine the units for energy production. per_capacity : str, optional Provide the energy production normalized by the project's capacity, in the desired units. If None, then the unnormalized energy production is returned, otherwise it must @@ -1401,12 +1402,12 @@ def energy_potential( The wind farm-level energy prodcution, in GWh, for the desired ``frequency``. """ # Use WOMBAT availability for the base index - availability = self.wombat.metrics.production_based_availability( + base_ix = self.wombat.metrics.production_based_availability( frequency="month-year", by="turbine" - ).loc[:, self.floris_turbine_order] + ).index if self.floris_results_type == "wind_rose": - energy_gwh = pd.DataFrame(0.0, dtype=float, index=availability.index, columns=["drop"]) + energy_gwh = pd.DataFrame(0.0, dtype=float, index=base_ix, columns=["drop"]) energy_gwh = energy_gwh.merge( self.turbine_potential_energy, how="left", @@ -1424,11 +1425,13 @@ def energy_potential( ] ) .sum() - .loc[availability.index] + .loc[base_ix] ) / 1000 energy_gwh.index.names = ["year", "month"] unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} + if units not in unit_map: + raise ValueError("`units` must be one of 'gw', 'mw', or 'kw'.") if by == "windfarm": energy_gwh = energy_gwh.sum(axis=1).to_frame(f"Energy Potential ({unit_map[units]})") @@ -1470,9 +1473,12 @@ def energy_production( environmental_loss_ratio: float | None = None, aep: bool = False, ) -> pd.DataFrame | float: - """Computes the energy production, or annual energy production, in GWh, for the simulation - by extrapolating the monthly contributions to AEP if FLORIS (with wakes) results were - computed by a wind rose, or using the time series results. + """Computes the energy production, or annual energy production. + + To compute the losses, the total loss ratio from :py:method:`loss_ratio` is applied + to each time step (e.g., month for month-year) rather than using each time step's losses. + This lower resolution apporach to turbine and time step energy stems from the nature of the + loss method itself, which is intended for farm-level results. Parameters ---------- @@ -1482,6 +1488,8 @@ def energy_production( by : str, optional One of "windfarm" (project level) or "turbine" (turbine level) to indicate what level to calculate the energy production. + units : str, optional + One of "gw", "mw", or "kw" to determine the units for energy production. per_capacity : str, optional Provide the energy production normalized by the project's capacity, in the desired units. If None, then the unnormalized energy production is returned, otherwise it must @@ -1509,58 +1517,28 @@ def energy_production( if frequency not in opts: raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore - # Use WOMBAT availability for the base index - availability = self.wombat.metrics.production_based_availability( - frequency="month-year", by="turbine" - ).loc[:, self.floris_turbine_order] + # Check the units + unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} + if units not in unit_map: + raise ValueError("`units` must be one of 'gw', 'mw', or 'kw'.") - if self.floris_results_type == "wind_rose": - energy_gwh = pd.DataFrame(0.0, dtype=float, index=availability.index, columns=["drop"]) - energy_gwh = energy_gwh.merge( - self.turbine_production_energy, - how="left", - left_on="month", - right_index=True, - ).drop(labels=["drop"], axis=1) - energy_gwh = energy_gwh / 1000 + energy = self.energy_potential( + frequency=frequency, + by=by, + units=units, + ) - elif self.floris_results_type == "time_series": - energy_gwh = ( - self.turbine_production_energy.groupby( - [ - self.turbine_production_energy.index.year, - self.turbine_production_energy.index.month, - ] - ) - .sum() - .loc[availability.index] - ) / 1000 - energy_gwh.index.names = ["year", "month"] + if TYPE_CHECKING: + assert isinstance(energy, pd.DataFrame) + # Convert naming from energy_potential() if by == "windfarm": - energy_gwh = energy_gwh.sum(axis=1).to_frame("Energy Production (GWh)") - - # Aggregate to the desired frequency level (nothing required for month-year) - if frequency == "annual": - energy_gwh = ( - energy_gwh.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) - ) - elif frequency == "project": + energy.columns = energy.columns.str.replace("Potential", "Production") + if frequency == "project": if by == "turbine": - energy_gwh = energy_gwh.sum(axis=0).to_frame(name="Energy Production (GWh)").T - else: - energy_gwh = energy_gwh.values.sum() - if aep: - if frequency != "project": - raise ValueError("`aep` can only be set to True, if `frequency`='project'.") - energy_gwh /= self.operations_years + energy.index = energy.index.str.replace("Potential", "Production") - if units == "kw": - energy = energy_gwh * 1e6 - if units == "mw": - energy = energy_gwh * 1e3 - if units == "gw": - energy = energy_gwh + energy *= 1 - self.loss_ratio(environmental_loss_ratio) if per_capacity is None: return energy @@ -1575,11 +1553,15 @@ def energy_losses( per_capacity: str | None = None, environmental_loss_ratio: float | None = None, aep: bool = False, - breakdown: bool = False, ) -> pd.DataFrame: """Computes the energy losses for the simulation by subtracting the energy production from the potential energy production. + To compute the losses, the total loss ratio from :py:method:`loss_ratio` is applied + to each time step (e.g., month for month-year) rather than using each time step's losses. + This lower resolution apporach to turbine and time step energy stems from the nature of the + loss method itself, which is intended for farm-level results. + Parameters ---------- frequency : str, optional @@ -1588,6 +1570,8 @@ def energy_losses( by : str, optional One of "windfarm" (project level) or "turbine" (turbine level) to indicate what level to calculate the energy production. + units : str, optional + One of "gw", "mw", or "kw" to determine the units for energy production. per_capacity : str, optional Provide the energy production normalized by the project's capacity, in the desired units. If None, then the unnormalized energy production is returned, otherwise it must @@ -1598,12 +1582,6 @@ def energy_losses( configuration. Defaults to 0.0159. aep : bool, optional AEP for the annualized losses. Only used for :py:attr:`frequency` = "project". - breakdown : bool, optional - Flag to return the losses breakdown including environmental, availability, wake, - technical, electrical losses, and total losses. - - .. note:: Returns the project-level breakdown only, regardless of :py:arg:`frequency` - input. Raises ------ @@ -1615,39 +1593,35 @@ def energy_losses( pd.DataFrame | float The wind farm-level energy prodcution, in GWh, for the desired ``frequency``. """ + # Check the frequency input + opts = ("project", "annual", "month-year") + if frequency not in opts: + raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore + + # Check the units + unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} + if units not in unit_map: + raise ValueError("`units` must be one of 'gw', 'mw', or 'kw'.") + potential = self.energy_potential( "month-year", by="turbine", - units="kw", + units=units, ) # Compute total loss ratio - total_loss_ratio = self.total_loss_ratio(environmental_loss_ratio=environmental_loss_ratio) - + total_loss_ratio = self.loss_ratio(environmental_loss_ratio=environmental_loss_ratio) losses = potential * total_loss_ratio - assert isinstance(losses, pd.DataFrame) - # display loss breakdown - if breakdown: - if frequency != "project": - warnings.warn("`frequency` must be 'project' when `breakdown=True`") - return self.losses_breakdown(environmental_loss_ratio=environmental_loss_ratio) + if TYPE_CHECKING: + assert isinstance(losses, pd.DataFrame) - unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} + # Convert naming from energy_potential() if by == "windfarm": - losses = losses.sum(axis=1).to_frame(f"Energy Losses ({unit_map[units]})") + losses.columns = losses.columns.str.replace("Potential", "Losses") if frequency == "project": - losses = losses.sum(axis=0) - if by == "windfarm": - losses = losses.values[0] - if aep: - losses /= self.operations_years - elif frequency == "annual": - losses = losses.groupby("year").sum() - if units == "mw": - losses /= 1e3 - elif units == "gw": - losses /= 1e6 + if by == "turbine": + losses.index = losses.index.str.replace("Potential", "Losses") if per_capacity is None: return losses @@ -1835,10 +1809,11 @@ def electrical_loss_ratio(self) -> float: return electrical_loss_ratio - def total_loss_ratio( + def loss_ratio( self, environmental_loss_ratio: float | None = None, - ) -> float: + breakdown: bool = False, + ) -> pd.DataFrame | float: """Calculate total losses based on environmental, availability, wake, technical, and electrical losses. @@ -1851,11 +1826,14 @@ def total_loss_ratio( The decimal environmental loss ratio to apply to the energy production. If None, then it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project configuration. Defaults to 0.0159. + breakdown : bool, optional + Flag to return the losses breakdown including environmental, availability, wake, + technical, electrical losses, and total losses. Returns ------- - float - The total loss ratio. + float | pd.DataFrame + The total loss ratio, or the DataFrame of all loss ratios. """ # Check that the environmental loos ratio exists @@ -1866,64 +1844,34 @@ def total_loss_ratio( " provided in the keyword arguments." ) - total_loss_ratio = 1 - ( + availability = 1 - self.availability(which="energy", frequency="project", by="windfarm") + wake = self.wake_losses(ratio=True) + technical = self.technical_loss_ratio() + electrical = self.electrical_loss_ratio() + total_loss = 1 - ( (1 - environmental_loss_ratio) - * (1 - (1 - self.availability(which="energy", frequency="project", by="windfarm"))) - * (1 - self.wake_losses(ratio=True)) - * (1 - self.technical_loss_ratio()) - * (1 - self.electrical_loss_ratio()) + * (1 - (availability)) + * (1 - wake) + * (1 - technical) + * (1 - electrical) ) + if breakdown: + loss_types = [ + "Environmental Losses", + "Availability Losses", + "Wake Losses", + "Technical Losses", + "Electrical Losses", + "Total Losses", + ] + loss_breakdown = pd.DataFrame( + [environmental_loss_ratio, availability, wake, technical, electrical, total_loss], + index=loss_types, + columns=["Loss Ratio"], + ) + return loss_breakdown - return total_loss_ratio - - def losses_breakdown( - self, - environmental_loss_ratio: float | None = None, - ) -> float: - """Provide a categorical breakout of each of the above loss categories, and the total. - - Parameters - ---------- - environmental_loss_ratio : float, optional - The decimal environmental loss ratio to apply to the energy production. If None, then - it will attempt to use the :py:attr:`environmental_loss_ratio` provided in the Project - configuration. Defaults to 0.0159. - - Returns - ------- - pd.DataFrame - Breakdown of all losses types considered and total losses in percentages. - - """ - loss_types = [ - "Environmental Losses", - "Availability Losses", - "Wake Losses", - "Technical Losses", - "Electrical Losses", - "Total Losses", - ] - - # Check that the environmental loos ratio exists - if environmental_loss_ratio is None: - if (environmental_loss_ratio := self.environmental_loss_ratio) is None: - raise ValueError( - "`environmental_loss_ratio` wasn't defined in the Project settings or in the" - " method keyword arguments." - ) - - values = [ - environmental_loss_ratio * 100, - (1 - self.availability(which="energy", frequency="project", by="windfarm")) * 100, - self.wake_losses(ratio=True) * 100, - self.technical_loss_ratio() * 100, - self.electrical_loss_ratio() * 100, - self.total_loss_ratio(environmental_loss_ratio=environmental_loss_ratio) * 100, - ] - - losses_breakdown = pd.DataFrame({"Loss Type": loss_types, "Value (%)": values}) - - return losses_breakdown + return total_loss def availability( self, which: str, frequency: str = "project", by: str = "windfarm" From 6de6f33bcc2bde4a6ad2f9b711682194d9f54b87 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 2 Dec 2024 16:40:16 -0800 Subject: [PATCH 17/23] fix small computation and aggregation bugs --- waves/project.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/waves/project.py b/waves/project.py index 3944e6d..8ec2b8e 100644 --- a/waves/project.py +++ b/waves/project.py @@ -1533,7 +1533,8 @@ def energy_production( # Convert naming from energy_potential() if by == "windfarm": - energy.columns = energy.columns.str.replace("Potential", "Production") + if frequency != "project": + energy.columns = energy.columns.str.replace("Potential", "Production") if frequency == "project": if by == "turbine": energy.index = energy.index.str.replace("Potential", "Production") @@ -1604,8 +1605,8 @@ def energy_losses( raise ValueError("`units` must be one of 'gw', 'mw', or 'kw'.") potential = self.energy_potential( - "month-year", - by="turbine", + frequency=frequency, + by=by, units=units, ) @@ -1618,7 +1619,8 @@ def energy_losses( # Convert naming from energy_potential() if by == "windfarm": - losses.columns = losses.columns.str.replace("Potential", "Losses") + if frequency != "project": + losses.columns = losses.columns.str.replace("Potential", "Losses") if frequency == "project": if by == "turbine": losses.index = losses.index.str.replace("Potential", "Losses") From 07f60b6d36cf1400ce13a6b9adb83c1edb2de51a Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 2 Dec 2024 16:54:29 -0800 Subject: [PATCH 18/23] update wake losses for potential --- waves/project.py | 53 ++++++++++++++++++++++-------------------------- 1 file changed, 24 insertions(+), 29 deletions(-) diff --git a/waves/project.py b/waves/project.py index 8ec2b8e..4860863 100644 --- a/waves/project.py +++ b/waves/project.py @@ -1672,27 +1672,34 @@ def wake_losses( pd.DataFrame | float The wind farm-level losses, in GWh, for the desired ``frequency``. """ + # Check the frequency input + opts = ("project", "annual", "month-year") + if frequency not in opts: + raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore + + # Check the units + unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} + if units not in unit_map: + raise ValueError("`units` must be one of 'gw', 'mw', or 'kw'.") + # Use WOMBAT availability for the base index - availability = self.wombat.metrics.production_based_availability( + base_ix = self.wombat.metrics.production_based_availability( frequency="month-year", by="turbine" - ).loc[:, self.floris_turbine_order] + ).index + + potential_energy_gwh = self.energy_potential( + frequency="month-year", + by="turbine", + units="gw", + ) + if TYPE_CHECKING: + assert isinstance(potential_energy_gwh, pd.DataFrame) + + # TODO: CHECK THIS WORKS # Retrieve the energy potential and and waked energy based on the appropriate FLORIS method if self.floris_results_type == "wind_rose": - potential_energy_gwh = pd.DataFrame( - 0.0, dtype=float, index=availability.index, columns=["drop"] - ) - potential_energy_gwh = potential_energy_gwh.merge( - self.turbine_potential_energy, - how="left", - left_on="month", - right_index=True, - ).drop(labels=["drop"], axis=1) - potential_energy_gwh = potential_energy_gwh / 1000 - - waked_energy_gwh = pd.DataFrame( - 0.0, dtype=float, index=availability.index, columns=["drop"] - ) + waked_energy_gwh = pd.DataFrame(0.0, dtype=float, index=base_ix, columns=["drop"]) waked_energy_gwh = waked_energy_gwh.merge( self.turbine_production_energy, how="left", @@ -1702,18 +1709,6 @@ def wake_losses( waked_energy_gwh = waked_energy_gwh / 1000 elif self.floris_results_type == "time_series": - potential_energy_gwh = ( - self.turbine_potential_energy.groupby( - [ - self.turbine_potential_energy.index.year, - self.turbine_potential_energy.index.month, - ] - ) - .sum() - .loc[availability.index] - ) / 1000 - potential_energy_gwh.index.names = ["year", "month"] - waked_energy_gwh = ( self.turbine_production_energy.groupby( [ @@ -1722,7 +1717,7 @@ def wake_losses( ] ) .sum() - .loc[availability.index] + .loc[base_ix] ) / 1000 waked_energy_gwh.index.names = ["year", "month"] From 1545ed923b95b230f85e98170f8e54909ee7136f Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 2 Dec 2024 16:56:03 -0800 Subject: [PATCH 19/23] update technical losses for unavailable land option --- waves/project.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/waves/project.py b/waves/project.py index 4860863..9ed2e1b 100644 --- a/waves/project.py +++ b/waves/project.py @@ -1779,8 +1779,10 @@ def technical_loss_ratio(self) -> float: """ if self.turbine_type == "floating": return 1 - (1 - 0.01) * (1 - 0.001) * (1 - 0.001) - else: + elif self.turbine_type == "fixed": return 0.01 + else: + raise NotImplementedError("land-based is not currently modeled") def electrical_loss_ratio(self) -> float: """Calculate electrical losses based on ORBIT parameters. From afe05b7dec91d7a2fcfd03943ae26c8e3a97cdec Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Mon, 2 Dec 2024 16:56:20 -0800 Subject: [PATCH 20/23] update changelog --- CHANGELOG.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 396b273..312309b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,21 @@ # CHANGELOG +## Unreleased (TBD) + +- A series of bugs in the FLORIS time series method have been fixed to ensure energy potential + and production calculations add up as expected. +- `loss_ratio` has been replaced with `environmental_loss_ratio` to account for the only loss + category that cannot be modeled in WAVES. +- `turbine_type` input has been added to indicate if a project is land-based (coming soon), or + fixed or floating offshore wind +- Energy losses are now available through: + - `Project.energy_losses()` for calculating total energy losses across varying granularities + - `Project.loss_ratio()` with an ability to provide categorical breakdowns + - `Project.technical_loss_ratio()` to calculate the ORCA technical losses. + - `Project.electrical_loss_ratio()` to calculate the ORCA technical losses. +- `Project.energy_potential()` now forms the basis of all energy production and loss methods to + ensure consistent computation. + ## 0.5.3 (7 May 2024) - A bug was fixed where the array system installation costs were nearly doubled when compared From 7d5b6d7bce06df41013f97a0ed3acb26a89696de Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Thu, 5 Dec 2024 16:16:23 -0800 Subject: [PATCH 21/23] add input validation and common floris energy capture method --- waves/project.py | 192 ++++++++++++++++------------------ waves/utilities/validators.py | 134 ++++++++++++++++++++++++ 2 files changed, 227 insertions(+), 99 deletions(-) create mode 100644 waves/utilities/validators.py diff --git a/waves/project.py b/waves/project.py index 9ed2e1b..97ba12c 100644 --- a/waves/project.py +++ b/waves/project.py @@ -35,6 +35,7 @@ run_parallel_time_series_floris, calculate_monthly_wind_rose_results, ) +from waves.utilities.validators import validate_common_inputs def convert_to_multi_index( @@ -1230,6 +1231,7 @@ def n_substations(self) -> int: return len(self.wombat.windfarm.substation_id) raise RuntimeError("No models wer provided, cannot calculate value.") + @validate_common_inputs(which=["units"]) def capacity(self, units: str = "mw") -> float: """Calculates the project's capacity in the desired units of kW, MW, or GW. @@ -1260,12 +1262,11 @@ def capacity(self, units: str = "mw") -> float: units = units.lower() if units == "kw": return capacity * 1000 - if units == "mw": - return capacity if units == "gw": return capacity / 1000 - raise ValueError("`units` must be one of: 'kw', 'mw', or 'gw'.") + return capacity + @validate_common_inputs(which=["per_capacity"]) def capex( self, breakdown: bool = False, per_capacity: str | None = None ) -> pd.DataFrame | float: @@ -1303,7 +1304,6 @@ def capex( return capex return capex.values[0, 0] - per_capacity = per_capacity.lower() capacity = self.capacity(per_capacity) unit_map = {"kw": "kW", "mw": "MW", "gw": "GW"} capex[f"CapEx per {unit_map[per_capacity]}"] = capex / capacity @@ -1361,6 +1361,66 @@ def export_system_total_cable_length(self): # Operational metrics + @validate_common_inputs(which=["frequency", "by", "units"]) + def _get_floris_energy( + self, which: str, frequency: str = "project", by: str = "windfarm", units: str = "gw" + ) -> pd.DataFrame | float: + unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} + + # Check the floris basis + if which not in ("potential", "production"): + raise ValueError("`which` should be one of 'potential' or 'production'") + + if which == "potential": + energy = self.turbine_potential_energy + else: + energy = self.turbine_production_energy + if by == "windfarm": + energy = energy.sum(axis=1).to_frame(f"Energy {which.title()} ({unit_map[units]})") + + # Use WOMBAT availability for the base index + base_ix = self.wombat.metrics.production_based_availability( + frequency="month-year", by="turbine" + ).index + + if self.floris_results_type == "wind_rose": + energy_gwh = pd.DataFrame(0.0, dtype=float, index=base_ix, columns=["drop"]) + energy_gwh = energy_gwh.merge( + energy, + how="left", + left_on="month", + right_index=True, + ).drop(labels=["drop"], axis=1) + energy_gwh /= 1000 + else: + energy_gwh = ( + energy.groupby([energy.index.year, energy.index.month]).sum().loc[base_ix] + ) / 1000 + energy_gwh.index.names = ["year", "month"] + + # Aggregate to the desired frequency level (nothing required for month-year) + if frequency == "annual": + energy_gwh = ( + energy_gwh.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) + ) + elif frequency == "project": + if by == "turbine": + energy_gwh = ( + energy_gwh.sum(axis=0) + .to_frame(name=f"Energy {which.title()} ({unit_map[units]})") + .T + ) + else: + energy_gwh = energy_gwh.values.sum() + + # Convert the units + if units == "kw": + return energy_gwh * 1e6 + if units == "mw": + return energy_gwh * 1e3 + return energy_gwh + + @validate_common_inputs(which=["frequency", "by", "units", "per_capacity"]) def energy_potential( self, frequency: str = "project", @@ -1430,8 +1490,6 @@ def energy_potential( energy_gwh.index.names = ["year", "month"] unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} - if units not in unit_map: - raise ValueError("`units` must be one of 'gw', 'mw', or 'kw'.") if by == "windfarm": energy_gwh = energy_gwh.sum(axis=1).to_frame(f"Energy Potential ({unit_map[units]})") @@ -1464,6 +1522,7 @@ def energy_potential( return energy return energy / self.capacity(per_capacity) + @validate_common_inputs(which=["frequency", "by", "units", "per_capacity"]) def energy_production( self, frequency: str = "project", @@ -1512,16 +1571,6 @@ def energy_production( pd.DataFrame | float The wind farm-level energy prodcution, in GWh, for the desired ``frequency``. """ - # Check the frequency input - opts = ("project", "annual", "month-year") - if frequency not in opts: - raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore - - # Check the units - unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} - if units not in unit_map: - raise ValueError("`units` must be one of 'gw', 'mw', or 'kw'.") - energy = self.energy_potential( frequency=frequency, by=by, @@ -1546,6 +1595,7 @@ def energy_production( return energy / self.capacity(per_capacity) + @validate_common_inputs(which=["frequency", "by", "units", "per_capacity"]) def energy_losses( self, frequency: str = "project", @@ -1594,16 +1644,6 @@ def energy_losses( pd.DataFrame | float The wind farm-level energy prodcution, in GWh, for the desired ``frequency``. """ - # Check the frequency input - opts = ("project", "annual", "month-year") - if frequency not in opts: - raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore - - # Check the units - unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} - if units not in unit_map: - raise ValueError("`units` must be one of 'gw', 'mw', or 'kw'.") - potential = self.energy_potential( frequency=frequency, by=by, @@ -1630,6 +1670,7 @@ def energy_losses( return losses / self.capacity(per_capacity) + @validate_common_inputs(which=["frequency", "by", "units", "per_capacity"]) def wake_losses( self, frequency: str = "project", @@ -1672,89 +1713,42 @@ def wake_losses( pd.DataFrame | float The wind farm-level losses, in GWh, for the desired ``frequency``. """ - # Check the frequency input - opts = ("project", "annual", "month-year") - if frequency not in opts: - raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore - - # Check the units unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} - if units not in unit_map: - raise ValueError("`units` must be one of 'gw', 'mw', or 'kw'.") # Use WOMBAT availability for the base index - base_ix = self.wombat.metrics.production_based_availability( - frequency="month-year", by="turbine" - ).index - - potential_energy_gwh = self.energy_potential( - frequency="month-year", - by="turbine", - units="gw", + potential_energy = self._get_floris_energy( + which="potential", + frequency=frequency, + by=by, + units=units, + ) + waked_energy = self._get_floris_energy( + which="production", + frequency=frequency, + by=by, + units=units, ) if TYPE_CHECKING: - assert isinstance(potential_energy_gwh, pd.DataFrame) - - # TODO: CHECK THIS WORKS + assert isinstance(potential_energy, pd.DataFrame) + assert isinstance(waked_energy, pd.DataFrame) - # Retrieve the energy potential and and waked energy based on the appropriate FLORIS method - if self.floris_results_type == "wind_rose": - waked_energy_gwh = pd.DataFrame(0.0, dtype=float, index=base_ix, columns=["drop"]) - waked_energy_gwh = waked_energy_gwh.merge( - self.turbine_production_energy, - how="left", - left_on="month", - right_index=True, - ).drop(labels=["drop"], axis=1) - waked_energy_gwh = waked_energy_gwh / 1000 - - elif self.floris_results_type == "time_series": - waked_energy_gwh = ( - self.turbine_production_energy.groupby( - [ - self.turbine_production_energy.index.year, - self.turbine_production_energy.index.month, - ] - ) - .sum() - .loc[base_ix] - ) / 1000 - waked_energy_gwh.index.names = ["year", "month"] - - losses = potential_energy_gwh - waked_energy_gwh - - if units == "kw": - losses = losses * 1e6 - potential = potential_energy_gwh * 1e6 - if units == "mw": - losses = losses * 1e3 - potential = potential_energy_gwh * 1e3 - if units == "gw": - losses = losses - potential = potential_energy_gwh + is_float = by == "windfarm" and frequency == "project" + if is_float: + losses = potential_energy - waked_energy + else: + losses = potential_energy - waked_energy.values + losses.index = losses.index.str.replace("Potential", "Losses") + losses.columns = losses.columns.str.replace("Potential", "Losses") unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} - name = f"Energy Losses ({'%' if not ratio else unit_map[units]})" - if by == "windfarm": - losses = losses.sum(axis=1).to_frame(name) - potential = potential.sum(axis=1).to_frame(name) - - # Aggregate to the desired frequency level (nothing required for month-year) - if frequency == "annual": - losses = losses.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) - potential = ( - potential.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) - ) - elif frequency == "project": - if by == "turbine": - losses = losses.sum(axis=0).to_frame(name).T - potential = potential.sum(axis=0).to_frame(name).T - else: - losses = losses.values.sum() - potential = potential.values.sum() + name = f"Energy Losses ({unit_map[units]})" if ratio: - return losses / potential + if is_float: + return losses / potential_energy + losses /= potential_energy.values + losses.index = losses.index.str.replace(name, "Loss Ratio") + losses.columns = losses.columns.str.replace(name, "Loss Ratio") if aep: if frequency != "project": diff --git a/waves/utilities/validators.py b/waves/utilities/validators.py new file mode 100644 index 0000000..8b231b3 --- /dev/null +++ b/waves/utilities/validators.py @@ -0,0 +1,134 @@ +""" +Provides a series of validation functions for commonly used keyword arguments in the +:py:class:`Project` results methods. +""" + +import inspect +from typing import Any +from functools import wraps +from collections.abc import Callable + + +def validate_frequency(frequency: str): + """Checks that the :py:attr:`frequency` input is valid. + + Parameters + ---------- + frequency : str + Date frequency for the timeseries aggregation. Must be one of "project", "annual", + or "month-year". + + Raises + ------ + ValueError + Raised if the input to :py:attr:`frequency` is not one of "project", "annual", + or "month-year". + """ + opts = ("project", "annual", "month-year") + if frequency not in opts: + raise ValueError(f"`frequency` must be one of {opts}. Provided: {frequency}.") + + +def validate_units(units: str): + """Checks that the :py:attr:`units` input is valid. + + Parameters + ---------- + units : str + Power-basis for the energy calculation. Must be one of "gw", "mw", or "kw". + + Raises + ------ + ValueError + Raised if the input to :py:attr:`units` is not one of "gw", "mw", or "kw". + """ + opts = ("gw", "mw", "kw") + if units not in opts: + raise ValueError(f"`units` must be one of {opts}. Provided: {units}.") + + +def validate_per_capacity(per_capacity: str | None): + """Checks that the :py:attr:`per_capacity` input is valid. + + Parameters + ---------- + per_capacity : str + Power-basis for the energy calculation. Must be one of "gw", "mw", "kw", or None. + + Raises + ------ + ValueError + Raised if the input to :py:attr:`per_capacity` is not one of "gw", "mw", or "kw". + """ + opts = ("gw", "mw", "kw", None) + if per_capacity not in opts: + raise ValueError(f"`per_capacity` must be one of {opts}. Provided: {per_capacity}.") + + +def validate_by(by: str): + """Checks that the :py:attr:`by` input is valid. + + Parameters + ---------- + by : str + Wind farm aggregation basis. Must be one of "windfarm" or "turbine". + + Raises + ------ + ValueError + Raised if the input to :py:attr:`by` is not one of "windfarm" or "turbine". + """ + opts = ("windfarm", "turbine") + if by not in opts: + raise ValueError(f"`by` must be one of {opts}. Provided: {by}.") + + +def validate_common_inputs(which: list[str] | None = None): + """Validates the standard inputs to many of :py:class:`Project`'s results methods. This is a + convenience wrapper to writing boilerplate checks for each aggregation method. + + Parameters + ---------- + which : list[str], optional + The names of the method arguments that should be validated. Can only be frequency, units, or + by. + """ + + def decorator(func: Callable): + """Gathes the arg indices from :py:attr:`data_cols` to be used in ``wrapper``.""" + argspec = inspect.getfullargspec(func) + signature = inspect.signature(func) + if which is None: + raise ValueError("No arguments provided for validation") + arg_ix_list = [argspec.args.index(name) for name in which] + + @wraps(func) + def wrapper(*args: Any, **kwargs: Any): + # Fetch the user inputs, convert them to the Series and None values, as appropriate, and + # update the args and kwargs for the new values + inputs = {} + for ix, name in zip(arg_ix_list, which): + try: + inputs[name] = args[ix] + except IndexError: + # Check that the argument isn't in fact an optional keyword argument + # and get the default if being used. + try: + inputs[name] = kwargs[name] + except KeyError: + inputs[name] = signature.parameters[name].default + + if "frequency" in inputs: + validate_frequency(inputs["frequency"]) + if "units" in inputs: + validate_units(inputs["units"]) + if "per_capacity" in inputs: + validate_per_capacity(inputs["per_capacity"]) + if "by" in inputs: + validate_by(inputs["by"]) + + return func(*args, **kwargs) + + return wrapper + + return decorator From 0b3a65cb1d7755e1dc2f0e0bcd759d524b2fdc5c Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Thu, 5 Dec 2024 16:46:54 -0800 Subject: [PATCH 22/23] update remaining metrics with validator decorator --- waves/project.py | 126 ++++++++++++++--------------------------------- 1 file changed, 37 insertions(+), 89 deletions(-) diff --git a/waves/project.py b/waves/project.py index 97ba12c..c329614 100644 --- a/waves/project.py +++ b/waves/project.py @@ -1461,62 +1461,12 @@ def energy_potential( pd.DataFrame | float The wind farm-level energy prodcution, in GWh, for the desired ``frequency``. """ - # Use WOMBAT availability for the base index - base_ix = self.wombat.metrics.production_based_availability( - frequency="month-year", by="turbine" - ).index - - if self.floris_results_type == "wind_rose": - energy_gwh = pd.DataFrame(0.0, dtype=float, index=base_ix, columns=["drop"]) - energy_gwh = energy_gwh.merge( - self.turbine_potential_energy, - how="left", - left_on="month", - right_index=True, - ).drop(labels=["drop"], axis=1) - energy_gwh = energy_gwh / 1000 - - elif self.floris_results_type == "time_series": - energy_gwh = ( - self.turbine_potential_energy.groupby( - [ - self.turbine_potential_energy.index.year, - self.turbine_potential_energy.index.month, - ] - ) - .sum() - .loc[base_ix] - ) / 1000 - energy_gwh.index.names = ["year", "month"] - - unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} - if by == "windfarm": - energy_gwh = energy_gwh.sum(axis=1).to_frame(f"Energy Potential ({unit_map[units]})") - - # Aggregate to the desired frequency level (nothing required for month-year) - if frequency == "annual": - energy_gwh = ( - energy_gwh.reset_index(drop=False).groupby("year").sum().drop(columns=["month"]) - ) - elif frequency == "project": - if by == "turbine": - energy_gwh = ( - energy_gwh.sum(axis=0).to_frame(name=f"Energy Potential ({unit_map[units]})").T - ) - else: - energy_gwh = energy_gwh.values.sum() - - if aep: - if frequency != "project": - raise ValueError("`aep` can only be set to True, if `frequency`='project'.") - energy_gwh /= self.operations_years - - if units == "kw": - energy = energy_gwh * 1e6 - if units == "mw": - energy = energy_gwh * 1e3 - if units == "gw": - energy = energy_gwh + energy = self._get_floris_energy( + which="potential", + frequency=frequency, + by=by, + units=units, + ) if per_capacity is None: return energy @@ -1737,8 +1687,11 @@ def wake_losses( losses = potential_energy - waked_energy else: losses = potential_energy - waked_energy.values - losses.index = losses.index.str.replace("Potential", "Losses") losses.columns = losses.columns.str.replace("Potential", "Losses") + try: + losses.index = losses.index.str.replace("Potential", "Losses") + except AttributeError: + pass # no need for multi index compatibility unit_map = {"kw": "kWh", "mw": "MWh", "gw": "GWh"} name = f"Energy Losses ({unit_map[units]})" @@ -1747,8 +1700,11 @@ def wake_losses( if is_float: return losses / potential_energy losses /= potential_energy.values - losses.index = losses.index.str.replace(name, "Loss Ratio") losses.columns = losses.columns.str.replace(name, "Loss Ratio") + try: + losses.index = losses.index.str.replace(name, "Loss Ratio") + except AttributeError: + pass # no need for multi index compatibility if aep: if frequency != "project": @@ -1838,15 +1794,15 @@ def loss_ratio( ) availability = 1 - self.availability(which="energy", frequency="project", by="windfarm") - wake = self.wake_losses(ratio=True) - technical = self.technical_loss_ratio() - electrical = self.electrical_loss_ratio() - total_loss = 1 - ( + wake_loss_ratio = self.wake_losses(ratio=True) + technical_loss_ratio = self.technical_loss_ratio() + electrical_loss_ratio = self.electrical_loss_ratio() + total_loss_ratio = 1 - ( (1 - environmental_loss_ratio) * (1 - (availability)) - * (1 - wake) - * (1 - technical) - * (1 - electrical) + * (1 - wake_loss_ratio) + * (1 - technical_loss_ratio) + * (1 - electrical_loss_ratio) ) if breakdown: loss_types = [ @@ -1858,14 +1814,22 @@ def loss_ratio( "Total Losses", ] loss_breakdown = pd.DataFrame( - [environmental_loss_ratio, availability, wake, technical, electrical, total_loss], + [ + environmental_loss_ratio, + availability, + wake_loss_ratio, + technical_loss_ratio, + electrical_loss_ratio, + total_loss_ratio, + ], index=loss_types, columns=["Loss Ratio"], ) return loss_breakdown - return total_loss + return total_loss_ratio + @validate_common_inputs(which=["frequency", "by"]) def availability( self, which: str, frequency: str = "project", by: str = "windfarm" ) -> pd.DataFrame | float: @@ -1911,6 +1875,7 @@ def availability( return availability.values[0, 0] return availability + @validate_common_inputs(which=["frequency", "by"]) def capacity_factor( self, which: str, @@ -1946,13 +1911,6 @@ def capacity_factor( if which not in ("net", "gross"): raise ValueError('``which`` must be one of "net" or "gross".') - opts = ("project", "annual", "month-year") - if frequency not in opts: - raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore - - by = by.lower().strip() - if by not in ("windfarm", "turbine"): - raise ValueError('``by`` must be one of "windfarm" or "turbine".') by_turbine = by == "turbine" numerator: pd.DataFrame @@ -2025,6 +1983,7 @@ def capacity_factor( capacity = capacity.sum(axis=1).to_frame(name=f"{which.title()} Capacity Factor") return numerator / capacity + @validate_common_inputs(which=["frequency", "per_capacity"]) def opex( self, frequency: str = "project", per_capacity: str | None = None ) -> pd.DataFrame | float: @@ -2055,6 +2014,7 @@ def opex( per_capacity = per_capacity.lower() return opex / self.capacity(per_capacity) + @validate_common_inputs(which=["frequency"]) def revenue( self, frequency: str = "project", @@ -2080,11 +2040,6 @@ def revenue( pd.DataFrame | float The revenue stream of the wind farm at the provided frequency. """ - # Check the frequency input - opts = ("project", "annual", "month-year") - if frequency not in opts: - raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore - # Check that an offtake_price exists if offtake_price is None: if (offtake_price := self.offtake_price) is None: @@ -2109,6 +2064,7 @@ def revenue( per_capacity = per_capacity.lower() return revenue / self.capacity(per_capacity) + @validate_common_inputs(which=["frequency"]) def capex_breakdown( self, frequency: str = "month-year", @@ -2180,11 +2136,6 @@ def capex_breakdown( TypeError Raised if a valid starting date can't be found for the installation. """ - # Check the frequency input - opts = ("project", "annual", "month-year") - if frequency not in opts: - raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore - # Find a valid starting date for the installation processes if (start_date := installation_start_date) is None: if (start_date := self.orbit_start_date) is None: @@ -2325,6 +2276,7 @@ def capex_breakdown( return capex_df return capex_df.CapEx.to_frame() + @validate_common_inputs(which=["frequency"]) def cash_flow( self, frequency: str = "month-year", @@ -2546,6 +2498,7 @@ def cash_flow( return cost_df return cost_df.cash_flow.to_frame() + @validate_common_inputs(which=["frequency"]) def npv( self, frequency: str = "project", @@ -2579,11 +2532,6 @@ def npv( pd.DataFrame The project net prsent value at the desired time resolution. """ - # Check the frequency input - opts = ("project", "annual", "month-year") - if frequency not in opts: - raise ValueError(f"`frequency` must be one of {opts}.") # type: ignore - # Check that the discout rate exists if discount_rate is None: if (discount_rate := self.discount_rate) is None: From 69f2018a75985b4f5d140e765b1f63857863af39 Mon Sep 17 00:00:00 2001 From: RHammond2 <13874373+RHammond2@users.noreply.github.com> Date: Thu, 5 Dec 2024 16:52:28 -0800 Subject: [PATCH 23/23] update changelog --- CHANGELOG.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 312309b..2039742 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,12 +9,17 @@ - `turbine_type` input has been added to indicate if a project is land-based (coming soon), or fixed or floating offshore wind - Energy losses are now available through: + - `Project._get_floris_energy()` to aggregate the FLORIS energy potential and waked energy + production to the correct level in place using the same methodology in multiple methods. - `Project.energy_losses()` for calculating total energy losses across varying granularities - `Project.loss_ratio()` with an ability to provide categorical breakdowns - `Project.technical_loss_ratio()` to calculate the ORCA technical losses. - `Project.electrical_loss_ratio()` to calculate the ORCA technical losses. - `Project.energy_potential()` now forms the basis of all energy production and loss methods to ensure consistent computation. +- A new series of validators have been added for commonly used parameterizations alongside a + decorator `@validate_common_inputs(which=...)` to apply the validations automatically before the + main methodology is run. ## 0.5.3 (7 May 2024)