HydPy 6.2.dev1__cp313-cp313-win_amd64.whl

hydpy/models/dummy/dummy_inputs.py

@@ -0,0 +1,41 @@
+# pylint: disable=missing-module-docstring
+
+# import...
+# ...from HydPy
+from hydpy.core import sequencetools
+
+
+class InterceptedWater(sequencetools.InputSequence):
+    """Intercepted water [mm]."""
+
+    NDIM, NUMERIC, SPAN = 1, False, (0.0, None)
+    STANDARD_NAME = sequencetools.StandardInputNames.INTERCEPTED_WATER_HRU
+
+
+class SoilWater(sequencetools.InputSequence):
+    """Soil water content [mm]."""
+
+    NDIM, NUMERIC, SPAN = 1, False, (0.0, None)
+    STANDARD_NAME = sequencetools.StandardInputNames.SOIL_WATER_HRU
+
+
+class SnowCover(sequencetools.InputSequence):
+    """Snow cover degree [-]."""
+
+    NDIM, NUMERIC, SPAN = 1, False, (0.0, None)
+    STANDARD_NAME = sequencetools.StandardInputNames.SNOW_COVER_DEGREE_HRU
+
+
+class SnowyCanopy(sequencetools.InputSequence):
+    """Snow cover degree in the canopies of tree-like vegetation (is |numpy.nan| for
+    non-tree-like vegetation) [-]."""
+
+    NDIM, NUMERIC, SPAN = 1, False, (0.0, None)
+    STANDARD_NAME = sequencetools.StandardInputNames.SNOW_COVER_DEGREE_CANOPY_HRU
+
+
+class SnowAlbedo(sequencetools.InputSequence):
+    """Snow albedo [-]."""
+
+    NDIM, NUMERIC, SPAN = 1, False, (0.0, 1.0)
+    STANDARD_NAME = sequencetools.StandardInputNames.ALBEDO_HRU

hydpy/models/dummy/dummy_model.py

@@ -0,0 +1,196 @@
+# pylint: disable=missing-module-docstring
+
+# import...
+# ...from standard library
+# ...from site-packages
+# ...from HydPy
+from hydpy.core import modeltools
+from hydpy.models.dummy import dummy_inputs
+from hydpy.models.dummy import dummy_inlets
+from hydpy.models.dummy import dummy_outlets
+from hydpy.models.dummy import dummy_fluxes
+
+
+class Pick_Q_V1(modeltools.Method):
+    r"""Query the current inflow from all inlet nodes.
+
+    Basic equation:
+      :math:`Q_{fluxes} = \sum Q_{inputs}`
+    """
+
+    REQUIREDSEQUENCES = (dummy_inlets.Q,)
+    RESULTSEQUENCES = (dummy_fluxes.Q,)
+
+    @staticmethod
+    def __call__(model: modeltools.Model) -> None:
+        flu = model.sequences.fluxes.fastaccess
+        inl = model.sequences.inlets.fastaccess
+        flu.q = 0.0
+        for idx in range(inl.len_q):
+            flu.q += inl.q[idx][0]
+
+
+class Pass_Q_V1(modeltools.Method):
+    """Update the outlet link sequence.
+
+    Basic equation:
+        :math:`Q_{outlets} = Q_{fluxes}`
+    """
+
+    REQUIREDSEQUENCES = (dummy_fluxes.Q,)
+    RESULTSEQUENCES = (dummy_outlets.Q,)
+
+    @staticmethod
+    def __call__(model: modeltools.Model) -> None:
+        flu = model.sequences.fluxes.fastaccess
+        out = model.sequences.outlets.fastaccess
+        out.q[0] += flu.q
+
+
+class Get_InterceptedWater_V1(modeltools.Method):
+    """Get the selected zone's current amount of intercepted water.
+
+    Example:
+
+        >>> from hydpy.models.dummy import *
+        >>> parameterstep()
+        >>> inputs.interceptedwater.shape = 2
+        >>> inputs.interceptedwater = 2.0, 4.0
+        >>> from hydpy import round_
+        >>> round_(model.get_interceptedwater_v1(0))
+        2.0
+        >>> round_(model.get_interceptedwater_v1(1))
+        4.0
+    """
+
+    REQUIREDSEQUENCES = (dummy_inputs.InterceptedWater,)
+
+    @staticmethod
+    def __call__(model: modeltools.Model, k: int) -> float:
+        inp = model.sequences.inputs.fastaccess
+
+        return inp.interceptedwater[k]
+
+
+class Get_SoilWater_V1(modeltools.Method):
+    """Get the selected zone's current soil water amount.
+
+    Example:
+
+        >>> from hydpy.models.dummy import *
+        >>> parameterstep()
+        >>> inputs.soilwater.shape = 2
+        >>> inputs.soilwater = 2.0, 4.0
+        >>> from hydpy import round_
+        >>> round_(model.get_soilwater_v1(0))
+        2.0
+        >>> round_(model.get_soilwater_v1(1))
+        4.0
+    """
+
+    REQUIREDSEQUENCES = (dummy_inputs.SoilWater,)
+
+    @staticmethod
+    def __call__(model: modeltools.Model, k: int) -> float:
+        inp = model.sequences.inputs.fastaccess
+
+        return inp.soilwater[k]
+
+
+class Get_SnowCover_V1(modeltools.Method):
+    """Get the selected zone's current snow cover fraction.
+
+    Example:
+
+        >>> from hydpy.models.dummy import *
+        >>> parameterstep()
+        >>> inputs.snowcover.shape = 2
+        >>> inputs.snowcover = 2.0, 4.0
+        >>> from hydpy import round_
+        >>> round_(model.get_snowcover_v1(0))
+        2.0
+        >>> round_(model.get_snowcover_v1(1))
+        4.0
+    """
+
+    REQUIREDSEQUENCES = (dummy_inputs.SnowCover,)
+
+    @staticmethod
+    def __call__(model: modeltools.Model, k: int) -> float:
+        inp = model.sequences.inputs.fastaccess
+
+        return inp.snowcover[k]
+
+
+class Get_SnowyCanopy_V1(modeltools.Method):
+    """Get the selected zone's current snow cover degree in the canopies of tree-like
+    vegetation (or |numpy.nan| if the zone's vegetation is not tree-like).
+
+    Example:
+
+        >>> from hydpy.models.dummy import *
+        >>> parameterstep()
+        >>> inputs.snowycanopy.shape = 2
+        >>> inputs.snowycanopy = 2.0, 4.0
+        >>> from hydpy import round_
+        >>> round_(model.get_snowycanopy_v1(0))
+        2.0
+        >>> round_(model.get_snowycanopy_v1(1))
+        4.0
+    """
+
+    REQUIREDSEQUENCES = (dummy_inputs.SnowyCanopy,)
+
+    @staticmethod
+    def __call__(model: modeltools.Model, k: int) -> float:
+        inp = model.sequences.inputs.fastaccess
+
+        return inp.snowycanopy[k]
+
+
+class Get_SnowAlbedo_V1(modeltools.Method):
+    """Get the selected zone's current snow albedo.
+
+    Example:
+
+        >>> from hydpy.models.dummy import *
+        >>> parameterstep()
+        >>> inputs.snowalbedo.shape = 2
+        >>> inputs.snowalbedo = 2.0, 4.0
+        >>> from hydpy import round_
+        >>> round_(model.get_snowalbedo_v1(0))
+        2.0
+        >>> round_(model.get_snowalbedo_v1(1))
+        4.0
+    """
+
+    REQUIREDSEQUENCES = (dummy_inputs.SnowAlbedo,)
+
+    @staticmethod
+    def __call__(model: modeltools.Model, k: int) -> float:
+        inp = model.sequences.inputs.fastaccess
+
+        return inp.snowalbedo[k]
+
+
+class Model(modeltools.AdHocModel):
+    """|dummy.DOCNAME.complete|."""
+
+    DOCNAME = modeltools.DocName(short="Dummy")
+    __HYDPY_ROOTMODEL__ = None
+
+    INLET_METHODS = (Pick_Q_V1,)
+    RECEIVER_METHODS = ()
+    RUN_METHODS = ()
+    INTERFACE_METHODS = (
+        Get_InterceptedWater_V1,
+        Get_SoilWater_V1,
+        Get_SnowCover_V1,
+        Get_SnowyCanopy_V1,
+        Get_SnowAlbedo_V1,
+    )
+    ADD_METHODS = ()
+    OUTLET_METHODS = (Pass_Q_V1,)
+    SENDER_METHODS = ()
+    SUBMODELINTERFACES = ()
+    SUBMODELS = ()

hydpy/models/dummy/dummy_outlets.py

@@ -0,0 +1,11 @@
+# pylint: disable=missing-module-docstring
+
+# import...
+# ...from HydPy
+from hydpy.core import sequencetools
+
+
+class Q(sequencetools.OutletSequence):
+    """Abfluss (runoff) [m³/s]."""
+
+    NDIM, NUMERIC = 0, False

hydpy/models/dummy_interceptedwater.py

@@ -0,0 +1,85 @@
+# pylint: disable=unused-wildcard-import
+"""
+|dummy_interceptedwater| 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 interception data.
+
+Integration test
+================
+
+The only functionality of |dummy_interceptedwater| is reading input time series.
+Hence, configuring and testing it does not require additional explanations:
+
+
+>>> from hydpy.models.dummy_interceptedwater 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.interceptedwater.series = [[1.0, 2.0], [3.0, 4.0]]
+
+.. integration-test::
+
+    >>> test()
+    |       date |      interceptedwater |
+    --------------------------------------
+    | 2000-01-01 | 1.0               2.0 |
+    | 2000-02-01 | 3.0               4.0 |
+
+>>> round_(model.get_interceptedwater(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.IntercModel_V1):
+    """|dummy_interceptedwater.DOCNAME.complete|."""
+
+    DOCNAME = modeltools.DocName(
+        short="Dummy-InterceptedWater",
+        description="dummy model supplying main models with intercepted water states",
+    )
+    __HYDPY_ROOTMODEL__ = False
+
+    INLET_METHODS = ()
+    RECEIVER_METHODS = ()
+    RUN_METHODS = ()
+    INTERFACE_METHODS = (dummy_model.Get_InterceptedWater_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_interceptedwater import *
+        >>> parameterstep()
+        >>> model.prepare_nmbzones(2)
+        >>> nmbzones
+        nmbzones(2)
+        """
+        self.parameters.control.nmbzones(nmbzones)
+
+
+tester = Tester()
+cythonizer = Cythonizer()

hydpy/models/dummy_node2node.py

@@ -0,0 +1,83 @@
+# pylint: disable=unused-wildcard-import
+"""
+.. _`LARSIM`: http://www.larsim.de/en/the-model/
+
+|dummy_node2node| serves as a placeholder model.  In each simulation step, it simply
+sums up its inputs and hands the resulting value to the downstream node without
+modifications.
+
+In *HydPy*, it is fairly easy to introduce additional |Element| objects and thus bring
+new models of arbitrary types into existing network structures.  Hence, there is
+typically no need to define dummy elements or models in anticipation of possible future
+changes.  However, application model |dummy_node2node| can help to more closely reflect
+the actual network structures of other model systems as `LARSIM`_, which are more
+restrictive regarding future changes and network complexity.
+
+Integration test
+================
+
+    .. how_to_understand_integration_tests::
+
+    We prepare a simulation period of three days:
+
+    >>> from hydpy import pub
+    >>> pub.timegrids = "2000-01-01", "2000-01-04", "1d"
+
+    The model object does not require any parameter information:
+
+    >>> from hydpy.models.dummy_node2node import *
+    >>> parameterstep()
+
+    We add the model object to an element connected to two inlet nodes and one outlet
+    node and prepare a runnable test object:
+
+    >>> from hydpy import Element, IntegrationTest
+    >>> element = Element("element",
+    ...                   inlets=("inlet1", "inlet2"),
+    ...                   outlets="outlet")
+    >>> element.model = model
+    >>> test = IntegrationTest(element)
+
+    After defining two input series, we can demonstrate that each pair of values of the
+    inlet nodes is summed up and handed to the outlet node:
+
+    >>> element.inlets.inlet1.sequences.sim.series = 0.0, 1.0, 2.0
+    >>> element.inlets.inlet2.sequences.sim.series = 0.0, 2.0, -4.0
+    >>> test()
+    |                date |    q | inlet1 | inlet2 | outlet |
+    ---------------------------------------------------------
+    | 2000-01-01 00:00:00 |  0.0 |    0.0 |    0.0 |    0.0 |
+    | 2000-01-02 00:00:00 |  3.0 |    1.0 |    2.0 |    3.0 |
+    | 2000-01-03 00:00:00 | -2.0 |    2.0 |   -4.0 |   -2.0 |
+"""
+
+# import...
+# ...from HydPy
+from hydpy.exe.modelimports import *
+from hydpy.core import modeltools
+
+# ...from dummy
+from hydpy.models.dummy import dummy_model
+
+
+class Model(modeltools.AdHocModel):
+    """|dummy_node2node.DOCNAME.complete|."""
+
+    DOCNAME = modeltools.DocName(
+        short="Dummy-Node2Node",
+        description="dummy model passing data from inlet to outlet nodes",
+    )
+    __HYDPY_ROOTMODEL__ = True
+
+    INLET_METHODS = (dummy_model.Pick_Q_V1,)
+    RECEIVER_METHODS = ()
+    RUN_METHODS = ()
+    ADD_METHODS = ()
+    OUTLET_METHODS = (dummy_model.Pass_Q_V1,)
+    SENDER_METHODS = ()
+    SUBMODELINTERFACES = ()
+    SUBMODELS = ()
+
+
+tester = Tester()
+cythonizer = Cythonizer()

hydpy/models/dummy_snowalbedo.py

@@ -0,0 +1,84 @@
+# pylint: disable=unused-wildcard-import
+"""
+|dummy_snowalbedo| merely serves testing purposes.  We use it, for example, to perform
+the integration tests for submodels like |evap_aet_morsim| without the need to couple
+them to complex main models like |lland_knauf| for providing snow albedo data.
+
+Integration test
+================
+
+The only functionality of |dummy_snowalbedo| is reading input time series.  Hence,
+configuring and testing it does not require additional explanations:
+
+>>> from hydpy.models.dummy_snowalbedo 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.snowalbedo.series = [[1.0, 2.0], [3.0, 4.0]]
+
+.. integration-test::
+
+    >>> test()
+    |       date |      snowalbedo |
+    --------------------------------
+    | 2000-01-01 | 1.0         2.0 |
+    | 2000-02-01 | 3.0         4.0 |
+
+>>> round_(model.get_snowalbedo_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.SnowAlbedoModel_V1):
+    """|dummy_snowalbedo.DOCNAME.complete|."""
+
+    DOCNAME = modeltools.DocName(
+        short="Dummy-SnowAlbedo",
+        description="dummy model supplying main models with snow albedo states",
+    )
+    __HYDPY_ROOTMODEL__ = False
+
+    INLET_METHODS = ()
+    RECEIVER_METHODS = ()
+    RUN_METHODS = ()
+    INTERFACE_METHODS = (dummy_model.Get_SnowAlbedo_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/dummy_snowcover.py

@@ -0,0 +1,84 @@
+# pylint: disable=unused-wildcard-import
+"""
+|dummy_snowcover| 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 snow cover data.
+
+Integration test
+================
+
+The only functionality of |dummy_snowcover| is reading input time series.  Hence,
+configuring and testing it does not require additional explanations:
+
+>>> from hydpy.models.dummy_snowcover 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.snowcover.series = [[1.0, 2.0], [3.0, 4.0]]
+
+.. integration-test::
+
+    >>> test()
+    |       date |      snowcover |
+    -------------------------------
+    | 2000-01-01 | 1.0        2.0 |
+    | 2000-02-01 | 3.0        4.0 |
+
+>>> round_(model.get_snowcover_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.SnowCoverModel_V1):
+    """|dummy_snowcover.DOCNAME.complete|."""
+
+    DOCNAME = modeltools.DocName(
+        short="Dummy-SnowCover",
+        description="dummy model supplying main models with snow cover states",
+    )
+    __HYDPY_ROOTMODEL__ = False
+
+    INLET_METHODS = ()
+    RECEIVER_METHODS = ()
+    RUN_METHODS = ()
+    INTERFACE_METHODS = (dummy_model.Get_SnowCover_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_snowcover import *
+        >>> parameterstep()
+        >>> model.prepare_nmbzones(2)
+        >>> nmbzones
+        nmbzones(2)
+        """
+        self.parameters.control.nmbzones(nmbzones)
+
+
+tester = Tester()
+cythonizer = Cythonizer()

hydpy/models/dummy_snowycanopy.py

@@ -0,0 +1,86 @@
+# pylint: disable=unused-wildcard-import
+"""
+|dummy_snowycanopy| merely serves testing purposes.  We use it, for example, to perform
+the integration tests for submodels like |evap_aet_morsim| without the need to couple
+them to complex main models like |lland_knauf| for providing snow interception data.
+
+Integration test
+================
+
+The only functionality of |dummy_snowycanopy| is reading input time series.  Hence,
+configuring and testing it does not require additional explanations:
+
+>>> from hydpy.models.dummy_snowycanopy 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.snowycanopy.series = [[1.0, 2.0], [3.0, 4.0]]
+
+.. integration-test::
+
+    >>> test()
+    |       date |      snowycanopy |
+    ---------------------------------
+    | 2000-01-01 | 1.0          2.0 |
+    | 2000-02-01 | 3.0          4.0 |
+
+>>> round_(model.get_snowycanopy_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.SnowyCanopyModel_V1):
+    """|dummy_snowycanopy.DOCNAME.complete|."""
+
+    DOCNAME = modeltools.DocName(
+        short="Dummy-SnowyCanopy",
+        description=(
+            "dummy model supplying main models with snow cover degrees in canopies"
+        ),
+    )
+    __HYDPY_ROOTMODEL__ = False
+
+    INLET_METHODS = ()
+    RECEIVER_METHODS = ()
+    RUN_METHODS = ()
+    INTERFACE_METHODS = (dummy_model.Get_SnowyCanopy_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_snowcover import *
+        >>> parameterstep()
+        >>> model.prepare_nmbzones(2)
+        >>> nmbzones
+        nmbzones(2)
+        """
+        self.parameters.control.nmbzones(nmbzones)
+
+
+tester = Tester()
+cythonizer = Cythonizer()