floris 4.2.1__py3-none-any.whl

floris/__init__.py

@@ -0,0 +1,24 @@
+
+from importlib.metadata import version
+from pathlib import Path
+
+
+__version__ = version("floris")
+
+
+from .floris_model import FlorisModel
+from .flow_visualization import (
+    plot_rotor_values,
+    visualize_cut_plane,
+    visualize_quiver,
+)
+from .heterogeneous_map import HeterogeneousMap
+from .par_floris_model import ParFlorisModel
+from .parallel_floris_model import ParallelFlorisModel
+from .uncertain_floris_model import ApproxFlorisModel, UncertainFlorisModel
+from .wind_data import (
+    TimeSeries,
+    WindRose,
+    WindRoseWRG,
+    WindTIRose,
+)

floris/convert_floris_input_v3_to_v4.py

@@ -0,0 +1,93 @@
+import sys
+from pathlib import Path
+
+import yaml
+
+
+"""
+This script is intended to be called with an argument and converts a floris input
+yaml file specified for FLORIS v3 to one specified for FLORIS v4.
+
+Usage:
+python convert_floris_input_v3_to_v4.py <path/to/floris_input>.yaml
+
+The resulting floris input file is placed in the same directory as the original yaml,
+and is appended _v4.
+"""
+
+
+def ignore_include(loader, node):
+    # Parrot back the !include tag
+    return node.tag + " " + node.value
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        raise Exception(
+            "Usage: python convert_floris_input_v3_to_v4.py <path/to/floris_input>.yaml"
+        )
+
+    # Set the yaml loader to ignore the !include tag
+    yaml.SafeLoader.add_constructor("!include", ignore_include)
+
+    input_yaml = sys.argv[1]
+
+    # Handling the path and new filename
+    input_path = Path(input_yaml)
+    split_input = input_path.parts
+    [filename_v3, extension] = split_input[-1].split(".")
+    filename_v4 = filename_v3 + "_v4"
+    split_output = list(split_input[:-1]) + [filename_v4 + "." + extension]
+    output_path = Path(*split_output)
+
+    # Load existing v3 model
+    with open(input_yaml, "r") as file:
+        v3_floris_input_dict = yaml.safe_load(file)
+    v4_floris_input_dict = v3_floris_input_dict.copy()
+
+    # Change turbulence_intensity field to turbulence_intensities as list
+    if "turbulence_intensities" in v3_floris_input_dict["flow_field"]:
+        if "turbulence_intensity" in v3_floris_input_dict["flow_field"]:
+            del v4_floris_input_dict["flow_field"]["turbulence_intensity"]
+    elif "turbulence_intensity" in v3_floris_input_dict["flow_field"]:
+        v4_floris_input_dict["flow_field"]["turbulence_intensities"] = [
+            v3_floris_input_dict["flow_field"]["turbulence_intensity"]
+        ]
+        del v4_floris_input_dict["flow_field"]["turbulence_intensity"]
+
+    # Change multidim_cp_ct velocity model to gauss
+    if v3_floris_input_dict["wake"]["model_strings"]["velocity_model"] == "multidim_cp_ct":
+        print(
+            "multidim_cp_ct velocity model specified. Changing to gauss, "
+            + "but note that other velocity models are also compatible with multidimensional "
+            + "turbines in FLORIS v4. "
+            + "You will also need to convert your multidimensional turbine yaml files and their "
+            + "corresponding power/thrust csv files to be compatible with FLORIS v4 and to reflect "
+            + " the absolute power curve, rather than the power coefficient curve."
+        )
+        v4_floris_input_dict["wake"]["model_strings"]["velocity_model"] = "gauss"
+
+    # Add enable_active_wake_mixing field
+    v4_floris_input_dict["wake"]["enable_active_wake_mixing"] = False
+
+    # Write the new v4 model to a new file, note that the in order to ignore the !include tag
+    # it is wrapped in single quotes by the ignore include/load/dump sequence and these will
+    # need to be removed in the next block of code
+    yaml.dump(v4_floris_input_dict, open(output_path, "w"), sort_keys=False)
+
+    # Open the output file and loop through line by line
+    # if a line contains the substring !include, then strip all
+    # occurrences of ' from the line to remove the extra single quotes
+    # added by the ignore include/load/dump sequence
+    temp_output_path = output_path.with_name("temp.yaml")
+    with open(temp_output_path, "w") as file:
+        with open(output_path, "r") as f:
+            for line in f:
+                if "!include" in line:
+                    line = line.replace("'", "")
+                file.write(line)
+
+    # Move the temp file to the output file
+    temp_output_path.replace(output_path)
+
+    print(output_path, "created.")

floris/convert_turbine_v3_to_v4.py

@@ -0,0 +1,86 @@
+
+import sys
+from pathlib import Path
+
+from floris.turbine_library import build_cosine_loss_turbine_dict, check_smooth_power_curve
+from floris.utilities import load_yaml
+
+
+"""
+This script is intended to be called with an argument and converts a turbine
+yaml file specified for FLORIS v3 to one specified for FLORIS v4.
+
+Usage:
+python convert_turbine_v3_to_v4.py <path/to/turbine>.yaml
+
+The resulting turbine is placed in the same directory as the original yaml,
+and is appended _v4.
+"""
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        raise Exception("Usage: python convert_turbine_v3_to_v4.py <path/to/turbine>.yaml")
+
+    input_yaml = sys.argv[1]
+
+    # Handling the path and new filename
+    input_path = Path(input_yaml)
+    split_input = input_path.parts
+    [filename_v3, extension] = split_input[-1].split(".")
+    filename_v4 = filename_v3 + "_v4"
+    split_output = list(split_input[:-1]) + [filename_v4+"."+extension]
+    output_path = Path(*split_output)
+
+    # Load existing v3 model
+    v3_turbine_dict = load_yaml(input_yaml)
+
+    # Split into components expected by build_turbine_dict
+    power_thrust_table = v3_turbine_dict["power_thrust_table"]
+    if "power_thrust_data_file" in power_thrust_table:
+        raise ValueError(
+            "Cannot convert multidimensional turbine model. Please manually update your "
+            + "turbine yaml. Note that the power_thrust_data_file csv needs to be updated to "
+            + "reflect the absolute power curve, rather than the power coefficient curve,"
+            + "and that `thrust` has been replaced by `thrust_coefficient`."
+        )
+    power_thrust_table["power_coefficient"] = power_thrust_table["power"]
+    power_thrust_table["thrust_coefficient"] = power_thrust_table["thrust"]
+    power_thrust_table.pop("power")
+    power_thrust_table.pop("thrust")
+
+    valid_properties = [
+        "generator_efficiency",
+        "hub_height",
+        "cosine_loss_exponent_yaw",
+        "cosine_loss_exponent_tilt",
+        "rotor_diameter",
+        "TSR",
+        "ref_air_density",
+        "ref_tilt"
+    ]
+
+    turbine_properties = {k:v for k,v in v3_turbine_dict.items() if k in valid_properties}
+    turbine_properties["ref_air_density"] = v3_turbine_dict["ref_density_cp_ct"]
+    turbine_properties["cosine_loss_exponent_yaw"] = v3_turbine_dict["pP"]
+    if "ref_tilt_cp_ct" in v3_turbine_dict:
+        turbine_properties["ref_tilt"] = v3_turbine_dict["ref_tilt_cp_ct"]
+    if "pT" in v3_turbine_dict:
+        turbine_properties["cosine_loss_exponent_tilt"] = v3_turbine_dict["pT"]
+
+    # Convert to v4 and print new yaml
+    v4_turbine_dict = build_cosine_loss_turbine_dict(
+        power_thrust_table,
+        v3_turbine_dict["turbine_type"],
+        output_path,
+        **turbine_properties
+    )
+
+    if not check_smooth_power_curve(
+        v4_turbine_dict["power_thrust_table"]["power"],
+        tolerance=0.001
+    ):
+        print(
+            "Non-smoothness detected in output power curve. ",
+            "Check above-rated power in generated v4 yaml file."
+        )

floris/core/__init__.py

@@ -0,0 +1,61 @@
+
+"""
+The :py:obj:`floris` package contains :py:obj:`floris.utilities` module
+and the modules that make up the FLORIS software. The floris simulation
+modules are used to complete a wake simulation for a given wind farm
+and turbine configuration.
+
+All modules and package can be imported with
+
+    >>> import floris
+
+The ``__init__.py`` file enables the import of all modules in this
+package so any additional modules should be included there.
+
+isort:skip_file
+"""
+
+# Provide full-path imports here for all modules
+# that should be included in the simulation package.
+# Since some of these depend on each other, the order
+# that they are listed here does matter.
+
+import floris.logging_manager
+
+from .base import BaseClass, BaseModel, State
+from .turbine.turbine import (
+    axial_induction,
+    power,
+    thrust_coefficient,
+    Turbine
+)
+from .rotor_velocity import (
+    average_velocity,
+    rotor_effective_velocity,
+    compute_tilt_angles_for_floating_turbines,
+)
+from .farm import Farm
+from .grid import (
+    FlowFieldGrid,
+    FlowFieldPlanarGrid,
+    Grid,
+    PointsGrid,
+    TurbineGrid,
+    TurbineCubatureGrid
+)
+from .flow_field import FlowField
+from .wake import WakeModelManager
+from .solver import (
+    cc_solver,
+    empirical_gauss_solver,
+    full_flow_cc_solver,
+    full_flow_empirical_gauss_solver,
+    full_flow_sequential_solver,
+    full_flow_turbopark_solver,
+    sequential_solver,
+    turbopark_solver,
+)
+from .core import Core
+
+# initialize the logger
+floris.logging_manager._setup_logger()

floris/core/base.py

@@ -0,0 +1,65 @@
+
+from abc import abstractmethod
+from enum import Enum
+from typing import (
+    Any,
+    Dict,
+    Final,
+)
+
+from attrs import (
+    Attribute,
+    define,
+    field,
+    fields,
+    setters,
+)
+
+from floris.logging_manager import LoggingManager
+from floris.type_dec import FromDictMixin
+
+
+"""
+Defines the BaseClass parent class for all models to be based upon.
+"""
+
+
+class State(Enum):
+    UNINITIALIZED = 0
+    INITIALIZED = 1
+    USED = 2
+
+
+@define
+class BaseClass(FromDictMixin):
+    """
+    BaseClass object class. This class does the logging and MixIn class inheritance.
+    """
+
+    # Initialize `state` and ensure it is treated as an attribute rather than a constant parameter.
+    # See https://www.attrs.org/en/stable/api-attr.html#attr.ib
+    state = field(init=False, default=State.UNINITIALIZED)
+    _logging_manager: LoggingManager = field(init=False, default=LoggingManager())
+
+    @property
+    def logger(self):
+        """Returns the logger manager object."""
+        return self._logging_manager.logger
+
+@define
+class BaseModel(BaseClass):
+    """
+    BaseModel is the generic class for any wake models. It defines the API required to
+    create a valid model.
+    """
+
+    # This is a numerical epsilon to prevent divide by zeros
+    NUM_EPS: Final[float] = field(init=False, default=0.001, on_setattr=setters.frozen)
+
+    @abstractmethod
+    def prepare_function() -> dict:
+        raise NotImplementedError("BaseModel.prepare_function")
+
+    @abstractmethod
+    def function() -> None:
+        raise NotImplementedError("BaseModel.function")