FMTsamodel.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
*/
 
#ifndef FMTSAMODEL_H
#define FMTSAMODEL_H
 
#include "FMTsemodel.hpp"
#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
{
 
class FMTEXPORT FMTsamodel final: public FMTsemodel
    {
    // 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,
        ReBuilder = 2,
        AreaConflictDestrutor = 3,
        AdjacencyConflictDestrutor = 4,
        MoveCount = 5
    };
    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 TotalMoves;
    // DocString: FMTsamodel::CycleMoves
    mutable std::vector<FMTmovestats>CycleMoves;
    // DocString: FMTsamodel::LastGlobalObjectiveValue
    double LastGlobalObjectiveValue;
    // DocString: FMTsamodel::Generator
    mutable std::default_random_engine Generator;
    // DocString: FMTsamodel::CoolingSchedule
    std::unique_ptr<Spatial::FMTsaschedule> CoolingSchedule;
    // DocString: FMTsamodel::NotAcceptedMovesCount
    std::array<size_t, FMTsamove::MoveCount>NotAcceptedMovesCount;
    // DocString: FMTsamodel()
    FMTsamodel(const FMTsemodel& rhs);
    protected:
        // DocString: FMTspatialschedule::GetFromBindings
        std::vector<bool> GetFromBindings(const Spatial::FMTspatialschedule::actionbindings& bindingactions) const;
        // DocString: FMTsamodel::GetCycleMoves
        size_t GetCycleMoves() const;
        // DocString: FMTsamodel::GetAcceptedCycleMoves
        size_t GetAcceptedCycleMoves() const;
        // DocString: FMTsamodel::AllowDestruction
        bool AllowDestruction(const Spatial::FMTspatialschedule& actual, const Spatial::FMTspatialschedule::actionbindings& bindings) 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(const Spatial::FMTspatialschedule& actual, const Spatial::FMTspatialschedule& candidat) const;
        // DocString: FMTsamodel::DoLocalMove
        Spatial::FMTspatialschedule DoLocalMove(const Spatial::FMTspatialschedule& actual,
            const Spatial::FMTspatialschedule::actionbindings& bindings,
            const std::vector<Spatial::FMTcoordinate>* movable,
            boost::unordered_map<Core::FMTdevelopment, bool>* operability) 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::move
        Spatial::FMTspatialschedule Move(const Spatial::FMTspatialschedule& actual,
                        const Spatial::FMTspatialschedule::actionbindings& bindings,
                        const std::vector<Spatial::FMTcoordinate>*movable = nullptr,
                        boost::unordered_map<Core::FMTdevelopment, bool>*operability= nullptr) const;
        // DocString: FMTsamodel::warmup
        double Warmup(const Spatial::FMTspatialschedule& actual,
            const Spatial::FMTspatialschedule::actionbindings& bindings,
            const std::vector<Spatial::FMTcoordinate>*movable = nullptr,
            boost::unordered_map<Core::FMTdevelopment, bool>*operability = nullptr,
            double initprobability = 0.5,size_t iterations=10);
        // DocString: FMTsamodel::initialgrow
        void InitialGrow();
        // DocString: FMTsamodel::initialbuild
        void RandomBuild();
        // DocString: FMTsamodel::schedulesbuild
        void SchedulesBuild(const std::vector<Core::FMTschedule>&schedules);
        // DocString: FMTsamodel::swap_ptr
        virtual void swap_ptr(const std::unique_ptr<FMTmodel>& rhs);
        // DocString: FMTsamodel:GetLocalMoveSize
        size_t GetLocalMoveSize() 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();
    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;
        FMTsamodel();
        ~FMTsamodel();
        FMTsamodel(const FMTsamodel& rhs);
        FMTsamodel(const FMTmodel& rhs);
        FMTsamodel(const FMTmodel& rhs,const Spatial::FMTforest& forest);
        FMTsamodel& operator = (const FMTsamodel& rhs);
        // DocString: FMTsamodel::clone
        virtual std::unique_ptr<FMTmodel>clone() const final;
        
        Graph::FMTgraphstats buildperiod();
 
    };
}
 
BOOST_CLASS_EXPORT_KEY(Models::FMTsamodel)
 
#endif // FMTSAMODEL_H