adds direct taxi improvement factor (#758)

include/motis/endpoints/routing.h

@@ -21,6 +21,9 @@
 
 namespace motis::ep {
 
+constexpr auto const kInfinityDuration =
+    nigiri::duration_t{std::numeric_limits<nigiri::duration_t::rep>::max()};
+
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 extern boost::thread_specific_ptr<nigiri::routing::search_state> search_state;
 

src/endpoints/routing.cc

@@ -40,9 +40,6 @@ using namespace std::chrono_literals;
 
 namespace motis::ep {
 
-constexpr auto const kInfinityDuration =
-    n::duration_t{std::numeric_limits<n::duration_t::rep>::max()};
-
 using td_offsets_t =
     n::hash_map<n::location_idx_t, std::vector<n::routing::td_offset>>;
 

src/odm/meta_router.cc

@@ -53,16 +53,14 @@ static boost::thread_specific_ptr<prima> p;
 
 constexpr auto const kODMLookAhead = 27h;
 constexpr auto const kSearchIntervalSize = 24h;
+constexpr auto const kODMDirectImprovement = 4.0;
 constexpr auto const kODMDirectPeriod = 1h;
 constexpr auto const kMinODMOffsetLength = n::duration_t{3};
 constexpr auto const kBlacklistPath = "/api/blacklist";
 constexpr auto const kWhitelistPath = "/api/whitelist";
 static auto const kReqHeaders = std::map<std::string, std::string>{
     {"Content-Type", "application/json"}, {"Accept", "application/json"}};
 
-constexpr auto const kInfinityDuration =
-    n::duration_t{std::numeric_limits<n::duration_t::rep>::max()};
-
 mixer get_odm_mixer() {
   return mixer{.alpha_ = 1.5,
                .beta_ = 0.39,
@@ -158,28 +156,45 @@ n::duration_t init_direct(std::vector<direct_ride>& direct_rides,
                           api::Place const& from_p,
                           api::Place const& to_p,
                           n::interval<n::unixtime_t> const intvl,
-                          api::plan_params const& query) {
-  auto [direct, duration] = r.route_direct(
+                          api::plan_params const& query,
+                          n::duration_t const fastest_direct) {
+  direct_rides.clear();
+
+  auto [_, taxi_duration] = r.route_direct(
       e, gbfs, from_p, to_p, {api::ModeEnum::CAR}, std::nullopt, std::nullopt,
       std::nullopt, intvl.from_,
       query.pedestrianProfile_ == api::PedestrianProfileEnum::WHEELCHAIR,
       std::chrono::seconds{query.maxDirectTime_}, query.maxMatchingDistance_,
       query.fastestDirectFactor_);
-  direct_rides.clear();
+
+  if (kODMDirectImprovement * taxi_duration > fastest_direct) {
+    fmt::println(
+        "[init] direct rides prohibited, improvement factor {} (taxi: "
+        "{}, walk: {})",
+        kODMDirectImprovement, taxi_duration, fastest_direct);
+    return taxi_duration;
+  }
+
+  fmt::println(
+      "[init] allowing direct rides, improvement factor {} (taxi: {}, "
+      "walk: {})",
+      kODMDirectImprovement, taxi_duration, fastest_direct);
+
   if (query.arriveBy_) {
     for (auto arr =
-             std::chrono::floor<std::chrono::hours>(intvl.to_ - duration) +
-             duration;
+             std::chrono::floor<std::chrono::hours>(intvl.to_ - taxi_duration) +
+             taxi_duration;
          intvl.contains(arr); arr -= kODMDirectPeriod) {
-      direct_rides.push_back({.dep_ = arr - duration, .arr_ = arr});
+      direct_rides.push_back({.dep_ = arr - taxi_duration, .arr_ = arr});
     }
   } else {
     for (auto dep = std::chrono::ceil<std::chrono::hours>(intvl.from_);
          intvl.contains(dep); dep += kODMDirectPeriod) {
-      direct_rides.push_back({.dep_ = dep, .arr_ = dep + duration});
+      direct_rides.push_back({.dep_ = dep, .arr_ = dep + taxi_duration});
     }
   }
-  return duration;
+
+  return taxi_duration;
 }
 
 void init_pt(std::vector<n::routing::start>& rides,
@@ -226,8 +241,9 @@ void meta_router::init_prima(n::interval<n::unixtime_t> const& odm_intvl) {
 
   auto direct_duration = std::optional<std::chrono::duration<int64_t>>{};
   if (odm_direct_ && r_.w_ && r_.l_) {
-    direct_duration = init_direct(p->direct_rides_, r_, e_, gbfs_rd_,
-                                  from_place_, to_place_, odm_intvl, query_);
+    direct_duration =
+        init_direct(p->direct_rides_, r_, e_, gbfs_rd_, from_place_, to_place_,
+                    odm_intvl, query_, fastest_direct_);
   }
 
   if (odm_pre_transit_ && holds_alternative<osr::location>(from_)) {
@@ -326,7 +342,7 @@ n::routing::query meta_router::get_base_query(
                               .and_then([](std::int64_t const dur) {
                                 return std::optional{n::duration_t{dur}};
                               })
-                              .value_or(kInfinityDuration),
+                              .value_or(ep::kInfinityDuration),
       .min_connection_count_ = 0U,
       .extend_interval_earlier_ = false,
       .extend_interval_later_ = false,
@@ -350,7 +366,7 @@ n::routing::query meta_router::get_base_query(
               .factor_ = static_cast<float>(query_.transferTimeFactor_)},
       .via_stops_ = motis::ep::get_via_stops(*tt_, *r_.tags_, query_.via_,
                                              query_.viaMinimumStay_),
-      .fastest_direct_ = fastest_direct_ == kInfinityDuration
+      .fastest_direct_ = fastest_direct_ == ep::kInfinityDuration
                              ? std::nullopt
                              : std::optional{fastest_direct_}};
 }
@@ -615,10 +631,10 @@ api::plan_response meta_router::run() {
   print_time(routing_start, "[routing]");
 
   // whitelisting
+  auto const wl_start = std::chrono::steady_clock::now();
   auto whitelist_response = std::optional<std::string>{};
   auto ioc2 = boost::asio::io_context{};
   if (blacklisted) {
-    auto const wl_start = std::chrono::steady_clock::now();
     extract_rides();
     try {
       fmt::println("[whitelisting] request for {} events", p->n_events());
@@ -636,7 +652,6 @@ api::plan_response meta_router::run() {
       fmt::println("[whitelisting] networking failed: {}", e.what());
       whitelist_response = std::nullopt;
     }
-    print_time(wl_start, "[whitelisting]");
   }
 
   // mixing
@@ -646,11 +661,12 @@ api::plan_response meta_router::run() {
   if (whitelisted) {
     p->adjust_to_whitelisting();
     add_direct();
-    fmt::println("[whitelisting] success");
   } else {
     p->odm_journeys_.clear();
     fmt::println("[whitelisting] failed, discarding ODM journeys");
   }
+  print_time(wl_start, "[whitelisting]");
+
   fmt::println("[mixing] {} PT journeys and {} ODM journeys",
                pt_result.journeys_.size(), p->odm_journeys_.size());
   get_odm_mixer().mix(pt_result.journeys_, p->odm_journeys_);