update

AntaresSimulatorTeam · Feb 24, 2025 · c6d14c9 · c6d14c9
1 parent 6c7d5b8
commit c6d14c9
Show file tree

Hide file tree

Showing 4 changed files with 59 additions and 77 deletions.
diff --git a/src/solver/optim-model-filler/ComponentFiller.cpp b/src/solver/optim-model-filler/ComponentFiller.cpp
@@ -218,21 +218,21 @@ void ComponentFiller::addStaticConstraint(Optimisation::LinearProblemApi::ILinea
 
 void ComponentFiller::addTimeDependentConstraints(
   Optimisation::LinearProblemApi::ILinearProblem& pb,
-  const std::map<unsigned int, LinearConstraint>& linear_constraints,
+  const std::vector<LinearConstraint>& linear_constraints,
   const std::string& constraint_id) const
 {
-    for (const auto& [timestep, linear_constraint]: linear_constraints)
+    for (const auto& linear_constraint: linear_constraints)
     {
         auto* ct = pb.addConstraint(linear_constraint.lb,
                                     linear_constraint.ub,
                                     component_.Id() + "." + constraint_id + '_'
-                                      + std::to_string(timestep));
+                                      + std::to_string(linear_constraint.timeStep));
         for (const auto& [var_id, coef]: linear_constraint.coef_per_var)
         {
             if (IsThisVariableTimeDependent(var_id))
             {
                 auto* variable = pb.getVariable(component_.Id() + "." + var_id + '_'
-                                                + std::to_string(timestep));
+                                                + std::to_string(linear_constraint.timeStep));
                 ct->setCoefficient(variable, coef);
             }
             else
@@ -255,7 +255,7 @@ void ComponentFiller::addConstraints(Optimisation::LinearProblemApi::ILinearProb
     for (const auto& constraint: component_.getModel()->getConstraints() | std::views::values)
     {
         auto* root_node = constraint.expression().RootNode();
-        const auto linear_constraints = visitor.dispatch(root_node);
+        auto linear_constraints = visitor.dispatch(root_node);
         if (checkTimeSteps(ctx))
         {
             if (IsThisConstraintTimeDependent(root_node))
@@ -265,7 +265,7 @@ void ComponentFiller::addConstraints(Optimisation::LinearProblemApi::ILinearProb
             }
             else
             {
-                addStaticConstraint(pb, linear_constraints.at(0), constraint.Id());
+                addStaticConstraint(pb, linear_constraints[0], constraint.Id());
             }
         }
     }

diff --git a/src/solver/optim-model-filler/ReadLinearConstraintVisitor.cpp b/src/solver/optim-model-filler/ReadLinearConstraintVisitor.cpp
@@ -41,56 +41,57 @@ std::string ReadLinearConstraintVisitor::name() const
     return "ReadLinearConstraintVisitor";
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(const EqualNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const EqualNode* node)
 {
     auto leftMinusRight = linear_expression_visitor_.dispatch(node->left())
                           - linear_expression_visitor_.dispatch(node->right());
 
     const auto& leftMinusRightLinearExpression = leftMinusRight.GetLinearExpressions();
-    std::map<unsigned int, LinearConstraint> constraints;
+    std::vector<LinearConstraint> constraints;
+    constraints.reserve(leftMinusRightLinearExpression.size());
 
-    for (const auto& [key, value]: leftMinusRightLinearExpression)
+    for (const auto& [timeStep, value]: leftMinusRightLinearExpression)
     {
-        constraints.emplace(key,
-                            LinearConstraint{.coef_per_var = value.coefPerVar(),
-                                             .lb = -value.offset(),
-                                             .ub = -value.offset()});
+        constraints.emplace_back(LinearConstraint{.coef_per_var = value.coefPerVar(),
+                                                  .lb = -value.offset(),
+                                                  .ub = -value.offset(),
+                                                  .timeStep = timeStep});
     }
     return constraints;
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const LessThanOrEqualNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const LessThanOrEqualNode* node)
 {
     auto leftMinusRight = linear_expression_visitor_.dispatch(node->left())
                           - linear_expression_visitor_.dispatch(node->right());
 
     const auto& leftMinusRightLinearExpression = leftMinusRight.GetLinearExpressions();
-    std::map<unsigned int, LinearConstraint> constraints;
+    std::vector<LinearConstraint> constraints;
+    constraints.reserve(leftMinusRightLinearExpression.size());
 
-    for (const auto& [key, value]: leftMinusRightLinearExpression)
+    for (const auto& [timeStep, value]: leftMinusRightLinearExpression)
     {
-        constraints.emplace(key,
-                            LinearConstraint{.coef_per_var = value.coefPerVar(),
-                                             .ub = -value.offset()});
+        constraints.emplace_back(LinearConstraint{.coef_per_var = value.coefPerVar(),
+                                                  .ub = -value.offset(),
+                                                  .timeStep = timeStep});
     }
     return constraints;
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const GreaterThanOrEqualNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const GreaterThanOrEqualNode* node)
 {
     auto leftMinusRight = linear_expression_visitor_.dispatch(node->left())
                           - linear_expression_visitor_.dispatch(node->right());
 
     const auto& leftMinusRightLinearExpression = leftMinusRight.GetLinearExpressions();
-    std::map<unsigned int, LinearConstraint> constraints;
+    std::vector<LinearConstraint> constraints;
+    constraints.reserve(leftMinusRightLinearExpression.size());
 
-    for (const auto& [key, value]: leftMinusRightLinearExpression)
+    for (const auto& [timeStep, value]: leftMinusRightLinearExpression)
     {
-        constraints.emplace(key,
-                            LinearConstraint{.coef_per_var = value.coefPerVar(),
-                                             .lb = -value.offset()});
+        constraints.emplace_back(LinearConstraint{.coef_per_var = value.coefPerVar(),
+                                                  .lb = -value.offset(),
+                                                  .timeStep = timeStep});
     }
     return constraints;
 }
@@ -100,72 +101,62 @@ static std::invalid_argument IllegalNodeException()
     return std::invalid_argument("Root node of a constraint must be a comparator.");
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(const SumNode* sum_node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const SumNode* sum_node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const SubtractionNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const SubtractionNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const MultiplicationNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const MultiplicationNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const DivisionNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const DivisionNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const NegationNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const NegationNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const VariableNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const VariableNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const ParameterNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const ParameterNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(const LiteralNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const LiteralNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const PortFieldNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const PortFieldNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const PortFieldSumNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const PortFieldSumNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const ComponentVariableNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const ComponentVariableNode* node)
 {
     throw IllegalNodeException();
 }
 
-std::map<unsigned int, LinearConstraint> ReadLinearConstraintVisitor::visit(
-  const ComponentParameterNode* node)
+std::vector<LinearConstraint> ReadLinearConstraintVisitor::visit(const ComponentParameterNode* node)
 {
     throw IllegalNodeException();
 }

diff --git a/src/solver/optim-model-filler/include/antares/solver/optim-model-filler/ComponentFiller.h b/src/solver/optim-model-filler/include/antares/solver/optim-model-filler/ComponentFiller.h
@@ -62,8 +62,8 @@ class ComponentFiller: public Optimisation::LinearProblemApi::LinearProblemFille
                              const std::string& constraint_id) const;
 
     void addTimeDependentConstraints(Optimisation::LinearProblemApi::ILinearProblem& pb,
-      const std::map<unsigned int, LinearConstraint>& linear_constraints,
-      const std::string& constraint_id) const;
+                                     const std::vector<LinearConstraint>& linear_constraints,
+                                     const std::string& constraint_id) const;
 
     void addConstraints(Optimisation::LinearProblemApi::ILinearProblem& pb,
                         Optimisation::LinearProblemApi::ILinearProblemData& data,

diff --git a/...ptim-model-filler/include/antares/solver/optim-model-filler/ReadLinearConstraintVisitor.h b/...ptim-model-filler/include/antares/solver/optim-model-filler/ReadLinearConstraintVisitor.h
@@ -48,10 +48,11 @@ struct LinearConstraint
     std::map<std::string, double> coef_per_var;
     double lb = -std::numeric_limits<double>::infinity();
     double ub = std::numeric_limits<double>::infinity();
+    unsigned int timeStep = 0;
 };
 
 class ReadLinearConstraintVisitor
-    : public Expressions::Visitors::NodeVisitor<std::map<unsigned int, LinearConstraint>>
+    : public Expressions::Visitors::NodeVisitor<std::vector<LinearConstraint>>
 {
 public:
     ReadLinearConstraintVisitor() = default;
@@ -62,35 +63,25 @@ class ReadLinearConstraintVisitor
 
 private:
     ReadLinearExpressionVisitor linear_expression_visitor_;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::SumNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::SubtractionNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::SumNode* node) override;
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::SubtractionNode* node) override;
+    std::vector<LinearConstraint> visit(
       const Expressions::Nodes::MultiplicationNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::DivisionNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::EqualNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::DivisionNode* node) override;
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::EqualNode* node) override;
+    std::vector<LinearConstraint> visit(
       const Expressions::Nodes::LessThanOrEqualNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
+    std::vector<LinearConstraint> visit(
       const Expressions::Nodes::GreaterThanOrEqualNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::NegationNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::VariableNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::ParameterNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::LiteralNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::PortFieldNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
-      const Expressions::Nodes::PortFieldSumNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::NegationNode* node) override;
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::VariableNode* node) override;
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::ParameterNode* node) override;
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::LiteralNode* node) override;
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::PortFieldNode* node) override;
+    std::vector<LinearConstraint> visit(const Expressions::Nodes::PortFieldSumNode* node) override;
+    std::vector<LinearConstraint> visit(
       const Expressions::Nodes::ComponentVariableNode* node) override;
-    std::map<unsigned int, LinearConstraint> visit(
+    std::vector<LinearConstraint> visit(
       const Expressions::Nodes::ComponentParameterNode* node) override;
 };
 } // namespace Antares::Optimization