ConstraintBuilder.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 "antares/solver/simulation/sim_structure_probleme_economique.h"
 
#include "../opt_fonctions.h"
#include "../opt_rename_problem.h"
#include "../variables/VariableManagement.h"
 
// TODO God struct should be decomposed
class ConstraintBuilderData final
{
public:
    std::vector<double>& Pi;
    std::vector<int>& Colonne;
    int& nombreDeContraintes;
    int& nombreDeTermesDansLaMatriceDeContrainte;
    std::vector<int>& IndicesDebutDeLigne;
    std::vector<double>& CoefficientsDeLaMatriceDesContraintes;
    std::vector<int>& IndicesColonnes;
    std::vector<int>& NombreDeTermesDesLignes;
    std::string& Sens;
    int& IncrementDAllocationMatriceDesContraintes;
    std::vector<CORRESPONDANCES_DES_VARIABLES>& CorrespondanceVarNativesVarOptim;
    const int32_t& NombreDePasDeTempsPourUneOptimisation;
    std::vector<int>& NumeroDeVariableStockFinal;
    std::vector<std::vector<int>>& NumeroDeVariableDeTrancheDeStock;
    std::vector<std::string>& NomDesContraintes;
    const std::vector<const char*>& NomsDesPays;
    const uint32_t& weekInTheYear;
    const uint32_t& NombreDePasDeTemps;
};
 
class ConstraintBuilder final
{
public:
    ConstraintBuilder() = delete;
 
    explicit ConstraintBuilder(ConstraintBuilderData& data):
        data(data),
        variableManager_(data.CorrespondanceVarNativesVarOptim,
                         data.NumeroDeVariableStockFinal,
                         data.NumeroDeVariableDeTrancheDeStock,
                         data.NombreDePasDeTempsPourUneOptimisation)
    {
    }
 
    ConstraintBuilder& updateHourWithinWeek(unsigned hour)
    {
        hourInWeek_ = hour;
        return *this;
    }
 
    ConstraintBuilder& DispatchableProduction(unsigned int index,
                                              double coeff,
                                              int offset = 0,
                                              int delta = 0);
 
    ConstraintBuilder& NumberOfDispatchableUnits(unsigned int index, double coeff);
 
    ConstraintBuilder& NumberStoppingDispatchableUnits(unsigned int index, double coeff);
 
    ConstraintBuilder& NumberStartingDispatchableUnits(unsigned int index, double coeff);
 
    ConstraintBuilder& NumberBreakingDownDispatchableUnits(unsigned int index, double coeff);
 
    ConstraintBuilder& NTCDirect(unsigned int index, double coeff, int offset = 0, int delta = 0);
 
    ConstraintBuilder& IntercoDirectCost(unsigned int index, double coeff);
 
    ConstraintBuilder& IntercoIndirectCost(unsigned int index, double coeff);
 
    ConstraintBuilder& ShortTermStorageInjection(unsigned int index,
                                                 double coeff,
                                                 int offset = 0,
                                                 int delta = 0);
 
    ConstraintBuilder& ShortTermStorageWithdrawal(unsigned int index,
                                                  double coeff,
                                                  int offset = 0,
                                                  int delta = 0);
 
    ConstraintBuilder& ShortTermStorageLevel(unsigned int index,
                                             double coeff,
                                             int offset = 0,
                                             int delta = 0);
 
    ConstraintBuilder& ShortTermStorageOverflow(unsigned int index,
                                                double coeff,
                                                int offset = 0,
                                                int delta = 0);
 
    ConstraintBuilder& ShortTermCostVariationInjection(unsigned int index,
                                                       double coeff,
                                                       int offset = 0,
                                                       int delta = 0);
    ConstraintBuilder& ShortTermCostVariationWithdrawal(unsigned int index,
                                                        double coeff,
                                                        int offset = 0,
                                                        int delta = 0);
 
    ConstraintBuilder& HydProd(unsigned int index, double coeff);
 
    ConstraintBuilder& HydProdDown(unsigned int index, double coeff);
 
    ConstraintBuilder& HydProdUp(unsigned int index, double coeff);
 
    ConstraintBuilder& Pumping(unsigned int index, double coeff);
 
    ConstraintBuilder& HydroLevel(unsigned int index, double coeff);
 
    ConstraintBuilder& Overflow(unsigned int index, double coeff);
 
    ConstraintBuilder& FinalStorage(unsigned int index, double coeff);
 
    ConstraintBuilder& PositiveUnsuppliedEnergy(unsigned int index, double coeff);
 
    ConstraintBuilder& NegativeUnsuppliedEnergy(unsigned int index, double coeff);
 
    ConstraintBuilder& LayerStorage(unsigned area, unsigned layer, double coeff);
 
 
    class ConstraintBuilderInvalidOperator final: public std::runtime_error
    {
    public:
        using std::runtime_error::runtime_error;
    };
 
    ConstraintBuilder& SetOperator(char op)
    {
        if (op == '<' || op == '=' || op == '>')
        {
            operator_ = op;
        }
        else
        {
            throw ConstraintBuilderInvalidOperator(std::string("Invalid operator: ") + op);
        }
 
        return *this;
    }
 
    ConstraintBuilder& equalTo()
    {
        operator_ = '=';
        return *this;
    }
 
    ConstraintBuilder& lessThan()
    {
        operator_ = '<';
        return *this;
    }
 
    ConstraintBuilder& greaterThan()
    {
        operator_ = '>';
        return *this;
    }
 
    void build();
 
    int NumberOfVariables() const
    {
        return nombreDeTermes_;
    }
 
    ConstraintBuilderData& data;
 
private:
    void OPT_ChargerLaContrainteDansLaMatriceDesContraintes();
 
    unsigned int hourInWeek_ = 0;
 
    char operator_ = '=';
    int nombreDeTermes_ = 0;
 
    void AddVariable(int index, double coeff);
 
    VariableManagement::VariableManager variableManager_;
};
 
class ConstraintFactory
{
public:
    ConstraintFactory() = delete;
 
    explicit ConstraintFactory(ConstraintBuilder& builder):
        builder(builder)
    {
    }
 
    ConstraintBuilder& builder;
};
 
// Helper functions
inline void ExportPaliers(const PALIERS_THERMIQUES& PaliersThermiquesDuPays,
                          ConstraintBuilder& newConstraintBuilder)
{
    for (int index = 0; index < PaliersThermiquesDuPays.NombreDePaliersThermiques; index++)
    {
        const int palier = PaliersThermiquesDuPays
                             .NumeroDuPalierDansLEnsembleDesPaliersThermiques[index];
        newConstraintBuilder.DispatchableProduction(palier, -1.0);
    }
}
 
class BindingConstraintData final
{
public:
    const char& TypeDeContrainteCouplante;
    const int& NombreDInterconnexionsDansLaContrainteCouplante;
    const std::vector<int>& NumeroDeLInterconnexion;
    const std::vector<double>& PoidsDeLInterconnexion;
    const std::vector<int>& OffsetTemporelSurLInterco;
    const int& NombreDePaliersDispatchDansLaContrainteCouplante;
    const std::vector<int>& PaysDuPalierDispatch;
    const std::vector<int>& NumeroDuPalierDispatch;
    const std::vector<double>& PoidsDuPalierDispatch;
    const std::vector<int>& OffsetTemporelSurLePalierDispatch;
    const char& SensDeLaContrainteCouplante;
    const char* const& NomDeLaContrainteCouplante;
    const std::vector<PALIERS_THERMIQUES>& PaliersThermiquesDuPays;
};
 
struct StartUpCostsData
{
    const std::vector<PALIERS_THERMIQUES>& PaliersThermiquesDuPays;
    bool Simulation;
};
 
struct ShortTermStorageData
{
    std::vector<CORRESPONDANCES_DES_CONTRAINTES>& CorrespondanceCntNativesCntOptim;
 
    const std::vector<::AREA_INPUT>& ShortTermStorage;
};
 
struct ShortTermStorageCumulativeConstraintData: ShortTermStorageData
{
    CORRESPONDANCES_DES_CONTRAINTES_HEBDOMADAIRES& CorrespondanceCntNativesCntOptimHebdomadaires;
};