doxygen/html/RexportParallel_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 REXPORTPARALLEL_H_INCLUDED

#define REXPORTPARALLEL_H_INCLUDED


#include "FMTTask.h"

#include "FMTTaskHandler.h"

#include "FMTReplanningTask.h"

#include "FMTPlanningTask.h"

#if defined FMTWITHOSI

    #include "FMTOpAreaSchedulerTask.h"

#endif

#include "FMTModel.h"

#include "FMTOutput.h"

#include "FMTutility.h"

#include <Rcpp.h>

#include <vector>


RCPP_EXPOSED_WRAP(Parallel::FMTTask);

RCPP_EXPOSED_AS(Parallel::FMTTask);

RCPP_DEFINEVECTOR(Parallel::FMTTask);//For vector


RCPP_EXPOSED_WRAP(Parallel::FMTReplanningTask);

RCPP_EXPOSED_AS(Parallel::FMTReplanningTask);

RCPP_DEFINEVECTOR(Parallel::FMTReplanningTask);//For vector


RCPP_EXPOSED_WRAP(Parallel::FMTPlanningTask);

RCPP_EXPOSED_AS(Parallel::FMTPlanningTask);

RCPP_DEFINEVECTOR(Parallel::FMTPlanningTask);//For vector

#if defined FMTWITHOSI

    RCPP_EXPOSED_WRAP(Parallel::FMTOpAreaSchedulerTask);

    RCPP_EXPOSED_AS(Parallel::FMTOpAreaSchedulerTask);

    RCPP_DEFINEVECTOR(Parallel::FMTOpAreaSchedulerTask);//For vector

#endif


RCPP_EXPOSED_WRAP(Parallel::FMTTaskHandler);

RCPP_EXPOSED_AS(Parallel::FMTTaskHandler);

RCPP_DEFINEVECTOR(Parallel::FMTTaskHandler);//For vector


namespace R

{


    void exportParallel()

    {


        Rcpp::class_<Parallel::FMTTask>("FMTtask", "@DocString(FMTTask)")

            .derives<Core::FMTObject>("FMTobject")

            .constructor("@DocString(FMTTask())");


        Rcpp::class_<Parallel::FMTReplanningTask>("FMTreplanningtask", "@DocString(FMTReplanningTask)")

            .derives<Parallel::FMTTask>("FMTtask")

            .constructor("@DocString(FMTReplanningTask::FMTReplanningTask(...))")

            .constructor<const Models::FMTModel&,

            const Models::FMTModel&,

            const Models::FMTModel&,

            std::string,

            std::string,

            std::vector<std::string>,

            Core::FMToutputlevel>("@DocString(FMTReplanningTask())")

            .method("setreplicates", static_cast<void(Parallel::FMTReplanningTask::*)(const int&)>(&Parallel::FMTReplanningTask::setReplicates),"@DocString(FMTReplanningTask::setreplicates)")

            .method("setreplanningperiods", &Parallel::FMTReplanningTask::setReplanningPeriods,

                "@DocString(FMTReplanningTask::setreplanningperiods)");


        Rcpp::class_<Parallel::FMTPlanningTask>("FMTplanningtask", "@DocString(FMTPlanningTask)")

            .derives<Parallel::FMTTask>("FMTtask")

            .constructor("@DocString(FMTPlanningTask::FMTPlanningTask())")

            .constructor<int,

            int,

            std::string,

            std::string,

            std::vector<std::string>,

            Core::FMToutputlevel,

            std::string>("@DocString(FMTPlanningTask::FMTPlanningTask(...))")

            .method("push_back", &Parallel::FMTPlanningTask::push_back,

                "@DocString(FMTPlanningTask::push_back");

#if defined FMTWITHOSI

        Rcpp::class_<Parallel::FMTOpAreaSchedulerTask>("FMTopareaschedulertask", "@DocString(FMTOpAreaSchedulerTask)")

            .derives<Parallel::FMTTask>("FMTtask")

            .constructor("@DocString(FMTOpAreaSchedulerTask::FMTOpAreaSchedulerTask())")

            .constructor<Models::FMTLpModel,

            std::vector<Heuristics::FMTOperatingAreaScheme>,

            Core::FMTOutputNode,std::string,

            std::string,unsigned int,double>("@DocString(FMTOpAreaSchedulerTask::FMTOpAreaSchedulerTask(...))");

#endif


        Rcpp::class_<Parallel::FMTTaskHandler>("FMTtaskhandler", "@DocString(FMTTaskHandler)")

            .derives<Core::FMTObject>("FMTobject")

            .constructor("@DocString(FMTTaskHandler())")

            .constructor<const Parallel::FMTTask&,unsigned int>("@DocString(FMTTaskHandler(const Parallel::FMTTask&,unsigned int))")

            .method("conccurentrun", &Parallel::FMTTaskHandler::conccurentRun,

                "@DocString(FMTTaskHandler::conccurentrun)")

            .method("ondemandrun", &Parallel::FMTTaskHandler::onDemandRun,

                "@DocString(FMTTaskHandler::ondemandrun)");


    }

}

#endif // PYEXPORTPARALLEL_H_INCLUDED

FMTModel.h

FMTOpAreaSchedulerTask.h

FMTOutput.h

FMTPlanningTask.h

FMTReplanningTask.h

FMTTaskHandler.h

FMTTask.h

FMTutility.h

RCPP_DEFINEVECTOR
RCPP_DEFINEVECTOR(Parallel::FMTTask)

RCPP_EXPOSED_AS
RCPP_EXPOSED_AS(Parallel::FMTTask)

RCPP_EXPOSED_WRAP
RCPP_EXPOSED_WRAP(Parallel::FMTTask)

Core::FMTObject
Base class of multiple FMT classes holding a shared exception handler pointer and logger.
Definition: FMTObject.h:49

Core::FMTOutputNode
Node of an output representing a set of developments in the graph, holding a source,...
Definition: FMTOutputNode.h:25

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

Parallel::FMTOpAreaSchedulerTask
Task to find a suboptimal schedule for the operating areas of a FMTLpModel.
Definition: FMTOpAreaSchedulerTask.h:47

Parallel::FMTPlanningTask
Task to carry multiple parallel optimizations of different FMTModel using the doPlanning function.
Definition: FMTPlanningTask.h:39

Parallel::FMTPlanningTask::push_back
void push_back(const Models::FMTModel &model, std::vector< Core::FMTSchedule >schedules=std::vector< Core::FMTSchedule >(), std::vector< Core::FMTOutput >louputs=std::vector< Core::FMTOutput >())
Push a new FMTModel in the task queue with an optional schedule.

Parallel::FMTReplanningTask
Replanning task using global, stochastic and local abstract models to simulate natural disturbances o...
Definition: FMTReplanningTask.h:43

Parallel::FMTReplanningTask::setReplicates
void setReplicates(const int &replicatesnumber)
Set the number of replicates to use.

Parallel::FMTReplanningTask::setReplanningPeriods
void setReplanningPeriods(const int &periodsnumber)
Set the number of replanning periods.

Parallel::FMTTaskHandler
Main class for running concurrent tasks at the same time.
Definition: FMTTaskHandler.h:27

Parallel::FMTTaskHandler::conccurentRun
void conccurentRun()
Use the split task virtual function to generate all the tasks and run them at the same time.

Parallel::FMTTaskHandler::onDemandRun
void onDemandRun()
Use the spawn task virtual function to generate tasks from the master task and add them to a list,...

Parallel::FMTTask
Task for parallel jobs.
Definition: FMTTask.h:27

Core::FMToutputlevel
FMToutputlevel
Enumerator describing the level of detail of an output (standard, total only, development).
Definition: FMTutility.h:22

R
Definition: RexportCore.h:153

R::exportParallel
void exportParallel()
Definition: RexportParallel.h:49