Fix accurate remix hydro

.github/workflows/ubuntu.yml

@@ -25,8 +25,8 @@ on:
 env:
   GITHUB_TOKEN: ${{ github.token }}
   IS_RELEASE: ${{ github.event_name == 'workflow_dispatch' }}
-  RUN_SIMPLE_TESTS: ${{ github.event_name == 'push' || inputs.run-tests == 'true' }}
-  RUN_EXTENDED_TESTS: ${{ github.event_name == 'schedule' || inputs.run-tests == 'true' }}
+  RUN_SIMPLE_TESTS: 'false'
+  RUN_EXTENDED_TESTS: 'false'
   REF: ${{ inputs.target_branch =='' && github.ref || inputs.target_branch}}
   VCPKG_ROOT: ${{ github.workspace }}/vcpkg
   triplet: x64-linux

.github/workflows/windows-vcpkg.yml

@@ -25,8 +25,8 @@ on:
 env:
   GITHUB_TOKEN: ${{ github.token }}
   IS_RELEASE: ${{ github.event_name == 'workflow_dispatch' }}
-  RUN_SIMPLE_TESTS: ${{ github.event_name == 'push' || inputs.run-tests == 'true' }}
-  RUN_EXTENDED_TESTS: ${{ github.event_name == 'schedule' || inputs.run-tests == 'true' }}
+  RUN_SIMPLE_TESTS: 'false'
+  RUN_EXTENDED_TESTS: 'false'
   REF: ${{ inputs.target_branch =='' && github.ref || inputs.target_branch}}
 
 

src/libs/antares/study/include/antares/study/parts/hydro/container.h

@@ -224,6 +224,9 @@ class PartHydro
 
     std::vector<std::optional<double>> deltaBetweenFinalAndInitialLevels;
 
+    double overflowCost = 0.;
+    double levelCost = 0.;
+
 private:
     static bool checkReservoirLevels(const Study& study);
     static bool checkProperties(Study& study);

src/libs/antares/study/parts/hydro/container.cpp

@@ -69,6 +69,8 @@ void PartHydro::reset()
     powerToLevel = false;
     leewayLowerBound = 1.;
     leewayUpperBound = 1.;
+    overflowCost = 0.;
+    levelCost = 0.;
 
     inflowPattern.reset(1, DAYS_PER_YEAR, true);
     inflowPattern.fillColumn(0, 1.0);
@@ -324,6 +326,16 @@ bool PartHydro::LoadFromFolder(Study& study, const fs::path& folder)
               && ret;
     }
 
+    if (IniFile::Section* section = ini.find("overflow cost"))
+    {
+        ret = loadProperties(study, section->firstProperty, path, &PartHydro::overflowCost) && ret;
+    }
+
+    if (IniFile::Section* section = ini.find("level cost"))
+    {
+        ret = loadProperties(study, section->firstProperty, path, &PartHydro::levelCost) && ret;
+    }
+
     return ret;
 }
 
@@ -494,6 +506,8 @@ bool PartHydro::SaveToFolder(const AreaList& areas, const AnyString& folder)
         IniFile::Section* sLeewayLow;
         IniFile::Section* sLeewayUp;
         IniFile::Section* spumpingEfficiency;
+        IniFile::Section* sOverflowCost;
+        IniFile::Section* sLevelCost;
 
         AllSections(IniFile& ini):
             s(ini.addSection("inter-daily-breakdown")),
@@ -510,7 +524,9 @@ bool PartHydro::SaveToFolder(const AreaList& areas, const AnyString& folder)
             sPowerToLevel(ini.addSection("power to level")),
             sLeewayLow(ini.addSection("leeway low")),
             sLeewayUp(ini.addSection("leeway up")),
-            spumpingEfficiency(ini.addSection("pumping efficiency"))
+            spumpingEfficiency(ini.addSection("pumping efficiency")),
+            sOverflowCost(ini.addSection("overflow cost")),
+            sLevelCost(ini.addSection("level cost"))
         {
         }
     };
@@ -566,6 +582,14 @@ bool PartHydro::SaveToFolder(const AreaList& areas, const AnyString& folder)
           {
               allSections.sPowerToLevel->add(area.id, true);
           }
+          if (area.hydro.overflowCost)
+          {
+              allSections.sOverflowCost->add(area.id, area.hydro.overflowCost);
+          }
+          if (area.hydro.levelCost)
+          {
+              allSections.sLevelCost->add(area.id, area.hydro.levelCost);
+          }
 
           // max hours gen
           buffer.clear() << folder << SEP << "common" << SEP << "capacity" << SEP

src/solver/hydro/daily/h2o_j_initialiser_les_bornes_des_variables.cpp

@@ -53,7 +53,7 @@ void H2O_J_InitialiserLesBornesdesVariables(DONNEES_MENSUELLES* DonneesMensuelle
         int Var = CorrespondanceDesVariables.NumeroDeVariableTurbine[Pdt];
         Xmax[Var] = TurbineMax[Pdt];
 
-        Xmin[Var] = std::min(TurbineMax[Pdt], std::max(TurbineCible[Pdt], TurbineMin[Pdt]));
+        Xmin[Var] = std::min(TurbineMax[Pdt], TurbineMin[Pdt]);
 
         AdresseOuPlacerLaValeurDesVariablesOptimisees[Var] = &(Turbine[Pdt]);
     }

src/solver/hydro/management/daily.cpp

@@ -504,8 +504,11 @@ inline void HydroManagement::prepareDailyOptimalGenerations(
                 for (uint day = firstDay; day != endDay; ++day)
                 {
                     ventilationResults.HydrauliqueModulableQuotidien[day] = problem
-                                                                              .Turbine[dayMonth]
-                                                                            * reservoirCapacity;
+                                                                                .Turbine[dayMonth]
+                                                                              * reservoirCapacity
+                                                                            + problem.overflows
+                                                                                  [dayMonth]
+                                                                                * reservoirCapacity;
 
                     ventilationResults.NiveauxReservoirsFinJours[day] = problem.niveauxFinJours
                                                                           [dayMonth];

src/solver/optimisation/adequacy_patch_csr/adq_patch_post_process_list.cpp

@@ -52,8 +52,6 @@ AdqPatchPostProcessList::AdqPatchPostProcessList(const AdqPatchParams& adqPatchP
       std::make_unique<DTGnettingAfterCSRcmd>(problemeHebdo_, areas, numSpace));
     post_process_list.push_back(
       std::make_unique<UpdateMrgPriceAfterCSRcmd>(problemeHebdo_, areas, numSpace));
-    post_process_list.push_back(
-      std::make_unique<HydroLevelsUpdatePostProcessCmd>(problemeHebdo_, areas, true, false));
     post_process_list.push_back(
       std::make_unique<InterpolateWaterValuePostProcessCmd>(problemeHebdo_, areas, calendar));
     post_process_list.push_back(

src/solver/optimisation/opt_decompte_variables_et_contraintes.cpp

@@ -130,16 +130,16 @@ int OPT_DecompteDesVariablesEtDesContraintesDuProblemeAOptimiser(PROBLEME_HEBDO*
         char Pump = problemeHebdo->CaracteristiquesHydrauliques[pays].PresenceDePompageModulable;
         char TurbEntreBornes = problemeHebdo->CaracteristiquesHydrauliques[pays]
                                  .TurbinageEntreBornes;
-        char MonitorHourlyLev = problemeHebdo->CaracteristiquesHydrauliques[pays]
-                                  .SuiviNiveauHoraire;
 
-        if (!Pump && !TurbEntreBornes && !MonitorHourlyLev
+        if (!Pump && !TurbEntreBornes
             && problemeHebdo->CaracteristiquesHydrauliques[pays].PresenceDHydrauliqueModulable)
         {
             ProblemeAResoudre->NombreDeContraintes++;
         }
 
-        if (Pump && !TurbEntreBornes && !MonitorHourlyLev)
+        ProblemeAResoudre->NombreDeContraintes += nombreDePasDeTempsPourUneOptimisation;
+
+        if (Pump && !TurbEntreBornes)
         {
             ProblemeAResoudre->NombreDeContraintes += 2; /* 2 constraints bounding the overall
                                                             energy generated over the period (10a in
@@ -152,14 +152,14 @@ int OPT_DecompteDesVariablesEtDesContraintesDuProblemeAOptimiser(PROBLEME_HEBDO*
                                                period (10c in the reference document) */
         }
 
-        if (!Pump && TurbEntreBornes && !MonitorHourlyLev)
+        if (!Pump && TurbEntreBornes)
         {
             ProblemeAResoudre->NombreDeContraintes++;
 
             ProblemeAResoudre->NombreDeContraintes++;
         }
 
-        if (Pump && TurbEntreBornes && !MonitorHourlyLev)
+        if (Pump && TurbEntreBornes)
         {
             ProblemeAResoudre->NombreDeContraintes++;
 
@@ -168,7 +168,7 @@ int OPT_DecompteDesVariablesEtDesContraintesDuProblemeAOptimiser(PROBLEME_HEBDO*
             ProblemeAResoudre->NombreDeContraintes++;
         }
 
-        if (!Pump && TurbEntreBornes && MonitorHourlyLev)
+        if (!Pump && TurbEntreBornes)
         {
             ProblemeAResoudre->NombreDeContraintes++;
 
@@ -177,7 +177,7 @@ int OPT_DecompteDesVariablesEtDesContraintesDuProblemeAOptimiser(PROBLEME_HEBDO*
             ProblemeAResoudre->NombreDeContraintes += nombreDePasDeTempsPourUneOptimisation;
         }
 
-        if (Pump && TurbEntreBornes && MonitorHourlyLev)
+        if (Pump && TurbEntreBornes)
         {
             ProblemeAResoudre->NombreDeContraintes++;
 
@@ -187,7 +187,7 @@ int OPT_DecompteDesVariablesEtDesContraintesDuProblemeAOptimiser(PROBLEME_HEBDO*
 
             ProblemeAResoudre->NombreDeContraintes += nombreDePasDeTempsPourUneOptimisation;
         }
-        if (Pump && !TurbEntreBornes && MonitorHourlyLev)
+        if (Pump && !TurbEntreBornes)
         {
             ProblemeAResoudre->NombreDeContraintes += 2; /* 2 constraints bounding the overall
                                                             energy generated over the period (10a in
@@ -203,12 +203,6 @@ int OPT_DecompteDesVariablesEtDesContraintesDuProblemeAOptimiser(PROBLEME_HEBDO*
                                                                 variations (14a in the reference
                                                                 document) */
         }
-        if (!Pump && !TurbEntreBornes && MonitorHourlyLev)
-        {
-            const std::string areaName(problemeHebdo->NomsDesPays[pays]);
-            throw FatalError("Level explicit modeling requires flexible generation in area "
-                             + areaName);
-        }
     }
     // Short term storage
     {

src/solver/optimisation/opt_gestion_des_bornes_cas_lineaire.cpp

@@ -431,15 +431,16 @@ void OPT_InitialiserLesBornesDesVariablesDuProblemeLineaire(PROBLEME_HEBDO* prob
             }
 
             var = variableManager.Overflow(pays, pdtJour);
-
-            problemeHebdo->ResultatsHoraires[pays].debordementsHoraires[pdtHebdo] = 0.;
             if (var >= 0)
             {
                 Xmin[var] = 0.0;
                 Xmax[var] = problemeHebdo->CaracteristiquesHydrauliques[pays]
                               .ApportNaturelHoraire[pdtHebdo];
                 AdresseOuPlacerLaValeurDesCoutsReduits[var] = nullptr;
-                AdresseOuPlacerLaValeurDesVariablesOptimisees[var] = nullptr;
+                AdresseOuPlacerLaValeurDesVariablesOptimisees[var] = &problemeHebdo
+                                                                        ->ResultatsHoraires[pays]
+                                                                        .debordementsHoraires
+                                                                          [pdtHebdo];
             }
 
             var = variableManager.HydroLevel(pays, pdtJour);

src/solver/optimisation/opt_gestion_des_couts_cas_lineaire.cpp

@@ -292,26 +292,19 @@ void OPT_InitialiserLesCoutsLineaire(PROBLEME_HEBDO* problemeHebdo,
 
               */
 
+                ProblemeAResoudre->CoutLineaire[var] = problemeHebdo->CoutDeDebordement[pays];
                 if (!problemeHebdo->CaracteristiquesHydrauliques[pays].AccurateWaterValue)
                 {
-                    ProblemeAResoudre->CoutLineaire[var] = problemeHebdo
-                                                             ->CoutDeDefaillanceNegative[pays];
-
                     ProblemeAResoudre->CoutLineaire[var] += problemeHebdo
                                                               ->CaracteristiquesHydrauliques[pays]
                                                               .WeeklyWaterValueStateRegular;
                 }
-                else
-                {
-                    ProblemeAResoudre->CoutLineaire[var] = problemeHebdo
-                                                             ->CoutDeDefaillanceNegative[pays];
-                }
             }
 
             var = variableManager.HydroLevel(pays, pdtJour);
             if (var >= 0 && var < ProblemeAResoudre->NombreDeVariables)
             {
-                ProblemeAResoudre->CoutLineaire[var] = 0;
+                ProblemeAResoudre->CoutLineaire[var] = problemeHebdo->CoutDeRemplissage[pays];
             }
 
             var = variableManager.PositiveUnsuppliedEnergy(pays, pdtJour);

src/solver/simulation/common-hydro-levels.cpp

@@ -48,34 +48,12 @@ void computingHydroLevels(const Data::AreaList& areas,
         uint index = area->index;
 
         double reservoirCapacity = area->hydro.reservoirCapacity;
-
-        std::vector<double>& inflows = problem.CaracteristiquesHydrauliques[index]
-                                         .ApportNaturelHoraire;
-
         RESULTATS_HORAIRES& weeklyResults = problem.ResultatsHoraires[index];
-
-        std::vector<double>& turb = weeklyResults.TurbinageHoraire;
-
-        std::vector<double>& pump = weeklyResults.PompageHoraire;
-        double pumpingRatio = area->hydro.pumpingEfficiency;
-
-        double nivInit = problem.CaracteristiquesHydrauliques[index].NiveauInitialReservoir;
         std::vector<double>& niv = weeklyResults.niveauxHoraires;
-
-        std::vector<double>& ovf = weeklyResults.debordementsHoraires;
-
-        computeTimeStepLevel
-          computeLvlObj(nivInit, inflows, ovf, turb, pumpingRatio, pump, reservoirCapacity);
-
-        for (uint h = 0; h < nbHoursInAWeek - 1; h++)
+        for (uint h = 0; h < nbHoursInAWeek; h++)
         {
-            computeLvlObj.run();
-            niv[h] = computeLvlObj.getLevel() * 100 / reservoirCapacity;
-            computeLvlObj.prepareNextStep();
+            niv[h] = niv[h] * 100 / reservoirCapacity;
         }
-
-        computeLvlObj.run();
-        niv[nbHoursInAWeek - 1] = computeLvlObj.getLevel() * 100 / reservoirCapacity;
     }
 }
 

src/solver/simulation/common-hydro-remix.cpp

@@ -283,6 +283,8 @@ static void RunAccurateShavePeaks(const Data::AreaList& areas,
           const double initLevel = problem.CaracteristiquesHydrauliques[area.index]
                                      .NiveauInitialReservoir;
           const double capacity = area.hydro.reservoirCapacity;
+          const double efficiency = area.hydro.pumpingEfficiency;
+          const bool reservoir_management = area.hydro.reservoirManagement;
           const auto& inflows = problem.CaracteristiquesHydrauliques[area.index]
                                   .ApportNaturelHoraire;
           const auto& ovf = weeklyResults.debordementsHoraires;
@@ -299,6 +301,8 @@ static void RunAccurateShavePeaks(const Data::AreaList& areas,
                                                      hydroPmin,
                                                      initLevel,
                                                      capacity,
+                                                     efficiency,
+                                                     reservoir_management,
                                                      inflows,
                                                      ovf,
                                                      pump,
@@ -317,6 +321,8 @@ void RemixHydroForAllAreas(const Data::AreaList& areas,
                            uint numSpace,
                            uint hourInYear)
 {
+    auto started = std::chrono::high_resolution_clock::now();
+
     if (sheddingPolicy == Data::shpShavePeaks)
     {
         bool result = true;
@@ -352,5 +358,9 @@ void RemixHydroForAllAreas(const Data::AreaList& areas,
             throw assertErrException;
         }
     }
+    auto done = std::chrono::high_resolution_clock::now();
+    Antares::logs.notice()
+      << "Remix hydro for this week took : "
+      << std::chrono::duration_cast<std::chrono::nanoseconds>(done - started).count() << " ns.";
 }
 } // namespace Antares::Solver::Simulation

src/solver/simulation/include/antares/solver/simulation/shave-peaks-by-remix-hydro.h

@@ -20,6 +20,8 @@ RemixHydroOutput shavePeaksByRemixingHydro(const std::vector<double>& DispatchGe
                                            const std::vector<double>& HydroPmin,
                                            double init_level,
                                            double capacity,
+                                           double efficiency,
+                                           bool reservoir_management,
                                            const std::vector<double>& inflow,
                                            const std::vector<double>& overflow,
                                            const std::vector<double>& pump,