FMT 1.2.0
Forest management tools for forest planning
Loading...
Searching...
No Matches
PYexportModel.h
Go to the documentation of this file.
1/*
2Copyright (c) 2019 Gouvernement du Québec
3
4SPDX-License-Identifier: LiLiQ-R-1.1
5License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt
6*/
7
8#ifndef PYEXPORTMODEL_H_INCLUDED
9#define PYEXPORTMODEL_H_INCLUDED
10
11#include "FMTModel.h"
12#include "FMTSrModel.h"
13#include "FMTLpModel.h"
14#include "FMTSeModel.h"
15#include "FMTSesModel.h"
16#include "FMTNssModel.h"
17#include "FMTSaModel.h"
18#include "FMTLpSolver.h"
19#include "FMTSaSchedule.h"
20
21#include "boost/python.hpp"
22
23namespace Python
24{
25BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(greedyreferencebuild_overloads, greedyReferenceBuild, 2, 4)
26BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(buildperiod_overloads, buildPeriod, 0, 3)
27BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(get_outputs_overloads, get_outputs, 0, 1)
28BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getsolution_overloads, getSolution, 1, 2)
29BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getLPoutputoverloads, getOutput, 2, 3)
30BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getSchedulesOverloads, getSchedule, 0, 1)
31BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getPotentialScheduleOverloads, getPotentialSchedule,2,3)
32BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(warmup_overloads, warmup, 2, 4)
33BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(evaluate_overloads, evaluate, 1, 2)
34BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getoperatingareaschedulerheuristics_overloads, getOperatingAreaSchedulerHeuristics,2, 4)
35BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getoperatingareaclustererheuristics_overloads,getOperatingAreaClustererHeuristics,4,7)
36BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getareavariabilities_overloads, getAreaVariabilities,2,3)
37BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(boundsolution_overloads, boundSolution, 1, 2)
38BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(eraseperiod_overloads, erasePeriod,0,1)
39BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(setsolution_overloads,setSolution, 2, 3)
40BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(setsolutionbylp_overloads,setSolutionByLp, 2, 3)
41BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(addscheduletoobjective_overloads, addScheduleToObjective, 1, 2)
42BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(getarea_overloads, getArea, 0, 2)
43BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(doplanning_overloads,doPlanning,1,2)
44BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(showparameters_overloads,showParameters,0,1)
45BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(eraseconstraint_overloads,eraseConstraint,1, 2)
46
47void exportModel()
48 {
49 namespace bp = boost::python;
50 bp::object ModelsModule(bp::handle<>(bp::borrowed(PyImport_AddModule("FMT.Models"))));
51 bp::scope().attr("Models") = ModelsModule;
52 bp::scope ModelsModule_scope = ModelsModule;
53 bp::scope().attr("__doc__") = ".. module:: Model\n"
54 "\n"
55 " :platform: Unix, Windows\n"
56 " :synopsis: Module used to generate all kind of Models (M2/M3).\n"
57 "\n";
58
59
60 bp::class_<Models::FMTModel, bp::bases<Core::FMTObject>>("FMTmodel", "@DocString(FMTModel)")
61 .def_pickle(FMT_pickle_suite<Models::FMTModel>())
62 .def(bp::init<Models::FMTModel>())
63 .def("getyields",&Models::FMTModel::getYields,
64 "@DocString(FMTModel::getyields)")
65 .def("setyields", &Models::FMTModel::setYields,
66 "@DocString(FMTModel::setyields)")
67 .def("setlifespan", &Models::FMTModel::setLifespan,
68 "@DocString(FMTModel::setlifespan)")
69 .def("addageyieldhandlers", &Models::FMTModel::addYieldHandlers<Core::FMTAgeYieldHandler>,
70 "@DocString(FMTModel::addyieldhandlers)")
71 .def("addtimeyieldhandlers", &Models::FMTModel::addYieldHandlers<Core::FMTTimeYieldHandler>,
72 "@DocString(FMTModel::addyieldhandlers)")
73 .def("getname", &Models::FMTModel::getName,
74 "@DocString(FMTModel::getname)")
75 .def("getarea",&Models::FMTModel::getArea, getarea_overloads(bp::args("period","beforegrowanddeath"), "@DocString(FMTModel::getarea)"))
76 .def("setarea", &Models::FMTModel::setArea,
77 "@DocString(FMTModel::setarea)")
78 .def("getthemes",&Models::FMTModel::getThemes,
79 "@DocString(FMTModel::getthemes)")
80 .def("setthemes", &Models::FMTModel::setThemes,
81 "@DocString(FMTModel::setthemes)")
82 .def("getactions",&Models::FMTModel::getActions,
83 "@DocString(FMTModel::getActions)")
84 .def("setactions", &Models::FMTModel::setActions,
85 "@DocString(FMTModel::setactions)")
86 .def("getoutputs", &Models::FMTModel::getOutputs,
87 "@DocString(FMTModel::getoutputs)")
88 .def("setoutputs", &Models::FMTModel::setOutputs,
89 "@DocString(FMTModel::setoutputs)")
90 .def("getconstraints", &Models::FMTModel::getConstraints,
91 "@DocString(FMTModel::getConstraints)")
92 .def("setconstraints", &Models::FMTModel::setConstraints,
93 "@DocString(FMTModel::setconstraints)")
94 .def("gettransitions",&Models::FMTModel::getTransitions,
95 "@DocString(FMTModel::gettransitions)")
96 .def("settransitions",&Models::FMTModel::setTransitions,
97 "@DocString(FMTModel::settransitions)")
98 .def("setname", &Models::FMTModel::setName,
99 "@DocString(FMTModel::setname)")
100 .def("setareaperiod", &Models::FMTModel::setAreaPeriod,
101 "@DocString(FMTModel::setareaperiod)")
102 .def("getlifespan",&Models::FMTModel::getLifespan,
103 "@DocString(FMTModel::getlifespan)")
104 .def("isValid",&Models::FMTModel::isValid,
105 "@DocString(FMTModel::isValid)")
106 .def("clearcache",&Models::FMTModel::clearCache,
107 "@DocString(FMTModel::clearcache)")
108 .def("getselectedmask",&Models::FMTModel::getSelectedMask,
109 "@DocString(FMTModel::getselectedmask)")
110 .def("getpostsolvefilter",&Models::FMTModel::getPostSolveFilter,
111 "@DocString(FMTModel::getpostsolvefilter)")
112 .def("basepresolve",&Models::FMTModel::basePreSolve,
113 "@DocString(FMTModel::basepresolve)")
114 .def("isoptimal", &Models::FMTModel::isOptimal,
115 "@DocString(FMTModel::isoptimal)")
116 .def("getobjectivevalue", &Models::FMTModel::getObjectiveValue,
117 "@DocString(FMTModel::getobjectivevalue)")
118 .def("getpotentialschedule", &Models::FMTModel::getPotentialSchedule,
119 getPotentialScheduleOverloads(bp::args("toremove","selection","withlock"),"@DocString(FMTModel::getpotentialschedule)"))
120 //The way to expose overload member functions with different args
121 .def<bool (Models::FMTModel::*)(const Models::FMTintmodelparameters& key, const int& value)>("setparameter", &Models::FMTModel::setParameter,
122 "@DocString(FMTModel::setparameter(const FMTintmodelparameters,const int&))")
123 .def<bool (Models::FMTModel::*)(const Models::FMTdblmodelparameters& key, const double& value)>("setparameter", &Models::FMTModel::setParameter,
124 "@DocString(FMTModel::setparameter(const FMTdblmodelparameters,const double))")
125 .def<bool (Models::FMTModel::*)(const Models::FMTboolmodelparameters& key, const bool& value)>("setparameter", &Models::FMTModel::setParameter,
126 "@DocString(FMTModel::setparameter(const FMTboolmodelparameters,const bool))")
127 .def<int (Models::FMTModel::*)(const Models::FMTintmodelparameters& key)const>("getparameter", &Models::FMTModel::getParameter,
128 "@DocString(FMTModel::getparameter(const FMTintmodelparameters))")
129 .def<double (Models::FMTModel::*)(const Models::FMTdblmodelparameters& key)const>("getparameter", &Models::FMTModel::getParameter,
130 "@DocString(FMTModel::getparameter(const FMTdblmodelparameters))")
131 .def<bool (Models::FMTModel::*)(const Models::FMTboolmodelparameters& key)const>("getparameter", &Models::FMTModel::getParameter,
132 "@DocString(FMTModel::getparameter(const FMTboolmodelparameters))")
133 .def("setcompresstime",&Models::FMTModel::setCompressTime,
134 "@DocString(FMTModel::setcompresstime)")
135 .def("getcompresstime",&Models::FMTModel::getCompressTime,
136 "@DocString(FMTModel::getcompresstime)")
137 .def("showparameters",&Models::FMTModel::showParameters,
138 showparameters_overloads(bp::args("showhelp"),"@DocString(FMTModel::showparameters)"))
139 .def("doplanning",&Models::FMTModel::doPlanning,
140 doplanning_overloads(bp::args("solve"),"@DocString(FMTModel::doplanning)"))
141 .def("getsolution", &Models::FMTModel::getSolution,
142 getsolution_overloads(bp::args("period", "withlock"), "@DocString(FMTModel::getsolution)"))
143 .def("getoutput", &Models::FMTModel::getOutput,
144 getLPoutputoverloads(bp::args("output", "period", "level"), "@DocString(FMTSeModel::getoutput)"));
145
146 definePyList<Models::FMTModel>();
147
148
149
150 bp::to_python_converter<std::map<std::string, double>, MapToDict<std::string, double>>();
151
152
153 bp::class_<Models::FMTSeModel, bp::bases<Models::FMTModel>>("FMTsemodel", "@DocString(FMTSeModel)")
154 .def(bp::init<Models::FMTModel>())
155 .def_pickle(FMT_pickle_suite<Models::FMTSeModel>())
156 .def("getmapping", &Models::FMTSeModel::getMapping,
157 "@DocString(FMTSeModel::getmapping)")
158 .def("setinitialmapping", &Models::FMTSeModel::setInitialMapping,
159 "@DocString(FMTSeModel::setinitialmapping)")
160 .def("getschedule", &Models::FMTSeModel::getSchedule,
161 getSchedulesOverloads(bp::args("withlock"), "@DocString(FMTSeModel::getschedule)"))
162 .def("getdisturbancestats", &Models::FMTSeModel::getDisturbanceStats,
163 "@DocString(FMTSeModel::getdisturbancestats)")
164 .def("getspatialoutput", &Models::FMTSeModel::getSpatialOutput,
165 "@DocString(FMTSeModel::getspatialoutput)")
166 /*.def("getSolution", &Models::FMTSeModel::getSolution,
167 getsolution_overloads(bp::args("period", "withlock"),"@DocString(FMTSeModel::getSolution)"))
168 .def("getarea", &Models::FMTSeModel::getArea,
169 getarea_overloads(bp::args("period", "beforegrowanddeath"), "@DocString(FMTSeModel::getarea)"))
170 .def("getOutput", &Models::FMTSeModel::getOutput,
171 getLPoutputoverloads(bp::args("output", "period", "level"), "@DocString(FMTSeModel::getOutput)"))*/
172 .def("getspschedule", &Models::FMTSeModel::getSpSchedule,
173 "@DocString(FMTSeModel::getspschedule)");
174
175 definePyList<Models::FMTSeModel>();
176
177
178 bp::class_<Models::FMTSesModel, bp::bases<Models::FMTSeModel>>("FMTsesmodel", "@DocString(FMTSesModel)")
179 .def(bp::init<Models::FMTModel>())
180 .def_pickle(FMT_pickle_suite<Models::FMTSesModel>())
181 .def("greedyreferencebuild", &Models::FMTSesModel::greedyReferenceBuild,
182 greedyreferencebuild_overloads(bp::args("schedule", "numberofiterations", "seed", "tolerance"), "@DocString(FMTSesModel::GreedyReferenceBuild)"));
183
184 definePyList<Models::FMTSesModel>();
185
186 bp::enum_<Models::FMTintmodelparameters>("FMTintmodelparameters")
187 .value("LENGTH", Models::FMTintmodelparameters::LENGTH)
188 .value("SEED", Models::FMTintmodelparameters::SEED)
189 .value("NUMBER_OF_ITERATIONS", Models::FMTintmodelparameters::NUMBER_OF_ITERATIONS)
190 .value("PRESOLVE_ITERATIONS", Models::FMTintmodelparameters::PRESOLVE_ITERATIONS)
191 .value("NUMBER_OF_THREADS", Models::FMTintmodelparameters::NUMBER_OF_THREADS)
192 .value("MATRIX_TYPE", Models::FMTintmodelparameters::MATRIX_TYPE);
193
194 definePyList<Models::FMTintmodelparameters>();
195
196 bp::enum_<Models::FMTdblmodelparameters>("FMTdblmodelparameters")
197 .value("TOLERANCE", Models::FMTdblmodelparameters::TOLERANCE)
198 .value("GOALING_SCHEDULE_WEIGHT", Models::FMTdblmodelparameters::GOALING_SCHEDULE_WEIGHT);
199
200 definePyList<Models::FMTdblmodelparameters>();
201
202 bp::enum_<Models::FMTboolmodelparameters>("FMTboolmodelparameters")
203 .value("FORCE_PARTIAL_BUILD", Models::FMTboolmodelparameters::FORCE_PARTIAL_BUILD)
204 .value("STRICTLY_POSITIVE", Models::FMTboolmodelparameters::STRICTLY_POSITIVE)
205 .value("POSTSOLVE", Models::FMTboolmodelparameters::POSTSOLVE)
206 .value("SHOW_LOCK_IN_SCHEDULES", Models::FMTboolmodelparameters::SHOW_LOCK_IN_SCHEDULES)
207 .value("PRESOLVE_CAN_REMOVE_STATIC_THEMES", Models::FMTboolmodelparameters::PRESOLVE_CAN_REMOVE_STATIC_THEMES)
208 .value("DEBUG_MATRIX", Models::FMTboolmodelparameters::DEBUG_MATRIX);
209
210 definePyList<Models::FMTboolmodelparameters>();
211
212
213
214 #ifdef FMTWITHOSI
215
216 bp::enum_<Models::FMTSolverInterface>("FMTsolverinterface")
217 .value("CLP", Models::FMTSolverInterface::CLP)
218 .value("GLPK", Models::FMTSolverInterface::GLPK)
219 #ifdef FMTWITHMOSEK
220 .value("MOSEK", Models::FMTSolverInterface::MOSEK)
221 #endif
222 .value("CPLEX", Models::FMTSolverInterface::CPLEX)
223 .value("GUROBI", Models::FMTSolverInterface::GUROBI);
224
225 definePyList<Models::FMTSolverInterface>();
226
227 bp::class_<Models::FMTLpSolver>("FMTlpolver", "@DocString(FMTLpSolver)")
228 //.def(bp::init<Models::FMTsolverinterface>())
229 .def("isProvenOptimal", &Models::FMTLpSolver::isProvenOptimal,
230 "@DocString(FMTLpSolver::isProvenOptimal)")
231 .def("getObjValue", &Models::FMTLpSolver::getObjValue,
232 "@DocString(FMTLpSolver::getObjValue)")
233 .def("getObjSense", &Models::FMTLpSolver::getObjSense,
234 "@DocString(FMTLpSolver::getObjSense)")
235 .def("setnumberofthreads", &Models::FMTLpSolver::setNumberOfThreads,
236 "@DocString(FMTLpSolver::setnumberofthreads)")
237 .def("setMIPgaptolerance", &Models::FMTLpSolver::setMipGapTolerance,
238 "@DocString(FMTLpSolver::setMipGapTolerance)")
239 .def("setoptimizerMAXtime", &Models::FMTLpSolver::setOptimizerMaxTime,
240 "@DocString(FMTLpSolver::setOptimizerMaxTime)")
241 .def("writeLP", &Models::FMTLpSolver::writeLp,
242 "@DocString(FMTLpSolver::writeLp)")
243 .def("writeMPS", &Models::FMTLpSolver::writeMps,
244 "@DocString(FMTLpSolver::writeMps)")
245 .def("getavailablesolverinterface", &Models::FMTLpSolver::getAvailableSolverInterface,
246 "@DocString(FMTLpSolver::getAvailableSolverInterface)").staticmethod("getavailablesolverinterface");
247
248 bp::class_<Models::FMTSrModel, bp::bases<Models::FMTModel>>("FMTsrmodel", "@DocString(FMTSrModel)")
249 .def_pickle(FMT_pickle_suite<Models::FMTSrModel>())
250 .def("buildperiod", &Models::FMTSrModel::buildPeriod, buildperiod_overloads(bp::args("schedule", "forcepartialbuild", "compressageclass"), "@DocString(FMTSrModel::buildperiod)"))
251
252 .def("setsolution", &Models::FMTSrModel::setSolution,
253 setsolution_overloads(bp::args("period", "schedule", "tolerance"), "@DocString(FMTSrModel::setsolution)"))
254 .def("forcesolution", &Models::FMTSrModel::forceSolution, "@DocString(FMTSrModel::forcesolution)")
255 .def("setsolutionbylp", &Models::FMTSrModel::setSolutionByLp,
256 setsolutionbylp_overloads(bp::args("period", "schedule", "tolerance"), "@DocString(FMTSrModel::setsolutionbylp)"))
257 //.def("getOutput", &Models::FMTSrModel::getOutput, getLPoutputoverloads(bp::args("output", "period", "level"), "@DocString(FMTSrModel::getOutput)"))
258 .def("cleargraphdevelopements", &Models::FMTSrModel::clearGraphDevelopments,
259 "@DocString(FMTSrModel::cleargraphdevelopements)")
260 .def("getstats", &Models::FMTSrModel::getStats,
261 "@DocString(FMTSrModel::getstats)")
262 .def("getRotations", &Models::FMTSrModel::getRotations,
263 "@DocString(FMTSrModel::getRotations)")
264 .def("getGraphStats", &Models::FMTSrModel::getGraphStats,
265 "@DocString(FMTSrModel::getGraphStats)")
266 .def("getscheduleproportions", &Models::FMTSrModel::getScheduleProportions,
267 "@DocString(FMTSrModel::getscheduleproportions)");
268
269 definePyList<Models::FMTSrModel>();
270
271 bp::class_<Models::FMTNssModel, bp::bases<Models::FMTSrModel>>("FMTnssmodel", "@DocString(FMTNssModel)")
272 .def(bp::init<Models::FMTModel, unsigned int>())
273 .def(bp::init<Models::FMTNssModel>())
274 .def_pickle(FMT_pickle_suite<Models::FMTNssModel>())
275 .def("simulate", &Models::FMTNssModel::simulate);
276
277 definePyList<Models::FMTNssModel>();
278
279
280 bp::class_<Models::FMTLpModel, bp::bases<Models::FMTSrModel>>("FMTlpmodel", "@DocString(FMTLpModel)")
281 .def(bp::init<Models::FMTModel, Models::FMTSolverInterface>())
282 .def(bp::init<Models::FMTLpModel>())
283 .def_pickle(FMT_pickle_suite<Models::FMTLpModel>())
284 //.def("boundSolution", &Models::FMTLpModel::boundSolution,
285 // boundsolution_overloads(bp::args("period", "tolerance"),
286 // "@DocString(FMTLpModel::boundSolution)"))
287 .def("setobjective", &Models::FMTLpModel::setObjective,
288 "@DocString(FMTLpModel::setobjective)")
289 .def("clearcache", &Models::FMTLpModel::clearCache,
290 "@DocString(FMTLpModel::clearcache)")
291 .def("clearconstraintlocation", &Models::FMTLpModel::clearConstraintLocation,
292 "@DocString(FMTLpModel::clearconstraintlocation)")
293 .def("setstrictlypositivesoutputsmatrix", &Models::FMTLpModel::setStrictlyPositivesOutputsMatrix,
294 "@DocString(FMTLpModel::setstrictlypositivesoutputsmatrix)")
295 .def("setconstraint", &Models::FMTLpModel::setConstraint,
296 "@DocString(FMTLpModel::setconstraint)")
297 .def("eraseconstraint", &Models::FMTLpModel::eraseConstraint,
298 eraseconstraint_overloads(bp::args("constraint","period"),"@DocString(FMTLpModel::eraseconstraint)"))
299 .def("eraseperiod", &Models::FMTLpModel::erasePeriod,
300 eraseperiod_overloads(bp::args("constraintsonly"), "@DocString(FMTLpModel::eraseperiod)"))
301 .def("resolve", &Models::FMTLpModel::resolve,
302 "@DocString(FMTLpModel::resolve)")
303 .def("initialsolve", &Models::FMTLpModel::initialSolve,
304 "@DocString(FMTLpModel::initialsolve)")
305 .def("__eq__", &Models::FMTLpModel::operator ==,
306 "@DocString(FMTLpModel::operator==)")
307 .def("__ne__", &Models::FMTLpModel::operator !=,
308 "@DocString(FMTLpModel::operator!=)")
309
310 .def("getObjValue", &Models::FMTLpModel::getObjValue,
311 "@DocString(FMTLpModel::getObjValue)")
312 .def("getlocalconstraints",
313 &Models::FMTLpModel::getReplanningConstraints,
314 "@DocString(FMTLpModel::getreplanningconstraints)")
315 .def("writeLP",
316 &Models::FMTLpModel::writeLp,
317 "@DocString(FMTLpModel::writeLp)")
318 .def("getoperatingareaschedulerheuristics", &Models::FMTLpModel::getOperatingAreaSchedulerHeuristics, getoperatingareaschedulerheuristics_overloads(bp::args("opareas", "node", "numberofheuristics", "copysolver","updatematrixname"), "@DocString(FMTLpModel::getoperatingareaschedulerheuristics)"))
319 .def("getoperatingareaclustererheuristics", &Models::FMTLpModel::getOperatingAreaClustererHeuristics, getoperatingareaclustererheuristics_overloads(bp::args("opareas", "statisticoutput", "areaoutput", "period", "numberofheuristics"), "@DocString(FMTLpModel::getoperatingareaschedulerheuristics)"))
320 .def("getvariabilities", &Models::FMTLpModel::getVariabilities, "@DocString(FMTLpModel::getvariabilities)")
321 .def("getareavariabilities", &Models::FMTLpModel::getAreaVariabilities, getareavariabilities_overloads(bp::args("outputs", "globalmask", "tolerance"), "@DocString(FMTLpModel::getareavariabilities)"))
322 .def("addscheduletoobjective", &Models::FMTLpModel::addScheduleToObjective, addscheduletoobjective_overloads(bp::args("schedule", "weight"),"@DocString(FMTLpModel::addscheduletoobjective)"));
323 //.def("doPlanning", &Models::FMTLpModel::doPlanning, doplanning_overloads(bp::args("solve", "schedules"),"@DocString(FMTLpModel::doPlanning)"));
324
325
326 definePyList<Models::FMTLpModel>();
327 #endif
328
329
330
331
332 bp::class_<Models::FMTSaModel, bp::bases<Models::FMTSeModel>>("FMTsamodel", "@DocString(FMTSaModel)")
333 .def(bp::init<Models::FMTModel>())
334 .def(bp::init<Models::FMTSaModel>())
335 .def("initialsolve", &Models::FMTSaModel::initialSolve,
336 "@DocString(FMTSaModel::initialsolve)");
337
338 definePyList<Models::FMTSaModel>();
339
340 }
341}
342#endif // PYEXPORTMODEL_H_INCLUDED
Models::FMTLpModel::getAreaVariabilities
std::map< std::string, std::vector< double > > getAreaVariabilities(const std::vector< Core::FMTOutput > &localoutputs, const std::vector< Core::FMTMask > &globalmasks, std::vector< double > tolerances=std::vector< double >()) const
Return the change in outputs resulting from a variation of the area of the model for a given global m...
Models::FMTLpModel::eraseConstraint
Graph::FMTGraphStats eraseConstraint(const Core::FMTConstraint &constraint, int period=-1)
Erase a constraint in the matrix and in the model elements.
Models::FMTLpModel::getOperatingAreaSchedulerHeuristics
std::vector< Heuristics::FMTOperatingAreaScheduler > getOperatingAreaSchedulerHeuristics(const std::vector< Heuristics::FMTOperatingAreaScheme > &opareas, const Core::FMTOutputNode &node, size_t numberofheuristics=1, bool copysolver=true)
Return operating area scheduler heuristics using multiple operating areas and an output node with a M...
Models::FMTLpModel::clearConstraintLocation
void clearConstraintLocation()
Clear the constraint localisation in the matrix.
Models::FMTLpModel::setStrictlyPositivesOutputsMatrix
void setStrictlyPositivesOutputsMatrix()
Set the model parameter STRICTLY_POSITIVE to true.
Models::FMTLpModel::setObjective
Graph::FMTGraphStats setObjective(const Core::FMTConstraint &objective)
Set the objective of the matrix for the whole planning horizon (graph length).
Models::FMTLpModel::getReplanningConstraints
virtual std::vector< Core::FMTConstraint > getReplanningConstraints(const std::string &modeltype, const std::vector< Core::FMTConstraint > &localconstraints, const int &period) const
Adjust local or global constraints to the global model during replanning, using the solution of this ...
Models::FMTLpModel::writeLp
void writeLp(const std::string &location)
Write the solver interface matrix to a file using the LP formulation.
Models::FMTLpModel::initialSolve
bool initialSolve()
Cold start of the LP solve of a simple LP model.
Models::FMTLpModel::clearCache
void clearCache()
Remove the cache to release memory.
Models::FMTLpModel::addScheduleToObjective
void addScheduleToObjective(const Core::FMTSchedule &schedule, double weight=1000)
Add weight to the objective function for a given schedule.
Models::FMTLpModel::getObjValue
double getObjValue() const
Get the objective value of the solved matrix.
Models::FMTLpModel::getOperatingAreaClustererHeuristics
std::vector< Heuristics::FMTOperatingAreaClusterer > getOperatingAreaClustererHeuristics(const std::vector< Heuristics::FMTOperatingAreaCluster > &clusters, const Core::FMTOutput &statisticoutput, const Core::FMTOutput &areaoutput, const int &period, size_t numberofheuristics=1, int minimalnumberofclusters=-1, int maximalnumberofclusters=-1) const
Return operating area clusterer heuristics for solving the operating area clustering problem using mu...
Models::FMTLpModel::erasePeriod
Graph::FMTGraphStats erasePeriod(bool constraintsonly=false)
Delete the first period (front) of the graph and the matrix, shrinking the planning length to the ori...
Models::FMTLpModel::setConstraint
Graph::FMTGraphStats setConstraint(const Core::FMTConstraint &constraint)
Set a constraint in the matrix for the whole planning horizon (graph length).
Models::FMTLpModel::getVariabilities
std::map< std::string, std::vector< double > > getVariabilities(const std::vector< Core::FMTOutput > &outputs, const int &periodStart, const int &periodStop)
Get the variability of multiple outputs for a given tolerance for each period between periodStart and...
Models::FMTLpModel::resolve
bool resolve()
Call solverinterface->resolve when some changes are done to the model, avoiding a full initialSolve.
Models::FMTLpSolver::writeLp
void writeLp(const std::string &location) const
Write the solver interface matrix to a file using the LP formulation.
Models::FMTLpSolver::getObjValue
double getObjValue() const
Get the objective value of the solved matrix.
Models::FMTLpSolver::writeMps
void writeMps(const std::string &location) const
Write the solver interface matrix to a file using the MPS formulation.
Models::FMTLpSolver::isProvenOptimal
bool isProvenOptimal() const
Return true if the program is optimal, synchronizing the matrix with the cache first.
Models::FMTLpSolver::getObjSense
double getObjSense() const
Return the objective sense of the solver interface, synchronizing with the cache first.
Models::FMTLpSolver::getAvailableSolverInterface
static std::vector< Models::FMTSolverInterface > getAvailableSolverInterface()
Return the available solver interfaces.
Models::FMTLpSolver::setOptimizerMaxTime
void setOptimizerMaxTime(const double &time)
Set the maximum amount of time the optimizer is allowed to spend on the optimization.
Models::FMTLpSolver::setMipGapTolerance
void setMipGapTolerance(const double &gap)
Set the tolerance between the relaxed optimal and the integer optimal.
Models::FMTLpSolver::setNumberOfThreads
void setNumberOfThreads(const size_t &nthread)
Set the maximum number of threads to be used by the solver.
Models::FMTModel
Base class for the different models in FMT.
Definition: FMTModel.h:62
Models::FMTModel::getSolution
virtual Core::FMTSchedule getSolution(int period, bool withlock=false) const
Get the standard solution for a given period, without the natural growth solution.
Models::FMTModel::getPostSolveFilter
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.
Models::FMTModel::getSelectedMask
Core::FMTMask getSelectedMask(const std::vector< Core::FMTTheme > &originalthemes) const
Get the selection mask needed to preSolve a FMTMask when the model is presolved.
Models::FMTModel::basePreSolve
FMTModel basePreSolve() const
Presolve the model using the existing area.
Models::FMTModel::getOutputs
std::vector< Core::FMTOutput > getOutputs() const
Return a copy of the outputs of the model.
Definition: FMTModel.h:365
Models::FMTModel::getThemes
std::vector< Core::FMTTheme > getThemes() const
Return a copy of the themes of the model.
Definition: FMTModel.h:320
Models::FMTModel::getCompressTime
std::vector< int > getCompressTime() const
Return a vector with the compresstime value for each period, the first period being index 0....
Models::FMTModel::doPlanning
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 ...
Models::FMTModel::getOutput
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.
Models::FMTModel::getParameter
int getParameter(const FMTintmodelparameters &key) const
Getter for int model parameters. See FMTModelParameters.h.
Models::FMTModel::getYields
Core::FMTYields getYields() const
Return a copy of the yields of the model.
Definition: FMTModel.h:347
Models::FMTModel::setOutputs
void setOutputs(const std::vector< Core::FMTOutput > &newoutputs)
Setter for the outputs of the model.
Models::FMTModel::setConstraints
void setConstraints(const std::vector< Core::FMTConstraint > &lconstraint)
Setter for the constraints of the model, replacing the original.
Models::FMTModel::getTransitions
std::vector< Core::FMTTransition > getTransitions() const
Return a copy of the transitions of the model.
Definition: FMTModel.h:338
Models::FMTModel::isOptimal
virtual bool isOptimal() const
Return true if the FMTModel is optimal.
Models::FMTModel::setAreaPeriod
void setAreaPeriod(const int &period)
Change the initial area period to the targeted period.
Models::FMTModel::setArea
void setArea(const std::vector< Core::FMTActualDevelopment > &ldevs)
Setter for the initial actual developments (area section), replacing the originals.
Models::FMTModel::getPotentialSchedule
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 o...
Models::FMTModel::getActions
std::vector< Core::FMTAction > getActions() const
Return a copy of the actions of the model.
Definition: FMTModel.h:329
Models::FMTModel::setParameter
virtual bool setParameter(const FMTintmodelparameters &p_key, const int &p_value)
set int parameters to nss model.
Models::FMTModel::setYields
void setYields(const Core::FMTYields &lylds)
Setter for the yields of the model, replacing the original.
Models::FMTModel::getLifespan
Core::FMTLifespans getLifespan() const
Return a copy of the lifespan of the model.
Definition: FMTModel.h:356
Models::FMTModel::getObjectiveValue
virtual double getObjectiveValue() const
Return the value of the global objective.
Models::FMTModel::setLifespan
void setLifespan(const Core::FMTLifespans &llifespan)
Setter for the lifespan of the model, replacing the original.
Models::FMTModel::setCompressTime
bool setCompressTime(const int &periodStart, const int &periodStop, const int &value)
Set the compresstime value for a range of periods. See FMTModelParameters.h.
Models::FMTModel::setName
void setName(const std::string &newname)
Set the name of the FMTModel.
Models::FMTModel::getName
std::string getName() const
Return the name of the FMTModel.
Definition: FMTModel.h:311
Models::FMTModel::showParameters
virtual void showParameters(const bool &showhelp=false) const
Show the parameter values.
Models::FMTModel::setTransitions
void setTransitions(const std::vector< Core::FMTTransition > &ltransitions)
Setter for the transitions of the model, replacing the originals.
Models::FMTModel::getArea
virtual std::vector< Core::FMTActualDevelopment > getArea(int period=0, bool beforegrowanddeath=false) const
Get the area of a given period as actual developments.
Models::FMTModel::setThemes
void setThemes(const std::vector< Core::FMTTheme > &lthemes)
Setter for the themes of the model, replacing the originals.
Models::FMTModel::isValid
bool isValid()
Validate the whole FMTModel through themes, actual developments, yields, actions, transitions,...
Models::FMTModel::getConstraints
std::vector< Core::FMTConstraint > getConstraints() const
Return a copy of the constraints of the model.
Definition: FMTModel.h:374
Models::FMTModel::setActions
void setActions(const std::vector< Core::FMTAction > &lactions)
Setter for the actions of the model, replacing the originals.
Models::FMTModel::clearCache
virtual void clearCache()
Clear caching elements to reduce memory usage.
Models::FMTNssModel::simulate
void simulate()
Do a non spatial simulation based on the area constraints in the optimize section.
Models::FMTSaModel::initialSolve
bool initialSolve()
Try to solve the model from a cold start.
Models::FMTSeModel::getSchedule
std::vector< Core::FMTSchedule > getSchedule(bool withlock=false) const
Return a copy of the operated schedules of the model, which can differ from the potential schedule.
Models::FMTSeModel::getDisturbanceStats
std::string getDisturbanceStats() const
Return a string of patch statistics (area, perimeter) of the disturbances stack.
Models::FMTSeModel::getMapping
Spatial::FMTForest getMapping() const
Return a copy of the actual spatial forest state of each development.
Models::FMTSeModel::setInitialMapping
bool setInitialMapping(const Spatial::FMTForest &forest)
Set the initial forest state, to be set before greedyReferenceBuild is called.
Models::FMTSeModel::getSpatialOutput
virtual Spatial::FMTLayer< double > getSpatialOutput(const Core::FMTOutput &output, int period) const
Get the spatial output value based on the spatial solution.
Models::FMTSeModel::getSpSchedule
Spatial::FMTSpatialSchedule getSpSchedule() const
Return a copy of the spatially explicit solution.
Definition: FMTSeModel.h:82
Models::FMTSesModel::greedyReferenceBuild
std::map< std::string, double > greedyReferenceBuild(const Core::FMTSchedule &p_schedule, size_t p_randomIterations, int p_seed=0, double p_tolerance=FMT_DBL_TOLERANCE)
Find the best spatialization for a schedule using random draws over several iterations.
Models::FMTSrModel::clearGraphDevelopments
void clearGraphDevelopments()
Clear the developments location by periods in the graph.
Models::FMTSrModel::getScheduleProportions
Core::FMTSchedule getScheduleProportions(int period, bool withlock) const
Same as getSolution but the schedule area represents the percentage of area of the development.
Models::FMTSrModel::getStats
Graph::FMTGraphStats getStats() const
Get the graph stats of the graph and matrix (number of columns, rows, edges, vertices).
Models::FMTSrModel::buildPeriod
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...
Models::FMTSrModel::getRotations
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 acti...
Models::FMTSrModel::setSolutionByLp
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,...
Models::FMTSrModel::forceSolution
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...
Models::FMTSrModel::setSolution
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 sol...
Models::FMTSrModel::getGraphStats
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 sub...
Models::FMTdblmodelparameters
FMTdblmodelparameters
Enumerator of the double parameters of a FMTModel.
Definition: FMTModelParameters.h:54
Models::TOLERANCE
@ TOLERANCE
Definition: FMTModelParameters.h:55
Models::GOALING_SCHEDULE_WEIGHT
@ GOALING_SCHEDULE_WEIGHT
Definition: FMTModelParameters.h:56
Models::FMTintmodelparameters
FMTintmodelparameters
Enumerator of the integer parameters of a FMTModel.
Definition: FMTModelParameters.h:28
Models::LENGTH
@ LENGTH
Definition: FMTModelParameters.h:29
Models::SEED
@ SEED
Definition: FMTModelParameters.h:30
Models::MATRIX_TYPE
@ MATRIX_TYPE
Definition: FMTModelParameters.h:34
Models::NUMBER_OF_THREADS
@ NUMBER_OF_THREADS
Definition: FMTModelParameters.h:33
Models::PRESOLVE_ITERATIONS
@ PRESOLVE_ITERATIONS
Definition: FMTModelParameters.h:32
Models::NUMBER_OF_ITERATIONS
@ NUMBER_OF_ITERATIONS
Definition: FMTModelParameters.h:31
Models::FMTboolmodelparameters
FMTboolmodelparameters
Enumerator of the boolean parameters of a FMTModel.
Definition: FMTModelParameters.h:67
Models::DEBUG_MATRIX
@ DEBUG_MATRIX
Definition: FMTModelParameters.h:73
Models::SHOW_LOCK_IN_SCHEDULES
@ SHOW_LOCK_IN_SCHEDULES
Definition: FMTModelParameters.h:71
Models::PRESOLVE_CAN_REMOVE_STATIC_THEMES
@ PRESOLVE_CAN_REMOVE_STATIC_THEMES
Definition: FMTModelParameters.h:72
Models::STRICTLY_POSITIVE
@ STRICTLY_POSITIVE
Definition: FMTModelParameters.h:69
Models::FORCE_PARTIAL_BUILD
@ FORCE_PARTIAL_BUILD
Definition: FMTModelParameters.h:68
Models::POSTSOLVE
@ POSTSOLVE
Definition: FMTModelParameters.h:70
Python
Definition: PYdefinitions.h:14
Python::exportModel
void exportModel()
Definition: PYexportModel.h:47
Generated by doxygen 1.9.6