FMTlpmodel.hpp

Go to the documentation of this file.

/*
Copyright (c) 2019 Gouvernement du Québec
 
SPDX-License-Identifier: LiLiQ-R-1.1
License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt
*/
 
#ifdef FMTWITHOSI
#ifndef FMTlpmodel_H_INCLUDED
#define FMTlpmodel_H_INCLUDED
 
#include "FMTsrmodel.hpp"
#include <boost/serialization/export.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/unordered_map.hpp>
#include <boost/serialization/vector.hpp>
#include <limits>
 
namespace Heuristics
{
    class FMToperatingareascheduler;
    class FMToperatingareaclusterer;
    class FMToperatingareacluster;
    class FMToperatingareascheme;
}
 
namespace Models
{
// DocString: FMTmatrixelement
enum FMTmatrixelement
    {
    goalvariable=0,//period base
    levelvariable=1,//general
    objectivevariable=2,//general
    constraint=3,//period base...
    strictlypositive=4,//when an output have negative coef, be sure that the value of the output in the graph is strictly positive (like in woodstock)
    nr_items=5
    };
 
// DocString: FMTlpmodel
class FMTEXPORT FMTlpmodel : public FMTsrmodel
    {
    // DocString: FMTlpmodel::serialize
    friend class boost::serialization::access;
    template<class Archive>
    void save(Archive& ar, const unsigned int version) const
    {
        ar& boost::serialization::make_nvp("model", boost::serialization::base_object<FMTsrmodel>(*this));
        ar& BOOST_SERIALIZATION_NVP(elements);
    }
    template<class Archive>
    void load(Archive& ar, const unsigned int version)
    {
        ar& boost::serialization::make_nvp("model", boost::serialization::base_object<FMTsrmodel>(*this));
        ar& BOOST_SERIALIZATION_NVP(elements);
    }
    // DocString: FMTlpmodel::elements
    std::vector<std::unordered_map<std::string,
        std::vector<std::vector<int>>>>elements;
    // DocString: FMTlpmodel::getclusterer
    Heuristics::FMToperatingareaclusterer getclusterer(
        const std::vector<Heuristics::FMToperatingareacluster>& initialcluster,
        const Core::FMToutput& areaoutput,
        const Core::FMToutput& statisticoutput,
        const int& period,int minimalnumberofclusters = -1,int maximalnumberofclusters = -1) const;
    // DocString: FMTlpmodel::getsetmatrixelement
    int getsetmatrixelement(const Core::FMTconstraint& constraint,
                     const FMTmatrixelement& element_type, const std::map<int, double>& indexes,
                     int period = -1,
                     double lowerbound = std::numeric_limits<double>::min(),
                     double upperbound = std::numeric_limits<double>::max());
    // DocString: FMTlpmodel::getgoals
    bool getgoals(const std::vector<std::string>& goalsnames, std::map<int,double>& index,const double& sense) const;
    // DocString: FMTlpmodel::getlevelfromlevelname
    int getlevelfromlevelname(const std::string& variable_level, int period,
        Core::FMTconstraint constraint = Core::FMTconstraint()) const;
    // DocString: FMTlpmodel::getsetlevel
    int getsetlevel(const Core::FMTconstraint& constraint,const std::string& variable_level,int period);
    // DocString: FMTlpmodel::getmatrixelement
    std::vector<std::vector<int>>getmatrixelement(const Core::FMTconstraint& constraint,int period) const;
    // DocString: FMTlpmodel::locatelevels
    void locatelevels(const std::vector<Core::FMToutputnode>& nodes,int period, std::map<int, double>& variables,const Core::FMTconstraint& constraint, double multiplier = 1);
    // DocString: FMTlpmodel::locatenodes
    std::vector<std::map<int, double>> locatenodes(const std::vector<Core::FMToutputnode>& nodes, int period, std::map<int, double>& variables,double multiplier = 1) const;
    // DocString: FMTlpmodel::updatematrixelements
    void updatematrixelements(std::vector<int>& matrixelements, const std::vector<int>& deletedelements) const;
    // DocString: FMTlpmodel::updateconstraintsmapping
    void updateconstraintsmapping(const std::vector<int>& Dvariables,const std::vector<int>& Dconstraints);
    // DocString: FMTlpmodel::updateconstraintsmapping
    bool updatematrixngraph(bool updategraph = true);
    // DocString: FMTlpmodel::getamountofpaths
    //size_t getamountofpaths(const Core::FMTdevelopment& dev, const int& actionid) const;
    // DocString: FMTlpmodel::ismatrixelement
    bool ismatrixelement(const Core::FMTconstraint& constraint,
            const FMTmatrixelement& element_type, int period) const;
    // DocString: FMTlpmodel::containsmatrixelements
    bool containsmatrixelements(const Core::FMTconstraint& constraint,int period) const;
    // DocString: FMTlpmodel::issamematrixelement
    bool issamematrixelement(const int& matrixindex, const FMTmatrixelement& element_type,
            const double& lowerb, const double& upperb, const std::map<int, double>& variables) const;
    
    // DocString: FMTlpmodel::getobjectivebounds
    std::vector<int>setobjectivebounds(bool dolower = true, bool doupper = true, double tolerance = FMT_DBL_TOLERANCE);
    // DocString: FMTlpmodel::updatematrixnaming
    void updatematrixnaming();
    // DocString: FMTlpmodel::updategeneralconstraintsnaming
    void updategeneralconstraintsnaming(std::vector<std::string>& colnames,
                                        std::vector<std::string>& rownames) const;
    // DocString: FMTlpmodel::setpositiveoutputsinmatrix
    bool setpositiveoutputsinmatrix(const Core::FMTconstraint& constraint, const std::vector<std::map<int, double>>& strictlypositivesoutputs,int period);
    virtual void swap_ptr(const std::unique_ptr<FMTmodel>& rhs);
    // DocString: FMTlpmodel::FMTlpmodel(const FMTsrmodel&)
    FMTlpmodel(const FMTsrmodel& rhs);
    // DocString: FMTlpmodel::trysetsolution(const std::vector<Core::FMTschedule>&)
    bool trysetsolution(const std::vector<Core::FMTschedule>& schedules);
    public:
        // DocString: FMTlpmodel::clearcache
        void clearcache();
        // DocString: FMTlpmodel::clearconstraintlocation
        void clearconstraintlocation();
        // DocString: FMTlpmodel(const FMTmodel,FMTsolverinterface)
        FMTlpmodel(const FMTmodel& base, FMTsolverinterface lsolvertype);
        // DocString: FMTlpmodel()
        FMTlpmodel();
        // DocString: FMTlpmodel(const FMTmodel, const Graph::FMTgraph<Graph::FMTvertexproperties,Graph::FMTedgeproperties>, const FMTlpsolver, const std::vector<std::unordered_map<std::string,std::vector<std::vector<int>>>>)
        FMTlpmodel( const FMTmodel& base,const Graph::FMTgraph<Graph::FMTvertexproperties,Graph::FMTedgeproperties>& lgraph,
                    const FMTlpsolver& lsolver,const std::vector<std::unordered_map<std::string,std::vector<std::vector<int>>>>& lelements);
        // DocString: FMTlpmodel(const FMTlpmodel)
        FMTlpmodel(const FMTlpmodel& rhs);
        // DocString: FMTlpmodel::initialsolve
        bool initialsolve();
        // DocString: FMTlpmodel(FMTlpmodel&&)
        FMTlpmodel(FMTlpmodel&& rhs)=default;
        // DocString: FMTlpmodel::operator=(FMTlpmodel&& rhs) 
        FMTlpmodel& operator =(FMTlpmodel&& rhs) =default;
        // DocString: FMTlpmodel::setstrictlypositivesoutputsmatrix
        void setstrictlypositivesoutputsmatrix();
        // DocString: FMTlpmodel::getoutput
        virtual std::map<std::string, double> getoutput(const Core::FMToutput& output,
            int period, Core::FMToutputlevel level = Core::FMToutputlevel::standard) const;
        // DocString: FMTlpmodel::getreplanningconstraints
        virtual std::vector<Core::FMTconstraint> getreplanningconstraints(const std::string& modeltype, const std::vector<Core::FMTconstraint>& localconstraints, const int& period) const;
        // DocString: FMTlpmodel::addscheduletoobjective
        void addscheduletoobjective(const Core::FMTschedule& schedule,double weight = 1000);
        // DocString: FMTlpmodel::operator==
        bool operator == (const FMTlpmodel& rhs) const;
        // DocString: FMTlpmodel::operator!=
        bool operator != (const FMTlpmodel& rhs) const;
        // DocString: FMTlpmodel::setobjective
        Graph::FMTgraphstats setobjective(const Core::FMTconstraint& objective);
        // DocString: FMTlpmodel::setconstraint
        Graph::FMTgraphstats setconstraint(const Core::FMTconstraint& constraint);
        // DocString: FMTlpmodel::eraseconstraint
        Graph::FMTgraphstats eraseconstraint(const Core::FMTconstraint& constraint,int period=-1);
        // DocString: FMTlpmodel::getvariabilities
        std::map<std::string, std::vector<double>>getvariabilities(const std::vector<Core::FMToutput>& outputs,
                                                                 const int& periodstart,const int& periodstop);
        // DocString: FMTlpmodel::getmodelfromproportions
        FMTlpmodel getmodelfromproportions(const std::vector<Core::FMTmask>& globalmasks,
                                            std::vector<double> tolerances) const;
        // DocString: FMTlpmodel::getareavariabilities
        std::map<std::string, std::vector<double>>getareavariabilities(const std::vector<Core::FMToutput>& localoutputs,
                const std::vector<Core::FMTmask>& globalmasks,
                std::vector<double> tolerances = std::vector<double>()) const;
        // DocString: FMTlpmodel::eraseperiod
        Graph::FMTgraphstats eraseperiod(bool constraintsonly = false);
        // DocString: FMTlpmodel::getoperatingareaschedulerheuristics
        std::vector<Heuristics::FMToperatingareascheduler>getoperatingareaschedulerheuristics(const std::vector<Heuristics::FMToperatingareascheme>& opareas,
                                                                                const Core::FMToutputnode& node,
                                                                                size_t numberofheuristics=1,
                                                                                bool copysolver=true);
        // DocString: FMTlpmodel::getoperatingareaclustererheuristics
        std::vector<Heuristics::FMToperatingareaclusterer>getoperatingareaclustererheuristics(const std::vector<Heuristics::FMToperatingareacluster>& clusters,
                                                                                const Core::FMToutput& statisticoutput,
                                                                                const Core::FMToutput& areaoutput,
                                                                                const int& period,
                                                                                size_t numberofheuristics=1,
                                                                                int minimalnumberofclusters = -1,
                                                                                int maximalnumberofclusters = -1) const;
        // DocString: FMTlpmodel::resolve
        bool resolve();
        // DocString: FMTlpmodel::operator=
        FMTlpmodel& operator = (const FMTlpmodel& rhs);
        // DocString: ~FMTlpmodel()
        ~FMTlpmodel() = default;
        // DocString: FMTlpmodel::getlpmodel
        FMTlpmodel getlocalmodel(FMTmodel localmodel = FMTmodel(),int period = 0) const;
        // DocString: FMTlpmodel::getObjValue
        double getObjValue() const;
        // DocString: FMTlpmodel::writeLP
        void writeLP(const std::string& location);
        // DocString: FMTlpmodel::writeMPS
        void writeMPS(const std::string& location);
        // DocString: FMTlpmodel::clone
        virtual std::unique_ptr<FMTmodel>clone() const;
        // DocString: FMTlpmodel::presolve
        virtual std::unique_ptr<FMTmodel>presolve(std::vector<Core::FMTactualdevelopment> optionaldevelopments = std::vector<Core::FMTactualdevelopment>()) const;
        // DocString: FMTmodel::build
        virtual bool build(std::vector<Core::FMTschedule> schedules=std::vector<Core::FMTschedule>());
        // DocString: FMTmodel::solve
        virtual bool solve();
        // DocString: FMTlpmodel::getcopy
        virtual std::unique_ptr<FMTmodel> getcopy(int period = 0) const;
        
    };
 
}
 
BOOST_CLASS_EXPORT_KEY(Models::FMTlpmodel)
 
#endif
#endif