FMTmodel.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
*/
 
#ifndef FMTMODEL_H_INCLUDED
#define FMTMODEL_H_INCLUDED
 
#include "FMTtheme.hpp"
#include "FMTaction.hpp"
#include "FMTtransition.hpp"
#include "FMTyields.hpp"
#include "FMTlifespans.hpp"
#include "FMTactualdevelopment.hpp"
#include "FMToutput.hpp"
#include "FMTconstraint.hpp"
#include "FMTlist.hpp"
#include "FMTmodelparameters.hpp"
#include <boost/serialization/vector.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/unordered_map.hpp>
#include <boost/serialization/export.hpp>
#include "FMToutputnode.hpp"
#include "FMTschedule.hpp"
 
 
namespace Graph
{
    template<class T1, class T2>
    class FMTgraph;
    class FMTlinegraph;
    class FMTgraphvertextoyield;
}
 
namespace Parser
{
    class FMTmodelparser;
}
 
namespace Spatial
{
    class FMTspatialschedule;
    class FMTspatialnodescache;
}
namespace Models
{
    class FMTmodelstats;
    // DocString: FMTmodel
    class FMTEXPORT FMTmodel : public Core::FMTobject
    {
        template<class T1,class T2>
        friend class Graph::FMTgraph;
        friend class Graph::FMTlinegraph;
        friend class Spatial::FMTspatialschedule;
        friend class Spatial::FMTspatialnodescache;
        friend class Parser::FMTmodelparser;
        friend class Graph::FMTgraphvertextoyield;
    public:
        // DocString: FMTmodel::aggregateAllActions
        Models::FMTmodel aggregateAllActions(const std::vector<std::string>& p_Aggregates) const;
        // DocString: FMTmodel::aggregateSchedules
        std::vector<Core::FMTschedule> aggregateSchedules(const std::vector<Core::FMTschedule>& p_schedules) const;
        // DocString: FMTmodel::setparallellogger
        virtual void setparallellogger(Logging::FMTlogger& logger);
        // DocString: FMTmodel::clearcache
        virtual void clearcache();
        // DocString: FMTmodel(const std::vector<Core::FMTactualdevelopment>& larea, const std::vector<Core::FMTtheme>, const std::vector<Core::FMTaction>, const std::vector<Core::FMTtransition>, const Core::FMTyields, const Core::FMTlifespans, const std::string, const std::vector<Core::FMToutput>, std::vector<Core::FMTconstraint>,FMTmodelparameters)
        FMTmodel(const std::vector<Core::FMTactualdevelopment>& larea, const std::vector<Core::FMTtheme>& lthemes,
            const std::vector<Core::FMTaction>& lactions,
            const std::vector<Core::FMTtransition>& ltransitions, const Core::FMTyields& lyields, const Core::FMTlifespans& llifespan,
            const std::string& lname, const std::vector<Core::FMToutput>& loutputs, std::vector<Core::FMTconstraint> lconstraints = std::vector<Core::FMTconstraint>(),
            FMTmodelparameters lparameters = FMTmodelparameters());
        // DocString: FMTmodel()
        FMTmodel();
        // DocString: ~FMTmodel
        virtual ~FMTmodel() = default;
        // DocString: FMTmodel(FMTmodel&&)
        FMTmodel(FMTmodel&& rhs) = default;
        // DocString: FMTmodel::operator=(FMTmodel&&) 
        FMTmodel& operator =(FMTmodel&& rhs) = default;
        // DocString: FMTmodel::getarea
        virtual std::vector<Core::FMTactualdevelopment>getarea(int period = 0, bool beforegrowanddeath = false) const;
        // DocString: FMTmodel::getcopy
        virtual std::unique_ptr<FMTmodel> getcopy(int period = 0) const;
        // DocString: FMTmodel::basepresolve
        FMTmodel basepresolve() const;
        // DocString: FMTmodel::getpresolvefilter
        Core::FMTmaskfilter getpresolvefilter(const std::vector<Core::FMTtheme>& originalthemes) const;
        // DocString: FMTmodel::getpostsolvefilter
        Core::FMTmaskfilter getpostsolvefilter(const std::vector<Core::FMTtheme>& originalthemes, const Core::FMTmask& devmask) const;
        // DocString: FMTmodel::getselectedmask
        Core::FMTmask getselectedmask(const std::vector<Core::FMTtheme>& originalthemes) const;
        // DocString: FMTmodel::presolve
        virtual std::unique_ptr<FMTmodel>presolve(std::vector<Core::FMTactualdevelopment> optionaldevelopments = std::vector<Core::FMTactualdevelopment>()) const;
        // DocString: FMTmodel::postsolve
        /*
        This function is for postsolving the presolved model into the original model.
        */
        virtual void postsolve(const FMTmodel& originalbasemodel);
        // DocString: FMTmodel::presolveschedule
        Core::FMTschedule presolveschedule(const Core::FMTschedule& originalbaseschedule,
            const FMTmodel& originalbasemodel) const;
        // DocString: FMTmodel::getmodelstats
        FMTmodelstats getmodelstats() const;
        // DocString: FMTmodel::cleanactionsntransitions
        void cleanactionsntransitions();
        // DocString: FMTmodel::getname
        inline std::string getname() const
        {
            return name;
        }
        // DocString: FMTmodel::getthemes
        inline std::vector<Core::FMTtheme>getthemes() const
        {
            return themes;
        }
        // DocString: FMTmodel::getactions
        inline std::vector<Core::FMTaction>getactions() const
        {
            return actions;
        }
        // DocString: FMTmodel::gettransitions
        inline std::vector<Core::FMTtransition>gettransitions() const
        {
            return transitions;
        }
        // DocString: FMTmodel::getyields
        inline Core::FMTyields getyields() const
        {
            return yields;
        }
        // DocString: FMTmodel::getlifespan
        inline Core::FMTlifespans getlifespan() const
        {
            return lifespan;
        }
        // DocString: FMTmodel::getoutputs
        inline std::vector<Core::FMToutput> getoutputs() const
        {
            return outputs;
        }
        // DocString: FMTmodel::getconstraints
        inline std::vector<Core::FMTconstraint>getconstraints() const
        {
            return constraints;
        }
        // DocString: FMTmodel::defaultdeathaction
        static Core::FMTaction defaultdeathaction(const Core::FMTlifespans& llifespan,
            const std::vector<Core::FMTtheme>& lthemes);
        // DocString: FMTmodel::defaultdeathtransition
        static Core::FMTtransition defaultdeathtransition(const Core::FMTlifespans& llifespan,
            const std::vector<Core::FMTtheme>& lthemes);
        // DocString: FMTmodel::addoutput
        void addoutput(const std::string& name, const std::string& maskstring, Core::FMTotar outputtarget,
            std::string action = std::string(), std::string yield = std::string(), std::string description = std::string(), int targettheme = -1);
        // DocString: FMTmodel::addyieldhandlers
        template<typename T>
        void addyieldhandlers(const std::vector<T>& yieldhandlers)
        {
            try {
                yields.unshrink(themes);
                for (const auto& yldhandler : yieldhandlers)
                {
                    std::unique_ptr<Core::FMTyieldhandler> yldhandlerptr = yldhandler.clone();
                    yields.push_back(yldhandlerptr->getmask(), yldhandlerptr);
                }
                yields.update();
            }
            catch (...) {
                _exhandler->printexceptions("", "FMTmodel:::addyieldhandlers", __LINE__, __FILE__);
            }
        }
        // DocString: FMTmodel::addyieldhandlersfromptr
        void addyieldhandlersfromptr(const std::vector<std::unique_ptr<Core::FMTyieldhandler>>& yieldhandlers);
        // DocString: FMTmodel::operator==
        bool operator == (const FMTmodel& rhs) const;
        // DocString: FMTmodel::operator<
        bool operator < (const FMTmodel& rhs) const;
        // DocString: FMTmodel::setarea
        void setarea(const std::vector<Core::FMTactualdevelopment>& ldevs);
        // DocString: FMTmodel::setthemes
        void setthemes(const std::vector<Core::FMTtheme>& lthemes);
        // DocString: FMTmodel::setactions
        void setactions(const std::vector<Core::FMTaction>& lactions);
        // DocString: FMTmodel::settransitions
        void settransitions(const std::vector<Core::FMTtransition>& ltransitions);
        // DocString: FMTmodel::setconstraints
        void setconstraints(const std::vector<Core::FMTconstraint>& lconstraint);
        // DocString: FMTmodel::setyields
        void setyields(const Core::FMTyields& lylds);
        // DocString: FMTmodel::setlifespan
        void setlifespan(const Core::FMTlifespans& llifespan);
        // DocString: FMTmodel::setname
        void setname(const std::string& newname);
        // DocString: FMTmodel::setoutputs
        void setoutputs(const std::vector<Core::FMToutput>& newoutputs);
        // DocString: FMTmodel::isvalid
        bool isvalid();
        // DocString: FMTmodel::locatestaticthemes(const Core::FMToutput, bool ignoreoutputvariables)
        std::vector<Core::FMTtheme> locatestaticthemes(const Core::FMToutput& output, bool ignoreoutputvariables = false) const;
        // DocString: FMTmodel::locatestaticthemes(const Core::FMToutputnode, bool ignoreoutputvariables)
        std::vector<Core::FMTtheme> locatestaticthemes(const Core::FMToutputnode& output, bool ignoreoutputvariables = false) const;
        // DocString: FMTmodel::locatedynamicthemes
        std::vector<Core::FMTtheme> locatedynamicthemes(const Core::FMToutput& outpu, bool ignoreoutputvariables = false) const;
        // DocString: FMTmodel::getdynamicmask(const Core::FMToutput, bool ignoreoutputvariables)
        Core::FMTmask getdynamicmask(const Core::FMToutput& output, bool ignoreoutputvariables = false) const;
        // DocString: FMTmodel::getdynamicmask(const Core::FMToutputnode, bool ignoreoutputvariables)
        Core::FMTmask getdynamicmask(const Core::FMToutputnode& node, bool ignoreoutputvariables = false) const;
        // DocString: FMTmodel::getstaticmask
        Core::FMTmask getstaticmask(const Core::FMToutputnode& node, bool ignoreoutputvariables = false) const;
        // DocString: FMTmodel::isstaticnode
        bool isstaticnode(const Core::FMToutputnode& node, double ratioofset = 0.1) const;
        // DocString: FMTmodel::locatestatictransitionsthemes
        std::vector<Core::FMTtheme>locatestatictransitionsthemes() const;
        // DocString: FMTmodel::locatenotestaticthemes
        std::vector<Core::FMTtheme>locatenodestaticthemes(const Core::FMToutputnode& node,
            bool ignoreoutputvariables = false,
            std::vector<Core::FMTtheme> basethemes = std::vector<Core::FMTtheme>()) const;
        // DocString: FMTmodel(FMTmodel)
        FMTmodel(const FMTmodel& rhs);
        // DocString: FMTmodel::operator=
        FMTmodel& operator = (const FMTmodel& rhs);
        // DocString: FMTmodel::empty
        bool empty() const;
        // DocString: FMTmodel::append
        void push_back(const FMTmodel& rhs);
        // DocString: FMTmodel::getinitialarea
        double getinitialarea() const;
        // DocString: FMTmodel::setareaperiod
        void setareaperiod(const int& period);
        // DocString: FMTmodel::getpotentialschedule
        Core::FMTschedule getpotentialschedule(std::vector<Core::FMTactualdevelopment> toremove,
            std::vector<Core::FMTactualdevelopment> selection, bool withlock = true) const;
        // DocString: FMTmodel::getreplanningconstraints
        virtual std::vector<Core::FMTconstraint> getreplanningconstraints(const std::string& modeltype, const std::vector<Core::FMTconstraint>& localconstraints, const int& period) const;
        // DocString: FMTmodel::doplanning
        virtual bool doplanning(const bool& solve, std::vector<Core::FMTschedule> schedules = std::vector<Core::FMTschedule>());
        // DocString: FMTmodel::getoutput
        virtual std::map<std::string, double> getoutput(const Core::FMToutput& output,
            int period, Core::FMToutputlevel level = Core::FMToutputlevel::standard) const;
        // DocString: FMTmodel::getsolution
        virtual Core::FMTschedule getsolution(int period, bool withlock = false) const;
        // DocString: FMTmodel::getoutputsfromperiods
        virtual std::map<std::string, std::vector<std::vector<double>>>getoutputsfromperiods(const std::vector<Core::FMToutput>& theoutputs,
            const int& firstperiod, const int& lastperiod, Core::FMToutputlevel level = Core::FMToutputlevel::standard) const;
        // DocString: FMTmodel::clone
        virtual std::unique_ptr<FMTmodel>clone() const;
        // DocString: FMTmodel::setparameter(const FMTintmodelparameters,const int&)
        virtual bool setparameter(const FMTintmodelparameters& key, const int& value);
        // DocString: FMTmodel::setparameter(const FMTdblmodelparameters,const double)
        virtual bool setparameter(const FMTdblmodelparameters& key, const double& value);
        // DocString: FMTmodel::setparameter(const FMTboolmodelparameters,const bool)
        virtual bool setparameter(const FMTboolmodelparameters& key, const bool& value);
        // DocString: FMTmodel::getparameter(const FMTintmodelparameters)
        int getparameter(const FMTintmodelparameters& key) const;
        // DocString: FMTmodel::getparameter(const FMTdblmodelparameters)
        double getparameter(const FMTdblmodelparameters& key) const;
        // DocString: FMTmodel::getparameter(const FMTboolmodelparameters)
        bool getparameter(const FMTboolmodelparameters& key) const;
        // DocString: FMTmodel::setcompresstime
        bool setcompresstime(const int& periodstart, const int& periodstop, const int& value);
        // DocString: FMTmodel::getcompresstime
        std::vector<int> getcompresstime() const;
        // DocString: FMTmodel::goalconstraints
        std::vector<Core::FMTconstraint>goalconstraints(double penalty = 999999) const;
        // DocString: FMTmodel::gettacticalconstraints
        std::vector<Core::FMTconstraint>gettacticalconstraints(double penalty = 999999, double scheduleweight = 999999, double objective = 0, double objectivefactor = 1.0) const;
        // DocString: FMTmodel::showparameters
        virtual void showparameters(const bool& showhelp = false)const;
        // DocString: FMTmodel::build
        virtual bool build(std::vector<Core::FMTschedule> schedules = std::vector<Core::FMTschedule>())
        {
            //Mettre message warning
            return false;
        }
        // DocString: FMTmodel::solve
        virtual bool solve()//Only for optimisation
        {
            //Mettre message warning
            return false;
        }
        // DocString: FMTmodel::isoptimal
        virtual bool isoptimal() const;
        // DocString: FMTmodel::getobjectivevalue
        virtual double getobjectivevalue() const;
    protected:
        // DocString: FMTmodel::parameters
        FMTmodelparameters parameters;
        // DocString: FMTmodel::area
        std::vector<Core::FMTactualdevelopment>area;
        // DocString: FMTmodel::themes
        std::vector<Core::FMTtheme>themes;
        // DocString: FMTmodel::actions
        std::vector<Core::FMTaction>actions;
        // DocString: FMTmodel::transitions
        std::vector<Core::FMTtransition>transitions;
        // DocString: FMTmodel::yields
        Core::FMTyields yields;
        // DocString: FMTmodel::lifespan
        Core::FMTlifespans lifespan;
        // DocString: FMTmodel::outputs
        std::vector<Core::FMToutput> outputs;
        // DocString: FMTmodel::constraints
        std::vector<Core::FMTconstraint>constraints;
        // DocString: FMTmodel::name
        std::string name;
        // DocString: FMTmodel::statictransitionthemes
        std::vector<size_t>statictransitionthemes;
        // DocString: FMTmodel::setdefaultobjects
        void setdefaultobjects();
        // DocString: FMTmodel::getbasemask
        Core::FMTmask getbasemask(std::vector<Core::FMTactualdevelopment> optionaldevelopments) const;
        // DocString: FMTmodel::getstatictransitionthemes
        std::vector<size_t>getstatictransitionthemes() const;
        // DocString: FMTmodel::getstaticpresolvethemes
        std::vector<Core::FMTtheme>getstaticpresolvethemes() const;
        void clearactionscache();
        void clearyieldcache();
        void cleartransitioncache();
        // DocString: FMTmodel::swap_ptr
        virtual void swap_ptr(const std::unique_ptr<FMTmodel>& rhs);
        // DocString: FMTmodel::setupschedulesforbuild
        std::vector<Core::FMTschedule>setupschedulesforbuild(const std::vector<Core::FMTschedule>& schedules) const;
        // DocString: FMTmodel::useactionserie
        bool useactionserie() const;
        // DocString: FMTmodel::getseriesmaxsize
        size_t getseriesmaxsize() const;
    private:
        // DocString: FMTmodel::save
        friend class boost::serialization::access;
        template<class Archive>
        void save(Archive& ar, const unsigned int version) const
        {
            ar& boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTobject>(*this));
            FMTobject::forcesave(ar, version);
            ar& BOOST_SERIALIZATION_NVP(parameters);
            ar& BOOST_SERIALIZATION_NVP(area);
            ar& BOOST_SERIALIZATION_NVP(themes);
            ar& BOOST_SERIALIZATION_NVP(actions);
            ar& BOOST_SERIALIZATION_NVP(transitions);
            ar& BOOST_SERIALIZATION_NVP(yields);
            ar& BOOST_SERIALIZATION_NVP(lifespan);
            ar& BOOST_SERIALIZATION_NVP(outputs);
            ar& BOOST_SERIALIZATION_NVP(constraints);
            ar& BOOST_SERIALIZATION_NVP(name);
        }
        // DocString: FMTmodel::load
        template<class Archive>
        void load(Archive& ar, const unsigned int version)
        {
            ar& boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTobject>(*this));
            FMTobject::forceload(ar, version);//get the object information for the global object
            ar& BOOST_SERIALIZATION_NVP(parameters);
            ar& BOOST_SERIALIZATION_NVP(area);
            ar& BOOST_SERIALIZATION_NVP(themes);
            ar& BOOST_SERIALIZATION_NVP(actions);
            ar& BOOST_SERIALIZATION_NVP(transitions);
            ar& BOOST_SERIALIZATION_NVP(yields);
            ar& BOOST_SERIALIZATION_NVP(lifespan);
            ar& BOOST_SERIALIZATION_NVP(outputs);
            ar& BOOST_SERIALIZATION_NVP(constraints);
            ar& BOOST_SERIALIZATION_NVP(name);
            //this->passinobject(*this);//Distribute global object to local object
        }
        BOOST_SERIALIZATION_SPLIT_MEMBER()
            // DocString: FMTmodel::validatelistmasks
            template<class T>
        void validatelistmasks(const Core::FMTlist<T>& container) const
        {
            try {
                for (const auto& listobject : container)
                {
                    std::string name = std::string(listobject.first);
                    Core::FMTtheme::validate(themes, name);
                }
            }
            catch (...)
            {
                _exhandler->raisefromcatch("", "FMTmodel::validatelistmasks", __LINE__, __FILE__);
            }
        }
        // DocString: FMTmodel::validatelistspec
        void validatelistspec(const Core::FMTspec& specifier) const;
        // DocString: FMTmodel::aggregateActions
        std::map<std::string, std::pair<std::string,Core::FMTmask>> aggregateActions(const std::vector<std::string>& p_ActionsMapping);
        // DocString: FMTmodel::aggregateTransitions
        void aggregateTransitions(const std::map<std::string, std::pair<std::string, Core::FMTmask>>& p_Filters);
        // DocString: FMTmodel::aggregateOutputs
        void aggregateOutputs(const std::map<std::string, std::pair<std::string, Core::FMTmask>>& p_Filters,
            std::vector<Core::FMToutput*>& p_Outputs);
        // DocString: FMTmodel::addNewMask
        Core::FMTmask addNewMask(const Core::FMTmask& p_incompleteMask);
        
        
 
    };
// DocString: FMTmodelcomparator
class FMTmodelcomparator
{
    // DocString: FMTmodelcomparator::model_name
    std::string model_name;
public:
    // DocString: FMTmodelcomparator(std::string)
    FMTmodelcomparator(std::string name);
    // DocString: FMTmodelcomparator::operator()
    bool operator()(const FMTmodel& model) const;
 
};
 
}
 
BOOST_CLASS_EXPORT_KEY(Models::FMTmodel)
 
#endif // FMTMODEL_H_INCLUDED