refactor constraint construction

src/solver/optimisation/AreaBalance.cpp

@@ -0,0 +1,75 @@
+#include "AreaBalance.h"
+#include "opt_rename_problem.h"
+
+static void shortTermStorageBalance(const ::ShortTermStorage::AREA_INPUT& shortTermStorageInput,
+                                    std::shared_ptr<NewConstraintBuilder> 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(NewVariable::ShortTermStorageInjection(index), 1.0);
+        }
+        if (const int varWithdrawal = WithdrawalVariable[index]; varWithdrawal >= 0)
+        {
+            constraintBuilder->include(NewVariable::ShortTermStorageWithdrawal(index), -1.0);
+        }
+    }
+}
+
+// Constraint definitions
+void AreaBalance::odd(int pays, std::shared_ptr<AreaBalanceData> data)
+{
+    int a = 13;
+    int b = a * 36;
+    logs.info() << "int odd builder->data->nombreDeContraintes"
+                << builder->data->nombreDeContraintes << "\n";
+    logs.info() << "int odd data->NumeroDeContrainteDesBilansPays[pays]"
+                << data->NumeroDeContrainteDesBilansPays[pays] << "\n";
+    data->NumeroDeContrainteDesBilansPays[pays] = builder->data->nombreDeContraintes;
+    logs.info() << "int odd 2" << a << "\n";
+}
+void AreaBalance::add(int pdt, int pays, std::shared_ptr<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(NewVariable::NTCDirect(interco), 1.0);
+        interco = data->IndexSuivantIntercoOrigine[interco];
+    }
+
+    interco = data->IndexDebutIntercoExtremite[pays];
+    while (interco >= 0)
+    {
+        builder->include(NewVariable::NTCDirect(interco), -1.0);
+        interco = data->IndexSuivantIntercoExtremite[interco];
+    }
+
+    new_exportPaliers(data->PaliersThermiquesDuPays, builder);
+    builder->include(NewVariable::HydProd(pays), -1.0)
+      .include(NewVariable::Pumping(pays), 1.0)
+      .include(NewVariable::PositiveUnsuppliedEnergy(pays), -1.0)
+      .include(NewVariable::NegativeUnsuppliedEnergy(pays), 1.0);
+
+    shortTermStorageBalance(
+      data->ShortTermStorage[pays], builder, data->InjectionVariable, data->WithdrawalVariable);
+
+    builder->equalTo();
+    builder->build();
+}

src/solver/optimisation/AreaBalance.h

@@ -0,0 +1,25 @@
+#pragma once
+#include "new_constraint_builder.h"
+
+struct 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;
+};
+
+class AreaBalance : public NewConstraint
+{
+public:
+    using NewConstraint::NewConstraint;
+
+    void add(int pdt, int pays, std::shared_ptr<AreaBalanceData> data);
+    void odd(int pays, std::shared_ptr<AreaBalanceData> data);
+    // void add(int pdt, int pays, AreaBalanceData& data);
+};

src/solver/optimisation/AreaHydroLevel.cpp

@@ -0,0 +1,36 @@
+#include "AreaHydroLevel.h"
+
+void AreaHydroLevel::add(int pays, int pdt)
+{
+    const auto& CorrespondanceVarNativesVarOptim
+      = problemeHebdo->CorrespondanceVarNativesVarOptim[pdt];
+    CORRESPONDANCES_DES_CONTRAINTES& CorrespondanceCntNativesCntOptim
+      = problemeHebdo->CorrespondanceCntNativesCntOptim[pdt];
+    CorrespondanceCntNativesCntOptim.NumeroDeContrainteDesNiveauxPays[pays]
+      = problemeHebdo->ProblemeAResoudre->NombreDeContraintes;
+    if (problemeHebdo->CaracteristiquesHydrauliques[pays].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(problemeHebdo->ProblemeAResoudre->NomDesContraintes,
+                              problemeHebdo->NamedProblems);
+
+        namer.UpdateArea(problemeHebdo->NomsDesPays[pays]);
+        namer.UpdateTimeStep(problemeHebdo->weekInTheYear * 168 + pdt);
+        namer.AreaHydroLevel(problemeHebdo->ProblemeAResoudre->NombreDeContraintes);
+        CorrespondanceCntNativesCntOptim.NumeroDeContrainteDesNiveauxPays[pays]
+          = problemeHebdo->ProblemeAResoudre->NombreDeContraintes;
+        builder.updateHourWithinWeek(pdt)
+          .include(Variable::HydProd(pays), 1.0)
+          .include(Variable::Pumping(pays),
+                   -problemeHebdo->CaracteristiquesHydrauliques[pays].PumpingRatio)
+          .include(Variable::Overflow(pays), 1.)
+          .equalTo()
+          .build();
+    }
+    else
+        CorrespondanceCntNativesCntOptim.NumeroDeContrainteDesNiveauxPays[pays] = -1;
+}

src/solver/optimisation/AreaHydroLevel.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "constraint_builder.h"
+
+class AreaHydroLevel : private Constraint
+{
+    public:
+    using Constraint::Constraint;
+    void add(int pays, int pdt);
+};

src/solver/optimisation/BindingConstraintDay.cpp

@@ -0,0 +1,92 @@
+#include "BindingConstraintDay.h"
+
+void BindingConstraintDay::add(int cntCouplante, std::shared_ptr<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(NewVariable::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(
+                  NewVariable::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,19 @@
+#pragma once
+#include "new_constraint_builder.h"
+
+struct BindingConstraintDayData : public BindingConstraintData
+{
+    std::vector<CORRESPONDANCES_DES_CONTRAINTES_JOURNALIERES>&
+      CorrespondanceCntNativesCntOptimJournalieres;
+
+    const int32_t& NombreDePasDeTempsDUneJournee;
+
+    std::vector<int32_t>& NumeroDeJourDuPasDeTemps;
+};
+
+class BindingConstraintDay : private NewConstraint
+{
+public:
+    using NewConstraint::NewConstraint;
+    void add(int cntCouplante, std::shared_ptr<BindingConstraintDayData> data);
+};

src/solver/optimisation/BindingConstraintDayGroup.cpp

@@ -0,0 +1,40 @@
+#include "BindingConstraintDayGroup.h"
+#include "new_constraint_builder_utils.h"
+
+std::shared_ptr<BindingConstraintDayData>
+  BindingConstraintDayGroup::GetBindingConstraintDayDataFromProblemHebdo(int cntCouplante)
+{
+    const CONTRAINTES_COUPLANTES& MatriceDesContraintesCouplantes
+      = problemeHebdo_->MatriceDesContraintesCouplantes[cntCouplante];
+
+    BindingConstraintDayData data
+      = {MatriceDesContraintesCouplantes.TypeDeContrainteCouplante,
+         MatriceDesContraintesCouplantes.NombreDInterconnexionsDansLaContrainteCouplante,
+         MatriceDesContraintesCouplantes.NumeroDeLInterconnexion,
+         MatriceDesContraintesCouplantes.PoidsDeLInterconnexion,
+         MatriceDesContraintesCouplantes.OffsetTemporelSurLInterco,
+         MatriceDesContraintesCouplantes.NombreDePaliersDispatchDansLaContrainteCouplante,
+         MatriceDesContraintesCouplantes.PaysDuPalierDispatch,
+         MatriceDesContraintesCouplantes.NumeroDuPalierDispatch,
+         MatriceDesContraintesCouplantes.PoidsDuPalierDispatch,
+         MatriceDesContraintesCouplantes.OffsetTemporelSurLePalierDispatch,
+         MatriceDesContraintesCouplantes.SensDeLaContrainteCouplante,
+         MatriceDesContraintesCouplantes.NomDeLaContrainteCouplante,
+         problemeHebdo_->PaliersThermiquesDuPays,
+         problemeHebdo_->CorrespondanceCntNativesCntOptimJournalieres,
+         problemeHebdo_->NombreDePasDeTempsDUneJournee,
+         problemeHebdo_->NumeroDeJourDuPasDeTemps};
+
+    return std::make_shared<BindingConstraintDayData>(data);
+}
+
+void BindingConstraintDayGroup::Build()
+{
+    BindingConstraintDay bindingConstraintDay(builder_);
+    for (uint32_t cntCouplante = 0; cntCouplante < problemeHebdo_->NombreDeContraintesCouplantes;
+         cntCouplante++)
+    {
+                bindingConstraintDay.add(cntCouplante,
+                                 GetBindingConstraintDayDataFromProblemHebdo(cntCouplante));
+    }
+}

src/solver/optimisation/BindingConstraintDayGroup.h

@@ -0,0 +1,16 @@
+#pragma once
+#include "ConstraintGroup.h"
+#include "BindingConstraintDay.h"
+
+class BindingConstraintDayGroup : public ConstraintGroup
+{
+public:
+    using ConstraintGroup::ConstraintGroup;
+
+    /*TODO Rename this*/
+    void Build() override;
+
+private:
+    std::shared_ptr<BindingConstraintDayData> GetBindingConstraintDayDataFromProblemHebdo(
+      int cntCouplante);
+};