bcesolverworker.hpp

// This file is part of the BCESolve library for games of incomplete
// information
// Copyright (C) 2022 Benjamin A. Brooks
// 
// BCESolve 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 3 of the License, or
// (at your option) any later version.
// 
// BCESolve 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, see
// <http://www.gnu.org/licenses/>.
// 
// Benjamin A. Brooks
// ben@benjaminbrooks.net
// Chicago, IL
 
#ifndef BCESOLVERWORKER_HPP
#define BCESOLVERWORKER_HPP
 
#include "bceabstractgame.hpp"
#include "bcegame.hpp"
#include "bce.hpp"
#include <QObject>
#include "bcegurobicallback.hpp"
#include <QMessageBox>
 
 
class BCESolverWorker : public QObject {
  Q_OBJECT;
 
private:
 
  BCEGame game;
  BCESolution solution;
  vector<double> weightData;
  vector<vector<double> > mapBoundaryData;
  BCEGurobiCallback * callback; 
  bool mapBoundaryOption;
  double minAngleIncrement;
 
public:
 
  BCESolverWorker(BCEGame _game,
          vector<double> _weightData,
          vector<vector<double> > _mapBoundaryData,
          BCEGurobiCallback * _callback,
          bool _mapBoundaryOption,
          double _minAngleIncrement):
    game(_game), weightData(_weightData),
    mapBoundaryData(_mapBoundaryData), callback(_callback),
    mapBoundaryOption(_mapBoundaryOption),minAngleIncrement(_minAngleIncrement)
  {}
 
  const BCESolution& getSolution() const {
    return solution;
  }
 
public slots:
 
 
  void startSolve() {
    try {
    
      BCESolver solver(game);
 
      // Populate constraints
      solver.populate();
 
      // Set callback object
      solver.model.setCallback(callback);
      callback->setFullOutput(true);
 
      // Solve the model
      solver.solve(weightData);
 
      // If map boundary is checked in the game tab, map the boundary
      if (mapBoundaryOption) {
    callback->setFullOutput(false);
    solver.setMinAngleIncr(minAngleIncrement);
    solver.mapBoundary(mapBoundaryData);
    callback->setFullOutput(true);
      }
 
      // A realization of 11 signals that the solve routine was interrupted
      if (solver.model.get(GRB_IntAttr_Status)!=11) {
    solver.getSolution(solution);
    emit(sendSolution(&solution,mapBoundaryOption));
      }
    }
    catch(BCEException &e) {
      emit(exceptionSignal(QString::fromStdString(e.getMessage())));
    }
    catch(std::exception &e) {
      string str(e.what());
      emit(exceptionSignal(QString::fromStdString(str)));
    }
    catch(GRBException &e) {
      emit(exceptionSignal(QString::fromStdString(e.getMessage() + 
                          "The error code for this GRBException was: " +
                          to_string(e.getErrorCode()))));
    }
  
    // Send a signal to end the solver thread.
    emit(workFinished());
 
  }
 
signals:
 
  void workFinished();
  void sendSolution(BCESolution *soln,bool isBoundaryMapped);
  void exceptionSignal(QString message);
 
};
 
#endif