models.h

Go to the documentation of this file.

#pragma once

#include "epecsolve.h"
#include <armadillo>
#include <gurobi_c++.h>
#include <iostream>
#include <memory>

namespace Models {
typedef struct FollPar FollPar;
typedef struct DemPar DemPar;
typedef struct LeadPar LeadPar;
typedef struct LeadAllPar LeadAllPar;

enum class TaxType { StandardTax, SingleTax, CarbonTax };

struct FollPar {
  std::vector<double> costs_quad =
      {}; 
  std::vector<double> costs_lin =
      {}; 
  std::vector<double> capacities =
      {}; 
  std::vector<double> emission_costs =
      {}; 
  std::vector<double> tax_caps = {}; 
  std::vector<std::string> names = {}; 
  FollPar(std::vector<double> costs_quad_ = {},
          std::vector<double> costs_lin_ = {},
          std::vector<double> capacities_ = {},
          std::vector<double> emission_costs_ = {},
          std::vector<double> tax_caps_ = {},
          std::vector<std::string> names_ = {})
      : costs_quad{costs_quad_}, costs_lin{costs_lin_}, capacities{capacities_},
        emission_costs{emission_costs_}, tax_caps(tax_caps_), names{names_} {}
};

struct DemPar {
  double alpha = 100; 
  double beta = 2; 
  DemPar(double alpha = 100, double beta = 2) : alpha{alpha}, beta{beta} {};
};

struct LeadPar {
  double import_limit = -1; 
  double export_limit = -1; 
  double price_limit =
      -1; 

  Models::TaxType tax_type =
      Models::TaxType::StandardTax; 
  bool tax_revenue = false; 
  // LeadPar(double imp_lim = -1, double exp_lim = -1, double price_limit = -1,
  // bool tax_revenue = false, Models::TaxType tax_type_ =
  // Models::TaxType::StandardTax)
  // : import_limit{imp_lim}, export_limit{exp_lim},
  // price_limit{price_limit},tax_type{tax_type_}, tax_revenue{tax_revenue} {}
  LeadPar(double imp_lim = -1, double exp_lim = -1, double price_limit = -1,
          bool tax_revenue = false, unsigned int tax_type_ = 0)
      : import_limit{imp_lim}, export_limit{exp_lim}, price_limit{price_limit},
        tax_revenue{tax_revenue} {
    switch (tax_type_) {
    case 0:
      tax_type = Models::TaxType::StandardTax;
      break;
    case 1:
      tax_type = Models::TaxType::SingleTax;
      break;
    case 2:
      tax_type = Models::TaxType::CarbonTax;
      break;
    default:
      tax_type = Models::TaxType::StandardTax;
    }
  }
};

struct LeadAllPar {
  unsigned int n_followers;           
  std::string name;                   
  Models::FollPar FollowerParam = {}; 
  Models::DemPar DemandParam = {};    
  Models::LeadPar LeaderParam = {};   
  LeadAllPar(unsigned int n_foll, std::string name, Models::FollPar FP = {},
             Models::DemPar DP = {}, Models::LeadPar LP = {})
      : n_followers{n_foll}, name{name}, FollowerParam{FP}, DemandParam{DP},
        LeaderParam{LP} {
    // Nothing here
  }
};

struct EPECInstance {
  std::vector<Models::LeadAllPar> Countries = {}; 
  arma::sp_mat TransportationCosts = {}; 

  EPECInstance(std::string filename) {
    this->load(filename);
  } 
  EPECInstance(std::vector<Models::LeadAllPar> Countries_, arma::sp_mat Transp_)
      : Countries{Countries_}, TransportationCosts{Transp_} {}

  void load(std::string filename);

  void save(std::string filename);
};

enum class LeaderVars {
  FollowerStart,
  NetImport,
  NetExport,
  CountryImport,
  Caps,
  Tax,
  TaxQuad,
  DualVar,
  ConvHullDummy,
  End
};

std::ostream &operator<<(std::ostream &ost, const FollPar P);

std::ostream &operator<<(std::ostream &ost, const DemPar P);

std::ostream &operator<<(std::ostream &ost, const LeadPar P);

std::ostream &operator<<(std::ostream &ost, const LeadAllPar P);

std::ostream &operator<<(std::ostream &ost, const LeaderVars l);

std::ostream &operator<<(std::ostream &ost, EPECInstance I);

using LeadLocs = std::map<LeaderVars, unsigned int>;

void increaseVal(LeadLocs &L, const LeaderVars start, const unsigned int val,
                 const bool startnext = true);
void decreaseVal(LeadLocs &L, const LeaderVars start, const unsigned int val,
                 const bool startnext = true);

void init(LeadLocs &L);

LeaderVars operator+(Models::LeaderVars a, int b);

class EPEC : public Game::EPEC {
  // Mandatory virtuals
private:
  void make_obj_leader(const unsigned int i, Game::QP_objective &QP_obj) final;
  virtual void updateLocs() override;
  virtual void prefinalize() override;
  virtual void postfinalize() override{};
  // override;

public:
  // Rest
private:
  std::vector<LeadAllPar> AllLeadPars =
      {}; 
  std::vector<std::shared_ptr<Game::QP_Param>> MC_QP =
      {}; 
  arma::sp_mat TranspCosts =
      {}; 
  std::vector<unsigned int> nImportMarkets =
      {}; 
  std::vector<LeadLocs> Locations =
      {}; 

  std::map<std::string, unsigned int> name2nos = {};
  unsigned int taxVars = {0};
  std::vector<arma::sp_mat>
      LeadConses{};                   
  std::vector<arma::vec> LeadRHSes{}; 

  bool dataCheck(const bool chkAllLeadPars = true,
                 const bool chkcountriesLL = true, const bool chkMC_QP = true,
                 const bool chkLeadConses = true,
                 const bool chkLeadRHSes = true,
                 const bool chknImportMarkets = true,
                 const bool chkLocations = true,
                 const bool chkLeaderLocations = true,
                 const bool chkLeadObjec = true) const;

  // Super low level
  bool ParamValid(const LeadAllPar &Param) const;

  void make_LL_QP(const LeadAllPar &Params, const unsigned int follower,
                  Game::QP_Param *Foll, const LeadLocs &Loc) const noexcept;

  void make_LL_LeadCons(arma::sp_mat &LeadCons, arma::vec &LeadRHS,
                        const LeadAllPar &Param,
                        const Models::LeadLocs &Loc = {},
                        const unsigned int import_lim_cons = 1,
                        const unsigned int export_lim_cons = 1,
                        const unsigned int price_lim_cons = 1,
                        const unsigned int activeTaxCaps = 0) const noexcept;

  void add_Leaders_tradebalance_constraints(const unsigned int i);

  void make_MC_leader(const unsigned int i);

  void make_MC_cons(arma::sp_mat &MCLHS, arma::vec &MCRHS) const override;

  void WriteCountry(const unsigned int i, const std::string filename,
                    const arma::vec x, const bool append = true) const;

  void WriteFollower(const unsigned int i, const unsigned int j,
                     const std::string filename, const arma::vec x) const;

public:                        // Attributes
  bool quadraticTax = {false}; 

  // double timeLimit = {-1}; ///< Controls the timeLimit (s) for findNashEq

  EPEC() = delete;

  EPEC(GRBEnv *env, arma::sp_mat TranspCosts = {})
      : Game::EPEC(env), TranspCosts{TranspCosts} {}

  // Unit tests
  void testLCP(const unsigned int i);

  EPEC &addCountry(
      LeadAllPar Params,
      const unsigned int addnlLeadVars = 0);

  EPEC &addTranspCosts(const arma::sp_mat &costs);

  unsigned int
  getPosition(const unsigned int countryCount,
              const LeaderVars var = LeaderVars::FollowerStart) const;

  unsigned int
  getPosition(const std::string countryCount,
              const LeaderVars var = LeaderVars::FollowerStart) const;

  EPEC &unlock();

  std::unique_ptr<GRBModel> Respond(const std::string name,
                                    const arma::vec &x) const;
  // Data access methods
  Game::NashGame *get_LowerLevelNash(const unsigned int i) const;

  Game::LCP *playCountry(std::vector<Game::LCP *> countries);

  // Writing model files
  void write(const std::string filename, const unsigned int i,
             bool append = true) const;

  void write(const std::string filename, bool append = true) const;

  void readSolutionJSON(const std::string filename);

  void writeSolutionJSON(std::string filename, const arma::vec x,
                         const arma::vec z) const;

  void writeSolution(const int writeLevel, std::string filename) const;

  const EPECInstance getInstance() const {
    return EPECInstance(this->AllLeadPars, this->TranspCosts);
  }
};

} // namespace Models

// Gurobi functions
std::string to_string(const GRBVar &var);

std::string to_string(const GRBConstr &cons, const GRBModel &model);

// ostream functions
namespace Models {
enum class prn { label, val };

std::ostream &operator<<(std::ostream &ost, Models::prn l);
} // namespace Models

Models::FollPar operator+(const Models::FollPar &F1, const Models::FollPar &F2);
/* Examples */