pickDeliver/pickDeliver_driver.cpp

Go to the documentation of this file.

/*PGR-GNU*****************************************************************
File: pickDeliver_driver.cpp
 
Copyright (c) 2021 pgRouting developers
Mail: [email protected]
 
Developer:
Copyright (c) 2021 Celia Virginia Vergara Castillo
Copyright (c) 2021 Joseph Emile Honour Percival
 
------
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 ********************************************************************PGR-GNU*/
#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"
 
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) {
  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());
  }
}