Base class holding the attributes and methods shared between the spatially referenced models (FMTLpModel and FMTNssModel). More...

#include <FMTSrModel.h>

Inheritance diagram for Models::FMTSrModel:

[legend]

Collaboration diagram for Models::FMTSrModel:

[legend]

Public Member Functions
void	setNodeCacheSize (const size_t &p_size)
	Set the size of reserved memory used when caching output nodes during the build process and output requests.

Graph::FMTGraphVertexToYield	getGraphVertexToYield () const
	Return a filled FMTGraphVertexToYield without a specific vertex selected.

virtual void	postSolve (const FMTModel &originalbasemodel)
	Postsolve the presolved model back into the original model, also postsolving the FMTGraph of the FMTSrModel.

void	setParallelLogger (Logging::FMTLogger &logger) override
	Pass a logger owned by the thread to the solver so it does not work in concurrency.

	FMTSrModel (const FMTModel &base, FMTSolverInterface lsolvertype)
	Main constructor building a FMTSrModel from its base class and letting the user choose the solver type.

	FMTSrModel ()
	Default constructor for FMTSrModel.

	FMTSrModel (const FMTSrModel &rhs)
	Copy constructor for FMTSrModel.

	FMTSrModel (FMTModel &&base, const Graph::FMTGraph< Graph::FMTVertexProperties, Graph::FMTEdgeProperties > &lgraph, const FMTLpSolver &lsolver)
	Constructor for FMTSrModel mainly used in postSolve.

FMTSrModel &	operator= (const FMTSrModel &rhs)
	Copy assignment operator for FMTSrModel.

	FMTSrModel (FMTSrModel &&rhs) noexcept
	Default move constructor for FMTSrModel.

FMTSrModel &	operator= (FMTSrModel &&rhs) noexcept
	Default move assignment for FMTSrModel.

	~FMTSrModel ()=default
	Default destructor for FMTSrModel.

bool	operator== (const FMTSrModel &rhs) const
	Comparison operator for FMTSrModel.

bool	operator!= (const FMTSrModel &rhs) const
	Comparison operator for FMTSrModel.

bool	unboundSolution (int period)
	Unbound the primal bounds of a given period.

bool	isPeriodBounded (int period) const
	Check if the FMTDevelopment areas are bounded on their primal variables for a given period.

void	clearGraphDevelopments ()
	Clear the developments location by periods in the graph.

void	clearGraphCache ()
	Clear the node caching in the graph.

bool	setSolution (int period, const Core::FMTSchedule &schedule, double tolerance=FMT_DBL_TOLERANCE)
	Set a solution for a given period to warmstart the model or to prepare to bound the model to that solution.

bool	setSolutionByLp (int period, const Core::FMTSchedule &schedule, double tolerance=FMT_DBL_TOLERANCE)
	Set the solution on a partial graph using a schedule, changing the objective function, constraints and variable bounds.

bool	forceSolution (int period, const Core::FMTSchedule &proportionschedulewithlock)
	Force a solution using a schedule based on proportions instead of area, placing only the parts of the solution possible with the model modifications.

Core::FMTSchedule	getSolution (int period, bool withlock=false) const final
	Get the standard solution for a given period, without the natural growth solution.

Core::FMTSchedule	getScheduleProportions (int period, bool withlock) const
	Same as getSolution but the schedule area represents the percentage of area of the development.

Graph::FMTGraphStats	getStats () const
	Get the graph stats of the graph and matrix (number of columns, rows, edges, vertices).

Graph::FMTGraphStats	getGraphStats (const Core::FMTMask &p_Subset) const
	Get the graph stats of the graph and matrix (number of columns, rows, edges, vertices) for a mask subset.

virtual std::unique_ptr< FMTModel >	getCopy (int period=0) const
	Return a copy of the FMTModel for the selected period.

virtual std::map< std::string, double >	getOutput (const Core::FMTOutput &output, int period, Core::FMToutputlevel level=Core::FMToutputlevel::standard) const
	Get the output value for a period using the matrix solution.

Graph::FMTGraphStats	buildPeriod (Core::FMTSchedule schedule=Core::FMTSchedule(), bool forcepartialbuild=false, int compressageclassoperability=1)
	Main function used to build the graph and the matrix, adding a period within the graph and the matrix.

int	getFirstActivePeriod () const
	Return the first active period.

virtual std::vector< Core::FMTActualDevelopment >	getArea (int period=0, bool beforegrowanddeath=false) const override
	Return the area for a given period for a FMTSrModel.

std::vector< Core::FMTActualDevelopment >	getPotentialArea (int p_Period=0, bool p_BeforeGrowAndDeath=false) const
	Compute the potential (maximum) development area for a period by forcing all solver decision variables to 1.0.

FMTLpSolver *	getSolverPtr ()
	Get a pointer to the solver behind the model.

const FMTLpSolver *	getConstSolverPtr () const
	Get a pointer to the const solver behind the model.

virtual std::unique_ptr< FMTModel >	clone () const override
	Get a clone of the FMTSrModel.

void	passInLogger (const std::unique_ptr< Logging::FMTLogger > &logger) override
	Pass in the logger, overridden for the osisolverinterface.

virtual std::unique_ptr< FMTModel >	preSolve (std::vector< Core::FMTActualDevelopment > optionaldevelopments=std::vector< Core::FMTActualDevelopment >()) const override
	Return a presolved copy of the FMTSrModel.

bool	boundSolution (int period, double tolerance=FMT_DBL_TOLERANCE)
	Bound the primal variables to the primal solution present in the matrix for a given period and tolerance.

bool	setParameter (const FMTintmodelparameters &key, const int &value) override
	Override setter for int model parameters.

bool	setParameter (const FMTboolmodelparameters &key, const bool &value) override
	Override setter for bool model parameters.

std::set< Core::FMTSerie >	getRotations (const Core::FMTMask &mask, const std::string &aggregate) const
	Get all the unique rotations (in periods) taken to complete a serie of actions for a mask and an action aggregate.

virtual bool	isOptimal () const
	Return true if the solver considers the solution optimal.

virtual double	getObjectiveValue () const
	Return the value of the solver objective.

std::vector< const Core::FMTDevelopment * >	getNoChoice (const Core::FMTMask &base_mask) const
	Return the period 0 developments of a base mask that have no actions assigned for the whole planning horizon.

std::set< std::string >	getAllMasks (const std::vector< Core::FMTTheme > &p_selectedThemes) const
	Get all masks in string format for a complete graph, only for the selected themes.

bool	SupportsMultiThreading () const override
	Return true if the solver support multithreading.

Public Member Functions inherited from Models::FMTModel
double	getYieldValue (const std::string &p_mask, const std::string &p_yield, int p_age, int p_period) const
	Get yield value.

void	setReplicate (size_t p_replicate, int p_ReplanningPeriod)
	Set the constraints to the specified Replanning Period.

bool	gotReIgnore (const int &p_replanningPeriod) const
	Check if setReIgnore needs to be called.

bool	gotReplicate (const int &p_replanningPeriod) const
	Check if setReplicate needs to be called.

FMTModel	buildAction (const std::string &p_actionName, const std::string &p_Targetyield) const
	Build an action based on the positive value of a yield.

std::vector< Core::FMTSchedule >	buildSchedule (const Core::FMTAction &p_action, const FMTModel &p_BaseModel, const std::string &p_Targetyield, const std::vector< Core::FMTSchedule > &p_schedules) const
	Build a schedule by looking at operability of the actual developments.

void	pushTheme (const std::string &p_themeName, const std::string &p_yieldName, const std::vector< std::string > &p_attributes)
	Push a new theme and update the whole model with it.

Models::FMTModel	aggregateAllActions (const std::vector< std::string > &p_Aggregates, std::vector< std::string > p_ActionOrdering) const
	Aggregate actions together and create a new model with new actions, transitions, outputs, constraints, yields and lifespan.

Models::FMTModel	splitActions (const std::vector< std::string > &p_Actions, const std::vector< std::string > &p_masks) const
	Split actions using the provided masks, new actions are named action_mask and aggregated into the original action name.

std::vector< std::string >	getSchedulesPriorities (const std::vector< Core::FMTSchedule > &p_schedules) const
	Return the action names in priority of area scheduled.

std::vector< Core::FMTSchedule >	aggregateSchedules (const std::vector< Core::FMTSchedule > &p_schedules) const
	Build a new schedule based on p_schedules with the corresponding aggregated actions.

std::vector< Core::FMTSchedule >	splitSchedules (const std::vector< Core::FMTSchedule > &p_schedules) const
	Using the actions of the model change the actions of the schedule.

virtual void	setParallelLogger (Logging::FMTLogger &logger)
	Set a thread owned logger so the solver does not work in concurrency.

virtual void	clearCache ()
	Clear caching elements to reduce memory usage.

	FMTModel (const std::vector< Core::FMTActualDevelopment > &larea, const std::vector< Core::FMTTheme > &lthemes, const std::vector< Core::FMTAction > &lactions, const std::vector< Core::FMTTransition > &ltransitions, const Core::FMTYields &lyields, const Core::FMTLifespans &llifespan, const std::string &lname, const std::vector< Core::FMTOutput > &loutputs, std::vector< Core::FMTConstraint > lconstraints=std::vector< Core::FMTConstraint >(), FMTModelParameters lparameters=FMTModelParameters())
	Main constructor for FMTModel used in Parser::FMTModelParser, constraints and parameters are optional.

	FMTModel ()
	Default constructor of FMTModel.

virtual	~FMTModel ()=default
	Default virtual destructor of FMTModel.

	FMTModel (FMTModel &&rhs)
	Default move constructor for FMTModel.

FMTModel &	operator= (FMTModel &&rhs)
	Default move assignment for FMTModel.

virtual std::vector< Core::FMTActualDevelopment >	getArea (int period=0, bool beforegrowanddeath=false) const
	Get the area of a given period as actual developments.

virtual std::unique_ptr< FMTModel >	getCopy (int period=0) const
	Return a copy of the FMTModel for the selected period, cleaning the constraints and keeping the objective.

FMTModel	basePreSolve () const
	Presolve the model using the existing area.

Core::FMTMaskFilter	getPreSolveFilter (const std::vector< Core::FMTTheme > &originalthemes) const
	Get the preSolve filter.

Core::FMTMaskFilter	getPostSolveFilter (const std::vector< Core::FMTTheme > &originalthemes, const Core::FMTMask &devmask) const
	Get the postsolve filter used by the preSolve, to turn a presolved mask into a postsolve mask.

Core::FMTMask	getSelectedMask (const std::vector< Core::FMTTheme > &originalthemes) const
	Get the selection mask needed to preSolve a FMTMask when the model is presolved.

virtual std::unique_ptr< FMTModel >	preSolve (std::vector< Core::FMTActualDevelopment > optionaldevelopments=std::vector< Core::FMTActualDevelopment >()) const
	Return a new presolved FMTModel using developments and the actual transitions of the model.

virtual void	postSolve (const FMTModel &originalbasemodel)
	Postsolve the presolved model into the original model.

Core::FMTSchedule	preSolveSchedule (const Core::FMTSchedule &originalbaseschedule, const FMTModel &originalbasemodel) const
	Return a new schedule with presolved development masks and actions.

FMTModelStats	getModelStats () const
	Return the statistics of the model such as the number of themes, yields, actions and transitions.

void	cleanActionsNTransitions ()
	Delete actions that have no defined transition and transitions that have no defined action, then sort them.

std::string	getName () const
	Return the name of the FMTModel.

std::vector< Core::FMTTheme >	getThemes () const
	Return a copy of the themes of the model.

std::vector< Core::FMTAction >	getActions () const
	Return a copy of the actions of the model.

std::vector< Core::FMTTransition >	getTransitions () const
	Return a copy of the transitions of the model.

Core::FMTYields	getYields () const
	Return a copy of the yields of the model.

Core::FMTLifespans	getLifespan () const
	Return a copy of the lifespan of the model.

std::vector< Core::FMTOutput >	getOutputs () const
	Return a copy of the outputs of the model.

std::vector< Core::FMTConstraint >	getConstraints () const
	Return a copy of the constraints of the model.

void	addOutput (const std::string &name, const std::string &maskstring, Core::FMTotar outputtarget, std::string action=std::string(), std::string yield=std::string(), std::string description=std::string(), int targetTheme=-1)
	Add one output to the model based only on strings.

template<typename T >
void	addYieldHandlers (const std::vector< T > &yieldhandlers)
	Add FMTYieldHandler from a vector to the yields.

void	addYieldHandlersFromPtr (const std::vector< std::unique_ptr< Core::FMTYieldHandler > > &yieldhandlers)
	Add unique pointers of FMTYieldHandler from a vector to the yields.

bool	operator== (const FMTModel &rhs) const
	Equality comparison operator of FMTModel.

bool	operator< (const FMTModel &rhs) const
	Less than comparison operator of FMTModel.

void	setArea (const std::vector< Core::FMTActualDevelopment > &ldevs)
	Setter for the initial actual developments (area section), replacing the originals.

void	setThemes (const std::vector< Core::FMTTheme > &lthemes)
	Setter for the themes of the model, replacing the originals.

void	setActions (const std::vector< Core::FMTAction > &lactions)
	Setter for the actions of the model, replacing the originals.

void	setTransitions (const std::vector< Core::FMTTransition > &ltransitions)
	Setter for the transitions of the model, replacing the originals.

void	setConstraints (const std::vector< Core::FMTConstraint > &lconstraint)
	Setter for the constraints of the model, replacing the original.

void	setYields (const Core::FMTYields &lylds)
	Setter for the yields of the model, replacing the original.

void	setLifespan (const Core::FMTLifespans &llifespan)
	Setter for the lifespan of the model, replacing the original.

void	setName (const std::string &newname)
	Set the name of the FMTModel.

void	setOutputs (const std::vector< Core::FMTOutput > &newoutputs)
	Setter for the outputs of the model.

bool	isValid ()
	Validate the whole FMTModel through themes, actual developments, yields, actions, transitions, outputs and constraints.

std::vector< const Core::FMTTheme * >	locateStaticThemes (const Core::FMTOutput &output, bool ignoreoutputvariables=false) const
	Return the themes that are not used in the transitions and in a given output (static themes).

std::vector< const Core::FMTTheme * >	locateStaticThemes (const Core::FMTOutputNode &output, bool ignoreoutputvariables=false) const
	Return the themes that are not used in the transitions and in a given output node (static themes).

std::vector< const Core::FMTTheme * >	locateDynamicThemes (const Core::FMTOutput &outpu, bool ignoreoutputvariables=false) const
	Return the themes used in the transition scheme.

Core::FMTMask	getDynamicMask (const Core::FMTOutput &output, bool ignoreoutputvariables=false) const
	Return a mask where static attributes have a value of 0 and dynamic attributes a value of 1.

Core::FMTMask	getDynamicMask (const Core::FMTOutputNode &node, bool ignoreoutputvariables=false) const
	Return a mask where static attributes have a value of 0 and dynamic attributes a value of 1.

virtual Core::FMTMask	getStaticMask (const Core::FMTOutputNode &node, bool ignoreoutputvariables=false) const
	Return a mask where static attributes have a value of 1 and dynamic attributes a value of 0.

bool	isStaticNode (const Core::FMTOutputNode &node, double ratioofset=0.1) const
	Return true if the node can be used in static mask functions.

std::vector< const Core::FMTTheme * >	locateStaticTransitionsThemes () const
	Return the static themes based on the model transitions.

std::vector< const Core::FMTTheme * >	locateNodeStaticThemes (const Core::FMTOutputNode &node, bool ignoreoutputvariables=false, std::vector< const Core::FMTTheme * > basethemes=std::vector< const Core::FMTTheme * >()) const
	Return the static themes of a node based on the model transitions.

	FMTModel (const FMTModel &rhs)
	Copy constructor of FMTModel.

FMTModel &	operator= (const FMTModel &rhs)
	Copy assignment of FMTModel.

bool	empty () const
	Return true if the FMTModel is empty.

void	push_back (const FMTModel &rhs)
	Append a FMTModel to this FMTModel without overriding the objective of the base model.

double	getInitialArea () const
	Return the sum of the area of the area vector.

void	setAreaPeriod (const int &period)
	Change the initial area period to the targeted period.

int	getAreaPeriod () const
	get the period of the area section.

Core::FMTSchedule	getPotentialSchedule (std::vector< Core::FMTActualDevelopment > toRemove, std::vector< Core::FMTActualDevelopment > selection, bool withlock=true) const
	Test operability of a selection minus the developments to remove and return a schedule with an area of 1.0 for each operable development.

virtual std::vector< Core::FMTConstraint >	getReplanningConstraints (const std::string &modeltype, const std::vector< Core::FMTConstraint > &localconstraints, const int &period) const
	Adjust the constraints that need to be set to a value of the global or local model and return all constraints.

virtual bool	doPlanning (const bool &solve, std::vector< Core::FMTSchedule > schedules=std::vector< Core::FMTSchedule >())
	Build the model and do the initial solve or simulate, using the build and solve overridden functions of the different model types.

virtual std::map< std::string, double >	getOutput (const Core::FMTOutput &output, int period, Core::FMToutputlevel level=Core::FMToutputlevel::standard) const
	Get the output value of an output for a given period using the spatial solution.

virtual Core::FMTSchedule	getSolution (int period, bool withlock=false) const
	Get the standard solution for a given period, without the natural growth solution.

virtual std::map< std::string, std::vector< std::vector< double > > >	getOutputsFromPeriods (const std::vector< Core::FMTOutput > &theoutputs, const int &firstPeriod, const int &lastPeriod, Core::FMToutputlevel level=Core::FMToutputlevel::standard) const
	For each output get a vector of output values from the first period to the last period.

virtual std::unique_ptr< FMTModel >	clone () const
	Get a clone of the FMTModel.

virtual bool	setParameter (const FMTintmodelparameters &p_key, const int &p_value)
	set int parameters to nss model.

virtual bool	setParameter (const FMTdblmodelparameters &key, const double &value)
	Setter for double model parameters. See FMTModelParameters.h.

virtual bool	setParameter (const FMTboolmodelparameters &key, const bool &value)
	Setter for bool model parameters. See FMTModelParameters.h.

virtual bool	setParameter (const FMTstrmodelparameters &p_key, const std::string &p_value)
	Setter forstr model parameters. See FMTModelParameters.h.

int	getParameter (const FMTintmodelparameters &key) const
	Getter for int model parameters. See FMTModelParameters.h.

double	getParameter (const FMTdblmodelparameters &key) const
	Getter for double model parameters. See FMTModelParameters.h.

bool	getParameter (const FMTboolmodelparameters &key) const
	Getter for bool model parameters. See FMTModelParameters.h.

const std::string &	getParameter (const FMTstrmodelparameters &p_key) const
	Getter for str model parameters. See FMTModelParameters.h.

bool	setCompressTime (const int &periodStart, const int &periodStop, const int &value)
	Set the compresstime value for a range of periods. See FMTModelParameters.h.

std::vector< int >	getCompressTime () const
	Return a vector with the compresstime value for each period, the first period being index 0. See FMTModelParameters.h.

std::vector< Core::FMTConstraint >	goalConstraints (double penalty=999999) const
	Return all constraints and the objective with goals and penalty.

std::vector< Core::FMTConstraint >	getTacticalConstraints (double penalty=999999, double scheduleweight=999999, double objective=0, double objectivefactor=1.0) const
	Get the constraints adapted for a tactical model.

virtual void	showParameters (const bool &showhelp=false) const
	Show the parameter values.

virtual bool	build (std::vector< Core::FMTSchedule > schedules=std::vector< Core::FMTSchedule >())
	Build the elements needed to solve the model, overridden by each type of model.

virtual bool	solve ()
	Solve the model, overridden by each type of model.

virtual bool	isOptimal () const
	Return true if the FMTModel is optimal.

virtual double	getObjectiveValue () const
	Return the value of the global objective.

std::default_random_engine *	getGeneratorPtr () const
	Get a pointer to the generator.

std::vector< size_t >	getStaticTransitionThemes () const
	Locate the static transition themes.

virtual bool	SupportsMultiThreading () const
	Some solver dont support multithreading.

Public Member Functions inherited from Core::FMTObject
	FMTObject ()
	Default constructor for FMTObject.

virtual	~FMTObject ()
	Default virtual destructor for FMTObject.

	FMTObject (const std::unique_ptr< Exception::FMTExceptionHandler > exhandler)
	Construct a FMTObject passing in the exception handler of another FMTObject.

	FMTObject (const FMTObject &rhs)
	Copy constructor for FMTObject.

FMTObject &	operator= (const FMTObject &rhs)
	Copy assignment operator for FMTObject.

virtual void	passInLogger (const std::unique_ptr< Logging::FMTLogger > &logger)
	Pass in the logger of another FMTObject.

void	passInExceptionHandler (const std::unique_ptr< Exception::FMTExceptionHandler > &exhandler)
	Pass in the exception handler of another FMTObject.

void	redirectLogToFile (const std::string &location)
	Redirect the log to a specific file, appending to it.

virtual void	setDefaultLogger ()
	Create and set a default logger to the FMTObject.

virtual void	setQuietLogger ()
	Create and set a quiet logger to the FMTObject.

virtual void	setTaskLogger ()
	Create and set a task logger to the FMTObject.

virtual void	setDebugLogger ()
	Create and set a debug logger to the FMTObject.

void	setDefaultExceptionHandler ()
	Create and set a default exception handler to the FMTObject.

void	setQuietExceptionHandler ()
	Create and set a quiet exception handler to the FMTObject.

void	setDebugExceptionHandler ()
	Create and set a debug exception handler to the FMTObject.

void	setFreeExceptionHandler ()
	Create and set a free exception handler to the FMTObject.

void	disableNestedExceptions ()
	Disable the nested exception throw of the exception handler.

void	enableNestedExceptions ()
	Enable the nested exception throw of the exception handler.

void	setErrorsToWarnings (const std::vector< Exception::FMTexc > &errors)
	Set a list of errors to be cast to warnings on the exception handler.

void	setMaxWarningsBeforeSilenced (const size_t &maxwarningcount)
	Set the number of warnings raised before being silenced.

template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Protected Member Functions
bool	summarize (const std::map< int, double > &variables, std::vector< int > &sumvariables, std::vector< double > &sumcoefficiants) const
	Summarize constraints stored in a map structure (key is the variable, element is the coefficient) into a vector structure for the osisolverinterface.

Graph::FMTGraphStats	initializeMatrix ()
	Initialize the solver interface, called once when the FMTGraph was empty after the first call of buildPeriod.

Graph::FMTGraphStats	updateMatrix (const Graph::FMTGraph< Graph::FMTVertexProperties, Graph::FMTEdgeProperties >::FMTvertex_pair &targets, const Graph::FMTGraphStats &newstats)
	Update the solver interface matrix after the graph has been updated with new development types during buildPeriod.

size_t	getGraphSize () const
	Return the size of the graph.

void	postSolveGraph (const FMTModel &originalbasemodel)
	Postsolve the graph, rebuilding each vertex and edge based on the original model.

std::queue< Graph::FMTGraph< Graph::FMTVertexProperties, Graph::FMTEdgeProperties >::FMTvertex_descriptor >	getActives ()
	Initialize the graph based on the area if it is not initialized, otherwise return the active vertices.

Protected Member Functions inherited from Models::FMTModel
void	setSeed (const int &p_seed)
	seed the random number generator

void	setDefaultObjects ()
	Define the default _DEATH action and transition when they are not defined by the user.

Core::FMTMask	getBaseMask (std::vector< Core::FMTActualDevelopment > optionaldevelopments) const
	Return a mask covering the actual bits used by the FMTModel and the optional developments.

std::vector< const Core::FMTTheme * >	getStaticPreSolveThemes () const
	Return the themes that are not part of the model, using the transition themes, constraints, actions and yields.

void	clearActionsCache ()
	Clear the cached actions data.

void	clearYieldCache ()
	Clear the cached yields data.

void	clearTransitionCache ()
	Clear the cached transitions data.

virtual void	swapPtr (std::unique_ptr< FMTModel > &rhs)
	Swap this model for the element at the end of the rhs unique pointer.

std::vector< Core::FMTSchedule >	setUpSchedulesForBuild (const std::vector< Core::FMTSchedule > &schedules) const
	Prepare the passed schedules for building based on FORCE_PARTIAL_BUILD, always returning a filled vector covering the whole length.

bool	useActionSerie () const
	Return true if the model makes use of action series.

size_t	getSeriesMaxSize () const
	Get the maximal serie size for the whole model.

Protected Member Functions inherited from Core::FMTObject
template<class Archive >
void	forceSave (Archive &ar, const unsigned int version) const
	Force the serialization to save useful information, which the default FMTObject serialization does not.

template<class Archive >
void	forceLoad (Archive &ar, const unsigned int version)
	Force the serialization to load useful information, which the default FMTObject serialization does not.

void	checkSignals () const
	Check if the user has sent a ctrl-c signal using boost::python to FMT.

void	setCplHandler ()
	Pass the FMT exception handler to the GDAL exception handler (GDAL only).

Protected Attributes
std::unique_ptr< Graph::FMTGraph< Graph::FMTVertexProperties, Graph::FMTEdgeProperties > >	m_graph
	graph holding the FMTdevelopments for all the periods.

FMTLpSolver	solver
	The lpsolver.

Protected Attributes inherited from Models::FMTModel
std::default_random_engine	m_generator
	Random number generator.

FMTModelParameters	parameters

std::vector< Core::FMTActualDevelopment >	area
	Actualdevelopments for period 0, seen in the area section or the shapefile/raster.

std::vector< Core::FMTTheme >	themes
	Model themes of the landscape section file.

std::vector< Core::FMTAction >	actions
	Model actions from the action file and also the _death action.

std::vector< Core::FMTTransition >	transitions
	Model transitions from the transition file and also the _death transition.

Core::FMTYields	yields
	Yields data comming from the yield file.

Core::FMTLifespans	lifespan
	lifespan data comming from the lifespan file

std::vector< Core::FMTOutput >	outputs
	Outputs comming from the ouput file.

std::vector< Core::FMTConstraint >	constraints
	Outputs comming from the optimization file.

std::string	name
	The name of the Model (name of the .pri file without extension)

std::vector< size_t >	statictransitionthemes
	The location of the themes static from transitions.

Friends
class	boost::serialization::access
	Save function used for serialization to do multiprocessing across multiple cpus (pickle in Python).

Additional Inherited Members
Static Public Member Functions inherited from Models::FMTModel
static Core::FMTAction	defaultDeathAction (const Core::FMTLifespans &llifespan, const std::vector< Core::FMTTheme > &lthemes)
	Return the default death action, based on the lifespan and themes, when not specified by the user.

static Core::FMTTransition	defaultDeathTransition (const Core::FMTLifespans &llifespan, const std::vector< Core::FMTTheme > &lthemes)
	Return the default death transition, based on the lifespan and themes, when not specified by the user.

Static Public Member Functions inherited from Core::FMTObject
static Logging::FMTLogger *	getLogger ()
	get a pointer to the actual logger.

static Exception::FMTExceptionHandler *	getExceptionHandler ()
	get a pointer to the actual exception handler.

static std::string	getRuntimeLocation ()
	Return the location of the FMT shared library.

static unsigned long long	getAvailableMemory ()
	Return the available memory in bytes.

static void	setTerminateStack ()
	will write the stack in the log when terminate called and raise a function failed.

static void	setAbortStack ()
	will write the stack in the log when abort called with SIGABRT and raise a function failed.

Static Protected Member Functions inherited from Core::FMTObject
static std::chrono::time_point< std::chrono::high_resolution_clock >	getClock ()
	Return a clock of the current time.

template<class chrono >
static double	getDuration (const std::chrono::time_point< std::chrono::high_resolution_clock > &startclock)
	Return the time elapsed since a start clock as a double.

static std::string	getDurationInSeconds (const std::chrono::time_point< std::chrono::high_resolution_clock > &startclock)
	Return the time elapsed since a start clock in seconds as a string.

static void	_logStack ()
	Log the stack trace...

static void	_terminate ()
	Raise an error with the boost stacktrace.

static void	_abort (int p_signal)
	Raise an error with the boost stacktrace on abort.

Static Protected Attributes inherited from Core::FMTObject
static std::unique_ptr< Exception::FMTExceptionHandler >	_exhandler
	A shared pointer to the exception handler.

static std::unique_ptr< Logging::FMTLogger >	_logger
	A shared pointer to the logger.

Detailed Description

Base class holding the attributes and methods shared between the spatially referenced models (FMTLpModel and FMTNssModel).

Constructor & Destructor Documentation

◆ FMTSrModel() [1/5]

Models::FMTSrModel::FMTSrModel	(	const FMTModel &	base,
		FMTSolverInterface	lsolvertype
	)

Main constructor building a FMTSrModel from its base class and letting the user choose the solver type.

See FMTSolverInterface.h for the supported solver types (CLP, MOSEK, GUROBI, CPLEX).

Parameters

[in]	base	the base model.
[in]	lsolvertype	the solver type.

◆ FMTSrModel() [2/5]

Models::FMTSrModel::FMTSrModel ( )

Default constructor for FMTSrModel.

◆ FMTSrModel() [3/5]

Models::FMTSrModel::FMTSrModel ( const FMTSrModel & rhs )

Copy constructor for FMTSrModel.

Parameters

[in] rhs the FMTSrModel to copy.

◆ FMTSrModel() [4/5]

Models::FMTSrModel::FMTSrModel	(	FMTModel &&	base,
		const Graph::FMTGraph< Graph::FMTVertexProperties, Graph::FMTEdgeProperties > &	lgraph,
		const FMTLpSolver &	lsolver
	)

Constructor for FMTSrModel mainly used in postSolve.

Parameters

[in]	base	the base model.
[in]	lgraph	the graph.
[in]	lsolver	the solver.

◆ FMTSrModel() [5/5]

Models::FMTSrModel::FMTSrModel ( FMTSrModel && rhs )

noexcept

Default move constructor for FMTSrModel.

Parameters

[in,out] rhs the model to move from.

◆ ~FMTSrModel()

Models::FMTSrModel::~FMTSrModel ( )

default

Default destructor for FMTSrModel.

Member Function Documentation

◆ boundSolution()

bool Models::FMTSrModel::boundSolution	(	int	period,
		double	tolerance = `FMT_DBL_TOLERANCE`
	)

Bound the primal variables to the primal solution present in the matrix for a given period and tolerance.

Useful to update a FMTLpModel or to get ready for replanning.

Parameters

[in]	period	the period.
[in]	tolerance	the tolerance.

Returns: true if the solution is bounded else false.

◆ buildPeriod()

Graph::FMTGraphStats Models::FMTSrModel::buildPeriod	(	Core::FMTSchedule	schedule = `Core::FMTSchedule()`,
		bool	forcepartialbuild = `false`,
		int	compressageclassoperability = `1`
	)

Main function used to build the graph and the matrix, adding a period within the graph and the matrix.

If the schedule is not empty the model is generated in partial build mode, building only the graph linked to the solution.

Parameters

[in]	schedule	the schedule.
[in]	forcepartialbuild	if true forces a partial build.
[in]	compressageclassoperability	the age class operability compression.

Returns: the graph stats.

◆ clearGraphCache()

void Models::FMTSrModel::clearGraphCache ( )

Clear the node caching in the graph.

◆ clearGraphDevelopments()

void Models::FMTSrModel::clearGraphDevelopments ( )

Clear the developments location by periods in the graph.

◆ clone()

virtual std::unique_ptr< FMTModel > Models::FMTSrModel::clone ( ) const

overridevirtual

Get a clone of the FMTSrModel.

Returns: a unique pointer to the cloned model.

Reimplemented from Models::FMTModel.

Reimplemented in Models::FMTLpModel, and Models::FMTNssModel.

◆ forceSolution()

bool Models::FMTSrModel::forceSolution	(	int	period,
		const Core::FMTSchedule &	proportionschedulewithlock
	)

Force a solution using a schedule based on proportions instead of area, placing only the parts of the solution possible with the model modifications.

The schedule must contain lock indicators if locks are used in the model.

Parameters

[in]	period	the period.
[in]	proportionschedulewithlock	the proportion schedule with lock.

Returns: true if the solution is forced else false.

◆ getActives()

std::queue< Graph::FMTGraph< Graph::FMTVertexProperties, Graph::FMTEdgeProperties >::FMTvertex_descriptor > Models::FMTSrModel::getActives ( )

protected

Initialize the graph based on the area if it is not initialized, otherwise return the active vertices.

Returns: a queue of active vertices of the graph.

◆ getAllMasks()

std::set< std::string > Models::FMTSrModel::getAllMasks ( const std::vector< Core::FMTTheme > & p_selectedThemes ) const

Get all masks in string format for a complete graph, only for the selected themes.

Parameters

[in] p_selectedThemes the selected themes.

Returns: a set of masks.

◆ getArea()

virtual std::vector< Core::FMTActualDevelopment > Models::FMTSrModel::getArea	(	int	period = `0`,
		bool	beforegrowanddeath = `false`
	)		const

overridevirtual

Return the area for a given period for a FMTSrModel.

For period 0 the area is the same as FMTModel::getarea; for period greater than 0 the area is the FMTDevelopment of the graph existing at the beginning of the period. Needs a built graph with a solution.

Parameters

[in]	period	the period.
[in]	beforegrowanddeath	if true returns before growth and death.

Returns: the actual developments.

Reimplemented from Models::FMTModel.

◆ getConstSolverPtr()

const FMTLpSolver * Models::FMTSrModel::getConstSolverPtr ( ) const

Get a pointer to the const solver behind the model.

Returns: a const pointer to the solver.

◆ getCopy()

virtual std::unique_ptr< FMTModel > Models::FMTSrModel::getCopy ( int period = 0 ) const

virtual

Return a copy of the FMTModel for the selected period.

For period 0 returns FMTModel::getCopy; for period greater than 0 returns a copy based on the developments of the FMTGraph. Needs a built graph with a solution.

Parameters

[in] period the period.

Returns: the copied model.

Reimplemented from Models::FMTModel.

Reimplemented in Models::FMTLpModel, and Models::FMTNssModel.

◆ getFirstActivePeriod()

int Models::FMTSrModel::getFirstActivePeriod ( ) const

Return the first active period.

Should be 0 for planning, but moves to 1 and so on when erasePeriod is called.

Returns: the first active period.

◆ getGraphSize()

size_t Models::FMTSrModel::getGraphSize ( ) const

protected

Return the size of the graph.

Returns: the graph size.

◆ getGraphStats()

Graph::FMTGraphStats Models::FMTSrModel::getGraphStats ( const Core::FMTMask & p_Subset ) const

Get the graph stats of the graph and matrix (number of columns, rows, edges, vertices) for a mask subset.

Parameters

[in] p_Subset the mask subset.

Returns: the graph stats for the graph.

◆ getGraphVertexToYield()

Graph::FMTGraphVertexToYield Models::FMTSrModel::getGraphVertexToYield ( ) const

Return a filled FMTGraphVertexToYield without a specific vertex selected.

Useful for a generic yield request depending on the full graph and model (like FMTYieldModel).

Returns: the graph vertex to yield.

◆ getNoChoice()

std::vector< const Core::FMTDevelopment * > Models::FMTSrModel::getNoChoice ( const Core::FMTMask & base_mask ) const

Return the period 0 developments of a base mask that have no actions assigned for the whole planning horizon.

The developments mask has to be a subset of the base mask.

Parameters

[in] base_mask the base mask.

Returns: the developments with no choice.

◆ getObjectiveValue()

virtual double Models::FMTSrModel::getObjectiveValue ( ) const

virtual

Return the value of the solver objective.

Returns: the objective value.

Reimplemented from Models::FMTModel.

◆ getOutput()

virtual std::map< std::string, double > Models::FMTSrModel::getOutput	(	const Core::FMTOutput &	output,
		int	period,
		Core::FMToutputlevel	level = `Core::FMToutputlevel::standard`
	)		const

virtual

Get the output value for a period using the matrix solution.

The map key is the output name when level is standard or totalonly, or the development name when level is developpement.

Parameters

[in]	output	the output.
[in]	period	the period.
[in]	level	the output level.

Returns: a map of names to values.

Reimplemented from Models::FMTModel.

Reimplemented in Models::FMTLpModel.

◆ getPotentialArea()

std::vector< Core::FMTActualDevelopment > Models::FMTSrModel::getPotentialArea	(	int	p_Period = `0`,
		bool	p_BeforeGrowAndDeath = `false`
	)		const

Compute the potential (maximum) development area for a period by forcing all solver decision variables to 1.0.

A temporary copy of the model is used so the current model is not modified.

Parameters

[in]	p_Period	the planning period.
[in]	p_BeforeGrowAndDeath	if true computes the area before growth and mortality, otherwise after.

Returns: the potential development area for the period.

◆ getRotations()

std::set< Core::FMTSerie > Models::FMTSrModel::getRotations	(	const Core::FMTMask &	mask,
		const std::string &	aggregate
	)		const

Get all the unique rotations (in periods) taken to complete a serie of actions for a mask and an action aggregate.

A serie can contain a subserie for an aggregate of actions, keeping only series whose actions are part of the aggregate.

Parameters

[in]	mask	the mask of the rotations.
[in]	aggregate	the aggregate the last action is considered to be in.

Returns: the unique series.

◆ getScheduleProportions()

Core::FMTSchedule Models::FMTSrModel::getScheduleProportions	(	int	period,
		bool	withlock
	)		const

Same as getSolution but the schedule area represents the percentage of area of the development.

Parameters

[in]	period	the period.
[in]	withlock	if true the schedule contains locked developments.

Returns: the schedule proportions.

◆ getSolution()

Core::FMTSchedule Models::FMTSrModel::getSolution	(	int	period,
		bool	withlock = `false`
	)		const

finalvirtual

Get the standard solution for a given period, without the natural growth solution.

Parameters

[in]	period	the period.
[in]	withlock	if true the schedule contains locked developments.

Returns: the solution schedule.

Reimplemented from Models::FMTModel.

◆ getSolverPtr()

FMTLpSolver * Models::FMTSrModel::getSolverPtr ( )

Get a pointer to the solver behind the model.

Returns: a pointer to the solver.

◆ getStats()

Graph::FMTGraphStats Models::FMTSrModel::getStats ( ) const

Get the graph stats of the graph and matrix (number of columns, rows, edges, vertices).

Returns: the full stats.

◆ initializeMatrix()

Graph::FMTGraphStats Models::FMTSrModel::initializeMatrix ( )

protected

Initialize the solver interface, called once when the FMTGraph was empty after the first call of buildPeriod.

Returns: the graph stats.

◆ isOptimal()

virtual bool Models::FMTSrModel::isOptimal ( ) const

virtual

Return true if the solver considers the solution optimal.

Returns: true if the solution is optimal else false.

Reimplemented from Models::FMTModel.

◆ isPeriodBounded()

bool Models::FMTSrModel::isPeriodBounded ( int period ) const

Check if the FMTDevelopment areas are bounded on their primal variables for a given period.

Parameters

[in] period the period.

Returns: true if the period is bounded else false.

◆ operator!=()

bool Models::FMTSrModel::operator!= ( const FMTSrModel & rhs ) const

Comparison operator for FMTSrModel.

Parameters

[in] rhs the FMTSrModel to compare to.

Returns: true if both models are different else false.

◆ operator=() [1/2]

FMTSrModel & Models::FMTSrModel::operator= ( const FMTSrModel & rhs )

Copy assignment operator for FMTSrModel.

Parameters

[in] rhs the FMTSrModel to copy.

Returns: a reference to this FMTSrModel.

◆ operator=() [2/2]

FMTSrModel & Models::FMTSrModel::operator= ( FMTSrModel && rhs )

noexcept

Default move assignment for FMTSrModel.

Parameters

[in,out] rhs the model to move from.

Returns: a reference to this FMTSrModel.

◆ operator==()

bool Models::FMTSrModel::operator== ( const FMTSrModel & rhs ) const

Comparison operator for FMTSrModel.

Parameters

[in] rhs the FMTSrModel to compare to.

Returns: true if both models are equal else false.

◆ passInLogger()

void Models::FMTSrModel::passInLogger ( const std::unique_ptr< Logging::FMTLogger > & logger )

overridevirtual

Pass in the logger, overridden for the osisolverinterface.

Parameters

[in] logger the logger.

Reimplemented from Core::FMTObject.

◆ postSolve()

virtual void Models::FMTSrModel::postSolve ( const FMTModel & originalbasemodel )

virtual

Postsolve the presolved model back into the original model, also postsolving the FMTGraph of the FMTSrModel.

Parameters

[in] originalbasemodel the original base model.

Reimplemented from Models::FMTModel.

◆ postSolveGraph()

void Models::FMTSrModel::postSolveGraph ( const FMTModel & originalbasemodel )

protected

Postsolve the graph, rebuilding each vertex and edge based on the original model.

Parameters

[in] originalbasemodel the original base model.

◆ preSolve()

virtual std::unique_ptr< FMTModel > Models::FMTSrModel::preSolve ( std::vector< Core::FMTActualDevelopment > optionaldevelopments = std::vector< Core::FMTActualDevelopment >() ) const

overridevirtual

Return a presolved copy of the FMTSrModel.

Parameters

[in] optionaldevelopments the optional developments.

Returns: the presolved model.

Reimplemented from Models::FMTModel.

Reimplemented in Models::FMTLpModel, and Models::FMTNssModel.

◆ setNodeCacheSize()

void Models::FMTSrModel::setNodeCacheSize ( const size_t & p_size )

Set the size of reserved memory used when caching output nodes during the build process and output requests.

Parameters

[in] p_size the size to reserve.

◆ setParallelLogger()

void Models::FMTSrModel::setParallelLogger ( Logging::FMTLogger & logger )

overridevirtual

Pass a logger owned by the thread to the solver so it does not work in concurrency.

The solver logger cannot work in parallel.

Parameters

[in] logger the logger.

Reimplemented from Models::FMTModel.

◆ setParameter() [1/2]

bool Models::FMTSrModel::setParameter	(	const FMTboolmodelparameters &	key,
		const bool &	value
	)

overridevirtual

Override setter for bool model parameters.

Parameters

[in]	key	the parameter key.
[in]	value	the value to set.

Returns: true if the parameter is set else false.

Reimplemented from Models::FMTModel.

◆ setParameter() [2/2]

bool Models::FMTSrModel::setParameter	(	const FMTintmodelparameters &	key,
		const int &	value
	)

overridevirtual

Override setter for int model parameters.

Parameters

[in]	key	the parameter key.
[in]	value	the value to set.

Returns: true if the parameter is set else false.

Reimplemented from Models::FMTModel.

◆ setSolution()

bool Models::FMTSrModel::setSolution	(	int	period,
		const Core::FMTSchedule &	schedule,
		double	tolerance = `FMT_DBL_TOLERANCE`
	)

Set a solution for a given period to warmstart the model or to prepare to bound the model to that solution.

Parameters

[in]	period	the period.
[in]	schedule	the schedule.
[in]	tolerance	the tolerance.

Returns: true if the solution is set else false.

◆ setSolutionByLp()

bool Models::FMTSrModel::setSolutionByLp	(	int	period,
		const Core::FMTSchedule &	schedule,
		double	tolerance = `FMT_DBL_TOLERANCE`
	)

Set the solution on a partial graph using a schedule, changing the objective function, constraints and variable bounds.

Useful with many lock exempt actions coming from a Ws model; only valid in a get results context on a partial graph.

Parameters

[in]	period	the period.
[in]	schedule	the schedule.
[in]	tolerance	the tolerance.

Returns: true if the solution is set else false.

◆ summarize()

bool Models::FMTSrModel::summarize	(	const std::map< int, double > &	variables,
		std::vector< int > &	sumvariables,
		std::vector< double > &	sumcoefficiants
	)		const

protected

Summarize constraints stored in a map structure (key is the variable, element is the coefficient) into a vector structure for the osisolverinterface.

Parameters

[in]	variables	the variables map.
[in,out]	sumvariables	the summarized variables.
[in,out]	sumcoefficiants	the summarized coefficients.

Returns: true if the summary succeeded else false.

◆ SupportsMultiThreading()

bool Models::FMTSrModel::SupportsMultiThreading ( ) const

overridevirtual

Return true if the solver support multithreading.

Returns: true if it support else false

Reimplemented from Models::FMTModel.

◆ unboundSolution()

bool Models::FMTSrModel::unboundSolution ( int period )

Unbound the primal bounds of a given period.

Parameters

[in] period the period.

Returns: true if the solution is unbounded else false.

◆ updateMatrix()

Graph::FMTGraphStats Models::FMTSrModel::updateMatrix	(	const Graph::FMTGraph< Graph::FMTVertexProperties, Graph::FMTEdgeProperties >::FMTvertex_pair &	targets,
		const Graph::FMTGraphStats &	newstats
	)

protected

Update the solver interface matrix after the graph has been updated with new development types during buildPeriod.

Variables and constraints related to each new development are added to the matrix (area transfer row, natural growth and action variables).

Parameters

[in]	targets	the target vertices.
[in]	newstats	the new stats.

Returns: the graph stats.

Friends And Related Function Documentation

◆ boost::serialization::access

friend class boost::serialization::access

friend

Save function used for serialization to do multiprocessing across multiple cpus (pickle in Python).

Template Parameters

Archive the archive type.

Parameters

[in,out]	ar	the archive to save to.
[in]	version	the serialization version.

Member Data Documentation

◆ m_graph

std::unique_ptr<Graph::FMTGraph<Graph::FMTVertexProperties, Graph::FMTEdgeProperties> > Models::FMTSrModel::m_graph

protected

graph holding the FMTdevelopments for all the periods.

◆ solver

FMTLpSolver Models::FMTSrModel::solver

protected

The lpsolver.

The documentation for this class was generated from the following file:

D:/FMT/Include/FMTSrModel.h

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FMTSrModel() [1/5]

◆ FMTSrModel() [2/5]

◆ FMTSrModel() [3/5]

◆ FMTSrModel() [4/5]

◆ FMTSrModel() [5/5]

◆ ~FMTSrModel()

Member Function Documentation

◆ boundSolution()

◆ buildPeriod()

◆ clearGraphCache()

◆ clearGraphDevelopments()

◆ clone()

◆ forceSolution()

◆ getActives()

◆ getAllMasks()

◆ getArea()

◆ getConstSolverPtr()

◆ getCopy()

◆ getFirstActivePeriod()

◆ getGraphSize()

◆ getGraphStats()

◆ getGraphVertexToYield()

◆ getNoChoice()

◆ getObjectiveValue()

◆ getOutput()

◆ getPotentialArea()

◆ getRotations()

◆ getScheduleProportions()

◆ getSolution()

◆ getSolverPtr()

◆ getStats()

◆ initializeMatrix()

◆ isOptimal()

◆ isPeriodBounded()

◆ operator!=()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator==()

◆ passInLogger()

◆ postSolve()

◆ postSolveGraph()

◆ preSolve()

◆ setNodeCacheSize()

◆ setParallelLogger()

◆ setParameter() [1/2]

◆ setParameter() [2/2]

◆ setSolution()

◆ setSolutionByLp()

◆ summarize()

◆ SupportsMultiThreading()

◆ unboundSolution()

◆ updateMatrix()

Friends And Related Function Documentation

◆ boost::serialization::access

Member Data Documentation

◆ m_graph

◆ solver