FMToperatingareascheduler.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 FMToperatingareascheduler_H_INCLUDED
#define FMToperatingareascheduler_H_INCLUDED
 
#include "FMTmask.hpp"
#include "FMToperatingareascheme.hpp"
#include "FMTlpheuristic.hpp"
 
 
 
 
#include <random>
#include <memory>
#include <map>
#include <vector>
//#include <chrono>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/export.hpp>
 
 
namespace Graph
{
    template<class T1, class T2>
    class FMTgraph;
}
 
namespace Models
{
    class FMTmodel;
}
 
namespace Core
{
    class FMToutputnode;
    class FMTtimeyieldhandler;
    class FMToutput;
}
 
 
namespace Heuristics
{
    // DocString: FMToperatingareascheduler
    class FMTEXPORT FMToperatingareascheduler : public FMTlpheuristic
    {
        // DocString: FMToperatingareaheuristic::save
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar & boost::serialization::make_nvp("lpsolve", boost::serialization::base_object<FMTlpheuristic>(*this));
            ar & BOOST_SERIALIZATION_NVP(operatingareas);
            ar & BOOST_SERIALIZATION_NVP(adjacencyconstraints);
            ar & BOOST_SERIALIZATION_NVP(proportionofset);
            ar & BOOST_SERIALIZATION_NVP(userandomness);
            ar & BOOST_SERIALIZATION_NVP(useprimal);
        }
        // DocString: FMToperatingareascheduler::operatingareas
        std::vector<FMToperatingareascheme>operatingareas;
        // DocString: FMToperatingareascheduler::adjacencyconstraints
        std::map<std::pair<Core::FMTmask, Core::FMTmask>, std::vector<int>>adjacencyconstraints;
        // DocString: FMToperatingareascheduler::proportionofset
        double proportionofset;
        // DocString: FMToperatingareascheduler::userandomness
        bool userandomness;
        // DocString: FMToperatingareascheduler::useprimal
        bool useprimal;
        // DocString: FMToperatingareascheduler::setoperatingareasconstraints
        void setoperatingareasconstraints(const Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>& maingraph,
            const Models::FMTmodel& model,
            const Core::FMToutputnode& target);
        // DocString: FMToperatingareascheduler::setadjacencyconstraints
        bool setadjacencyconstraints();
        // DocString: FMToperatingareascheduler::setdraw
        std::vector<std::vector<FMToperatingareascheme>::const_iterator> setdraw();
        // DocString: FMToperatingareascheduler::draw
        std::vector<std::vector<FMToperatingareascheme>::const_iterator> draw(std::vector<std::vector<FMToperatingareascheme>::const_iterator>& oparea);
        // DocString: FMToperatingareascheduler::setbounds
        size_t setbounds(const std::vector<std::vector<FMToperatingareascheme>::const_iterator>& tobound,const std::vector<int>& schemestoskip=std::vector<int>(), bool keeploose=true);
        // DocString: FMToperatingareascheduler::selectscheme
        size_t selectscheme(std::vector<size_t>& potentialschemes, const int& schemetoskip) const;
        // DocString: FMToperatingareascheduler::getbounds
        bool getbounds(const std::vector<FMToperatingareascheme>::const_iterator& operatingareaiterator,
            std::vector<int>& targeteditems,std::vector<double>& bounds, const bool& boundall, const size_t& schemeid=0,bool keeploose=true) const;
        // DocString: FMToperatingareascheduler::unboundall
        void unboundall(bool atprimal = false);
        // DocString: FMToperatingareascheduler::unbound
        void unbound(const std::vector<std::vector<FMToperatingareascheme>::const_iterator>& tounbound,bool atprimal = false);
        // DocString: FMToperatingareascheduler::closeprimalbounds
        void closeprimalbounds();
        // DocString: FMToperatingareascheduler::setallinteger
        void setallinteger();
        // DocString: FMToperatingareascheduler::resolvemodel
        int resolvemodel();
        // DocString: FMToperatingareascheduler::clearrowcache
        void clearrowcache();
        // DocString: FMToperatingareascheduler::getsolutionindexes
        /*
        Return the scheme index which is bounded for each operatingareascheme pass to the function in the same order.
        */
        std::vector<int> getsolutionindexes(const std::vector<std::vector<FMToperatingareascheme>::const_iterator>& opareaits) const;
        // DocString: FMToperatingareascheduler::getthreadid
        /*
        Return thread id to log it into functions greedypass and initialsove
        */
        std::string getthreadid() const;
        // DocString: FMToperatingareascheduler::completeinitialsolution
        bool completeinitialsolution();
        // DocString: FMToperatingareascheduler::gotrejectednodes
        bool gotrejectednodes() const;
        // DocString: FMToperatingareascheduler::resetbasegreedysolution
        void resetbasegreedysolution(const std::vector<std::vector<FMToperatingareascheme>::const_iterator>& selected,
                                    const std::vector<int>& oldschemeid,
                                    const std::vector<int>& oldconstraints,
                                    const std::vector<double>& oldbounds);
        // DocString: FMToperatingareascheduler::releasegreedysolution
        bool releasegreedysolution(const std::vector<std::vector<FMToperatingareascheme>::const_iterator>& selected,
            std::vector<int>& oldconstraints,
            std::vector<double>& oldbounds);
        // DocString: FMToperatingareascheduler::greedymovesolution
        bool greedymovesolution(const std::vector<std::vector<FMToperatingareascheme>::const_iterator>& selected,
                                const std::vector<int>& oldschemeid);
        // DocString: FMToperatingareascheduler::setfordualinitialsolve
        void setfordualinitialsolve();
        // DocString: FMToperatingareascheduler::initialmovesolution
        int initialmovesolution(const std::vector<std::vector<FMToperatingareascheme>::const_iterator>& selected);
        // DocString: FMToperatingareascheduler::resetbaseinitialsolution
        void resetbaseinitialsolution();
    public:
        // DocString: FMToperatingareascheduler::generateinitialproportionofset
        /*
        Try to calculate a good proportion of set for the initialsolve...if anything goes wrong it will be 0.25 If more complexity is
        detected using the FMToperatingareascheme getnumberofscheme vs the getnumberofsimplescheme it will get the difference and use a factor of 0.00025
        to decrease in a linear fashion the propotion of set to a minimum of 0.01.
        */
        double generateinitialproportionofset() const;
        // DocString: FMToperatingareascheduler::empty
        bool empty() const;
        // DocString: FMToperatingareascheduler::initialsolve
        bool initialsolve() final;
        // DocString: FMToperatingareascheduler::branchnboundsolve
        bool branchnboundsolve() final;
        // DocString: FMToperatingareascheduler::greedypass
        bool greedypass(const double& initsol, const unsigned int& iteration) final;
        // DocString: FMToperatingareascheduler::setasrandom
        void setasrandom();
        // DocString: FMToperatingareascheduler::setasprimal
        void setasprimal();
        // DocString: FMToperatingareascheduler::setproportionofset
        void setproportionofset(const double& proportion);
        // DocString: FMToperatingareascheduler::getsolution
        std::vector<Core::FMTtimeyieldhandler> getsolution( const std::string& yldname) const;
        // DocString: FMToperatingareascheduler::getlevelsolution
        std::vector<Core::FMToutput>getlevelsolution(const std::string& outputname,const std::string& aggregate,int outputid) const;
        // DocString: FMToperatingareascheduler(const std::vector<FMToperatingarea>,const Graph::FMTgraph,const Models::FMTmodel,const Core::FMToutputnode,std::shared_ptr<OsiSolverInterface>,const Models::FMTsolverinterface,size_t lseed,double proportionofset,bool userandomness,bool copysolver)
        FMToperatingareascheduler(const std::vector<FMToperatingareascheme>& loperatingareas,
            const Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>& maingraph,
            const Models::FMTmodel& model,
            const Core::FMToutputnode& target,
            Models::FMTlpsolver& basesolve, size_t lseed = 0,
            double proportionofset = 0.25, bool userandomness = false, bool copysolver = true);
        // DocString: FMToperatingareascheduler()
        FMToperatingareascheduler()=default;
        // DocString: FMToperatingareascheduler(const FMToperatingareaheuristic&)
        FMToperatingareascheduler(const FMToperatingareascheduler& rhs);
        // DocString: FMToperatingareascheduler(const FMToperatingareaheuristic&&)
        FMToperatingareascheduler(FMToperatingareascheduler&& rhs)=default;
        // DocString: FMToperatingareascheduler::operator=
        FMToperatingareascheduler& operator = (const FMToperatingareascheduler& rhs);
        // DocString: FMToperatingareascheduler::isfeasible
        ~FMToperatingareascheduler();
    };
}
BOOST_CLASS_EXPORT_KEY(Heuristics::FMToperatingareascheduler)
#endif
#endif