HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/models/dummy_soilwater.py

@@ -0,0 +1,85 @@
+# pylint: disable=unused-wildcard-import
+"""
+|dummy_soilwater| merely serves testing purposes.  We use it, for example, to perform
+the integration tests for submodels like |evap_aet_hbv96| without the need to couple
+them to complex main models like |hland_96| for providing soil water data.
+
+Integration test
+================
+
+The only functionality of |dummy_soilwater| is reading input time series.  Hence,
+configuring and testing it does not require additional explanations:
+
+
+>>> from hydpy.models.dummy_soilwater import *
+>>> parameterstep()
+>>> from hydpy import Element
+>>> element = Element("element")
+>>> element.model = model
+
+>>> from hydpy import IntegrationTest, pub, round_
+>>> pub.timegrids = "2000-01-01", "2000-01-03", "1d"
+>>> nmbzones(2)
+
+>>> test = IntegrationTest(element)
+>>> test.dateformat = "%Y-%d-%m"
+
+>>> inputs.soilwater.series = [[1.0, 2.0], [3.0, 4.0]]
+
+.. integration-test::
+
+    >>> test()
+    |       date |      soilwater |
+    -------------------------------
+    | 2000-01-01 | 1.0        2.0 |
+    | 2000-02-01 | 3.0        4.0 |
+
+>>> round_(model.get_soilwater_v1(1))
+4.0
+"""
+# import...
+# ...from HydPy
+from hydpy.core import importtools
+from hydpy.core import modeltools
+from hydpy.exe.modelimports import *
+from hydpy.models.dummy import dummy_control
+from hydpy.models.dummy import dummy_model
+from hydpy.interfaces import stateinterfaces
+
+ADDITIONAL_CONTROLPARAMETERS = (dummy_control.NmbZones,)
+
+
+class Model(modeltools.AdHocModel, stateinterfaces.SoilWaterModel_V1):
+    """|dummy_soilwater.DOCNAME.complete|."""
+
+    DOCNAME = modeltools.DocName(
+        short="Dummy-SoilWater",
+        description="dummy model supplying main models with soil water states",
+    )
+    __HYDPY_ROOTMODEL__ = False
+
+    INLET_METHODS = ()
+    RECEIVER_METHODS = ()
+    RUN_METHODS = ()
+    INTERFACE_METHODS = (dummy_model.Get_SoilWater_V1,)
+    ADD_METHODS = ()
+    OUTLET_METHODS = ()
+    SENDER_METHODS = ()
+    SUBMODELINTERFACES = ()
+    SUBMODELS = ()
+
+    @importtools.define_targetparameter(dummy_control.NmbZones)
+    def prepare_nmbzones(self, nmbzones: int) -> None:
+        """Set the number of zones.
+
+        >>> from hydpy.models.dummy_soilwater import *
+        >>> parameterstep()
+        >>> model.prepare_nmbzones(2)
+        >>> nmbzones
+        nmbzones(2)
+        """
+        self.parameters.control.nmbzones(nmbzones)
+
+
+tester = Tester()
+cythonizer = Cythonizer()

hydpy/models/evap/__init__.py

@@ -0,0 +1,13 @@
+"""
+The |evap.DOCNAME.complete| model family supplies methods for calculating potential
+evapotranspiration.
+"""
+
+# import...
+# ...from HydPy
+from hydpy.exe.modelimports import *
+from hydpy.models.evap.evap_masks import Masks
+from hydpy.models.evap.evap_model import Model
+
+tester = Tester()
+cythonizer = Cythonizer()

hydpy/models/evap/evap_control.py

@@ -0,0 +1,354 @@
+# pylint: disable=missing-module-docstring
+
+# import...
+# ...from standard library
+from __future__ import annotations
+
+# ...from HydPy
+from hydpy.core import exceptiontools
+from hydpy.core import parametertools
+from hydpy.core.typingtools import *
+from hydpy.models.evap import evap_parameters
+
+
+class NmbHRU(parametertools.Parameter):
+    """The number of separately modelled hydrological response units [-]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, int, None, (0, None)
+
+    def __call__(self, *args, **kwargs) -> None:
+        nmbhru_old = exceptiontools.getattr_(self, "value", None)
+        super().__call__(*args, **kwargs)
+        nmbhru_new = self.value
+        if nmbhru_new != nmbhru_old:
+            for subpars in self.subpars.pars:
+                for par in subpars:
+                    if (par.NDIM == 1) and not isinstance(
+                        par, parametertools.KeywordParameter1D
+                    ):
+                        par.shape = nmbhru_new
+            seqs = self.subpars.pars.model.sequences
+            for subseqs in seqs:
+                for seq in subseqs:
+                    if seq.NDIM == 1:
+                        seq.shape = nmbhru_new
+            seq_ = getattr(seqs.logs, "loggedpotentialevapotranspiration", None)
+            if seq_ is not None:
+                seq_.shape = self.value
+
+
+class HRUType(parametertools.NameParameter):
+    """Hydrological response unit type [-]."""
+
+    NDIM, TYPE, TIME = 1, int, None
+    SPAN = (None, None)
+    constants = parametertools.Constants(ANY=0)
+
+
+class Water(evap_parameters.ZipParameter1D):
+    """A flag that indicates whether the individual zones are water areas or not."""
+
+    TYPE, TIME, SPAN = bool, None, (False, True)
+
+
+class Interception(evap_parameters.ZipParameter1D):
+    """A flag that indicates whether interception evaporation is relevant for the
+    individual zones."""
+
+    TYPE, TIME, SPAN = bool, None, (False, True)
+
+
+class Soil(evap_parameters.ZipParameter1D):
+    """A flag that indicates whether soil evapotranspiration is relevant for the
+    individual zones."""
+
+    TYPE, TIME, SPAN = bool, None, (False, True)
+
+
+class Plant(evap_parameters.ZipParameter1D):
+    """A flag that indicates whether the individual zones contain any vegetation."""
+
+    TYPE, TIME, SPAN = bool, None, (False, True)
+
+
+class Tree(evap_parameters.ZipParameter1D):
+    """A flag that indicates whether the individual zones contain tree-like
+    vegetation."""
+
+    TYPE, TIME, SPAN = bool, None, (False, True)
+
+
+class Conifer(evap_parameters.ZipParameter1D):
+    """A flag that indicates whether the individual zones contain conifer-like
+    vegetation."""
+
+    TYPE, TIME, SPAN = bool, None, (False, True)
+
+
+class HRUArea(parametertools.Parameter):
+    """The area of each hydrological response unit [km²]."""
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (0.0, None)
+
+
+class HRUAltitude(evap_parameters.ZipParameter1D):
+    """The altitude of each hydrological response unit [m]."""
+
+    TYPE, TIME, SPAN = float, None, (None, None)
+    INIT = 0.0
+
+
+class MeasuringHeightWindSpeed(parametertools.Parameter):
+    """The height above ground of the wind speed measurements [m]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, float, None, (0, None)
+    INIT = 10.0
+
+
+class AirTemperatureAddend(evap_parameters.ZipParameter1D):
+    """Adjustment addend for air temperature [K]."""
+
+    TYPE, TIME, SPAN = float, None, (None, None)
+    INIT = 0.0
+
+
+class CoastFactor(evap_parameters.ZipParameter1D):
+    """The "coast factor" of Turc-Wendling's reference evapotranspiration equation
+    [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.6, 1.0)
+    INIT = 1.0
+
+
+class Albedo(evap_parameters.LandMonthParameter):
+    """Earth surface albedo [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+    INIT = 0.5
+
+
+class GroundAlbedo(evap_parameters.ZipParameter1D):
+    """The albedo of the snow-free ground (including soils, sealed surfaces, and water
+    areas) [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+    INIT = 0.2
+
+
+class GroundAlbedoSnow(evap_parameters.ZipParameter1D):
+    """The albedo of the snow-covered ground (including soils and sealed surfaces)
+    [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+    INIT = 0.8
+
+
+class LeafAlbedo(evap_parameters.PlantParameter1D):
+    """The albedo of the snow-free leaves [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+    INIT = 0.2
+
+
+class LeafAlbedoSnow(evap_parameters.PlantParameter1D):
+    """The albedo of the snow-covered leaves [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+    INIT = 0.8
+
+
+class LeafAreaIndex(evap_parameters.LandMonthParameter):
+    """Leaf area index [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+    INIT = 5.0
+
+
+class CropHeight(evap_parameters.LandMonthParameter):
+    """Crop height [m]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+    INIT = 1.0
+
+
+class CloudTypeFactor(parametertools.Parameter):
+    """Cloud type-specific factor for calculating atmospheric longwave counter radiation
+    [-]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, float, None, (0.0, None)
+    INIT = 0.2
+
+
+class NightCloudFactor(parametertools.Parameter):
+    """Factor for adjusting daytime estimates of the cloud coverage degree to nighttime
+    [-]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, float, None, (0.0, None)
+    INIT = 1.0
+
+
+class Emissivity(parametertools.Parameter):
+    """The emissivity of the land surface [-]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, float, None, (0.0, 1.0)
+    INIT = 0.95
+
+
+class AverageSoilHeatFlux(parametertools.MonthParameter):
+    """Monthly averages of the soil heat flux [W/m²]."""
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (None, None)
+    INIT = 0.0
+
+
+class SurfaceResistance(evap_parameters.LandMonthParameter):
+    """Surface resistance of water areas, sealed areas, and vegetation with sufficient
+    water supply [s/m]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+    INIT = 100.0
+
+
+class WetSoilResistance(evap_parameters.SoilParameter1D):
+    """Surface resistance of wet soils [s/m]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+    INIT = 100.0
+
+
+class SoilResistanceIncrease(evap_parameters.SoilParameter1D):
+    """Increase in soil surface resistance if evaporation dominates precipitation
+    [s/m/T]."""
+
+    TYPE, TIME, SPAN = float, True, (0.0, None)
+    INIT = 0.0
+
+
+class WetnessThreshold(evap_parameters.SoilParameter1D):
+    """The ratio between precipitation and potential evapotranspiration above which the
+    topmost soil layer becomes wet [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+    INIT = 1.0
+
+
+class LeafResistance(evap_parameters.PlantParameter1D):
+    """Surface resistance of plant leaves [s/m]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+    INIT = 100.0
+
+
+class EvapotranspirationFactor(evap_parameters.ZipParameter1D):
+    """The adjustment factor for potential evapotranspiration [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+    INIT = 1.0
+
+
+class MonthFactor(parametertools.MonthParameter):
+    """Factor for converting general potential evaporation or evapotranspiration
+    (usually grass reference evapotranspiration) to month-specific potential
+    evaporation or evapotranspiration [-]."""
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (0.0, None)
+
+
+class LandMonthFactor(evap_parameters.LandMonthParameter):
+    """Factor for converting general potential evaporation or evapotranspiration
+    (usually grass reference evapotranspiration) to land-use- and month-specific
+    potential evaporation or evapotranspiration [-]."""
+
+    NDIM, TYPE, TIME, SPAN = 2, float, None, (0.0, None)
+
+
+class AltitudeFactor(evap_parameters.ZipParameter1D):
+    """Decrease of potential evapotranspiration with altitude [-1/100m].
+
+    In the terminology of HBV96: ECAlt."""
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (None, None)
+    INIT = 0.1
+
+
+class PrecipitationFactor(evap_parameters.ZipParameter1D):
+    """Decrease in potential evapotranspiration due to precipitation [T/mm].
+
+    In the terminology of HBV96: EPF.
+    """
+
+    NDIM, TYPE, TIME, SPAN = 1, float, False, (0.0, None)
+    INIT = 0.0
+
+
+class AirTemperatureFactor(evap_parameters.ZipParameter1D):
+    """Temperature factor related to the difference of current reference
+    evapotranspiration and normal reference evapotranspiration [1/°C].
+
+    In the terminology of HBV96: ETF.
+    """
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (None, None)
+    INIT = 0.1
+
+
+class DampingFactor(evap_parameters.ZipParameter1D):
+    """Damping factor (temporal weighting factor) for potential evapotranspiration
+    [-]."""
+
+    NDIM, TYPE, TIME, SPAN = 1, float, True, (0.0, 1.0)
+    INIT = 0.0
+
+
+class TemperatureThresholdIce(evap_parameters.WaterParameter1D):
+    """Temperature threshold for evaporation from water areas [°C].
+
+    In the terminology of HBV96: TTIce.
+    """
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (None, None)
+
+
+class MaxSoilWater(evap_parameters.SoilParameter1D):
+    """Maximum soil water content [mm].
+
+    In the terminology of HBV96: FC.
+    """
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (0.0, None)
+    INIT = 200.0
+
+
+class SoilMoistureLimit(evap_parameters.SoilParameter1D):
+    """Relative soil moisture limit for potential evapotranspiration [-].
+
+    In the terminology of HBV96: `LP`. Typical value: 0.9.
+
+    In the terminology of MORECS: `PY`. Typical value: 0.6.
+    """
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (0.0, 1.0)
+    INIT = 0.9
+
+
+class ExcessReduction(evap_parameters.SoilParameter1D):
+    """A factor for restricting actual to potential evapotranspiration [-].
+
+    In the terminology of HBV96: ERED.
+    """
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (0.0, 1.0)
+
+
+class DisseFactor(evap_parameters.SoilParameter1D):
+    """Factor for calculating actual soil evapotranspiration based on potential
+    evapotranspiration estimates that follow the :cite:t:`ref-Disse1995` formulation of
+    the :cite:t:`ref-Minhas1974` equation.
+
+    In the terminology of :cite:t:`ref-Minhas1974` and :cite:t:`ref-Disse1995`: r.
+
+    In the terminology of LARSIM: GRASREF_R.
+    """
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (0.0, None)
+    INIT = 5.0

hydpy/models/evap/evap_derived.py

@@ -0,0 +1,236 @@
+# pylint: disable=missing-module-docstring
+
+# import...
+# ...from site-packages
+import numpy
+
+# ...from HydPy
+import hydpy
+from hydpy.core import exceptiontools
+from hydpy.core import objecttools
+from hydpy.core import parametertools
+
+# ...from evap
+from hydpy.models.evap import evap_parameters
+from hydpy.models.evap import evap_control
+from hydpy.models.evap import evap_fixed
+from hydpy.models.evap import evap_logs
+
+
+class MOY(parametertools.MOYParameter):
+    """References the "global" month of the year index array [-]."""
+
+
+class HRUAreaFraction(parametertools.Parameter):
+    """The area fraction of each hydrological response unit [-]."""
+
+    NDIM, TYPE, TIME, SPAN = 1, float, None, (0.0, 1.0)
+
+    CONTROLPARAMETERS = (evap_control.HRUArea,)
+
+    def update(self) -> None:
+        r"""Calculate the fractions based on
+        :math:`HRUAreaFraction_i = HRUArea_i / \Sigma HRUArea`.
+
+        >>> from hydpy.models.evap import *
+        >>> parameterstep()
+        >>> nmbhru(5)
+        >>> hruarea(10.0, 40.0, 20.0, 25.0, 5.0)
+        >>> derived.hruareafraction.update()
+        >>> derived.hruareafraction
+        hruareafraction(0.1, 0.4, 0.2, 0.25, 0.05)
+        """
+        hruarea = self.subpars.pars.control.hruarea.values
+        self.values = hruarea / numpy.sum(hruarea)
+
+
+class Altitude(parametertools.Parameter):
+    """Average (reference) subbasin altitude [100m]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, float, None, (None, None)
+
+    CONTROLPARAMETERS = (evap_control.HRUArea, evap_control.HRUAltitude)
+
+    def update(self) -> None:
+        """Average the individual hydrological response units' altitudes.
+
+        >>> from hydpy.models.evap import *
+        >>> parameterstep()
+        >>> nmbhru(3)
+        >>> hruarea(5.0, 3.0, 2.0)
+        >>> hrualtitude(1.0, 3.0, 8.0)
+        >>> derived.altitude.update()
+        >>> derived.altitude
+        altitude(3.0)
+        """
+        control = self.subpars.pars.control
+        self.value = numpy.dot(
+            control.hruarea.values, control.hrualtitude.values
+        ) / numpy.sum(control.hruarea.values)
+
+
+class Seconds(parametertools.SecondsParameter):
+    """The length of the actual simulation step size in seconds [h]."""
+
+
+class Hours(parametertools.HoursParameter):
+    """The length of the actual simulation step size in hours [h]."""
+
+
+class Days(parametertools.DaysParameter):
+    """The length of the actual simulation step size in days [d]."""
+
+
+class NmbLogEntries(parametertools.Parameter):
+    """The number of log entries required for a memory duration of 24 hours [-]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, int, None, (1, None)
+
+    def update(self):
+        """Calculate the number of entries and adjust the shape of all relevant log
+        sequences.
+
+        The aimed memory duration is one day.  Hence, the number of required log
+        entries depends on the simulation step size:
+
+        >>> from hydpy.models.evap import *
+        >>> parameterstep()
+        >>> from hydpy import pub
+        >>> pub.timegrids = "2000-01-01", "2000-01-02", "8h"
+        >>> nmbhru(2)
+        >>> derived.nmblogentries.update()
+        >>> derived.nmblogentries
+        nmblogentries(3)
+        >>> logs.loggedglobalradiation
+        loggedglobalradiation(nan, nan, nan)
+
+        For 1-dimensional logged properties, there is a second axis whose size depends
+        on the selected number of hydrological response units:
+
+        >>> logs.loggedairtemperature
+        loggedairtemperature([[nan, nan],
+                              [nan, nan],
+                              [nan, nan]])
+
+        >>> logs.loggedpotentialevapotranspiration
+        loggedpotentialevapotranspiration(nan, nan, nan)
+
+        To prevent losing information, updating parameter |NmbLogEntries| resets the
+        shape of the relevant log sequences only when necessary:
+
+        >>> logs.loggedglobalradiation = 1.0
+        >>> logs.loggedairtemperature = 2.0
+        >>> logs.loggedpotentialevapotranspiration = 3.0
+        >>> derived.nmblogentries.update()
+        >>> logs.loggedglobalradiation
+        loggedglobalradiation(1.0, 1.0, 1.0)
+        >>> logs.loggedairtemperature
+        loggedairtemperature([[2.0, 2.0],
+                              [2.0, 2.0],
+                              [2.0, 2.0]])
+        >>> logs.loggedpotentialevapotranspiration
+        loggedpotentialevapotranspiration(3.0, 3.0, 3.0)
+
+        There is an explicit check for inappropriate simulation step sizes:
+
+        >>> pub.timegrids = "2000-01-01 00:00", "2000-01-01 10:00", "5h"
+        >>> derived.nmblogentries.update()
+        Traceback (most recent call last):
+        ...
+        ValueError: The value of parameter `nmblogentries` of element `?` cannot be \
+determined for a the current simulation step size.  The fraction of the memory period \
+(1d) and the simulation step size (5h) leaves a remainder.
+        """
+        nmb = "1d" / hydpy.pub.timegrids.stepsize
+        if nmb % 1:
+            raise ValueError(
+                f"The value of parameter {objecttools.elementphrase(self)} cannot be "
+                f"determined for a the current simulation step size.  The fraction of "
+                f"the memory period (1d) and the simulation step size "
+                f"({hydpy.pub.timegrids.stepsize}) leaves a remainder."
+            )
+        self(nmb)
+        pars = self.subpars.pars
+        for seq in pars.model.sequences.logs:
+            if isinstance(seq, evap_logs.LoggedPotentialEvapotranspiration):
+                new_shape = self.value
+                old_shape = exceptiontools.getattr_(seq, "shape", (None, None))[1]
+            else:
+                if seq.NDIM == 1:
+                    new_shape = (self.value,)
+                elif seq.NDIM == 2:
+                    new_shape = self.value, pars.control.nmbhru.value
+                else:
+                    assert False
+                old_shape = exceptiontools.getattr_(seq, "shape", (None,))
+            if new_shape != old_shape:
+                seq.shape = new_shape
+
+
+class RoughnessLength(
+    evap_parameters.LandMonthParameter
+):  # ToDo: not directy required, remove?
+    """Roughness length [m]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+    CONTROLPARAMETERS = (evap_control.CropHeight,)
+
+    def update(self):
+        r"""Calculate the roughness length based on
+        :math:`max(0.13 \cdot CropHeight, \ 0.00013)`.
+
+        The original equation seems to go back to Montheith.  We added the minimum
+        value of 0.13 mm to cope with water areas and bare soils (to avoid zero
+        roughness lengths):
+
+        ToDo: Add a reference.
+
+        >>> from hydpy.models.evap import *
+        >>> parameterstep()
+        >>> nmbhru(3)
+        >>> cropheight(
+        ...     ANY=[0.0, 0.001, 0.01, 0.1, 1.0, 2.0, 3.0, 4.0, 5.0, 10.0, 15.0, 20.0])
+        >>> derived.roughnesslength.update()
+        >>> derived.roughnesslength
+        roughnesslength(ANY=[0.00013, 0.00013, 0.0013, 0.013, 0.13, 0.26, 0.39,
+                             0.52, 0.65, 1.3, 1.95, 2.6])
+        """
+        cropheight = self.subpars.pars.control.cropheight.values
+        self.values = numpy.clip(0.13 * cropheight, 0.00013, None)
+
+
+class AerodynamicResistanceFactor(evap_parameters.LandMonthParameter):
+    """Factor for calculating aerodynamic resistance [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+    CONTROLPARAMETERS = (evap_control.CropHeight,)
+    DERIVEDPARAMETERS = (RoughnessLength,)
+    FIXEDPARAMETERS = (evap_fixed.AerodynamicResistanceFactorMinimum,)
+
+    def update(self):
+        r"""Calculate the factor for calculating aerodynamic resistance based on the
+        :math:`max \big( ln(2 / z_0) \cdot ln(10 / z_0) / 0.41^2, \ \tau \big)` with
+        :math:`z_0` being the |RoughnessLength| :cite:p:`ref-Löpmeier2014` and
+        :math:`\tau` the "alternative value" suggested by :cite:t:`ref-Thompson1981`
+        and also used by :cite:t:`ref-LARSIM`.
+
+
+        >>> from hydpy.models.evap import *
+        >>> parameterstep()
+        >>> derived.roughnesslength(
+        ...     ANY=[0.00013, 0.00013, 0.0013, 0.013, 0.13, 0.26, 0.39, 0.52, 0.65,
+        ...          1.3, 1.95, 2.6])
+        >>> derived.aerodynamicresistancefactor.update()
+        >>> derived.aerodynamicresistancefactor
+        aerodynamicresistancefactor(ANY=[752.975177, 752.975177, 476.301466,
+                                         262.708041, 112.194903, 94.0, 94.0, 94.0,
+                                         94.0, 94.0, 94.0, 94.0])
+        """
+        pars = self.subpars.pars
+        z0 = pars.derived.roughnesslength.values
+        min_ = pars.fixed.aerodynamicresistancefactorminimum.value
+        self.values = numpy.clip(
+            numpy.log(10.0 / z0) * numpy.log(10.0 / z0) / 0.41**2, min_, None
+        )