anonymous_namespace{optimize_driver.cpp} Namespace Reference

Functions
std::vector< Short_vehicle >	get_initial_stops (Vehicle_t *vehicles_arr, size_t total_vehicles)
	get the original stops More...
std::vector< Short_vehicle >	one_processing (PickDeliveryOrders_t *shipments_arr, size_t total_shipments, Vehicle_t *vehicles_arr, size_t total_vehicles, std::vector< Short_vehicle > new_stops, const vrprouting::problem::Matrix &time_matrix, int max_cycles, int64_t execution_date)
	Executes an optimization with the input data. More...
Identifiers< TTimestamp >	processing_times_by_shipment (PickDeliveryOrders_t *shipments_arr, size_t total_shipments)
	: extract the times where the shipments opens or closes More...
Identifiers< TTimestamp >	processing_times_by_vehicle (Vehicle_t *vehicles_arr, size_t total_vehicles)
	: extract the times where the vehicle opens or closes More...
std::vector< Short_vehicle >	subdivide_processing (PickDeliveryOrders_t *shipments_arr, size_t total_shipments, Vehicle_t *vehicles_arr, size_t total_vehicles, const vrprouting::problem::Matrix &time_matrix, int max_cycles, int64_t execution_date, bool subdivide_by_vehicle, std::ostringstream &log)
	Executes an optimization by subdivision of data. More...
void	update_stops (std::vector< Short_vehicle > &the_stops, const std::vector< Short_vehicle > new_values)
	Update the vehicle stops to the new values. More...

Function Documentation

get_initial_stops()

std::vector<Short_vehicle> anonymous_namespace{optimize_driver.cpp}::get_initial_stops	(	Vehicle_t *	vehicles_arr,
		size_t	total_vehicles
	)

get the original stops

Parameters

[in]	vehicles_arr	A C Array of vehicles
[in]	total_vehicles	size of the vehicles_arr

Returns

(vehicle id, stops vector) pair which hold the stops structure

Definition at line 165 of file optimize_driver.cpp.

      {
  std::vector<Short_vehicle> the_stops;
  for (size_t i = 0; i < total_vehicles; ++i) {
    std::vector<Id> stops;
    for (size_t j = 0; j < vehicles_arr[i].stops_size; ++j) {
      stops.push_back(vehicles_arr[i].stops[j]);
    }
    the_stops.push_back({vehicles_arr[i].id, stops});
  }
  std::sort(the_stops.begin(), the_stops.end(), []
      (const Short_vehicle &lhs, const Short_vehicle &rhs) {return lhs.id < rhs.id;});
  return the_stops;
}

References Vehicle_t::id, and Vehicle_t::stops_size.

Referenced by subdivide_processing().

one_processing()

std::vector<Short_vehicle> anonymous_namespace{optimize_driver.cpp}::one_processing	(	PickDeliveryOrders_t *	shipments_arr,
		size_t	total_shipments,
		Vehicle_t *	vehicles_arr,
		size_t	total_vehicles,
		std::vector< Short_vehicle >	new_stops,
		const vrprouting::problem::Matrix &	time_matrix,
		int	max_cycles,
		int64_t	execution_date
	)

Executes an optimization with the input data.

Parameters

[in]	shipments_arr	A C Array of pickup and dropoff shipments
[in]	total_shipments	size of the shipments_arr
[in]	vehicles_arr	A C Array of vehicles
[in]	total_vehicles	size of the vehicles_arr
[in]	new_stops	stops that override the original stops.
[in]	time_matrix	The unique time matrix
[in]	max_cycles	number of cycles to perform during the optimization phase
[in]	execution_date	Value used for not moving shipments that are before this date

Returns

(vehicle id, stops vector) pair which hold the the new stops structure

Definition at line 69 of file optimize_driver.cpp.

                          {
  try {
    /*
     * Construct problem
     */
    vrprouting::problem::PickDeliver pd_problem(
        shipments_arr, total_shipments,
        vehicles_arr, total_vehicles,
        new_stops,
        time_matrix);
 
    /*
     * Unknown problem when createing the pick Deliver problem
     */
    if (!pd_problem.msg.get_error().empty()) {
      throw std::make_pair(pd_problem.msg.get_error(), pd_problem.msg.get_log());
    }
 
    /*
     * get initial solution
     */
    using Initial_solution = vrprouting::initialsol::tabu::Initial_solution;
    using Solution = vrprouting::problem::Solution;
    auto sol = static_cast<Solution>(Initial_solution(execution_date, true, &pd_problem));
 
    /*
     * Optimize the initial solution:
     * - false: do not stop on all served
     * - true:  optimize
     */
    using Optimize = vrprouting::optimizers::tabu::Optimize;
    sol = Optimize(sol, static_cast<size_t>(max_cycles), false, true);
 
    return sol.get_stops();
  } catch(...) {
    throw;
  }
}

References vrprouting::Pgr_messages::get_error(), vrprouting::Pgr_messages::get_log(), and vrprouting::problem::PickDeliver::msg.

Referenced by do_optimize(), and subdivide_processing().

processing_times_by_shipment()

Identifiers<TTimestamp> anonymous_namespace{optimize_driver.cpp}::processing_times_by_shipment	(	PickDeliveryOrders_t *	shipments_arr,
		size_t	total_shipments
	)

: extract the times where the shipments opens or closes

Parameters

[in]	shipments_arr	A C Array of pickup and dropoff shipments
[in]	total_shipments	size of the shipments_arr

Returns

processing times

Definition at line 123 of file optimize_driver.cpp.

      {
  Identifiers<TTimestamp> processing_times;
  for (size_t i = 0; i < total_shipments; ++i) {
    processing_times += shipments_arr[i].pick_open_t;
    processing_times += shipments_arr[i].pick_close_t;
    processing_times += shipments_arr[i].deliver_open_t;
    processing_times += shipments_arr[i].deliver_close_t;
  }
  return processing_times;
}

References PickDeliveryOrders_t::deliver_close_t, PickDeliveryOrders_t::deliver_open_t, PickDeliveryOrders_t::pick_close_t, and PickDeliveryOrders_t::pick_open_t.

Referenced by subdivide_processing().

processing_times_by_vehicle()

Identifiers<TTimestamp> anonymous_namespace{optimize_driver.cpp}::processing_times_by_vehicle	(	Vehicle_t *	vehicles_arr,
		size_t	total_vehicles
	)

: extract the times where the vehicle opens or closes

Parameters

[in]	vehicles_arr	A C Array of vehicles
[in]	total_vehicles	size of the vehicles_arr

Returns

processing times

Definition at line 144 of file optimize_driver.cpp.

      {
  Identifiers<TTimestamp> processing_times;
  for (size_t i = 0; i < total_vehicles; ++i) {
    processing_times += vehicles_arr[i].start_open_t;
    processing_times += vehicles_arr[i].start_close_t;
    processing_times += vehicles_arr[i].end_open_t;
    processing_times += vehicles_arr[i].end_close_t;
  }
  return processing_times;
}

References Vehicle_t::end_close_t, Vehicle_t::end_open_t, Vehicle_t::start_close_t, and Vehicle_t::start_open_t.

Referenced by subdivide_processing().

subdivide_processing()

std::vector<Short_vehicle> anonymous_namespace{optimize_driver.cpp}::subdivide_processing	(	PickDeliveryOrders_t *	shipments_arr,
		size_t	total_shipments,
		Vehicle_t *	vehicles_arr,
		size_t	total_vehicles,
		const vrprouting::problem::Matrix &	time_matrix,
		int	max_cycles,
		int64_t	execution_date,
		bool	subdivide_by_vehicle,
		std::ostringstream &	log
	)

Executes an optimization by subdivision of data.

Parameters

[in]	shipments_arr	A C Array of pickup and dropoff shipments
[in]	total_shipments	size of the shipments_arr
[in]	vehicles_arr	A C Array of vehicles
[in]	total_vehicles	size of the vehicles_arr
[in]	new_stops	stops that override the original stops.
[in]	time_matrix	The unique time matrix
[in]	max_cycles	number of cycles to perform during the optimization phase
[in]	execution_date	Value used for not moving shipments that are before this date

Returns

(vehicle id, stops vector) pair which hold the the new stops structure

Definition at line 213 of file optimize_driver.cpp.

                         {
  try {
    auto the_stops = get_initial_stops(vehicles_arr, total_vehicles);
 
    auto processing_times = subdivide_by_vehicle?
      processing_times_by_vehicle(vehicles_arr, total_vehicles)
      : processing_times_by_shipment(shipments_arr, total_shipments);
 
    Identifiers<Id> prev_shipments_in_stops;
    for (const auto &t : processing_times) {
      CHECK_FOR_INTERRUPTS();
      /*
       * Get active vehicles at time t
       */
      auto vehicles_to_process = static_cast<size_t>(std::distance(vehicles_arr,
        std::partition(
            vehicles_arr, vehicles_arr + total_vehicles,
            [&](const Vehicle_t& v)
            {return v.start_open_t <= t && t <= v.end_close_t;})));
 
      /* Get shipments in stops of active vehicles */
      Identifiers<Id> shipments_in_stops;
      for (size_t i = 0; i < vehicles_to_process; ++i) {
        auto v_id = vehicles_arr[i].id;
        auto v_to_modify = std::find_if(
            the_stops.begin(), the_stops.end(), [&]
            (const Short_vehicle& v) -> bool {return v.id == v_id;});
 
        for (const auto &s : v_to_modify->stops) {
          shipments_in_stops += s;
        }
      }
 
      /*
       * Nothing to do:
       * - no shipments to process
       * - last optimization had exavtly the same shipments
       */
      if ((shipments_in_stops.size() == 0)
          || (prev_shipments_in_stops == shipments_in_stops)) continue;
      log << "\nOptimizing at time: " << t;
 
      prev_shipments_in_stops = shipments_in_stops;
 
      auto shipments_to_process = static_cast<size_t>(std::distance(shipments_arr,
        std::partition(shipments_arr, shipments_arr + total_shipments,
            [&](const PickDeliveryOrders_t& s){return shipments_in_stops.has(s.id);})));
 
      pgassert(shipments_to_process > 0);
      pgassert(shipments_in_stops.size() == static_cast<size_t>(shipments_to_process));
 
      auto new_stops = one_processing(
          shipments_arr, shipments_to_process,
          vehicles_arr, vehicles_to_process, the_stops,
          time_matrix,
          max_cycles, execution_date);
 
      update_stops(the_stops, new_stops);
    }
 
    return the_stops;
  } catch(...) {
    throw;
  }
}

References CHECK_FOR_INTERRUPTS, Vehicle_t::end_close_t, get_initial_stops(), Identifiers< T >::has(), Vehicle_t::id, PickDeliveryOrders_t::id, one_processing(), pgassert, processing_times_by_shipment(), processing_times_by_vehicle(), Identifiers< T >::size(), Vehicle_t::start_open_t, and update_stops().

Referenced by do_optimize().

update_stops()

void anonymous_namespace{optimize_driver.cpp}::update_stops	(	std::vector< Short_vehicle > &	the_stops,
		const std::vector< Short_vehicle >	new_values
	)

Update the vehicle stops to the new values.

Parameters

[in,out]	the_stops	set of stops that are to be updated
[in]	new_values	subset of stops that are to be used for the update

Definition at line 187 of file optimize_driver.cpp.

                                                        {
  for (const auto &v : new_values) {
    auto v_id = v.id;
    auto v_to_modify = std::find_if(
        the_stops.begin(), the_stops.end(), [v_id]
        (const Short_vehicle& v) -> bool {return v.id == v_id;});
    pgassert(v_to_modify != the_stops.end());
    v_to_modify->stops = v.stops;
  }
}

References pgassert, and Short_vehicle::stops.

Referenced by subdivide_processing().