FMTReplanningTask.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 FMTreplanningtask_Hm_included
#define FMTreplanningtask_Hm_included
 
#include "FMTTask.h"
#include "FMTActualDevelopment.h"
#include "FMTSchedule.h"
#include <vector>
#include <queue>
#include <memory>
#include <string>
#include "FMTutility.h"
 
 
namespace Models
{
    class FMTModel;
}
 
namespace Core
{
    class FMTOutput;
}
 
 
 
namespace Parallel
{
    class FMTParallelWriter;
    // DocString: FMTReplanningTask
    class FMTEXPORT FMTReplanningTask : public FMTTask
    {
        
    public:
        // DocString: FMTReplanningTask::FMTReplanningTask()
        FMTReplanningTask() = default;
        // DocString: FMTReplanningTask::FMTReplanningTask(const FMTReplanningTask&)
        FMTReplanningTask(const FMTReplanningTask& rhs) = default;
        // DocString: FMTReplanningTask::operator=(const FMTReplanningTask&)
        FMTReplanningTask& operator = (const FMTReplanningTask& rhs) = default;
        // DocString: FMTReplanningTask::~FMTReplanningTask()
        virtual ~FMTReplanningTask() = default;
        // DocString: FMTReplanningTask::clone
        std::unique_ptr<FMTTask>clone() const;
        // DocString: FMTReplanningTask::FMTReplanningTask(...)
        FMTReplanningTask(const Models::FMTModel& globalm,
                        const Models::FMTModel& stochasticm,
                        const Models::FMTModel& localm,
                        const std::vector<Core::FMTOutput>& outputs,
                        const std::string& outputlocation,
                        const std::string& gdaldriver,
                        const std::vector<std::string>& creationoptions,
                        const int& replicates,
                        const int& replanningperiodssize,
                        const double& minimaldrift,
                        Core::FMToutputlevel outputlevel,
                        const bool writeSchedule = false);
        // DocString: FMTReplanningTask::FMTReplanningTask(const Models::FMTModel&,const Models::FMTModel&,const Models::FMTModel&)
        FMTReplanningTask(const Models::FMTModel& globalm,
            const Models::FMTModel& stochasticm,
            const Models::FMTModel& localm,
            const std::string& outputlocation,
            const std::string& gdaldriver,
            const std::vector<std::string>& creationoptions,
            Core::FMToutputlevel outputlevel);
        // DocString: FMTReplanningTask::setReplicates
        void setReplicates(const int& replicatesnumber);
        // DocString: FMTReplanningTask::setReplicates
        void setReplicates(const int& replicatesnumbermin, const int& replicatesnumbermax);
        // DocString: FMTReplanningTask::setReplanningPeriods
        void setReplanningPeriods(const int& periodsnumber);
        // DocString: FMTReplanningTask::split
        virtual std::vector<std::unique_ptr<FMTTask>>split(const unsigned int& numberoftasks) const;
        // DocString: FMTReplanningTask::spwan
        virtual std::unique_ptr<FMTTask>spawn();
        // DocString: FMTReplanningTask::work
        virtual void work();
        // DocString: FMTReplanningTask::finalize
        virtual void finalize();
        // DocString: FMTReplanningTask::passInLogger
        void passInLogger(const std::unique_ptr<Logging::FMTLogger>& logger) override;
        // DocString: FMTReplanningTask::setWriteSchedule
        void setWriteSchedule(const bool p_write);
        // DocString: FMTReplanningTask::SupportsMultiThreading()
        bool SupportsMultiThreading() const override;
    private:
        // DocString: FMTReplanningTask::m_resultswriter
        std::shared_ptr<FMTParallelWriter>m_resultswriter;
        // DocString: FMTReplanningTask::m_baseschedule
        std::shared_ptr<Core::FMTSchedule>m_baseschedule;
        // DocString: FMTReplanningTask::global
        std::shared_ptr<Models::FMTModel>global;//base area is in here.
        // DocString: FMTReplanningTask::m_stochastic
        std::shared_ptr<Models::FMTModel>m_stochastic;
        // DocString: FMTReplanningTask::m_local
        std::shared_ptr<Models::FMTModel>m_local;
        // DocString: FMTReplanningTask::m_replicateids
        std::queue<int>m_replicateids;
        // DocString: FMTReplanningTask::m_dynamicarea
        std::vector<Core::FMTActualDevelopment>m_dynamicarea;
        // DocString: FMTReplanningTask::m_iterationglobalschedule
        Core::FMTSchedule m_iterationglobalschedule;
        // DocString: FMTReplanningTask::m_dynamicconstraints
        std::vector<Core::FMTConstraint>m_dynamicconstraints;
        // DocString: FMTReplanningTask::m_replanningperiods
        int m_replanningperiods;
        // DocString: FMTReplanningTask::appendSchedule
        bool m_writeSchedule;
        std::string m_outputlocation;
        // DocString: FMTReplanningTask::_copySharedModel
        std::unique_ptr<Models::FMTModel>_copySharedModel(const std::shared_ptr<Models::FMTModel>model);
        // DocString: FMTReplanningTask::_doModelPlanning
        std::unique_ptr<Models::FMTModel>_doModelPlanning(
            const std::shared_ptr<Models::FMTModel>model,
            const int& replanningperiod,
            bool getsolutionandlocal = false,
            bool applyscheduleweight = false,
            bool setdynamicconstraints = true);
        // DocString: FMTReplanningTask::_writeResults
        void _writeResults(const std::string& modelname, const int& modellength,
            const std::unique_ptr<Models::FMTModel>& modelptr, const int& replanningperiod, bool onlyfirstperiod = false);
        // DocString: FMTReplanningTask::_writeSchedule
        void _writeSchedule(const std::unique_ptr<Models::FMTModel>& p_model,
                            int p_ReportingPeriod, int p_ModelPeriod) const;
        // DocString: FMTReplanningTask::_getIteration
        const int _getIteration() const;
        // DocString: FMTReplanningTask::_setReIgnore
        void _setReIgnore(std::unique_ptr<Models::FMTModel>& modelcpy, const int& replanningperiod) const;
        // DocString: FMTReplanningTask::_setReplicate
        void _setReplicate(std::unique_ptr<Models::FMTModel>& modelcpy, const int& replanningperiod) const;
        // DocString: FMTReplanningTask::m_primaryName
        std::string m_primaryName;
    };
 
}
 
 
 
#endif