FMTNssModel.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 FMTNSSMODEL_H
#define FMTNSSMODEL_H
 
#ifdef FMTWITHOSI
 
#include "FMTSrModel.h"
#include <sstream>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/export.hpp>
#include <random>
 
 
namespace Models
{
    // DocString: FMTNssModel
    class FMTEXPORT FMTNssModel : public FMTSrModel
    {
        public:
            // DocString: FMTNssModel()
            FMTNssModel();
            // DocString: ~FMTNssModel()
            ~FMTNssModel()=default;
            // DocString: FMTNssModel(const FMTNssModel&)
            FMTNssModel(const FMTNssModel& rhs);
            // DocString: FMTNssModel::operator=
            FMTNssModel& operator=(const FMTNssModel& rhs) = default;
            // DocString: FMTNssModel(const FMTModel&,unsigned int)
            FMTNssModel(const FMTModel& rhs, unsigned int seed);
            
            // DocString: FMTNssModel(FMTNssModel&&)
            FMTNssModel(FMTNssModel&& rhs)=default;
            // DocString: FMTNssModel::operator=(FMTNssModel&& rhs) 
            FMTNssModel& operator =(FMTNssModel&& rhs) =default;
            // DocString: FMTNssModel::setParameter(const FMTintmodelparameters,const int&)
            virtual bool setParameter(const FMTintmodelparameters& p_key, const int& p_value);
            // DocString: FMTNssModel::simulate
            void simulate();
            // DocString: FMTNssModel::preSolve
            virtual std::unique_ptr<FMTModel>preSolve(std::vector<Core::FMTActualDevelopment> optionaldevelopments = std::vector<Core::FMTActualDevelopment>()) const;
            // DocString: FMTNssModel::clone
            virtual std::unique_ptr<FMTModel>clone() const;
            // DocString: FMTModel::build
            virtual bool build(std::vector<Core::FMTSchedule> schedules=std::vector<Core::FMTSchedule>());
            // DocString: FMTModel::solve
            virtual bool solve()
            {
                return true;
            }
            // DocString: FMTNssModel::setParameter(const FMTboolmodelparameters, const bool)
            bool setParameter(const FMTboolmodelparameters& key, const bool& value) override;
            // DocString: FMTNssModel::getCopy
            virtual std::unique_ptr<FMTModel> getCopy(int period = 0) const;
        private:
            // DocString: FMTNssModel::save
            friend class boost::serialization::access;
            template<class Archive>
            void save(Archive& ar, const unsigned int version) const
            {
                ar& boost::serialization::make_nvp("model", boost::serialization::base_object<FMTSrModel>(*this));
 
            }
            // DocString: FMTNssModel::load
            template<class Archive>
            void load(Archive& ar, const unsigned int version)
            {
                ar& boost::serialization::make_nvp("model", boost::serialization::base_object<FMTSrModel>(*this));
 
            }
            BOOST_SERIALIZATION_SPLIT_MEMBER()
            // DocString: FMTNssModel::constraintsToTarget
            std::vector<const Core::FMTOutput*> constraintsToTarget(std::vector<double>& p_targets, const int& p_period);
            // DocString: FMTNssModel::gotOutputForDev
            bool gotOutputForDev(const Core::FMTDevelopment& p_development,
                                const std::vector<const Core::FMTOutput*>& p_outputs,
                                const std::set<size_t>& p_outputIds) const;
            // DocString: FMTNssModel::getFirstOperable
            std::pair<size_t, const Core::FMTAction*> getFirstOperable(const Core::FMTDevelopment& development,
                std::vector<std::vector<const Core::FMTAction*>> targets,
                const std::vector<const Core::FMTOutput*>& alloutputs) const;
            // DocString: FMTNssModel::getActionsTargets
            std::vector<std::set<size_t>> getActionsTargets(const std::vector<const Core::FMTOutput*>& p_allOutputs) const;
            // DocString: FMTNssModel::updateOutputs
            double updateOutputs(const Core::FMTDevelopment& p_development,
                                const std::vector<Core::FMTDevelopmentPath>& p_paths,
                                const int& p_action, const double& p_devArea,
                                std::vector<double>& p_targets, std::vector<std::set<size_t>>& p_actionsoutputs,
                                const std::vector<const Core::FMTOutput*>& p_allOutput) const;
            // DocString: FMTNssModel(const FMTSrModel&,unsigned int)
            FMTNssModel(const FMTSrModel& rhs, unsigned int seed);
            // DocString: FMTNssModel::swapPtr
            virtual void swapPtr(std::unique_ptr<FMTModel>& rhs);
 
    };
}
 
BOOST_CLASS_EXPORT_KEY(Models::FMTNssModel)
#endif 
#endif