foxes 0.7.3.1__tar.gz → 0.7.4__tar.gz

{foxes-0.7.3.1/foxes.egg-info → foxes-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foxes
-Version: 0.7.3.1
+Version: 0.7.4
 Summary: Farm Optimization and eXtended yield Evaluation Software
 Author: Fraunhofer IWES
 Author-email: jonas.schmidt@iwes.fraunhofer.de

foxes-0.7.4/foxes/VERSION

@@ -0,0 +1 @@
+0.7.4

{foxes-0.7.3.1 → foxes-0.7.4}/foxes/constants.py

@@ -66,7 +66,7 @@ POINTS = "points"
 """
 
 AMB_TARGET_RESULTS = "amb_target_res"
-""" Identified for ambient target results
+""" Identifier for ambient target results
 :group: foxes.constants
 """
 

{foxes-0.7.3.1 → foxes-0.7.4}/foxes/core/wind_farm.py

@@ -48,7 +48,7 @@ class WindFarm:
         self.turbines.append(turbine)
         if verbosity > 0:
             print(
-                f"Turbine {turbine.index}, {turbine.name}: {', '.join(turbine.models)}"
+                f"Turbine {turbine.index}, {turbine.name}: xy=({turbine.xy[0]:.2f}, {turbine.xy[1]:.2f}), {', '.join(turbine.models)}"
             )
 
     @property

{foxes-0.7.3.1 → foxes-0.7.4}/foxes/input/windio/__init__.py

@@ -7,4 +7,5 @@ from .read_fields import wio2foxes, foxes2wio
 from .get_states import get_states
 from .read_farm import read_turbine_type, read_layout
 from .read_attributes import read_attributes
+from .read_outputs import read_outputs
 from .runner import WindioRunner

foxes-0.7.4/foxes/input/windio/get_states.py

@@ -0,0 +1,184 @@
+import numpy as np
+import pandas as pd
+from xarray import Dataset
+from numbers import Number
+
+from foxes.core import States
+import foxes.constants as FC
+import foxes.variables as FV
+
+def _get_profiles(coords, fields, dims, ovars, fixval, verbosity):
+    """Read ABL profiles information
+    :group: input.windio
+    """
+    profiles = {}
+    if FV.Z0 in fields:
+        if FV.H not in fields and verbosity > 0:
+            print(f"Ignoring '{FV.Z0}', since no reference_height found. No ABL profile activated.")
+        elif FV.MOL in fields:
+            ovars.append(FV.MOL)
+            fixval[FV.H] = fields[FV.H]
+            profiles = {FV.WS: "ABLLogWsProfile"}
+        else:
+            fixval[FV.H] = fields[FV.H]
+            profiles = {FV.WS: "ABLLogNeutralWsProfile"}
+    elif FV.H in fields and verbosity > 0:
+        print(f"Ignoring '{FV.H}', since no '{FV.Z0}' data found. No ABL profile activated.")
+    if len(profiles) and verbosity > 2:
+        print(f"        Selecting ABL profile '{profiles[FV.WS]}', {FV.H} = {fields[FV.H]} m")
+            
+    return profiles
+    
+def _get_SingleStateStates(coords, fields, dims, states_dict, 
+                           ovars, fixval, profiles, verbosity):
+    """Try to generate single state parameters
+    :group: input.windio
+    """
+    for c in coords:
+        if not isinstance(c, Number):
+            return False
+
+    if verbosity > 2:
+        print("        selecting class 'SingleStateStates'")
+
+    smap = {FV.WS: "ws", FV.WD: "wd", FV.TI: "ti", FV.RHO: "rho"}
+
+    data = {smap[v]: d for v, d in fixval.items()}
+    for v, d in coords.items():
+        if v in smap:
+            data[smap[v]] = d
+        elif verbosity > 1:
+            print(f"        ignoring coord '{v}'")
+    for v, d in fields.items():
+        if v in smap and len(dims[v]) == 0:
+            data[smap[v]] = d
+        elif verbosity > 1:
+            print(f"        ignoring field '{v}' with dims {dims[v]}")
+
+    sdata = pd.DataFrame(index=coords[FC.TIME], data=data)
+    sdata.index.name = FC.TIME
+    states_dict.update(
+        dict(
+            states_type="SingleStateStates",
+            profiles=profiles,
+            **data,
+        )
+    )
+    return True
+
+def _get_Timeseries(coords, fields, dims, states_dict, 
+                    ovars, fixval, profiles, verbosity):
+    """Try to generate time series parameters
+    :group: input.windio
+    """
+    if len(coords) == 1 and FC.TIME in coords:
+        if verbosity > 2:
+            print("        selecting class 'Timeseries'")
+
+        data = {}
+        fix = {}
+        for v, d in fields.items():
+            if dims[v] == (FC.TIME,):
+                data[v] = d
+            elif len(dims[v]) == 0:
+                fix[v] = d
+            elif verbosity > 2:
+                print(f"        ignoring field '{v}' with dims {dims[v]}")
+        fix.update({v: d for v, d in fixval.items() if v not in data})
+
+        sdata = pd.DataFrame(index=coords[FC.TIME], data=data)
+        sdata.index.name = FC.TIME
+        states_dict.update(
+            dict(
+                states_type="Timeseries",
+                data_source=sdata,
+                output_vars=ovars,
+                fixed_vars=fix,
+                profiles=profiles,
+            )
+        )
+        return True
+    return False
+
+def _get_MultiHeightNCTimeseries(coords, fields, dims, states_dict, 
+                    ovars, fixval, profiles, verbosity):
+    """Try to generate time series parameters
+    :group: input.windio
+    """
+    if len(coords) == 2 and FC.TIME in coords and FV.H in coords:
+        if verbosity > 2:
+            print("        selecting class 'MultiHeightNCTimeseries'")
+            
+        if len(profiles) and verbosity > 0:
+            print(f"Ignoring profile '{profiles[FV.WS]}' for states class 'MultiHeightNCTimeseries'")
+
+        data = {}
+        fix = {}
+        for v, d in fields.items():
+            if dims[v] == (FC.TIME, FV.H):
+                data[v] = ((FC.TIME, FV.H), d)
+            if dims[v] == (FV.H, FC.TIME):
+                data[v] = ((FC.TIME, FV.H), np.swapaxes(d, 0, 1))
+            elif len(dims[v]) == 0:
+                fix[v] = d
+            elif verbosity > 2:
+                print(f"        ignoring field '{v}' with dims {dims[v]}")
+        fix.update({v: d for v, d in fixval.items() if v not in data})
+
+        sdata = Dataset(coords=coords, data_vars=data)
+        states_dict.update(
+            dict(
+                states_type="MultiHeightNCTimeseries",
+                h_coord=FV.H,
+                format_times_func=None,
+                data_source=sdata,
+                output_vars=ovars,
+                fixed_vars=fix,
+            )
+        )
+        return True
+    return False
+
+def get_states(coords, fields, dims, verbosity=1):
+    """
+    Reads states parameters from windio input
+
+    Parameters
+    ----------
+    coords: dict
+        The coordinates data
+    fields: dict
+        The fields data
+    dims: dict
+        The dimensions data
+    verbosity: int
+        The verbosity level
+
+    Returns
+    -------
+    states: foxes.core.States
+        The states object
+
+    :group: input.windio
+
+    """
+    if verbosity > 2:
+        print("      Preparing states")
+        
+    ovars = [FV.WS, FV.WD, FV.TI, FV.RHO]
+    fixval = {FV.TI: 0.05, FV.RHO: 1.225}  
+    profiles = _get_profiles(coords, fields, dims, ovars, fixval, verbosity)
+
+    states_dict = {}
+    if _get_SingleStateStates(
+        coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+    ) or _get_Timeseries(
+        coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+    ) or _get_MultiHeightNCTimeseries(
+        coords, fields, dims, states_dict, ovars, fixval, profiles, verbosity
+    ):
+        return States.new(**states_dict)
+    else:
+        raise ValueError(
+            f"Failed to create states for coords {list(coords.keys())} and fields {list(fields.keys())} with dims {dims}"
+        )

{foxes-0.7.3.1 → foxes-0.7.4}/foxes/input/windio/read_attributes.py

@@ -2,6 +2,8 @@ from foxes.utils import Dict
 from foxes.core import WakeModel, WakeFrame
 import foxes.variables as FV
 
+from .read_outputs import read_outputs
+
 
 def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbosity):
     """Reads the wind deficit wake model"""
@@ -23,11 +25,20 @@ def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbos
         },
         name="ws_sup_dict",
     )
-
+    ws_sup_amb_dict = Dict(
+        {
+            "Linear": "ws_linear_amb",
+            "Quadratic": "ws_quadratic_amb",
+        },
+        name="ws_sup_dict",
+    )
+    
     wname = wind_deficit.pop("name")
-    if verbosity > 1:
+    eff_ws = wind_deficit.pop("use_effective_ws", True)
+    if verbosity > 2:
         print("    Reading wind_deficit_model")
-        print("      Name:", wname)
+        print("      Name    :", wname)
+        print("      Eff ws  :", eff_ws)
         print("      Contents:", [k for k in wind_deficit.keys()])
     wind_def_dict = Dict(wmodel_type=wind_def_map[wname], induction=induction)
     kcoef = Dict(wind_deficit["wake_expansion_coefficient"], name="kcoef")
@@ -36,11 +47,11 @@ def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbos
     amb_ti = kcoef.get("free_stream_ti", False)
     if ka is None or ka == 0.0:
         wind_def_dict["k"] = kb
-        if verbosity > 1:
+        if verbosity > 2:
             print("        Using k =", kb)
     else:
         ti_var = FV.AMB_TI if amb_ti else FV.TI
-        if verbosity > 1:
+        if verbosity > 2:
             print(f"      Using k = {ka} * {ti_var} + {kb}")
         wind_def_dict["k"] = None
         wind_def_dict["ka"] = ka
@@ -48,20 +59,20 @@ def _read_wind_deficit(wind_deficit, superposition, induction, algo_dict, verbos
         wind_def_dict["ti_var"] = ti_var
     if "ceps" in wind_deficit:
         sbf = wind_deficit["ceps"]
-        if verbosity > 1:
+        if verbosity > 2:
             print(f"      Using sbeta_factor = {sbf}")
         wind_def_dict["sbeta_factor"] = sbf
-    wind_def_dict["superposition"] = ws_sup_dict[superposition["ws_superposition"]]
+    supd = ws_sup_dict if eff_ws else ws_sup_amb_dict
+    wind_def_dict["superposition"] = supd[superposition["ws_superposition"]]
 
     algo_dict["mbook"].wake_models[wname] = WakeModel.new(**wind_def_dict)
-    if verbosity > 1:
+    if verbosity > 2:
         print(f"      Created wake model '{wname}':")
         print("       ", algo_dict["mbook"].wake_models[wname])
     algo_dict["wake_models"].append(wname)
 
     return ka, kb, amb_ti
 
-
 def _read_turbulence(
     turbulence_model, superposition, induction, algo_dict, ka, kb, amb_ti, verbosity
 ):
@@ -70,7 +81,7 @@ def _read_turbulence(
     twake_def_map = Dict(
         {
             "CrespoHernandez": "CrespoHernandezTIWake",
-            "IEC-TI-2019": "IECTI2019",
+            "IEC-TI-2019": "IECTIWake",
         },
         name="twake_def_map",
     )
@@ -84,38 +95,41 @@ def _read_turbulence(
     )
 
     wname = turbulence_model.pop("name")
-    if verbosity > 1:
+    if verbosity > 2:
         print("    Reading turbulence_model")
         print("      Name:", wname)
         print("      Contents:", [k for k in turbulence_model.keys()])
-    tiwake_dict = dict(wmodel_type=twake_def_map[wname], induction=induction)
-    if "wake_expansion_coefficient" in turbulence_model:
-        kcoef = Dict(turbulence_model["wake_expansion_coefficient"], name="kcoef")
-        ka = kcoef["k_a"]
-        kb = kcoef.get("k_b", 0.0)
-        amb_ti = kcoef.get("free_stream_ti", False)
-    if ka is None or ka == 0.0:
-        tiwake_dict["k"] = kb
-        if verbosity > 1:
-            print("        Using k =", kb)
-    else:
-        ti_var = FV.AMB_TI if amb_ti else FV.TI
-        if verbosity > 1:
-            print(f"      Using k = {ka} * {ti_var} + {kb}")
-        tiwake_dict["k"] = None
-        tiwake_dict["ka"] = ka
-        tiwake_dict["kb"] = kb
-        tiwake_dict["ti_var"] = ti_var
-    tiwake_dict["superposition"] = ti_sup_dict[superposition["ti_superposition"]]
-
-    algo_dict["mbook"].wake_models[wname] = WakeModel.new(**tiwake_dict)
-    if verbosity > 1:
-        print(f"      Created wake model '{wname}':")
-        print("       ", algo_dict["mbook"].wake_models[wname])
-    algo_dict["wake_models"].append(wname)
-
+    if wname != "None":
+        tiwake_dict = dict(wmodel_type=twake_def_map[wname], induction=induction)
+        if wname == "IEC-TI-2019":
+            tiwake_dict["opening_angle"] = None
+            tiwake_dict["iec_type"] = "2019"
+        if "wake_expansion_coefficient" in turbulence_model:
+            kcoef = Dict(turbulence_model["wake_expansion_coefficient"], name="kcoef")
+            ka = kcoef["k_a"]
+            kb = kcoef.get("k_b", 0.0)
+            amb_ti = kcoef.get("free_stream_ti", False)
+        if ka is None or ka == 0.0:
+            tiwake_dict["k"] = kb
+            if verbosity > 2:
+                print("        Using k =", kb)
+        else:
+            ti_var = FV.AMB_TI if amb_ti else FV.TI
+            if verbosity > 2:
+                print(f"      Using k = {ka} * {ti_var} + {kb}")
+            tiwake_dict["k"] = None
+            tiwake_dict["ka"] = ka
+            tiwake_dict["kb"] = kb
+            tiwake_dict["ti_var"] = ti_var
+        tiwake_dict["superposition"] = ti_sup_dict[superposition["ti_superposition"]]
+
+        algo_dict["mbook"].wake_models[wname] = WakeModel.new(**tiwake_dict)
+        if verbosity > 2:
+            print(f"      Created wake model '{wname}':")
+            print("       ", algo_dict["mbook"].wake_models[wname])
+        algo_dict["wake_models"].append(wname)
 
-def _read_blockage(blockage_model, superposition, induction, algo_dict, verbosity):
+def _read_blockage(blockage_model, induction, algo_dict, verbosity):
     """Reads the blockage model"""
     indc_def_map = Dict(
         {
@@ -128,23 +142,22 @@ def _read_blockage(blockage_model, superposition, induction, algo_dict, verbosit
     )
 
     wname = blockage_model.pop("name")
-    if verbosity > 1:
+    if verbosity > 2:
         print("    Reading blockage_model")
         print("      Name:", wname)
         print("      Contents:", [k for k in blockage_model.keys()])
     if wname != "None":
         indc_dict = Dict(wmodel_type=indc_def_map[wname], induction=induction)
         algo_dict["mbook"].wake_models[wname] = WakeModel.new(**indc_dict)
-        if verbosity > 1:
+        if verbosity > 2:
             print(f"      Created wake model '{wname}':")
             print("       ", algo_dict["mbook"].wake_models[wname])
         algo_dict["wake_models"].append(wname)
         algo_dict["algo_type"] = "Iterative"
 
-
 def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
     """Reads the rotor averaging"""
-    if verbosity > 1:
+    if verbosity > 2:
         print("    Reading rotor_averaging")
         print("      Contents:", [k for k in rotor_averaging.keys()])
     grid = rotor_averaging["grid"]
@@ -158,13 +171,13 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
     wake_averaging = rotor_averaging["wake_averaging"]
     wse_P = rotor_averaging["wind_speed_exponent_for_power"]
     wse_ct = rotor_averaging["wind_speed_exponent_for_ct"]
-    if verbosity > 1:
+    if verbosity > 2:
         print("        grid                :", grid)
         print("        background_averaging:", background_averaging)
         print("        wake_averaging      :", wake_averaging)
         print("        ws exponent power   :", wse_P)
         print("        ws exponent ct      :", wse_ct)
-    if background_averaging == "center":
+    if background_averaging in ["center", "centre"]:
         algo_dict["rotor_model"] = "centre"
     elif background_averaging == "grid":
         algo_dict["rotor_model"] = f"grid{nx*ny}"
@@ -172,7 +185,7 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
         raise KeyError(
             f"Expecting background_averaging 'center' or 'grid', got '{background_averaging}'"
         )
-    if wake_averaging == "centre":
+    if wake_averaging in ["centre", "center"]:
         algo_dict["partial_wakes"] = "centre"
     elif wake_averaging == "grid":
         if background_averaging == "grid":
@@ -184,11 +197,10 @@ def _read_rotor_averaging(rotor_averaging, algo_dict, verbosity):
                 algo_dict["partial_wakes"] = grid
     else:
         algo_dict["partial_wakes"] = wake_averaging
-    if verbosity > 1:
+    if verbosity > 2:
         print("        --> rotor_model     :", algo_dict["rotor_model"])
         print("        --> partial_wakes   :", algo_dict["partial_wakes"])
 
-
 def _read_deflection(deflection, induction, algo_dict, verbosity):
     """Reads deflection model"""
     defl_def_map = Dict(
@@ -200,7 +212,7 @@ def _read_deflection(deflection, induction, algo_dict, verbosity):
     )
 
     wname = deflection.pop("name")
-    if verbosity > 1:
+    if verbosity > 2:
         print("    Reading deflection_model")
         print("      Name:", wname)
         print("      Contents:", [k for k in deflection.keys()])
@@ -211,21 +223,20 @@ def _read_deflection(deflection, induction, algo_dict, verbosity):
         )
     except TypeError:
         algo_dict["mbook"].wake_frames[wname] = WakeFrame.new(**indc_dict)
-    if verbosity > 1:
+    if verbosity > 2:
         print(f"      Created wake frame '{wname}':")
         print("       ", algo_dict["mbook"].wake_frames[wname])
     algo_dict["wake_frame"] = wname
 
-
 def _read_analysis(wio_ana, algo_dict, verbosity):
     """Reads the windio analyses"""
-    if verbosity > 1:
+    if verbosity > 2:
         print("    Reading analysis")
         print("      Contents:", [k for k in wio_ana.keys()])
 
     # superposition:
     superposition = Dict(wio_ana["superposition_model"], name="superposition_model")
-    if verbosity > 1:
+    if verbosity > 2:
         print("    Reading superposition_model")
         print("      Contents:", [k for k in superposition.keys()])
 
@@ -237,8 +248,8 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
         },
         name="induction mapping",
     )
-    induction = imap[wio_ana["axial_induction_model"]]
-    if verbosity > 1:
+    induction = imap[wio_ana.get("axial_induction_model", "1D")]
+    if verbosity > 2:
         print("    axial induction model:", induction)
 
     # wind deficit model:
@@ -248,33 +259,35 @@ def _read_analysis(wio_ana, algo_dict, verbosity):
     )
 
     # turbulence model:
-    turbulence_model = Dict(wio_ana["turbulence_model"], name="turbulence_model")
-    _read_turbulence(
-        turbulence_model, superposition, induction, algo_dict, ka, kb, amb_ti, verbosity
-    )
+    if "turbulence_model" in wio_ana:
+        turbulence_model = Dict(wio_ana["turbulence_model"], name="turbulence_model")
+        _read_turbulence(
+            turbulence_model, superposition, induction, algo_dict, ka, kb, amb_ti, verbosity
+        )
+    elif verbosity > 0:
+        print("turbulence_model not found, not using a TI wake model")
 
     # blockage model:
-    blockage_model = Dict(wio_ana["blockage_model"], name="blockage_model")
-    _read_blockage(blockage_model, superposition, induction, algo_dict, verbosity)
-
+    if "blockage_model" in wio_ana:
+        blockage_model = Dict(wio_ana["blockage_model"], name="blockage_model")
+        _read_blockage(blockage_model, induction, algo_dict, verbosity)
+    elif verbosity > 0:
+        print("blockage_model not found, not using a turbine induction model")
+        
     # rotor_averaging:
-    rotor_averaging = Dict(wio_ana["rotor_averaging"], name="rotor_averaging")
-    _read_rotor_averaging(rotor_averaging, algo_dict, verbosity)
-
+    if "rotor_averaging" in wio_ana:
+        rotor_averaging = Dict(wio_ana["rotor_averaging"], name="rotor_averaging")
+        _read_rotor_averaging(rotor_averaging, algo_dict, verbosity)
+    elif verbosity > 0:
+        print("rotor_averaging not found, using default settings")
+        
     # deflection:
-    deflection = Dict(wio_ana["deflection_model"], name="deflection_model")
-    _read_deflection(deflection, induction, algo_dict, verbosity)
-
-
-def _read_outputs(wio_outs, algo_dict, verbosity):
-    """Reads the outputs"""
-    if verbosity > 1:
-        print("  Reading outputs")
-        print("    Contents:", [k for k in wio_outs.keys()])
-    quit()
-    return []
-
-
+    if "deflection_model" in wio_ana:
+        deflection = Dict(wio_ana["deflection_model"], name="deflection_model")
+        _read_deflection(deflection, induction, algo_dict, verbosity)
+    elif verbosity > 0:
+        print("deflection_model not found, using default settings")
+        
 def read_attributes(wio, algo_dict, verbosity):
     """
     Reads the attributes part of windio
@@ -297,7 +310,7 @@ def read_attributes(wio, algo_dict, verbosity):
 
     """
     wio_attrs = Dict(wio["attributes"], name="attributes")
-    if verbosity > 0:
+    if verbosity > 1:
         print("Reading attributes")
         print("  Contents:", [k for k in wio_attrs.keys()])
 
@@ -305,17 +318,21 @@ def read_attributes(wio, algo_dict, verbosity):
     if "flow_model" in wio_attrs:
         flow_model = Dict(wio_attrs["flow_model"], name="flow_model")
         fmname = flow_model.pop("name")
-        if verbosity > 1:
+        if verbosity > 2:
             print("    Reading flow_model")
             print("      Name:", fmname)
             print("      Contents:", [k for k in flow_model.keys()])
         if fmname != "foxes":
-            raise ValueError(f"Can only run flow_model 'foxes', got '{fmname}'")
+            print(f"Running flow model 'foxes', overruling original choice '{fmname}'")
 
     # read analysis:
     wio_ana = Dict(wio_attrs["analysis"], name="analyses")
     _read_analysis(wio_ana, algo_dict, verbosity)
 
     # outputs:
-    outputs = Dict(wio_attrs["outputs"], name="outputs")
-    return _read_outputs(outputs, algo_dict, verbosity)
+    out_dicts = []
+    if "outputs" in wio_attrs:
+        outputs = Dict(wio_attrs["outputs"], name="outputs")
+        out_dicts = read_outputs(outputs, algo_dict, verbosity)
+
+    return out_dicts

{foxes-0.7.3.1 → foxes-0.7.4}/foxes/input/windio/read_farm.py

@@ -32,27 +32,27 @@ def read_turbine_type(wio_trbns, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
 
     """
     tname = wio_trbns.pop("name")
-    if verbosity > 1:
+    if verbosity > 2:
         print("    Reading wio_trbns")
         print("      Name:", tname)
         print("      Contents:", [k for k in wio_trbns.keys()])
 
     # read performance:
     performance = Dict(wio_trbns["performance"], name="performance")
-    if verbosity > 1:
+    if verbosity > 2:
         print("        Reading performance")
         print("          Contents:", [k for k in performance.keys()])
 
     # P, ct data:
     if "power_curve" in performance:
         power_curve = Dict(performance["power_curve"], name="power_curve")
-        if verbosity > 1:
+        if verbosity > 2:
             print("            Reading power_curve")
             print("              Contents:", [k for k in power_curve.keys()])
         P = power_curve["power_values"]
         ws_P = power_curve["power_wind_speeds"]
         ct_curve = Dict(performance["Ct_curve"], name="Ct_values")
-        if verbosity > 1:
+        if verbosity > 2:
             print("            Reading Ct_curve")
             print("              Contents:", [k for k in ct_curve.keys()])
         ct = ct_curve["Ct_values"]
@@ -66,7 +66,7 @@ def read_turbine_type(wio_trbns, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
                 raise ValueError(f"Expecting wind speed exponent 1, 2 or 3, got {wse}")
             return FV.REWS if wse == 1 else (FV.REWS2 if wse == 2 else FV.REWS3)
 
-        if verbosity > 1:
+        if verbosity > 2:
             print(f"            Creating model '{tname}'")
             print(f"              Turbine type class: PCtFromTwo")
         algo_dict["mbook"].turbine_types[tname] = TurbineType.new(
@@ -83,19 +83,19 @@ def read_turbine_type(wio_trbns, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
             var_ws_P=_get_wse_var(ws_exp_P),
             rho=1.225,
         )
-        if verbosity > 1:
+        if verbosity > 2:
             print("               ", algo_dict["mbook"].turbine_types[tname])
 
     # P, ct data:
     elif "Cp_curve" in performance:
         cp_curve = Dict(performance["Cp_curve"], name="Cp_curve")
-        if verbosity > 1:
+        if verbosity > 2:
             print("            Reading Cp_curve")
             print("              Contents:", [k for k in cp_curve.keys()])
         cp = cp_curve["Cp_values"]
         ws_cp = cp_curve["Cp_wind_speeds"]
         ct_curve = Dict(performance["Ct_curve"], name="Ct_values")
-        if verbosity > 1:
+        if verbosity > 2:
             print("            Reading Ct_curve")
             print("              Contents:", [k for k in ct_curve.keys()])
         ct = ct_curve["Ct_values"]
@@ -104,7 +104,7 @@ def read_turbine_type(wio_trbns, algo_dict, ws_exp_P, ws_exp_ct, verbosity):
         data_cp = pd.DataFrame(data={"ws": ws_cp, "cp": cp})
         data_ct = pd.DataFrame(data={"ws": ws_ct, "ct": ct})
 
-        if verbosity > 1:
+        if verbosity > 2:
             print(f"            Creating model '{tname}'")
             print(f"              Turbine type class: CpCtFromTwo")
         algo_dict["mbook"].turbine_types[tname] = TurbineType.new(
@@ -150,14 +150,14 @@ def read_layout(lname, ldict, algo_dict, ttype, verbosity=1):
     :group: input.windio
 
     """
-    if verbosity > 1:
+    if verbosity > 2:
         print(f"        Reading '{lname}'")
     cdict = Dict(ldict["coordinates"], name="coordinates")
     farm = algo_dict["farm"]
     for xy in zip(cdict["x"], cdict["y"]):
         farm.add_turbine(
             Turbine(xy=np.array(xy), turbine_models=[ttype]),
-            verbosity=0,
+            verbosity=verbosity-3,
         )
-    if verbosity > 1:
+    if verbosity > 2:
         print(f"          Added {farm.n_turbines} wio_trbns of type '{ttype}'")