cbuilder.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/>.
 */
#ifndef __ANTARES_CONSTRAINTSBUILDER_BUILDER_CBUILDER_H__
#define __ANTARES_CONSTRAINTSBUILDER_BUILDER_CBUILDER_H__
 
#include <yuni/yuni.h>
#include <yuni/core/string.h>
 
#include <antares/study/study.h>
#include "antares/solver/constraints-builder/grid.h"
#include "antares/study/area/constants.h"
 
#define CB_PREFIX "@UTO_"
 
namespace Antares
{
class areaInfo
{
public:
    areaInfo(Data::Area* area)
    {
        ptr = area;
        nodeName = area->name.to<std::string>();
    }
 
    std::string getName()
    {
        return nodeName;
    }
 
public:
    Data::Area* ptr;
    std::string nodeName;
};
 
class linkInfo
{
public:
    double weight;
    bool enabled = true;
    Data::AreaLinkName name;
    Antares::Data::AssetType type;
    double angleLB = 0;
    double angleUB = 0;
    bool hasPShiftsEqual = true;
 
    uint nImpedanceChanges;
    double avgImpedance;
    Data::AreaLink* ptr;
 
public:
    double getWeightWithImpedance() const;
    Yuni::String getName() const;
 
    linkInfo() = default;
 
    ~linkInfo() = default;
 
    struct comparepWeight
    {
        inline bool operator()(const linkInfo* lhs, const linkInfo* rhs) const
        {
            return lhs->getWeightWithImpedance() < rhs->getWeightWithImpedance();
        }
    };
 
    struct comparepWeightWithImpedance
    {
        inline bool operator()(const linkInfo* lhs, const linkInfo* rhs) const
        {
            return lhs->getWeightWithImpedance() < rhs->getWeightWithImpedance();
        }
    };
 
    struct addpWeight
    {
        double operator()(double i, const linkInfo* o) const
        {
            return (o->getWeightWithImpedance() + i);
        }
    };
 
    struct addpWeightWithImpedance
    {
        double operator()(double i, const linkInfo* o) const
        {
            return (o->getWeightWithImpedance() + i);
        }
    };
 
    bool operator<(const linkInfo& other) const
    {
        return getWeightWithImpedance() < other.getWeightWithImpedance()
                 ? true
                 : (getWeightWithImpedance() > other.getWeightWithImpedance()
                      ? false
                      : getName() < other.getName());
    }
}; // class linkInfo
 
class State
{
public:
    State(std::vector<double> impedancesList, uint time, double infinite = 1000000):
        secondMember(3, time),
        impedances(impedancesList)
    {
        secondMember.fillColumn(1, -1 * infinite);
        secondMember.fillColumn(0, infinite);
    }
 
    Matrix<double, double> secondMember;
    std::vector<double> impedances;
    std::map<linkInfo*, double> WeightMap;
};
 
class Cycle
{
public:
    Cycle(const std::vector<linkInfo*>& linkList, double infinite = 1000000):
        time(0),
        loop(linkList),
        opType(Data::BindingConstraint::opEquality),
        pInfinite(infinite)
    {
        uint columnImpedance = (uint)Antares::Data::fhlImpedances;
 
        std::vector<double> impedances;
        Data::AreaLink* previousLine = linkList[0]->ptr;
        double currentLineSign = 1;
        for (auto line = linkList.begin(); line != linkList.end(); line++)
        {
            if ((*line)->nImpedanceChanges > 0
                || ((*line)->type == Antares::Data::atAC && (!(*line)->hasPShiftsEqual)))
            {
                opType = Data::BindingConstraint::opBoth;
            }
            impedances.push_back((*line)->ptr->parameters[columnImpedance][0]);
 
            time = HOURS_PER_YEAR; /*BC loading always expects 8786 values heigth will
                                                 have to be resized*/
 
            if (line == linkList.begin())
            {
                currentLineSign = 1;
            }
            else
            {
                if (previousLine->with == (*line)->ptr->from
                    || previousLine->from
                         == (*line)->ptr->with) //[(A/B),(B/C),... ] or [(A,B),(C/A),... ]
                {
                }
                else if (previousLine->from == (*line)->ptr->from
                         || previousLine->with == (*line)->ptr->with)
                {
                    currentLineSign *= -1;
                }
                else
                {
                    assert(0 and "links of the loops do not connect or are not in the right order");
                }
            }
 
            sign.push_back(currentLineSign);
            previousLine = (*line)->ptr;
        }
        State state(impedances, time, pInfinite);
        states.push_back(state);
    }
 
    State& getState(std::vector<double>& impedances)
    {
        std::vector<State>::iterator stIT = std::find_if(states.begin(),
                                                         states.end(),
                                                         [&impedances](State& s) -> bool
                                                         { return s.impedances == impedances; });
 
        if (stIT == states.end())
        {
            State state(impedances, time, pInfinite);
            states.push_back(state);
            stIT = std::find_if(states.begin(),
                                states.end(),
                                [&impedances](State& s) -> bool
                                { return s.impedances == impedances; });
        }
        return *stIT;
    }
 
    uint time;
    std::vector<double> sign;
    const std::vector<linkInfo*>& loop;
    std::vector<State> states;
    Data::BindingConstraint::Operator opType;
    double pInfinite;
};
 
class CBuilder final
{
public:
    typedef std::vector<linkInfo*> Vector;
    typedef std::map<linkInfo*, double> WeightMap;
    typedef std::map<linkInfo*, double> Pattern;
    typedef std::vector<Pattern> VectorOfPatterns;
    typedef std::map<uint, Pattern*> Map;
 
public:
 
 
    CBuilder(Antares::Data::Study&);
    ~CBuilder() = default;
 
    bool runConstraintsBuilder(bool standalone = false);
 
    bool completeFromStudy();
 
    bool deletePreviousConstraints();
 
    bool saveCBuilderToFile(const String& filename = "") const;
    bool completeCBuilderFromFile(const std::string& filename = "");
 
    int alreadyExistingNetworkConstraints(const Yuni::String& prefix) const;
 
    linkInfo* findLinkInfoFromNodeNames(Data::AreaName& u, Data::AreaName& v)
    {
        auto linkIT = std::find_if(pLink.begin(),
                                   pLink.end(),
                                   [&u, &v](std::shared_ptr<linkInfo> edgeP) -> bool
                                   {
                                       if (edgeP->ptr->from->id == u && edgeP->ptr->with->id == v)
                                       {
                                           return true;
                                       }
                                       if (edgeP->ptr->from->id == v && edgeP->ptr->with->id == u)
                                       {
                                           return true;
                                       }
                                       else
                                       {
                                           return false;
                                       }
                                   });
        if (linkIT != pLink.end())
        {
            return linkIT->get();
        }
 
        return nullptr;
    }
 
    void buildAreaToLinkInfosMap()
    {
        areaToLinks.clear();
        for (auto& area: pStudy.areas)
        {
            auto a = area.second;
            std::for_each(pLink.begin(),
                          pLink.end(),
                          [&a, this](std::shared_ptr<linkInfo> edgeP)
                          {
                              if (edgeP->ptr->from == a || edgeP->ptr->with == a)
                              {
                                  this->areaToLinks[a].insert(edgeP.get());
                              }
                          });
        }
    }
 
    linkInfo* getLink(uint i)
    {
        if (i < pLink.size())
        {
            return pLink[i].get();
        }
        return nullptr;
    }
 
    size_t linkCount()
    {
        return pLink.size();
    }
 
    bool isCycleDriver(linkInfo*);
 
    uint cycleCount(linkInfo* lnkI);
 
    bool createConstraints(const std::vector<Vector>&);
 
    double setInfinite(const long value)
    {
        return infiniteSecondMember = value;
    }
 
    bool setCheckNodalLoopFlow(const bool value)
    {
        return checkNodalLoopFlow = value;
    }
 
    bool setLoopFlowInclusion(const bool value)
    {
        return includeLoopFlow = value;
    }
 
    bool setPhaseShiftInclusion(const bool value)
    {
        return includePhaseShift = value;
    }
 
    double getInfinite()
    {
        return infiniteSecondMember;
    }
 
    bool getCheckNodalLoopFlow()
    {
        return checkNodalLoopFlow;
    }
 
    bool getLoopFlowInclusion()
    {
        return includeLoopFlow;
    }
 
    bool getPhaseShiftInclusion()
    {
        return includePhaseShift;
    }
 
    bool setUpToDate(const bool value)
    {
        return isUpToDate = value;
    }
 
    bool getUpToDate()
    {
        return isUpToDate;
    }
 
    bool update();
 
    bool updateLinks();
 
    bool checkValidityOfNodalLoopFlow(linkInfo* linkInfo, size_t hour);
 
    void updateLinkPhaseShift(linkInfo* linkInfo, size_t hour) const;
    bool checkLinkPhaseShift(linkInfo* linkInfo, size_t hour) const;
 
    void setCalendarStart(int start)
    {
        calendarStart = start;
    }
 
    void setCalendarEnd(int end)
    {
        calendarEnd = end;
    }
 
    uint getCalendarStart()
    {
        return calendarStart;
    }
 
    uint getCalendarEnd()
    {
        return calendarEnd;
    }
 
private:
    std::shared_ptr<Antares::Data::BindingConstraint> addConstraint(
      const Data::ConstraintName& name,
      const Yuni::String& op,
      const Yuni::String& type,
      const WeightMap& weights,
      const double& secondMember);
 
public:
    std::vector<std::shared_ptr<linkInfo>> pLink;
 
private:
    std::string pPrefix;
    std::string pPrefixDelete;
    bool pDelete;
    bool includeLoopFlow = true;
    bool includePhaseShift = true;
    bool isUpToDate = false;
    bool checkNodalLoopFlow = true;
    double infiniteSecondMember = 1000000;
 
    uint calendarStart = 1;
    uint calendarEnd = 8760;
 
    std::vector<std::vector<linkInfo*>> pMesh;
 
    std::map<Data::Area*, std::set<linkInfo*>> areaToLinks;
 
    Antares::Data::Study& pStudy;
 
    Graph::Grid<Antares::Data::Area> _grid;
 
}; // class cbuilder
 
} // namespace Antares
 
#endif // __ANTARES_CONSTRAINTSBUILDER_BUILDER_CBUILDER_H__