Implement vehicle order cost objective

cpp/include/cuopt/routing/data_model_view.hpp

@@ -287,6 +287,26 @@ class data_model_view_t {
                                const i_t nvehicles,
                                bool validate_input = true);
 
+  /**
+   * @brief Set the cost of assigning a specific vehicle to each order.
+   *        costs[order_id] = cost of vehicle vehicle_id serving order order_id.
+   *        A cost of 0 means a free assignment; a finite cost > 0 will be minimized
+   *        as the VEHICLE_ORDER_COST objective. If add_vehicle_order_match has already
+   *        marked a (vehicle, order) pair as infeasible, specifying a finite cost for
+   *        that pair is an error.
+   *
+   * @param vehicle_id  vehicle id for which costs are specified
+   * @param costs       device memory pointer to n_orders double values
+   * @param n_orders    number of orders (must match the problem size)
+   */
+  void set_vehicle_order_cost(const i_t vehicle_id, double const* costs, const i_t n_orders);
+
+  /**
+   * @brief Get the vehicle order cost map
+   */
+  const std::unordered_map<i_t, raft::device_span<double const>>& get_vehicle_order_cost()
+    const noexcept;
+
   /**
    * @brief In fully heterogenous fleet mode, vehicle can take different amount
    * of times to complete a task based on their profile and the order being
@@ -647,6 +667,7 @@ class data_model_view_t {
   bool const* skip_first_trip_{nullptr};
   std::unordered_map<i_t, raft::device_span<i_t const>> vehicle_order_match_;
   std::unordered_map<i_t, raft::device_span<i_t const>> order_vehicle_match_;
+  std::unordered_map<i_t, raft::device_span<double const>> vehicle_order_cost_;
   std::unordered_map<i_t, raft::device_span<i_t const>> order_service_times_;
   objective_t const* objective_{};
   f_t const* objective_weights_{};

cpp/include/cuopt/routing/routing_structures.hpp

@@ -29,6 +29,7 @@ enum class objective_t {
   VARIANCE_ROUTE_SERVICE_TIME,  // Variance in route service times
   PRIZE,                        // Sum of prizes of all orders that are served
   VEHICLE_FIXED_COST,           // Used when fixed vehicle cost are enabled
+  VEHICLE_ORDER_COST,           // Sum of vehicle-order assignment costs (mismatch dimension)
   SIZE  // Helper enum to keep track of number of supported objective functions
 };
 

cpp/src/routing/arc_value.hpp

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -112,7 +112,9 @@ static constexpr double get_arc_of_dimension(const NodeInfo<i_t>& l1,
   } else if constexpr (dim == dim_t::SERVICE_TIME) {
     return l1.is_depot() ? 0. : vehicle_info.order_service_times[l1.node()];
   } else if constexpr (dim == dim_t::MISMATCH) {
-    return !l1.is_service_node() ? 0. : (double)(1 - vehicle_info.order_match[l1.node()]);
+    return (!l1.is_service_node() || vehicle_info.order_costs.empty())
+             ? 0.
+             : vehicle_info.order_costs[l1.node()];
   } else if constexpr (dim == dim_t::BREAK) {
     return l1.is_break();
   } else {

cpp/src/routing/data_model_view.cu

@@ -338,6 +338,16 @@ void data_model_view_t<i_t, f_t>::add_order_vehicle_match(const i_t order_id,
   order_vehicle_match_[order_id] = raft::device_span<i_t const>(vehicles, nvehicles);
 }
 
+template <typename i_t, typename f_t>
+void data_model_view_t<i_t, f_t>::set_vehicle_order_cost(const i_t vehicle_id,
+                                                         double const* costs,
+                                                         const i_t n_orders)
+{
+  cuopt_expects(
+    costs != nullptr, error_type_t::ValidationError, "vehicle_order_cost cannot be null");
+  vehicle_order_cost_[vehicle_id] = raft::device_span<double const>(costs, n_orders);
+}
+
 template <typename i_t, typename f_t>
 void data_model_view_t<i_t, f_t>::set_order_service_times(i_t const* service_times,
                                                           const i_t truck_id,
@@ -667,6 +677,13 @@ data_model_view_t<i_t, f_t>::get_order_vehicle_match() const noexcept
   return order_vehicle_match_;
 }
 
+template <typename i_t, typename f_t>
+const std::unordered_map<i_t, raft::device_span<double const>>&
+data_model_view_t<i_t, f_t>::get_vehicle_order_cost() const noexcept
+{
+  return vehicle_order_cost_;
+}
+
 template <typename i_t, typename f_t>
 const std::unordered_map<i_t, raft::device_span<i_t const>>&
 data_model_view_t<i_t, f_t>::get_order_service_times() const noexcept

cpp/src/routing/dimensions.cuh

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -215,6 +215,7 @@ struct service_time_dimension_info_t {
 
 struct mismatch_dimension_info_t {
   bool has_vehicle_order_match = false;
+  bool has_vehicle_order_cost  = false;
   constexpr bool has_constraints() const { return has_vehicle_order_match; }
 };
 

cpp/src/routing/fleet_info.hpp

@@ -128,7 +128,7 @@ class fleet_info_t {
       info.fixed_cost          = fixed_costs[vehicle_id];
       info.matrices            = matrices.view();
       info.order_service_times = fleet_order_constraints.get_order_service_times(vehicle_id);
-      info.order_match         = fleet_order_constraints.get_order_match(vehicle_id);
+      info.order_costs         = fleet_order_constraints.get_order_costs(vehicle_id);
 
       size_t stride = num_vehicles;
       i_t n_cap_dim = capacities.size() / num_vehicles;
@@ -275,7 +275,7 @@ class fleet_info_t {
     info.fixed_cost          = v_fixed_costs_.element(vehicle_id, handle_ptr_->get_stream());
     info.matrices            = matrices_.view();
     info.order_service_times = fleet_order_constraints_.get_order_service_times(vehicle_id);
-    info.order_match         = fleet_order_constraints_.get_order_match(vehicle_id);
+    info.order_costs         = fleet_order_constraints_.get_order_costs(vehicle_id);
 
     size_t stride = num_vehicles;
     i_t n_cap_dim = v_capacities_.size() / num_vehicles;

cpp/src/routing/fleet_order_constraints.cu

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -9,16 +9,22 @@
 
 #include <thrust/fill.h>
 #include <cuopt/error.hpp>
+#include <limits>
 #include <raft/core/span.hpp>
+#include <set>
+#include <unordered_set>
 #include <utilities/copy_helpers.hpp>
 #include <vector>
 
 namespace cuopt {
 namespace routing {
 namespace detail {
 
+// Generate a flat [n_vehicles x n_orders] matrix of order costs.
+// Infeasible pairs (excluded by vehicle_order_match/order_vehicle_match) get +inf.
+// Compatible pairs default to 0.0.
 template <typename i_t, typename f_t>
-rmm::device_uvector<bool> generate_vehicle_order_match_matrix(
+rmm::device_uvector<double> generate_vehicle_order_match_matrix(
   data_model_view_t<i_t, f_t> const& data_model, bool& is_homogenous)
 {
   auto handle_ptr_     = data_model.get_handle_ptr();
@@ -32,18 +38,18 @@ rmm::device_uvector<bool> generate_vehicle_order_match_matrix(
   const i_t order_begin           = depot_included ? 1 : 0;
 
   if (!vehicle_order_match.empty() || !order_vehicle_match.empty()) {
-    std::vector<bool> vehicle_order_match_h(n_orders * fleet_size, true);
+    // Use 0.0 for compatible, +inf for infeasible.
+    std::vector<double> order_costs_h(n_orders * fleet_size, 0.0);
     std::set<std::pair<i_t, i_t>> not_allowed_pairs;
-    // loop over specified vehicles and set the entries corresponding to specified
-    // order list to true and remaining orders to false
+
     for (const auto& [vehicle_id, order_ids] : vehicle_order_match) {
       const auto order_ids_vec_h = cuopt::host_copy(order_ids, stream_view);
       const auto order_ids_h =
         std::unordered_set<i_t>(order_ids_vec_h.begin(), order_ids_vec_h.end());
 
       for (i_t order_id = order_begin; order_id < n_orders; ++order_id) {
         if (!order_ids_h.count(order_id)) {
-          vehicle_order_match_h[vehicle_id * n_orders + order_id] = false;
+          order_costs_h[vehicle_id * n_orders + order_id] = std::numeric_limits<double>::infinity();
           not_allowed_pairs.insert({order_id, vehicle_id});
         }
       }
@@ -55,7 +61,7 @@ rmm::device_uvector<bool> generate_vehicle_order_match_matrix(
         std::unordered_set<i_t>(vehicle_ids_vec_h.begin(), vehicle_ids_vec_h.end());
       for (i_t vehicle_id = 0; vehicle_id < fleet_size; ++vehicle_id) {
         if (!vehicle_ids_h.count(vehicle_id)) {
-          vehicle_order_match_h[order_id + vehicle_id * n_orders] = false;
+          order_costs_h[order_id + vehicle_id * n_orders] = std::numeric_limits<double>::infinity();
         } else {
           cuopt_expects(
             not_allowed_pairs.count({order_id, vehicle_id}) == 0u,
@@ -65,12 +71,12 @@ rmm::device_uvector<bool> generate_vehicle_order_match_matrix(
       }
     }
 
-    if (is_homogenous && !vehicle_order_match_h.empty()) {
+    if (is_homogenous && !order_costs_h.empty()) {
       for (i_t vehicle_id = 1; vehicle_id < fleet_size; ++vehicle_id) {
         if (is_homogenous) {
           for (i_t order_id = order_begin; order_id < n_orders; ++order_id) {
-            if (vehicle_order_match_h[order_id + (vehicle_id - 1) * n_orders] !=
-                vehicle_order_match_h[order_id + vehicle_id * n_orders]) {
+            if (order_costs_h[order_id + (vehicle_id - 1) * n_orders] !=
+                order_costs_h[order_id + vehicle_id * n_orders]) {
               is_homogenous = false;
               break;
             }
@@ -79,21 +85,21 @@ rmm::device_uvector<bool> generate_vehicle_order_match_matrix(
       }
     }
 
-    return cuopt::device_copy(vehicle_order_match_h, stream_view);
+    return cuopt::device_copy(order_costs_h, stream_view);
   }
 
-  return rmm::device_uvector<bool>(0, stream_view);
+  return rmm::device_uvector<double>(0, stream_view);
 }
 
 template <typename i_t>
 __global__ void modify_service_times(raft::device_span<i_t> service_times,
-                                     raft::device_span<bool const> order_vehicle_match)
+                                     raft::device_span<double const> order_costs)
 {
-  cuopt_assert(service_times.size() == order_vehicle_match.size(),
-               "service times and order vehicle match matrix should have same sizes");
+  cuopt_assert(service_times.size() == order_costs.size(),
+               "service times and order costs matrix should have same sizes");
   size_t idx = threadIdx.x + blockDim.x * blockIdx.x;
   for (; idx < service_times.size(); idx += blockDim.x * gridDim.x) {
-    if (!order_vehicle_match[idx]) { service_times[idx] = std::numeric_limits<i_t>::max(); }
+    if (isinf(order_costs[idx])) { service_times[idx] = std::numeric_limits<i_t>::max(); }
   }
 }
 
@@ -102,14 +108,64 @@ void populate_vehicle_order_match(data_model_view_t<i_t, f_t> const& data_model,
                                   detail::fleet_order_constraints_t<i_t>& fleet_order_constraints_,
                                   bool& is_homogenous)
 {
-  fleet_order_constraints_.order_match =
+  fleet_order_constraints_.order_costs =
     generate_vehicle_order_match_matrix<i_t, f_t>(data_model, is_homogenous);
 }
 
+template <typename i_t, typename f_t>
+void populate_vehicle_order_cost(data_model_view_t<i_t, f_t> const& data_model,
+                                 detail::fleet_order_constraints_t<i_t>& fleet_order_constraints_)
+{
+  auto handle_ptr_     = data_model.get_handle_ptr();
+  auto stream_view     = handle_ptr_->get_stream();
+  const i_t fleet_size = data_model.get_fleet_size();
+  const i_t n_orders   = data_model.get_num_orders();
+
+  const auto& vehicle_order_cost = data_model.get_vehicle_order_cost();
+  if (vehicle_order_cost.empty()) { return; }
+
+  // Ensure order_costs array is allocated (may not be if order_match wasn't set)
+  if (fleet_order_constraints_.order_costs.is_empty()) {
+    fleet_order_constraints_.order_costs =
+      rmm::device_uvector<double>(n_orders * fleet_size, stream_view);
+    thrust::fill(handle_ptr_->get_thrust_policy(),
+                 fleet_order_constraints_.order_costs.begin(),
+                 fleet_order_constraints_.order_costs.end(),
+                 0.0);
+  }
+
+  // Copy per-vehicle cost arrays from user input, with consistency checks
+  auto order_costs_h = cuopt::host_copy(fleet_order_constraints_.order_costs, stream_view);
+  handle_ptr_->sync_stream();
+
+  for (const auto& [vehicle_id, costs_span] : vehicle_order_cost) {
+    const auto costs_h = cuopt::host_copy(costs_span, stream_view);
+    handle_ptr_->sync_stream();
+    cuopt_expects((i_t)costs_h.size() == n_orders,
+                  error_type_t::ValidationError,
+                  "vehicle_order_cost size must equal number of orders");
+    for (i_t order_id = 0; order_id < n_orders; ++order_id) {
+      double existing = order_costs_h[vehicle_id * n_orders + order_id];
+      double new_cost = costs_h[order_id];
+      cuopt_expects(!(std::isinf(existing) && std::isfinite(new_cost)),
+                    error_type_t::ValidationError,
+                    "Inconsistency: vehicle_order_match marks pair as infeasible but "
+                    "vehicle_order_cost specifies a finite cost for the same pair");
+      if (!std::isinf(existing)) { order_costs_h[vehicle_id * n_orders + order_id] = new_cost; }
+    }
+  }
+
+  fleet_order_constraints_.order_costs = cuopt::device_copy(order_costs_h, stream_view);
+}
+
 template void populate_vehicle_order_match(
   data_model_view_t<int, float> const& data_model,
   detail::fleet_order_constraints_t<int>& fleet_order_constraints_,
   bool& is_homogenous);
+
+template void populate_vehicle_order_cost(
+  data_model_view_t<int, float> const& data_model,
+  detail::fleet_order_constraints_t<int>& fleet_order_constraints_);
 }  // namespace detail
 }  // namespace routing
 }  // namespace cuopt