feature: add constraint StayInTime

Add constraint that assures that Boat stays in the time coverage of the
weather data. Only to be used for testing purposes.

Author: kdemmich

WeatherRoutingTool/algorithms/genetic/patcher.py

@@ -241,6 +241,7 @@ def _setup_components(self) -> tuple[WeatherCond, Boat, WaterDepth, ConstraintsL
             time_forecast,
             time_resolution,
             default_map, )
+        time_frame = (wt.time_start, wt.time_end)
 
         # *******************************************
         # initialise boat
@@ -265,7 +266,8 @@ def _setup_components(self) -> tuple[WeatherCond, Boat, WaterDepth, ConstraintsL
             map_size=default_map,
             depthfile=depthfile,
             waypoints=config.INTERMEDIATE_WAYPOINTS,
-            courses_path=config.COURSES_FILE, )
+            courses_path=config.COURSES_FILE,
+            time_frame=time_frame)
 
         return wt, boat, water_depth, constraints_list
 

WeatherRoutingTool/algorithms/genetic/problem.py

@@ -100,7 +100,7 @@ def _evaluate(self, x: np.ndarray, out: dict, *args, **kwargs) -> None:
 
         # logger.debug(f"RoutingProblem._evaluate: type(x)={type(x)}, x.shape={x.shape}, x={x}")
         obj_dict = self.get_power(x[0])
-        constraints = utils.get_constraints(x[0], self.constraint_list)
+        constraints = utils.get_constraints(x[0], self.constraint_list, obj_dict["start_times"])
         out['F'] = self.get_objectives(obj_dict)
         out['G'] = np.column_stack([constraints])
 
@@ -184,4 +184,5 @@ def get_power(self, route: np.array) -> dict:
                 print('time_diff: ', time_diff)
                 print('time obj.: ', time_obj)
 
-        return {"fuel_sum": fuel_obj, "shipparams": shipparams, "time_obj": time_obj}
+        return {"fuel_sum": fuel_obj, "shipparams": shipparams, "time_obj": time_obj,
+                "start_times": route_dict["start_times"]}

WeatherRoutingTool/algorithms/genetic/utils.py

@@ -9,6 +9,7 @@
 from pymoo.core.duplicate import ElementwiseDuplicateElimination
 
 import WeatherRoutingTool.utils.graphics as graphics
+from WeatherRoutingTool.constraints.constraints import ConstraintsList
 from WeatherRoutingTool.routeparams import RouteParams
 
 logger = logging.getLogger("WRT.genetic")
@@ -84,13 +85,22 @@ def geojson_from_route(
     return geojson
 
 
-def get_constraints_array(route: np.ndarray, constraint_list) -> np.ndarray:
-    """Return constraint violation per waypoint in route
+def get_constraints_array(route: np.ndarray, constraint_list: ConstraintsList,
+                          start_times: np.ndarray = None) -> np.ndarray:
+    """Return constraint violation per waypoint in a route.
+
+    This function calls the constraint evaluation method of the constraint module for every waypoint of a route.
 
     :param route: Candidate array of waypoints
     :type route: np.ndarray
+    :param constraint_list: List of constraints that need to be evaluated
+    :type constraint_list: ConstraintsList
+    :param start_times: array of start times from every waypoint
+    :type start_times: np.ndarray
     :return: Array of constraint violations
+    :rtype: np.ndarray
     """
+
     lat = route[:, 0]
     lon = route[:, 1]
     is_constrained = [False for i in range(0, lat.shape[0] - 1)]
@@ -100,21 +110,40 @@ def get_constraints_array(route: np.ndarray, constraint_list) -> np.ndarray:
     lon_start = lon[:-1]
     lon_end = lon[1:]
 
-    is_constrained = constraint_list.safe_crossing(lat_start, lon_start, lat_end, lon_end, None, is_constrained)
+    is_constrained = constraint_list.safe_crossing(
+        lat_start=lat_start,
+        lon_start=lon_start,
+        lat_end=lat_end,
+        lon_end=lon_end,
+        start_times=start_times,
+        is_constrained=is_constrained
+    )
     return is_constrained
 
 
-def get_constraints(route, constraint_list):
-    """Get sum of constraint violations of all waypoints of the provided route
+def get_constraints(route: np.ndarray, constraint_list: ConstraintsList, start_times: np.ndarray = None) -> np.ndarray:
+    """Get sum of constraint violations of all waypoints of the provided route.
+
+    Currently, the start times from a waypoint are only passed by RoutingProblem._evaluate. This means that restrictions
+    with respect to arrival time are only enforced in the evaluation process and not in the Mutation, Crossover or
+    Population classes.
+    # TODO enable support of constraints with a time dependence also in Mutation, Crossover and Population classes
 
     :param route: List of waypoints
     :type route: np.ndarray
-    :param constraints_list: List of constraints configured by the config
-    :type constraints_list: ConstraintsList
+    :param constraint_list: List of constraints that need to be evaluated
+    :type constraint_list: ConstraintsList
+    :param start_times: array of start times from every waypoint
+    :type start_times: np.ndarray
+    :return: Array of constraint violations
+    :rtype: np.ndarray
     """
 
-    # ToDo: what about time?
-    constraints = np.sum(get_constraints_array(route, constraint_list))
+    constraints = np.sum(get_constraints_array(
+        route=route,
+        constraint_list=constraint_list,
+        start_times=start_times)
+    )
     return constraints
 
 

WeatherRoutingTool/config.py

@@ -64,10 +64,10 @@ class Config(BaseModel):
     # minimum and maximum possible boat speed [m/s]
     CONSTRAINTS_LIST: List[Literal[
         'land_crossing_global_land_mask', 'land_crossing_polygons', 'seamarks',
-        'water_depth', 'on_map', 'via_waypoints', 'status_error'
+        'water_depth', 'on_map', 'in_time', 'via_waypoints', 'status_error'
     ]]
     # options: 'land_crossing_global_land_mask', 'land_crossing_polygons',
-    # 'seamarks','water_depth', 'on_map', 'via_waypoints', 'status_error'
+    # 'seamarks','water_depth', 'on_map', 'in_time', 'via_waypoints', 'status_error'
 
     _DATA_MODE_DEPTH: str = PrivateAttr('from_file')  # options: 'automatic', 'from_file', 'odc', 'skip'
     _DATA_MODE_WEATHER: str = PrivateAttr('from_file')  # options: 'automatic', 'from_file', 'odc', 'skip'

WeatherRoutingTool/constraints/constraints.py

@@ -1,5 +1,6 @@
 import os
 import logging
+from datetime import datetime
 
 import cartopy.crs as ccrs
 import cartopy.feature as cf
@@ -28,7 +29,8 @@ class Constraint:
     """
     Main class for handling of constraints. Constraints implemented so far:
     LandCrossing (prohibit land crossing), WaterDepth (prohibit crossing of areas with too low water depth),
-    StayOnMap (prohibit leaving the area for which the weather data has been obtained)
+    StayOnMap (prohibit leaving the area for which the weather data has been obtained),
+    StayInTime (prohibit leaving the timeframe for which the weather data has been obtained)
     """
 
     name: str
@@ -52,6 +54,9 @@ def print_constraint_message(self):
     def constraint_on_point(self, lat, lon, time):
         pass
 
+    def check_crossing(self, lat_start, lon_start, lat_end, lon_end, time_start=None):
+        pass
+
     def print_debug(self, message):
         logger.debug(self.name + str(": ") + str(message))
 
@@ -191,6 +196,17 @@ def get_constraints_list(constraints_string_list, **kwargs):
             constraints_list.add_neg_constraint(on_map)
             is_stay_on_map = True
 
+        if 'in_time' in constraints_string_list:
+            if 'time_frame' not in kwargs:
+                raise ValueError('To use the in-time constraint module, you need to provide the timeframe '
+                                 'of the weather data.')
+            time = kwargs.get('time_frame')
+            time_start = time[0]
+            time_end = time[1]
+            in_time = StayInTime()
+            in_time.set_time(time_start, time_end)
+            constraints_list.add_neg_constraint(in_time, 'continuous')
+
         if 'seamarks' in constraints_string_list:
             if is_stay_on_map:
                 seamarks = SeamarkCrossing(is_stay_on_map, map_size)
@@ -339,21 +355,53 @@ def safe_endpoint(self, lat, lon, current_time, is_constrained):
             is_constrained += is_constrained_temp
         return is_constrained
 
-    def safe_crossing(self, lat_start, lon_start, lat_end, lon_end, current_time, is_constrained):
-        is_constrained_discrete = is_constrained
-        is_constrained_continuous = is_constrained
-        is_constrained_discrete = self.safe_crossing_discrete(lat_start, lon_start, lat_end, lon_end, current_time,
-                                                              is_constrained)
-        is_constrained_continuous = self.safe_crossing_continuous(lat_start, lon_start, lat_end, lon_end,
-                                                                  is_constrained)
+    def safe_crossing(self, lat_start: np.ndarray, lon_start: np.ndarray, lat_end: np.ndarray, lon_end: np.ndarray,
+                      start_times: np.ndarray, is_constrained: list[bool]):
+        """
+        Check whether there is a constraint on the way from a starting point (lat_start, lon_start) to the destination
+        (lat_end, lon_end).
+
+        :param lat_start: Latitude(s) of start point(s) of section(s) to check
+        :type lat_start: numpy.ndarray or float
+        :param lon_start: Longitude(s) of start point(s) of section(s) to check
+        :type lon_start: numpy.ndarray or float
+        :param lat_end: Latitude(s) of end point(s) of section(s) to check
+        :type lat_end: numpy.ndarray or float
+        :param lon_end: Longitude(s) of end point(s) of section(s) to check
+        :type lon_end: numpy.ndarray or float
+        :param current_time: Time(s) at the start point(s) of the section(s); may be None
+        :type current_time: numpy.ndarray or None
+        :param is_constrained: Booleans for every section stating if it is already constrained
+        :type is_constrained: list[bool]
+        :return: is_constrained
+        :rtype: list[bool]
+        """
+
+        is_constrained_discrete = self.safe_crossing_discrete(
+            lat_start=lat_start,
+            lon_start=lon_start,
+            lat_end=lat_end,
+            lon_end=lon_end,
+            current_time=start_times,
+            is_constrained=is_constrained
+        )
+        is_constrained_continuous = self.safe_crossing_continuous(
+            lat_start=lat_start,
+            lon_start=lon_start,
+            lat_end=lat_end,
+            lon_end=lon_end,
+            time_start=start_times,
+            is_constrained=is_constrained
+        )
 
         # TO BE UPDATED
         is_constrained_array = (np.array(is_constrained) | np.array(is_constrained_discrete)
                                 | np.array(is_constrained_continuous))
         is_constrained = is_constrained_array.tolist()
         return is_constrained
 
-    def safe_crossing_continuous(self, lat_start, lon_start, lat_end, lon_end, is_constrained):
+    def safe_crossing_continuous(self, lat_start: np.ndarray, lon_start: np.ndarray, lat_end: np.ndarray,
+                                 lon_end: np.ndarray, time_start: np.ndarray, is_constrained: list[bool]):
         """TODO: add description
         _summary_
 
@@ -367,6 +415,8 @@ def safe_crossing_continuous(self, lat_start, lon_start, lat_end, lon_end, is_co
         :type lon_end: numpy.ndarray or float
         :param is_constrained: List of booleans for every constraint stating if the section is constraint by it
         :type is_constrained: list[bool]
+        :param time_start: Time(s) at start point(s) of section(s) to check
+        :type time_start: numpy.ndarray or None
         :return: is_constrained.tolist()
         :rtype: list[bool]
         """
@@ -377,12 +427,19 @@ def safe_crossing_continuous(self, lat_start, lon_start, lat_end, lon_end, is_co
         # logger.debug('Length of latitudes: ' + str(len(lat_start)))
 
         for constr in self.negative_constraints_continuous:
-            is_constrained_temp = constr.check_crossing(lat_start, lon_start, lat_end, lon_end)
+            is_constrained_temp = constr.check_crossing(
+                lat_start=lat_start,
+                lon_start=lon_start,
+                lat_end=lat_end,
+                lon_end=lon_end,
+                time_start=time_start
+            )
             is_constrained = np.array(is_constrained) | np.array(is_constrained_temp)
 
         return is_constrained.tolist()
 
-    def safe_crossing_discrete(self, lat_start, lon_start, lat_end, lon_end, current_time, is_constrained):
+    def safe_crossing_discrete(self, lat_start: np.ndarray, lon_start: np.ndarray, lat_end: np.ndarray,
+                               lon_end: np.ndarray, current_time: np.ndarray, is_constrained: list[bool]):
         """
         Check whether there is a constraint on the way from a starting point (lat_start, lon_start) to the destination
         (lat_end, lon_end).
@@ -511,7 +568,7 @@ def load_data_from_file(self, courses_path):
         routeData.close()
         return status, lats, lons
 
-    def check_crossing(self, lat_start=None, lon_start=None, lat_end=None, lon_end=None, current_time=None):
+    def check_crossing(self, lat_start=None, lon_start=None, lat_end=None, lon_end=None, time_start=None):
         status, lats_netcdf, lon_netcdf = self.load_data_from_file(self.courses_path)
         # Double-check coordinates
         assert (lats_netcdf == lat_start).all()
@@ -799,6 +856,56 @@ def set_map(self, lat1, lon1, lat2, lon2):
         self.lon2 = lon2
 
 
+class StayInTime(NegativeContraint):
+    """
+    Constraint such that the boat can't leave the timeframe that has weather data available
+    """
+
+    time_start: datetime
+    time_end: datetime
+
+    def __init__(self):
+        NegativeContraint.__init__(self, "StayInTime")
+        self.message += "leaving wheather time frame!"  # self.resource_type = 0
+
+    def check_crossing(self, lat_start: np.ndarray, lon_start: np.ndarray, lat_end: np.ndarray, lon_end: np.ndarray,
+                       time_start: np.ndarray = None):
+        """
+        Check whether array of start times from route waypoints is covered by weather data.
+
+        time_start can be None. In this case, all waypoints are not constrained.
+        :param lat_start: Start latitude
+        :type lat_start: np.ndarray
+        :param lon_start: Start longitude
+        :type lon_start: np.ndarray
+        :param lat_end: End latitude
+        :type lat_end: np.ndarray
+        :param lon_end: End longitude
+        :type lon_end: np.ndarray
+        :param time_start: Start time
+        :type time_start: np.ndarray or None
+        :return is_out_of_time: list constraints
+        :rtype is_out_of_time: list[bool]
+
+        """
+
+        if time_start is None:
+            return np.full(np.shape(lat_start), False)
+        is_out_of_time = ((time_start > self.time_end) + (time_start < self.time_start))
+        # if is_out_of_time.any():
+        #    print('checking time: ' + str(time_start))
+        #    print('is_out_of_time: ' + str(is_out_of_time))
+        #    print(f'start_time={self.time_start}, end_time={self.time_end}')
+        return is_out_of_time
+
+    def print_info(self):
+        logger.info(form.get_log_step("stay in wheather time frame", 1))
+
+    def set_time(self, time_start, time_end):
+        self.time_start = time_start
+        self.time_end = time_end
+
+
 class ContinuousCheck(NegativeContraint):
     """
     Contains various functions to test data connection, gathering and use for obtaining spatial relations
@@ -876,7 +983,7 @@ def print_info(self):
     def connect_database(self):
         pass
 
-    def check_crossing(self, lat_start, lon_start, lat_end, lon_end, time=None):
+    def check_crossing(self, lat_start, lon_start, lat_end, lon_end, time_start=None):
         result_length = len(lat_start)
         res = []
 
@@ -1024,7 +1131,7 @@ def concat_nodes_ways(self, db_engine, query):
         else:
             return "false query passed"
 
-    def check_crossing(self, lat_start, lon_start, lat_end, lon_end):
+    def check_crossing(self, lat_start, lon_start, lat_end, lon_end, time_start=None):
         """
         Check if certain route crosses specified seamark objects
 
@@ -1106,7 +1213,7 @@ def query_land_polygons(self, db_engine, query):
         gdf = gdf[gdf["geom"] != None]
         return gdf
 
-    def check_crossing(self, lat_start, lon_start, lat_end, lon_end):
+    def check_crossing(self, lat_start, lon_start, lat_end, lon_end, time_start=None):
         """
         Check if certain route crosses specified seamark objects
 

WeatherRoutingTool/execute_routing.py

@@ -42,6 +42,7 @@ def execute_routing(config, ship_config):
     # initialise weather
     wt = WeatherFactory.get_weather(config._DATA_MODE_WEATHER, windfile, departure_time, time_forecast, time_resolution,
                                     default_map)
+    time_frame = (wt.time_start, wt.time_end)
 
     # *******************************************
     # initialise boat
@@ -55,7 +56,7 @@ def execute_routing(config, ship_config):
         constraints_string_list=config.CONSTRAINTS_LIST, data_mode=config._DATA_MODE_DEPTH,
         min_depth=boat.get_required_water_depth(),
         map_size=default_map, depthfile=depthfile, waypoints=config.INTERMEDIATE_WAYPOINTS,
-        courses_path=config.COURSES_FILE)
+        courses_path=config.COURSES_FILE, time_frame=time_frame)
 
     # *******************************************
     # initialise route

WeatherRoutingTool/ship/ship.py

@@ -123,7 +123,7 @@ def check_value_in_range(self, lats, lons, time):
 
     def approx_weather(self, var, lats, lons, time, height=None, depth=None):
 
-        self.check_value_in_range(lats, lons, time)
+        # self.check_value_in_range(lats, lons, time)
 
         ship_var = var.sel(latitude=lats, longitude=lons, time=time, method='nearest', drop=False)
         if height: