FMTConstraint.h

Go to the documentation of this file.

/*
Copyright (c) 2019 Gouvernement du Québec
 
SPDX-License-Identifier: LiLiQ-R-1.1
License-Filename: LICENSES/EN/LiLiQ-R11unicode.txt
*/
 
#ifndef FMTconstraint_Hm_included
#define FMTconstraint_Hm_included
 
#include "FMTOutput.h"
#include <vector>
#include <string>
#include <limits>
#include "FMTBounds.hpp"
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/export.hpp>
 
namespace Core
{
class FMTTransition;
class FMTTheme;
class FMTAction;
class FMTYields;
// DocString: FMTconstrainttype
enum  FMTconstrainttype
{
    FMTMAXobjective = 1,
    FMTMINobjective = 2,
    FMTMAXMINobjective = 3,
    FMTMINMAXobjective = 4,
    FMTevenflow = 5,
    FMTnondeclining = 6,
    FMTsequence = 7,
    FMTstandard = 8,
    FMTspatialsize = 9,
    FMTspatialadjacency = 10,
    FMTspatialgreenup = 11,
    FMTSpatialGroup = 12,
    FMTrandomaction = 13//need to be deleted
};
// DocString: FMTConstraint
class FMTEXPORT FMTConstraint: public FMTOutput,public FMTSpec
    {
    public:
        // DocString: FMTConstraint()
        FMTConstraint();
        // DocString: FMTConstraint(FMTconstrainttype,const FMTOutput&)
        FMTConstraint(FMTconstrainttype ltype, const FMTOutput& loutput);
        // DocString: FMTConstraint(const FMTConstraint&)
        FMTConstraint(const FMTConstraint& rhs);
        // DocString: FMTConstraint::operator=
        FMTConstraint& operator = (const FMTConstraint& rhs);
        // DocString: FMTConstraint::operator==
        bool operator == (const FMTConstraint& rhs) const;
        // DocString: FMTConstraint::operator!=
        bool operator != (const FMTConstraint& rhs) const;
        // DocString: FMTConstraint::extraVariables
        bool extraVariables() const;
        // DocString: FMTConstraint::isGoal
        bool isGoal() const;
        // DocString: FMTConstraint::isSetFrom
        bool isSetFrom(const std::string& modeltype) const;
        // DocString: FMTConstraint::isReIgnore
        bool isReIgnore(const int& replanningperiod) const;
        // DocString: FMTConstraint::doSupportRandom
        bool doSupportRandom() const;
        // DocString: FMTConstraint::setFrom
        Core::FMTConstraint setFrom(const std::string& modeltype,const double& value) const;
        // DocString: FMTConstraint::getScheduleWeight
        double getScheduleWeight() const;
        // DocString: FMTConstraint::getFromReplicate
        Core::FMTConstraint getFromReplicate(const size_t& replicate,const int& period) const;
        // DocString: FMTConstraint::setFromReplicate
        void setFromReplicate(size_t p_replicate,int p_period);
        
        // DocString: FMTConstraint::gotReplicate
        bool gotReplicate(const int& p_period) const;
        // DocString: FMTConstraint::getPenalties
        std::vector<std::string>getPenalties(double & sense) const;
        // DocString: FMTConstraint::getVariableLevels
        std::vector<std::string>getVariableLevels() const;
        // DocString: FMTConstraint::getGoal
        void getGoal(std::string& name,double& value) const;
        // DocString: FMTConstraint::setGoal
        void setGoal(const std::string& goalname, const double& value);
        // DocString: FMTConstraint::setPenalties
        void setPenalties(const std::string& penaltyoperator, const std::vector<std::string>& variables);
        // DocString: FMTConstraint::isObjective
        bool isObjective() const;
        // DocString: FMTConstraint::sense
        double sense() const;
        // DocString: FMTConstraint::getBounds
        void getBounds(double& lower, double& upper,int period = 0) const;
        // DocString: FMTConstraint::setRhs
        void setRhs(double lower,double upper);
        // DocString: FMTConstraint::setLength
        void setLength(int firstPeriod = 1,int lastPeriod = std::numeric_limits<int>::max());
        // DocString: FMTConstraint::getVariations
        void getVariations(double& lower, double& upper) const;
        // DocString: FMTConstraint::isMultiple
        bool isMultiple() const;
        // DocString: FMTConstraint::acrossPeriod
        bool acrossPeriod() const;
        // DocString: FMTConstraint::hash
        size_t hash(bool hashrhs = true,bool hashoutputonly = false) const;
        // DocString: FMTConstraint::hasHasOutput
        size_t hasHasOutput() const;
        // DocString: FMTConstraint::setOutput
        void setOutput(const FMTOutput& out);
        // DocString: FMTConstraint::setConstraintType
        void setConstraintType(FMTconstrainttype ltype);
        // DocString: FMTConstraint::getConstraintType
        FMTconstrainttype getConstraintType() const;
        // DocString: FMTConstraint::operator std::string
        operator std::string() const;
        // DocString: FMTConstraint::isSpatial
        bool isSpatial() const;
        // DocString: FMTConstraint::isRandomAction
        bool isRandomAction() const;
        // DocString: FMTConstraint::getGroup
        size_t getGroup() const;
        // DocString: FMTConstraint::outputEmpty
        size_t outputEmpty() const;
        // DocString: FMTConstraint::preSolve
        FMTConstraint preSolve(const FMTMaskFilter& filter,
            const std::vector<FMTTheme>& originalthemes,
            const std::vector<const FMTTheme*>& selectedthemes,
            const std::vector<FMTTheme>& newthemes,
            const std::vector<FMTAction>& actions,
            const std::vector<bool>& p_valideActions,
            const FMTYields& yields) const;
        // DocString: FMTConstraint::preSolveRef
        void preSolveRef(const FMTMaskFilter& p_filter,
            const std::vector<FMTTheme>& p_originalThemes,
            const std::vector<const FMTTheme*>& p_selectedThemes,
            const std::vector<FMTTheme>& p_newThemes,
            const std::vector<FMTAction>& p_actions,
            const std::vector<bool>& p_valideActions,
            const FMTYields& p_yields);
        // DocString: ~FMTConstraint()
        ~FMTConstraint()=default;
        // DocString: FMTConstraint::evaluate
        double evaluate(const std::vector<double>& temporalvalues) const;
        // DocString: FMTConstraint::getActionIds
        std::vector<int>getActionIds(const std::vector<Core::FMTAction>& actions) const;
        // DocString: FMTConstraint::isActionsused
        std::vector<bool>isActionsused(const std::vector<Core::FMTAction>& actions) const;
        // DocString: FMTConstraint::canBeTurnedToYieldsBasedOnTransitions
        bool canBeTurnedToYieldsBasedOnTransitions(const std::vector<Core::FMTTheme>& p_themes,
                                                const std::vector<Core::FMTTransition>& p_trans,
                                                const std::vector<Core::FMTAction>& p_actions,
                                                const std::vector<bool>& p_valideActions) const;
        // DocString: FMTConstraint::turnToYieldsBasedOnTransition
        void turnToYieldsBasedOnTransition( const std::vector<Core::FMTTheme>& themes,
                                            const std::vector<Core::FMTTransition>& trans,
                                            std::vector<Core::FMTAction>&actions,
                                            const std::vector<bool>& p_valideActions,
                                            Core::FMTYields& yields,
                                            const int& constraintid) const;
        // DocString: FMTConstraint::canBeTurnedToYields
        bool canBeTurnedToYields() const;
        // DocString: FMTConstraint::turnToYieldsAndActions
        void turnToYieldsAndActions(const std::vector<Core::FMTTheme>& themes,
                         std::vector<Core::FMTAction>&actions,
                        const std::vector<bool>& p_valideActions,
                         Core::FMTYields& yields,
                         const int& constraintid) const;
 
        // DocString: FMTConstraint::getThemeTarget
        int getThemeTarget() const;
        // DocString: FMTConstraint::getWeight
        double getWeight() const;
    private:
        // DocString: FMTConstraint::serialize
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            ar& boost::serialization::make_nvp("output", boost::serialization::base_object<FMTOutput>(*this));
            ar& boost::serialization::make_nvp("specification", boost::serialization::base_object<FMTSpec>(*this));
            ar& boost::serialization::make_nvp("type", m_type);
        }
        // DocString: FMTConstraint::m_type
        FMTconstrainttype m_type;
        // DocString: FMTConstraint::_standardString
        void _standardString(std::string& line, std::string& period_bounds,
            std::string& goal, std::string& global,bool asInt = false) const;
        // DocString: FMTConstraint::_getMaxAndMin
        void _getMaxAndMin(const std::vector<double>& values, double& min, double& max) const;
        // DocString: FMTConstraint::_getSum
        double _getSum(const std::vector<double>& values) const;
        // DocString: FMTConstraint::_getPeriodicVariationCost
        double _getPeriodicVariationCost(const std::vector<double>& values, bool evaluateupper = false) const;
        // DocString: FMTConstraint::_getVariability
        double _getVariability(const std::vector<double>& values, const double& var, const double& lowarvar) const;
        // DocString: FMTConstraint::_getReplicateValues
        bool _getReplicateValue(size_t p_replicate, int p_period, double& p_bound) const;
        // DocString: FMTConstraint::_setIterationChange
        void _setIterationChange(double p_bound);
        // DocString: FMTConstraint::getiterationchange
        Core::FMTConstraint _getIterationChange(double p_PeriodChanges) const;
 
    };
}
 
BOOST_CLASS_EXPORT_KEY(Core::FMTConstraint)
#endif