BindingConstraint.h

/*
** Copyright 2007-2025, RTE (https://www.rte-france.com)
** See AUTHORS.txt
** SPDX-License-Identifier: MPL-2.0
** This file is part of Antares-Simulator,
** Adequacy and Performance assessment for interconnected energy networks.
**
** Antares_Simulator is free software: you can redistribute it and/or modify
** it under the terms of the Mozilla Public Licence 2.0 as published by
** the Mozilla Foundation, either version 2 of the License, or
** (at your option) any later version.
**
** Antares_Simulator is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** Mozilla Public Licence 2.0 for more details.
**
** You should have received a copy of the Mozilla Public Licence 2.0
** along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
*/
#pragma once
 
#include <memory>
#include <set>
#include <utility>
#include <vector>
 
#include <yuni/yuni.h>
#include <yuni/core/noncopyable.h>
#include <yuni/core/string.h>
 
#include <antares/array/matrix.h>
#include <antares/inifile/inifile.h>
#include "antares/antares/antares.h"
#include "antares/study/filter.h"
 
#include "../area/links.h"
#include "../fwd.h"
#include "../parts/thermal/cluster.h"
#include "BindingConstraintStructures.h"
#include "EnvForLoading.h"
 
namespace Antares::Data
{
// Forward declaration
struct CompareBindingConstraintName;
 
class BindingConstraint final: public Yuni::NonCopyable<BindingConstraint>
{
    friend class BindingConstraintLoader;
    friend class BindingConstraintSaver;
 
public:
    enum Type
    {
        typeUnknown = 0,
        typeHourly,
        typeDaily,
        typeWeekly,
        typeMax
    };
 
    enum Operator
    {
        opUnknown = 0,
        opEquality,
        opLess,
        opGreater,
        opBoth,
        opMax
    };
 
    enum Column
    {
        columnInferior = 0,
        columnSuperior,
        columnEquality,
        columnMax,
    };
 
    using Set = std::set<std::shared_ptr<BindingConstraint>, CompareBindingConstraintName>;
    using linkWeightMap = std::map<const AreaLink*, double, CompareLinkName>;
    using iterator = linkWeightMap::iterator;
    using const_iterator = linkWeightMap::const_iterator;
 
    using clusterWeightMap = std::map<const ThermalCluster*, double, CompareClusterName>;
 
    using linkOffsetMap = std::map<const AreaLink*, int>;
 
    using clusterOffsetMap = std::map<const ThermalCluster*, int>;
 
    static const char* TypeToCString(Type t);
 
    static Type StringToType(const AnyString& text);
 
    static const char* OperatorToCString(Operator o);
    static const char* OperatorToShortCString(Operator o);
 
    static const char* MathOperatorToCString(Operator o);
 
    static Operator StringToOperator(const AnyString& text);
 
 
 
    ~BindingConstraint() = default;
 
 
 
    const ConstraintName& name() const;
 
    void name(const AnyString& newname);
 
    void pId(const AnyString& name);
 
    const ConstraintName& id() const;
 
 
 
    const YString& comments() const;
 
 
 
    std::string group() const;
    void group(std::string group_name);
 
    void comments(const AnyString& newcomments);
 
    void resetToDefaultValues();
 
 
    iterator begin();
    const_iterator begin() const;
 
    iterator end();
    const_iterator end() const;
 
    bool skipped() const;
    bool isActive() const;
 
    // Ref to prevent copy. const ref to prevent modification.
    const Matrix<>& RHSTimeSeries() const;
    Matrix<>& RHSTimeSeries();
 
    bool hasAllWeightedLinksOnLayer(size_t layerID);
 
    bool hasAllWeightedClustersOnLayer(size_t layerID);
 
 
 
    double weight(const AreaLink* lnk) const;
 
    void weight(const AreaLink* lnk, double w);
 
 
 
    double weight(const ThermalCluster* clstr) const;
 
    void weight(const ThermalCluster* clstr, double w);
 
    void removeAllWeights();
 
    void copyWeights(const Study& study,
                     const BindingConstraint& rhs,
                     bool emptyBefore,
                     const std::function<void(AreaName&, const AreaName&)>& translate);
 
    int offset(const AreaLink* lnk) const;
 
    int offset(const ThermalCluster* lnk) const;
 
    void offset(const AreaLink* lnk, int o);
 
    void offset(const ThermalCluster* clstr, int o);
 
    void copyOffsets(const Study& study,
                     const BindingConstraint& rhs,
                     bool emptyBefore,
                     const std::function<void(AreaName&, const AreaName&)>& translate);
 
    uint linkCount() const;
 
    uint clusterCount() const;
 
 
 
    Type type() const;
 
    void setTimeGranularity(Type t);
 
 
    Operator operatorType() const;
    void operatorType(Operator o);
 
    uint yearByYearFilter() const;
    uint synthesisFilter() const;
 
 
    bool enabled() const;
    void enabled(bool v);
 
 
 
    void clearAndReset(const AnyString& name, Type newType, Operator op);
 
    bool forceReload(bool reload = false) const;
 
    void markAsModified() const;
 
    void reverseWeightSign(const AreaLink* lnk);
 
    bool contains(const BindingConstraint* bc) const;
    bool contains(const Area* area) const;
 
    bool contains(const AreaLink* lnk) const;
 
    bool contains(const ThermalCluster* clstr) const;
 
    void buildFormula(YString& s) const;
 
    BindingConstraintStructures initLinkArrays() const;
 
    template<class Env>
    std::string timeSeriesFileName(const Env& env) const;
 
    const clusterWeightMap& clustersAndWeights() const;
 
private:
    ConstraintName pName;
    ConstraintName pID;
    Matrix<> RHSTimeSeries_;
    linkWeightMap pLinkWeights;
    clusterWeightMap pClusterWeights;
    linkOffsetMap pLinkOffsets;
    clusterOffsetMap pClusterOffsets;
    Type pType;
    Operator pOperator;
    // By default, print nothing
    uint pFilterYearByYear = filterNone;
    // By default, print nothing
    uint pFilterSynthesis = filterNone;
    bool pEnabled = false;
    YString pComments;
    std::string group_ = "default";
 
    void clear();
 
    void copyFrom(const BindingConstraint* original);
 
}; // class BindingConstraint
 
// class BindConstList
 
struct CompareBindingConstraintName final
{
    bool operator()(const std::shared_ptr<BindingConstraint>& s1,
                    const std::shared_ptr<BindingConstraint>& s2) const
    {
        return s1->name() < s2->name();
    }
};
 
namespace Enum
{
template<>
inline const std::initializer_list<std::string>& getNames<Antares::Data::BindingConstraint::Type>()
{
    static const std::initializer_list<std::string> il = {"unknown", "hourly", "daily", "weekly"};
    return il;
}
 
template<>
inline const std::initializer_list<std::string>&
getNames<Antares::Data::BindingConstraint::Operator>()
{
    static const std::initializer_list<std::string> il = {"unknown",
                                                          "equality",
                                                          "less",
                                                          "greater",
                                                          "both"};
    return il;
}
} // namespace Enum
 
} // namespace Antares::Data
 
#include "BindingConstraint.hxx"