prog_solver.cc

Go to the documentation of this file.

#include "prog_solver.h"
 
#include <sstream>
 
#include "context.h"
#include "prog_translator.h"
#include "greedy_solver.h"
#include "solver_factory.h"
 
namespace cyclus {
 
void Report(OsiSolverInterface* iface) {
  std::cout << iface->getNumCols() << " total variables, "
            << iface->getNumIntegers() << " integer.\n";
  std::cout << iface->getNumRows() << " constraints\n";
}
 
ProgSolver::ProgSolver(std::string solver_t)
    : solver_t_(solver_t),
      tmax_(ProgSolver::kDefaultTimeout),
      verbose_(false),
      mps_(false),
      ExchangeSolver(false) {}
 
ProgSolver::ProgSolver(std::string solver_t, bool exclusive_orders)
    : solver_t_(solver_t),
      tmax_(ProgSolver::kDefaultTimeout),
      verbose_(false),
      mps_(false),
      ExchangeSolver(exclusive_orders) {}
 
ProgSolver::ProgSolver(std::string solver_t, double tmax)
    : solver_t_(solver_t),
      tmax_(tmax),
      verbose_(false),
      mps_(false),
      ExchangeSolver(false) {}
 
ProgSolver::ProgSolver(std::string solver_t, double tmax, bool exclusive_orders,
                       bool verbose, bool mps)
    : solver_t_(solver_t),
      tmax_(tmax),
      verbose_(verbose),
      mps_(mps),
      ExchangeSolver(exclusive_orders) {}
 
ProgSolver::~ProgSolver() {}
 
void ProgSolver::WriteMPS() {
  std::stringstream ss;
  ss << "exchng_" << sim_ctx_->time();
  iface_->writeMps(ss.str().c_str());
}
 
double ProgSolver::SolveGraph() {
  SolverFactory sf(solver_t_, tmax_);
  iface_ = sf.get();
  try {
    // get greedy solution
    GreedySolver greedy(exclusive_orders_);
    double greedy_obj = greedy.Solve(graph_);
    graph_->ClearMatches();
 
    // translate graph to iface_ instance
    double pseudo_cost = PseudoCost(); // from ExchangeSolver API
    ProgTranslator xlator(graph_, iface_, exclusive_orders_, pseudo_cost);
    xlator.ToProg();
    if (mps_)
      WriteMPS();
 
    // set noise level
    CoinMessageHandler h;
    h.setLogLevel(0);
    if (verbose_) {
      Report(iface_);
      h.setLogLevel(4);
    }
    iface_->passInMessageHandler(&h);
    if (verbose_) {
      std::cout << "Solving problem, message handler has log level of "
                << iface_->messageHandler()->logLevel() << "\n";
    }
 
    // solve and back translate
    SolveProg(iface_, greedy_obj, verbose_);
 
    xlator.FromProg();
  } catch(...) {
    delete iface_;
    throw;
  }
  double ret = iface_->getObjValue();
  delete iface_;
  return ret;
}
 
}  // namespace cyclus