HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/interfaces/aetinterfaces.py

@@ -0,0 +1,94 @@
+"""This module defines submodel interfaces for calculating actual evapotranspiration."""
+
+# import...
+# ...from hydpy
+from hydpy.core import modeltools
+from hydpy.core.typingtools import *
+
+
+class AETModel_V1(modeltools.SubmodelInterface):
+    """Interface for calculating interception evaporation, evapotranspiration from
+    soils, evaporation from water areas in separate steps.
+
+    An essential note for model developers: All main models using the |AETModel_V1|
+    interface must first call |AETModel_V1.determine_interceptionevaporation| but are
+    free to choose the execution order of methods
+    |AETModel_V1.determine_soilevapotranspiration| and
+    |AETModel_V1.determine_waterevaporation|.  All submodels following the
+    |AETModel_V1| interface must work for both orders.  Additionally, the main model
+    must calculate its snow routine (if it has one) before calling any method defined
+    by the |AETModel_V1| interface.
+    """
+
+    typeid: ClassVar[Literal[1]] = 1
+    """Type identifier for |AETModel_V1| submodels."""
+
+    def prepare_nmbzones(self, nmbzones: int) -> None:
+        """Set the number of zones in which the actual calculations take place."""
+
+    def prepare_subareas(self, subareas: Sequence[float]) -> None:
+        """Set the areas of the individual zones in km²."""
+
+    def prepare_elevations(self, elevations: Sequence[float]) -> None:
+        """Set the elevations of the individual zones in m."""
+
+    def prepare_zonetypes(self, zonetypes: Sequence[int]) -> None:
+        """Set the types (usually land cover types) of the individual zones."""
+
+    def prepare_water(self, water: VectorInputBool) -> None:
+        """Set the flags for whether the individual zones are water areas or not."""
+
+    def prepare_interception(self, interception: VectorInputBool) -> None:
+        """Set the flags for whether interception evaporation is relevant for the
+        individual zones."""
+
+    def prepare_soil(self, soil: VectorInputBool) -> None:
+        """Set the flags for whether soil evapotranspiration is relevant for the
+        individual zones."""
+
+    def prepare_plant(self, tree: VectorInputBool) -> None:
+        """Set the flags for whether the individual zones contain any vegetation."""
+
+    def prepare_tree(self, tree: VectorInputBool) -> None:
+        """Set the flags for whether the individual zones contain tree-like
+        vegetation."""
+
+    def prepare_conifer(self, conifer: VectorInputBool) -> None:
+        """Set the flags for whether the individual zones contain conifer-like
+        vegetation."""
+
+    def prepare_measuringheightwindspeed(self, measuringheightwindspeed: float) -> None:
+        """Set the height above the ground of the wind speed measurements in m."""
+
+    def prepare_leafareaindex(self, maxsoilwater: MatrixInputFloat) -> None:
+        """Set the leaf area index in m²/m²."""
+
+    def prepare_maxsoilwater(self, maxsoilwater: VectorInputFloat) -> None:
+        """Set the maximum soil water content in mm."""
+
+    @modeltools.abstractmodelmethod
+    def determine_interceptionevaporation(self) -> None:
+        """Determine the actual interception evaporation."""
+
+    @modeltools.abstractmodelmethod
+    def determine_soilevapotranspiration(self) -> None:
+        """Determine the actual evapotranspiration from the soil."""
+
+    @modeltools.abstractmodelmethod
+    def determine_waterevaporation(self) -> None:
+        """Determine the actual evapotranspiration from open water areas."""
+
+    @modeltools.abstractmodelmethod
+    def get_interceptionevaporation(self, k: int) -> float:
+        """Get the selected zone's previously calculated interception evaporation in
+        mm/T."""
+
+    @modeltools.abstractmodelmethod
+    def get_soilevapotranspiration(self, k: int) -> float:
+        """Get the selected zone's previously calculated soil evapotranspiration in
+        mm/T."""
+
+    @modeltools.abstractmodelmethod
+    def get_waterevaporation(self, k: int) -> float:
+        """Get the selected zone's previously calculated water area evaporation in
+        mm/T."""

hydpy/interfaces/dischargeinterfaces.py

@@ -0,0 +1,45 @@
+"""This module defines interfaces for calculating discharge based on flow formulas or
+rating curves."""
+
+# import...
+# ...from hydpy
+from hydpy.core import modeltools
+from hydpy.core.typingtools import *
+
+
+class DischargeModel_V1(modeltools.SubmodelInterface):
+    """Simple interface for calculating discharge in m³/s based on the current water
+    depth."""
+
+    typeid: ClassVar[Literal[1]] = 1
+    """Type identifier for |DischargeModel_V1| submodels."""
+
+    def prepare_channeldepth(self, channeldepth: float) -> None:
+        """Set the channel depth in m."""
+
+    def prepare_tolerance(self, tolerance: float) -> None:
+        """Set the water depth-related smoothing parameter in m."""
+
+    @modeltools.abstractmodelmethod
+    def calculate_discharge(self, waterdepth: float) -> float:
+        """Calculate the discharge based on the water depth given in m and return it in
+        m³/s."""
+
+
+class DischargeModel_V2(modeltools.SubmodelInterface):
+    """Simple interface for calculating discharge in mm/T based on the current water
+    depth."""
+
+    typeid: ClassVar[Literal[2]] = 2
+    """Type identifier for |DischargeModel_V2| submodels."""
+
+    def prepare_channeldepth(self, channeldepth: float) -> None:
+        """Set the channel depth in m."""
+
+    def prepare_tolerance(self, tolerance: float) -> None:
+        """Set the water depth-related smoothing parameter in m."""
+
+    @modeltools.abstractmodelmethod
+    def calculate_discharge(self, waterdepth: float) -> float:
+        """Calculate the discharge based on the water depth given in m and return it in
+        mm/T."""

hydpy/interfaces/petinterfaces.py

@@ -0,0 +1,117 @@
+"""This module defines submodel interfaces for calculating potential
+evapotranspiration."""
+
+# import...
+# ...from hydpy
+from hydpy.core import modeltools
+from hydpy.core.typingtools import *
+
+
+class PETModel_V1(modeltools.SubmodelInterface):
+    """Simple interface for calculating all potential evapotranspiration values in one
+    step."""
+
+    typeid: ClassVar[Literal[1]] = 1
+    """Type identifier for |PETModel_V1| submodels."""
+
+    def prepare_nmbzones(self, nmbzones: int) -> None:
+        """Set the number of zones in which the actual calculations take place."""
+
+    def prepare_subareas(self, subareas: Sequence[float]) -> None:
+        """Set the areas of the individual zones in km²."""
+
+    def prepare_zonetypes(self, zonetypes: Sequence[int]) -> None:
+        """Set the types (usually land cover types) of the individual zones."""
+
+    def prepare_measuringheightwindspeed(self, measuringheightwindspeed: float) -> None:
+        """Set the height above the ground of the wind speed measurements in m."""
+
+    @modeltools.abstractmodelmethod
+    def determine_potentialevapotranspiration(self) -> None:
+        """Calculate potential evapotranspiration."""
+
+    @modeltools.abstractmodelmethod
+    def get_potentialevapotranspiration(self, k: int) -> float:
+        """Get the previously calculated potential evapotranspiration of the selected
+        zone in mm/T."""
+
+    @modeltools.abstractmodelmethod
+    def get_meanpotentialevapotranspiration(self) -> float:
+        """Get the previously calculated average potential evapotranspiration in
+        mm/T."""
+
+
+class PETModel_V2(modeltools.SubmodelInterface):
+    """Interface for calculating separate potential interception, soil, and water
+    evapotranspiration values.
+
+    An essential note for model developers: All main models using the |PETModel_V2|
+    interface must first call |PETModel_V2.determine_potentialinterceptionevaporation|
+    but are free to choose the execution order of methods
+    |PETModel_V2.determine_potentialsoilevapotranspiration| and
+    |PETModel_V2.determine_potentialwaterevaporation|.  All submodels following the
+    |PETModel_V2| interface must work for both orders.
+    """
+
+    typeid: ClassVar[Literal[2]] = 2
+    """Type identifier for |PETModel_V2| submodels."""
+
+    def prepare_nmbzones(self, nmbzones: int) -> None:
+        """Set the number of zones in which the actual calculations take place."""
+
+    def prepare_subareas(self, subareas: Sequence[float]) -> None:
+        """Set the areas of the individual zones in km²."""
+
+    def prepare_zonetypes(self, zonetypes: Sequence[int]) -> None:
+        """Set the types (usually land cover types) of the individual zones."""
+
+    def prepare_water(self, water: VectorInputBool) -> None:
+        """Set the flags for whether the individual zones are water areas or not."""
+
+    def prepare_interception(self, interception: VectorInputBool) -> None:
+        """Set the flags for whether interception evaporation is relevant for the
+        individual zones."""
+
+    def prepare_soil(self, soil: VectorInputBool) -> None:
+        """Set the flags for whether soil evapotranspiration is relevant for the
+        individual zones."""
+
+    def prepare_plant(self, tree: VectorInputBool) -> None:
+        """Set the flags for whether the individual zones contain any vegetation."""
+
+    def prepare_tree(self, tree: VectorInputBool) -> None:
+        """Set the flags for whether the individual zones contain tree-like
+        vegetation."""
+
+    def prepare_measuringheightwindspeed(self, measuringheightwindspeed: float) -> None:
+        """Set the height above the ground of the wind speed measurements in m."""
+
+    def prepare_leafareaindex(self, maxsoilwater: MatrixInputFloat) -> None:
+        """Set the leaf area index in m²/m²."""
+
+    @modeltools.abstractmodelmethod
+    def determine_potentialinterceptionevaporation(self) -> None:
+        """Calculate potential interception evaporation."""
+
+    @modeltools.abstractmodelmethod
+    def get_potentialinterceptionevaporation(self, k: int) -> float:
+        """Get the selected zone's previously calculated potential interception
+        evaporation in mm/T."""
+
+    @modeltools.abstractmodelmethod
+    def determine_potentialsoilevapotranspiration(self) -> None:
+        """Calculate potential evapotranspiration from the soil."""
+
+    @modeltools.abstractmodelmethod
+    def get_potentialsoilevapotranspiration(self, k: int) -> float:
+        """Get the previously calculated potential evapotranspiration from the soil of
+        the selected zone in mm/T."""
+
+    @modeltools.abstractmodelmethod
+    def determine_potentialwaterevaporation(self) -> None:
+        """Calculate potential evaporation from open water areas."""
+
+    @modeltools.abstractmodelmethod
+    def get_potentialwaterevaporation(self, k: int) -> float:
+        """Get the previously calculated potential evaporation from open water areas of
+        the selected zone in mm/T."""

hydpy/interfaces/precipinterfaces.py

@@ -0,0 +1,42 @@
+"""This module defines submodel interfaces for providing precipitation."""
+
+# import...
+# ...from hydpy
+from hydpy.core import modeltools
+from hydpy.core.typingtools import *
+
+
+class PrecipModel_V1(modeltools.SubmodelInterface):
+    """Pure getter interface for using main models as sub-submodels."""
+
+    typeid: ClassVar[Literal[1]] = 1
+    """Type identifier for |PrecipModel_V1| submodels."""
+
+    @modeltools.abstractmodelmethod
+    def get_precipitation(self, k: int) -> float:
+        """Get the selected zone's precipitation value in mm/T."""
+
+
+class PrecipModel_V2(modeltools.SubmodelInterface):
+    """Simple interface for determining precipitation in one step."""
+
+    typeid: ClassVar[Literal[2]] = 2
+    """Type identifier for |PrecipModel_V2| submodels."""
+
+    def prepare_nmbzones(self, nmbzones: int) -> None:
+        """Set the number of zones in which the actual calculations take place."""
+
+    def prepare_subareas(self, subareas: Sequence[float]) -> None:
+        """Set the areas of the individual zones in km²."""
+
+    @modeltools.abstractmodelmethod
+    def determine_precipitation(self) -> None:
+        """Determine precipitation."""
+
+    @modeltools.abstractmodelmethod
+    def get_precipitation(self, k: int) -> float:
+        """Get the selected zone's precipitation value in mm/T."""
+
+    @modeltools.abstractmodelmethod
+    def get_meanprecipitation(self) -> float:
+        """Get the previously calculated average precipitation in mm/T."""

hydpy/interfaces/radiationinterfaces.py

@@ -0,0 +1,79 @@
+"""This module defines submodel interfaces for providing radiation-related data."""
+
+# import...
+# ...from hydpy
+from hydpy.core import modeltools
+from hydpy.core.typingtools import *
+
+
+class RadiationModel_V1(modeltools.SharableSubmodelInterface):
+    """Simple interface for determining all data in one step."""
+
+    typeid: ClassVar[Literal[1]] = 1
+    """Type identifier for |RadiationModel_V1| submodels."""
+
+    @modeltools.abstractmodelmethod
+    def process_radiation(self) -> None:
+        """Read and calculate all eventually required sunshine and radiation data."""
+
+    @modeltools.abstractmodelmethod
+    def get_possiblesunshineduration(self) -> float:
+        """Get the possible sunshine duration in h."""
+
+    @modeltools.abstractmodelmethod
+    def get_sunshineduration(self) -> float:
+        """Get the sunshine duration in h."""
+
+    @modeltools.abstractmodelmethod
+    def get_clearskysolarradiation(self) -> float:
+        """Get the clear sky solar radiation in W/m²."""
+
+    @modeltools.abstractmodelmethod
+    def get_globalradiation(self) -> float:
+        """Get the global radiation in W/m²."""
+
+
+class RadiationModel_V2(modeltools.SharableSubmodelInterface):
+    """Pure getter interface for global radiation."""
+
+    typeid: ClassVar[Literal[2]] = 2
+    """Type identifier for |RadiationModel_V2| submodels."""
+
+    @modeltools.abstractmodelmethod
+    def get_globalradiation(self) -> float:
+        """Get the global radiation in W/m²."""
+
+
+class RadiationModel_V3(modeltools.SharableSubmodelInterface):
+    """Pure getter interface for clear-sky solar radiation and global radiation."""
+
+    typeid: ClassVar[Literal[3]] = 3
+    """Type identifier for |RadiationModel_V3| submodels."""
+
+    @modeltools.abstractmodelmethod
+    def get_clearskysolarradiation(self) -> float:
+        """Get the clear sky solar radiation in W/m²."""
+
+    @modeltools.abstractmodelmethod
+    def get_globalradiation(self) -> float:
+        """Get the global radiation in W/m²."""
+
+
+class RadiationModel_V4(modeltools.SharableSubmodelInterface):
+    """Pure getter interface for possible sunshine duration, actual sunshine duration,
+    and global radiation."""
+
+    typeid: ClassVar[Literal[4]] = 4
+    """Type identifier for |RadiationModel_V4| submodels."""
+
+    @modeltools.abstractmodelmethod
+    def get_possiblesunshineduration(self) -> float:
+        """Get the possible sunshine duration in h."""
+
+    @modeltools.abstractmodelmethod
+    def get_sunshineduration(self) -> float:
+        """Get the sunshine duration in h."""
+
+    @modeltools.abstractmodelmethod
+    def get_globalradiation(self) -> float:
+        """Get the global radiation in W/m²."""

hydpy/interfaces/rconcinterfaces.py

@@ -0,0 +1,30 @@
+"""This module defines submodel interfaces for calculating runoff concentration
+processes."""
+
+# import...
+# ...from hydpy
+from hydpy.core import modeltools
+from hydpy.core.typingtools import *
+
+
+class RConcModel_V1(modeltools.SubmodelInterface):
+    """Simple interface for calculating runoff concentration processes."""
+
+    typeid: ClassVar[Literal[1]] = 1
+    """Type identifier for |RConcModel_V1| submodels."""
+
+    def get_waterbalance(self, initial_conditions: ConditionsSubmodel) -> float:
+        """Get the difference between currently stored water and the given initial
+        conditions in mm."""
+
+    @modeltools.abstractmodelmethod
+    def set_inflow(self, inflow: float) -> None:
+        """Set the runoff concentration input in mm/T."""
+
+    @modeltools.abstractmodelmethod
+    def determine_outflow(self) -> None:
+        """Calculate runoff concentration output."""
+
+    @modeltools.abstractmodelmethod
+    def get_outflow(self) -> float:
+        """Get the previously calculated runoff concentration output in mm/T."""