foxes 0.7.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

foxes/models/model_book.py

@@ -1,7 +1,7 @@
 from math import sqrt
 import foxes.models as fm
 import foxes.variables as FV
-from foxes.utils import Dict, FDict
+from foxes.utils import FDict
 
 from foxes.core import (
     PointDataModel,
@@ -16,6 +16,7 @@ from foxes.core import (
     WakeModel,
     AxialInductionModel,
     TurbineInductionModel,
+    GroundModel,
 )
 
 
@@ -25,42 +26,45 @@ class ModelBook:
 
     Attributes
     ----------
-    point_models: foxes.utils.Dict
+    point_models: foxes.utils.FDict
         The point models. Keys: model name str,
         values: foxes.core.PointDataModel
-    rotor_models: foxes.utils.Dict
+    rotor_models: foxes.utils.FDict
         The rotor models. Keys: model name str,
         values: foxes.core.RotorModel
-    turbine_types: foxes.utils.Dict
+    turbine_types: foxes.utils.FDict
         The turbine type models. Keys: model name str,
         values: foxes.core.TurbineType
-    turbine_models: foxes.utils.Dict
+    turbine_models: foxes.utils.FDict
         The turbine models. Keys: model name str,
         values: foxes.core.TurbineModel
-    farm_models: foxes.utils.Dict
+    farm_models: foxes.utils.FDict
         The farm models. Keys: model name str,
         values: foxes.core.FarmModel
-    farm_controllers: foxes.utils.Dict
+    farm_controllers: foxes.utils.FDict
         The farm controllers. Keys: model name str,
         values: foxes.core.FarmController
-    partial_wakes: foxes.utils.Dict
+    partial_wakes: foxes.utils.FDict
         The partial wakes. Keys: model name str,
         values: foxes.core.PartialWakeModel
-    wake_frames: foxes.utils.Dict
+    wake_frames: foxes.utils.FDict
         The wake frames. Keys: model name str,
         values: foxes.core.WakeFrame
-    wake_superpositions: foxes.utils.Dict
+    wake_superpositions: foxes.utils.FDict
         The wake superposition models. Keys: model name str,
         values: foxes.core.WakeSuperposition
-    wake_models: foxes.utils.Dict
+    wake_models: foxes.utils.FDict
         The wake models. Keys: model name str,
         values: foxes.core.WakeModel
-    induction_models: foxes.utils.Dict
+    induction_models: foxes.utils.FDict
         The induction models. Keys: model name str,
         values: foxes.core.AxialInductionModel
-    sources: foxes.utils.Dict
+    ground_models: foxes.utils.FDict
+        The ground models. Keys: model name str,
+        values: foxes.core.GroundModel
+    sources: foxes.utils.FDict
         All sources dict
-    base_classes: foxes.utils.Dict
+    base_classes: foxes.utils.FDict
         The base classes for all model types
 
     :group: models
@@ -77,7 +81,7 @@ class ModelBook:
             Path to power/ct curve file, for creation
             of default turbine type model
         """
-        self.point_models = Dict(name="point_models")
+        self.point_models = FDict(name="point_models")
         self.point_models["tke2ti"] = fm.point_models.TKE2TI()
 
         self.rotor_models = FDict(name="rotor_models")
@@ -88,8 +92,11 @@ class ModelBook:
             n2 = float(n2)
             n = int(sqrt(n2))
             if n**2 != n2:
-                raise Exception(f"GridRotor factory: Value {n2} is not the square of an integer")
+                raise Exception(
+                    f"GridRotor factory: Value {n2} is not the square of an integer"
+                )
             return n
+
         self.rotor_models.add_factory(
             fm.rotor_models.GridRotor,
             "grid<n2>",
@@ -100,7 +107,7 @@ class ModelBook:
         )
         self.rotor_models.add_factory(
             fm.rotor_models.GridRotor,
-            "raw_grid<n2>",
+            "grid<n2>_raw",
             kwargs=dict(calc_vars=rvars, reduce=False),
             var2arg={"n2": "n"},
             n2=_n2n,
@@ -115,13 +122,13 @@ class ModelBook:
         )
         self.rotor_models.add_factory(
             fm.rotor_models.LevelRotor,
-            "raw_level<n>",
+            "level<n>_raw",
             kwargs=dict(calc_vars=rvars, reduce=False),
             n=lambda x: int(x),
             hints={"n": "(Number of vertical levels)"},
         )
 
-        self.turbine_types = Dict(name="turbine_types")
+        self.turbine_types = FDict(name="turbine_types")
         self.turbine_types["null_type"] = fm.turbine_types.NullType()
         self.turbine_types["NREL5MW"] = fm.turbine_types.PCtFile(
             "NREL-5MW-D126-H90.csv", rho=1.225
@@ -165,8 +172,10 @@ class ModelBook:
             "kTI_<kTI>_<kb>",
             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)",
-                   "kb": "(Value, e.g. 004 for 0.04)"},
+            hints={
+                "kTI": "(Value, e.g. 004 for 0.04)",
+                "kb": "(Value, e.g. 004 for 0.04)",
+            },
         )
         self.turbine_models.add_factory(
             fm.turbine_models.kTI,
@@ -174,8 +183,10 @@ class ModelBook:
             kwargs=dict(ti_var=FV.AMB_TI),
             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)",
-                   "kb": "(Value, e.g. 004 for 0.04)"},
+            hints={
+                "kTI": "(Value, e.g. 004 for 0.04)",
+                "kb": "(Value, e.g. 004 for 0.04)",
+            },
         )
 
         self.turbine_models["hubh_data"] = fm.turbine_models.RotorCentreCalc(
@@ -187,7 +198,7 @@ class ModelBook:
             }
         )
 
-        self.farm_models = Dict(
+        self.farm_models = FDict(
             name="farm_models",
             **{
                 f"farm_{mname}": fm.farm_models.Turbine2FarmModel(m)
@@ -195,7 +206,7 @@ class ModelBook:
             },
         )
 
-        self.farm_controllers = Dict(
+        self.farm_controllers = FDict(
             name="farm_controllers",
             basic_ctrl=fm.farm_controllers.BasicFarmController(),
         )
@@ -224,13 +235,10 @@ class ModelBook:
             name="wake_frames",
             rotor_wd=fm.wake_frames.RotorWD(var_wd=FV.WD),
             rotor_wd_farmo=fm.wake_frames.FarmOrder(),
-            yawed=fm.wake_frames.YawedWakes(),
         )
-        self.wake_frames.add_factory(
+        self.wake_frames.add_k_factory(
             fm.wake_frames.YawedWakes,
-            "yawed_k<k>",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"k": "(Value, e.g. 004 for 0.04)"},
+            "yawed_[wake_k]",
         )
         self.wake_frames.add_factory(
             fm.wake_frames.Streamlines2D,
@@ -246,11 +254,13 @@ class ModelBook:
         )
 
         self.wake_frames["timelines"] = fm.wake_frames.Timelines()
+
         def _todt(x):
             if x[-1] == "s":
-                return float(x[:-1])/60
+                return float(x[:-1]) / 60
             elif x[-3:] == "min":
                 return float(x[:-3])
+
         self.wake_frames.add_factory(
             fm.wake_frames.Timelines,
             "timelines_<dt>",
@@ -266,7 +276,7 @@ class ModelBook:
             hints={"dt": "(Time step, e.g '10s', '1min' etc.)"},
         )
 
-        self.wake_superpositions = Dict(
+        self.wake_superpositions = FDict(
             name="wake_superpositions",
             ws_linear=fm.wake_superpositions.WSLinear(scale_amb=False),
             ws_linear_lim=fm.wake_superpositions.WSLinear(
@@ -309,192 +319,119 @@ class ModelBook:
             ti_max=fm.wake_superpositions.TIMax(superp_to_amb="quadratic"),
         )
 
-        self.axial_induction = Dict(name="induction_models")
-        self.axial_induction["Betz"] = fm.axial_induction_models.BetzAxialInduction()
-        self.axial_induction["Madsen"] = (
-            fm.axial_induction_models.MadsenAxialInduction()
-        )
+        self.axial_induction = FDict(name="induction_models")
+        self.axial_induction["Betz"] = fm.axial_induction.BetzAxialInduction()
+        self.axial_induction["Madsen"] = fm.axial_induction.MadsenAxialInduction()
 
         self.wake_models = FDict(name="wake_models")
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.JensenWake,
-            "Jensen_<superposition>",
+            "Jensen_<superposition>_[wake_k]",
+            kwargs=dict(induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.JensenWake,
-            "Jensen_<superposition>_k<k>",
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
-        )
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah2014_<superposition>",
-            kwargs=dict(sbeta_factor=0.2),
+            "Bastankhah2014_<superposition>_[wake_k]",
+            kwargs=dict(sbeta_factor=0.2, induction="Madsen"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah2014_<superposition>_k<k>",
-            kwargs=dict(sbeta_factor=0.2),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
-        )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah2014B_<superposition>",
+            "Bastankhah2014B_<superposition>_[wake_k]",
             kwargs=dict(sbeta_factor=0.2, induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah2014B_<superposition>_k<k>",
-            kwargs=dict(sbeta_factor=0.2, induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
-        )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah025_<superposition>",
-            kwargs=dict(sbeta_factor=0.25),
+            "Bastankhah025_<superposition>_[wake_k]",
+            kwargs=dict(sbeta_factor=0.25, induction="Madsen"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah025_<superposition>_k<k>",
-            kwargs=dict(sbeta_factor=0.25),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
-        )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah025B_<superposition>",
+            "Bastankhah025B_<superposition>_[wake_k]",
             kwargs=dict(sbeta_factor=0.25, induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2014,
-            "Bastankhah025B_<superposition>_k<k>",
-            kwargs=dict(sbeta_factor=0.25, induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
-        )
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2016,
-            "Bastankhah2016_<superposition>",
+            "Bastankhah2016_<superposition>_[wake_k]",
+            kwargs=dict(induction="Madsen"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.Bastankhah2016,
-            "Bastankhah2016_<superposition>_k<k>",
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
-        )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2016,
-            "Bastankhah2016B_<superposition>",
+            "Bastankhah2016B_<superposition>_[wake_k]",
             kwargs=dict(induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.Bastankhah2016,
-            "Bastankhah2016B_<superposition>_k<k>",
-            kwargs=dict(induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
-        )
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.TurbOParkWake,
-            "TurbOPark_<superposition>",
+            "TurbOPark_<superposition>_[wake_k]",
+            kwargs=dict(induction="Madsen"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.TurbOParkWake,
-            "TurbOPark_<superposition>_k<k>",
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
-        )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.TurbOParkWake,
-            "TurbOParkB_<superposition>",
+            "TurbOParkB_<superposition>_[wake_k]",
             kwargs=dict(induction="Betz"),
             superposition=lambda s: f"ws_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ws_linear)"},
         )
-        self.wake_models.add_factory(
-            fm.wake_models.wind.TurbOParkWake,
-            "TurbOParkB_<superposition>_k<k>",
-            kwargs=dict(induction="Betz"),
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
-        )
 
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.wind.TurbOParkWakeIX,
-            "TurbOParkIX_<superposition>_dx<dx>",
+            "TurbOParkIX_<superposition>_[wake_k]_dx<dx>",
             superposition=lambda s: f"ws_{s}",
             dx=lambda x: float(x),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "dx": "(Integration step in m)"},
+            hints={
+                "superposition": "(Superposition, e.g. linear for ws_linear)",
+                "dx": "(Integration step in m)",
+            },
         )
 
-        self.wake_models.add_factory(
-            fm.wake_models.wind.TurbOParkWakeIX,
-            "TurbOParkIX_<superposition>_k<k>_dx<dx>",
-            superposition=lambda s: f"ws_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            dx=lambda x: float(x),
-            hints={"superposition": "(Superposition, e.g. linear for ws_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)",
-                   "dx": "(Integration step in m)"},
+        self.wake_models.add_k_factory(
+            fm.wake_models.ti.CrespoHernandezTIWake,
+            "CrespoHernandez_<superposition>_[wake_k]",
+            kwargs=dict(use_ambti=False),
+            superposition=lambda s: f"ti_{s}",
+            hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
 
         self.wake_models.add_factory(
-            fm.wake_models.ti.CrespoHernandezTIWake,
-            "CrespoHernandez_<superposition>",
-            kwargs=dict(use_ambti=False),
+            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.CrespoHernandezTIWake,
-            "CrespoHernandez_<superposition>_k<k>",
-            kwargs=dict(use_ambti=False),
+            fm.wake_models.ti.IECTIWake,
+            "IECTI2019_<superposition>",
+            kwargs=dict(iec_type="2019"),
             superposition=lambda s: f"ti_{s}",
-            k=lambda x: float(f"0.{x[1:]}" if x[0] == "0" else float(x)),
-            hints={"superposition": "(Superposition, e.g. linear for ti_linear)",
-                   "k": "(Value, e.g. 004 for 0.04)"},
+            hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
+        )
+        self.wake_models.add_k_factory(
+            fm.wake_models.ti.IECTIWake,
+            "IECTI2019k_<superposition>_[wake_k]",
+            kwargs=dict(iec_type="2019", opening_angle=None),
+            superposition=lambda s: f"ti_{s}",
+            hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
 
         self.wake_models.add_factory(
@@ -504,11 +441,10 @@ class ModelBook:
             superposition=lambda s: f"ti_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
-
-        self.wake_models.add_factory(
+        self.wake_models.add_k_factory(
             fm.wake_models.ti.IECTIWake,
-            "IECTI2019_<superposition>",
-            kwargs=dict(iec_type="2019"),
+            "IECTI2005k_<superposition>_[wake_k]",
+            kwargs=dict(iec_type="2005", opening_angle=None),
             superposition=lambda s: f"ti_{s}",
             hints={"superposition": "(Superposition, e.g. linear for ti_linear)"},
         )
@@ -519,8 +455,20 @@ class ModelBook:
         self.wake_models[f"SelfSimilar2020"] = (
             fm.wake_models.induction.SelfSimilar2020()
         )
+        self.wake_models[f"VortexSheet"] = fm.wake_models.induction.VortexSheet()
+
+        self.ground_models = FDict(name="ground_models")
+        self.ground_models["no_ground"] = fm.ground_models.NoGround()
+        self.ground_models["ground_mirror"] = fm.ground_models.GroundMirror()
+        self.ground_models.add_factory(
+            fm.ground_models.WakeMirror,
+            "blh_mirror_h<height>",
+            var2arg={"height": "heights"},
+            height=lambda h: [0.0, float(h)],
+            hints={"height": "(Boundary layer wake reflection height)"},
+        )
 
-        self.sources = Dict(
+        self.sources = FDict(
             name="sources",
             point_models=self.point_models,
             rotor_models=self.rotor_models,
@@ -533,8 +481,9 @@ class ModelBook:
             wake_superpositions=self.wake_superpositions,
             wake_models=self.wake_models,
             axial_induction=self.axial_induction,
+            ground_models=self.ground_models,
         )
-        self.base_classes = Dict(
+        self.base_classes = FDict(
             name="base_classes",
             point_models=PointDataModel,
             rotor_models=RotorModel,
@@ -547,6 +496,7 @@ class ModelBook:
             wake_superpositions=WakeSuperposition,
             wake_models=WakeModel,
             axial_induction=AxialInductionModel,
+            ground_models=GroundModel,
         )
 
         for s in self.sources.values():
@@ -663,7 +613,7 @@ class ModelBook:
 
         """
         for ms in self.sources.values():
-            if isinstance(ms, Dict):
+            if isinstance(ms, FDict):
                 for m in ms.values():
                     if m.initialized:
                         m.finalize(algo, verbosity)

foxes/models/partial_wakes/axiwake.py

@@ -44,6 +44,31 @@ class PartialAxiwake(PartialCentre):
     def __repr__(self):
         return f"{type(self).__name__}(n={self.n})"
 
+    def check_wmodel(self, wmodel, error=True):
+        """
+        Checks the wake model type
+
+        Parameters
+        ----------
+        wmodel: foxes.core.WakeModel
+            The wake model to be tested
+        error: bool
+            Flag for raising TypeError
+
+        Returns
+        -------
+        chk: bool
+            True if wake model is compatible
+
+        """
+        if not isinstance(wmodel, AxisymmetricWakeModel):
+            if error:
+                raise TypeError(
+                    f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not an AxisymmetricWakeModel"
+                )
+            return False
+        return True
+
     def contribute(
         self,
         algo,
@@ -79,10 +104,8 @@ class PartialAxiwake(PartialCentre):
             The wake model
 
         """
-        if not isinstance(wmodel, AxisymmetricWakeModel):
-            raise TypeError(
-                f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not an AxisymmetricWakeModel"
-            )
+        # check:
+        self.check_wmodel(wmodel, error=True)
 
         # prepare:
         n_states = mdata.n_states

foxes/models/partial_wakes/top_hat.py

@@ -24,6 +24,31 @@ class PartialTopHat(PartialCentre):
 
     """
 
+    def check_wmodel(self, wmodel, error=True):
+        """
+        Checks the wake model type
+
+        Parameters
+        ----------
+        wmodel: foxes.core.WakeModel
+            The wake model to be tested
+        error: bool
+            Flag for raising TypeError
+
+        Returns
+        -------
+        chk: bool
+            True if wake model is compatible
+
+        """
+        if not isinstance(wmodel, TopHatWakeModel):
+            if error:
+                raise TypeError(
+                    f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not a TopHatWakeModel"
+                )
+            return False
+        return True
+
     def __init__(self, rotor_model=None):
         """
         Constructor.
@@ -105,10 +130,7 @@ class PartialTopHat(PartialCentre):
             The wake model
 
         """
-        if not isinstance(wmodel, TopHatWakeModel):
-            raise TypeError(
-                f"Partial wakes '{self.name}': Cannot be applied to wake model '{wmodel.name}', since not a TopHatWakeModel"
-            )
+        self.check_wmodel(wmodel, error=True)
 
         wcoos = algo.wake_frame.get_wake_coos(algo, mdata, fdata, tdata, downwind_index)
         x = wcoos[:, :, 0, 0]

foxes/models/turbine_types/PCt_file.py

@@ -103,6 +103,7 @@ class PCtFile(TurbineType):
 
     def __repr__(self):
         a = f"D={self.D}, H={self.H}, P_nominal={self.P_nominal}, P_unit={self.P_unit}, rho={self.rho}"
+        a += f", var_ws_ct={self.WSCT}, var_ws_P={self.WSP}"
         return f"{type(self).__name__}({a})"
 
     def output_farm_vars(self, algo):