.. _program_listing_file_include_interfaces_epec_models.h:

Program Listing for File epec_models.h
======================================

|exhale_lsh| :ref:`Return to documentation for file <file_include_interfaces_epec_models.h>` (``include/interfaces/epec_models.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   /* #############################################
    *             This file is part of
    *                    ZERO
    *
    *             Copyright (c) 2020
    *     Released under the Creative Commons
    *         CC BY-NC-SA 4.0 License
    *
    *              Find out more at
    *        https://github.com/ds4dm/ZERO
    * #############################################*/
   
   
   #pragma once
   
   
   #include "zero.h"
   #include <armadillo>
   #include <gurobi_c++.h>
   #include <iostream>
   #include <memory>
   #include <utility>
   
   namespace Models {
     namespace EPEC {
        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_} {}
        };
   
        /*
         * @brief Stores the parameters of the demand curve in a country model
         */
        struct DemPar {
           double alpha = 100; 
           double beta = 2; 
           DemPar(double alpha = 100, double beta = 2) : alpha{alpha}, beta{beta} {};
        };
   
        /*
         * @brief Stores the parameters of the leader in a country model
         */
        struct LeadPar {
           double import_limit = -1; 
           double export_limit = -1; 
           double price_limit  = -1;   
           bool   tradeAllowed = true; 
   
           Models::EPEC::TaxType tax_type = Models::EPEC::TaxType::StandardTax;
           /*
            * @brief Dictates whether the leader objective willinclude tax revenues
            */
           bool tax_revenue = false;
           LeadPar(double       imp_lim     = -1,
                     double       exp_lim     = -1,
                     double       price_limit = -1,
                     bool         tax_revenue = false,
                     unsigned int tax_type_   = 0,
                     bool         tradeBool   = true)
                : import_limit{imp_lim}, export_limit{exp_lim}, price_limit{price_limit},
                   tax_revenue{tax_revenue}, tradeAllowed{tradeBool} {
             switch (tax_type_) {
             case 0:
                tax_type = Models::EPEC::TaxType::StandardTax;
                break;
             case 1:
                tax_type = Models::EPEC::TaxType::SingleTax;
                break;
             case 2:
                tax_type = Models::EPEC::TaxType::CarbonTax;
                break;
             default:
                tax_type = Models::EPEC::TaxType::StandardTax;
             }
           }
        };
   
        struct LeadAllPar {
           unsigned int          n_followers;        
           std::string           name;               
           Models::EPEC::FollPar FollowerParam = {}; 
           Models::EPEC::DemPar  DemandParam   = {}; 
           Models::EPEC::LeadPar LeaderParam   = {}; 
           LeadAllPar(unsigned int          n_foll,
                         std::string           name,
                         Models::EPEC::FollPar FP = {},
                         Models::EPEC::DemPar  DP = {},
                         Models::EPEC::LeadPar LP = {})
                : n_followers{n_foll}, name{std::move(name)}, FollowerParam{FP}, DemandParam{DP},
                   LeaderParam{LP} {
             // Nothing here
           }
        };
   
        struct EPECInstance {
           std::vector<Models::EPEC::LeadAllPar> Countries = {}; 
           arma::sp_mat TransportationCosts                = {}; 
   
           explicit EPECInstance(std::string filename) {
             this->load(filename);
           } 
           EPECInstance(std::vector<Models::EPEC::LeadAllPar> Countries_, arma::sp_mat Transp_)
                : Countries{Countries_}, TransportationCosts{Transp_} {}
   
           void load(const std::string &filename);
   
           void save(const 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, const 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::EPEC::LeaderVars a, int b);
   
        class EPEC : public Game::EPEC {
           // Mandatory virtuals
        private:
           void makeObjectivePlayer(const unsigned int i, MathOpt::QP_Objective &QP_obj) final;
   
           void updateLocations() override;
   
           void preFinalize() override;
   
           void postFinalize() override{};
           // override;
   
        public:
           // Rest
        private:
           std::vector<LeadAllPar> AllLeadPars = {}; 
           std::vector<std::shared_ptr<MathOpt::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(bool chkAllLeadPars     = true,
                               bool chkcountriesLL     = true,
                               bool chkMC_QP           = true,
                               bool chkLeadConses      = true,
                               bool chkLeadRHSes       = true,
                               bool chknImportMarkets  = true,
                               bool chkLocations       = true,
                               bool chkLeaderLocations = true,
                               bool chkLeadObjec       = true) const;
   
           // Super low level
           bool ParamValid(const LeadAllPar &Param) const;
   
           void make_LL_QP(const LeadAllPar & Params,
                                const unsigned int follower,
                                MathOpt::QP_Param *Foll,
                                const LeadLocs &   Loc) noexcept;
   
           void make_LL_LeadCons(arma::sp_mat &                LeadCons,
                                        arma::vec &                   LeadRHS,
                                        const LeadAllPar &            Param,
                                        const Models::EPEC::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 unsigned int            disableTrade    = 0) const noexcept;
   
           void add_Leaders_tradebalance_constraints(const unsigned int i);
   
           void make_MC_leader(const unsigned int i);
   
           void makeMCConstraints(arma::sp_mat &MCLHS, arma::vec &MCRHS) const override;
   
           void WriteCountrySolution(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,
                                    bool               append) 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} {}
   
           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;
   
           // Writing model files
           void
           writeLeadParams(const std::string &filename, const unsigned int i, bool append = true) const;
   
           void readSolutionJSON(const std::string &filename);
   
           void
           writeSolutionJSON(const std::string &filename, const arma::vec &x, const arma::vec &z) const;
   
           void writeSolution(const int writeLevel, const std::string &filename) const;
   
           const EPECInstance getInstance() const {
             return EPECInstance(this->AllLeadPars, this->TranspCosts);
           }
        };
   
        /*
         * @brief Enum class for handling print of labels and their values.
         */
        enum class prn { label, val };
   
        std::ostream &operator<<(std::ostream &ost, Models::EPEC::prn l);
     } // namespace EPEC
   } // namespace Models
   
   // Gurobi functions
   std::string to_string(const GRBVar &var);
   
   std::string to_string(const GRBConstr &cons, const GRBModel &model);
   
   Models::EPEC::FollPar operator+(const Models::EPEC::FollPar &F1, const Models::EPEC::FollPar &F2);