Add attribute enabled to additional constraints, adapt tests [ANT-1855]

src/libs/antares/study/include/antares/study/parts/short-term-storage/additionalConstraints.h

@@ -33,7 +33,6 @@ class SingleAdditionalConstraint
     std::set<int> hours;
     unsigned int globalIndex = 0;
     unsigned int localIndex = 0;
-
     bool isValidHoursRange() const;
 };
 
@@ -43,6 +42,7 @@ struct AdditionalConstraints
     std::string cluster_id;
     std::string variable;
     std::string operatorType;
+    bool enabled = true;
     // TODO a lot unused entries
     // std::array<double, HOURS_PER_YEAR> rhs = {};
     std::vector<double> rhs;
@@ -55,6 +55,9 @@ struct AdditionalConstraints
         std::string error_msg;
     };
 
+    // Number of enabled constraints
+    std::size_t enabledConstraints() const;
+
     ValidateResult validate() const;
 
 private:

src/libs/antares/study/parts/short-term-storage/additionalConstraints.cpp

@@ -72,4 +72,9 @@ bool AdditionalConstraints::isValidOperatorType() const
 {
     return operatorType == "less" || operatorType == "equal" || operatorType == "greater";
 }
+
+std::size_t AdditionalConstraints::enabledConstraints() const
+{
+    return enabled ? constraints.size() : 0;
+}
 } // namespace Antares::Data::ShortTermStorage

src/libs/antares/study/parts/short-term-storage/container.cpp

@@ -107,12 +107,13 @@ static void loadHours(const std::string& hoursStr, AdditionalConstraints& additi
     }
 }
 
-static bool readRHS(AdditionalConstraints& additionalConstraints,
-                    const fs::path& rhsPath)
+static bool readRHS(AdditionalConstraints& additionalConstraints, const fs::path& rhsPath)
 {
-    const auto ret = loadFile(rhsPath,
-                              additionalConstraints.rhs);
-    if (ret) { fillIfEmpty(additionalConstraints.rhs, 0.0); }
+    const auto ret = loadFile(rhsPath, additionalConstraints.rhs);
+    if (ret)
+    {
+        fillIfEmpty(additionalConstraints.rhs, 0.0);
+    }
     return ret;
 }
 
@@ -141,6 +142,10 @@ bool STStorageInput::loadAdditionalConstraints(const fs::path& parentPath)
                 value.to<std::string>(clusterName);
                 additionalConstraints.cluster_id = transformNameIntoID(clusterName);
             }
+            else if (key == "enabled")
+            {
+                value.to<bool>(additionalConstraints.enabled);
+            }
             else if (key == "variable")
             {
                 value.to<std::string>(additionalConstraints.variable);
@@ -155,13 +160,19 @@ bool STStorageInput::loadAdditionalConstraints(const fs::path& parentPath)
             }
         }
 
-        if (const auto rhsPath = parentPath / (
-                                     "rhs_" + additionalConstraints.name
-                                     + ".txt"); !readRHS(additionalConstraints, rhsPath))
+        // We don't want load RHS and link the STS time if the constraint is disabled
+        if (!additionalConstraints.enabled)
+        {
+            return true;
+        }
+
+        if (const auto rhsPath = parentPath / ("rhs_" + additionalConstraints.name + ".txt");
+            !readRHS(additionalConstraints, rhsPath))
         {
             logs.error() << "Error while reading rhs file: " << rhsPath;
             return false;
         }
+
         if (auto [ok, error_msg] = additionalConstraints.validate(); !ok)
         {
             logs.error() << "Invalid constraint in section: " << section->name;
@@ -242,7 +253,7 @@ std::size_t STStorageInput::cumulativeConstraintCount() const
                    cluster.additionalConstraints.end(),
                    0,
                    [](size_t inner_constraint_count, const auto& additionalConstraints)
-                   { return inner_constraint_count + additionalConstraints.constraints.size(); });
+                   { return inner_constraint_count + additionalConstraints.enabledConstraints(); });
       });
 }
 

src/solver/optimisation/opt_decompte_variables_et_contraintes.cpp

@@ -249,8 +249,8 @@ int OPT_DecompteDesVariablesEtDesContraintesDuProblemeAOptimiser(PROBLEME_HEBDO*
                 {
                     for (const auto& additionalConstraints: storage.additionalConstraints)
                     {
-                        ProblemeAResoudre->NombreDeContraintes += additionalConstraints.constraints
-                                                                    .size();
+                        ProblemeAResoudre->NombreDeContraintes += additionalConstraints
+                                                                    .enabledConstraints();
                     }
                 }
             }

src/solver/simulation/sim_calcul_economique.cpp

@@ -60,15 +60,20 @@ static void importShortTermStorages(
             toInsert.penalizeVariationInjection = st.properties.penalizeVariationInjection;
             toInsert.penalizeVariationWithdrawal = st.properties.penalizeVariationWithdrawal;
             toInsert.name = st.properties.name;
-            toInsert.additionalConstraints = st.additionalConstraints;
-            for (auto& additionalConstraints: toInsert.additionalConstraints)
+            for (const auto& constraint: st.additionalConstraints)
             {
-                for (auto& [_, globalIndex, __]: additionalConstraints.constraints)
+                if (constraint.enabled)
                 {
-                    globalIndex = constraintGlobalIndex;
-                    ++constraintGlobalIndex;
+                    auto newConstraint = constraint;
+                    for (auto& c: newConstraint.constraints)
+                    {
+                        c.globalIndex = constraintGlobalIndex;
+                        ++constraintGlobalIndex;
+                    }
+                    toInsert.additionalConstraints.push_back(std::move(newConstraint));
                 }
             }
+
             toInsert.series = st.series;
 
             // TODO add missing properties, or use the same struct

src/tests/src/libs/antares/study/short-term-storage-input/short-term-storage-input-output.cpp

@@ -22,6 +22,7 @@
 
 #define WIN32_LEAN_AND_MEAN
 
+#include <absl/strings/internal/str_format/extension.h>
 #include <filesystem>
 #include <fstream>
 
@@ -886,9 +887,10 @@ BOOST_DATA_TEST_CASE(Validate_AllVariableOperatorCombinations,
 
 BOOST_DATA_TEST_CASE(Validate_AllVariableOperatorCombinationsFromFile,
                      bdata::make({"injection", "withdrawal", "netting"})
-                       ^ bdata::make({"less", "equal", "greater"}),
+                       * bdata::make({"less", "equal", "greater"}) * bdata::make({true, false}),
                      variable,
-                     op)
+                     op,
+                     enabled)
 {
     // Define the path for the test data
     std::filesystem::path testPath = std::filesystem::temp_directory_path() / "test_data";
@@ -900,6 +902,8 @@ BOOST_DATA_TEST_CASE(Validate_AllVariableOperatorCombinationsFromFile,
     iniFile << "cluster=clustera\n";
     iniFile << "variable=" << variable << "\n";
     iniFile << "operator=" << op << "\n";
+    iniFile << std::boolalpha;
+    iniFile << "enabled=" << enabled << "\n";
     iniFile << "hours=[1,2,3]\n";
     iniFile.close();
 
@@ -919,10 +923,10 @@ BOOST_DATA_TEST_CASE(Validate_AllVariableOperatorCombinationsFromFile,
 
     // Load constraints from the `.ini` file
     bool result = storageInput.loadAdditionalConstraints(testPath);
+    BOOST_CHECK_EQUAL(storageInput.cumulativeConstraintCount(), enabled ? 1 : 0);
 
     // Assertions
     BOOST_CHECK_EQUAL(result, true);
-
     // Validate loaded constraints
     auto& built_cluster = storageInput.storagesByIndex[0];
     BOOST_REQUIRE_EQUAL(built_cluster.additionalConstraints.size(), 1);