without env

.gitattributes

@@ -0,0 +1,59 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Zuzanna Osika
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights  
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
+copies of the Software, and to permit persons to whom the Software is  
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in  
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
+THE SOFTWARE.

README.md

@@ -0,0 +1,102 @@
+# MORL4Water
+
+<details>
+<summary>🥐 Dataset Metadata</summary>
+
+This repository includes a Croissant metadata file [`croissant.json`](./croissant.json), making MORL4Water compatible with Hugging Face standards for dataset discoverability and interoperability.  
+Learn more about [Croissant metadata](https://huggingface.co/docs/croissant/index).
+
+</details>
+
+---
+
+Welcome to **MORL4Water**, a flexible Gym environment designed for simulating **water management** in river systems.  
+With MORL4Water, you can build detailed water simulations and **train or test multi-objective reinforcement learning (MORL)** agents.
+
+Currently, we have **three river basins** implemented as Gym environments:
+- **Nile River Basin**
+- **Susquehanna River Basin**
+- **Omo River Basin**
+
+The toolkit is **modular**, allowing users to extend or build their own water systems.  
+For an overview of available system components, please refer to the [System Elements](#).
+
+---
+
+## 🚀 Installation and Running
+
+### Installation
+
+Ensure you are using **Python ≥ 3.11**. Install via pip:
+
+```bash
+pip install morl4water
+```
+
+### Running an Example Simulation
+
+```python
+import mo_gymnasium
+import morl4water.examples
+
+# Create the environment
+water_management_system = mo_gymnasium.make('nile-v0')
+
+def run_nile():
+    obs, info = water_management_system.reset()
+    print(f'Initial Obs: {obs}')
+    final_truncated = False
+    final_terminated = False
+    for t in range(10):
+        if not final_terminated and not final_truncated:
+            action = water_management_system.action_space.sample()
+            print(f'Action for month {t}: {action}')
+            (
+                final_observation,
+                final_reward,
+                final_terminated,
+                final_truncated,
+                final_info
+            ) = water_management_system.step(action)
+            print(f'Observation: {final_observation}')
+            print(f'Reward: {final_reward}')
+        else:
+            break
+    return final_observation
+
+run_nile()
+```
+
+---
+
+## 📚 Documentation
+
+For detailed documentation, visit the [MORL4Water Website](https://osikazuzanna.github.io/morl4water/).
+
+---
+
+## 📜 License
+
+This project is licensed under the [MIT License](https://opensource.org/licenses/MIT).
+
+---
+
+## ✨ Citation
+
+If you use MORL4Water in your work, please consider citing it (BibTeX coming soon).
+
+---
+
+
+
+# 🛠️ Contributing
+
+Contributions are welcome! Feel free to open an issue or pull request.
+
+---
+
+# 🛡️ About
+
+Developed by **Zuzanna Osika**, 2025.
+
+---

croissant.json

@@ -0,0 +1,29 @@
+{
+    "@context": "https://w3id.org/croissant/context.jsonld",
+    "@type": "Dataset",
+    "name": "MORL4Water",
+    "description": "MORL4Water is a flexible modular Gym environment for simulating water management in river systems, designed to train and test multi-objective reinforcement learning (MORL) agents. Includes Nile River Basin, Susquehanna River Basin, and Omo River Basin environments.",
+    "license": "https://opensource.org/licenses/MIT",
+    "distribution": [
+      {
+        "@type": "DataDownload",
+        "encodingFormat": "application/zip",
+        "contentUrl": "https://huggingface.co/osikazuzanna/morl4water/resolve/main/morl4water.zip"
+      }
+    ],
+    "creator": {
+      "@type": "Person",
+      "name": "Zuzanna Osika"
+    },
+    "keywords": [
+      "multi-objective reinforcement learning",
+      "MORL",
+      "Gymnasium",
+      "water management",
+      "simulation",
+      "river systems",
+      "environment modeling"
+    ],
+    "datePublished": "2025-04-26"
+  }
+  

morl4water/__init__.py

@@ -0,0 +1,4 @@
+from . import core
+from . import examples
+
+__all__ = ["core", "examples"]

morl4water/core/__init__.py

@@ -0,0 +1,2 @@
+
+

morl4water/core/envs/water_management_system.py

@@ -0,0 +1,247 @@
+import gymnasium as gym
+import numpy as np
+from datetime import datetime
+from dateutil.relativedelta import relativedelta
+from gymnasium.spaces import Box, Dict, Space
+from gymnasium.core import ObsType, RenderFrame
+from typing import Any, Union, Optional
+from morl4water.core.models.flow import Flow
+from morl4water.core.models.facility import Facility, ControlledFacility
+import time
+from gymnasium.spaces import flatten_space
+
+class WaterManagementSystem(gym.Env):
+    def __init__(
+        self,
+        water_systems: list[Union[Facility, ControlledFacility, Flow]],
+        rewards: dict,
+        start_date: datetime,
+        timestep_size: relativedelta,
+        seed: int = 42,
+        add_timestamp = None,
+        custom_obj = None
+    ) -> None:
+        self.water_systems: list[Union[Facility, ControlledFacility, Flow]] = water_systems
+        self.rewards: dict = rewards
+
+        self.start_date: datetime = start_date
+        self.current_date: datetime = start_date
+        self.timestep_size: relativedelta = timestep_size
+        self.timestep: int = 0
+
+        self.seed: int = seed
+        self.add_timestamp = add_timestamp
+        self.custom_obj = custom_obj
+
+        self.observation_space: Space = self._determine_observation_space()
+        self.observation_space = flatten_space(self.observation_space)
+        self.action_space: Space = self._determine_action_space()
+        self.action_space = flatten_space(self.action_space)
+
+        self.max_capacities = self._determine_capacities()
+        
+        if self.custom_obj:
+            self.reward_space: Space = Box(-1.0, 1.0, shape=(len(self.custom_obj),))
+        else:
+            self.reward_space: Space = Box(-1.0, 1.0, shape=(len(rewards.keys()),))
+
+
+        self.observation: np.array = self._determine_observation()
+
+        
+        
+        
+
+        for water_system in self.water_systems:
+            water_system.current_date = self.current_date
+            water_system.timestep_size = self.timestep_size
+
+    def _determine_observation(self) -> np.array:
+        result = []
+        for water_system in self.water_systems:
+            if isinstance(water_system, ControlledFacility):
+                result.append(water_system.determine_observation())
+        result_normalized = list(np.divide(result, self.max_capacities))
+        if self.add_timestamp:
+                result.append(0)
+                result_normalized.append(0)
+            
+        return np.array(result), np.array(result_normalized)
+
+    def _determine_observation_space(self) -> Dict:
+        if self.add_timestamp is not None:
+            return Dict(
+            {
+            **{
+                water_system.name: Box(low=0, high=1)
+                for water_system in self.water_systems
+                if isinstance(water_system, ControlledFacility)
+            },
+            "timestamp": Box(low=0, high=1)
+            }
+            )
+
+        else:
+            return  Dict(
+                {
+                    water_system.name: Box(low=0, high=1)
+                    for water_system in self.water_systems
+                    if isinstance(water_system, ControlledFacility)
+                }
+            )
+
+
+    def _determine_action_space(self) -> Dict:
+        return Dict(
+            {
+                water_system.name: water_system.action_space
+                for water_system in self.water_systems
+                if isinstance(water_system, ControlledFacility)
+            }
+        )
+
+    def _determine_capacities(self):
+        capacities = [water_system.max_capacity for water_system in self.water_systems if isinstance(water_system, ControlledFacility)]
+        return capacities
+    
+    def _is_truncated(self) -> bool:
+        return False
+
+    def _determine_info(self) -> dict[str, Any]:
+        # TODO: decide on what we wnat to output in the info.
+        return {"water_systems": self.water_systems}
+
+    def reset(self, seed: Optional[int] = None, options: Optional[dict] = None) -> tuple[ObsType, dict[str, Any]]:
+        # We need the following line to seed self.np_random.
+        super().reset(seed=seed)
+        self.current_date = self.start_date
+        self.timestep = 0
+
+        self.observation, observation_normalized = self._determine_observation()
+        # Reset rewards
+        for key in self.rewards.keys():
+            self.rewards[key] = 0
+
+        for water_system in self.water_systems:
+            water_system.current_date = self.start_date
+            water_system.reset()
+        return observation_normalized, self._determine_info()
+
+    def step(self, action: np.array) -> tuple[np.array, np.array, bool, bool, dict]:
+        """
+    Execute a single step in the water management simulation.
+
+    This method processes the provided action for each water system in the 
+    environment, updating the states of each facility and returning the 
+    observations, rewards, termination status, truncation status, and 
+    additional information.
+
+    Args:
+        action (np.array): An array of actions to be taken for each 
+            controlled facility in the simulation. The action should 
+            correspond to the facilities' names.
+
+    Returns:
+        tuple[np.array, np.array, bool, bool, dict]:
+            A tuple containing:
+
+            - np.array: A flattened array of normalized observations for 
+              each water system, representing their current states as 
+              percentages of their maximum capacities.
+            - np.array: A flattened array of final rewards collected from 
+              the facilities based on the executed actions.
+            - bool: A flag indicating whether the simulation has 
+              terminated.
+            - bool: A flag indicating whether the simulation has been 
+              truncated.
+            - dict: A dictionary containing additional information, such 
+              as the current date and other relevant data from the 
+              water systems.
+
+    Notes:
+        - The method resets rewards for each facility at the beginning 
+          of the step.
+        - If `custom_obj` is specified, only the relevant rewards are 
+          returned based on the keys in `custom_obj`.
+        - Observations are normalized by dividing by their maximum 
+          capacities.
+        - The method increments the timestep and updates the current 
+          date based on the `timestep_size` attribute.
+
+    """
+
+        final_reward = {}
+        
+
+        # Reset rewards
+        for key in self.rewards.keys():
+            final_reward[key] = 0
+
+        final_observation = {}
+        final_terminated = False
+        final_truncated = False
+        final_info = {"date": self.current_date}
+
+        for water_system in self.water_systems:
+            water_system.current_date = self.current_date
+
+            if isinstance(water_system, ControlledFacility):
+                observation, reward, terminated, truncated, info = water_system.step(action[water_system.name])
+
+            elif isinstance(water_system, Facility) or isinstance(water_system, Flow):
+                observation, reward, terminated, truncated, info = water_system.step()
+            else:
+                raise ValueError()
+
+            # Set observation for a Controlled Facility.
+            if isinstance(water_system, ControlledFacility):
+                final_observation[water_system.name] = observation
+
+            # Add reward to the objective assigned to this Facility (unless it is a Flow or the facility has no objectives).
+            if isinstance(water_system, Facility) or isinstance(water_system, ControlledFacility):
+                if water_system.objective_name:
+                    final_reward[water_system.objective_name] += reward
+
+            # Store additional information
+            final_info[water_system.name] = info
+
+
+            # Determine whether program should stop
+            final_terminated = final_terminated or terminated
+            final_truncated = final_truncated or truncated or self._is_truncated()
+
+
+        self.timestep += 1
+        self.current_date += self.timestep_size
+
+        #check if only a subset of rewards to return
+        if self.custom_obj is not None:
+            final_reward = [final_reward[key] for key in self.custom_obj]
+        else:
+            final_reward = list(final_reward.values())
+
+        final_observations = list(final_observation.values())
+        #normalize the observation to be percentage of max capacity
+        final_observations = list(np.divide(final_observations, self.max_capacities))
+        if self.add_timestamp=='m':
+            final_observations.append(final_info['date'].month/12)
+        elif self.add_timestamp=='h':
+            final_observations.append(final_info['date'].hour/24)
+             
+
+
+        return (
+            np.array(final_observations).flatten(),
+            np.array(final_reward).flatten(),
+            final_terminated,
+            final_truncated,
+            final_info
+        )
+
+    def close(self) -> None:
+        # TODO: implement if needed, e.g. for closing opened rendering frames.
+        pass
+
+    def render(self) -> Union[RenderFrame, list[RenderFrame], None]:
+        # TODO: implement if needed, for rendering simulation.
+        pass

morl4water/core/models/__init__.py

@@ -0,0 +1,12 @@
+# models/__init__.py
+from .catchment import Catchment
+from .flow import Flow, Inflow, Outflow
+from .irrigation_district import IrrigationDistrict
+from .objective import Objective
+from .power_plant import PowerPlant
+from .reservoir_with_pump import ReservoirWithPump
+from .reservoir import Reservoir
+from .weir import Weir
+from .facility import Facility, ControlledFacility
+
+__all__ = ["Catchment", "Flow","Facility","ControlledFacility",  "Inflow", "Outflow", "IrrigationDistrict", "Objective", "PowerPlant", "ReservoirWithPump", "Reservoir", "Weir"]

morl4water/core/models/catchment.py

@@ -0,0 +1,22 @@
+from morl4water.core.models.facility import Facility
+
+
+class Catchment(Facility):
+    def __init__(self, name: str, all_water_accumulated: list[float]) -> None:
+        super().__init__(name)
+        self.all_water_accumulated: list[float] = all_water_accumulated
+
+    def determine_reward(self) -> float:
+        return 0
+
+    def get_inflow(self, timestep: int) -> float:
+        return self.all_water_accumulated[timestep % len(self.all_water_accumulated)]
+
+    def determine_consumption(self) -> float:
+        return 0
+
+    def is_truncated(self) -> bool:
+        return self.timestep >= len(self.all_water_accumulated)
+
+    def determine_info(self) -> dict:
+        return {"water_consumption": self.determine_consumption()}

morl4water/core/models/facility.py

@@ -0,0 +1,339 @@
+import numpy as np
+from abc import ABC, abstractmethod
+from datetime import datetime
+from dateutil.relativedelta import relativedelta
+from gymnasium.spaces import Space, Box
+from gymnasium.core import ObsType, ActType
+from typing import SupportsFloat, Optional
+from morl4water.core.models.objective import Objective
+
+
+class Facility(ABC):
+    """
+    Abstract base class representing a facility with inflow and outflow management, along with reward determination.
+
+    Attributes
+    ----------
+    name : str
+        Identifier for the facility.
+    all_inflow : list[float]
+        Historical inflow values recorded over time.
+    all_outflow : list[float]
+        Historical outflow values recorded over time.
+    objective_function : Callable
+        Function to evaluate the facility’s performance based on defined objectives.
+    objective_name : str
+        Name of the objective function used.
+    current_date : Optional[datetime]
+        Date associated with the current timestep of the facility.
+    timestep_size : Optional[relativedelta]
+        Size of the timestep for simulation. Usually 1 month.
+    timestep : int
+        Current timestep index for the facility simulation.
+    split_release : Optional
+        Placeholder for managing release strategies (usage to be defined).
+    normalize_objective : float
+        Normalization factor for the objective reward.
+    """
+    def __init__(self, name: str, objective_function=Objective.no_objective, objective_name: str = "", normalize_objective=0.0) -> None:
+        """
+        Initializes a Facility instance.
+
+        Args:
+            name (str): Identifier for the facility.
+            objective_function (Callable): Function to evaluate the facility’s performance.
+            objective_name (str): Name of the objective function.
+            normalize_objective (float): Maximum value for normalizing the reward; defaults to 0.0.
+        """
+        self.name: str = name
+        self.all_inflow: list[float] = []
+        self.all_outflow: list[float] = []
+
+        self.objective_function = objective_function
+        self.objective_name = objective_name
+
+        self.current_date: Optional[datetime] = None
+        self.timestep_size: Optional[relativedelta] = None
+        self.timestep: int = 0
+
+        self.split_release = None
+        self.normalize_objective = normalize_objective
+
+    @abstractmethod
+    def determine_reward(self) -> float:
+        """
+        Abstract method to compute the reward based on the facility's performance.
+
+        Returns:
+            float: The computed reward for the current timestep.
+
+        Raises:
+            NotImplementedError: If this method is not implemented in a subclass.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def determine_consumption(self) -> float:
+        """
+        Abstract method to calculate the facility's water consumption.
+
+        Returns:
+            float: The calculated water consumption for the current timestep.
+
+        Raises:
+            NotImplementedError: If this method is not implemented in a subclass.
+        """
+        raise NotImplementedError()
+
+    def is_terminated(self) -> bool:
+        """
+        Checks if the facility simulation has reached a terminating condition.
+
+        Returns:
+            bool: Always returns False for the base Facility class; override in subclasses as needed.
+        """
+        return False
+
+    def is_truncated(self) -> bool:
+        """
+        Checks if the facility simulation has been truncated.
+
+        Returns:
+            bool: Always returns False for the base Facility class; override in subclasses as needed.
+        """
+        return False
+
+    def get_inflow(self, timestep: int) -> float:
+        """
+        Retrieves the inflow value for a specific timestep.
+
+        Args:
+            timestep (int): The timestep index for which to retrieve the inflow.
+
+        Returns:
+            float: The inflow value for the specified timestep.
+
+        Raises:
+            IndexError: If the timestep is out of bounds.
+        """
+        return self.all_inflow[timestep]
+
+    def set_inflow(self, timestep: int, inflow: float) -> None:
+        """
+        Sets the inflow value for a specific timestep, adjusting if necessary.
+
+        Args:
+            timestep (int): The timestep index at which to set the inflow.
+            inflow (float): The inflow value to set.
+
+        Raises:
+            IndexError: If the timestep index is invalid.
+        """
+        if len(self.all_inflow) == timestep:
+            self.all_inflow.append(inflow)
+        elif len(self.all_inflow) > timestep:
+            self.all_inflow[timestep] += inflow
+        else:
+            raise IndexError
+
+    def determine_outflow(self) -> float:
+        """
+        Calculates the outflow based on the current inflow and consumption.
+
+        Returns:
+            float: The calculated outflow for the current timestep.
+        """
+        return self.get_inflow(self.timestep) - self.determine_consumption()
+
+    def get_outflow(self, timestep: int) -> float:
+        """
+        Retrieves the outflow value for a specific timestep.
+
+        Args:
+            timestep (int): The timestep index for which to retrieve the outflow.
+
+        Returns:
+            float: The outflow value for the specified timestep.
+
+        Raises:
+            IndexError: If the timestep is out of bounds.
+        """
+        return self.all_outflow[timestep]
+
+    def step(self) -> tuple[ObsType, float, bool, bool, dict]:
+        """
+        Advances the simulation by one timestep, calculating outflows and rewards.
+
+        Returns:
+            tuple[ObsType, float, bool, bool, dict]: A tuple containing:
+                - ObsType: Placeholder for observation type (to be defined).
+                - float: The reward for the current timestep.
+                - bool: Indicates if the simulation has terminated.
+                - bool: Indicates if the simulation has been truncated.
+                - dict: Additional information about the facility's state.
+        """
+        self.all_outflow.append(self.determine_outflow())
+        # TODO: Determine if we need to satisy any terminating codnitions for facility.
+        reward = self.determine_reward()
+        if self.normalize_objective>0.0:
+            reward = reward/self.normalize_objective
+        terminated = self.is_terminated()
+        truncated = self.is_truncated()
+        info = self.determine_info()
+
+        self.timestep += 1
+
+        return None, reward, terminated, truncated, info
+
+    def reset(self) -> None:
+        """
+        Resets the facility to its initial state for a new simulation run.
+
+        Returns:
+            None
+        """
+        self.timestep: int = 0
+        self.all_inflow: list[float] = []
+        self.all_outflow: list[float] = []
+
+    def determine_info(self) -> dict:
+        """
+        Method to gather information about the facility's state.
+
+        Returns:
+            dict: A dictionary containing information about the facility.
+
+        Raises:
+            NotImplementedError: If this method is not implemented in a subclass.
+        """
+        raise NotImplementedError()
+
+    def __eq__(self, other):
+        """
+        Checks equality between two Facility instances based on their names.
+
+        Args:
+            other (Facility): The other facility to compare against.
+
+        Returns:
+            bool: True if both facilities are of the same class and have the same name, False otherwise.
+        """
+        return isinstance(other, self.__class__) and self.name == other.name
+
+    def __hash__(self):
+        """
+        Returns a hash of the facility based on its name.
+
+        Returns:
+            int: The hash value of the facility.
+        """
+        return hash(self.name)
+
+
+class ControlledFacility(ABC):
+    def __init__(
+        self,
+        name: str,
+        observation_space: Space,
+        action_space: ActType,
+        max_capacity: float, 
+        max_action: float,
+
+        objective_function=Objective.no_objective,
+        objective_name: str = "",
+    ) -> None:
+        self.name: str = name
+        self.all_inflow: list[float] = []
+        self.all_outflow: list[float] = []
+        self.max_capacity: float = max_capacity
+        self.max_action: float = max_action
+
+
+        self.observation_space: Space = observation_space
+        #check if there is more than one outflow from a reservoir
+        if len(self.max_action)>1:
+            self.action_space: Space = Box(low=0, high=1, shape=(len(self.max_action),))
+        else:
+            self.action_space: Space = action_space
+
+        self.objective_function = objective_function
+        self.objective_name = objective_name
+
+
+        self.current_date: Optional[datetime] = None
+        self.timestep_size: Optional[relativedelta] = None
+        self.timestep: int = 0
+
+        self.should_split_release = np.prod(self.action_space.shape) > 1
+        self.split_release = None
+
+    @abstractmethod
+    def determine_reward(self) -> float:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def determine_outflow(action: ActType) -> float:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def determine_observation(self) -> ObsType:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def is_terminated(self) -> bool:
+        raise NotImplementedError()
+
+    def is_truncated(self) -> bool:
+        return False
+
+    def get_inflow(self, timestep: int) -> float:
+        return self.all_inflow[timestep]
+
+    def set_inflow(self, timestep: int, inflow: float) -> None:
+        if len(self.all_inflow) == timestep:
+            self.all_inflow.append(inflow)
+        elif len(self.all_inflow) > timestep:
+            self.all_inflow[timestep] += inflow
+        else:
+            raise IndexError
+
+    def get_outflow(self, timestep: int) -> float:
+        return self.all_outflow[timestep]
+
+    def step(self, action: ActType) -> tuple[ObsType, SupportsFloat, bool, bool, dict]:
+        self.all_outflow.append(self.determine_outflow(action))
+        # TODO: Change stored_water to multiple outflows.
+
+        observation = self.determine_observation()
+        reward = self.determine_reward()
+        terminated = self.is_terminated()
+        truncated = self.is_truncated()
+        info = self.determine_info()
+
+        self.timestep += 1
+
+        return (
+            observation,
+            reward,
+            terminated,
+            truncated,
+            info,
+        )
+
+    def reset(self) -> None:
+        self.timestep: int = 0
+        self.all_inflow: list[float] = []
+        self.all_outflow: list[float] = []
+
+    def determine_info(self) -> dict:
+        """
+        Returns information about the reservoir.
+        
+        """
+        raise {}
+
+    def __eq__(self, other):
+        return isinstance(other, self.__class__) and self.name == other.name
+
+    def __hash__(self):
+        return hash(self.name)

morl4water/core/models/flow.py

@@ -0,0 +1,138 @@
+from datetime import datetime
+from dateutil.relativedelta import relativedelta
+from typing import Union, Optional
+from morl4water.core.models.facility import Facility, ControlledFacility
+from gymnasium.core import ObsType
+
+
+class Flow:
+    def __init__(
+        self,
+        name: str,
+        sources: list[Union[Facility, ControlledFacility]],
+        destinations: Facility | ControlledFacility | dict[Facility | ControlledFacility, float],
+        max_capacity: float,
+        evaporation_rate: float = 0.0,
+        delay: int = 0,
+        default_outflow: Optional[float] = None,
+    ) -> None:
+        self.name: str = name
+        self.sources: list[Union[Facility, ControlledFacility]] = sources
+
+        if isinstance(destinations, Facility) or isinstance(destinations, ControlledFacility):
+            self.destinations = {destinations: 1.0}
+        else:
+            self.destinations: dict[Union[Facility, ControlledFacility], float] = destinations
+
+        self.max_capacity: float = max_capacity
+        self.evaporation_rate: float = evaporation_rate
+
+        self.delay: int = delay
+        self.default_outflow: Optional[float] = default_outflow
+
+        self.current_date: Optional[datetime] = None
+        self.timestep_size: Optional[relativedelta] = None
+        self.timestep: int = 0
+
+    def determine_source_outflow(self) -> float:
+        if self.timestep - self.delay < 0 and self.default_outflow:
+            return self.default_outflow
+        else:
+            timestep_after_delay_clipped = max(0, self.timestep - self.delay)
+
+            return sum(source.get_outflow(timestep_after_delay_clipped) for source in self.sources)
+
+    def determine_source_outflow_by_destination(self, destination_index: int, destination_inflow_ratio: float) -> float:
+        if self.timestep - self.delay < 0 and self.default_outflow:
+            return self.default_outflow
+        else:
+            timestep_after_delay_clipped = max(0, self.timestep - self.delay)
+            total_source_outflow = 0
+
+            # Calculate each source contribution to the destination
+            for source in self.sources:
+                source_outflow = source.get_outflow(timestep_after_delay_clipped)
+
+                # Determine if source has custom split policy
+                if source.split_release:
+                    total_source_outflow += source_outflow * source.split_release[destination_index]
+                else:
+                    total_source_outflow += source_outflow * destination_inflow_ratio
+
+            return total_source_outflow
+
+    def set_destination_inflow(self) -> None:
+        for destination_index, (destination, destination_inflow_ratio) in enumerate(self.destinations.items()):
+            destination_inflow = self.determine_source_outflow_by_destination(
+                destination_index, destination_inflow_ratio
+            )
+
+            destination.set_inflow(self.timestep, destination_inflow * (1.0 - self.evaporation_rate))
+
+    def is_truncated(self) -> bool:
+        return False
+
+    def determine_info(self) -> dict:
+        return {"name": self.name, "flow": self.determine_source_outflow()}
+
+    def step(self) -> tuple[Optional[ObsType], float, bool, bool, dict]:
+        self.set_destination_inflow()
+
+        terminated = self.determine_source_outflow() > self.max_capacity
+        truncated = self.is_truncated()
+        reward = float("-inf") if terminated else 0.0 
+        info = self.determine_info()
+
+        self.timestep += 1
+
+        return None, reward, terminated, truncated, info
+
+    def reset(self) -> None:
+        self.timestep = 0
+
+
+class Inflow(Flow):
+    def __init__(
+        self,
+        name: str,
+        destinations: Facility | ControlledFacility | dict[Facility | ControlledFacility, float],
+        max_capacity: float,
+        all_inflow: list[float],
+        evaporation_rate: float = 0.0,
+        delay: int = 0,
+        default_outflow: Optional[float] = None,
+    ) -> None:
+        super().__init__(name, None, destinations, max_capacity, evaporation_rate, delay, default_outflow)
+        self.all_inflow: list[float] = all_inflow
+
+    def determine_source_outflow(self) -> float:
+        if self.timestep - self.delay < 0 and self.default_outflow:
+            return self.default_outflow
+        else:
+            timestep_after_delay_clipped = max(0, self.timestep - self.delay) % len(self.all_inflow)
+
+            return self.all_inflow[timestep_after_delay_clipped]
+
+    def determine_source_outflow_by_destination(self, destination_index: int, destination_inflow_ratio: float) -> float:
+        if self.timestep - self.delay < 0 and self.default_outflow:
+            return self.default_outflow
+        else:
+            timestep_after_delay_clipped = max(0, self.timestep - self.delay) % len(self.all_inflow)
+
+            return self.all_inflow[timestep_after_delay_clipped] * destination_inflow_ratio
+
+    def is_truncated(self) -> bool:
+        return self.timestep >= len(self.all_inflow)
+
+
+class Outflow(Flow):
+    def __init__(
+        self,
+        name: str,
+        sources: list[Union[Facility, ControlledFacility]],
+        max_capacity: float,
+    ) -> None:
+        super().__init__(name, sources, None, max_capacity)
+
+    def set_destination_inflow(self) -> None:
+        pass

morl4water/core/models/irrigation_district.py

@@ -0,0 +1,130 @@
+from morl4water.core.models.facility import Facility
+
+
+class IrrigationDistrict(Facility):
+    """
+    Represents an irrigation district with specific water demand, consumption, and deficit tracking.
+
+    Attributes
+    ----------
+    name : str
+        Identifier for the irrigation district.
+    all_demand : list[float]
+        Monthly water demand values for the irrigation district.
+    total_deficit : float
+        Cumulative water deficit experienced by the district over time.
+    all_deficit : list[float]
+        Monthly record of deficits, calculated as demand minus consumption.
+    normalize_objective : float
+        Normalization factor for the objective function reward. It should be the highest monthly value in a year. Default is 0.0
+
+    """
+    def __init__(self, name: str, all_demand: list[float], objective_function, objective_name: str, normalize_objective:float = 0.0) -> None:
+        """
+        Initializes an Irrigation District instance.
+
+        Parameters:
+            name : str
+                Identifier for the irrigation district.
+            all_demand : list[float]
+                Monthly water demand values for the irrigation district.
+            objective_function : callable
+                Function to evaluate the district’s performance.
+            objective_name : str
+                Name of the objective.
+            normalize_objective : float, optional
+                Maximum value for normalizing the objective, it should be the highest monthly demand in the whole year. By default 0.0.
+
+        """
+        super().__init__(name, objective_function, objective_name, normalize_objective)
+        self.all_demand: list[float] = all_demand
+        self.total_deficit: float = 0
+        self.all_deficit: list[float] = []
+
+    def get_current_demand(self) -> float:
+        """
+        Returns the demand value for the current timestep.
+
+        Returns
+        -------
+        float
+            Demand for the current timestep.
+        
+        """
+        return self.all_demand[self.timestep % len(self.all_demand)]
+
+    def determine_deficit(self) -> float:
+        """
+        Calculates the reward (irrigation deficit) given the values of its attributes
+
+        Returns
+        -------
+        float
+            Water deficit of the irrigation district
+        """
+        consumption = self.determine_consumption()
+        deficit = self.get_current_demand() - consumption
+        self.total_deficit += deficit
+        self.all_deficit.append(deficit)
+        return deficit
+
+    def determine_reward(self) -> float:
+        """
+        Calculates the reward for the irrigation district based on the objective function.
+
+        Returns
+        -------
+        float
+            Reward as calculated by the objective function.
+        """
+        return self.objective_function(self.get_current_demand(), float(self.get_inflow(self.timestep)))
+
+    def determine_consumption(self) -> float:
+        """
+        Calculates the water consumption for the irrigation district based on current demand and inflow.
+
+        Returns
+        -------
+        float
+            Water consumption for the current timestep.
+        """
+        return min(self.get_current_demand(), self.get_inflow(self.timestep))
+
+    def is_truncated(self) -> bool:
+        """
+        Checks if the simulation has reached the end of the demand data.
+
+        Returns:
+            bool: 
+                True if the simulation has no more demand data to process, False otherwise.
+        """
+        return self.timestep >= len(self.all_demand)
+
+    def determine_info(self) -> dict:
+        """
+        Returns information about the irrigation district.
+
+        Returns:
+            dict: 
+                A dictionary containing key metrics for the district.
+        """
+        return {
+            "name": self.name,
+            "inflow": self.get_inflow(self.timestep),
+            "outflow": self.get_outflow(self.timestep),
+            "demand": self.get_current_demand(),
+            "total_deficit": self.total_deficit,
+            "list_deficits": self.all_deficit,
+        }
+
+    def reset(self) -> None:
+        """
+        Resets the irrigation district's deficit attributes and inherited attributes.
+
+        Returns:
+            None
+
+        """        
+        super().reset()
+        self.total_deficit = 0
+        self.all_deficit = []

morl4water/core/models/objective.py

@@ -0,0 +1,37 @@
+class Objective:
+
+    @staticmethod
+    def no_objective(*args):
+        return 0.0
+
+    @staticmethod
+    def identity(value: float) -> float:
+        return value
+
+    @staticmethod
+    def is_greater_than_minimum(minimum_value: float) -> float:
+        return lambda value: 1.0 if value >= minimum_value else 0.0
+
+    @staticmethod
+    def is_greater_than_minimum_with_condition(minimum_value: float) -> float:
+        return lambda condition, value: 1.0 if condition and value >= minimum_value else 0.0
+
+    @staticmethod
+    def deficit_minimised(demand: float, received: float) -> float:
+        return -max(0.0, demand - received)
+
+    @staticmethod
+    def deficit_squared_ratio_minimised(demand: float, received: float) -> float:
+        return -((max(0.0, demand - received) / demand) ** 2)
+
+    @staticmethod
+    def supply_ratio_maximised(demand: float, received: float) -> float:
+        return received / demand if received / demand < 1.0 else 1.0
+
+    @staticmethod
+    def scalar_identity(scalar: float) -> float:
+        return lambda value: value * scalar
+
+    @staticmethod
+    def sequential_scalar(scalar: list[float]) -> float:
+        return lambda index, value: value * scalar[index]

morl4water/core/models/power_plant.py

@@ -0,0 +1,217 @@
+from morl4water.core.models.facility import Facility
+from morl4water.core.models.reservoir import Reservoir
+from morl4water.core.utils import utils
+from scipy.constants import g
+import numpy as np
+
+
+class PowerPlant(Facility):
+    """
+    Class to represent Hydro-energy Powerplant
+
+    Attributes:
+    -----------
+    name : str
+        identifier
+    efficiency : float
+        Efficiency coefficient (mu) used in hydropower formula
+    max_turbine_flow : float
+        Maximum possible flow that can be passed through the turbines for the
+        purpose of hydroenergy production
+    head_start_level : float
+        Minimum elevation of water level that is used to calculate hydraulic
+        head for hydropower production
+    max_capacity : float
+        Total design capacity (mW) of the plant
+    water_level_coeff : float
+        Coefficient that determines the water level based on the volume of outflow
+        Used to calculate at what level the head of the power plant operates
+    water_usage : float
+        Amount of water  that is used by plant, decimal coefficient
+
+    Methods:
+    ----------
+    determine_reward():
+        Calculates the reward (power generation) given the values of its attributes
+    determine_consumption():
+        Determines how much water is consumed by the power plant
+    determine_info():
+        Returns info about the hydro-energy powerplant
+    """
+
+    def __init__(
+        self,
+        name: str,
+        objective_function,
+        objective_name: str,
+        efficiency: float,
+        min_turbine_flow: float = 0.0,
+        normalize_objective: float = 0.0,
+        max_turbine_flow: float = 0.0,
+        head_start_level: float = 0.0,
+        max_capacity: float = 0.0,
+        reservoir: Reservoir = None,
+        water_usage: float = 0.0,
+        tailwater: np.array = None,
+        turbines: np.array = None,
+        n_turbines: int = 0,
+        energy_prices: np.array = None
+    ) -> None:
+        super().__init__(name, objective_function, objective_name, normalize_objective)
+        self.efficiency: float = efficiency
+        self.max_turbine_flow: float = max_turbine_flow
+        self.head_start_level: float = head_start_level
+        self.min_turbine_flow: float = min_turbine_flow
+        self.max_capacity: float = max_capacity
+        self.reservoir: Reservoir = reservoir
+        self.water_usage: float = water_usage
+        self.production_vector: np.ndarray = np.empty(0, dtype=np.float64)
+        self.tailwater = tailwater
+        self.turbines = turbines
+        self.n_turbines = n_turbines
+        self.energy_prices = energy_prices
+
+    def determine_turbine_flow(self) -> float:
+        return max(self.min_turbine_flow, min(self.max_turbine_flow, self.get_inflow(self.timestep)))
+
+    # Constants are configured as parameters with default values
+    def determine_production(self) -> float:
+        """
+        Calculates power production in MWh , when tailwater and turbine data is not available
+
+        Returns:
+        ----------
+        float
+            Plant's power production in MWh
+        """
+        m3_to_kg_factor: int = 1000
+        w_Mw_conversion: float = 1e-6
+        # Turbine flow is equal to outflow, as long as it does not exceed maximum turbine flow
+        turbine_flow = self.determine_turbine_flow()
+
+        # Uses water level from reservoir to determine water level
+        water_level = self.reservoir.level_vector[-1] if self.reservoir.level_vector else 0
+        # Calculate at what level the head will generate power, using water_level of the outflow and head_start_level
+        head = max(0.0, water_level - self.head_start_level)
+
+        # Calculate power in mW, has to be lower than or equal to capacity
+        power_in_mw = min(
+            self.max_capacity,
+            turbine_flow * head * m3_to_kg_factor * g * self.efficiency * w_Mw_conversion,
+        )
+
+        # Calculate the numbe rof hours the power plant has been running.
+        final_date = self.current_date + self.timestep_size
+        timestep_hours = (final_date - self.current_date).total_seconds() / 3600
+
+        # Hydro-energy power production in mWh
+        production = power_in_mw * timestep_hours
+        self.production_vector = np.append(self.production_vector, production)
+
+        return production
+    
+
+
+
+    def determine_production_detailed(self) -> float:
+        """Calculates power production when tailwater information and information regarding turbines is known.
+        Assumes metric system"""
+
+        cubicFeetToCubicMeters = 0.0283  # 1 cf = 0.0283 m3
+        feetToMeters = 0.3048  # 1 ft = 0.3048 m
+        m3_to_kg_factor = 1000
+        p = 0.0
+        water_level = self.reservoir.level_vector[-1] if self.reservoir.level_vector else 0
+        turbine_flow = self.determine_turbine_flow()
+
+        deltaH = water_level - utils.interpolate_tailwater_level(
+            self.tailwater[0], self.tailwater[1], turbine_flow
+        )
+
+        q_split = turbine_flow
+
+        for j in range(0, self.n_turbines):
+            if q_split < self.turbines[1][j]:
+                qturb = 0.0
+            elif q_split > self.turbines[0][j]:
+                qturb = self.turbines[0][j]
+            else:
+                qturb = q_split
+            q_split = q_split - qturb
+            p = p + (
+                self.efficiency
+                * g
+                * m3_to_kg_factor
+                * (cubicFeetToCubicMeters * qturb)
+                * (feetToMeters * deltaH)
+                * 3600
+                / (3600 * 1000)
+            )  
+
+
+        # Calculate the numbe rof hours the power plant has been running.
+        final_date = self.current_date + self.timestep_size
+        timestep_hours = (final_date - self.current_date).total_seconds() / 3600
+
+        production = p * timestep_hours
+        self.production_vector = np.append(self.production_vector, production)
+
+        return production
+
+
+
+    def determine_reward(self) -> float:
+        """
+        Determines reward for the power plant using the power production.
+
+        Parameters:
+        -----------
+        objective_function : (float) -> float
+            Function calculating the objective given the power production.
+
+        Returns:
+        ----------
+        float
+            Reward.
+        """
+
+        if self.turbines is not None and self.tailwater is not None:
+            return self.objective_function(self.determine_production_detailed())
+        else:
+            return self.objective_function(self.determine_production())
+
+    def determine_consumption(self) -> float:
+        """
+        Determines water consumption.
+
+        Returns:
+        ----------
+        float
+            How much water is consumed
+        """
+        return self.determine_turbine_flow() * self.water_usage
+
+    def determine_info(self) -> dict:
+        """
+        Determines info of hydro-energy power plant
+
+        Returns:
+        ----------
+        dict
+            Info about power plant (name, inflow, outflow, water usage, timestep, total production)
+        """
+        return {
+            "name": self.name,
+            "inflow": self.get_inflow(self.timestep),
+            "outflow": self.get_outflow(self.timestep),
+            "monthly_production": self.production_vector[-1],
+            "water_usage": self.water_usage,
+            "total production (MWh)": sum(self.production_vector),
+        }
+
+    def determine_month(self) -> int:
+        return self.timestep % 12
+
+    def reset(self) -> None:
+        super().reset()
+        self.production_vector = np.empty(0, dtype=np.float64)

morl4water/core/models/reservoir.py

@@ -0,0 +1,233 @@
+from morl4water.core.models.facility import ControlledFacility
+from gymnasium.spaces import Box, Space
+import numpy as np
+from dateutil.relativedelta import relativedelta
+from datetime import datetime
+from numpy.core.multiarray import interp as compiled_interp
+
+
+class Reservoir(ControlledFacility):
+    """
+    A class used to represent reservoirs of the problem
+
+    Attributes
+    ----------
+    name: str
+        Lowercase non-spaced name of the reservoir
+    storage_vector: np.array (1xH)
+        m3
+        A vector that holds the volume of the water in the reservoir
+        throughout the simulation horizon
+    level_vector: np.array (1xH)
+        m
+        A vector that holds the elevation of the water in the reservoir
+        throughout the simulation horizon
+    release_vector: np.array (1xH)
+        m3/s
+        A vector that holds the actual average release per month
+        from the reservoir throughout the simulation horizon
+    evap_rates: np.array (1x12)
+        cm
+        Monthly evaporation rates of the reservoir
+
+    Methods
+    -------
+    determine_info()
+        Return dictionary with parameters of the reservoir.
+    storage_to_level(h=float)
+        Returns the level(height) based on volume.
+    level_to_storage(s=float)
+        Returns the volume based on level(height).
+    level_to_surface(h=float)
+        Returns the surface area based on level.
+    determine_outflow(action: float)
+        Returns average monthly water release.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        max_capacity: float,
+        max_action: list[float],
+        objective_function,
+        integration_timestep_size: relativedelta,
+        evap_rates: list[float],
+        evap_rates_timestep_size: relativedelta,
+        storage_to_minmax_rel: list[list[float]],
+        storage_to_level_rel: list[list[float]],
+        storage_to_surface_rel: list[list[float]],
+        objective_name: str = "",
+        stored_water: float = 0,
+        spillage: float = 0,
+        observation_space = Box(low=0, high=1),
+        action_space = Box(low=0, high=1),
+
+                ) -> None:
+        super().__init__(name, observation_space, action_space, max_capacity, max_action)
+        self.stored_water: float = stored_water
+
+        self.evap_rates = evap_rates
+        self.evap_rates_timestep = evap_rates_timestep_size
+        self.storage_to_minmax_rel = storage_to_minmax_rel
+        self.storage_to_level_rel = storage_to_level_rel
+        self.storage_to_surface_rel = storage_to_surface_rel
+        
+        self.storage_vector = []
+        self.level_vector = []
+        self.release_vector = []
+
+        # Initialise storage vector
+        self.storage_vector.append(stored_water)
+
+        self.objective_function = objective_function
+        self.objective_name = objective_name
+
+        self.integration_timestep_size: relativedelta = integration_timestep_size
+        self.spillage = spillage
+        # self.water_level = self.storage_to_level(self.stored_water)
+
+    def determine_reward(self) -> float:
+        # Pass water level to reward function
+        return self.objective_function(self.storage_to_level(self.stored_water))
+
+    def determine_outflow(self, actions: np.array) -> list[float]:
+
+        current_storage = self.storage_vector[-1]
+        #check if we are releasing to one destination or more
+        if self.should_split_release == True:
+            #if it's more destinations, we have to create a list for sub-releases during the integration loop
+            sub_releases = []
+            actions = np.multiply(actions, self.max_action)
+        else:
+            sub_releases = np.empty(0, dtype=np.float64)
+            actions = actions*self.max_action
+
+        final_date = self.current_date + self.timestep_size
+        timestep_seconds = (final_date + self.evap_rates_timestep - final_date).total_seconds()
+        evaporatio_rate_per_second = self.evap_rates[self.determine_time_idx()] / (100 * timestep_seconds)
+
+        while self.current_date < final_date:
+            next_date = min(final_date, self.current_date + self.integration_timestep_size)
+            integration_time_seconds = (next_date - self.current_date).total_seconds()
+
+            #calculate the surface to get the evaporation
+            surface = self.storage_to_surface(current_storage)
+            #evaporation per integration timestep
+            evaporation = surface * (evaporatio_rate_per_second * integration_time_seconds)
+            #get min and max possible release based on the current storage
+            min_possible_release, max_possible_release = self.storage_to_minmax(current_storage)
+            #release per second is calculated based on the min-max releases which depend on the storage level and the predicted actions
+            release_per_second = min(max_possible_release, max(min_possible_release, np.sum(actions)))
+
+            sub_releases = np.append(sub_releases, release_per_second)
+
+            total_addition = self.get_inflow(self.timestep) * integration_time_seconds
+
+            current_storage += total_addition - evaporation - (np.sum(release_per_second) - self.spillage) * integration_time_seconds
+            
+            self.current_date = next_date
+
+        # Update the amount of water in the Reservoir
+        self.storage_vector.append(current_storage)
+        self.stored_water = current_storage
+
+        # Record level based on storage for time t
+        self.level_vector.append(self.storage_to_level(current_storage))
+
+        # Calculate the ouflow of water
+        if self.should_split_release == True:
+            sub_releases = np.array(sub_releases)
+            average_release = np.mean(sub_releases, dtype=np.float64, axis = 0)
+        else:
+            average_release = np.mean(sub_releases, dtype=np.float64)
+
+        self.release_vector.append(average_release)
+
+        total_action = np.sum(average_release)
+
+        # Split release for different destinations
+        if self.should_split_release and total_action != 0:
+            self.split_release = [(action / total_action) for action in average_release]
+            average_release = total_action
+
+        return average_release
+
+    def determine_info(self) -> dict:
+        info = {
+            "name": self.name,
+            "stored_water": self.stored_water,
+            "current_level": self.level_vector[-1] if self.level_vector else None,
+            "current_release": self.release_vector[-1] if self.release_vector else None,
+            "evaporation_rates": self.evap_rates.tolist(),
+        }
+        return info
+
+    def determine_observation(self) -> float:
+        if self.stored_water > 0:
+            return self.stored_water
+        else:
+            return 0.0
+
+    def is_terminated(self) -> bool:
+        return self.stored_water > self.max_capacity or self.stored_water < 0
+    
+
+
+    def determine_time_idx(self) -> int:
+        if self.evap_rates_timestep.months > 0:
+            return self.current_date.month - 1
+        elif self.evap_rates_timestep.days > 0:
+            return self.current_date.timetuple().tm_yday - 1
+        elif self.evap_rates_timestep.hours > 0:
+            return (self.current_date.timetuple().tm_yday - 1) * 24 + self.current_date.hour - 1
+        else:
+            raise ValueError('The timestep is not supported, only time series with intervals of months, days, hours are supported')
+
+
+    def storage_to_level(self, s: float) -> float:
+        return self.modified_interp(s, self.storage_to_level_rel[0], self.storage_to_level_rel[1])
+
+    def storage_to_surface(self, s: float) -> float:
+        return self.modified_interp(s, self.storage_to_surface_rel[0], self.storage_to_surface_rel[1])
+
+    def level_to_minmax(self, h) -> tuple[np.ndarray, np.ndarray]:
+        return (
+            np.interp(h, self.rating_curve[0], self.rating_curve[1]),
+            np.interp(h, self.rating_curve[0], self.rating_curve[2]),
+        )
+
+    def storage_to_minmax(self, s) -> tuple[np.ndarray, np.ndarray]:
+        return (
+            np.interp(s, self.storage_to_minmax_rel[0], self.storage_to_minmax_rel[1]),
+            np.interp(s, self.storage_to_minmax_rel[0], self.storage_to_minmax_rel[2]),
+        )
+
+    @staticmethod
+    def modified_interp(x: float, xp: float, fp: float, left=None, right=None) -> float:
+        fp = np.asarray(fp)
+
+        return compiled_interp(x, xp, fp, left, right)
+
+    # def modified_interp(x: float, xp: float, fp: float, left=None, right=None) -> float:
+    #     fp = np.asarray(fp)
+    #     dim = len(xp) - 1
+    #     if x <= xp[0]:
+    #     # if x is smaller than the smallest value on X, interpolate between the first two values
+    #         y = (x - xp[0]) * (fp[1] - fp[0]) / (xp[1] - xp[0]) + fp[0]
+    #         return y
+    #     elif x >= xp[dim]:
+    #     # if x is larger than the largest value, interpolate between the the last two values
+    #         y = fp[dim] + (fp[dim] - fp[dim - 1]) / (xp[dim] - xp[dim - 1]) * (
+    #         x - xp[dim])  # y = Y[dim]
+    #         return y
+    #     else:
+    #         return compiled_interp(x, xp, fp, left, right)
+
+
+    def reset(self) -> None:
+        super().reset()
+        stored_water = self.storage_vector[0]
+        self.storage_vector = [stored_water]
+        self.stored_water = stored_water
+        self.level_vector = []
+        self.release_vector = []

morl4water/core/models/reservoir_with_pump.py

@@ -0,0 +1,288 @@
+from morl4water.core.models.facility import ControlledFacility
+from gymnasium.spaces import Box, Space
+import numpy as np
+from dateutil.relativedelta import relativedelta
+from datetime import datetime
+from numpy.core.multiarray import interp as compiled_interp
+from typing import Callable
+import inspect
+from morl4water.core.utils import utils
+
+class ReservoirWithPump(ControlledFacility):
+    """
+    A class used to represent reservoirs with a pump of the problem.
+    The pump can pump the water in and out of the reservoir as well as store the water
+
+    Attributes
+    ----------
+    name_reservoir: str
+        Lowercase non-spaced name of the reservoir
+    name_pump: str
+        Lowercase non-spaced name of the pumping station
+    storage_vector: np.array (1xH)
+        m3
+        A vector that holds the volume of the water in the reservoir
+        throughout the simulation horizon
+    level_vector: np.array (1xH)
+        m
+        A vector that holds the elevation of the water in the reservoir
+        throughout the simulation horizon
+    release_vector: np.array (1xH)
+        m3/s
+        A vector that holds the actual average release per month
+        from the reservoir throughout the simulation horizon
+    evap_rates: np.array (1x12)
+        cm
+        Monthly evaporation rates of the reservoir
+
+    Methods
+    -------
+    determine_info()
+        Return dictionary with parameters of the reservoir.
+    storage_to_level(h=float)
+        Returns the level(height) based on volume.
+    level_to_storage(s=float)
+        Returns the volume based on level(height).
+    level_to_surface(h=float)
+        Returns the surface area based on level.
+    determine_outflow(action: float)
+        Returns average monthly water release.
+    """
+    def __init__(
+        self,
+        name: str,
+        max_capacity: float,
+        max_action: float,
+        objective_function,
+        integration_timestep_size: relativedelta,
+        evap_rates: list[float],
+        evap_rates_pump: list[float],
+        evap_rates_timestep_size: relativedelta,
+        storage_to_minmax_rel: list[list[float]],
+        storage_to_level_rel: list[list[float]],
+        storage_to_surface_rel: list[list[float]],
+        storage_to_surface_rel_pump: list[list[float]],
+        storage_to_level_rel_pump: list[list[float]],
+        pumping_rules: Callable,
+        inflows_pump: list[float] = None,
+        objective_name: str = "",
+        stored_water_reservoir: float = 0,
+        stored_water_pump: float = 0,
+        observation_space = Box(low=0, high=1),
+        action_space = Box(low=0, high=1),
+        spillage: float = 0
+                ) -> None:
+        super().__init__(name, observation_space, action_space, max_capacity, max_action)
+        self.stored_water: float = stored_water_reservoir
+        self.stored_pump: float = stored_water_pump
+
+        self.evap_rates = evap_rates
+        self.evap_rates_pump = evap_rates_pump
+        self.evap_rates_timestep = evap_rates_timestep_size
+        self.storage_to_minmax_rel = storage_to_minmax_rel
+        self.storage_to_level_rel = storage_to_level_rel
+        self.storage_to_surface_rel = storage_to_surface_rel
+        self.storage_to_surface_rel_pump = storage_to_surface_rel_pump
+        self.storage_to_level_rel_pump = storage_to_level_rel_pump
+        self.spillage = spillage
+        self.required_params = ['day_of_the_week', 'hour', 'level_reservoir', 'level_pump', 'storage_reservoir', 'storage_pump']
+
+        self.inflows_pump = inflows_pump
+        
+        self.storage_vector = []
+        self.storage_pump_vector = []
+        self.level_vector = []
+        self.release_vector = []
+
+        # Initialise storage vector
+        self.storage_vector.append(stored_water_reservoir)
+        self.storage_pump_vector.append(stored_water_pump)
+
+        self.objective_function = objective_function
+        self.objective_name = objective_name
+
+        self.integration_timestep_size: relativedelta = integration_timestep_size
+        
+
+        if not callable(pumping_rules):
+            raise ValueError("The pumping rules should be defined as a function, which takes as argument storage_level of the reservoir and the pump.")
+        
+        # Get the signature of the method
+        sig = inspect.signature(pumping_rules)
+
+        # Check if the method has the required parameters
+        for param in self.required_params:
+            if param not in sig.parameters:
+                raise ValueError(f"The method must have a parameter named '{param}'.")
+
+        # Assign the provided method to the instance
+        self.pumping_rules = pumping_rules
+
+
+    def determine_reward(self) -> float:
+        # Pass water level to reward function
+        return self.objective_function(self.storage_to_level(self.stored_water))
+
+    def determine_outflow(self, actions: np.array) -> list[float]:
+        #determine current storage for the reservoir
+        current_storage = self.storage_vector[-1]
+        #determine current storage for the pump
+        current_storage_pump = self.storage_pump_vector[-1]
+        #check if we are releasing to one destination or more
+        if self.should_split_release == True:
+            #if it's more destinations, we have to create a list for sub-releases during the integration loop
+            sub_releases = []
+            actions = np.multiply(actions, self.max_action)
+        else:
+            sub_releases = np.empty(0, dtype=np.float64)
+            actions = actions*self.max_action
+
+            
+        final_date = self.current_date + self.timestep_size
+        timestep_seconds = (final_date + self.evap_rates_timestep - final_date).total_seconds()
+        evaporatio_rate_per_second = self.evap_rates[self.determine_time_idx()] / (100 * timestep_seconds)
+        evaporatio_rate_per_second_pump = self.evap_rates_pump[self.determine_time_idx()] / (100 * timestep_seconds)
+        
+        while self.current_date < final_date:
+            next_date = min(final_date, self.current_date + self.integration_timestep_size)
+            integration_time_seconds = (next_date - self.current_date).total_seconds()
+            
+            #pumping/release of the pump
+
+            pumping, release_pump = self.pumping_rules(day = self.current_date.weekday(), 
+                                                  hour = self.current_date.hour, 
+                                                  level_reservoir = self.storage_to_level(current_storage), 
+                                                  level_pump = self.storage_to_level_pump(self.stored_pump),
+                                                  storage_reservoir = current_storage, storage_pump = self.stored_pump)
+
+
+            surface = self.storage_to_surface(current_storage)
+            surface_pump = self.storage_to_surface_pump(current_storage_pump)
+
+            evaporation = surface * (evaporatio_rate_per_second * integration_time_seconds)
+            evaporation_pump = surface_pump * (evaporatio_rate_per_second_pump * integration_time_seconds)
+
+            current_storage_pump += (self.inflows_pump[self.timestep] + pumping - release_pump) * integration_time_seconds - evaporation_pump
+
+
+            min_possible_release, max_possible_release = self.storage_to_minmax(current_storage)
+
+            release_per_second = min(max_possible_release, max(min_possible_release, np.sum(actions)))
+
+            #depending if there are multiple outflows, append release decisions for every integration step
+            if self.should_split_release == True:
+                sub_releases.append(release_per_second)
+            else:
+                sub_releases = np.append(sub_releases, release_per_second)
+
+            total_addition = (self.get_inflow(self.timestep) + release_pump) * integration_time_seconds
+
+            current_storage += total_addition - evaporation - np.sum(release_per_second) * integration_time_seconds
+
+            self.current_date = next_date
+
+        # Update the amount of water in the Reservoir
+        self.storage_vector.append(current_storage)
+        self.stored_water = current_storage
+
+        # Update water in the pump
+        self.storage_pump_vector.append(current_storage_pump)
+        self.stored_pump = current_storage_pump
+
+        # Record level based on storage for time t
+        self.level_vector.append(self.storage_to_level(current_storage))
+
+        # Calculate the ouflow of water
+        if self.should_split_release == True:
+            sub_releases = np.array(sub_releases)
+            average_release = np.mean(sub_releases, dtype=np.float64, axis = 0)
+        else:
+            average_release = np.mean(sub_releases, dtype=np.float64)
+
+        self.release_vector.append(average_release)
+
+        total_action = np.sum(average_release)
+        # Split release for different destinations
+        if self.should_split_release and total_action != 0:
+            
+            self.split_release = [(action / total_action) for action in average_release]
+            average_release = total_action
+
+        return average_release
+
+    def determine_info(self) -> dict:
+        info = {
+            "name": self.name,
+            "stored_water": self.stored_water,
+            "current_level": self.level_vector[-1] if self.level_vector else None,
+            "current_release": self.release_vector[-1] if self.release_vector else None,
+            "evaporation_rates": self.evap_rates.tolist(),
+            "pump_level": self.stored_pump
+        }
+        return info
+
+    def determine_observation(self) -> float:
+        return self.stored_water
+
+    def is_terminated(self) -> bool:
+        return self.stored_water > self.max_capacity or self.stored_water < 0
+
+    def determine_time_idx(self) -> int:
+        if self.evap_rates_timestep.months > 0:
+            return self.current_date.month - 1
+        elif self.evap_rates_timestep.days > 0:
+            return self.current_date.timetuple().tm_yday - 1
+        elif self.evap_rates_timestep.hours > 0:
+            return (self.current_date.timetuple().tm_yday - 1) * 24 + self.current_date.hour - 1
+        else:
+            raise ValueError('The timestep is not supported, only time series with intervals of months, days, hours are supported')
+
+    def storage_to_level(self, s: float) -> float:
+        return self.modified_interp(s, self.storage_to_level_rel[0], self.storage_to_level_rel[1])
+    
+    def storage_to_level_pump(self, s: float) -> float:
+        return self.modified_interp(s, self.storage_to_level_rel_pump[0], self.storage_to_level_rel_pump[1])
+
+
+    def storage_to_surface(self, s: float) -> float:
+        return self.modified_interp(s, self.storage_to_surface_rel[0], self.storage_to_surface_rel[1])
+    
+    def storage_to_surface_pump(self, s: float) -> float:
+        return self.modified_interp(s, self.storage_to_surface_rel_pump[0], self.storage_to_surface_rel_pump[1])
+
+
+    def level_to_minmax(self, h) -> tuple[np.ndarray, np.ndarray]:
+        return (
+            np.interp(h, self.rating_curve[0], self.rating_curve[1]),
+            np.interp(h, self.rating_curve[0], self.rating_curve[2]),
+        )
+
+    def storage_to_minmax(self, s) -> tuple[np.ndarray, np.ndarray]:
+        return (
+            np.interp(s, self.storage_to_minmax_rel[0], self.storage_to_minmax_rel[1]),
+            np.interp(s, self.storage_to_minmax_rel[0], self.storage_to_minmax_rel[2]),
+        )
+
+    @staticmethod
+    def modified_interp(x: float, xp: float, fp: float, left=None, right=None) -> float:
+        fp = np.asarray(fp)
+        dim = len(xp) - 1
+        if x <= xp[0]:
+        # if x is smaller than the smallest value on X, interpolate between the first two values
+            y = (x - xp[0]) * (fp[1] - fp[0]) / (xp[1] - xp[0]) + fp[0]
+            return y
+        elif x >= xp[dim]:
+        # if x is larger than the largest value, interpolate between the the last two values
+            y = fp[dim] + (fp[dim] - fp[dim - 1]) / (xp[dim] - xp[dim - 1]) * (
+            x - xp[dim])  # y = Y[dim]
+            return y
+        else:
+            return compiled_interp(x, xp, fp, left, right)
+
+    def reset(self) -> None:
+        super().reset()
+        stored_water = self.storage_vector[0]
+        self.storage_vector = [stored_water]
+        self.stored_water = stored_water
+        self.level_vector = [self.storage_to_level(stored_water)]
+        self.release_vector = []

morl4water/core/models/weir.py

@@ -0,0 +1,142 @@
+from morl4water.core.models.facility import ControlledFacility
+from gymnasium.spaces import Box, Space
+import numpy as np
+from dateutil.relativedelta import relativedelta
+from datetime import datetime
+from numpy.core.multiarray import interp as compiled_interp
+
+
+class Weir(ControlledFacility):
+    """
+    A class used to represent reservoirs of the problem
+
+    Attributes
+    ----------
+    name: str
+        Lowercase non-spaced name of the reservoir
+    storage_vector: np.array (1xH)
+        m3
+        A vector that holds the volume of the water in the reservoir
+        throughout the simulation horizon
+    level_vector: np.array (1xH)
+        m
+        A vector that holds the elevation of the water in the reservoir
+        throughout the simulation horizon
+    release_vector: np.array (1xH)
+        m3/s
+        A vector that holds the actual average release per month
+        from the reservoir throughout the simulation horizon
+    evap_rates: np.array (1x12)
+        cm
+        Monthly evaporation rates of the reservoir
+
+    Methods
+    -------
+    determine_info()
+        Return dictionary with parameters of the reservoir.
+    storage_to_level(h=float)
+        Returns the level(height) based on volume.
+    level_to_storage(s=float)
+        Returns the volume based on level(height).
+    level_to_surface(h=float)
+        Returns the surface area based on level.
+    determine_outflow(action: float)
+        Returns average monthly water release.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        max_capacity: float,
+        max_action: list[float],
+        objective_function,
+        integration_timestep_size: relativedelta,
+        objective_name: str = "",
+        stored_water: float = 0,
+        spillage: float = 0,
+        observation_space = Box(low=0, high=1),
+        action_space = Box(low=0, high=1),
+
+                ) -> None:
+        super().__init__(name, observation_space, action_space, max_capacity, max_action)
+        self.stored_water: float = stored_water
+
+        self.should_split_release = True
+        
+        
+        self.storage_vector = []
+        self.level_vector = []
+        self.release_vector = []
+
+        # Initialise storage vector
+        self.storage_vector.append(stored_water)
+
+        self.objective_function = objective_function
+        self.objective_name = objective_name
+
+        self.integration_timestep_size: relativedelta = integration_timestep_size
+        self.spillage = spillage
+
+
+    def determine_reward(self) -> float:
+        #Pass average inflow (which is stored_water ) to reward function
+        return self.objective_function(self.stored_water)
+
+    def determine_outflow(self, actions: np.array) -> list[float]:
+
+        destination_1_release = np.empty(0, dtype=np.float64)
+        weir_observation_lst = []
+
+        final_date = self.current_date + self.timestep_size
+
+        while self.current_date < final_date:
+            next_date = min(final_date, self.current_date + self.integration_timestep_size)
+
+            #See what is the current inflow to weir and scale up the action to the first destination ( the action is a percentage of water going to destination 1)
+            weir_observation = self.get_inflow(self.timestep)
+            max_action = weir_observation 
+            actions_scaled_up = actions*max_action
+
+            destination_1_release = np.append(destination_1_release, actions_scaled_up)
+
+            weir_observation_lst = np.append(weir_observation_lst, weir_observation)
+            
+            self.current_date = next_date
+
+        #Averaging inflow to weir over last step (usually month) as a potential observation space to be used
+        average_release = np.mean(weir_observation_lst, dtype=np.float64)
+        self.storage_vector.append(average_release) #TODO does it make sense to keep it?
+        self.stored_water = average_release # TODO used in determine_observation
+      
+        #potential storage (observation space understood as total inflow) is same as the total release
+        self.release_vector.append(average_release)
+
+        # Split release for different destinations, action is expected to be in range [0,1]
+        self.split_release = [actions, (1-actions)]
+        
+
+        return average_release
+
+    def determine_info(self) -> dict:
+        info = {
+            "name": self.name,
+            "average_release": self.stored_water,
+        }
+        return info
+
+    def determine_observation(self) -> float:
+        if self.stored_water > 0:
+            return self.stored_water
+        else:
+            return 0.0
+
+    def is_terminated(self) -> bool:
+        return self.stored_water > self.max_capacity or self.stored_water < 0
+    
+    def reset(self) -> None:
+        super().reset()
+        stored_water = self.storage_vector[0]
+        self.storage_vector = [stored_water]
+        self.stored_water = stored_water
+        self.level_vector = []
+        self.release_vector = []

morl4water/core/utils/__init__.py

@@ -0,0 +1,26 @@
+# morl4water/core/utils/__init__.py
+from .utils import (
+    generate_random_actions,
+    convert_str_to_float_list,
+    gallonToCubicFeet,
+    inchesToFeet,
+    cubicFeetToCubicMeters,
+    feetToMeters,
+    acreToSquaredFeet,
+    acreFeetToCubicFeet,
+    cubicFeetToAcreFeet,
+    interpolate_tailwater_level,
+)
+
+__all__ = [
+    "generate_random_actions",
+    "convert_str_to_float_list",
+    "gallonToCubicFeet",
+    "inchesToFeet",
+    "cubicFeetToCubicMeters",
+    "feetToMeters",
+    "acreToSquaredFeet",
+    "acreFeetToCubicFeet",
+    "cubicFeetToAcreFeet",
+    "interpolate_tailwater_level",
+]

morl4water/core/utils/utils.py

@@ -0,0 +1,71 @@
+import numpy as np
+from numba import njit
+
+LIST_SPECIFIC_CHARACTERS = "[],"
+
+
+def generate_random_actions(number_of_actions=4, seed=42) -> np.ndarray:
+    np.random.seed(seed)
+    return np.random.rand(4) * [10000, 10000, 10000, 4000]
+
+
+def convert_str_to_float_list(string_list: str) -> list:
+    return list(map(float, string_list.translate(str.maketrans("", "", LIST_SPECIFIC_CHARACTERS)).split()))
+
+@njit
+def gallonToCubicFeet(x):
+    conv = 0.13368  # 1 gallon = 0.13368 cf
+    return x * conv
+
+
+@njit
+def inchesToFeet(x):
+    conv = 0.08333  # 1 inch = 0.08333 ft
+    return x * conv
+
+
+@njit
+def cubicFeetToCubicMeters(x):
+    conv = 0.0283  # 1 cf = 0.0283 m3
+    return x * conv
+
+
+@njit
+def feetToMeters(x):
+    conv = 0.3048  # 1 ft = 0.3048 m
+    return x * conv
+
+
+@njit
+def acreToSquaredFeet(x):
+    conv = 43560  # 1 acre = 43560 feet2
+    return x * conv
+
+
+@njit
+def acreFeetToCubicFeet(x):
+    conv = 43560  # 1 acre-feet = 43560 feet3
+    return x * conv
+
+
+@njit
+def cubicFeetToAcreFeet(x):
+    conv = 43560  # 1 acre = 43560 feet2
+    return x / conv
+
+
+@njit
+def interpolate_tailwater_level(X, Y, x):
+    dim = len(X) - 1
+    if x <= X[0]:
+        y = (x - X[0]) * (Y[1] - Y[0]) / (X[1] - X[0]) + Y[0]
+        return y
+    elif x >= X[dim]:
+        y = Y[dim] + (Y[dim] - Y[dim - 1]) / (X[dim] - X[dim - 1]) * (
+            x - X[dim]
+        )
+        return y
+    else:
+        y = np.interp(x, X, Y)
+    return y
+

morl4water/core/wrappers/transform_action.py

@@ -0,0 +1,34 @@
+import numpy as np
+import gymnasium as gym
+from gymnasium.spaces.dict import Dict
+from morl4water.core.envs.water_management_system import WaterManagementSystem
+from morl4water.core.models.facility import ControlledFacility
+
+
+class ReshapeArrayAction(gym.ActionWrapper, gym.utils.RecordConstructorArgs):
+    def __init__(self, env: WaterManagementSystem):
+        # assert isinstance(env.action_space, Dict)
+
+        self.ordered_shapes = {}
+        self.slices = {}
+        current_index = 0
+
+        for water_system in env.water_systems:
+            if isinstance(water_system, ControlledFacility):
+                number_of_actions = np.prod(water_system.action_space.shape)
+
+                self.slices[water_system.name] = slice(current_index, current_index + number_of_actions)
+                self.ordered_shapes[water_system.name] = water_system.action_space.shape
+
+                current_index += number_of_actions
+
+        gym.utils.RecordConstructorArgs.__init__(self)
+        gym.ActionWrapper.__init__(self, env)
+
+    def action(self, action):
+        reshaped_actions = {}
+
+        for name, sub_action_space_shape in self.ordered_shapes.items():
+            reshaped_actions[name] = np.reshape(action[self.slices[name]], sub_action_space_shape)
+
+        return reshaped_actions

morl4water/examples/__init__.py

@@ -0,0 +1,23 @@
+from .nile_river_simulation import create_nile_river_env
+from .omo_river_simulation import create_omo_river_env
+from .susquehanna_river_simulation import create_susquehanna_river_env
+from gymnasium.envs.registration import register
+
+__all__=['create_nile_river_env', 'create_omo_river_env', 'create_susquehanna_river_env']
+
+
+register(
+    id='nile-v0',
+    entry_point='morl4water.examples.nile_river_simulation:create_nile_river_env',
+)
+
+register(
+    id='omo-v0',
+    entry_point='morl4water.examples.omo_river_simulation:create_omo_river_env',
+)
+
+
+register(
+    id='susquehanna-v0',
+    entry_point='morl4water.examples.susquehanna_river_simulation:create_susquehanna_river_env',
+)

morl4water/examples/data/nile_river/catchments/InflowAtbara.txt

@@ -0,0 +1,240 @@
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902
+7.712786885245902
+3.004426229508197
+0.4216393442622951
+1.4672131147540983
+2.970983606557377
+28.256393442622947
+592.7859154929578
+1979.0281690140846
+1301.619718309859
+304.04647887323944
+63.12239436619718
+28.43633802816902

morl4water/examples/data/nile_river/catchments/InflowBlueNile.txt

@@ -0,0 +1,240 @@
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195
+111
+72
+56
+55
+86
+254
+1006
+2160
+1698
+932
+377
+195

morl4water/examples/data/nile_river/catchments/InflowDinder.txt

@@ -0,0 +1,240 @@
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+80.00040000000001
+773.0
+402.006
+154.001
+1.202e-11
+17.999699999999997
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+437.0
+1533.01
+1089.999
+79.0
+38.0004
+61.0002
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+437.995
+991.998
+423.99600000000004
+38.0004
+11.000029999999999
+1.202e-11
+7.0000100000000005
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+125.00450000000001
+1090.994
+918.003
+40.999599999999994
+17.0004
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+210.996
+930.0
+1134.998
+333.99699999999996
+40.999599999999994
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+98.00019999999999
+112.0002
+921.999
+377.005
+56.0001
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+70.00009999999999
+1342.0349999999999
+1090.994
+304.006
+7.0000100000000005
+17.999699999999997
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+36.9999
+313.00300000000004
+398.99499999999995
+36.000600000000006
+38.9998
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+372.998
+857.997
+677.004
+85.9999
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+366.99999999999994
+607.004
+876.9989999999999
+209.005
+8.99997
+1.202e-11
+1.9999600000000002
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+300.994
+1143.998
+1168.0
+568.002
+35.000099999999996
+21.0
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+2.99999
+19.0002
+475.005
+1491.99
+1264.9829999999997
+857.997
+101.99980000000001
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.0
+1.202e-11
+372.998
+1061.998
+1227.043
+541.995
+117.9995
+35.000099999999996
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+142.0033
+910.998
+1000.995
+31.999699999999997
+1.202e-11
+17.999699999999997
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+22.000600000000002
+422.004
+952.9979999999999
+1153.9969999999998
+377.005
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+739.9979999999999
+865.998
+863.994
+310.004
+21.0
+17.999699999999997
+14.00004
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+369.99899999999997
+702.005
+622.0
+361.997
+5.00006
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+229.99800000000002
+867.006
+636.996
+249.99699999999999
+31.999699999999997
+1.202e-11
+1.202e-11
+2.99999
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+355.00300000000004
+966.001
+1070.0
+377.005
+35.000099999999996
+19.0002
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+1.202e-11
+504.00100000000003
+1262.0189999999998
+921.999
+515.9979999999999
+19.0002
+17.999699999999997

morl4water/examples/data/nile_river/catchments/InflowGERDToRoseires.txt

@@ -0,0 +1,240 @@
+24.510399999999997
+10.14448
+8.71016
+7.554919999999999
+14.221300000000001
+58.735200000000006
+193.126
+417.32899999999995
+410.52599999999995
+269.453
+96.1708
+69.6219
+35.5721
+14.696200000000001
+9.96167
+17.835900000000002
+20.4262
+122.398
+279.667
+598.063
+530.668
+307.454
+182.397
+79.891
+39.9974
+17.7757
+6.05139
+13.370800000000001
+43.0962
+58.449600000000004
+246.112
+432.117
+501.015
+198.24099999999999
+99.4537
+62.9961
+35.867
+40.1605
+9.13156
+13.13362
+13.598099999999999
+31.5665
+255.706
+633.6590000000001
+486.654
+206.027
+74.1328
+28.242
+23.779600000000002
+14.135
+8.895260000000002
+22.6782
+18.7205
+122.01599999999999
+214.969
+518.071
+558.811
+268.485
+101.7117
+36.6172
+35.489700000000006
+20.814500000000002
+6.6598999999999995
+5.53068
+25.4062
+112.2064
+192.988
+524.0509999999999
+241.576
+162.369
+102.3899
+34.911899999999996
+25.892699999999998
+20.3724
+30.021200000000004
+9.925229999999999
+22.128300000000003
+102.24940000000001
+274.343
+595.7230000000001
+725.294
+389.903
+129.1305
+59.9695
+24.6511
+8.06663
+8.13619
+3.75662
+16.5572
+44.304300000000005
+192.16099999999997
+372.31600000000003
+447.11199999999997
+259.383
+110.41019999999999
+62.8344
+28.959999999999997
+29.6231
+10.00312
+8.38143
+20.3354
+64.3023
+240.674
+648.009
+561.532
+320.808
+47.244200000000006
+59.32019999999999
+25.001700000000003
+9.85567
+6.998429999999999
+4.38608
+60.05799999999999
+81.18860000000001
+281.779
+520.742
+505.229
+354.35
+106.4364
+73.5479
+16.1203
+8.66252
+14.4661
+23.915899999999997
+23.7061
+116.759
+263.564
+718.5749999999999
+753.386
+491.466
+93.9054
+62.223600000000005
+14.0253
+7.91267
+8.05723
+14.3499
+32.1842
+81.44090000000001
+334.919
+797.835
+791.951
+629.006
+185.514
+95.1268
+41.6235
+16.9733
+12.328300000000002
+7.33685
+19.5104
+62.1079
+358.16700000000003
+588.102
+803.699
+525.316
+197.336
+87.8544
+15.1401
+18.7037
+18.3097
+4.50395
+27.69
+71.9136
+266.656
+511.51300000000003
+445.67499999999995
+366.543
+161.325
+74.56700000000001
+65.9456
+13.988100000000001
+8.70354
+8.02689
+20.936700000000002
+107.1924
+361.166
+689.689
+695.635
+517.685
+136.013
+65.94930000000001
+31.032200000000003
+9.6826
+9.08856
+16.362699999999997
+36.6221
+108.7614
+295.565
+580.763
+446.91700000000003
+131.28199999999998
+145.78799999999998
+26.445999999999998
+15.1924
+12.6207
+10.177039999999998
+9.158930000000002
+13.8982
+63.169
+256.911
+306.805
+552.306
+360.47800000000007
+59.9638
+31.2456
+21.708599999999997
+17.4805
+8.160219999999999
+14.72881
+14.6217
+78.41300000000001
+275.29499999999996
+452.121
+512.391
+426.49300000000005
+100.6218
+39.4196
+33.2491
+35.504999999999995
+5.75518
+17.6431
+19.2479
+77.84549999999999
+234.482
+656.286
+628.155
+352.798
+100.28580000000001
+58.2312
+20.8178
+3.6788000000000003
+12.9772
+11.3796
+34.9115
+105.75319999999999
+277.87
+630.071
+545.1129999999999
+376.781
+148.109
+43.601

morl4water/examples/data/nile_river/catchments/InflowRahad.txt

@@ -0,0 +1,240 @@
+3.9999610000000003
+0.0
+0.0
+0.0
+0.0
+3.0000489999999997
+37.00047
+294.0024
+379.9975
+350.996
+0.0
+7.0000100000000005
+0.999996
+0.0
+0.0
+0.0
+0.0
+0.0
+78.0005
+377.9973
+398.995
+96.0
+0.0
+22.999499999999998
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+182.9961
+302.99600000000004
+338.00100000000003
+114.99749999999999
+32.99973000000001
+3.9999610000000003
+0.999996
+0.0
+0.0
+0.0
+0.0
+3.9999610000000003
+94.00009999999999
+273.0037
+338.00100000000003
+30.00049
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+70.99948
+189.9987
+396.00489999999996
+243.0011
+15.99962
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+82.0001
+317.0023
+137.9974
+90.9998
+32.99973000000001
+0.0
+0.0
+0.0
+0.0
+0.0
+2.0000359999999997
+18.0006
+54.99986
+398.995
+353.99730000000005
+257.9973
+13.00048
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+18.0006
+227.0049
+187.9976
+78.0005
+29.0001
+0.999996
+0.0
+0.0
+0.0
+0.0
+3.0000489999999997
+0.0
+107.9999
+294.0024
+230.9961
+125.00240000000001
+2.0000359999999997
+0.999996
+0.0
+2.0000359999999997
+0.0
+0.0
+0.0
+0.0
+180.00599999999997
+248.0036
+509.0022
+66.00048000000001
+37.00047
+13.00048
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+124.0013
+364.00120000000004
+404.9985
+298.00470000000007
+30.99987
+0.0
+2.0000359999999997
+0.0
+0.0
+0.0
+3.0000489999999997
+0.0
+127.0036
+349.99490000000003
+245.0023
+475.99739999999997
+58.00010999999999
+0.0
+0.0
+0.999996
+0.0
+0.0
+0.0
+0.0
+165.99869999999999
+285.9987
+479.99980000000005
+234.9974
+34.99949
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+27.99961
+274.0048
+310.99980000000005
+32.00036
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+169.00000000000003
+373.9949
+412.0012
+349.99490000000003
+0.0
+3.0000489999999997
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+185.99740000000003
+287.99989999999997
+424.9962
+165.99869999999999
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+90.9998
+257.9973
+243.0011
+242.0011
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+0.0
+63.00021999999999
+249.00369999999998
+349.99490000000003
+160.9963
+3.0000489999999997
+0.0
+0.0
+4.999973999999999
+0.0
+0.0
+0.0
+0.0
+119.9999
+357.9986
+379.9975
+204.005
+13.00048
+3.0000489999999997
+0.0
+0.0
+0.999996
+0.0
+0.0
+0.0
+145.0
+281.9973
+349.99490000000003
+398.995
+54.000479999999996
+0.0

morl4water/examples/data/nile_river/catchments/InflowRoseiresToAbuNaama.txt

@@ -0,0 +1,240 @@
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642
+19.707
+13.61
+14.761
+9.8333
+1.8998
+0.0
+0.0
+0.0
+54.866
+86.225
+36.155
+27.642

morl4water/examples/data/nile_river/catchments/InflowSukiToSennar.txt

@@ -0,0 +1,240 @@
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994
+9.2637
+6.3979
+6.9387
+4.6224
+0.89304
+0.0
+0.0
+0.0
+25.791
+40.533
+16.996
+12.994

morl4water/examples/data/nile_river/catchments/InflowWhiteNile.txt

@@ -0,0 +1,240 @@
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049
+1010.799988
+776.299988
+793.299988
+1160.599976
+1045.699951
+763.400024
+569.099976
+535.0
+844.400024
+1120.099976
+1065.199951
+1083.300049

morl4water/examples/data/nile_river/irrigation/irr_demand_DSSennar.txt

@@ -0,0 +1,240 @@
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336
+7.467144564
+8.267195767
+10.45400239
+11.57407407
+12.32078853
+12.73148148
+8.960573477
+7.093787336
+10.41666667
+11.20071685
+10.0308642
+7.093787336

morl4water/examples/data/nile_river/irrigation/irr_demand_Egypt.txt

@@ -0,0 +1,240 @@
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738
+1310.483871
+1620.37037
+1635.304659
+1589.506173
+1896.654719
+2438.271605
+2523.894863
+2202.807646
+1601.080247
+1452.359618
+1481.481481
+1355.286738

morl4water/examples/data/nile_river/irrigation/irr_demand_Gezira.txt

@@ -0,0 +1,240 @@
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644
+319.5937873
+328.207672
+155.3166069
+26.62037037
+51.52329749
+254.2438272
+349.8357228
+176.9713262
+361.882716
+388.2915173
+357.2530864
+344.2353644

morl4water/examples/data/nile_river/irrigation/irr_demand_Hassanab.txt

@@ -0,0 +1,240 @@
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945
+28.37514934
+19.84126984
+8.21385902
+6.944444444
+10.82735962
+22.37654321
+20.16129032
+16.05436081
+30.47839506
+37.70908005
+38.96604938
+35.09557945

morl4water/examples/data/nile_river/irrigation/irr_demand_Tamaniat.txt

@@ -0,0 +1,240 @@
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815
+18.66786141
+12.81415344
+5.227001195
+4.62962963
+7.093787336
+14.66049383
+13.44086022
+10.82735962
+20.44753086
+25.01493429
+25.84876543
+23.14814815

morl4water/examples/data/nile_river/irrigation/irr_demand_USSennar.txt

@@ -0,0 +1,240 @@
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466
+67.5776583
+66.13756614
+44.80286738
+34.72222222
+35.09557945
+77.16049383
+97.44623656
+93.71266428
+132.3302469
+148.2228196
+141.9753086
+82.88530466

morl4water/examples/data/nile_river/reservoirs/evap_GERD.txt

@@ -0,0 +1,12 @@
+13.5
+13.6
+17.1
+15.7
+10.6
+4.2
+-0.4
+0.1
+1.4
+9.1
+11.4
+11.5

morl4water/examples/data/nile_river/reservoirs/evap_HAD.txt

@@ -0,0 +1,12 @@
+10.38
+13
+20.3
+25.2
+31.71
+32.49
+32.4
+31.5
+27
+21.51
+14.01
+10.6

morl4water/examples/data/nile_river/reservoirs/evap_Merowe.txt

@@ -0,0 +1,12 @@
+13.5
+13.6
+17.1
+15.7
+10.6
+4.2
+-0.4
+0.1
+1.4
+9.1
+11.4
+11.5

morl4water/examples/data/nile_river/reservoirs/evap_Roseires.txt

@@ -0,0 +1,12 @@
+17.98
+18.48
+22.66
+22.11
+18.91
+6.27
+-2.79
+-2.6
+1.95
+12.49
+15.69
+16.74