doxygen/html/FMTSaModel_8h_source.html

/*

Copyright (c) 2019 Gouvernement du Qu�bec


SPDX-License-Identifier: LiLiQ-R-1.1

License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt

*/


#ifndef FMTSAMODEL_H

#define FMTSAMODEL_H


#include "FMTSeModel.h"

#include <memory>

#include <vector>

#include <random>

#include <boost/serialization/vector.hpp>

#include <boost/serialization/serialization.hpp>

#include <boost/serialization/nvp.hpp>

#include <boost/serialization/export.hpp>


namespace Spatial

{

    class FMTForest;

    class FMTSaSchedule;

    class FMTExponentialSchedule;

}


namespace Models

{

#ifdef FMTWITHOSI

    class FMTLpModel;

#endif

// DocString: FMTSaModel

class FMTEXPORT FMTSaModel final: public FMTSeModel

    {

    public:

        // DocString: FMTSeModel::logMovesReport

        void logMovesReport() const;

        // DocString: FMTSaModel::isProvenOptimal

        bool isProvenOptimal() const;

        // DocString: FMTSaModel::initialSolve

        bool initialSolve();

        // DocString: FMTSaModel::build

        virtual bool build(std::vector<Core::FMTSchedule> schedules = std::vector<Core::FMTSchedule>());

        // DocString: FMTSaModel::solve

        virtual bool solve();

        // DocString: FMTSaModel::preSolve

        virtual std::unique_ptr<FMTModel>preSolve(std::vector<Core::FMTActualDevelopment> optionaldevelopments = std::vector<Core::FMTActualDevelopment>()) const;

        // DocString: FMTSaModel::getCopy

        virtual std::unique_ptr<FMTModel> getCopy(int period = 0) const;

        // DocString: FMTSaModel()

        FMTSaModel()=default;

        // DocString: ~FMTSaModel()

        ~FMTSaModel();

        // DocString: FMTSaModel(const FMTSaModel)

        FMTSaModel(const FMTSaModel& rhs);

        // DocString: FMTSaModel(const FMTModel)

        FMTSaModel(const FMTModel& rhs);

        // DocString: FMTSaModel(const FMTModel, const FMTForest)

        FMTSaModel(const FMTModel& rhs, const Spatial::FMTForest& forest);

        // DocString: FMTSaModel::operator=

        FMTSaModel& operator = (const FMTSaModel& rhs);

        // DocString: FMTSaModel::clone

        virtual std::unique_ptr<FMTModel>clone() const final;


        // DocString: FMTSaModel::buildPeriod

        Graph::FMTGraphStats buildPeriod();

    protected:

        // DocString: FMTSaModel::swapPtr

        virtual void swapPtr(std::unique_ptr<FMTModel>& rhs);

    private:

    // DocString: FMTSaModel::Serialize

    friend class boost::serialization::access;

    template<class Archive>

    void serialize(Archive& ar, const unsigned int version)

    {

        ar& boost::serialization::make_nvp("semodel", boost::serialization::base_object<FMTSeModel>(*this));

    }

    enum FMTsamove

    {

        Local = 1,

        AreaConflictDestrutor = 2,

        AdjacencyConflictDestrutor = 3,

        GroupsConflictDestructor = 4,

        EventsSpread = 5,

        //ReBuilder = 7,

        MoveCount = 6

    };

    // DocString: FMTSaModel::getMovesName

    static std::string getMovesName(FMTsamove p_move);

    class FMTMoveStats

        {

        public:

            FMTMoveStats() = default;

            FMTMoveStats(const FMTMoveStats& rhs) = default;

            FMTMoveStats& operator=(const FMTMoveStats& rhs) = default;

            // DocString: FMTSaModel::FMTMoveStats::MoveType

            //The move done

            FMTsamove MoveType;

            // DocString: FMTSaModel::FMTMoveStats::MoveSize

            //Number of element changed

            size_t MoveSize;

            // DocString: FMTSaModel::FMTMoveStats::ObjectiveImpact

            //The amount of objective change due to the move

            double ObjectiveImpact;

            // DocString: FMTSaModel::FMTMoveStats::Accepted

            //If the move was Accepted

            bool Accepted;

        };

    // DocString: FMTSaModel::totalMoves

    size_t m_TotalMoves;

    // DocString: FMTSaModel::cycleMoves

    mutable std::vector<FMTMoveStats>m_CycleMoves;

    // DocString: FMTSaModel::coolingSchedule

    std::unique_ptr<Spatial::FMTSaSchedule>m_CoolingSchedule;

    // DocString: FMTSaModel::notAcceptedMovesCount

    std::array<size_t, FMTsamove::MoveCount>m_NotAcceptedMovesCount;

    // DocString: FMTSaModel::m_BestObjective

    double m_BestObjective;

    // DocString: FMTSaModel(const FMTSeModel)

    FMTSaModel(const FMTSeModel& rhs);

    // DocString: FMTSaModel::_doWriteDisturbances

    bool _doWriteDisturbances() const;

    // DocString: FMTSaModel::_writeDisturbances

    void _writeDisturbances() const;

        // DocString: FMTSaModel::getFromBindings

        std::vector<bool> _getFromBindings(const Spatial::FMTSpatialSchedule::actionbindings& bindingactions, bool adjacency = false) const;

        // DocString: FMTSaModel::getCycleMoves

        size_t _getCycleMoves() const;

        // DocString: FMTSaModel::getAcceptedCycleMoves

        size_t _getAcceptedCycleMoves() const;

        // DocString: FMTSaModel::allowDestruction

        bool _allowAreaDestruction(const Spatial::FMTSpatialSchedule& actual, const Spatial::FMTSpatialSchedule::actionbindings& bindings) const;

        // DocString: FMTSaModel::_allowAdjacencyDestruction

        bool _allowAdjacencyDestruction(const Spatial::FMTSpatialSchedule& actual, const Spatial::FMTSpatialSchedule::actionbindings& bindings) const;

        // DocString: FMTSaModel::_allowGroupDestruction

        bool _allowGroupDestruction(const Spatial::FMTSpatialSchedule& p_actual) const;

        // DocString: FMTSaModel::_allowEventsSpread

        bool _allowEventsSpread(const Spatial::FMTSpatialSchedule& p_actual) const;

        // DocString: FMTSaModel::allowMove

        bool _allowMove(const FMTsamove& move) const;

        // DocString: FMTSaModel::allowAnyMove

        bool _allowAnyMove() const;

        // DocString: FMTSaModel::getAMove

        FMTsamove _getAMove(const Spatial::FMTSpatialSchedule& actual, const Spatial::FMTSpatialSchedule::actionbindings& bindings) const;

        // DocString: FMTSaModel::evaluate

        bool _isBetter(double p_candidatObjective) const;

        // DocString: FMTSaModel::doLocalMove

        Spatial::FMTSpatialSchedule _doLocalMove(const Spatial::FMTSpatialSchedule& actual,

            const Spatial::FMTSpatialSchedule::actionbindings& bindings) const;

        // DocString: FMTSaModel::doConflictDestruction

        Spatial::FMTSpatialSchedule _doConflictDestruction(const Spatial::FMTSpatialSchedule& actual,

            const Spatial::FMTSpatialSchedule::actionbindings& bindings,

           std::vector<std::vector<Spatial::FMTCoordinate>> selectionpool, const int& period) const;

       // DocString: FMTSaModel::doEventsAreaConflictDestrutorMove

        Spatial::FMTSpatialSchedule _doEventsAreaConflictDestrutorMove(const Spatial::FMTSpatialSchedule& actual,

            const Spatial::FMTSpatialSchedule::actionbindings& bindings) const;

        // DocString: FMTSaModel::doEventsAdjacencyConflictDestrutorMove

        Spatial::FMTSpatialSchedule _doEventsAdjacencyConflictDestrutorMove(const Spatial::FMTSpatialSchedule& actual,

            const Spatial::FMTSpatialSchedule::actionbindings& bindings) const;

        // DocString: FMTSaModel::doGroupsConflictDestrutorMove

        Spatial::FMTSpatialSchedule _doGroupsConflictDestrutorMove(const Spatial::FMTSpatialSchedule& p_actual) const;

        // DocString: FMTSaModel::_doEventsSpread

        Spatial::FMTSpatialSchedule _doEventsSpread(const Spatial::FMTSpatialSchedule& p_actual) const;


        // DocString: FMTSaModel::move

        Spatial::FMTSpatialSchedule _move(const Spatial::FMTSpatialSchedule& actual,

                        const Spatial::FMTSpatialSchedule::actionbindings& bindings) const;

        // DocString: FMTSaModel::warmup

        double _warmup(const Spatial::FMTSpatialSchedule& actual,

            const Spatial::FMTSpatialSchedule::actionbindings& bindings);

        // DocString: FMTSaModel::initialgrow

        void _initialGrow();

        // DocString: FMTSaModel::initialbuild

        void _randomBuild();

        // DocString: FMTSaModel::schedulesbuild

        void _schedulesBuild(const std::vector<Core::FMTSchedule>&schedules);

        // DocString: FMTSaModel::_getLocalMoveSize

        size_t _getLocalMoveSize() const;

        // DocString: FMTSaModel::_getMaximalMoveSize

        size_t _getMaximalMoveSize(size_t p_MaxSize) const;

        // DocString: FMTSaModel::_getRandomMoveSize

        size_t _getRandomMoveSize(size_t p_MaxSize) const;

        // DocString: FMTSaModel::getRebuild

        Spatial::FMTSpatialSchedule _getRebuild(const Spatial::FMTSpatialSchedule& actual) const;

        // DocString: FMTSaModel::isCycleProvenOptimal

        bool _isCycleProvenOptimal() const;

        // DocString: FMTSaModel::dofactorization

        void _doFactorization();

        // DocString: FMTSaModel::logSolutionStatus

        void _logSolutionStatus() const;

        // DocString: FMTSaModel::logTemperatureStatus

        void _logCycleStatus() const;

        // DocString: FMTSaModel::coolDown

        void _coolDown();

        // DocString: FMTSaModel::updateFailedMoveCount

        void _UpdateFailedMoveCount();


        // DocString: FMTSaModel::_GetSchedules

        std::vector<Core::FMTSchedule>_GetSchedules(const Spatial::FMTSpatialSchedule& p_SpatialSchedule, bool withlock) const;


        #ifdef FMTWITHOSI

            // DocString: FMTSaModel::_getRandomLpModel

            Models::FMTLpModel _getRandomLpModel(const Spatial::FMTSpatialSchedule& p_SpatialSchedule) const;

        #endif


        // DocString: FMTSaModel::_setBestSolutionTo

        void _setBestSolutionTo(Spatial::FMTSpatialSchedule& p_NewBestSolution,

                                double p_ObjectiveValue);


        // DocString: FMTSaModel::_getConstraintsStats

        void _getConstraintsStats(const Spatial::FMTSpatialSchedule& p_NewBestSolution,double& p_Objective,

                                 double& p_SpatialRatio, double& p_InventoryRatio, double& p_TotalRatiom,

                                 double& p_PrimalInf) const;


        // DocString: FMTSaModel::_resetTabouMoves

        void _resetTabouMoves();


        // DocString: FMTSaModel::_getNonTabouMoves

        std::vector<FMTsamove> _getNonTabouMoves() const;


        // DocString: FMTSaModel::_allowMove

        bool _allowMove(FMTsamove p_move, const Spatial::FMTSpatialSchedule& p_actual,

            const Spatial::FMTSpatialSchedule::actionbindings& p_bindings) const;


    };

}


BOOST_CLASS_EXPORT_KEY(Models::FMTSaModel)


#endif // FMTSAMODEL_H

FMTSeModel.h

FMTEXPORT
#define FMTEXPORT
Definition: FMTutility.h:125

Models::FMTLpModel
Type III LP forest planning model, with the graph divided per period.
Definition: FMTLpModel.h:54

Models::FMTModel
Base class for the different models in FMT.
Definition: FMTModel.h:62

Models::FMTSaModel
Area restricted model (ARM) using the simulated annealing meta-heuristic to solve the spatial optimiz...
Definition: FMTSaModel.h:40

Models::FMTSaModel::isProvenOptimal
bool isProvenOptimal() const
Return true if the solution is optimal based on the termination criteria.

Models::FMTSaModel::clone
virtual std::unique_ptr< FMTModel > clone() const final
Get a clone of the FMTSaModel.

Models::FMTSaModel::FMTSaModel
FMTSaModel(const FMTSaModel &rhs)
Copy constructor for FMTSaModel.

Models::FMTSaModel::initialSolve
bool initialSolve()
Try to solve the model from a cold start.

Models::FMTSaModel::FMTSaModel
FMTSaModel(const FMTModel &rhs)
Construct a FMTSaModel from a FMTModel, using the parent as argument.

Models::FMTSaModel::build
virtual bool build(std::vector< Core::FMTSchedule > schedules=std::vector< Core::FMTSchedule >())
Try to build the spatial schedule from a schedule if one is provided, otherwise randomly build the mo...

Models::FMTSaModel::getCopy
virtual std::unique_ptr< FMTModel > getCopy(int period=0) const
Return a copy of the FMTModel for the selected period.

Models::FMTSaModel::FMTSaModel
FMTSaModel(const FMTModel &rhs, const Spatial::FMTForest &forest)
Construct a FMTSaModel from a FMTModel and a forest.

Models::FMTSaModel::~FMTSaModel
~FMTSaModel()
Destructor for FMTSaModel.

Models::FMTSaModel::FMTSaModel
FMTSaModel()=default
Default constructor for FMTSaModel.

Models::FMTSaModel::solve
virtual bool solve()
Call initialSolve on the solver.

Models::FMTSaModel::logMovesReport
void logMovesReport() const
Log the moves report.

Models::FMTSaModel::preSolve
virtual std::unique_ptr< FMTModel > preSolve(std::vector< Core::FMTActualDevelopment > optionaldevelopments=std::vector< Core::FMTActualDevelopment >()) const
Return a presolved copy of the model using a vector of developments and the actual transitions,...

Models::FMTSeModel
Abstract class for spatially explicit models, parent of FMTSesModel and FMTSaModel.
Definition: FMTSeModel.h:33

Spatial::FMTForest
Spatially referenced layer of Core::FMTDevelopment representing the forest.
Definition: FMTForest.h:33

Spatial::FMTSpatialSchedule
Map containing a line graph for each cell, representing the stand, the action and the transition at e...
Definition: FMTSpatialSchedule.h:50

Spatial::FMTSpatialSchedule::actionbindings
std::vector< std::vector< Spatial::FMTBindingSpatialAction > > actionbindings
Definition: FMTSpatialSchedule.h:52

Graph
Definition: FMTAreaParser.h:35

Models
Namespace containing all enumerator and classes used to construct or manipulate the different type of...
Definition: FMTAreaParser.h:54

Spatial
Definition: FMTAreaParser.h:40

boost
Definition: FMTAction.h:463

std
STL namespace.