FMTspatialschedule.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 FMTSPATIALSCHEDULE_H
#define FMTSPATIALSCHEDULE_H
 
#include "FMTlayer.hpp"
#include "FMTlinegraph.hpp"
#include "FMTeventcontainer.hpp"
#include "FMTbindingspatialaction.hpp"
#include "FMTspatialnodescache.hpp"
 
namespace Core {
    class FMTGCBMtransition;
    class FMToutput;
    class FMTmodel;
    class FMTconstraint;
    class FMTyields;
    class FMTaction;
    class FMTdevelopment;
}
 
 
 
namespace Spatial
{
class FMTforest;
enum  FMTspatialscheduletype
    {
        FMTcomplete = 1,
        FMTpartial = 2
    };
 
// DocString: FMTspatialschedule
class FMTEXPORT FMTspatialschedule : public FMTlayer<Graph::FMTlinegraph>
{
    mutable FMTspatialnodescache cache;
    FMTspatialscheduletype scheduletype;
    std::vector<double>constraintsfactor;
    public:
        typedef std::vector<std::vector<Spatial::FMTbindingspatialaction>> actionbindings;
        // DocString: FMTspatialschedule(FMTspatialschedule&&)
        FMTspatialschedule(FMTspatialschedule&& rhs) noexcept;
        // DocString: FMTspatialschedule()
        FMTspatialschedule();
        // DocString: FMTspatialschedule(const FMTforest)
        FMTspatialschedule(const FMTforest& initialmap);
        // DocString: ~FMTspatialschedule()
        virtual ~FMTspatialschedule() = default;
        // DocString: FMTspatialschedule(const FMTspatialschedule)
        FMTspatialschedule(const FMTspatialschedule& other);
        // DocString: FMTspatialschedule(const FMTspatialschedule,const std::vector<FMTcoordinate>)
        FMTspatialschedule(const FMTspatialschedule& other,
            const std::vector<FMTcoordinate>::const_iterator& firstcoord,
            const std::vector<FMTcoordinate>::const_iterator& endcoord);
        // DocString: FMTspatialschedule::=
        FMTspatialschedule& operator=(const FMTspatialschedule& rhs);
        // DocString: FMTspatialschedule::==
        bool operator == (const FMTspatialschedule& rhs)const;
        // DocString: FMTspatialschedule::!=
        bool operator != (const FMTspatialschedule& rhs)const;
        // DocString: FMTspatialschedule::empty
        bool empty() const {return mapping.empty();};
        // DocString: FMTspatialschedule::actperiod
        int actperiod() const;
        // DocString: FMTspatialschedule::copyfromselected(const FMTspatialschedule, const std::vector<size_t>)
        bool copyfromselected(const FMTspatialschedule& rhs, const std::vector<size_t>& selected);
        // DocString: FMTspatialschedule::swapfromselected
        bool swapfromselected(FMTspatialschedule& rhs, const std::vector<size_t>& selected);
        // DocString: FMTspatialschedule::getforestperiod
        FMTforest getforestperiod(const int& period,bool periodstart=false) const;
        // DocString: FMTspatialschedule::allow_action
        bool allow_action(const int& targetaction,const std::vector<Spatial::FMTbindingspatialaction>&bindingactions,const FMTcoordinate& location, const int& period) const;
       // DocString: FMTspatialschedule::getupdatedscheduling
       std::vector<std::set<Spatial::FMTcoordinate>>getupdatedscheduling(
                                            const Models::FMTmodel& model,  
                                             const std::vector<int>& actiontargets,
                                            boost::unordered_map<Core::FMTdevelopment, std::vector<bool>>& cachedaction,
                                          const std::vector<boost::unordered_set<Core::FMTdevelopment>>& scheduleoperabilities,
                                           bool schedule_only = true,
                                           std::vector<std::set<Spatial::FMTcoordinate>> original= std::vector<std::set<Spatial::FMTcoordinate>>(),
                                            std::vector<FMTcoordinate> updatedcoordinate= std::vector<FMTcoordinate>()) const;
 
       // DocString: FMTspatialschedule::evaluatespatialconstraint
       double evaluatespatialconstraint(const Core::FMTconstraint& spatialconstraint,
           const Models::FMTmodel& model/*, const FMTeventcontainer* subset = nullptr*/) const;
       // DocString: FMTspatialschedule::evaluatedistance
       /*double evaluatedistance(const FMTevent& eventof,
           const double& lowerdistancetoevent,
           const double& upperdistancetoevent,
           const int& period, const std::vector<bool>& actionsused,
           std::unordered_set<size_t>& relations,
           const std::vector<FMTeventcontainer::const_iterator>& events) const;*/
        // DocString: FMTspatialschedule::verifyspatialfeasability
        std::set<FMTcoordinate> verifyspatialfeasability(const int& targetaction,
            const std::vector<Spatial::FMTbindingspatialaction>& bindingactions,
            const int& period, const std::set<FMTcoordinate>& operables) const;
        // DocString: FMTspatialschedule::buildharvest
        FMTeventcontainer buildharvest(const double& target, const Spatial::FMTbindingspatialaction& targetaction, std::default_random_engine& generator, std::set<FMTcoordinate> mapping_pass,
            const int& previousperiod, const int& actionid, std::vector<FMTcoordinate>& operated) const;
        // DocString: FMTspatialschedule::operateevents
        double operateevents(const FMTeventcontainer& cuts,const Core::FMTaction& action, const int& action_id, const Core::FMTtransition& Transition,
                     const Core::FMTyields& ylds, const std::vector<Core::FMTtheme>& themes);
        // DocString: FMTspatialschedule::operatecoord
        void operatecoord(const FMTcoordinate& coord,const Core::FMTaction& action, const int& action_id, const FMTbindingspatialaction& bindingspaction, const Core::FMTtransition& Transition,
                     const Core::FMTyields& ylds, const std::vector<Core::FMTtheme>& themes);
        // DocString: FMTspatialschedule::grow
        void grow();
        // DocString: FMTspatialschedule::setnewperiod
        //void setnewperiod();
        // DocString: FMTspatialschedule::getschedules
        std::vector<Core::FMTschedule> getschedules(const std::vector<Core::FMTaction>& modelactions,bool withlock=false) const;
        // DocString: FMTspatialschedule::getgraphsoutputs
        std::vector<double> getgraphsoutputs(const Models::FMTmodel& model, const Core::FMTconstraint& constraint,
                                             const FMTspatialschedule*  friendlysolution = nullptr) const;
        // DocString: FMTspatialschedule::isbetterthan
        std::vector<int> isbetterthan(const FMTspatialschedule& newsolution,
                                     const Models::FMTmodel& model) const;
        // DocString: FMTspatialschedule::getconstraintevaluation
        double getconstraintevaluation(const Core::FMTconstraint&constraint,
            const Models::FMTmodel& model,const FMTspatialschedule* friendlysolution = nullptr) const;
        // DocString: FMTspatialschedule::getconstraintsvalues
        std::vector<double> getconstraintsvalues(const Models::FMTmodel& model,
            const FMTspatialschedule*   friendlysolution = nullptr) const;
        // DocString: FMTspatialschedule::getweightedfactors
        std::vector<double> getweightedfactors(const Models::FMTmodel& model,
            const FMTspatialschedule*   friendlysolution = nullptr) const;
        // DocString: FMTspatialschedule::getdualinfeasibility
        double getprimalinfeasibility(const std::vector<const Core::FMTconstraint*>& constraints,
            const Models::FMTmodel& model,const FMTspatialschedule* friendlysolution = nullptr, bool withfactorization = false) const;
        // DocString: FMTspatialschedule::logsolutionstatus
        void logsolutionstatus(const size_t& iteration, const double& objective, const double& primalinfeasibility) const;
        // DocString: FMTspatialschedule::getsolutionstatus
        void getsolutionstatus(double& objective, double& primalinfeasibility,const Models::FMTmodel& model,
            const FMTspatialschedule*   friendlysolution = nullptr, bool withsense = true, bool withfactorization = false,bool withspatial = true) const;
        // DocString: FMTspatialschedule::getglobalobjective
        double getglobalobjective(const Models::FMTmodel& model,
            const FMTspatialschedule*   friendlysolution = nullptr) const;
        // DocString: FMTspatialschedule::getobjectivevaluey
        double getobjectivevalue(const Core::FMTconstraint& constraint, const Models::FMTmodel& model,
            const FMTspatialschedule*   friendlysolution = nullptr,bool withsense = true) const;
        // DocString: FMTspatialschedule::setgraphfromcache
        void setgraphfromcache(const Graph::FMTlinegraph& graph, const Models::FMTmodel& model, const int&startingperiod, bool remove = true);
 
        // DocString: FMTspatialschedule::getpatchstats
        std::string getpatchstats(const std::vector<Core::FMTaction>& actions) const;
        // DocString: FMTspatialschedule::lastdistlayer
        FMTlayer<std::string> lastdistlayer(const std::vector<Core::FMTaction>& modelactions, const int& period) const;
        // DocString: FMTspatialschedule::getGCBMtransitions
        std::vector<Core::FMTGCBMtransition> getGCBMtransitions(FMTlayer<std::string>& stackedactions, const std::vector<Core::FMTaction>& modelactions, const std::vector<Core::FMTtheme>& classifiers, const int& period) const;
        // DocString: FMTspatialschedule::getpredictors
        std::vector<std::vector<Graph::FMTpredictor>> getpredictors(FMTlayer<int>& predictorids, const Models::FMTmodel& model, const std::vector<std::string>& yieldnames, const int& period,bool periodonevalues = false,bool withGCBMid = true) const;
        
        // DocString: FMTspatialschedule::eraselastperiod
        void eraselastperiod();
        // DocString: FMTspatialschedule::getbindingactions
        std::vector<Spatial::FMTbindingspatialaction> getbindingactions(const Models::FMTmodel& model, const int& period) const;
        // DocString: FMTspatialschedule::getbindingactionsbyperiod
        actionbindings getbindingactionsbyperiod(const Models::FMTmodel& model) const;
        // DocString: FMTspatialschedule::referencebuild
        std::map<std::string, double> referencebuild(const Core::FMTschedule& schedule, const Models::FMTmodel& model,
                                        const std::vector<boost::unordered_set<Core::FMTdevelopment>>& scheduleoperabilities,
                                        bool schedule_only = true,
                                        bool scheduleatfirstpass = true,
                                        unsigned int seed = 0);
        // DocString: FMTspatialschedule::greedyreferencebuild
        std::map<std::string, double> greedyreferencebuild(const Core::FMTschedule& schedule, const Models::FMTmodel& model,
                                        const size_t& randomiterations,
                                        unsigned int seed = 0,
                                        double tolerance = FMT_DBL_TOLERANCE,
                                        bool log = true);
        // DocString: FMTspatialschedule::randombuild
        Graph::FMTgraphstats randombuild(const Models::FMTmodel& model, std::default_random_engine& generator);
        // DocString: FMTspatialschedule::perturbgraph
        void perturbgraph(const FMTcoordinate& coordinate,const int& period,
            const Models::FMTmodel& model, std::default_random_engine& generator,
            const actionbindings& bindings);
        // DocString: FMTspatialschedule::isbetterbygroup
        bool isbetterbygroup(const FMTspatialschedule& rhs, const Models::FMTmodel& model) const;
        // DocString: FMTspatialschedule::swap
        void swap(FMTspatialschedule& rhs);
        // DocString: FMTspatialschedule::getmovablecoordinates
        std::vector<Spatial::FMTcoordinate>getmovablecoordinates(const Models::FMTmodel& model,const int& period,
                                                                                    const std::vector<Spatial::FMTcoordinate>* statics,
                                                                                    boost::unordered_map<Core::FMTdevelopment, bool>*operability = nullptr) const;
 
        // DocString: FMTspatialschedule::getperiodwithmaximalevents
        int getperiodwithmaximalevents(const std::vector<bool>& actions) const;
        // DocString: FMTspatialschedule::getareaconflictcoordinates
        std::vector<std::vector<Spatial::FMTcoordinate>>getareaconflictcoordinates(const actionbindings& bindingactions,const int& period,bool conflictonly=true) const;
        // DocString: FMTspatialschedule::getadjacencyconflictcoordinates
        std::vector<std::vector<Spatial::FMTcoordinate>>getadjacencyconflictcoordinates(const actionbindings& bindingactions,const int& period, bool conflictonly = true) const;
        // DocString: FMTspatialschedule::getstaticsmovablecoordinates
        std::vector<Spatial::FMTcoordinate>getstaticsmovablecoordinates(const Models::FMTmodel& model) const;
        // DocString: FMTspatialschedule::ispartial
        bool ispartial() const;
        // DocString: FMTspatialschedule::emptyevents
        bool emptyevents() const;
        // DocString: FMTspatialschedule::copyfrompartial
        void copyfrompartial(const FMTspatialschedule& rhs);
        // DocString: FMTspatialschedule::copyfrompartial
        void copyfrompartial(FMTspatialschedule& rhs);
        // DocString: FMTspatialschedule::setconstraintsfactor
        void setconstraintsfactor(const Models::FMTmodel& model,const std::vector<double>&factors);
        // DocString: FMTspatialschedule::needsrefactortorization
        bool needsrefactortorization(const Models::FMTmodel& model) const;
        // DocString: FMTspatialschedule::dorefactortorization
        void dorefactortorization(const Models::FMTmodel& model);
        // DocString: FMTspatialschedule::getconstraintsfactor
        std::vector<double> getconstraintsfactor() const;
        // DocString: FMTspatialschedule::getoutput
        std::map<std::string, std::vector<double>> getoutput(const Models::FMTmodel & model, const Core::FMToutput& output,
            const int& periodstart, const int& periodstop,
            Core::FMToutputlevel level = Core::FMToutputlevel::totalonly) const;
        // DocString: FMTspatialschedule::getoutput
        FMTlayer<double> getoutput(const Models::FMTmodel& model, const Core::FMToutput& output,const int& period) const;
        // DocString: FMTspatialschedule::getoutputbycoordinate
        std::vector<std::pair<FMTcoordinate, double>>getoutputbycoordinate(const Models::FMTmodel & model,
            const Core::FMToutput& output, const int& period) const;
        // DocString: FMTspatialschedule::postsolve
        void postsolve(const Core::FMTmaskfilter&  filter,const std::vector<Core::FMTaction>& presolveactions,const Models::FMTmodel& originalbasemodel);
    protected:
        // DocString: FMTspatialschedule::events
        FMTeventcontainer events;
        // DocString: FMTspatialschedule::getfromevents(const Core::FMTconstraint&, const std::vector<Core::FMTaction>&, const int&, const int&)
        std::vector<const Graph::FMTlinegraph*>getfromevents(const Core::FMTconstraint& constraint, const std::vector<Core::FMTaction>& actions, const int& start, const int& stop) const;
        // DocString: FMTspatialschedule::getfromevents(const Core::FMToutputnode&, const std::vector<Core::FMTaction>&, const int&)
        std::vector<FMTcoordinate>getfromevents(const Core::FMToutputnode& node, const std::vector<Core::FMTaction>& actions, const int& period) const;
        // DocString: FMTspatialschedule::getoutputfromgraph
        std::map<std::string,double> getoutputfromgraph(const Graph::FMTlinegraph& linegraph, const Models::FMTmodel & model,
            const Core::FMToutputnode& node, const double* solution,const int&period, const Core::FMTmask& nodemask,
            boost::unordered_map<Core::FMTmask, double>& nodecache, Core::FMToutputlevel level = Core::FMToutputlevel::totalonly) const;
 
        // DocString: FMTspatialschedule::setgraphcachebystatic
        void setgraphcachebystatic(const std::vector<FMTcoordinate>& coordinates, const Core::FMToutputnode& node) const;
        // DocString: FMTspatialschedule::getmaximalpatchsizes
        //std::vector<size_t>getmaximalpatchsizes(const std::vector<FMTspatialaction>& spactions) const;
        // DocString: FMTspatialschedule::inscheduleoperabilities
        bool inscheduleoperabilities(const std::vector<boost::unordered_set<Core::FMTdevelopment>>& scheduleoperabilities,
            Core::FMTdevelopment const* dev,const int& actionid, const Core::FMTaction& action) const;
        // DocString: FMTspatialschedule::getoutputfromnode
        std::vector<FMTlayer<Graph::FMTlinegraph>::const_iterator> getoutputfromnode(const Models::FMTmodel& model, const Core::FMToutputnode& node, const int& period) const;
    private:
        // DocString: FMTspatialschedule::evaluatespatialadjacency
        double evaluatespatialadjacency(
            const int& period,
            const size_t& greenup,
            const size_t& lowerlookup,
            const size_t& upperlookup,
            const bool& testlower,
            const bool& testupper,
            std::vector<FMTeventcontainer::const_iterator>& conflicts,
            boost::unordered_set<FMTeventrelation>& relations,
            const std::vector<bool>& actionused) const;
        
};
}
 
 
#endif // FMTSPATIALSCHEDULE_H