HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/models/whmod/whmod_constants.py

@@ -0,0 +1,77 @@
+"""|whmod.DOCNAME.long| provides two types of constants: those associated with the land
+type and those associated with the soil type of the individual zones of a
+sub-catchment.  They are all available via wildcard-imports:
+
+>>> from hydpy.models.whmod import *
+>>> (GRASS, DECIDUOUS, CORN, CONIFER, SPRINGWHEAT, WINTERWHEAT, SUGARBEETS, SEALED,
+...  WATER)
+(1, 2, 3, 4, 5, 6, 7, 8, 9)
+>>> (SAND, SAND_COHESIVE, LOAM, CLAY, SILT, PEAT, NONE)
+(10, 11, 12, 13, 14, 15, 16)
+"""
+
+from hydpy.core import parametertools
+
+
+GRASS = parametertools.IntConstant(1)
+"""Land type constant for grassland."""
+DECIDUOUS = parametertools.IntConstant(2)
+"""Land type constant for deciduous forests."""
+CORN = parametertools.IntConstant(3)
+"""Land type constant for corn fields."""
+CONIFER = parametertools.IntConstant(4)
+"""Land type constant for coniferous forests."""
+SPRINGWHEAT = parametertools.IntConstant(5)
+"""Land type constant for spring wheat fields."""
+WINTERWHEAT = parametertools.IntConstant(6)
+"""Land type constant for winter wheat fields."""
+SUGARBEETS = parametertools.IntConstant(7)
+"""Land type constant for sugar beet fields."""
+SEALED = parametertools.IntConstant(8)
+"""Land type constant for sealed areas."""
+WATER = parametertools.IntConstant(9)
+"""Land type constant for water areas."""
+
+SAND = parametertools.IntConstant(10)
+"""Soil type constant for sand."""
+SAND_COHESIVE = parametertools.IntConstant(11)
+"""Soil type constant for cohesive sand."""
+LOAM = parametertools.IntConstant(12)
+"""Soil type constant for loam."""
+CLAY = parametertools.IntConstant(13)
+"""Soil type constant for clay."""
+SILT = parametertools.IntConstant(14)
+"""Soil type constant for silt."""
+PEAT = parametertools.IntConstant(15)
+"""Soil type constant for peat."""
+NONE = parametertools.IntConstant(16)
+"""Soil type constant for areas without soils."""
+
+
+CONSTANTS: parametertools.Constants = parametertools.Constants()
+LANDTYPE_CONSTANTS: parametertools.Constants = parametertools.Constants(
+    **{key: value for key, value in CONSTANTS.items() if value <= WATER}
+)
+SOILTYPE_CONSTANTS: parametertools.Constants = parametertools.Constants(
+    **{key: value for key, value in CONSTANTS.items() if value >= SAND}
+)
+
+# Make only the constants available on wildcard-imports.
+__all__ = [
+    "GRASS",
+    "DECIDUOUS",
+    "CORN",
+    "CONIFER",
+    "SPRINGWHEAT",
+    "WINTERWHEAT",
+    "SUGARBEETS",
+    "SEALED",
+    "WATER",
+    "SAND",
+    "SAND_COHESIVE",
+    "LOAM",
+    "CLAY",
+    "SILT",
+    "PEAT",
+    "NONE",
+]

hydpy/models/whmod/whmod_control.py

@@ -0,0 +1,333 @@
+# pylint: disable=missing-module-docstring
+
+import itertools
+
+import numpy
+
+from hydpy.core import exceptiontools
+from hydpy.core import objecttools
+from hydpy.core import parametertools
+
+from hydpy.models.whmod.whmod_constants import *
+from hydpy.models.whmod import whmod_constants
+from hydpy.models.whmod import whmod_masks
+from hydpy.models.whmod import whmod_parameters
+
+
+class Area(parametertools.Parameter):
+    """Total area [m²]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, float, None, (1e-10, None)
+
+
+class NmbZones(parametertools.Parameter):
+    """Number of zones (hydrological response units) in a subbasin [-].
+
+    |NmbZones| determines the length of most 1-dimensional parameters and sequences.
+    Usually, you should first prepare |NmbZones| and define the values of all
+    1-dimensional parameters and sequences afterwards:
+
+    >>> from hydpy.models.whmod import *
+    >>> parameterstep()
+    >>> nmbzones(5)
+    >>> availablefieldcapacity.shape
+    (5,)
+    >>> states.soilmoisture.shape
+    (5,)
+
+    Changing the value of |NmbZones| later reshapes the affected parameters and
+    sequences and makes it necessary to reset their values:
+
+    >>> availablefieldcapacity(2.0)
+    >>> availablefieldcapacity
+    availablefieldcapacity(2.0)
+    >>> nmbzones(3)
+    >>> availablefieldcapacity
+    availablefieldcapacity(?)
+
+    Re-defining the same value does not delete the already available data:
+
+    >>> availablefieldcapacity(2.0)
+    >>> nmbzones(3)
+    >>> availablefieldcapacity
+    availablefieldcapacity(2.0)
+    """
+
+    NDIM, TYPE, TIME, SPAN = 0, int, None, (1, None)
+
+    def __call__(self, *args, **kwargs):
+        old = exceptiontools.getattr_(self, "value", None)
+        super().__call__(*args, **kwargs)
+        new = self.value
+        if new != old:
+            model = self.subpars.pars.model
+            for subvars in itertools.chain(model.parameters, model.sequences):
+                for var in subvars:
+                    if var.NDIM == 1:
+                        var.shape = new
+
+
+class ZoneArea(whmod_parameters.LandTypeCompleteParameter):
+    """Zone area [m²]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+
+class LandType(parametertools.NameParameter):
+    """Land cover type [-]."""
+
+    constants = whmod_constants.LANDTYPE_CONSTANTS
+
+
+class SoilType(parametertools.NameParameter):
+    """Soil type [-].
+
+    >>> from hydpy.models.whmod import *
+    >>> parameterstep()
+    >>> nmbzones(9)
+    >>> landtype(GRASS, DECIDUOUS, CORN, CONIFER, SPRINGWHEAT, WINTERWHEAT, SUGARBEETS,
+    ...          SEALED, WATER)
+    >>> soiltype(SAND, SAND_COHESIVE, LOAM, CLAY, SILT, PEAT, SAND, NONE, NONE)
+    >>> soiltype
+    soiltype(SAND, SAND_COHESIVE, LOAM, CLAY, SILT, PEAT, SAND, NONE, NONE)
+    >>> soiltype(SAND, SAND_COHESIVE, LOAM, CLAY, SILT, PEAT, NONE, NONE, NONE)
+    Traceback (most recent call last):
+    ...
+    ValueError: While trying to set the values of parameter `soiltype` of element `?`, \
+the following error occurred: The soil type of land type(s) SUGARBEETS must not be NONE.
+
+    >>> soiltype
+    soiltype(?)
+
+
+    >>> soiltype(SAND, SAND_COHESIVE, LOAM, CLAY, SILT, PEAT, SAND, SAND, SAND)
+    Traceback (most recent call last):
+    ...
+    ValueError: While trying to set the values of parameter `soiltype` of element `?`, \
+the following error occurred: The soil type of land type(s) SEALED and WATER must be \
+NONE.
+
+    >>> soiltype
+    soiltype(?)
+
+
+
+    """
+
+    constants = whmod_constants.SOILTYPE_CONSTANTS
+    mask = whmod_masks.LandTypeSoil()
+
+    def __call__(self, *args, **kwargs) -> None:
+
+        def _make_names() -> str:
+            value2name = whmod_constants.LANDTYPE_CONSTANTS.value2name
+            return objecttools.enumeration([value2name[l] for l in landtype[jdxs]])
+
+        try:
+            super().__call__(*args, **kwargs)
+            landtype = self.subpars.landtype.values
+            should_be_soil = (landtype != SEALED) * (landtype != WATER)
+            is_soil = self.values != NONE
+            if numpy.any(jdxs := should_be_soil * ~is_soil):
+                self._valueready = False
+                raise ValueError(
+                    f"The soil type of land type(s) {_make_names()} must not be NONE."
+                )
+            if numpy.any(jdxs := ~should_be_soil * is_soil):
+                self._valueready = False
+                raise ValueError(
+                    f"The soil type of land type(s) {_make_names()} must be NONE."
+                )
+        except BaseException:
+            objecttools.augment_excmessage(
+                "While trying to set the values of parameter "
+                f"{objecttools.elementphrase(self)}"
+            )
+
+
+class CisternSource(whmod_parameters.LandTypeNonWaterParameter):
+    """A flag that indicates whether a zone's excess water (surface runoff or
+    percolation) is channelled into the cistern [-].."""
+
+    TYPE, TIME, SPAN = bool, None, (False, True)
+
+
+class CisternCapacity(parametertools.Parameter):
+    """Maximum water amount that can be collected in the cistern [m³]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, float, None, (0.0, None)
+
+
+class InterceptionCapacity(parametertools.KeywordParameter2D):
+    """Maximum interception storage [mm]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+
+    columnnames = parametertools.MonthParameter.entrynames
+    rownames = whmod_constants.LANDTYPE_CONSTANTS.get_sortednames(
+        relevant=whmod_masks.LandTypeNonWater.relevant
+    )
+
+
+class DegreeDayFactor(whmod_parameters.LandTypeNonWaterParameter):
+    """Degree day factor for snow melting [mm/T/K]."""
+
+    TYPE, TIME, SPAN = float, True, (0.0, None)
+
+
+class AvailableFieldCapacity(whmod_parameters.SoilTypeParameter):
+    """Maximum relative soil moisture content [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+
+class RootingDepth(whmod_parameters.LandTypeSoilParameter):
+    """Maximum rooting depth [m]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+
+class GroundwaterDepth(whmod_parameters.SoilTypeParameter):
+    """Average groundwater depth [m]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+
+class WithCapillaryRise(parametertools.Parameter):
+    """Flag to turn on/off capillary rise [-]."""
+
+    NDIM, TYPE, TIME = 0, bool, None
+
+
+class CapillaryThreshold(whmod_parameters.SoilTypeParameter):
+    """Relative soil moisture where the capillary rise starts [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+
+class CapillaryLimit(whmod_parameters.SoilTypeParameter):
+    """Relative soil moisture where the capillary rise reaches its maximum [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+
+class IrrigationTrigger(parametertools.KeywordParameter2D):
+    """Relative soil moisture below which irrigation starts [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+
+    columnnames = parametertools.MonthParameter.entrynames
+    rownames = whmod_constants.LANDTYPE_CONSTANTS.get_sortednames(
+        relevant=whmod_masks.LandTypeSoil.relevant
+    )
+
+    def trim(self, lower=None, upper=None) -> bool:
+        r"""Trim |IrrigationTrigger| following
+        :math:`0 \leq IrrigationTrigger \leq IrrigationTarget \leq 1`.
+
+        >>> from hydpy.models.whmod import *
+        >>> parameterstep()
+        >>> trigger = irrigationtrigger
+
+        >>> trigger(
+        ...     grass=0.0,
+        ...     deciduous=0.0,
+        ...     corn=[0.0, 0.0, 0.0, 0.0, 0.0, 0.7, 1.0, 1.3, 0.0, 0.0, 0.0, 0.0],
+        ...     conifer=0.0,
+        ...     springwheat=0.0,
+        ...     winterwheat=0.0,
+        ...     sugarbeets=0.0,
+        ... )
+        >>> trigger.corn_jun, trigger.corn_jul, trigger.corn_aug
+        (0.7, 1.0, 1.0)
+
+        >>> irrigationtarget.corn_jun = 0.7
+        >>> irrigationtarget.corn_jul = 0.7
+        >>> trigger(
+        ...     grass=0.0,
+        ...     deciduous=0.0,
+        ...     corn=[0.0, 0.0, 0.0, 0.0, 0.0, 0.7, 1.0, 1.3, 0.0, 0.0, 0.0, 0.0],
+        ...     conifer=0.0,
+        ...     springwheat=0.0,
+        ...     winterwheat=0.0,
+        ...     sugarbeets=0.0,
+        ... )
+        >>> trigger = irrigationtrigger
+        >>> trigger.corn_jun, trigger.corn_jul, trigger.corn_aug
+        (0.7, 0.7, 1.0)
+        """
+
+        if upper is None:
+            upper = self.subpars.irrigationtarget.values.copy()
+            upper[numpy.isnan(upper)] = 1.0
+        return super().trim(lower, upper)
+
+
+class IrrigationTarget(parametertools.KeywordParameter2D):
+    """Relative soil moisture content at which irrigation ends [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+
+    columnnames = parametertools.MonthParameter.entrynames
+    rownames = whmod_constants.LANDTYPE_CONSTANTS.get_sortednames(
+        relevant=whmod_masks.LandTypeSoil.relevant
+    )
+
+    def trim(self, lower=None, upper=None) -> bool:
+        r"""Trim |IrrigationTarget| following
+        :math:`0 \leq IrrigationTrigger \leq IrrigationTarget \leq 1`.
+
+        >>> from hydpy.models.whmod import *
+        >>> parameterstep()
+        >>> target = irrigationtarget
+
+        >>> target(
+        ...     grass=0.0,
+        ...     deciduous=0.0,
+        ...     corn=[0.0, 0.0, 0.0, 0.0, 0.0, 0.7, 0.3, -0.1, 0.0, 0.0, 0.0, 0.0],
+        ...     conifer=0.0,
+        ...     springwheat=0.0,
+        ...     winterwheat=0.0,
+        ...     sugarbeets=0.0,
+        ... )
+        >>> target.corn_jun, target.corn_jul, target.corn_aug
+        (0.7, 0.3, 0.0)
+
+        >>> irrigationtrigger.corn_jun = 0.7
+        >>> irrigationtrigger.corn_jul = 0.7
+        >>> target(
+        ...     grass=0.0,
+        ...     deciduous=0.0,
+        ...     corn=[0.0, 0.0, 0.0, 0.0, 0.0, 0.7, 0.3, -0.1, 0.0, 0.0, 0.0, 0.0],
+        ...     conifer=0.0,
+        ...     springwheat=0.0,
+        ...     winterwheat=0.0,
+        ...     sugarbeets=0.0,
+        ... )
+        >>> target = irrigationtarget
+        >>> target.corn_jun, target.corn_jul, target.corn_aug
+        (0.7, 0.7, 0.0)
+        """
+
+        if lower is None:
+            lower = self.subpars.irrigationtrigger.values.copy()
+            lower[numpy.isnan(lower)] = 0.0
+        return super().trim(lower, upper)
+
+
+class WithExternalIrrigation(parametertools.Parameter):
+    """Flag to turn on/off external irrigation [-]."""
+
+    NDIM, TYPE, TIME = 0, bool, None
+
+
+class BaseflowIndex(whmod_parameters.LandTypeGroundwaterParameter):
+    """Baseflow index [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+
+
+class RechargeDelay(parametertools.Parameter):
+    """Delay between soil percolation and groundwater recharge [T]."""
+
+    NDIM, TYPE, TIME, SPAN = 0, float, False, (0.0, None)

hydpy/models/whmod/whmod_derived.py

@@ -0,0 +1,210 @@
+# pylint: disable=missing-module-docstring
+
+import numpy
+
+import hydpy
+from hydpy.core import parametertools
+
+from hydpy.models.whmod.whmod_constants import *
+from hydpy.models.whmod import whmod_parameters
+from hydpy.models.whmod import whmod_control
+
+
+class MOY(parametertools.MOYParameter):
+    """References the "global" month of the year index array [-]."""
+
+
+class ZoneRatio(whmod_parameters.LandTypeCompleteParameter):
+    """Relative zone area [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, 1.0)
+
+    CONTROLPARAMETERS = (whmod_control.Area, whmod_control.ZoneArea)
+
+    def update(self):
+        """Calculate the relative zone areas based on
+        :math:`ZoneRation = ZoneArea / Area`.
+
+        >>> from hydpy.models.whmod import *
+        >>> parameterstep()
+        >>> nmbzones(3)
+        >>> landtype(GRASS, WATER, SEALED)
+        >>> area(100.0)
+        >>> zonearea(20.0, 30.0, 50.0)
+        >>> derived.zoneratio.update()
+        >>> derived.zoneratio
+        zoneratio(grass=0.2, sealed=0.5, water=0.3)
+        """
+        control = self.subpars.pars.control
+        self.values = control.zonearea / control.area
+
+
+class SoilDepth(whmod_parameters.SoilTypeParameter):
+    """Effective soil depth [m]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+    CONTROLPARAMETERS = (whmod_control.RootingDepth, whmod_control.GroundwaterDepth)
+
+    def update(self):
+        """Calculate the effective soil depth
+
+        >>> from hydpy.models.whmod import *
+        >>> parameterstep()
+        >>> nmbzones(4)
+        >>> landtype(GRASS, DECIDUOUS, CONIFER, WATER)
+        >>> soiltype(SAND, SILT, CLAY, NONE)
+        >>> groundwaterdepth(1.0)
+        >>> rootingdepth(0.5, 1.0, 1.5, 2.0)
+        >>> derived.soildepth.update()
+        >>> derived.soildepth
+        soildepth(clay=1.0, sand=0.5, silt=1.0)
+        """
+        control = self.subpars.pars.control
+        self.values = numpy.minimum(
+            control.rootingdepth.values, control.groundwaterdepth.values
+        )
+
+
+class MaxSoilWater(whmod_parameters.SoilTypeParameter):
+    """Maximum water content of the considered soil column [mm]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+    CONTROLPARAMETERS = (
+        whmod_control.AvailableFieldCapacity,
+        whmod_control.RootingDepth,
+    )
+    DERIVEDPARAMETERS = (SoilDepth,)
+
+    def update(self):
+        r"""Calculate the maximum soil water content based on
+        :math:`1000 \cdot AvailableFieldCapacity \cdot max(SoilDepth, \, 0.3)`
+
+        >>> from hydpy.models.whmod import *
+        >>> parameterstep()
+        >>> nmbzones(7)
+        >>> landtype(GRASS, GRASS, GRASS, GRASS, GRASS, GRASS, SEALED)
+        >>> soiltype(SAND, SAND_COHESIVE, LOAM, CLAY, SILT, PEAT, NONE)
+        >>> availablefieldcapacity(0.2)
+        >>> derived.soildepth(
+        ...     sand=0.0, sand_cohesive=0.2, loam=0.3, clay=0.4, silt=1.0, peat=1.0
+        ... )
+        >>> derived.maxsoilwater.update()
+        >>> derived.maxsoilwater
+        maxsoilwater(clay=80.0, loam=60.0, peat=200.0, sand=60.0,
+                     sand_cohesive=60.0, silt=200.0)
+        """
+        availablefieldcapacity = self.subpars.pars.control.availablefieldcapacity
+        soildepth = self.subpars.soildepth
+        self(1000.0 * availablefieldcapacity * numpy.maximum(soildepth, 0.3))
+
+
+class Beta(whmod_parameters.SoilTypeParameter):
+    """Nonlinearity parameter for calculating percolation [-]."""
+
+    TYPE, TIME, SPAN = float, None, (0.0, None)
+
+    CONTROLPARAMETERS = (whmod_control.SoilType,)
+    DERIVEDPARAMETERS = (MaxSoilWater,)
+
+    def update(self):
+        r"""Calculate |Beta| based on
+        :math:`1 + \frac{6}{1 + (MaxSoilWater / 118.25)^{-6.5}}`
+        :cite:p:`ref-Armbruster2002`.
+
+        >>> from hydpy.models.whmod import *
+        >>> parameterstep()
+        >>> nmbzones(7)
+        >>> landtype(GRASS, GRASS, GRASS, GRASS, GRASS, GRASS, SEALED)
+        >>> soiltype(SAND, SAND_COHESIVE, LOAM, CLAY, SILT, PEAT, NONE)
+        >>> derived.maxsoilwater(
+        ...     sand=0.0, sand_cohesive=50.0, loam=100.0, clay=150.0, silt=200.0,
+        ...     peat=250.0
+        ... )
+        >>> derived.beta.update()
+        >>> derived.beta
+        beta(clay=5.945944, loam=2.510161, peat=6.954142, sand=1.0,
+             sand_cohesive=1.022215, silt=6.809179)
+
+        >>> nmbzones(2)
+        >>> landtype(WATER, SEALED)
+        >>> soiltype(NONE)
+        >>> derived.maxsoilwater(100.0)
+        >>> derived.beta.update()
+        >>> derived.beta
+        beta(nan)
+        """
+        maxsoilwater = self.subpars.maxsoilwater
+        self.values = numpy.nan
+        idxs1 = self.subpars.pars.control.soiltype.values != NONE
+        idxs2 = maxsoilwater.values <= 0.0
+        idxs3 = idxs1 * idxs2
+        self.values[idxs3] = 1.0
+        idxs4 = idxs1 * ~idxs2
+        self.values[idxs4] = 1.0 + 6.0 / (1 + (maxsoilwater[idxs4] / 118.25) ** -6.5)
+
+
+class PotentialCapillaryRise(whmod_parameters.SoilTypeParameter):
+    """Potential capillary rise [mm/T]."""
+
+    TYPE, TIME, SPAN = float, True, (0.0, None)
+
+    CONTROLPARAMETERS = (
+        whmod_control.SoilType,
+        whmod_control.CapillaryThreshold,
+        whmod_control.CapillaryLimit,
+        whmod_control.RootingDepth,
+        whmod_control.GroundwaterDepth,
+    )
+    DERIVEDPARAMETERS = (SoilDepth,)
+
+    def update(self):
+        r"""Calculate the potential capillary rise based on
+        :math:`5 \cdot Days \cdot
+        \frac{(GroundwaterDepth - SoilDepth) - CapillaryThreshold}
+        {CapillaryLimit - CapillaryThreshold}`.
+
+        >>> from hydpy.models.whmod import *
+        >>> simulationstep("1h")
+        >>> parameterstep("1d")
+        >>> nmbzones(7)
+        >>> landtype(GRASS, GRASS, GRASS, GRASS, GRASS, GRASS, SEALED)
+        >>> soiltype(SAND, SAND, SAND, SAND, SAND, SAND, NONE)
+        >>> capillarythreshold(sand=0.8)
+        >>> capillarylimit(sand=0.4)
+        >>> derived.soildepth(sand=1.0)
+        >>> groundwaterdepth(1.2, 1.4, 1.6, 1.8, 2.0, nan, nan)
+        >>> derived.potentialcapillaryrise.update()
+        >>> derived.potentialcapillaryrise
+        potentialcapillaryrise(5.0, 5.0, 2.5, 0.0, 0.0, nan, nan)
+        >>> from hydpy import print_vector
+        >>> print_vector(derived.potentialcapillaryrise.values)
+        0.208333, 0.208333, 0.104167, 0.0, 0.0, nan, nan
+
+        >>> capillarythreshold(sand=0.6)
+        >>> capillarylimit(sand=0.6)
+        >>> derived.potentialcapillaryrise.update()
+        >>> derived.potentialcapillaryrise
+        potentialcapillaryrise(5.0, 5.0, 0.0, 0.0, 0.0, nan, nan)
+        """
+
+        self.values = numpy.nan
+        values = self.values
+        maxrise = 5.0 * hydpy.pub.options.simulationstep.days
+        control = self.subpars.pars.control
+        for i, (soiltype, threshold, limit, delta) in enumerate(
+            zip(
+                control.soiltype.values,
+                control.capillarythreshold.values,
+                control.capillarylimit.values,
+                control.groundwaterdepth.values - self.subpars.soildepth.values,
+            )
+        ):
+            if soiltype != NONE:
+                if delta >= threshold:
+                    values[i] = 0.0
+                elif delta <= limit:
+                    values[i] = maxrise
+                else:
+                    values[i] = maxrise * ((delta - threshold) / (limit - threshold))

hydpy/models/whmod/whmod_factors.py

@@ -0,0 +1,9 @@
+# pylint: disable=missing-module-docstring
+
+from hydpy.models.whmod import whmod_sequences
+
+
+class RelativeSoilMoisture(whmod_sequences.Factor1DSoilSequence):
+    """Crop-available relative soil water content [-]."""
+
+    SPAN = (0.0, 1.0)