FMTOperatingAreaScheme.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 FMToperatingareascheme_Hm_included
#define FMToperatingareascheme_Hm_included
 
#include "FMTOperatingArea.h"
#include <vector>
#include <map>
#include <memory>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/export.hpp>
#include "FMTGraph.hpp"
#include "FMTObject.h"
 
namespace Core
{
    class FMTMask;
}
 
namespace Models
{
    class FMTLpSolver;
}
 
 
namespace Heuristics
    {
    // DocString: FMTOperatingAreaScheme
    class FMTEXPORT FMTOperatingAreaScheme: public FMTOperatingArea, public Core::FMTObject
        {
        // 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>& vertices) 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>>& vertices);
        // 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>& totalareavertices,
            Models::FMTLpSolver& solver,
            const double* primalsolution,
            const Graph::FMTGraph<Graph::FMTVertexProperties, Graph::FMTEdgeProperties>& maingraph, const std::vector<int>& actionIDS);
 
        // DocString: FMTOperatingAreaScheme::getIgnoredVertices
        std::vector<Graph::FMTGraph<Graph::FMTVertexProperties, Graph::FMTEdgeProperties>::FMTvertex_descriptor> getIgnoredVertices(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>>& targetedperiodsvertices) 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, double tempThreshold = -1) 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::getCommonBinaries
            std::map<int, std::vector<int>> getCommonBinaries(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* p_primalsolution, const double* p_lowerbounds,
                const double* p_upperbounds,const std::vector<FMTOperatingAreaScheme>& p_neighbors) const;
            // DocString: FMTOperatingAreaScheme::getPotentialDualSchemes
            std::vector<size_t>getPotentialDualSchemes(const double* p_dualsolution, const double* p_upperbound,
                        const std::vector<FMTOperatingAreaScheme>& p_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>>& vertices,
                const std::vector<Graph::FMTGraph<Graph::FMTVertexProperties, Graph::FMTEdgeProperties>::FMTvertex_descriptor>& totalareavertices,
                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::getMaximalSchemesConstraint
            const int& getMaximalSchemesConstraint() const;
 
            // DocString: FMTOperatingAreaScheme::getGreenUp
            const size_t& getGreenUp() const { return greenup; };
        
        private:
            // DocString: FMTOperatingAreaScheme::_maxNearThresholdActivityRows
            double _maxNearThresholdActivityRows(const std::vector<int>& rows, const double* dualsolution) const;
            // DocString: FMTOperatingAreaScheme::_findIndexLocation
            size_t _findIndexLocation(int binary) const;
            // DocString: FMTOperatingAreaScheme::_addPotentialResults
            void _addPotentialResults(
                size_t indexlocation, 
                std::vector<size_t>& potentialindexes, 
                std::vector<double>& potentialValues,
                const double* dualsolution) const;
            // DocString: FMTOperatingAreaScheme::_checkDoubleIncludes
            static bool _checkDoubleIncludes(const std::vector<std::vector<int>>& openingconstraints);
        };
 
    // DocString: FMTOperatingAreaSchemeComparator
    class FMTOperatingAreaSchemeComparator
        {
        public:
            // DocString: FMTOperatingAreaSchemeComparator(const Core::FMTMask)
            FMTOperatingAreaSchemeComparator(const Core::FMTMask& lmask);
            // DocString: FMTOperatingAreaSchemeComparator::operator()
            bool operator()(const FMTOperatingAreaScheme& oparea) const;
 
        private:
            // DocString: FMTOperatingAreaSchemeComparator::m_mask
            Core::FMTMask m_mask;
        };
 
    }
    BOOST_CLASS_EXPORT_KEY(Heuristics::FMTOperatingAreaScheme)
#endif
#endif