add script to calculate fuel consumption for fixed route from json file

Author: kdemmich

scripts/fuel_consumption_for_specific_route.py

@@ -4,74 +4,40 @@
 ##
 
 import argparse
-import os
-from datetime import datetime
+import json
+import logging
+from datetime import timedelta
+from pathlib import Path
 
 import numpy as np
-import matplotlib.pyplot as plt
 from astropy import units as u
 
 from WeatherRoutingTool.config import Config, set_up_logging
-from WeatherRoutingTool.routeparams import RouteParams
-from WeatherRoutingTool.ship.shipparams import ShipParams
 from WeatherRoutingTool.utils.graphics import get_figure_path
 from WeatherRoutingTool.utils.maps import Map
-from WeatherRoutingTool.ship.maripower_tanker import MariPowerTanker
+from WeatherRoutingTool.routeparams import RouteParams
 from WeatherRoutingTool.ship.direct_power_boat import DirectPowerBoat
+from WeatherRoutingTool.ship.maripower_tanker import MariPowerTanker
+from WeatherRoutingTool.ship.shipparams import ShipParams
 
-
-def run_maripower_test_scenario(calmfactor, windfactor, wavefactor, waypoint_dict, geojsondir, maripower_scenario,
-                                draught_fp, draught_ap, sog):
-    boat = MariPowerTanker(file_name=config.CONFIG_PATH)
-    boat.set_ship_property('Draught_FP', draught_fp.mean())
-    boat.set_ship_property('Draught_AP', draught_ap.mean())
-    boat.set_ship_property('WindForcesFactor', windfactor)
-    boat.set_ship_property('WaveForcesFactor', wavefactor)
-    boat.set_ship_property('CalmWaterFactor', calmfactor)
-    boat.speed = sog
-    boat.load_data()
-
-    print('Running maripower setting ' + maripower_scenario)
-
-    ship_params = boat.get_ship_parameters(waypoint_dict['courses'], waypoint_dict['start_lats'],
-                                           waypoint_dict['start_lons'], time[:-1], sog)
-
-    start = (lat[0], lon[0])
-    finish = (lat[-1], lon[-1])
-
-    rp = RouteParams(
-        count=lat.shape[0] - 2,
-        start=start,
-        finish=finish,
-        gcr=None,
-        route_type='read_from_csv',
-        time=waypoint_dict['travel_times'],
-        lats_per_step=lat,
-        lons_per_step=lon,
-        course_per_step=waypoint_dict['courses'],
-        dists_per_step=waypoint_dict['dist'],
-        starttime_per_step=time,
-        ship_params_per_step=ship_params)
-
-    if geojsondir:
-        filename = os.path.join(geojsondir, 'route_' + maripower_scenario + '.json')
-        print('Writing file: ', filename)
-        rp.return_route_to_API(filename)
-
-
-def run_dpm_test_scenario(waypoint_dict, geojsondir, maripower_scenario, sog):
+def run_dpm_test_scenario(waypoint_dict, geojsondir, sog, output_route):
     boat = DirectPowerBoat(file_name=config.CONFIG_PATH)
     boat.speed = sog
     boat.load_data()
 
-    print('Running direct power boat setting ' + maripower_scenario)
-
     ship_params = boat.get_ship_parameters(waypoint_dict['courses'], waypoint_dict['start_lats'],
-                                           waypoint_dict['start_lons'], time[:-1], sog)
+                                           waypoint_dict['start_lons'], waypoint_dict['start_times'], sog)
 
     start = (lat[0], lon[0])
     finish = (lat[-1], lon[-1])
 
+    # add arrival at destination to 'start_times'
+    travel_time = timedelta(seconds= waypoint_dict['travel_times'][-1].to("second").value)
+    waypoint_dict['start_times'] = np.append(
+        waypoint_dict['start_times'],
+        waypoint_dict['start_times'][-1] + travel_time
+    )
+
     rp = RouteParams(
         count=lat.shape[0] - 2,
         start=start,
@@ -83,152 +49,66 @@ def run_dpm_test_scenario(waypoint_dict, geojsondir, maripower_scenario, sog):
         lons_per_step=lon,
         course_per_step=waypoint_dict['courses'],
         dists_per_step=waypoint_dict['dist'],
-        starttime_per_step=time,
+        starttime_per_step=waypoint_dict['start_times'],
         ship_params_per_step=ship_params)
 
     if geojsondir:
-        filename = os.path.join(geojsondir, 'route_' + maripower_scenario + '.json')
+        filename = output_route
         print('Writing file: ', filename)
         rp.return_route_to_API(filename)
 
+def lat_lon_from_file(filename):
+    with open(filename) as file:
+        rp_dict = json.load(file)
 
-def cut_indices(lat, lon, time, sog, fore_draught, aft_draught, cut_route):
-    start_indices_lat = int(np.where(abs(lat - cut_route[0]) < 0.001)[0][0])
-    end_indices_lat = int(np.where(abs(lat - cut_route[2]) < 0.001)[0][0])
-    start_indices_lon = int(np.where(abs(lon - cut_route[1]) < 0.001)[0][0])
-    end_indices_lon = int(np.where(abs(lon - cut_route[3]) < 0.001)[0][0])
-
-    print('start_lat: ', lat[start_indices_lat])
-    print('end_lat: ', lat[end_indices_lat])
-    print('start_lon: ', lon[start_indices_lon])
-    print('end_lon: ', lon[end_indices_lon])
+    point_list = rp_dict['features']
+    count = len(point_list)
 
-    if (start_indices_lat != start_indices_lon) or (end_indices_lat != end_indices_lon):
-        raise ValueError('Latitude and longitude are not matching for cut')
+    lats_per_step = np.full(count, -99.)
+    lons_per_step = np.full(count, -99.)
 
-    lat = lat[start_indices_lat:end_indices_lat + 1]
-    lon = lon[start_indices_lat:end_indices_lat + 1]
-    time = time[start_indices_lat:end_indices_lat + 1]
-    fore_draught = fore_draught[start_indices_lat:end_indices_lat + 1]
-    aft_draught = aft_draught[start_indices_lat:end_indices_lat + 1]
-    sog = sog[start_indices_lat:end_indices_lat]
-
-    print('mean speed cut: ', sog.mean())
-    print('start time cut: ', time[0])
-    print('mean aft draugh cut: ', aft_draught.mean())
-    print('mean fore draugh cut: ', fore_draught.mean())
-
-    return lat, lon, time, sog, fore_draught, aft_draught
+    for ipoint in range(0, count):
+        coord_pair = point_list[ipoint]['geometry']['coordinates']
+        lats_per_step[ipoint] = coord_pair[1]
+        lons_per_step[ipoint] = coord_pair[0]
 
+    return lats_per_step, lons_per_step
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description='Weather Routing Tool')
     required_args = parser.add_argument_group('required arguments')
     optional_args = parser.add_argument_group('optional arguments')
     required_args.add_argument('-f', '--file', help="Config file name (absolute path)", required=True, type=str)
-    required_args.add_argument('-r', '--route', help="Route file name (absolute path)", required=True, type=str)
-    required_args.add_argument('-n', '--name', help="Name string for output json file", required=True, type=str)
-
-    optional_args.add_argument('--write-geojson', help="<True|False>. Defaults to 'False'", required=False,
-                               type=str, default='False')
-    optional_args.add_argument('-wave', '--wave_scenario', help="Weight for wave resistance (maripower only)",
-                               required=False, type=float, default=1.)
-    optional_args.add_argument('-wind', '--wind_scenario', help="Weight for wind resistance (maripower only)",
-                               required=False, type=float, default=1.)
-    optional_args.add_argument('-calm', '--calm_water_scenario', help="Weight for calm water resistance "
-                                                                      "(maripower only)",
-                               required=False, type=float, default=1.)
-    optional_args.add_argument('-bt', '--boat_type',
-                               help="<maripower|direct_power_method>. Defaults to 'direct_power_method' ",
-                               required=False,
-                               type=str, default='direct_power_method')
+    required_args.add_argument('-r-in', '--input_route', help="Route file name (absolute path)", required=True, type=str)
+    required_args.add_argument('-r-out', '--output_route', help="Route file name (absolute path)", required=True, type=str)
 
     set_up_logging()
 
     # read arguments
     args = parser.parse_args()
-
-    config = Config(file_name=args.file)
-    config.print()
-
-    scenario_name = args.name
+    config = Config.assign_config(Path(args.file))
 
     windfile = config.WEATHER_DATA
     depthfile = config.DEPTH_DATA
-    if str(args.write_geojson).lower() == 'true':
-        routepath = config.ROUTE_PATH
-    else:
-        routepath = None
+    input_route = args.input_route
+    output_route = args.output_route
     coursesfile = config.COURSES_FILE
     figurefile = get_figure_path()
     time_resolution = config.DELTA_TIME_FORECAST
     time_forecast = config.TIME_FORECAST
-    departure_time = datetime.strptime(config.DEPARTURE_TIME, '%Y-%m-%dT%H:%MZ')
+    departure_time = config.DEPARTURE_TIME
     lat1, lon1, lat2, lon2 = config.DEFAULT_MAP
     default_map = Map(lat1, lon1, lat2, lon2)
-
-    maripower_test_scenarios_calm = args.calm_water_scenario
-    maripower_test_scenarios_wind = args.wind_scenario
-    maripower_test_scenarios_wave = args.wave_scenario
-
-    lat, lon, time, sog, fore_draught, aft_draught, power, fuel_rate = RouteParams.from_gzip_file(args.route)
-
-    # possibility to analyse only single parts of the route
-    # lat, lon, time, sog, fore_draught, aft_draught = cut_indices(lat, lon, time, sog, fore_draught,
-    #                                                               aft_draught, cut_route)
+    sog = 7.717 * u.meter/u.second
 
     # obtain position, time and courses for every waypoint
-    waypoint_dict = RouteParams.get_per_waypoint_coords(lon, lat, time[0], sog)
+    lat, lon = lat_lon_from_file(input_route)
+    waypoint_dict = RouteParams.get_per_waypoint_coords(lon, lat, departure_time, sog)
 
     # obtain RouteParams object for different models or for gzip data
-    if str(args.boat_type) == 'direct_power_method':
-        run_dpm_test_scenario(
-            waypoint_dict,
-            routepath,
-            scenario_name,
-            sog
-        )
-
-    if str(args.boat_type) == 'maripower':
-        run_maripower_test_scenario(
-            maripower_test_scenarios_calm,
-            maripower_test_scenarios_wind,
-            maripower_test_scenarios_wave,
+    run_dpm_test_scenario(
             waypoint_dict,
-            routepath,
-            scenario_name,
-            fore_draught,
-            aft_draught,
-            sog
-        )
-
-    if str(args.boat_type) == 'data':
-        boat = DirectPowerBoat(file_name=config.CONFIG_PATH)
-        power = power * boat.power_at_sp * 0.01 * 4 / 3  # power_at_sp is 75% of SMCR power
-
-        ship_params = ShipParams.set_default_array_1D(len(lon))
-        ship_params.fuel_rate = fuel_rate
-        ship_params.power = power
-
-        start = (lat[0], lon[0])
-        finish = (lat[-1], lon[-1])
-
-        rp = RouteParams(
-            count=lat.shape[0] - 2,
-            start=start,
-            finish=finish,
-            gcr=None,
-            route_type='read_from_gzip',
-            time=waypoint_dict['travel_times'],
-            lats_per_step=lat,
-            lons_per_step=lon,
-            course_per_step=waypoint_dict['courses'],
-            dists_per_step=waypoint_dict['dist'],
-            starttime_per_step=time,
-            ship_params_per_step=ship_params,
-        )
-
-        if routepath:
-            filename = os.path.join(routepath, 'route_' + scenario_name + '.json')
-            print('Writing file: ', filename)
-            rp.return_route_to_API(filename)
+            input_route,
+            sog,
+            output_route
+    )