FMTsrmodel.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 FMTsrmodel_H_INCLUDED
#define FMTsrmodel_H_INCLUDED
 
#include "FMTmodel.hpp"
#include <boost/serialization/export.hpp>
#include <boost/serialization/split_member.hpp>
#include "FMTlpsolver.hpp"
#include "FMTvertexproperties.hpp"
#include "FMTedgeproperties.hpp"
#include "FMTgraph.hpp"
 
#if defined FMTWITHR
    #include <Rcpp.h>
#endif
 
namespace Core
{
    class FMTSerie;
}
 
 
namespace Graph
{
    class FMTgraphvertextoyield;
}
 
namespace Models 
    {
    // DocString: FMTsrmodel
    class FMTEXPORT FMTsrmodel : public FMTmodel
    {
    public:
        // DocString: FMTsrmodel::getGraphVertexToYield
        /*
        If you want to do a generic yieldrequest for the model you may need to have a graphvertextoyield to deal with yields
        that depand on the full graph and model (like FMTyieldmodel).
        the function return a filled Graphvertexyoyield without a specific vertex selected.
        */
        Graph::FMTgraphvertextoyield getGraphVertexToYield() const;
        // DocString: FMTsrmodel::postsolve
        /*
        This function is for postsolving the presolved model into the original model. In this case, the FMTgraph of the FMTsrmodel is also postsolved.
        */
        virtual void postsolve(const FMTmodel& originalbasemodel);
        // DocString: FMTsrmodel::setparallellogger
        void setparallellogger(Logging::FMTlogger& logger) override;
        // DocString: FMTsrmodel::getavailablesolverinterface
        static std::vector<Models::FMTsolverinterface> getavailablesolverinterface();
        // DocString: FMTsrmodel(const FMTmodel,FMTsolverinterface)
        FMTsrmodel(const FMTmodel& base, FMTsolverinterface lsolvertype);
        // DocString: FMTsrmodel()
        FMTsrmodel();
        // DocString: FMTsrmodel(const FMTsrmodel)
        FMTsrmodel(const FMTsrmodel& rhs);
        // DocString: FMTsrmodel(const FMTmodel, const Graph::FMTgraph<Graph::FMTvertexproperties,Graph::FMTedgeproperties>,    const FMTlpsolver)
        FMTsrmodel( const FMTmodel& base,const Graph::FMTgraph<Graph::FMTvertexproperties,Graph::FMTedgeproperties>& lgraph,
                    const FMTlpsolver& lsolver);
        // DocString: FMTsrmodel::operator=
        FMTsrmodel& operator = (const FMTsrmodel& rhs)=default;
        // DocString: FMTsrmodel(FMTsrmodel&&)
        FMTsrmodel(FMTsrmodel&& rhs)=default;
        // DocString: FMTsrmodel::operator=(FMTsrmodel&& rhs) 
        FMTsrmodel& operator =(FMTsrmodel&& rhs) =default;
        // DocString: ~FMTsrmodel()
        ~FMTsrmodel() = default;
        // DocString: FMTsrmodel::operator==
        bool operator == (const FMTsrmodel& rhs) const;
        // DocString: FMTsrmodel::operator!=
        bool operator != (const FMTsrmodel& rhs) const;
        // DocString: FMTsrmodel::unboundsolution
        bool unboundsolution(int period);
        // DocString: FMTsrmodel::isperiodbounded
        bool isperiodbounded(int period) const;
        // DocString: FMTsrmodel::cleargraphdevelopements
        void cleargraphdevelopements();
        // DocString: FMTsrmodel::cleargraphcache
        void cleargraphcache();
        // DocString: FMTsrmodel::setsolution
        bool setsolution(int period, const Core::FMTschedule& schedule, double tolerance = FMT_DBL_TOLERANCE);
        // DocString: FMTsrmodel::setsolutionbylp
        bool setsolutionbylp(int period, const Core::FMTschedule& schedule, double tolerance = FMT_DBL_TOLERANCE);
        // DocString: FMTsrmodel::forcesolution
        bool forcesolution(int period, const Core::FMTschedule& proportionschedulewithlock);
        // DocString: FMTsrmodel::getsolution
        Core::FMTschedule getsolution(int period, bool withlock = false) const final;
        // DocString: FMTsrmodel::getscheduleproportions
        Core::FMTschedule getscheduleproportions(int period, bool withlock) const;
        // DocString: FMTsrmodel::getstats
        Graph::FMTgraphstats getstats() const;
        // DocString: FMTsrmodel::getcopy
        virtual std::unique_ptr<FMTmodel> getcopy(int period = 0) const;
        // DocString: FMTsrmodel::getoutput
        virtual std::map<std::string, double> getoutput(const Core::FMToutput& output,
            int period, Core::FMToutputlevel level = Core::FMToutputlevel::standard) const;
        #if defined FMTWITHR
        // DocString: FMTsrmodel::getoutputsdataframe
        Rcpp::DataFrame getoutputsdataframe(const std::vector<Core::FMToutput>& outputsdata, int firstperiod, int lastperiod) const;
        #endif 
        // DocString: FMTsrmodel::buildperiod
        Graph::FMTgraphstats buildperiod(Core::FMTschedule schedule = Core::FMTschedule(),
                bool forcepartialbuild = false, int compressageclassoperability = 1);
        // DocString: FMTsrmodel::getfirstactiveperiod
        int getfirstactiveperiod() const;
        // DocString: FMTsrmodel::getarea
        virtual std::vector<Core::FMTactualdevelopment>getarea(int period = 0, bool beforegrowanddeath = false) const override;
        // DocString: FMTsrmodel::getsolverptr()
        FMTlpsolver* getsolverptr();
        // DocString: FMTsrmodel::getconstsolverptr()
        const FMTlpsolver* getconstsolverptr() const;
        // DocString: FMTsrmodel::clone
        virtual std::unique_ptr<FMTmodel>clone() const override;
        // DocString: FMTsrmodel::passinlogger
        void passinlogger(const std::shared_ptr<Logging::FMTlogger>& logger) override;
        // DocString: FMTsrmodel::presolve
        virtual std::unique_ptr<FMTmodel>presolve(std::vector<Core::FMTactualdevelopment> optionaldevelopments = std::vector<Core::FMTactualdevelopment>()) const override;
        // DocString: FMTsrmodel::boundsolution
        bool boundsolution(int period, double tolerance = FMT_DBL_TOLERANCE);
        // DocString: FMTsrmodel::setparameter(const FMTintmodelparameters, const int)
        bool setparameter(const FMTintmodelparameters& key, const int& value) override;
        // DocString: FMTsrmodel::setparameter(const FMTboolmodelparameters, const bool)
        bool setparameter(const FMTboolmodelparameters& key, const bool& value) override;
        // DocString: FMTsrmodel::getgraphstats
        Graph::FMTgraphstats getgraphstats() const;
        // DocString: FMTsrmodel::getrorations
        std::set<Core::FMTSerie>getrorations(const Core::FMTmask& mask, const std::string& aggregate) const;
        // DocString: FMTsrmodel::isoptimal
        virtual bool isoptimal() const;
        // DocString: FMTsrmodel::getobjectivevalue
        virtual double getobjectivevalue() const;
        // DocString: FMTsrmodel::getnochoice
        std::vector<const Core::FMTdevelopment*> getnochoice(const Core::FMTmask& base_mask) const;
    protected:
        // DocString: FMTsrmodel::graph
        Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>graph;
        // DocString: FMTsrmodel::solver
        FMTlpsolver solver;
        // DocString: FMTsrmodel::summarize
        bool summarize(const std::map<int, double>& variables,
            std::vector<int>& sumvariables, std::vector<double>& sumcoefficiants) const;
        // DocString: FMTsrmodel::initializematrix
        Graph::FMTgraphstats initializematrix();
        // DocString: FMTsrmodel::updatematrix
        Graph::FMTgraphstats updatematrix(const Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_pair& targets,
            const Graph::FMTgraphstats& newstats);
        // DocString: FMTsrmodel::getgraphlength
        size_t getgraphsize() const;
        // DocString: FMTsrmodel::postsolvegraph
        void postsolvegraph(const FMTmodel& originalbasemodel);
    private:
        // DocString: FMTsrmodel::save
        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<FMTmodel>(*this));
            ar& BOOST_SERIALIZATION_NVP(solver);
            ar& BOOST_SERIALIZATION_NVP(graph);
        }
        // DocString: FMTsrmodel::load
        template<class Archive>
        void load(Archive& ar, const unsigned int version)
        {
            ar& boost::serialization::make_nvp("model", boost::serialization::base_object<FMTmodel>(*this));
            ar& BOOST_SERIALIZATION_NVP(solver);
            ar& BOOST_SERIALIZATION_NVP(graph);
            solver.passinmessagehandler(*_logger);
        }
        BOOST_SERIALIZATION_SPLIT_MEMBER()
 
    };
 
}
 
BOOST_CLASS_EXPORT_KEY(Models::FMTsrmodel)
 
#endif 
#endif