foxes 0.8.2__py3-none-any.whl → 1.1.0.2__py3-none-any.whl

foxes/input/windio/read_outputs.py

@@ -5,28 +5,39 @@ from foxes.utils import Dict
 import foxes.variables as FV
 import foxes.constants as FC
 
+from .read_fields import foxes2wio
+
+
 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):
+    """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")
+        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({
+        ivmap.update(
+            {
+                FC.STATE: "time",
+                FC.TURBINE: "turbine",
+            }
+        )
+
+        out_dicts.append(
+            Dict(
+                {
                     "output_type": "StateTurbineTable",
                     "farm_results": True,
                     "algo": False,
@@ -34,16 +45,23 @@ def _read_turbine_outputs(wio_outs, odir, out_dicts, verbosity):
                     "run_kwargs": dict(
                         variables=[vmap[v] for v in output_variables],
                         name_map=ivmap,
-                        to_file=odir/turbine_nc_filename,
+                        to_file=odir / turbine_nc_filename,
+                        round={
+                            vw: FV.get_default_digits(vf) for vw, vf in vmap.items()
+                        },
                         verbosity=verbosity,
                     ),
                     "output_yaml_update": {
                         "power_table": f"include {turbine_nc_filename}",
                     },
-                }, name = "turbine_outputs"))
+                },
+                name="turbine_outputs",
+            )
+        )
+
 
 def _read_flow_field(wio_outs, odir, out_dicts, verbosity):
-    """ Reads the flow field request """
+    """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")
@@ -51,10 +69,15 @@ def _read_flow_field(wio_outs, odir, out_dicts, verbosity):
         z_planes = Dict(flow_field.pop("z_planes"), name="z_planes")
         z_sampling = z_planes["z_sampling"]
         xy_sampling = z_planes["xy_sampling"]
+        cases_run = Dict(flow_field.pop("cases_run", {}), name="cases_run")
+        states_isel = cases_run.get("subset", None)
+        if "all_occurences" in cases_run and cases_run.pop("all_occurences"):
+            states_isel = None
         if verbosity > 2:
             print("      Reading flow_field")
             print("        File name       :", flow_nc_filename)
             print("        output_variables:", output_variables)
+            print("        states subset   :", states_isel)
             print("        z_sampling      :", z_sampling)
             print("        xy_sampling     :", xy_sampling)
 
@@ -62,30 +85,48 @@ def _read_flow_field(wio_outs, odir, out_dicts, verbosity):
             wind_speed=FV.WS,
             wind_direction=FV.WD,
         )
-        
+
+        if z_sampling in ["hub_height", "default"]:
+            z = None
+        elif isinstance(z_sampling, (int, float)):
+            z = z_sampling
+        else:
+            raise NotImplementedError(
+                f"z_sampling '{z_sampling}' of type '{type(z_sampling).__name__}' is not supported (yet). Please give 'hub_height', 'default' or a float."
+            )
+
         if xy_sampling == "default":
-            out_dicts.append(Dict({
+            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.,
+                            states_isel=states_isel,
+                            n_img_points=(100, 100),
                             variables=[vmap[v] for v in output_variables],
-                            z=None if z_sampling == "hub_height" else z_sampling,
-                            to_file=odir/flow_nc_filename,
+                            z=z,
+                            to_file=odir / flow_nc_filename,
+                            label_map=foxes2wio,
                             verbosity=verbosity,
                         ),
                         "output_yaml_update": {
                             "flow_field": f"include {flow_nc_filename}",
                         },
-                    }, name = "flow_field"))
+                    },
+                    name="flow_field",
+                )
+            )
         else:
-            raise NotImplementedError(f"xy_sampling '{xy_sampling}' is not supported (yet)")
-            
-        
-def read_outputs(wio_outs, algo_dict, verbosity):
+            raise NotImplementedError(
+                f"xy_sampling '{xy_sampling}' is not supported (yet)"
+            )
+
+
+def read_outputs(wio_outs, algo_dict, output_dir=None, verbosity=1):
     """
     Reads the windio outputs
 
@@ -95,6 +136,8 @@ def read_outputs(wio_outs, algo_dict, verbosity):
         The windio output data
     algo_dict: dict
         The algorithm dictionary
+    output_dir: pathlib.Path, optional
+        Path to the output folder
     verbosity: int
         The verbosity level, 0=silent
 
@@ -109,7 +152,11 @@ def read_outputs(wio_outs, algo_dict, verbosity):
 
     """
     out_dicts = []
-    odir = Path(wio_outs.pop("output_folder", "results"))
+    odir = (
+        Path(output_dir)
+        if output_dir is not None
+        else Path(wio_outs.pop("output_folder", "results"))
+    )
     odir.mkdir(exist_ok=True, parents=True)
     if verbosity > 2:
         print("  Reading outputs")

foxes/input/windio/runner.py

@@ -5,7 +5,7 @@ from foxes.output import Output
 
 
 def _write_yaml(data, fpath):
-    """ Write the data to yaml """
+    """Write the data to yaml"""
     rmap = {
         "include": "!include",
     }
@@ -13,11 +13,12 @@ def _write_yaml(data, fpath):
         yaml.dump(data, file)
     with open(fpath, "r") as f:
         s = f.read()
-    with open(fpath, 'w') as f:
+    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
@@ -40,6 +41,10 @@ class WindioRunner:
         Name of the written input data file
     file_name_output_yaml: str
         Name of the written output data file
+    write_input_yaml: bool
+        Flag for writing file_name_input_yaml
+    write_output_yaml: bool
+        Flag for writing file_name_output_yaml
     verbosity: int
         The verbosity level, 0 = silent
 
@@ -48,15 +53,17 @@ class WindioRunner:
     """
 
     def __init__(
-        self, 
-        algo_dict, 
+        self,
+        algo_dict,
         output_dir=".",
-        output_dicts=[], 
-        wio_input_data=None, 
+        output_dicts=[],
+        wio_input_data=None,
         file_name_input_yaml="recorded_input.yaml",
         file_name_output_yaml="recorded_output.yaml",
+        write_input_yaml=False,
+        write_output_yaml=False,
         verbosity=1,
-        ):
+    ):
         """
         Conbstructor
 
@@ -74,6 +81,10 @@ class WindioRunner:
             Name of the written input data file
         file_name_output_yaml: str
             Name of the written output data file
+        write_input_yaml: bool
+            Flag for writing file_name_input_yaml
+        write_output_yaml: bool
+            Flag for writing file_name_output_yaml
         verbosity: int
             The verbosity level, 0 = silent
 
@@ -84,15 +95,17 @@ class WindioRunner:
         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.write_input_yaml = write_input_yaml
+        self.write_output_yaml = write_output_yaml
         self.verbosity = verbosity
         self.farm_results = None
         self.output_results = None
 
         self.__initialized = False
-        
+
         self._output_yaml = {}
-        if wio_input_data is not None and len(wio_input_data):
-            fpath = output_dir/file_name_input_yaml
+        if self.write_input_yaml 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}"
@@ -131,7 +144,7 @@ class WindioRunner:
             run_fname = odict.pop("run_func")
             run_args = odict.pop("run_args", ())
             run_kwargs = odict.pop("run_kwargs", {})
-                    
+
             _odict = odict.copy()
             if "output_yaml_update" in _odict:
                 self._output_yaml.update(_odict.pop("output_yaml_update"))
@@ -142,11 +155,12 @@ class WindioRunner:
             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)
-            
+
+        if self.write_output_yaml:
+            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

@@ -1,5 +1,3 @@
-import numpy as np
-import pandas as pd
 from pathlib import Path
 
 from foxes.core import WindFarm
@@ -9,7 +7,7 @@ from foxes.data import StaticData, WINDIO
 
 from .read_fields import read_wind_resource_field
 from .get_states import get_states
-from .read_farm import read_layout, read_turbine_type
+from .read_farm import read_layout, read_turbine_types
 from .read_attributes import read_attributes
 from .runner import WindioRunner
 
@@ -78,19 +76,28 @@ def _read_farm(wio, algo_dict, verbosity):
         ws_exp_ct = 1
 
     # read turbine type:
-    turbines = Dict(wio_farm["turbines"], name="turbines")
-    ttype = read_turbine_type(turbines, algo_dict, ws_exp_P, ws_exp_ct, verbosity)
+    ttypes = read_turbine_types(wio_farm, algo_dict, ws_exp_P, ws_exp_ct, verbosity)
 
     # read layouts:
-    layouts = Dict(wio_farm["layouts"], name="layouts")
+    wfarm = wio_farm["layouts"]
+    if isinstance(wfarm, dict):
+        layouts = Dict(wfarm, name="layouts")
+    else:
+        layouts = Dict({i: l for i, l in enumerate(wfarm)}, name="layouts")
     if verbosity > 2:
         print("    Reading layouts")
         print("      Contents:", [k for k in layouts.keys()])
     for lname, ldict in layouts.items():
-        read_layout(lname, ldict, algo_dict, ttype, verbosity)
+        read_layout(lname, ldict, algo_dict, ttypes, verbosity)
 
 
-def read_windio(windio_yaml, verbosity=1):
+def read_windio(
+    windio_yaml,
+    verbosity=1,
+    algo_pars=None,
+    output_dir=None,
+    **runner_pars,
+):
     """
     Reads a complete WindIO case.
 
@@ -103,6 +110,12 @@ def read_windio(windio_yaml, verbosity=1):
         Path to the windio yaml file
     verbosity: int
         The verbosity level, 0 = silent
+    algo_pars: dict, optional
+        Additional algorithm parameters
+    output_dir: str, optional
+        Path to the output folder
+    runner_pars: dict, optional
+        Additional parameters for the WindioRunner
 
     Returns
     -------
@@ -113,7 +126,6 @@ def read_windio(windio_yaml, verbosity=1):
     :group: input.windio
 
     """
-
     wio_file = Path(windio_yaml)
     if not wio_file.is_file():
         wio_file = StaticData().get_file_path(WINDIO, wio_file, check_raw=False)
@@ -128,32 +140,38 @@ def read_windio(windio_yaml, verbosity=1):
         print("  Name:", wio.pop("name", None))
         print("  Contents:", [k for k in wio.keys()])
 
-    algo_dict = Dict(
-        algo_type="Downwind",
-        mbook=ModelBook(),
-        farm=WindFarm(),
-        wake_models=[],
-        verbosity=verbosity-3,
+    algo_dict = Dict(algo_type="Downwind", name="algo_dict")
+    if algo_pars is not None:
+        algo_dict.update(algo_pars)
+    algo_dict.update(
+        dict(
+            mbook=ModelBook(),
+            farm=WindFarm(),
+            wake_models=[],
+            verbosity=verbosity - 3,
+        )
     )
 
     _read_site(wio, algo_dict, verbosity)
     _read_farm(wio, algo_dict, verbosity)
-    
+
     out_dicts, odir = read_attributes(
         wio,
         algo_dict,
-        verbosity,
+        output_dir=output_dir,
+        verbosity=verbosity,
     )
 
     if verbosity > 1:
         print("Creating windio runner")
     runner = WindioRunner(
-                algo_dict, 
-                output_dir=odir,
-                output_dicts=out_dicts, 
-                wio_input_data=wio, 
-                verbosity=verbosity
-            )
+        algo_dict,
+        output_dir=odir,
+        output_dicts=out_dicts,
+        wio_input_data=wio,
+        verbosity=verbosity,
+        **runner_pars,
+    )
 
     return runner
 

foxes/models/farm_models/turbine2farm.py

@@ -65,7 +65,7 @@ class Turbine2FarmModel(FarmModel):
         return self.turbine_model.output_farm_vars(algo)
 
     def calculate(self, algo, mdata, fdata, **parameters):
-        """ "
+        """
         The main model calculation.
 
         This function is executed on a single chunk of data,

foxes/models/ground_models/wake_mirror.py

@@ -56,7 +56,7 @@ class WakeMirror(GroundModel):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_deltas: dict
             The wake deltas. Key: variable name,
             value: numpy.ndarray with shape
@@ -70,6 +70,10 @@ class WakeMirror(GroundModel):
         # prepare:
         hh = fdata[FV.H][:, downwind_index].copy()
 
+        # DEBUG CHECK:
+        # import numpy as np
+        # assert(np.all(fdata[FV.H]==fdata[FV.TXYH[..., 2]]))
+
         # contribution from main wake:
         wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
         wmodel.contribute(algo, mdata, fdata, tdata, downwind_index, wcoos, wake_deltas)
@@ -78,14 +82,14 @@ class WakeMirror(GroundModel):
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
 
-            fdata[FV.H][:, downwind_index] = hh + 2 * (h - hh)
+            fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             pwake.contribute(
                 algo, mdata, fdata, tdata, downwind_index, wake_deltas, wmodel
             )
 
         # reset heights:
-        fdata[FV.H][:, downwind_index] = hh
+        fdata[FV.TXYH][:, downwind_index, 2] = hh
 
     def contribute_to_point_wakes(
         self,
@@ -113,7 +117,7 @@ class WakeMirror(GroundModel):
             The target point data
         downwind_index: int
             The index of the wake causing turbine
-            in the downwnd order
+            in the downwind order
         wake_deltas: dict
             The wake deltas. Key: variable name,
             value: numpy.ndarray with shape
@@ -133,7 +137,7 @@ class WakeMirror(GroundModel):
         tdata[FC.TARGETS] = tdata[FC.TARGETS].copy()  # making sure this is no ref
         for h in self.heights:
 
-            fdata[FV.H][:, downwind_index] = hh + 2 * (h - hh)
+            fdata[FV.TXYH][:, downwind_index, 2] = hh + 2 * (h - hh)
 
             wcoos = algo.wake_frame.get_wake_coos(
                 algo, mdata, fdata, tdata, downwind_index
@@ -143,7 +147,7 @@ class WakeMirror(GroundModel):
             )
 
         # reset heights:
-        fdata[FV.H][:, downwind_index] = hh
+        fdata[FV.TXYH][:, downwind_index, 2] = hh
 
 
 class GroundMirror(WakeMirror):

foxes/models/model_book.py

@@ -85,8 +85,7 @@ class ModelBook:
         self.point_models["tke2ti"] = fm.point_models.TKE2TI()
 
         self.rotor_models = FDict(name="rotor_models")
-        rvars = [FV.REWS, FV.REWS2, FV.REWS3, FV.TI, FV.RHO]
-        self.rotor_models["centre"] = fm.rotor_models.CentreRotor(calc_vars=rvars)
+        self.rotor_models["centre"] = fm.rotor_models.CentreRotor()
 
         def _n2n(n2):
             n2 = float(n2)
@@ -100,7 +99,7 @@ class ModelBook:
         self.rotor_models.add_factory(
             fm.rotor_models.GridRotor,
             "grid<n2>",
-            kwargs=dict(calc_vars=rvars, reduce=True),
+            kwargs=dict(reduce=True),
             var2arg={"n2": "n"},
             n2=_n2n,
             hints={"n2": "(Number of points in square grid)"},
@@ -108,7 +107,7 @@ class ModelBook:
         self.rotor_models.add_factory(
             fm.rotor_models.GridRotor,
             "grid<n2>_raw",
-            kwargs=dict(calc_vars=rvars, reduce=False),
+            kwargs=dict(reduce=False),
             var2arg={"n2": "n"},
             n2=_n2n,
             hints={"n2": "(Number of points in square grid)"},
@@ -116,14 +115,14 @@ class ModelBook:
         self.rotor_models.add_factory(
             fm.rotor_models.LevelRotor,
             "level<n>",
-            kwargs=dict(calc_vars=rvars, reduce=True),
+            kwargs=dict(reduce=True),
             n=lambda x: int(x),
             hints={"n": "(Number of vertical levels)"},
         )
         self.rotor_models.add_factory(
             fm.rotor_models.LevelRotor,
             "level<n>_raw",
-            kwargs=dict(calc_vars=rvars, reduce=False),
+            kwargs=dict(reduce=False),
             n=lambda x: int(x),
             hints={"n": "(Number of vertical levels)"},
         )
@@ -158,14 +157,14 @@ class ModelBook:
             fm.turbine_models.kTI,
             "kTI_<kTI>",
             kTI=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"kTI": "(Value, e.g. 004 for 0.04)"},
+            hints={"kTI": "(Value, e.g. 02 for 0.2)"},
         )
         self.turbine_models.add_factory(
             fm.turbine_models.kTI,
             "kTI_amb_<kTI>",
             kwargs=dict(ti_var=FV.AMB_TI),
             kTI=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"kTI": "(Value, e.g. 004 for 0.04)"},
+            hints={"kTI": "(Value, e.g. 04 for 0.4)"},
         )
         self.turbine_models.add_factory(
             fm.turbine_models.kTI,
@@ -173,7 +172,7 @@ class ModelBook:
             kTI=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
             kb=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
             hints={
-                "kTI": "(Value, e.g. 004 for 0.04)",
+                "kTI": "(Value, e.g. 04 for 0.4)",
                 "kb": "(Value, e.g. 004 for 0.04)",
             },
         )
@@ -184,7 +183,7 @@ class ModelBook:
             kTI=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
             kb=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
             hints={
-                "kTI": "(Value, e.g. 004 for 0.04)",
+                "kTI": "(Value, e.g. 04 for 0.4)",
                 "kb": "(Value, e.g. 004 for 0.04)",
             },
         )
@@ -254,12 +253,24 @@ class ModelBook:
         )
 
         self.wake_frames["timelines"] = fm.wake_frames.Timelines()
+        self.wake_frames["dyn_wakes"] = fm.wake_frames.DynamicWakes()
+        self.wake_frames["seq_dyn_wakes"] = fm.wake_frames.SeqDynamicWakes()
 
         def _todt(x):
             if x[-1] == "s":
                 return float(x[:-1]) / 60
             elif x[-3:] == "min":
                 return float(x[:-3])
+            else:
+                raise NotImplementedError(f"Cannot translate '{x}' into minutes")
+
+        def _tokm(x):
+            if x[-2:] == "km":
+                return float(x[:-2])
+            elif x[-1] == "m":
+                return float(x[:-1]) / 1e3
+            else:
+                raise NotImplementedError(f"Cannot translate '{x}' into km")
 
         self.wake_frames.add_factory(
             fm.wake_frames.Timelines,
@@ -268,6 +279,13 @@ class ModelBook:
             var2arg={"dt": "dt_min"},
             hints={"dt": "(Time step, e.g '10s', '1min' etc.)"},
         )
+        self.wake_frames.add_factory(
+            fm.wake_frames.DynamicWakes,
+            "dyn_wakes_<length>",
+            length=_tokm,
+            var2arg={"length": "max_length_km"},
+            hints={"length": "(Maximal wake length, e.g. '5km' or '5000m')"},
+        )
         self.wake_frames.add_factory(
             fm.wake_frames.SeqDynamicWakes,
             "seq_dyn_wakes_<dt>",
@@ -411,14 +429,6 @@ class ModelBook:
             hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
 
-        self.wake_models.add_factory(
-            fm.wake_models.ti.IECTIWake,
-            "IECTI2005_<superposition>",
-            kwargs=dict(iec_type="2005"),
-            superposition=lambda s: f"ti_{s}",
-            hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
-        )
-
         self.wake_models.add_factory(
             fm.wake_models.ti.IECTIWake,
             "IECTI2019_<superposition>",
@@ -450,12 +460,39 @@ class ModelBook:
         )
 
         self.wake_models[f"RHB"] = fm.wake_models.induction.RankineHalfBody()
+
+        self.wake_models[f"VortexSheet"] = fm.wake_models.induction.VortexSheet()
+        self.wake_models.add_factory(
+            fm.wake_models.induction.VortexSheet,
+            "VortexSheet_<superposition>",
+            superposition=lambda s: f"ws_{s}",
+            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+        )
+
         self.wake_models[f"Rathmann"] = fm.wake_models.induction.Rathmann()
+        self.wake_models.add_factory(
+            fm.wake_models.induction.Rathmann,
+            "Rathmann_<superposition>",
+            superposition=lambda s: f"ws_{s}",
+            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+        )
+
         self.wake_models[f"SelfSimilar"] = fm.wake_models.induction.SelfSimilar()
         self.wake_models[f"SelfSimilar2020"] = (
             fm.wake_models.induction.SelfSimilar2020()
         )
-        self.wake_models[f"VortexSheet"] = fm.wake_models.induction.VortexSheet()
+        self.wake_models.add_factory(
+            fm.wake_models.induction.SelfSimilar,
+            "SelfSimilar_<superposition>",
+            superposition=lambda s: f"ws_{s}",
+            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+        )
+        self.wake_models.add_factory(
+            fm.wake_models.induction.SelfSimilar2020,
+            "SelfSimilar2020_<superposition>",
+            superposition=lambda s: f"ws_{s}",
+            hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
+        )
 
         self.ground_models = FDict(name="ground_models")
         self.ground_models["no_ground"] = fm.ground_models.NoGround()
@@ -466,6 +503,7 @@ class ModelBook:
             var2arg={"height": "heights"},
             height=lambda h: [0.0, float(h)],
             hints={"height": "(Boundary layer wake reflection height)"},
+            example_vars={"height": 500},
         )
 
         self.sources = FDict(
@@ -504,7 +542,7 @@ class ModelBook:
                 m.name = k
 
     def __getitem__(self, key):
-        return self.sources.__getitem__(key)
+        return self.sources.get_item(key)
 
     def print_toc(self, subset=None, search=None):
         """