pickDeliver/pickDeliver_driver.cpp File Reference

#include "drivers/pickDeliver_driver.h"
#include <cstring>
#include <sstream>
#include <string>
#include <deque>
#include "problem/pickDeliver.h"
#include "c_types/pickDeliveryOrders_t.h"
#include "c_types/solution_rt.h"
#include "c_types/vehicle_t.h"
#include "problem/matrix.h"
#include "cpp_common/pgr_assert.h"
#include "initialsol/tabu.h"
#include "optimizers/tabu.h"
#include "c_common/pgr_alloc.hpp"

Include dependency graph for pickDeliver/pickDeliver_driver.cpp:

Go to the source code of this file.

Functions
void	do_pickDeliver (PickDeliveryOrders_t *customers_arr, size_t total_customers, Vehicle_t *vehicles_arr, size_t total_vehicles, Matrix_cell_t *matrix_cells_arr, size_t total_cells, Time_multipliers_t *multipliers_arr, size_t total_multipliers, bool optimize, double factor, int max_cycles, bool stop_on_all_served, int64_t execution_date, Solution_rt **return_tuples, size_t *return_count, char **log_msg, char **notice_msg, char **err_msg)

Function Documentation

do_pickDeliver()

void do_pickDeliver	(	PickDeliveryOrders_t *	customers_arr,
		size_t	total_customers,
		Vehicle_t *	vehicles_arr,
		size_t	total_vehicles,
		Matrix_cell_t *	matrix_cells_arr,
		size_t	total_cells,
		Time_multipliers_t *	multipliers_arr,
		size_t	total_multipliers,
		bool	optimize,
		double	factor,
		int	max_cycles,
		bool	stop_on_all_served,
		int64_t	execution_date,
		Solution_rt **	return_tuples,
		size_t *	return_count,
		char **	log_msg,
		char **	notice_msg,
		char **	err_msg
	)

Parameters

[in]	customers_arr	A C Array of pickup and dropoff orders
[in]	total_customers	size of the customers_arr
[in]	vehicles_arr	A C Array of vehicles
[in]	total_vehicles	size of the vehicles_arr
[in]	matrix_cells_arr	A C Array of the (time) matrix cells
[in]	total_cells	size of the matrix_cells_arr
[in]	multipliers_arr	A C Array of the multipliers
[in]	total_multipliers	size of the multipliers_arr
[in]	optimize	flag to control optimization
[in]	factor	A global multiplier for the (time) matrix cells
[in]	max_cycles	number of cycles to perform during the optimization phase
[in]	stop_on_all_served	Indicator to stop optimization when all orders are served
[in]	execution_date	Value used for not moving orders that are before this date
[out]	return_tuples	C array of contents to be returned to postgres
[out]	return_count	number of tuples returned
[out]	log_msg	special log message pointer
[out]	notice_msg	special message pointer to be returned as NOTICE
[out]	err_msg	special message pointer to be returned as ERROR

Returns

void

Precondition

The messages: log_msg, notice_msg, err_msg must be empty (=nullptr)

The C arrays: customers_arr, vehicles_arr, matrix_cells_arr must not be empty

The C array: return_tuples must be empty

Only matrix cells (i, i) can be missing and are considered as 0 (time units)

Postcondition

The C arrays: customers_arr, vehicles_arr, matrix_cells_arr Do not change

The C array: return_tuples contains the result for the problem given

The return_tuples array size is return_count

err_msg is empty if no throw from the process is catched

log_msg contains some logging

notice_msg is empty

Definition at line 108 of file pickDeliver/pickDeliver_driver.cpp.

                    {
  std::ostringstream log;
  std::ostringstream notice;
  std::ostringstream err;
  try {
    /*
     * verify preconditions
     */
    pgassert(!(*log_msg));
    pgassert(!(*notice_msg));
    pgassert(!(*err_msg));
    pgassert(total_customers);
    pgassert(total_vehicles);
    pgassert(total_cells);
    pgassert(*return_count == 0);
    pgassert(!(*return_tuples));
    log << "do_pickDeliver\n";
 
    *return_tuples = nullptr;
    *return_count = 0;
 
    Identifiers<Id> node_ids;
    Identifiers<Id> order_ids;
 
    for (size_t i = 0; i < total_customers; ++i) {
      node_ids += customers_arr[i].pick_node_id;
      node_ids += customers_arr[i].deliver_node_id;
      order_ids += customers_arr[i].id;
    }
 
    bool missing = false;
    for (size_t i = 0; i < total_vehicles; ++i) {
      auto vehicle = vehicles_arr[i];
      node_ids += vehicle.start_node_id;
      node_ids += vehicle.end_node_id;
      for (size_t j = 0; j < vehicle.stops_size; ++j) {
        if (!order_ids.has(vehicle.stops[j])) {
          if (!missing) err << "Order in 'stops' information missing";
          missing = true;
          err << "Missing information of order " << vehicle.stops[j] << "\n";
        }
      }
      if (missing) {
        *err_msg = pgr_msg(err.str());
        return;
      }
    }
 
    vrprouting::problem::Matrix cost_matrix(
        matrix_cells_arr, total_cells,
        multipliers_arr, total_multipliers,
        node_ids, static_cast<Multiplier>(factor));
#if 1
    /*
     * Verify matrix triangle inequality
     */
    if (!cost_matrix.obeys_triangle_inequality()) {
      log << "[PickDeliver] Fixing Matrix that does not obey triangle inequality ";
      log << cost_matrix.fix_triangle_inequality() << " cycles used";
 
      if (!cost_matrix.obeys_triangle_inequality()) {
        log << "[pickDeliver] Matrix Still does not obey triangle inequality ";
      }
    }
#endif
    /*
     * Verify matrix cells preconditions
     */
    if (!cost_matrix.has_no_infinity()) {
      err << "An Infinity value was found on the Matrix";
      *err_msg = pgr_msg(err.str());
      return;
    }
 
 
    log << "stop_on_all_served" << stop_on_all_served << "\n";
    log << "execution_date" << execution_date << "\n";
    log << "Initialize problem\n";
    /*
     * Construct problem
     */
    vrprouting::problem::PickDeliver pd_problem(
        customers_arr, total_customers,
        vehicles_arr, total_vehicles,
        cost_matrix);
 
    err << pd_problem.msg.get_error();
    if (!err.str().empty()) {
      log << pd_problem.msg.get_error();
      log << pd_problem.msg.get_log();
      *log_msg = pgr_msg(log.str());
      *err_msg = pgr_msg(err.str());
      return;
    }
    log << pd_problem.msg.get_log();
    pd_problem.msg.clear();
 
    log << "Finish Initialize problem\n";
 
#if 0
    try {
#endif
      /*
       * get initial solutions
       */
      using Initial_solution = vrprouting::initialsol::tabu::Initial_solution;
      using Solution = vrprouting::problem::Solution;
      auto sol = static_cast<Solution>(Initial_solution(execution_date, optimize, &pd_problem));
      /*
       * Solve (optimize)
       */
      using Optimize = vrprouting::optimizers::tabu::Optimize;
      sol = Optimize(sol, static_cast<size_t>(max_cycles), stop_on_all_served, optimize);
#if 0
    } catch (AssertFailedException &except) {
      log << pd_problem.msg.get_log();
      throw;
    } catch(...) {
      log << "Caught unknown exception!";
      throw;
    }
#endif
 
    log << pd_problem.msg.get_log();
    pd_problem.msg.clear();
    log << "Finish solve\n";
 
    /*
     * Prepare results
     */
    auto solution = sol.get_postgres_result();
    log << pd_problem.msg.get_log();
    pd_problem.msg.clear();
    log << "solution size: " << solution.size() << "\n";
 
 
    if (!solution.empty()) {
      (*return_tuples) = pgr_alloc(solution.size(), (*return_tuples));
      int seq = 0;
      for (const auto &row : solution) {
        (*return_tuples)[seq] = row;
        ++seq;
      }
    }
    (*return_count) = solution.size();
 
    log << pd_problem.msg.get_log();
 
    pgassert(*err_msg == nullptr);
    *log_msg = log.str().empty()?
      nullptr :
      pgr_msg(log.str());
    *notice_msg = notice.str().empty()?
      nullptr :
      pgr_msg(notice.str());
  } catch (AssertFailedException &except) {
    if (*return_tuples) free(*return_tuples);
    (*return_count) = 0;
    err << except.what() << log.str();
    *err_msg = pgr_msg(err.str());
  } catch (std::exception& except) {
    if (*return_tuples) free(*return_tuples);
    (*return_count) = 0;
    err << except.what() << log.str();
    *err_msg = pgr_msg(err.str());
  } catch(...) {
    if (*return_tuples) free(*return_tuples);
    (*return_count) = 0;
    err << "Caught unknown exception!" << log.str();
    *err_msg = pgr_msg(err.str());
  }
}

References vrprouting::Pgr_messages::clear(), PickDeliveryOrders_t::deliver_node_id, vrprouting::base::Base_Matrix::fix_triangle_inequality(), vrprouting::Pgr_messages::get_error(), vrprouting::Pgr_messages::get_log(), Identifiers< T >::has(), vrprouting::base::Base_Matrix::has_no_infinity(), PickDeliveryOrders_t::id, vrprouting::problem::PickDeliver::msg, vrprouting::base::Base_Matrix::obeys_triangle_inequality(), pgassert, pgr_alloc(), pgr_msg(), PickDeliveryOrders_t::pick_node_id, and AssertFailedException::what().

Referenced by process().