FMTnssmodel.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 FMTNSSMODEL_H
#define FMTNSSMODEL_H
 
#ifdef FMTWITHOSI
 
#include "FMTsrmodel.hpp"
#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
    {
        // 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));
            std::stringstream basegenerator;
            basegenerator << generator;
            const std::string basegeneratorstring(basegenerator.str());
            ar & BOOST_SERIALIZATION_NVP(basegeneratorstring);
 
        }
        // 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));
            std::string basegeneratorstring;
            ar & BOOST_SERIALIZATION_NVP(basegeneratorstring);
            std::stringstream(basegeneratorstring) >> generator;
            
        }
        BOOST_SERIALIZATION_SPLIT_MEMBER()
        // DocString: FMTnssmodel::generator
        std::default_random_engine generator;
        // DocString: FMTnssmodel::constraintstotarget
        std::vector<const Core::FMToutput*> constraintstotarget(std::vector<double>& targets,const int& period);
        // DocString: FMTnssmodel::getoperabilities
        std::vector<std::pair<size_t, const Core::FMTaction*>> getoperabilities(const Core::FMTactualdevelopment& development,
            std::vector<std::vector<const Core::FMTaction*>> targets,
            const std::vector<const Core::FMToutput*>& alloutputs) const;
        // DocString: FMTnssmodel::etactionstargets
        std::vector<std::vector<const Core::FMTaction*>> getactionstargets(const std::vector<const Core::FMToutput*>& alloutputs) const;
        // DocString: FMTnssmodel::operate
        std::vector<Core::FMTdevelopmentpath> operate(const Core::FMTactualdevelopment& development,const double& areatarget,const Core::FMTaction* target,Core::FMTschedule& schedule) const;
        // DocString: FMTnssmodel::updatearea
        void updatearea(std::vector<Core::FMTactualdevelopment>& basearea, std::vector<Core::FMTactualdevelopment>::iterator developmentit,const std::vector<Core::FMTdevelopmentpath>& paths, const double& operatedarea);
        // DocString: FMTnssmodel::updateareatargets
        void updateareatargets(const double& areaoperated,const size_t& outtarget,
            std::vector<const Core::FMToutput*>& alloutputs,std::vector<double>& targets,
            std::vector<std::vector<const Core::FMTaction*>>& actiontargets) const;
        virtual void swap_ptr(const std::unique_ptr<FMTmodel>& rhs);
        // DocString: FMTnssmodel(const FMTsrmodel&,unsigned int)
        FMTnssmodel(const FMTsrmodel& rhs, unsigned int seed);
        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::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 FMTintmodelparameters, const int)
            bool setparameter(const FMTintmodelparameters& key, const int& value) override;
            // 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;
    };
}
 
BOOST_CLASS_EXPORT_KEY(Models::FMTnssmodel)
#endif 
#endif