FMToperatingareascheme.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 FMToperatingareascheme_H_INCLUDED
#define FMToperatingareascheme_H_INCLUDED
 
#include "FMToperatingarea.hpp"
#include <vector>
#include <map>
#include <memory>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/export.hpp>
#include "FMTgraph.hpp"
 
 
namespace Core
{
    class FMTmask;
}
 
namespace Models
{
    class FMTlpsolver;
}
 
 
namespace Heuristics
    {
    // DocString: FMToperatingareascheme
    class FMTEXPORT FMToperatingareascheme: public FMToperatingarea
        {
        // DocString: FMToperatingareascheme::serialize
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
            {
            ar & boost::serialization::make_nvp("operatingarea", boost::serialization::base_object<FMToperatingarea>(*this));
            ar & BOOST_SERIALIZATION_NVP(openingconstraints);
            ar & BOOST_SERIALIZATION_NVP(openingbinaries);
            ar & BOOST_SERIALIZATION_NVP(maximalschemesconstraint);
            ar & BOOST_SERIALIZATION_NVP(schemesperiods);
            ar & BOOST_SERIALIZATION_NVP(openingtime);
            ar & BOOST_SERIALIZATION_NVP(returntime);
            ar & BOOST_SERIALIZATION_NVP(repetition);
            ar & BOOST_SERIALIZATION_NVP(greenup);
            }
        // DocString: FMToperatingareascheme::openingconstraints
        std::vector<std::vector<int>>openingconstraints;
        // DocString: FMToperatingareascheme::openingbinaries
        std::vector<int>openingbinaries;
        // DocString: FMToperatingareascheme::maximalschemesconstraint
        int maximalschemesconstraint;
        // DocString: FMToperatingareascheme::schemesperiods
        std::vector<std::vector<int>>schemesperiods;
        // DocString: FMToperatingareascheme::openingtime
        size_t openingtime;
        // DocString: FMToperatingareascheme::returntime
        size_t returntime;
        // DocString: FMToperatingareascheme::repetition
        size_t repetition;
        // DocString: FMToperatingareascheme::greenup
        size_t greenup;
        // DocString: FMToperatingareascheme::startingperiod
        size_t startingperiod;
        // DocString: FMToperatingareascheme::threshold
        double threshold; 
        // DocString: FMToperatingareascheme::maxreturntime
        //between return time and maxreturntime for each closing
        size_t maxreturntime;
        // DocString: FMToperatingareascheme::rejectednodescid
        int rejectednodescid;
        // DocString: FMToperatingareascheme::getarea
        double getprimalarea(const double* primalsolution, const Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>& maingraph, const std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>& verticies) const;
        // DocString: FMToperatingareascheme::getbestschemeid
        size_t getbestschemeid(const double* primalsolution) const;
        // DocString: FMToperatingareascheme::generateschemes
        std::vector<std::vector<std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>>> generateschemes(const std::vector<std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>>& verticies);
        // DocString: FMToperatingareascheme::schemestoLP
        void schemestoLP(const std::vector<std::vector<std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>>>& schemes,
            const std::vector<std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>>& periodictargetednodes,
            const std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>& totalareaverticies,
            Models::FMTlpsolver& solver,
            const double* primalsolution,
            const Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>& maingraph, const std::vector<int>& actionIDS);
 
        // DocString: FMToperatingareascheme::getignoredverticies
        std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor> getignoredverticies(const std::vector<std::vector<std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>>>& schemes,
            const std::vector<std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>>& targetedperiodsverticies) const;
 
        // DocString: FMToperatingareascheme::schemestoperiods
        std::vector<std::vector<int>> schemestoperiods(const std::vector<std::vector<std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>>>& schemes, const Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>& maingraph) const;
        // DocString: FMToperatingareascheme::getrowsactivitysum
        double getrowsactivitysum(const std::vector<int>& rows, const double* dualsolution) const;
        // DocString: FMToperatingareascheme::isthresholdactivityrows
        bool isthresholdactivityrows(const std::vector<int>& rows, const double* dualsolution) const;
        // DocString: FMToperatingareascheme::fillpattern
        std::vector<double>fillpattern(const std::vector<double>& pattern, const int& startat) const;
        // DocString: FMToperatingareascheme::closenoactivity
        void closenoactivity(std::vector<double>& filleduppattern, const size_t& selected, const double* dualsolution) const;
        // DocString: FMToperatingareascheme::getmaxperiod
        int getmaxperiod() const;
        public:
            // DocString: FMToperatingareascheme::setreturntime
            void setreturntime(const size_t& minimalreturntime,const size_t& maximalreturntime);
            // DocString: FMToperatingareascheme::getthreshold
            double getthreshold() const;
            // DocString: FMToperatingareascheme::getopeningtime
            size_t getopeningtime() const;
            // DocString: FMToperatingareascheme::getminimalreturntime
            size_t getminimalreturntime() const;
            // DocString: FMToperatingareascheme::getrepetition
            size_t getrepetition() const;
            // DocString: FMToperatingareascheme::getmaximalreturntime
            size_t getmaximalreturntime() const;
            // DocString: FMToperatingareascheme::empty
            bool empty() const;
            // DocString: FMToperatingareascheme::getopeningbinaries
            const std::vector<int>& getopeningbinaries() const;
            // DocString: FMToperatingareascheme::getstartingperiod
            size_t getstartingperiod() const;
            // DocString: FMToperatingareascheme::getbinariessum
            double getbinariessum(const double* primalsolution) const;
            // DocString: FMToperatingareascheme::getactivitysum
            double getactivitysum(const double* dualsolution) const;
            // DocString: FMToperatingareascheme::getthresholdactivity
            bool isthresholdactivity(const double* dualsolution) const;
            // DocString: FMToperatingareascheme::getcommonbinairies
            std::map<int, std::vector<int>> getcommonbinairies(const FMToperatingareascheme& neighbor) const;
            // DocString: FMToperatingareascheme::getprimalsolutionindex
            size_t getprimalsolutionindex(const double* primalsolution) const;
            // DocString: FMToperatingareascheme::getdualsolutionindex
            bool getdualsolutionindex(const double* upperbound, size_t& locid) const;
            // DocString: FMToperatingareascheme::havepotentialsolution
            bool havepotentialsolution(const double* primalsolution) const;
            // DocString: FMToperatingareascheme::haveactivitysolution
            bool haveactivitysolution(const double* dualsolution) const;
            // DocString: FMToperatingareascheme::isallprimalbounded
            bool isallprimalbounded(const double* lowerbounds, const double* upperbounds) const;
            // DocString: FMToperatingareascheme::isalldualbounded
            bool isalldualbounded(const double* upperbounds) const;
            // DocString: FMToperatingareascheme::isprimalbounded
            bool isprimalbounded(const double* lowerbounds, const double* upperbounds) const;
            // DocString: FMToperatingareascheme::isdualbounded
            bool isdualbounded(const double* upperbounds) const;
            // DocString: FMToperatingareascheme::getpotentialprimalschemes
            std::vector<size_t>getpotentialprimalschemes(const double* primalsolution, const double* lowerbounds, const double* upperbounds,const std::vector<FMToperatingareascheme>& neighbors) const;
            // DocString: FMToperatingareascheme::getpotentialdualschemes
            std::vector<size_t>getpotentialdualschemes(const double* dualsolution, const double* upperbound, const std::vector<FMToperatingareascheme>& neighbors) const;
            // DocString: FMToperatingareascheme::getressourcestodelete
            void getressourcestodelete(std::vector<int>& colstodelete, std::vector<int>& rowstodelete) const; //Remove all variable and constraints related to the operating area from the solver
            // DocString: FMToperatingareascheme::pushbinaries
            void pushbinaries(std::vector<int>& targets) const;
            // DocString: FMToperatingareascheme::unboundallprimalschemes
            size_t unboundallprimalschemes(std::vector<int>& targets, std::vector<double>& bounds) const;
            // DocString: FMToperatingareascheme::unboundalldualschemes
            size_t unboundalldualschemes(std::vector<int>& targets, std::vector<double>& bounds) const;
            // DocString: FMToperatingareascheme::boundallprimalschemes
            size_t boundallprimalschemes(std::vector<int>& targets, std::vector<double>& bounds,double boundvalue = 1.0) const;
            // DocString: FMToperatingareascheme::boundalldualschemes
            size_t boundalldualschemes(std::vector<int>& targets, std::vector<double>& bounds) const;
            // DocString: FMToperatingareascheme::boundprimalscheme
            bool boundprimalscheme(std::vector<int>& targets, std::vector<double>& bounds, const size_t& schemeid) const; 
            // DocString: FMToperatingareascheme::unbounddualscheme
            bool unbounddualscheme(const double* rowactivities, std::vector<int>& targets, std::vector<double>& bounds, const size_t& schemeid, bool looseset=true) const;
            // DocString: FMToperatingareascheme::getprimalsolution
            std::vector<double> getprimalsolution(const double* primalsolution) const;
            // DocString: FMToperatingareascheme::getdualsolution
            std::vector<double> getdualsolution(const double* upperbounds, const double* dualsolution, bool& canbreakneighboring) const;
            // DocString: FMToperatingareascheme::getduallowerbounds
            std::vector<double> getduallowerbounds(const double* lowerbounds,const double* upperbounds) const;
            // DocString: FMToperatingareascheme::setconstraints
            void setconstraints(const std::vector<std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>>& verticies,
                const std::vector<Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>::FMTvertex_descriptor>& totalareaverticies,
                const Graph::FMTgraph<Graph::FMTvertexproperties, Graph::FMTedgeproperties>& graph,Models::FMTlpsolver& solver,
                const double* primalsolution,
                const std::vector<int>& actionIDS);
            // DocString: FMToperatingareascheme(const FMToperatingarea,const size_t, const size_t,const size_t,const size_t,const size_t)
            FMToperatingareascheme(const FMToperatingarea& oparea,const size_t& lopeningtime, const size_t& lreturntime, const size_t& lmaxreturntime,
                const size_t& lrepetition, const size_t& lgreenup,const size_t& lstartingperiod,double minimalarearatio=0.0);
            // DocString: FMToperatingareascheme()
            FMToperatingareascheme()=default;
            // DocString: FMToperatingareascheme(const FMToperatingarea)
            FMToperatingareascheme(const FMToperatingareascheme& rhs) = default;
            // DocString: FMToperatingareascheme::operator=
            FMToperatingareascheme& operator = (const FMToperatingareascheme& rhs)=default;
            // DocString: FMToperatingareascheme::fillboundsnvariables
            void fillboundsnvariables(const double* lowerb, const double* upperb, std::vector<int>& constraintstargets,std::vector<double>&bounds) const;
            // DocString: FMToperatingareascheme::operator==
            bool operator == (const FMToperatingareascheme& rhs) const;
            // DocString: FMToperatingareascheme::operator!=
            bool operator != (const FMToperatingareascheme& rhs) const;
            // DocString: ~FMToperatingareascheme()
            ~FMToperatingareascheme()=default;
            // DocString: FMToperatingareascheme::presolve
            FMToperatingareascheme presolve(const Core::FMTmask& selectedmask,const std::vector<Core::FMTtheme>&presolvedthemes) const;
            // DocString: FMToperatingareascheme::getnumberofscheme
            size_t getnumberofscheme() const;
            // DocString: FMToperatingareascheme::getnumberofsimplescheme
            size_t getnumberofsimplescheme() const;
            // DocString: FMToperatingareascheme::getrejectednodescid
            const int& getrejectednodescid() const;
            // DocString: FMToperatingareascheme::getschemesperiods
            const std::vector<std::vector<int>>& getopeningconstraints() const;
            // DocString: FMToperatingareascheme::maximalschemesconstraint
            const int& getmaximalschemesconstraint() const;
 
            const size_t& getgreenup() const { return greenup; };
 
        };
 
    // DocString: FMToperatingareaschemecomparator
    class FMToperatingareaschemecomparator
        {
            // DocString: FMToperatingareaschemecomparator::mask
            Core::FMTmask mask;
        public:
            // DocString: FMToperatingareaschemecomparator(const Core::FMTmask)
            FMToperatingareaschemecomparator(const Core::FMTmask& lmask);
            // DocString: FMToperatingareaschemecomparator::operator()
            bool operator()(const FMToperatingareascheme& oparea) const;
 
        };
 
    }
    BOOST_CLASS_EXPORT_KEY(Heuristics::FMToperatingareascheme)
#endif
#endif