FMTSrModel.h

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_Hm_included
#define FMTsrmodel_Hm_included
 
#include "FMTModel.h"
#include <boost/serialization/export.hpp>
#include <boost/serialization/split_member.hpp>
#include "FMTLpSolver.h"
#include "FMTVertexProperties.h"
#include "FMTEdgeProperties.h"
#include "FMTGraph.hpp"
#include <memory>
 
#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::setNodeCacheSize
        void setNodeCacheSize(const size_t& p_size);
        // DocString: FMTSrModel::getGraphVertexToYield
        Graph::FMTGraphVertexToYield getGraphVertexToYield() const;
        // DocString: FMTSrModel::postSolve
        virtual void postSolve(const FMTModel& originalbasemodel);
        // DocString: FMTSrModel::setParallelLogger
        void setParallelLogger(Logging::FMTLogger& logger) override;
        // 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(FMTModel&& base,const Graph::FMTGraph<Graph::FMTVertexProperties,Graph::FMTEdgeProperties>& lgraph,
                    const FMTLpSolver& lsolver);
        // DocString: FMTSrModel::operator=
        FMTSrModel& operator = (const FMTSrModel& rhs);
        // DocString: FMTSrModel(FMTSrModel&&)
        FMTSrModel(FMTSrModel&& rhs) noexcept;
        // DocString: FMTSrModel::operator=(FMTSrModel&& rhs) 
        FMTSrModel& operator =(FMTSrModel&& rhs) noexcept;
        // 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::clearGraphDevelopments
        void clearGraphDevelopments();
        // 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::getGraphStats
        Graph::FMTGraphStats getGraphStats(const Core::FMTMask& p_Subset) 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::getPotentialArea
        std::vector<Core::FMTActualDevelopment>getPotentialArea(int p_Period = 0, bool p_BeforeGrowAndDeath = false) const;
        
        
        // 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::unique_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::getRotations
        std::set<Core::FMTSerie>getRotations(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;
        // DocString: FMTSrModel::getAllMasks
        std::set<std::string> getAllMasks(const std::vector<Core::FMTTheme>& p_selectedThemes) const;
        // DocString: FMTSrModel::SupportsMultiThreading
        bool SupportsMultiThreading() const override;
    protected:
        // DocString: FMTSrModel::graph
        std::unique_ptr<Graph::FMTGraph<Graph::FMTVertexProperties, Graph::FMTEdgeProperties>>m_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);
        // DocString: FMTSrModel::getActives
        std::queue<Graph::FMTGraph<Graph::FMTVertexProperties, Graph::FMTEdgeProperties>::FMTvertex_descriptor> getActives();
    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(m_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(m_graph);
            solver.passInMessageHandler(*_logger);
        }
        BOOST_SERIALIZATION_SPLIT_MEMBER()
 
    };
 
}
 
BOOST_CLASS_EXPORT_KEY(Models::FMTSrModel)
 
#endif 
#endif