Feature/remove problem hebdo from constraint builder lib

src/solver/optimisation/AreaBalance.cpp

@@ -0,0 +1,66 @@
+#include "AreaBalance.h"
+
+static void shortTermStorageBalance(const ::ShortTermStorage::AREA_INPUT& shortTermStorageInput,
+                                    ConstraintBuilder& constraintBuilder,
+                                    std::vector<int>& InjectionVariable,
+                                    std::vector<int>& WithdrawalVariable)
+{
+    for (const auto& storage : shortTermStorageInput)
+    {
+        unsigned index = storage.clusterGlobalIndex;
+        if (const int varInjection = InjectionVariable[index]; varInjection >= 0)
+        {
+            constraintBuilder.include(Variable::ShortTermStorageInjection(index), 1.0);
+        }
+        if (const int varWithdrawal = WithdrawalVariable[index]; varWithdrawal >= 0)
+        {
+            constraintBuilder.include(Variable::ShortTermStorageWithdrawal(index), -1.0);
+        }
+    }
+}
+
+// Constraint definitions
+void AreaBalance::add(int pdt, int pays, AreaBalanceData& data)
+{
+    // /** can be done without this --- keep it for now**/
+    // data.NumeroDeContrainteDesBilansPays[pays] = builder.data.nombreDeContraintes;
+
+    // /******/
+    // // TODO improve this
+
+    // ConstraintNamer namer(builder.data.NomDesContraintes, builder.data.NamedProblems);
+    // namer.UpdateTimeStep(builder.data.weekInTheYear * 168 + pdt);
+    // namer.UpdateArea(builder.data.NomsDesPays[pays]);
+    // namer.AreaBalance(builder.data.nombreDeContraintes);
+
+    // builder.updateHourWithinWeek(pdt);
+
+    // int interco = data.IndexDebutIntercoOrigine[pays];
+    // while (interco >= 0)
+    // {
+    //     builder.include(Variable::NTCDirect(interco), 1.0);
+    //     interco = data.IndexSuivantIntercoOrigine[interco];
+    //     }
+
+    // interco = data.IndexDebutIntercoExtremite[pays];
+    // while (interco >= 0)
+    // {
+    //     builder.include(Variable::NTCDirect(interco), -1.0);
+    //     interco = data.IndexSuivantIntercoExtremite[interco];
+    // }
+
+    // exportPaliers(data.PaliersThermiquesDuPays, builder);
+    // builder.include(Variable::HydProd(pays), -1.0)
+    //   .include(Variable::Pumping(pays), 1.0)
+    //   .include(Variable::PositiveUnsuppliedEnergy(pays), -1.0)
+    //   .include(Variable::NegativeUnsuppliedEnergy(pays), 1.0);
+
+    // shortTermStorageBalance(
+    //   data.ShortTermStorage[pays], builder, data.InjectionVariable, data.WithdrawalVariable);
+
+    // builder.equalTo();
+    // builder.build();
+    logs.info() << "" << data.NumeroDeContrainteDesBilansPays[pays] << "\n";
+    int a = 13;
+    int b = a / 33;
+}

src/solver/optimisation/AreaBalance.h

@@ -0,0 +1,46 @@
+#pragma once
+#include "constraint_builder.h"
+
+struct AreaBalanceData
+{
+    AreaBalanceData(std::vector<int>& NumeroDeContrainteDesBilansPays,
+                    std::vector<int>& InjectionVariable,
+                    std::vector<int>& WithdrawalVariable,
+                    const std::vector<int>& IndexDebutIntercoOrigine,
+                    const std::vector<int>& IndexSuivantIntercoOrigine,
+                    const std::vector<int>& IndexDebutIntercoExtremite,
+                    const std::vector<int>& IndexSuivantIntercoExtremite,
+                    const PALIERS_THERMIQUES& PaliersThermiquesDuPays,
+                    const std::vector<::ShortTermStorage::AREA_INPUT>& ShortTermStorage)
+
+     :
+     NumeroDeContrainteDesBilansPays(NumeroDeContrainteDesBilansPays),
+     InjectionVariable(InjectionVariable),
+     WithdrawalVariable(WithdrawalVariable),
+     IndexDebutIntercoOrigine(IndexDebutIntercoOrigine),
+     IndexSuivantIntercoOrigine(IndexSuivantIntercoOrigine),
+     IndexDebutIntercoExtremite(IndexDebutIntercoExtremite),
+     IndexSuivantIntercoExtremite(IndexSuivantIntercoExtremite),
+     PaliersThermiquesDuPays(PaliersThermiquesDuPays),
+     ShortTermStorage(ShortTermStorage)
+    {
+    }
+
+    std::vector<int>& NumeroDeContrainteDesBilansPays;
+    std::vector<int>& InjectionVariable;
+    std::vector<int>& WithdrawalVariable;
+    const std::vector<int>& IndexDebutIntercoOrigine;
+    const std::vector<int>& IndexSuivantIntercoOrigine;
+    const std::vector<int>& IndexDebutIntercoExtremite;
+    const std::vector<int>& IndexSuivantIntercoExtremite;
+    const PALIERS_THERMIQUES& PaliersThermiquesDuPays;
+    const std::vector<::ShortTermStorage::AREA_INPUT>& ShortTermStorage;
+};
+
+class AreaBalance : private Constraint
+{
+public:
+    using Constraint::Constraint;
+
+    void add(int pdt, int pays, AreaBalanceData& data);
+};

src/solver/optimisation/AreaHydroLevel.cpp

@@ -0,0 +1,28 @@
+#include "AreaHydroLevel.h"
+
+void AreaHydroLevel::add(int pays, int pdt, AreaHydroLevelData& data)
+{
+    data.NumeroDeContrainteDesNiveauxPays[pays] = builder.data.nombreDeContraintes;
+    if (data.SuiviNiveauHoraire)
+    {
+        builder.updateHourWithinWeek(pdt).include(Variable::HydroLevel(pays), 1.0);
+        if (pdt > 0)
+        {
+            builder.updateHourWithinWeek(pdt - 1).include(Variable::HydroLevel(pays), -1.0);
+        }
+        ConstraintNamer namer(builder.data.NomDesContraintes, builder.data.NamedProblems);
+
+        namer.UpdateArea(builder.data.NomsDesPays[pays]);
+        namer.UpdateTimeStep(builder.data.weekInTheYear * 168 + pdt);
+        namer.AreaHydroLevel(builder.data.nombreDeContraintes);
+        data.NumeroDeContrainteDesNiveauxPays[pays] = builder.data.nombreDeContraintes;
+        builder.updateHourWithinWeek(pdt)
+          .include(Variable::HydProd(pays), 1.0)
+          .include(Variable::Pumping(pays), -data.PumpingRatio)
+          .include(Variable::Overflow(pays), 1.)
+          .equalTo()
+          .build();
+    }
+    else
+        data.NumeroDeContrainteDesNiveauxPays[pays] = -1;
+}

src/solver/optimisation/AreaHydroLevel.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "constraint_builder.h"
+
+struct AreaHydroLevelData
+{
+    std::vector<int>& NumeroDeContrainteDesNiveauxPays;
+    const bool& SuiviNiveauHoraire;
+    const double& PumpingRatio;
+};
+
+class AreaHydroLevel : private Constraint
+{
+    public:
+    using Constraint::Constraint;
+    void add(int pays, int pdt, AreaHydroLevelData& data);
+};

src/solver/optimisation/BindingConstraintDay.cpp

@@ -0,0 +1,88 @@
+#include "BindingConstraintDay.h"
+
+void BindingConstraintDay::add(int cntCouplante, BindingConstraintDayData& data)
+{
+    if (data.TypeDeContrainteCouplante != CONTRAINTE_JOURNALIERE)
+        return;
+
+    const int nbInterco = data.NombreDInterconnexionsDansLaContrainteCouplante;
+    const int nbClusters = data.NombreDePaliersDispatchDansLaContrainteCouplante;
+
+    const int NombreDePasDeTempsPourUneOptimisation
+      = builder.data.NombreDePasDeTempsPourUneOptimisation; // TODO
+    const int NombreDePasDeTempsDUneJournee = data.NombreDePasDeTempsDUneJournee;
+    int pdtDebut = 0;
+    while (pdtDebut < NombreDePasDeTempsPourUneOptimisation)
+    {
+        int jour = data.NumeroDeJourDuPasDeTemps[pdtDebut];
+
+        for (int index = 0; index < nbInterco; index++)
+        {
+            int interco = data.NumeroDeLInterconnexion[index];
+            double poids = data.PoidsDeLInterconnexion[index];
+            int offset = data.OffsetTemporelSurLInterco[index];
+
+            for (int pdt = pdtDebut; pdt < pdtDebut + NombreDePasDeTempsDUneJournee; pdt++)
+            {
+                int pdt1;
+                if (offset >= 0)
+                {
+                    pdt1 = (pdt + offset) % builder.data.NombreDePasDeTempsPourUneOptimisation;
+                }
+                else
+                {
+                    pdt1 = (pdt + offset + builder.data.NombreDePasDeTemps)
+                           % builder.data.NombreDePasDeTempsPourUneOptimisation;
+                }
+                builder.updateHourWithinWeek(pdt1).include(
+                  Variable::NTCDirect(interco), poids, 0, false, builder.data.NombreDePasDeTemps);
+            }
+        }
+
+        for (int index = 0; index < nbClusters; index++)
+        {
+            int pays = data.PaysDuPalierDispatch[index];
+            const PALIERS_THERMIQUES& PaliersThermiquesDuPays = data.PaliersThermiquesDuPays[pays];
+            const int palier
+              = PaliersThermiquesDuPays.NumeroDuPalierDansLEnsembleDesPaliersThermiques
+                  [data.NumeroDuPalierDispatch[index]];
+            double poids = data.PoidsDuPalierDispatch[index];
+            int offset = data.OffsetTemporelSurLePalierDispatch[index];
+
+            for (int pdt = pdtDebut; pdt < pdtDebut + NombreDePasDeTempsDUneJournee; pdt++)
+            {
+                int pdt1;
+                if (offset >= 0)
+                {
+                    pdt1 = (pdt + offset) % builder.data.NombreDePasDeTempsPourUneOptimisation;
+                }
+                else
+                {
+                    pdt1 = (pdt + offset + builder.data.NombreDePasDeTemps)
+                           % builder.data.NombreDePasDeTempsPourUneOptimisation;
+                }
+
+                builder.updateHourWithinWeek(pdt1).include(Variable::DispatchableProduction(palier),
+                                                           poids,
+                                                           0,
+                                                           false,
+                                                           builder.data.NombreDePasDeTemps);
+            }
+        }
+
+        data.CorrespondanceCntNativesCntOptimJournalieres[jour]
+          .NumeroDeContrainteDesContraintesCouplantes[cntCouplante]
+          = builder.data.nombreDeContraintes;
+
+        char op = data.SensDeLaContrainteCouplante;
+        builder.operatorRHS(op);
+        {
+            ConstraintNamer namer(builder.data.NomDesContraintes, builder.data.NamedProblems);
+            namer.UpdateTimeStep(jour);
+            namer.BindingConstraintDay(builder.data.nombreDeContraintes,
+                                       data.NomDeLaContrainteCouplante);
+        }
+        builder.build();
+        pdtDebut += data.NombreDePasDeTempsDUneJournee;
+    }
+}

src/solver/optimisation/BindingConstraintDay.h

@@ -0,0 +1,63 @@
+#pragma once
+#include "constraint_builder.h"
+
+struct BindingConstraintDayData : public BindingConstraintData
+{
+    BindingConstraintDayData(BindingConstraintDayData& data) :
+     BindingConstraintData(data),
+     CorrespondanceCntNativesCntOptimJournalieres(
+       data.CorrespondanceCntNativesCntOptimJournalieres),
+     NombreDePasDeTempsDUneJournee(data.NombreDePasDeTempsDUneJournee),
+     NumeroDeJourDuPasDeTemps(data.NumeroDeJourDuPasDeTemps)
+    {
+    }
+    BindingConstraintDayData(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,
+                             std::vector<CORRESPONDANCES_DES_CONTRAINTES_JOURNALIERES>&
+                               CorrespondanceCntNativesCntOptimJournalieres,
+                             const int32_t& NombreDePasDeTempsDUneJournee,
+                             std::vector<int32_t>& NumeroDeJourDuPasDeTemps) :
+     BindingConstraintData(TypeDeContrainteCouplante,
+                           NombreDInterconnexionsDansLaContrainteCouplante,
+                           NumeroDeLInterconnexion,
+                           PoidsDeLInterconnexion,
+                           OffsetTemporelSurLInterco,
+                           NombreDePaliersDispatchDansLaContrainteCouplante,
+                           PaysDuPalierDispatch,
+                           NumeroDuPalierDispatch,
+                           PoidsDuPalierDispatch,
+                           OffsetTemporelSurLePalierDispatch,
+                           SensDeLaContrainteCouplante,
+                           NomDeLaContrainteCouplante,
+                           PaliersThermiquesDuPays),
+     CorrespondanceCntNativesCntOptimJournalieres(CorrespondanceCntNativesCntOptimJournalieres),
+     NombreDePasDeTempsDUneJournee(NombreDePasDeTempsDUneJournee),
+     NumeroDeJourDuPasDeTemps(NumeroDeJourDuPasDeTemps)
+    {
+    }
+
+    // std::vector<std::vector<int>&>& CorrespondanceCntNativesCntOptimJournalieres;
+    std::vector<CORRESPONDANCES_DES_CONTRAINTES_JOURNALIERES>&
+      CorrespondanceCntNativesCntOptimJournalieres;
+
+    const int32_t& NombreDePasDeTempsDUneJournee;
+
+    std::vector<int32_t>& NumeroDeJourDuPasDeTemps;
+};
+class BindingConstraintDay : private Constraint
+{
+public:
+    using Constraint::Constraint;
+    void add(int cntCouplante, BindingConstraintDayData& data);
+};

src/solver/optimisation/BindingConstraintHour.cpp

@@ -0,0 +1,73 @@
+#include "BindingConstraintHour.h"
+
+void BindingConstraintHour::add(int pdt, int cntCouplante, BindingConstraintHourData& data)
+{
+    data.NumeroDeContrainteDesContraintesCouplantes[cntCouplante]
+      = builder.data.nombreDeContraintes;
+
+    if (data.TypeDeContrainteCouplante != CONTRAINTE_HORAIRE)
+        return;
+
+    builder.updateHourWithinWeek(pdt);
+    // Links
+    const int nbInterco = data.NombreDInterconnexionsDansLaContrainteCouplante;
+    for (int index = 0; index < nbInterco; index++)
+    {
+        const int interco = data.NumeroDeLInterconnexion[index];
+        const double poids = data.PoidsDeLInterconnexion[index];
+        const int offset = data.OffsetTemporelSurLInterco[index];
+        int pdt1;
+        if (offset >= 0)
+        {
+            pdt1 = (pdt + offset) % builder.data.NombreDePasDeTempsPourUneOptimisation;
+        }
+        else
+        {
+            pdt1 = (pdt + offset + builder.data.NombreDePasDeTemps)
+                   % builder.data.NombreDePasDeTempsPourUneOptimisation;
+        }
+
+        builder.updateHourWithinWeek(pdt1).include(
+          Variable::NTCDirect(interco), poids, 0, false, builder.data.NombreDePasDeTemps);
+    }
+
+    // Thermal clusters
+    const int nbClusters = data.NombreDePaliersDispatchDansLaContrainteCouplante;
+    for (int index = 0; index < nbClusters; index++)
+    {
+        const int pays = data.PaysDuPalierDispatch[index];
+        const PALIERS_THERMIQUES& PaliersThermiquesDuPays = data.PaliersThermiquesDuPays[pays];
+        const int palier
+          = PaliersThermiquesDuPays
+              .NumeroDuPalierDansLEnsembleDesPaliersThermiques[data.NumeroDuPalierDispatch[index]];
+        const double poids = data.PoidsDuPalierDispatch[index];
+        const int offset = data.OffsetTemporelSurLePalierDispatch[index];
+        int pdt1;
+
+        if (offset >= 0)
+        {
+            pdt1 = (pdt + offset) % builder.data.NombreDePasDeTempsPourUneOptimisation;
+        }
+        else
+        {
+            pdt1 = (pdt + offset + builder.data.NombreDePasDeTemps)
+                   % builder.data.NombreDePasDeTempsPourUneOptimisation;
+        }
+
+        builder.updateHourWithinWeek(pdt1).include(Variable::DispatchableProduction(palier),
+                                                   poids,
+                                                   0,
+                                                   false,
+                                                   builder.data.NombreDePasDeTemps);
+    }
+
+    char op = data.SensDeLaContrainteCouplante;
+    builder.operatorRHS(op);
+    {
+        ConstraintNamer namer(builder.data.NomDesContraintes, builder.data.NamedProblems);
+        namer.UpdateTimeStep(builder.data.weekInTheYear * 168 + pdt);
+        namer.BindingConstraintHour(builder.data.nombreDeContraintes,
+                                    data.NomDeLaContrainteCouplante);
+    }
+    builder.build();
+}