FMTSeModel.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
*/
 
#ifndef FMTSEM_Hm_included
#define FMTSEM_Hm_included
 
#include "FMTModel.h"
#include "FMTSpatialSchedule.h"
#include <boost/serialization/vector.hpp>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/export.hpp>
#include "FMTSpatialGraphs.h"
 
namespace Spatial
{
    template <typename T>
    class FMTLayer;
}
 
namespace Models
{
// DocString: FMTSeModel
class FMTEXPORT FMTSeModel : public FMTModel
    {
    public:
        // DocString: FMTSeModel()
        FMTSeModel();
        // DocString: ~FMTSeModel()
        virtual ~FMTSeModel() = default;
        // DocString: FMTSeModel(const FMTSeModel)
        FMTSeModel(const FMTSeModel& rhs);
        // DocString: FMTSeModel(const FMTModel, const FMTForest)
        FMTSeModel(const FMTModel& rhs,const Spatial::FMTForest& forest);
        // DocString: FMTSeModel(const FMTModel, const FMTForest)
        FMTSeModel(const FMTModel& rhs);
        // DocString: FMTSeModel::operator=
        FMTSeModel& operator = (const FMTSeModel& rhs);
        // DocString: FMTSeModel::getMapping
        Spatial::FMTForest getMapping() const;
        // DocString: FMTSeModel::getSpSchedule
        inline Spatial::FMTSpatialSchedule getSpSchedule() const
        {
            return m_BestSolution;
        }
        // DocString: FMTSeModel::getDisturbanceStats
        std::string getDisturbanceStats() const;
        // DocString: FMTSeModel::getSchedule
        std::vector<Core::FMTSchedule> getSchedule(bool withlock=false) const;
        // DocString: FMTSeModel::setInitialMapping
        bool setInitialMapping(const Spatial::FMTForest& forest);
        // DocString: FMTSeModel::logConstraintsInfeasibilities
        void logConstraintsInfeasibilities() const;
        // DocString: FMTSeModel::logConstraintsFactors
        void logConstraintsFactors() const;
        // DocString: FMTSeModel::preSolve
        virtual std::unique_ptr<FMTModel>preSolve(
            std::vector<Core::FMTActualDevelopment> optionaldevelopments = std::vector<Core::FMTActualDevelopment>()) const;
        // DocString: FMTSeModel::postSolve
        virtual void postSolve(const FMTModel& originalbasemodel);
        // DocString: FMTSeModel::getOutput
        virtual std::map<std::string, double> getOutput(const Core::FMTOutput& output,
            int period, Core::FMToutputlevel level = Core::FMToutputlevel::standard) const;
        // DocString: FMTSeModel::getOutput
        virtual Spatial::FMTLayer<double> getSpatialOutput(const Core::FMTOutput& output,int period) const;
        // DocString: FMTSeModel::getSolution
        virtual Core::FMTSchedule getSolution(int period, bool withlock = false) const;
 
        
        // DocString: FMTSeModel::clone
        virtual std::unique_ptr<FMTModel>clone() const;
        // DocString: FMTSeModel::getArea
        virtual std::vector<Core::FMTActualDevelopment>getArea(int period = 0, bool beforegrowanddeath = false) const;
        // DocString: FMTSeModel::getCopy
        virtual std::unique_ptr<FMTModel> getCopy(int period = 0) const;
        // DocString: FMTModel::getObjectiveValue
        virtual double getObjectiveValue() const;
        // DocString: FMTSeModel::getSchedules
        std::vector<Core::FMTSchedule> getSchedules(const Spatial::FMTSpatialSchedule& p_SpatialSchedule,
            bool withlock = false) const;
        // DocString: FMTSeModel::getSolutionStatus
        void getSolutionStatus(const Spatial::FMTSpatialSchedule& p_SpatialSchedule,
            double& p_Objective, double& p_PrimalInFeasibility,
            bool withsense = true, bool withfactorization = false, bool withspatial = true) const;
        // DocString: FMTSeModel::getConstraintEvaluation
        double getConstraintEvaluation(size_t p_Constraint) const;
        
    protected:
        // DocString: FMTSeModel::spschedule
        Spatial::FMTSpatialSchedule m_BestSolution;
        // DocString: FMTSeModel::FMTSpatialGraphs
        Spatial::FMTSpatialGraphs m_SpatialGraphs;
 
        // DocString: FMTSeModel::_getGlobalObjective
        double _getGlobalObjective(const Spatial::FMTSpatialSchedule& p_Schedule) const;
 
        // DocString: FMTSeModel::_getConstraintsValues
        std::vector<double> _getConstraintsValues(const Spatial::FMTSpatialSchedule& p_SpatialSchedule) const;
 
        // DocString: FMTSeModel::_doRefactorization
        void _doRefactorization(Spatial::FMTSpatialSchedule& p_SpatialSchedule) const;
        // DocString: FMTSeModel::_getNewSolution
        Spatial::FMTSpatialSchedule _getNewSolution(const Spatial::FMTSpatialSchedule& p_FromSolution) const;
        // DocString: FMTSeModel::greedyReferenceBuild
        std::map<std::string, double> greedyReferenceBuild(
            Spatial::FMTSpatialSchedule& p_SpatialSchedule,
            const Core::FMTSchedule& schedule,
            const size_t& randomiterations,
            unsigned int seed = 0,
            double tolerance = FMT_DBL_TOLERANCE,
            bool log = true) const;
        // DocString: FMTSeModel::_getConstraintFactor
        double _getConstraintFactor(size_t p_constraint, double p_GrossValue) const;
        // DocString: FMTSeModel::_isValidFactor
        bool _isValidFactor(double p_GrossValue)const;
    private:
        // DocString: FMTSeModel::Serialize
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar& boost::serialization::make_nvp("model", boost::serialization::base_object<FMTModel>(*this));
            //ar& BOOST_SERIALIZATION_NVP(m_BestSolution);
        }
        // DocString: FMTSeModel::swapPtr
        virtual void swapPtr(std::unique_ptr<FMTModel>& rhs);
        // DocString: FMTSeModel::_buildArea
        void _buildArea(const Spatial::FMTForest& p_Forest);
        // DocString: FMTSeModel::_buildGraphs
        void _buildGraphs(double p_cellSize);
        // DocString: FMTSeModel::_buildSolution
        void _buildSolution(const Spatial::FMTForest& p_Forest);
        // DocString: FMTSeModel::_copyGraphs
        void _copyGraphs(const Spatial::FMTSpatialGraphs& pToCopy);
        // DocString: FMTSeModel::_copySolution
        void _copySolution(const Spatial::FMTSpatialSchedule& pToCopy);
        // DocString: FMTSeModel::_getConstraintNumerator
        double _getConstraintNumerator(size_t p_constraint) const;
        static const double MAX_FACTOR;
        
    };
 
}
 
BOOST_CLASS_EXPORT_KEY(Models::FMTSeModel)
 
#endif // FMTSEM_Hm_included