rename additional_constraints

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

@@ -51,6 +51,6 @@ class STStorageCluster
 
     std::shared_ptr<Series> series = std::make_shared<Series>();
     mutable Properties properties;
-    std::vector<AdditionalConstraints> additional_constraints;
+    std::vector<AdditionalConstraints> additionalConstraints;
 };
 } // namespace Antares::Data::ShortTermStorage

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

@@ -75,7 +75,7 @@ bool STStorageInput::createSTStorageClustersFromIniFile(const fs::path& path)
     return true;
 }
 
-static void loadHours(const std::string& hoursStr, AdditionalConstraints& additional_constraints)
+static void loadHours(const std::string& hoursStr, AdditionalConstraints& additionalConstraints)
 {
     //
     // std::stringstream ss(value.c_str());
@@ -108,22 +108,22 @@ static void loadHours(const std::string& hoursStr, AdditionalConstraints& additi
         if (!hourSet.empty())
         {
             // Add this group to the `hours` vec
-            additional_constraints.constraints.push_back(
+            additionalConstraints.constraints.push_back(
               {.hours = hourSet, .localIndex = localIndex});
             ++localIndex;
         }
     }
 }
 
-static bool readRHS(AdditionalConstraints& additional_constraints,
+static bool readRHS(AdditionalConstraints& additionalConstraints,
                     const fs::path& parentPath,
                     const std::string& sectionName)
 {
-    loadFile(parentPath / ("rhs_" + additional_constraints.name + ".txt"),
-             additional_constraints.rhs);
-    fillIfEmpty(additional_constraints.rhs, 0.0);
+    loadFile(parentPath / ("rhs_" + additionalConstraints.name + ".txt"),
+             additionalConstraints.rhs);
+    fillIfEmpty(additionalConstraints.rhs, 0.0);
 
-    if (auto [ok, error_msg] = additional_constraints.validate(); !ok)
+    if (auto [ok, error_msg] = additionalConstraints.validate(); !ok)
     {
         logs.error() << "Invalid constraint in section: " << sectionName;
         logs.error() << error_msg;
@@ -144,8 +144,8 @@ bool STStorageInput::loadAdditionalConstraints(const fs::path& parentPath)
 
     for (auto* section = ini.firstSection; section; section = section->next)
     {
-        AdditionalConstraints additional_constraints;
-        additional_constraints.name = section->name.c_str();
+        AdditionalConstraints additionalConstraints;
+        additionalConstraints.name = section->name.c_str();
         for (auto* property = section->firstProperty; property; property = property->next)
         {
             const std::string key = property->key;
@@ -156,30 +156,30 @@ bool STStorageInput::loadAdditionalConstraints(const fs::path& parentPath)
                 // TODO do i have to transform the name to id? TransformNameIntoID
                 std::string clusterName;
                 value.to<std::string>(clusterName);
-                additional_constraints.cluster_id = transformNameIntoID(clusterName);
+                additionalConstraints.cluster_id = transformNameIntoID(clusterName);
             }
             else if (key == "variable")
             {
-                value.to<std::string>(additional_constraints.variable);
+                value.to<std::string>(additionalConstraints.variable);
             }
             else if (key == "operator")
             {
-                value.to<std::string>(additional_constraints.operatorType);
+                value.to<std::string>(additionalConstraints.operatorType);
             }
             else if (key == "hours")
             {
-                loadHours(value.c_str(), additional_constraints);
+                loadHours(value.c_str(), additionalConstraints);
             }
         }
 
-        if (!readRHS(additional_constraints, parentPath, section->name))
+        if (!readRHS(additionalConstraints, parentPath, section->name))
         {
             return false;
         }
 
         auto it = std::ranges::find_if(storagesByIndex,
-                                       [&additional_constraints](const STStorageCluster& cluster)
-                                       { return cluster.id == additional_constraints.cluster_id; });
+                                       [&additionalConstraints](const STStorageCluster& cluster)
+                                       { return cluster.id == additionalConstraints.cluster_id; });
         if (it == storagesByIndex.end())
         {
             logs.warning() << " from file " << pathIni;
@@ -189,7 +189,7 @@ bool STStorageInput::loadAdditionalConstraints(const fs::path& parentPath)
         }
         else
         {
-            it->additional_constraints.push_back(additional_constraints);
+            it->additionalConstraints.push_back(additionalConstraints);
         }
     }
 
@@ -246,11 +246,11 @@ std::size_t STStorageInput::cumulativeConstraintCount() const
       {
           return outer_constraint_count
                  + std::accumulate(
-                   cluster.additional_constraints.begin(),
-                   cluster.additional_constraints.end(),
+                   cluster.additionalConstraints.begin(),
+                   cluster.additionalConstraints.end(),
                    0,
-                   [](size_t inner_constraint_count, const auto& additional_constraints)
-                   { return inner_constraint_count + additional_constraints.constraints.size(); });
+                   [](size_t inner_constraint_count, const auto& additionalConstraints)
+                   { return inner_constraint_count + additionalConstraints.constraints.size(); });
       });
 }
 

src/solver/optimisation/constraints/ShortTermStorageCumulation.cpp

@@ -130,20 +130,20 @@ void ShortTermStorageCumulation::add(int pays)
 
     for (const auto& storage: data.ShortTermStorage[pays])
     {
-        for (const auto& additional_constraints: storage.additional_constraints)
+        for (const auto& additionalConstraints: storage.additionalConstraints)
         {
             // sum (var[h]) sign rhs, h in list provided by user where:
             // var = injection for InjectionCumulationConstraint
             // var = withdrawal for WithdrawalCumulationConstraint
             // var = injectionEfficiency * injection - withdrawalEfficiency * withdrawal for Netting
             auto constraintHelper = cumulationConstraintFromVariable(
-              additional_constraints.variable);
-            for (const auto& [hours, globalIndex, localIndex]: additional_constraints.constraints)
+              additionalConstraints.variable);
+            for (const auto& [hours, globalIndex, localIndex]: additionalConstraints.constraints)
             {
                 namer.ShortTermStorageCumulation(constraintHelper->name(),
                                                  builder.data.nombreDeContraintes,
                                                  storage.name,
-                                                 additional_constraints.name + "_"
+                                                 additionalConstraints.name + "_"
                                                    + std::to_string(localIndex));
                 const auto index = storage.clusterGlobalIndex;
                 data.CorrespondanceCntNativesCntOptimHebdomadaires
@@ -155,7 +155,7 @@ void ShortTermStorageCumulation::add(int pays)
                     builder.updateHourWithinWeek(hour - 1);
                     constraintHelper->build(builder, index, storage);
                 }
-                builder.SetOperator(ConvertSense(additional_constraints.operatorType)).build();
+                builder.SetOperator(ConvertSense(additionalConstraints.operatorType)).build();
             }
         }
     }

src/solver/optimisation/opt_decompte_variables_et_contraintes.cpp

@@ -245,11 +245,11 @@ int OPT_DecompteDesVariablesEtDesContraintesDuProblemeAOptimiser(PROBLEME_HEBDO*
                     ProblemeAResoudre->NombreDeContraintes
                       += 2 * nombreDePasDeTempsPourUneOptimisation;
                 }
-                if (!storage.additional_constraints.empty())
+                if (!storage.additionalConstraints.empty())
                 {
-                    for (const auto& additional_constraints: storage.additional_constraints)
+                    for (const auto& additionalConstraints: storage.additionalConstraints)
                     {
-                        ProblemeAResoudre->NombreDeContraintes += additional_constraints.constraints
+                        ProblemeAResoudre->NombreDeContraintes += additionalConstraints.constraints
                                                                     .size();
                     }
                 }

src/solver/optimisation/opt_gestion_second_membre_cas_lineaire.cpp

@@ -56,9 +56,9 @@ static void shortTermStorageCumulationRHS(
     {
         for (auto& storage: shortTermStorageInput[areaIndex])
         {
-            for (const auto& additional_constraints: storage.additional_constraints)
+            for (const auto& additionalConstraints: storage.additionalConstraints)
             {
-                for (const auto& constraint: additional_constraints.constraints)
+                for (const auto& constraint: additionalConstraints.constraints)
                 {
                     const int cnt = CorrespondancesDesContraintesHebdomadaires
                                       .ShortTermStorageCumulation[constraint.globalIndex];
@@ -67,8 +67,8 @@ static void shortTermStorageCumulationRHS(
                       constraint.hours.begin(),
                       constraint.hours.end(),
                       0.0,
-                      [weekFirstHour, &additional_constraints](const double sum, const int hour)
-                      { return sum + additional_constraints.rhs[weekFirstHour + hour - 1]; });
+                      [weekFirstHour, &additionalConstraints](const double sum, const int hour)
+                      { return sum + additionalConstraints.rhs[weekFirstHour + hour - 1]; });
                 }
             }
         }

src/solver/simulation/include/antares/solver/simulation/sim_structure_probleme_economique.h

@@ -183,7 +183,7 @@ struct PROPERTIES
     bool penalizeVariationInjection;
 
     std::shared_ptr<Antares::Data::ShortTermStorage::Series> series;
-    std::vector<Antares::Data::ShortTermStorage::AdditionalConstraints> additional_constraints;
+    std::vector<Antares::Data::ShortTermStorage::AdditionalConstraints> additionalConstraints;
     int clusterGlobalIndex;
     std::string name;
 };

src/solver/simulation/sim_calcul_economique.cpp

@@ -60,10 +60,10 @@ static void importShortTermStorages(
             toInsert.penalizeVariationInjection = st.properties.penalizeVariationInjection;
             toInsert.penalizeVariationWithdrawal = st.properties.penalizeVariationWithdrawal;
             toInsert.name = st.properties.name;
-            toInsert.additional_constraints = st.additional_constraints;
-            for (auto& additional_constraints: toInsert.additional_constraints)
+            toInsert.additionalConstraints = st.additionalConstraints;
+            for (auto& additionalConstraints: toInsert.additionalConstraints)
             {
-                for (auto& [_, globalIndex, __]: additional_constraints.constraints)
+                for (auto& [_, globalIndex, __]: additionalConstraints.constraints)
                 {
                     globalIndex = clusterCumulativeConstraintGlobalIndex;
                     ++clusterCumulativeConstraintGlobalIndex;

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

@@ -564,8 +564,8 @@ BOOST_AUTO_TEST_CASE(loadAdditionalConstraints_ValidFile)
     bool result = storageInput.loadAdditionalConstraints(testPath);
 
     BOOST_CHECK_EQUAL(result, true);
-    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additional_constraints.size(), 1);
-    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additional_constraints[0].name,
+    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additionalConstraints.size(), 1);
+    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additionalConstraints[0].name,
                       "constraint1");
 
     std::filesystem::remove_all(testPath);
@@ -678,11 +678,11 @@ BOOST_AUTO_TEST_CASE(loadAdditionalConstraints_ValidRhs)
     bool result = storageInput.loadAdditionalConstraints(testPath);
 
     BOOST_CHECK_EQUAL(result, true);
-    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additional_constraints[0].rhs.size(),
+    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additionalConstraints[0].rhs.size(),
                       HOURS_PER_YEAR);
-    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additional_constraints[0].rhs[0], 0.0);
+    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additionalConstraints[0].rhs[0], 0.0);
     BOOST_CHECK_EQUAL(
-      storageInput.storagesByIndex[0].additional_constraints[0].rhs[HOURS_PER_YEAR - 1],
+      storageInput.storagesByIndex[0].additionalConstraints[0].rhs[HOURS_PER_YEAR - 1],
       HOURS_PER_YEAR - 1);
 
     std::filesystem::remove_all(testPath);
@@ -721,10 +721,10 @@ BOOST_AUTO_TEST_CASE(Load2ConstraintsFromIniFile)
     bool result = storageInput.loadAdditionalConstraints(testPath);
 
     BOOST_CHECK_EQUAL(result, true);
-    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additional_constraints.size(), 2);
+    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additionalConstraints.size(), 2);
 
     //------- constraint1 ----------
-    const auto& constraint1 = storageInput.storagesByIndex[0].additional_constraints[0];
+    const auto& constraint1 = storageInput.storagesByIndex[0].additionalConstraints[0];
     BOOST_CHECK_EQUAL(constraint1.name, "constraint1");
     BOOST_CHECK_EQUAL(constraint1.operatorType, "less");
     BOOST_CHECK_EQUAL(constraint1.variable, "injection");
@@ -735,7 +735,7 @@ BOOST_AUTO_TEST_CASE(Load2ConstraintsFromIniFile)
 
     //------- constraint2 ----------
 
-    const auto& constraint2 = storageInput.storagesByIndex[0].additional_constraints[1];
+    const auto& constraint2 = storageInput.storagesByIndex[0].additionalConstraints[1];
     BOOST_CHECK_EQUAL(constraint2.name, "constraint2");
     BOOST_CHECK_EQUAL(constraint2.operatorType, "greater");
     BOOST_CHECK_EQUAL(constraint2.variable, "withdrawal");
@@ -769,9 +769,9 @@ BOOST_AUTO_TEST_CASE(loadAdditionalConstraints_MissingRhsFile)
     bool result = storageInput.loadAdditionalConstraints(testPath);
 
     BOOST_CHECK_EQUAL(result, true);
-    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additional_constraints[0].rhs.size(),
+    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additionalConstraints[0].rhs.size(),
                       HOURS_PER_YEAR);
-    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additional_constraints[0].rhs[0], 0.0);
+    BOOST_CHECK_EQUAL(storageInput.storagesByIndex[0].additionalConstraints[0].rhs[0], 0.0);
 
     std::filesystem::remove_all(testPath);
 }
@@ -902,8 +902,8 @@ BOOST_DATA_TEST_CASE(Validate_AllVariableOperatorCombinationsFromFile,
 
     // Validate loaded constraints
     auto& built_cluster = storageInput.storagesByIndex[0];
-    BOOST_REQUIRE_EQUAL(built_cluster.additional_constraints.size(), 1);
-    const auto& loadedConstraint = built_cluster.additional_constraints[0];
+    BOOST_REQUIRE_EQUAL(built_cluster.additionalConstraints.size(), 1);
+    const auto& loadedConstraint = built_cluster.additionalConstraints[0];
 
     // Check variable, operator type, and rhs values
     BOOST_CHECK_EQUAL(loadedConstraint.variable, variable);