foxes 0.7.3.1__py3-none-any.whl → 0.7.4.3__py3-none-any.whl

foxes/input/windio/read_fields.py

@@ -20,6 +20,7 @@ wio2foxes = {
     "turbulence_intensity": FV.TI,
     "LMO": FV.MOL,
     "z0": FV.Z0,
+    "reference_height": FV.H,
 }
 
 """ Mapping from foxes to windio variables
@@ -27,8 +28,7 @@ wio2foxes = {
 """
 foxes2wio = {d: k for k, d in wio2foxes.items()}
 
-
-def _read_nondimensional_coordinate(name, wio_data, coords, fields, dims):
+def _read_nondimensional_coordinate(name, wio_data, coords):
     """read nondimensional coordinate
     :group: input.windio
     """
@@ -37,8 +37,7 @@ def _read_nondimensional_coordinate(name, wio_data, coords, fields, dims):
         return True
     return False
 
-
-def _read_dimensional_coordinate(name, wio_data, coords, fields, dims):
+def _read_dimensional_coordinate(name, wio_data, coords):
     """read dimensional coordinate
     :group: input.windio
     """
@@ -49,17 +48,15 @@ def _read_dimensional_coordinate(name, wio_data, coords, fields, dims):
         return True
     return False
 
-
-def _read_multi_dimensional_coordinate(*args, **kwargs):
+def _read_multi_dimensional_coordinate(name, wio_data, coords):
     """Read multi dimensional coordinate
     :group: input.windio
     """
     return _read_nondimensional_coordinate(
-        *args, **kwargs
-    ) or _read_dimensional_coordinate(*args, **kwargs)
+        name, wio_data, coords
+    ) or _read_dimensional_coordinate(name, wio_data, coords)
 
-
-def _read_nondimensional_data(name, wio_data, coords, fields, dims):
+def _read_nondimensional_data(name, wio_data, fields, dims):
     """read nondimensional data
     :group: input.windio
     """
@@ -70,8 +67,7 @@ def _read_nondimensional_data(name, wio_data, coords, fields, dims):
         return True
     return False
 
-
-def _read_dimensional_data(name, wio_data, coords, fields, dims):
+def _read_dimensional_data(name, wio_data, fields, dims):
     """read dimensional data
     :group: input.windio
     """
@@ -87,17 +83,22 @@ def _read_dimensional_data(name, wio_data, coords, fields, dims):
         return True
     return False
 
-
-def _read_multi_dimensional_data(*args, **kwargs):
+def _read_multi_dimensional_data(name, wio_data, fields, dims):
     """Read multi dimensional data
     :group: input.windio
     """
-    return _read_nondimensional_data(*args, **kwargs) or _read_dimensional_data(
-        *args, **kwargs
-    )
-
-
-def read_wind_resource_field(name, wio_data, coords, fields, dims):
+    return _read_nondimensional_data(
+        name, wio_data, fields, dims
+    ) or _read_dimensional_data(name, wio_data, fields, dims)
+
+def read_wind_resource_field(
+    name, 
+    wio_data, 
+    coords, 
+    fields, 
+    dims, 
+    verbosity,
+    ):
     """
     Reads wind resource data into fields and dims
 
@@ -113,6 +114,8 @@ def read_wind_resource_field(name, wio_data, coords, fields, dims):
         The fields dict, filled on the fly
     dims: dict
         The dimensions dict, filled on the fly
+    verbosity: int
+        The verbosity level, 0=silent
 
     Returns
     -------
@@ -129,12 +132,19 @@ def read_wind_resource_field(name, wio_data, coords, fields, dims):
         "friction_velocity",
         "k",
         "epsilon",
+        "ABL_height",
+        "lapse_rate",
+        "capping_inversion_thickness",
+        "capping_inversion_strength",
     ]:
-        print(f"Ignoring variable '{name}'")
+        if verbosity > 2:
+            print(f"        Ignoring variable '{name}'")
         return False
 
-    elif name in ["time", "wind_turbine"] and _read_multi_dimensional_coordinate(
-        name, wio_data, coords, fields, dims
+    if verbosity > 2:
+        print(f"        Reading variable '{name}'")
+    if name in ["time", "wind_turbine"] and _read_multi_dimensional_coordinate(
+        name, wio_data, coords
     ):
         return True
 
@@ -145,8 +155,8 @@ def read_wind_resource_field(name, wio_data, coords, fields, dims):
         "y",
         "height",
     ] and (
-        _read_multi_dimensional_coordinate(name, wio_data, coords, fields, dims)
-        or _read_multi_dimensional_data(name, wio_data, coords, fields, dims)
+        _read_multi_dimensional_coordinate(name, wio_data, coords)
+        or _read_multi_dimensional_data(name, wio_data, fields, dims)
     ):
         return True
 
@@ -156,8 +166,8 @@ def read_wind_resource_field(name, wio_data, coords, fields, dims):
         "turbulence_intensity",
         "LMO",
         "z0",
-        "k",
-    ] and _read_multi_dimensional_data(name, wio_data, coords, fields, dims):
+        "reference_height",
+    ] and _read_multi_dimensional_data(name, wio_data, fields, dims):
         return True
 
     else:

foxes/input/windio/read_outputs.py

@@ -0,0 +1,125 @@
+import numpy as np
+from pathlib import Path
+
+from foxes.utils import Dict
+import foxes.variables as FV
+import foxes.constants as FC
+
+def _read_turbine_outputs(wio_outs, odir, out_dicts, verbosity):
+    """ Reads the turbine outputs request """
+    if "turbine_outputs" in wio_outs and wio_outs["turbine_outputs"].get("report", True):
+        turbine_outputs = Dict(wio_outs["turbine_outputs"], name="turbine_outputs")
+        turbine_nc_filename = turbine_outputs.pop("turbine_nc_filename", "turbine_outputs.nc")
+        output_variables = turbine_outputs["output_variables"]
+        if verbosity > 2:
+            print("      Reading turbine_outputs")
+            print("        File name:", turbine_nc_filename)
+            print("        output_variables:", output_variables)
+        
+        vmap = Dict(
+            power=FV.P,
+            rotor_effective_velocity=FV.REWS,
+        )
+        ivmap = {d: k for k, d in vmap.items()}
+        ivmap.update({
+            FC.STATE: "time", 
+            FC.TURBINE: "turbine",
+        })
+        
+        out_dicts.append(Dict({
+                    "output_type": "StateTurbineTable",
+                    "farm_results": True,
+                    "algo": False,
+                    "run_func": "get_dataset",
+                    "run_kwargs": dict(
+                        variables=[vmap[v] for v in output_variables],
+                        name_map=ivmap,
+                        to_file=odir/turbine_nc_filename,
+                        verbosity=verbosity,
+                    ),
+                    "output_yaml_update": {
+                        "power_table": f"include {turbine_nc_filename}",
+                    },
+                }, name = "turbine_outputs"))
+
+def _read_flow_field(wio_outs, odir, out_dicts, verbosity):
+    """ Reads the flow field request """
+    if "flow_field" in wio_outs and wio_outs["flow_field"].get("report", True):
+        flow_field = Dict(wio_outs["flow_field"], name="flow_field")
+        flow_nc_filename = flow_field.pop("flow_nc_filename", "flow_field.nc")
+        output_variables = flow_field.pop("output_variables")
+        z_planes = Dict(flow_field.pop("z_planes"), name="z_planes")
+        z_sampling = z_planes["z_sampling"]
+        xy_sampling = z_planes["xy_sampling"]
+        if verbosity > 2:
+            print("      Reading flow_field")
+            print("        File name       :", flow_nc_filename)
+            print("        output_variables:", output_variables)
+            print("        z_sampling      :", z_sampling)
+            print("        xy_sampling     :", xy_sampling)
+
+        vmap = Dict(
+            wind_speed=FV.WS,
+            wind_direction=FV.WD,
+        )
+        
+        if xy_sampling == "default":
+            out_dicts.append(Dict({
+                        "output_type": "SliceData",
+                        "farm_results": True,
+                        "algo": True,
+                        "verbosity_delta": 3,
+                        "run_func": "get_states_data_xy",
+                        "run_kwargs": dict(
+                            resolution=30.,
+                            variables=[vmap[v] for v in output_variables],
+                            z=None if z_sampling == "hub_height" else z_sampling,
+                            to_file=odir/flow_nc_filename,
+                            verbosity=verbosity,
+                        ),
+                        "output_yaml_update": {
+                            "flow_field": f"include {flow_nc_filename}",
+                        },
+                    }, name = "flow_field"))
+        else:
+            raise NotImplementedError(f"xy_sampling '{xy_sampling}' is not supported (yet)")
+            
+        
+def read_outputs(wio_outs, algo_dict, verbosity):
+    """
+    Reads the windio outputs
+
+    Parameters
+    ----------
+    wio_outs: dict
+        The windio output data
+    algo_dict: dict
+        The algorithm dictionary
+    verbosity: int
+        The verbosity level, 0=silent
+
+    Returns
+    -------
+    out_dicts: list of dict
+        The output dictionaries
+    odir: pathlib.Path
+        Path to the output folder
+
+    :group: input.windio
+
+    """
+    out_dicts = []
+    odir = Path(wio_outs.pop("output_folder", "results"))
+    odir.mkdir(exist_ok=True, parents=True)
+    if verbosity > 2:
+        print("  Reading outputs")
+        print("    Output folder:", odir)
+        print("    Contents:", [k for k in wio_outs.keys()])
+
+    # read turbine_outputs:
+    _read_turbine_outputs(wio_outs, odir, out_dicts, verbosity)
+
+    # read flow field:
+    _read_flow_field(wio_outs, odir, out_dicts, verbosity)
+
+    return out_dicts, odir

foxes/input/windio/runner.py

@@ -1,7 +1,23 @@
+import yaml
+
 from foxes.core import Algorithm
 from foxes.output import Output
 
 
+def _write_yaml(data, fpath):
+    """ Write the data to yaml """
+    rmap = {
+        "include": "!include",
+    }
+    with open(fpath, "w") as file:
+        yaml.dump(data, file)
+    with open(fpath, "r") as f:
+        s = f.read()
+    with open(fpath, 'w') as f:
+        for k1, k2 in rmap.items():
+            s = s.replace(k1, k2)
+        f.write(s)
+        
 class WindioRunner:
     """
     Runner for windio input
@@ -10,12 +26,20 @@ class WindioRunner:
     ----------
     algo: foxes.core.Algorithm
         The algorithm object
+    output_dir: pathlib.Path
+        Path to the output folder
     output_dicts: list of dict
         The output dictionaries
     farm_results: xarray.Dataset
         The farm results
     output_results: list
         The output results
+    wio_input_data: dict
+        The wind_energy_system windio input data
+    file_name_input_yaml: str
+        Name of the written input data file
+    file_name_output_yaml: str
+        Name of the written output data file
     verbosity: int
         The verbosity level, 0 = silent
 
@@ -23,7 +47,16 @@ class WindioRunner:
 
     """
 
-    def __init__(self, algo_dict, output_dicts=[], verbosity=1):
+    def __init__(
+        self, 
+        algo_dict, 
+        output_dir=".",
+        output_dicts=[], 
+        wio_input_data=None, 
+        file_name_input_yaml="recorded_input.yaml",
+        file_name_output_yaml="recorded_output.yaml",
+        verbosity=1,
+        ):
         """
         Conbstructor
 
@@ -31,29 +64,48 @@ class WindioRunner:
         ----------
         algo_dict: dict
             The algorithm dictionary
+        output_dir: pathlib.Path
+            Path to the output folder
         output_dicts: list of dict
             The output dictionaries
+        wio_input_data: dict
+            The wind_energy_system windio input data
+        file_name_input_yaml: str
+            Name of the written input data file
+        file_name_output_yaml: str
+            Name of the written output data file
         verbosity: int
             The verbosity level, 0 = silent
 
         """
         self.algo = algo_dict
+        self.output_dir = output_dir
         self.output_dicts = output_dicts
+        self.wio_input_data = wio_input_data
+        self.file_name_input_yaml = file_name_input_yaml
+        self.file_name_output_yaml = file_name_output_yaml
         self.verbosity = verbosity
         self.farm_results = None
         self.output_results = None
 
         self.__initialized = False
-
-    def print(self, *args, **kwargs):
+        
+        self._output_yaml = {}
+        if wio_input_data is not None and len(wio_input_data):
+            fpath = output_dir/file_name_input_yaml
+            self.print(f"Writing file", fpath)
+            _write_yaml(wio_input_data, fpath)
+            self._output_yaml["wind_energy_system"] = f"include {file_name_input_yaml}"
+
+    def print(self, *args, level=1, **kwargs):
         """Print based on verbosity"""
-        if self.verbosity > 0:
+        if self.verbosity >= level:
             print(*args, **kwargs)
 
     def initialize(self):
         """Initializes the runner"""
         if isinstance(self.algo, dict):
-            self.print(f"Creating algorithm '{self.algo['algo_type']}'")
+            self.print(f"Creating algorithm '{self.algo['algo_type']}'", level=2)
             self.algo = Algorithm.new(**self.algo)
         if not self.algo.initialized:
             self.algo.initialize()
@@ -68,7 +120,7 @@ class WindioRunner:
         """Runs the farm calculation"""
         if not self.__initialized:
             self.initialize()
-        print("Running farm_calc")
+        self.print("Running farm_calc")
         self.farm_results = self.algo.calc_farm()
 
     def run_outputs(self):
@@ -79,10 +131,22 @@ class WindioRunner:
             run_fname = odict.pop("run_func")
             run_args = odict.pop("run_args", ())
             run_kwargs = odict.pop("run_kwargs", {})
-            o = Output.new(**odict)
+                    
+            _odict = odict.copy()
+            if "output_yaml_update" in _odict:
+                self._output_yaml.update(_odict.pop("output_yaml_update"))
+            if _odict.pop("farm_results", False):
+                _odict["farm_results"] = self.farm_results
+            if _odict.pop("algo", False):
+                _odict["algo"] = self.algo
+            o = Output.new(**_odict)
             f = getattr(o, run_fname)
             self.output_results.append(f(*run_args, **run_kwargs))
-
+            
+        fpath = self.output_dir/self.file_name_output_yaml
+        self.print(f"Writing file", fpath)
+        _write_yaml(self._output_yaml, fpath)
+            
     def run(self):
         """Runs all calculations"""
         self.run_farm_calc()

foxes/input/windio/windio.py

@@ -17,25 +17,25 @@ from .runner import WindioRunner
 def _read_site(wio, algo_dict, verbosity):
     """Reads the site information"""
     wio_site = Dict(wio["site"], name="site")
-    if verbosity > 0:
+    if verbosity > 1:
         print("Reading site")
         print("  Name:", wio_site.pop("name", None))
         print("  Contents:", [k for k in wio_site.keys()])
 
     # ignore boundaries:
-    if verbosity > 1:
+    if verbosity > 2:
         print("  Ignoring boundaries")
 
     # read energy_resource:
     energy_resource = Dict(wio_site["energy_resource"], name="energy_resource")
-    if verbosity > 1:
+    if verbosity > 2:
         print("  Reading energy_resource")
         print("    Name:", energy_resource.pop("name", None))
         print("    Contents:", [k for k in energy_resource.keys()])
 
     # read wind_resource:
     wind_resource = Dict(energy_resource["wind_resource"], name="wind_resource")
-    if verbosity > 1:
+    if verbosity > 2:
         print("    Reading wind_resource")
         print("      Name:", wind_resource.pop("name", None))
         print("      Contents:", [k for k in wind_resource.keys()])
@@ -45,16 +45,17 @@ def _read_site(wio, algo_dict, verbosity):
     fields = Dict(name="fields")
     dims = Dict(name="dims")
     for n, d in wind_resource.items():
-        if verbosity > 1:
-            print("        Reading", n)
-        read_wind_resource_field(n, d, coords, fields, dims)
-    if verbosity > 1:
+        read_wind_resource_field(n, d, coords, fields, dims, verbosity)
+    if verbosity > 2:
         print("      Coords:")
         for c, d in coords.items():
             print(f"        {c}: Shape {d.shape}")
         print("      Fields:")
         for f, d in dims.items():
-            print(f"        {f}: Dims {d}, shape {fields[f].shape}")
+            if len(d):
+                print(f"        {f}: Dims {d}, shape {fields[f].shape}")
+            else:
+                print(f"        {f} = {fields[f]}")
 
     algo_dict["states"] = get_states(coords, fields, dims, verbosity)
 
@@ -62,7 +63,7 @@ def _read_site(wio, algo_dict, verbosity):
 def _read_farm(wio, algo_dict, verbosity):
     """Reads the wind farm information"""
     wio_farm = Dict(wio["wind_farm"], name="wind_farm")
-    if verbosity > 0:
+    if verbosity > 1:
         print("Reading wind farm")
         print("  Name:", wio_farm.pop("name", None))
         print("  Contents:", [k for k in wio_farm.keys()])
@@ -82,7 +83,7 @@ def _read_farm(wio, algo_dict, verbosity):
 
     # read layouts:
     layouts = Dict(wio_farm["layouts"], name="layouts")
-    if verbosity > 1:
+    if verbosity > 2:
         print("    Reading layouts")
         print("      Contents:", [k for k in layouts.keys()])
     for lname, ldict in layouts.items():
@@ -123,7 +124,7 @@ def read_windio(windio_yaml, verbosity=1):
     yml_utils = import_module("windIO.utils.yml_utils", hint="pip install windio")
     wio = yml_utils.load_yaml(wio_file)
 
-    if verbosity > 0:
+    if verbosity > 1:
         print("  Name:", wio.pop("name", None))
         print("  Contents:", [k for k in wio.keys()])
 
@@ -132,20 +133,27 @@ def read_windio(windio_yaml, verbosity=1):
         mbook=ModelBook(),
         farm=WindFarm(),
         wake_models=[],
-        verbosity=verbosity - 1,
+        verbosity=verbosity-3,
     )
 
     _read_site(wio, algo_dict, verbosity)
     _read_farm(wio, algo_dict, verbosity)
-    out_dicts = read_attributes(
+    
+    out_dicts, odir = read_attributes(
         wio,
         algo_dict,
         verbosity,
     )
 
-    if verbosity > 0:
+    if verbosity > 1:
         print("Creating windio runner")
-    runner = WindioRunner(algo_dict, output_dicts=out_dicts, verbosity=verbosity)
+    runner = WindioRunner(
+                algo_dict, 
+                output_dir=odir,
+                output_dicts=out_dicts, 
+                wio_input_data=wio, 
+                verbosity=verbosity
+            )
 
     return runner
 

foxes/models/wake_models/wind/bastankhah14.py

@@ -140,7 +140,7 @@ class Bastankhah2014(GaussianWakeModel):
             downwind_index=downwind_index,
             upcast=True,
         )
-
+        
         # select targets:
         st_sel = (x > 0) & (ct > 0)
         if np.any(st_sel):

foxes/output/__init__.py

@@ -14,6 +14,7 @@ from .animation import Animator
 from .calc_points import PointCalculator
 from .slice_data import SliceData
 from .rotor_point_plots import RotorPointPlot
+from .state_turbine_table import StateTurbineTable
 
 from .flow_plots_2d import FlowPlots2D, SeqFlowAnimationPlugin
 from . import grids

foxes/output/slice_data.py

@@ -20,12 +20,21 @@ class SliceData(Output):
         The farm results
     runner: foxes.utils.runners.Runner, optional
         The runner
-
-    :group: output.flow_plots_2d
+    verbosity_delta: int
+        Verbosity threshold for printing calculation info
+            
+    :group: output
 
     """
 
-    def __init__(self, algo, farm_results, runner=None, **kwargs):
+    def __init__(
+        self, 
+        algo, 
+        farm_results, 
+        runner=None, 
+        verbosity_delta=1,
+        **kwargs,
+        ):
         """
         Constructor.
 
@@ -37,6 +46,8 @@ class SliceData(Output):
             The farm results
         runner: foxes.utils.runners.Runner, optional
             The runner
+        verbosity_delta: int
+            Verbosity threshold for printing calculation info
         kwargs: dict, optional
             Additional parameters for the base class
 
@@ -45,6 +56,7 @@ class SliceData(Output):
         self.algo = algo
         self.fres = farm_results
         self.runner = runner
+        self.verbosity_delta = verbosity_delta
 
     def _data_mod(
         self,
@@ -134,7 +146,7 @@ class SliceData(Output):
             g_pts=g_pts,
             sel={FC.STATE: states_sel} if states_sel is not None else None,
             isel={FC.STATE: states_isel} if states_isel is not None else None,
-            verbosity=verbosity,
+            verbosity=verbosity-self.verbosity_delta,
             **kwargs,
         )
         states = point_results[FC.STATE].to_numpy()
@@ -282,7 +294,16 @@ class SliceData(Output):
 
         """
         gdata = grids.get_grid_xy(
-            self.fres, resolution, xmin, ymin, xmax, ymax, z, xspace, yspace, verbosity
+            self.fres, 
+            resolution, 
+            xmin, 
+            ymin, 
+            xmax, 
+            ymax, 
+            z, 
+            xspace, 
+            yspace, 
+            verbosity-self.verbosity_delta,
         )
 
         data = self._calc_mean_data(
@@ -424,7 +445,7 @@ class SliceData(Output):
             y,
             xspace,
             zspace,
-            verbosity,
+            verbosity-self.verbosity_delta,
         )
         gdatb = (gdata[0], gdata[2], gdata[1], gdata[3])
 
@@ -567,7 +588,7 @@ class SliceData(Output):
             x,
             yspace,
             zspace,
-            verbosity,
+            verbosity-self.verbosity_delta,
         )
         gdatb = (gdata[1], gdata[2], gdata[0], gdata[3])
 
@@ -632,7 +653,7 @@ class SliceData(Output):
             algo=self.algo,
             farm_results=self.fres,
             g_pts=g_pts,
-            verbosity=verbosity,
+            verbosity=verbosity-self.verbosity_delta,
             **kwargs,
         )
         states = point_results[FC.STATE].to_numpy()
@@ -773,7 +794,16 @@ class SliceData(Output):
 
         """
         gdata = grids.get_grid_xy(
-            self.fres, resolution, xmin, ymin, xmax, ymax, z, xspace, yspace, verbosity
+            self.fres, 
+            resolution, 
+            xmin, 
+            ymin, 
+            xmax, 
+            ymax, 
+            z, 
+            xspace, 
+            yspace, 
+            verbosity-self.verbosity_delta,
         )
 
         data = self._calc_states_data(
@@ -911,7 +941,7 @@ class SliceData(Output):
             y,
             xspace,
             zspace,
-            verbosity,
+            verbosity-self.verbosity_delta,
         )
         gdatb = (gdata[0], gdata[2], gdata[1], gdata[3])
 
@@ -1050,7 +1080,7 @@ class SliceData(Output):
             x,
             yspace,
             zspace,
-            verbosity,
+            verbosity-self.verbosity_delta,
         )
         gdatb = (gdata[1], gdata[2], gdata[0], gdata[3])