doxygen/html/FMTModel_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 FMTMODEL_Hm_included

#define FMTMODEL_Hm_included


#include "FMTTheme.h"

#include "FMTAction.h"

#include "FMTTransition.h"

#include "FMTYields.h"

#include "FMTLifespans.h"

#include "FMTActualDevelopment.h"

#include "FMTOutput.h"

#include "FMTConstraint.h"

#include "FMTList.hpp"

#include "FMTModelParameters.h"

#include <boost/serialization/vector.hpp>

#include <boost/serialization/map.hpp>

#include <boost/serialization/unordered_map.hpp>

#include <boost/serialization/export.hpp>

#include "FMTOutputNode.h"

#include "FMTSchedule.h"

#include <random>


namespace Graph

{

    template<class T1, class T2>

    class FMTGraph;

    class FMTLineGraph;

    class FMTGraphVertexToYield;

}


namespace Parser

{

    class FMTModelParser;

}


namespace Spatial

{

    class FMTSpatialSchedule;

    class FMTSpatialNodesCache;

    class FMTSpatialGraphs;

}

namespace Models

{

    class FMTModelStats;

    // DocString: FMTModel

    class FMTEXPORT FMTModel : public Core::FMTObject

    {

        template<class T1,class T2>

        friend class Graph::FMTGraph;

        friend class Graph::FMTLineGraph;

        friend class Spatial::FMTSpatialSchedule;

        friend class Spatial::FMTSpatialNodesCache;

        friend class Spatial::FMTSpatialGraphs;

        friend class Parser::FMTModelParser;

        friend class Graph::FMTGraphVertexToYield;

    public:

        // DocString: FMTModel::getYieldValue

        double getYieldValue(const std::string& p_mask, const std::string& p_yield, int p_age, int p_period) const;

        // DocString: FMTModel::setReplicate

        void setReplicate(size_t p_replicate,int p_ReplanningPeriod);

        // DocString: FMTModel::gotReIgnore

        bool gotReIgnore(const int& p_replanningPeriod) const;

        // DocString: FMTModel::gotReplicate

        bool gotReplicate(const int& p_replanningPeriod) const;

        // DocString: FMTModel::buildAction

        FMTModel buildAction(const std::string& p_actionName,

                            const std::string& p_Targetyield) const;

        // DocString: FMTModel::buildSchedule

        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;


        // DocString: FMTModel::pushTheme

        void pushTheme(const std::string& p_themeName,

            const std::string& p_yieldName,

            const std::vector<std::string>& p_attributes);

        // DocString: FMTModel::aggregateAllActions

        Models::FMTModel aggregateAllActions(const std::vector<std::string>& p_Aggregates,

                                            std::vector<std::string> p_ActionOrdering) const;

        // DocString: FMTModel::splitActions

        Models::FMTModel splitActions(const std::vector<std::string>& p_Actions,

                                        const std::vector<std::string>& p_masks) const;

        // DocString: FMTSchedule::getPriorities

        std::vector<std::string>getSchedulesPriorities(const std::vector<Core::FMTSchedule>& p_schedules) const;

        // DocString: FMTModel::aggregateSchedules

        std::vector<Core::FMTSchedule> aggregateSchedules(const std::vector<Core::FMTSchedule>& p_schedules) const;

        // DocString: FMTModel::splitSchedules

        std::vector<Core::FMTSchedule> splitSchedules(const std::vector<Core::FMTSchedule>& p_schedules) const;

        // DocString: FMTModel::setParallelLogger

        virtual void setParallelLogger(Logging::FMTLogger& logger);

        // DocString: FMTModel::clearCache

        virtual void clearCache();

        // DocString: FMTModel(const std::vector<Core::FMTActualDevelopment>& larea, const std::vector<Core::FMTTheme>, const std::vector<Core::FMTAction>, const std::vector<Core::FMTTransition>, const Core::FMTYields, const Core::FMTLifespans, const std::string, const std::vector<Core::FMTOutput>, std::vector<Core::FMTConstraint>,FMTModelParameters)

        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());

        // DocString: FMTModel()

        FMTModel();

        // DocString: ~FMTModel

        virtual ~FMTModel() = default;

        // DocString: FMTModel(FMTModel&&)

        FMTModel(FMTModel&& rhs);

        // DocString: FMTModel::operator=(FMTModel&&)

        FMTModel& operator =(FMTModel&& rhs);

        // DocString: FMTModel::getArea

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

        // DocString: FMTModel::getCopy

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

        // DocString: FMTModel::basePreSolve

        FMTModel basePreSolve() const;

        // DocString: FMTModel::getPreSolveFilter

        Core::FMTMaskFilter getPreSolveFilter(const std::vector<Core::FMTTheme>& originalthemes) const;

        // DocString: FMTModel::getPostSolveFilter

        Core::FMTMaskFilter getPostSolveFilter(const std::vector<Core::FMTTheme>& originalthemes, const Core::FMTMask& devmask) const;

        // DocString: FMTModel::getSelectedMask

        Core::FMTMask getSelectedMask(const std::vector<Core::FMTTheme>& originalthemes) const;

        // DocString: FMTModel::preSolve

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

        // DocString: FMTModel::postSolve

        virtual void postSolve(const FMTModel& originalbasemodel);

        // DocString: FMTModel::preSolveSchedule

        Core::FMTSchedule preSolveSchedule(const Core::FMTSchedule& originalbaseschedule,

            const FMTModel& originalbasemodel) const;

        // DocString: FMTModel::getModelStats

        FMTModelStats getModelStats() const;

        // DocString: FMTModel::cleanActionsNTransitions

        void cleanActionsNTransitions();

        // DocString: FMTModel::getName

        inline std::string getName() const

        {

            return name;

        }

        // DocString: FMTModel::getThemes

        inline std::vector<Core::FMTTheme>getThemes() const

        {

            return themes;

        }

        // DocString: FMTModel::getActions

        inline std::vector<Core::FMTAction>getActions() const

        {

            return actions;

        }

        // DocString: FMTModel::getTransitions

        inline std::vector<Core::FMTTransition>getTransitions() const

        {

            return transitions;

        }

        // DocString: FMTModel::getYields

        inline Core::FMTYields getYields() const

        {

            return yields;

        }

        // DocString: FMTModel::getLifespan

        inline Core::FMTLifespans getLifespan() const

        {

            return lifespan;

        }

        // DocString: FMTModel::getOutputs

        inline std::vector<Core::FMTOutput> getOutputs() const

        {

            return outputs;

        }

        // DocString: FMTModel::getConstraints

        inline std::vector<Core::FMTConstraint>getConstraints() const

        {

            return constraints;

        }

        // DocString: FMTModel::defaultDeathAction

        static Core::FMTAction defaultDeathAction(const Core::FMTLifespans& llifespan,

            const std::vector<Core::FMTTheme>& lthemes);

        // DocString: FMTModel::defaultDeathTransition

        static Core::FMTTransition defaultDeathTransition(const Core::FMTLifespans& llifespan,

            const std::vector<Core::FMTTheme>& lthemes);

        // DocString: FMTModel::addOutput

        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);

        // DocString: FMTModel::addYieldHandlers

        template<typename T>

        void addYieldHandlers(const std::vector<T>& yieldhandlers)

        {

            try {

                yields.unShrink(themes);

                for (const auto& yldhandler : yieldhandlers)

                {

                    std::unique_ptr<Core::FMTYieldHandler> yldhandlerptr = yldhandler.clone();

                    yields.push_back(yldhandlerptr->getMask(), yldhandlerptr);

                }

                yields.update();

            }

            catch (...) {

                _exhandler->printExceptions("", "FMTModel:::addyieldhandlers", __LINE__, __FILE__);

            }

        }

        // DocString: FMTModel::addYieldHandlersFromPtr

        void addYieldHandlersFromPtr(const std::vector<std::unique_ptr<Core::FMTYieldHandler>>& yieldhandlers);

        // DocString: FMTModel::operator==

        bool operator == (const FMTModel& rhs) const;

        // DocString: FMTModel::operator<

        bool operator < (const FMTModel& rhs) const;

        // DocString: FMTModel::setArea

        void setArea(const std::vector<Core::FMTActualDevelopment>& ldevs);

        // DocString: FMTModel::setThemes

        void setThemes(const std::vector<Core::FMTTheme>& lthemes);

        // DocString: FMTModel::setActions

        void setActions(const std::vector<Core::FMTAction>& lactions);

        // DocString: FMTModel::setTransitions

        void setTransitions(const std::vector<Core::FMTTransition>& ltransitions);

        // DocString: FMTModel::setConstraints

        void setConstraints(const std::vector<Core::FMTConstraint>& lconstraint);

        // DocString: FMTModel::setYields

        void setYields(const Core::FMTYields& lylds);

        // DocString: FMTModel::setLifespan

        void setLifespan(const Core::FMTLifespans& llifespan);

        // DocString: FMTModel::setName

        void setName(const std::string& newname);

        // DocString: FMTModel::setOutputs

        void setOutputs(const std::vector<Core::FMTOutput>& newoutputs);

        // DocString: FMTModel::isValid

        bool isValid();

        // DocString: FMTModel::locateStaticThemes(const Core::FMTOutput, bool ignoreoutputvariables)

        std::vector<const Core::FMTTheme*> locateStaticThemes(const Core::FMTOutput& output, bool ignoreoutputvariables = false) const;

        // DocString: FMTModel::locateStaticThemes(const Core::FMTOutputNode, bool ignoreoutputvariables)

        std::vector<const Core::FMTTheme*> locateStaticThemes(const Core::FMTOutputNode& output, bool ignoreoutputvariables = false) const;

        // DocString: FMTModel::locateDynamicThemes

        std::vector<const Core::FMTTheme*> locateDynamicThemes(const Core::FMTOutput& outpu, bool ignoreoutputvariables = false) const;

        // DocString: FMTModel::getDynamicMask(const Core::FMTOutput, bool ignoreoutputvariables)

        Core::FMTMask getDynamicMask(const Core::FMTOutput& output, bool ignoreoutputvariables = false) const;

        // DocString: FMTModel::getDynamicMask(const Core::FMTOutputNode, bool ignoreoutputvariables)

        Core::FMTMask getDynamicMask(const Core::FMTOutputNode& node, bool ignoreoutputvariables = false) const;

        // DocString: FMTModel::getStaticMask

        virtual Core::FMTMask getStaticMask(const Core::FMTOutputNode& node, bool ignoreoutputvariables = false) const;

        // DocString: FMTModel::isStaticNode

        bool isStaticNode(const Core::FMTOutputNode& node, double ratioofset = 0.1) const;

        // DocString: FMTModel::locateStaticTransitionsThemes

        std::vector<const Core::FMTTheme*>locateStaticTransitionsThemes() const;

        // DocString: FMTModel::locatenotestaticthemes

        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;

        // DocString: FMTModel(FMTModel)

        FMTModel(const FMTModel& rhs);

        // DocString: FMTModel::operator=

        FMTModel& operator = (const FMTModel& rhs);

        // DocString: FMTModel::empty

        bool empty() const;

        // DocString: FMTModel::append

        void push_back(const FMTModel& rhs);

        // DocString: FMTModel::getInitialArea

        double getInitialArea() const;

        // DocString: FMTModel::setAreaPeriod

        void setAreaPeriod(const int& period);

        // DocString: FMTModel::getAreaPeriod

        int getAreaPeriod() const;

        // DocString: FMTModel::getPotentialSchedule

        Core::FMTSchedule getPotentialSchedule(std::vector<Core::FMTActualDevelopment> toRemove,

            std::vector<Core::FMTActualDevelopment> selection, bool withlock = true) const;

        // DocString: FMTModel::getReplanningConstraints

        virtual std::vector<Core::FMTConstraint> getReplanningConstraints(const std::string& modeltype, const std::vector<Core::FMTConstraint>& localconstraints, const int& period) const;

        // DocString: FMTModel::doPlanning

        virtual bool doPlanning(const bool& solve, std::vector<Core::FMTSchedule> schedules = std::vector<Core::FMTSchedule>());

        // DocString: FMTModel::getOutput

        virtual std::map<std::string, double> getOutput(const Core::FMTOutput& output,

            int period, Core::FMToutputlevel level = Core::FMToutputlevel::standard) const;

        // DocString: FMTModel::getSolution

        virtual Core::FMTSchedule getSolution(int period, bool withlock = false) const;

        // DocString: FMTModel::getOutputsFromPeriods

        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;

        // DocString: FMTModel::clone

        virtual std::unique_ptr<FMTModel>clone() const;

        // DocString: FMTModel::setParameter(const FMTintmodelparameters,const int&)

        // DocString: FMTNssModel::setParameter

        virtual bool setParameter(const FMTintmodelparameters& p_key, const int& p_value);

        // DocString: FMTModel::setParameter(const FMTdblmodelparameters,const double)

        virtual bool setParameter(const FMTdblmodelparameters& key, const double& value);

        // DocString: FMTModel::setParameter(const FMTboolmodelparameters,const bool)

        virtual bool setParameter(const FMTboolmodelparameters& key, const bool& value);

        // DocString: FMTModel::setParameter(const FMTboolstrparameters,const std::string)

        virtual bool setParameter(const FMTstrmodelparameters& p_key, const std::string& p_value);

        // DocString: FMTModel::getParameter(const FMTintmodelparameters)

        int getParameter(const FMTintmodelparameters& key) const;

        // DocString: FMTModel::getParameter(const FMTdblmodelparameters)

        double getParameter(const FMTdblmodelparameters& key) const;

        // DocString: FMTModel::getParameter(const FMTboolmodelparameters)

        bool getParameter(const FMTboolmodelparameters& key) const;

        // DocString: FMTModel::getParameter(const FMTstrmodelparameters)

        const std::string& getParameter(const FMTstrmodelparameters& p_key) const;

        // DocString: FMTModel::setCompressTime

        bool setCompressTime(const int& periodStart, const int& periodStop, const int& value);

        // DocString: FMTModel::getCompressTime

        std::vector<int> getCompressTime() const;

        // DocString: FMTModel::goalConstraints

        std::vector<Core::FMTConstraint>goalConstraints(double penalty = 999999) const;

        // DocString: FMTModel::getTacticalConstraints

        std::vector<Core::FMTConstraint>getTacticalConstraints(double penalty = 999999, double scheduleweight = 999999, double objective = 0, double objectivefactor = 1.0) const;

        // DocString: FMTModel::showParameters

        virtual void showParameters(const bool& showhelp = false)const;

        // DocString: FMTModel::build

        virtual bool build(std::vector<Core::FMTSchedule> schedules = std::vector<Core::FMTSchedule>())

        {

            //Mettre message warning

            return false;

        }

        // DocString: FMTModel::solve

        virtual bool solve()//Only for optimisation

        {

            //Mettre message warning

            return false;

        }

        // DocString: FMTModel::isOptimal

        virtual bool isOptimal() const;

        // DocString: FMTModel::getObjectiveValue

        virtual double getObjectiveValue() const;

        // DocString: FMTModel::getGeneratorPtr

        std::default_random_engine* getGeneratorPtr() const;

        // DocString: FMTModel::getStaticTransitionThemes

        std::vector<size_t>getStaticTransitionThemes() const;

        // DocString: FMTModel::SupportsMultiThreading

        virtual bool SupportsMultiThreading() const;

    protected:

        // DocString: FMTModel::m_generator

        mutable std::default_random_engine m_generator;

        // DocString: FMTModel::parameters

        FMTModelParameters parameters;

        // DocString: FMTModel::area

        std::vector<Core::FMTActualDevelopment>area;

        // DocString: FMTModel::themes

        std::vector<Core::FMTTheme>themes;

        // DocString: FMTModel::actions

        std::vector<Core::FMTAction>actions;

        // DocString: FMTModel::transitions

        std::vector<Core::FMTTransition>transitions;

        // DocString: FMTModel::yields

        Core::FMTYields yields;

        // DocString: FMTModel::lifespan

        Core::FMTLifespans lifespan;

        // DocString: FMTModel::outputs

        std::vector<Core::FMTOutput> outputs;

        // DocString: FMTModel::constraints

        std::vector<Core::FMTConstraint>constraints;

        // DocString: FMTModel::name

        std::string name;

        // DocString: FMTModel::statictransitionthemes

        std::vector<size_t>statictransitionthemes;

        // DocString: FMTModel::setSeed

        void setSeed(const int& p_seed);

        // DocString: FMTModel::setDefaultObjects

        void setDefaultObjects();

        // DocString: FMTModel::getBaseMask

        Core::FMTMask getBaseMask(std::vector<Core::FMTActualDevelopment> optionaldevelopments) const;


        // DocString: FMTModel::getStaticPreSolveThemes

        std::vector<const Core::FMTTheme*>getStaticPreSolveThemes() const;

        // DocString: FMTModel::clearActionsCache

        void clearActionsCache();

        // DocString: FMTModel::clearYieldCache

        void clearYieldCache();

        // DocString: FMTModel::clearTransitionCache

        void clearTransitionCache();

        // DocString: FMTModel::swapPtr

        virtual void swapPtr(std::unique_ptr<FMTModel>& rhs);

        // DocString: FMTModel::setUpSchedulesForBuild

        std::vector<Core::FMTSchedule>setUpSchedulesForBuild(const std::vector<Core::FMTSchedule>& schedules) const;

        // DocString: FMTModel::useActionSerie

        bool useActionSerie() const;

        // DocString: FMTModel::getSeriesMaxSize

        size_t getSeriesMaxSize() const;


    private:

        // DocString: FMTModel::save

        friend class boost::serialization::access;

        template<class Archive>

        void save(Archive& ar, const unsigned int version) const

        {

            ar& boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTObject>(*this));

            FMTObject::forceSave(ar, version);

            std::stringstream basegenerator;

            basegenerator << m_generator;

            const std::string baseGeneratorString(basegenerator.str());

            ar& BOOST_SERIALIZATION_NVP(baseGeneratorString);

            ar& BOOST_SERIALIZATION_NVP(parameters);

            ar& BOOST_SERIALIZATION_NVP(area);

            ar& BOOST_SERIALIZATION_NVP(themes);

            ar& BOOST_SERIALIZATION_NVP(actions);

            ar& BOOST_SERIALIZATION_NVP(transitions);

            ar& BOOST_SERIALIZATION_NVP(yields);

            ar& BOOST_SERIALIZATION_NVP(lifespan);

            ar& BOOST_SERIALIZATION_NVP(outputs);

            ar& BOOST_SERIALIZATION_NVP(constraints);

            ar& BOOST_SERIALIZATION_NVP(name);

        }

        // DocString: FMTModel::load

        template<class Archive>

        void load(Archive& ar, const unsigned int version)

        {

            ar& boost::serialization::make_nvp("FMTobject", boost::serialization::base_object<FMTObject>(*this));

            FMTObject::forceLoad(ar, version);//get the object information for the global object

            std::string baseGeneratorString;

            ar& BOOST_SERIALIZATION_NVP(baseGeneratorString);

            std::stringstream(baseGeneratorString) >> m_generator;

            ar& BOOST_SERIALIZATION_NVP(parameters);

            ar& BOOST_SERIALIZATION_NVP(area);

            ar& BOOST_SERIALIZATION_NVP(themes);

            ar& BOOST_SERIALIZATION_NVP(actions);

            ar& BOOST_SERIALIZATION_NVP(transitions);

            ar& BOOST_SERIALIZATION_NVP(yields);

            ar& BOOST_SERIALIZATION_NVP(lifespan);

            ar& BOOST_SERIALIZATION_NVP(outputs);

            ar& BOOST_SERIALIZATION_NVP(constraints);

            ar& BOOST_SERIALIZATION_NVP(name);

            //this->passinobject(*this);//Distribute global object to local object

        }

        BOOST_SERIALIZATION_SPLIT_MEMBER()

            // DocString: FMTModel::validateListMasks

            template<class T>

        void validateListMasks(const Core::FMTList<T>& container) const

        {

            try {

                for (const auto& listobject : container)

                {

                    std::string name = std::string(listobject.first);

                    Core::FMTTheme::validate(themes, name);

                }

            }

            catch (...)

            {

                _exhandler->raiseFromCatch("", "FMTModel::validateListMasks", __LINE__, __FILE__);

            }

        }

        // DocString: FMTModel::validateListSpec

        void validateListSpec(const Core::FMTSpec& specifier) const;

        // DocString: FMTModel::aggregateActions

        std::map<std::string, std::pair<std::string,Core::FMTMask>> aggregateActions(std::vector<std::string> p_ActionsMapping);

        // DocString: FMTModel::aggregateTransitions

        void aggregateTransitions(const std::map<std::string, std::pair<std::string, Core::FMTMask>>& p_Filters);

        // DocString: FMTModel::aggregateOutputs

        void aggregateOutputs(const std::map<std::string, std::pair<std::string, Core::FMTMask>>& p_Filters,

            std::vector<Core::FMTOutput*>& p_Outputs, const std::vector<std::string>& p_ActionOrdering);

        // DocString: FMTModel::addNewMask

        Core::FMTMask addNewMask(const Core::FMTMask& p_incompleteMask);

        // DocString: FMTModel::extendSchedule

        std::vector<Core::FMTSchedule> extendSchedule(const std::vector<Core::FMTSchedule>& p_schedules) const;

        // DocString: FMTModel::_gutsOfConstructor

        void _gutsOfConstructor(const std::vector<Core::FMTActualDevelopment>& p_area);

        // DocString: FMTModel::_cleanVector

        template<class T>

        static void _cleanVector(std::vector<T>& p_toClean, const std::vector<bool>& p_whichtoKeep)

            {

            size_t Id = p_toClean.size();

            while (Id != 0)

                {

                --Id;

                if (!p_whichtoKeep[Id])

                    {

                    p_toClean.erase(p_toClean.begin() + Id);

                    }

                }

            }

        // DocString: FMTModel::_getYieldsStraticAggregates

        std::set<std::string>_getYieldsStraticAggregates(const std::string& p_yieldName) const;

        // DocString: FMTModel::_getAggregatesWrap

        std::string _getAggregatesWrap(const Core::FMTMask& p_mask,

            const std::vector<size_t>& p_themes) const;

        // DocString: FMTModel::_getAggregatesThemes

        std::vector<size_t> _getAggregatesThemes(const std::string& p_yieldName) const;

        // DocString: FMTModel::_getYieldAttribute

        std::string _getYieldAttribute(const Core::FMTMask& p_devMask,

            const std::string& p_yieldName, const std::vector<size_t>& p_AggregatedThemes) const;

    };

// DocString: FMTModelComparator

class FMTModelComparator

{

public:

    // DocString: FMTModelComparator(std::string)

    FMTModelComparator(std::string p_name);

    // DocString: FMTModelComparator::operator()

    bool operator()(const FMTModel& model) const;


private:

    // DocString: FMTModelComparator::m_modelName

    std::string m_modelName;

};


}


BOOST_CLASS_EXPORT_KEY(Models::FMTModel)


#endif // FMTMODEL_Hm_included

FMTAction.h

FMTActualDevelopment.h

FMTConstraint.h

FMTLifespans.h

FMTModelParameters.h

FMTOutputNode.h

FMTOutput.h

FMTSchedule.h

FMTTheme.h

FMTTransition.h

FMTYields.h

FMTEXPORT
#define FMTEXPORT
Definition: FMTutility.h:125

Core::FMTAction
List of specifications dictating the operability of a subset of developments to this action.
Definition: FMTAction.h:43

Core::FMTLifespans
List holding the maximum age of aggregates of developments.
Definition: FMTLifespans.h:23

Core::FMTMaskFilter
Filter built from masks used to preSolve and postsolve FMTMask objects.
Definition: FMTMaskFilter.h:31

Core::FMTMask
Core class holding, as a boost dynamic bitset, which theme attributes are part of a mask.
Definition: FMTMask.h:96

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

Core::FMTOutput
Class letting the user formulate a constraint in the optimize section or collect data across the grap...
Definition: FMTOutput.h:37

Core::FMTSchedule
Spatially referenced schedule describing the area of developments for which an action can be operated...
Definition: FMTSchedule.h:29

Core::FMTTheme::validate
static bool validate(const std::vector< Core::FMTTheme > &p_themes, std::string &p_mask, std::string p_otherinformation=std::string())
Validate the construction of a valid mask string based on the themes, trimming the mask if there are ...

Core::FMTTransition
List of FMTFork describing the transition of an action, disturbing a development to generate new deve...
Definition: FMTTransition.h:35

Core::FMTYields
FMTList containing multiple yield handlers as seen in the yield section, holding the information rela...
Definition: FMTYields.h:44

Graph::FMTGraphVertexToYield
Adapter pointing to a vertex of a line graph or a full graph and its model, used to answer a generic ...
Definition: FMTGraphVertexToYield.h:31

Graph::FMTGraph
Definition: FMTGraphVertexToYield.h:20

Graph::FMTLineGraph
Simple graph where each action generates a single new vertex (0-—0-—0-—0), used with FMTLayer to simu...
Definition: FMTLineGraph.h:27

Logging::FMTLogger
Base class handling the level of information printed by FMT.
Definition: FMTLogger.h:37

Models::FMTModelComparator
Comparator used to compare FMTModel with std::find_if when models are in a stl container.
Definition: FMTModel.h:1134

Models::FMTModelComparator::FMTModelComparator
FMTModelComparator(std::string p_name)
Constructor of the comparator.

Models::FMTModelComparator::operator()
bool operator()(const FMTModel &model) const
Return true if the given model matches the name held by the comparator.

Models::FMTModelParameters
Class containing all the parameters a model needs to be solved by the different types of FMTModel.
Definition: FMTModelParameters.h:97

Models::FMTModelStats
Class reporting the statistics of a FMTModel, used with the preSolve and postsolve functions.
Definition: FMTModelStats.h:24

Models::FMTModel
Base class for the different models in FMT.
Definition: FMTModel.h:62

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

Models::FMTModel::build
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.
Definition: FMTModel.h:798

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::parameters
FMTModelParameters parameters
Definition: FMTModel.h:850

Models::FMTModel::pushTheme
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::name
std::string name
The name of the Model (name of the .pri file without extension)
Definition: FMTModel.h:877

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::themes
std::vector< Core::FMTTheme > themes
Model themes of the landscape section file.
Definition: FMTModel.h:856

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

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

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::yields
Core::FMTYields yields
Yields data comming from the yield file.
Definition: FMTModel.h:865

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

Models::FMTModel::addOutput
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.

Models::FMTModel::getDynamicMask
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.

Models::FMTModel::statictransitionthemes
std::vector< size_t > statictransitionthemes
The location of the themes static from transitions.
Definition: FMTModel.h:880

Models::FMTModel::getOutputs
std::vector< Core::FMTOutput > getOutputs() const
Return a copy of the outputs of the model.
Definition: FMTModel.h:365

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

Models::FMTModel::locateStaticThemes
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).

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::buildSchedule
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.

Models::FMTModel::constraints
std::vector< Core::FMTConstraint > constraints
Outputs comming from the optimization file.
Definition: FMTModel.h:874

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

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

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

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

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

Models::FMTModel::outputs
std::vector< Core::FMTOutput > outputs
Outputs comming from the ouput file.
Definition: FMTModel.h:871

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

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

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

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

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

Models::FMTModel::getYields
Core::FMTYields getYields() const
Return a copy of the yields of the model.
Definition: FMTModel.h:347

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

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

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

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

Models::FMTModel::FMTModel
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...

Models::FMTModel::cleanActionsNTransitions
void cleanActionsNTransitions()
Delete actions that have no defined transition and transitions that have no defined action,...

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

Models::FMTModel::setUpSchedulesForBuild
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 vec...

Models::FMTModel::getTransitions
std::vector< Core::FMTTransition > getTransitions() const
Return a copy of the transitions of the model.
Definition: FMTModel.h:338

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

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

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

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

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::solve
virtual bool solve()
Solve the model, overridden by each type of model.
Definition: FMTModel.h:808

Models::FMTModel::defaultDeathAction
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.

Models::FMTModel::getDynamicMask
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.

Models::FMTModel::defaultDeathTransition
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...

Models::FMTModel::clearActionsCache
void clearActionsCache()
Clear the cached actions data.

Models::FMTModel::aggregateAllActions
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,...

Models::FMTModel::actions
std::vector< Core::FMTAction > actions
Model actions from the action file and also the _death action.
Definition: FMTModel.h:859

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

Models::FMTModel::splitSchedules
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.

Models::FMTModel::setReplicate
void setReplicate(size_t p_replicate, int p_ReplanningPeriod)
Set the constraints to the specified Replanning 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::useActionSerie
bool useActionSerie() const
Return true if the model makes use of action series.

Models::FMTModel::getActions
std::vector< Core::FMTAction > getActions() const
Return a copy of the actions of the model.
Definition: FMTModel.h:329

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

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

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

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

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

Models::FMTModel::m_generator
std::default_random_engine m_generator
Random number generator.
Definition: FMTModel.h:846

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

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

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

Models::FMTModel::locateNodeStaticThemes
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.

Models::FMTModel::getLifespan
Core::FMTLifespans getLifespan() const
Return a copy of the lifespan of the model.
Definition: FMTModel.h:356

Models::FMTModel::locateStaticThemes
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).

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::transitions
std::vector< Core::FMTTransition > transitions
Model transitions from the transition file and also the _death transition.
Definition: FMTModel.h:862

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

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::area
std::vector< Core::FMTActualDevelopment > area
Actualdevelopments for period 0, seen in the area section or the shapefile/raster.
Definition: FMTModel.h:853

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

Models::FMTModel::preSolve
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.

Models::FMTModel::addYieldHandlers
void addYieldHandlers(const std::vector< T > &yieldhandlers)
Add FMTYieldHandler from a vector to the yields.
Definition: FMTModel.h:417

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

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

Models::FMTModel::getName
std::string getName() const
Return the name of the FMTModel.
Definition: FMTModel.h:311

Models::FMTModel::setSeed
void setSeed(const int &p_seed)
seed the random number generator

Models::FMTModel::lifespan
Core::FMTLifespans lifespan
lifespan data comming from the lifespan file
Definition: FMTModel.h:868

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

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::aggregateSchedules
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.

Models::FMTModel::getReplanningConstraints
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 con...

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

Models::FMTModel::getCopy
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 objec...

Models::FMTModel::splitActions
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 ori...

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

Models::FMTModel::getOutputsFromPeriods
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.

Models::FMTModel::getStaticMask
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.

Models::FMTModel::getTacticalConstraints
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.

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

Models::FMTModel::isValid
bool isValid()
Validate the whole FMTModel through themes, actual developments, yields, actions, transitions,...

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

Models::FMTModel::clearTransitionCache
void clearTransitionCache()
Clear the cached transitions data.

Models::FMTModel::getConstraints
std::vector< Core::FMTConstraint > getConstraints() const
Return a copy of the constraints of the model.
Definition: FMTModel.h:374

Models::FMTModel::FMTModel
FMTModel()
Default constructor of FMTModel.

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

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

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

Models::FMTModel::clearYieldCache
void clearYieldCache()
Clear the cached yields data.

Parser::FMTModelParser
Main parser reading and writing model files, for single or multiple scenarios, using all the other FM...
Definition: FMTModelParser.h:48

Spatial::FMTSpatialGraphs
Container of the line graphs of a spatially explicit model, organized by constraint family,...
Definition: FMTSpatialGraphs.h:52

Spatial::FMTSpatialSchedule
Map containing a line graph for each cell, representing the stand, the action and the transition at e...
Definition: FMTSpatialSchedule.h:50

Core
The Core namespace provides classes for simulating stands/strata growth/harvest through time.
Definition: FMTAction.h:34

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

Core::standard
@ standard
Definition: FMTutility.h:23

Core::FMTotar
FMTotar
Enumerator describing the target of an output (inventory, actual, value, time yield,...
Definition: FMTutility.h:101

Graph
Definition: FMTAreaParser.h:35

Models
Namespace containing all enumerator and classes used to construct or manipulate the different type of...
Definition: FMTAreaParser.h:54

Models::FMTdblmodelparameters
FMTdblmodelparameters
Enumerator of the double parameters of a FMTModel.
Definition: FMTModelParameters.h:54

Models::FMTstrmodelparameters
FMTstrmodelparameters
Enumerator of the string parameters of a FMTModel.
Definition: FMTModelParameters.h:84

Models::FMTintmodelparameters
FMTintmodelparameters
Enumerator of the integer parameters of a FMTModel.
Definition: FMTModelParameters.h:28

Models::FMTboolmodelparameters
FMTboolmodelparameters
Enumerator of the boolean parameters of a FMTModel.
Definition: FMTModelParameters.h:67

Parser
Namespace handling all FMT's parsers. Everything related to I/O should be located in this namespace.
Definition: FMTActionParser.h:27

Spatial
Definition: FMTAreaParser.h:40