[ANT-2608] Introducing time dependency behaviour (#2572)

Co-authored-by: GitHub Actions <[email protected]> Co-authored-by: Florian OMNES <[email protected]>
AntaresSimulatorTeam · Jan 21, 2025 · bcd4e1f · bcd4e1f
1 parent a5ea8f6
commit bcd4e1f
Show file tree

Hide file tree

Showing 32 changed files with 793 additions and 156 deletions.
diff --git a/src/solver/expressions/include/antares/solver/expressions/nodes/ParameterNode.h b/src/solver/expressions/include/antares/solver/expressions/nodes/ParameterNode.h
@@ -3,6 +3,12 @@
 #include <string>
 
 #include <antares/solver/expressions/nodes/Leaf.h>
+#include "antares/solver/expressions/visitors/TimeIndex.h"
+
+namespace Antares::Solver::Visitors
+{
+enum class TimeIndex : unsigned int;
+}
 
 namespace Antares::Solver::Nodes
 {
@@ -12,11 +18,25 @@ namespace Antares::Solver::Nodes
 class ParameterNode final: public Leaf<std::string>
 {
 public:
-    using Leaf<std::string>::Leaf;
+    explicit ParameterNode(
+      const std::string& value,
+      Visitors::TimeIndex time_index = Visitors::TimeIndex::VARYING_IN_TIME_AND_SCENARIO):
+        Leaf<std::string>(value),
+        time_index_(time_index)
+    {
+    }
 
     std::string name() const override
     {
         return "ParameterNode";
     }
+
+    Visitors::TimeIndex timeIndex() const
+    {
+        return time_index_;
+    }
+
+private:
+    Visitors::TimeIndex time_index_;
 };
 } // namespace Antares::Solver::Nodes
diff --git a/src/solver/expressions/include/antares/solver/expressions/nodes/VariableNode.h b/src/solver/expressions/include/antares/solver/expressions/nodes/VariableNode.h
@@ -3,6 +3,12 @@
 #include <string>
 
 #include <antares/solver/expressions/nodes/Leaf.h>
+#include "antares/solver/expressions/visitors/TimeIndex.h"
+
+namespace Antares::Solver::Visitors
+{
+enum class TimeIndex : unsigned int;
+}
 
 namespace Antares::Solver::Nodes
 {
@@ -13,11 +19,25 @@ namespace Antares::Solver::Nodes
 class VariableNode final: public Leaf<std::string>
 {
 public:
-    using Leaf<std::string>::Leaf;
+    explicit VariableNode(
+      const std::string& value,
+      Visitors::TimeIndex time_index = Visitors::TimeIndex::VARYING_IN_TIME_AND_SCENARIO):
+        Leaf<std::string>(value),
+        time_index_(time_index)
+    {
+    }
 
     std::string name() const override
     {
         return "VariableNode";
     }
+
+    Visitors::TimeIndex timeIndex() const
+    {
+        return time_index_;
+    }
+
+private:
+    Visitors::TimeIndex time_index_;
 };
 } // namespace Antares::Solver::Nodes
diff --git a/src/solver/expressions/include/antares/solver/expressions/visitors/TimeIndexVisitor.h b/src/solver/expressions/include/antares/solver/expressions/visitors/TimeIndexVisitor.h
@@ -32,12 +32,14 @@ namespace Antares::Solver::Visitors
 class TimeIndexVisitor: public NodeVisitor<TimeIndex>
 {
 public:
+    // TODO if Node contains time and scenario dependency,  do we need this ctor?
     /**
      * @brief Constructs a time index visitor with the specified context.
      *
      * @param context The context containing the time index for each node.
      */
     explicit TimeIndexVisitor(std::unordered_map<const Nodes::Node*, TimeIndex> context);
+    explicit TimeIndexVisitor() = default;
 
     std::string name() const override;
 

diff --git a/src/solver/expressions/visitors/CloneVisitor.cpp b/src/solver/expressions/visitors/CloneVisitor.cpp
@@ -81,7 +81,7 @@ Nodes::Node* CloneVisitor::visit(const Nodes::NegationNode* negationNode)
 
 Nodes::Node* CloneVisitor::visit(const Nodes::VariableNode* variableNode)
 {
-    return registry_.create<Nodes::VariableNode>(variableNode->value());
+    return registry_.create<Nodes::VariableNode>(variableNode->value(), variableNode->timeIndex());
 }
 
 Nodes::Node* CloneVisitor::visit(const Nodes::ParameterNode* parameterNode)

diff --git a/src/solver/expressions/visitors/TimeIndexVisitor.cpp b/src/solver/expressions/visitors/TimeIndexVisitor.cpp
@@ -69,12 +69,12 @@ TimeIndex TimeIndexVisitor::visit(const Nodes::GreaterThanOrEqualNode* gt)
 
 TimeIndex TimeIndexVisitor::visit(const Nodes::VariableNode* var)
 {
-    return context_.at(var);
+    return var->timeIndex();
 }
 
 TimeIndex TimeIndexVisitor::visit(const Nodes::ParameterNode* param)
 {
-    return context_.at(param);
+    return param->timeIndex();
 }
 
 TimeIndex TimeIndexVisitor::visit([[maybe_unused]] const Nodes::LiteralNode* lit)
@@ -89,21 +89,25 @@ TimeIndex TimeIndexVisitor::visit(const Nodes::NegationNode* neg)
 
 TimeIndex TimeIndexVisitor::visit(const Nodes::PortFieldNode* port_field_node)
 {
+    // TODO FIXME
     return context_.at(port_field_node);
 }
 
 TimeIndex TimeIndexVisitor::visit(const Nodes::PortFieldSumNode* port_field_node)
 {
+    // TODO FIXME
     return context_.at(port_field_node);
 }
 
 TimeIndex TimeIndexVisitor::visit(const Nodes::ComponentVariableNode* component_variable_node)
 {
+    // TODO FIXME
     return context_.at(component_variable_node);
 }
 
 TimeIndex TimeIndexVisitor::visit(const Nodes::ComponentParameterNode* component_parameter_node)
 {
+    // TODO FIXME
     return context_.at(component_parameter_node);
 }
 

diff --git a/src/solver/modelConverter/convertorVisitor.cpp b/src/solver/modelConverter/convertorVisitor.cpp
@@ -21,6 +21,7 @@
 
 #include <antares/solver/expressions/nodes/ExpressionsNodes.h>
 #include <antares/solver/modelConverter/convertorVisitor.h>
+#include "antares/solver/expressions/visitors/TimeIndex.h"
 
 #include "ExprLexer.h"
 #include "ExprParser.h"
@@ -83,7 +84,7 @@ NodeRegistry convertExpressionToNode(const std::string& exprStr, const ModelPars
     ExprParser::ExprContext* tree = parser.expr();
     Antares::Solver::Registry<Node> registry;
     ConvertorVisitor visitor(registry, model);
-    Node* root = std::any_cast<Node*>(visitor.visit(tree));
+    auto root = std::any_cast<Node*>(visitor.visit(tree));
     return NodeRegistry(root, std::move(registry));
 }
 
@@ -108,21 +109,39 @@ class NoParameterOrVariableWithThisName: public std::runtime_error
     }
 };
 
+// to silent warning, convert bool to unsigned int
+static constexpr unsigned int convertBool(bool in)
+{
+    return in ? 1 : 0;
+}
+
+static constexpr Visitors::TimeIndex convertToTimeIndex(bool timedependent, bool scenariodependent)
+{
+    return static_cast<Visitors::TimeIndex>((convertBool(scenariodependent) << 1)
+                                            | convertBool(timedependent));
+}
+
 std::any ConvertorVisitor::visitIdentifier(ExprParser::IdentifierContext* context)
 {
     for (const auto& param: model_.parameters)
     {
         if (param.id == context->IDENTIFIER()->getText())
         {
-            return static_cast<Node*>(registry_.create<ParameterNode>(param.id));
+            return static_cast<Node*>(
+              registry_.create<ParameterNode>(param.id,
+                                              convertToTimeIndex(param.time_dependent,
+                                                                 param.scenario_dependent)));
         }
     }
 
     for (const auto& var: model_.variables)
     {
         if (var.id == context->getText())
         {
-            return static_cast<Node*>(registry_.create<VariableNode>(var.id));
+            return static_cast<Node*>(
+              registry_.create<VariableNode>(var.id,
+                                             convertToTimeIndex(var.time_dependent,
+                                                                var.scenario_dependent)));
         }
     }
 

diff --git a/src/solver/modelConverter/include/antares/solver/modelConverter/convertorVisitor.h b/src/solver/modelConverter/include/antares/solver/modelConverter/convertorVisitor.h
@@ -28,5 +28,6 @@
 
 namespace Antares::Solver::ModelConverter
 {
+
 NodeRegistry convertExpressionToNode(const std::string& exprStr, const ModelParser::Model& model);
 } // namespace Antares::Solver::ModelConverter
diff --git a/src/solver/modelConverter/modelConverter.cpp b/src/solver/modelConverter/modelConverter.cpp
@@ -21,6 +21,7 @@
 
 #include "antares/solver/modelConverter/modelConverter.h"
 
+#include "antares/solver/expressions/visitors/TimeIndex.h"
 #include "antares/solver/modelConverter/convertorVisitor.h"
 #include "antares/study/system-model/constraint.h"
 #include "antares/study/system-model/expression.h"
@@ -74,15 +75,13 @@ std::vector<Antares::Study::SystemModel::PortType> convertTypes(
 std::vector<Antares::Study::SystemModel::Parameter> convertParameters(
   const Antares::Solver::ModelParser::Model& model)
 {
-    std::vector<Antares::Study::SystemModel::Parameter> parameters;
+    namespace SM = Antares::Study::SystemModel;
+    std::vector<SM::Parameter> parameters;
     for (const auto& parameter: model.parameters)
     {
-        parameters.emplace_back(
-          parameter.id,
-          static_cast<Antares::Study::SystemModel::Parameter::TimeDependent>(
-            parameter.time_dependent),
-          static_cast<Antares::Study::SystemModel::Parameter::ScenarioDependent>(
-            parameter.scenario_dependent));
+        parameters.emplace_back(parameter.id,
+                                SM::fromBool<SM::TimeDependent>(parameter.time_dependent),
+                                SM::fromBool<SM::ScenarioDependent>(parameter.scenario_dependent));
     }
     return parameters;
 }
@@ -117,19 +116,22 @@ Antares::Study::SystemModel::ValueType convertType(Antares::Solver::ModelParser:
  */
 std::vector<Antares::Study::SystemModel::Variable> convertVariables(const ModelParser::Model& model)
 {
-    std::vector<Antares::Study::SystemModel::Variable> variables;
+    namespace SM = Antares::Study::SystemModel;
+
+    std::vector<SM::Variable> variables;
+
     for (const auto& variable: model.variables)
     {
-        Antares::Study::SystemModel::Expression lb(variable.lower_bound,
-                                                   convertExpressionToNode(variable.lower_bound,
-                                                                           model));
-        Antares::Study::SystemModel::Expression ub(variable.upper_bound,
-                                                   convertExpressionToNode(variable.upper_bound,
-                                                                           model));
+        SM::Expression lb(variable.lower_bound,
+                          convertExpressionToNode(variable.lower_bound, model));
+        SM::Expression ub(variable.upper_bound,
+                          convertExpressionToNode(variable.upper_bound, model));
         variables.emplace_back(variable.id,
                                std::move(lb),
                                std::move(ub),
-                               convertType(variable.variable_type));
+                               convertType(variable.variable_type),
+                               SM::fromBool<SM::TimeDependent>(variable.time_dependent),
+                               SM::fromBool<SM::ScenarioDependent>(variable.scenario_dependent));
     }
 
     return variables;
@@ -153,10 +155,10 @@ std::vector<Antares::Study::SystemModel::Constraint> convertConstraints(
     std::vector<Antares::Study::SystemModel::Constraint> constraints;
     for (const auto& constraint: model.constraints)
     {
-        auto expr = convertExpressionToNode(constraint.expression, model);
+        auto nodeRegistry = convertExpressionToNode(constraint.expression, model);
         constraints.emplace_back(constraint.id,
                                  Antares::Study::SystemModel::Expression{constraint.expression,
-                                                                         std::move(expr)});
+                                                                         std::move(nodeRegistry)});
     }
     return constraints;
 }

diff --git a/src/solver/modelParser/encoders.hxx b/src/solver/modelParser/encoders.hxx
@@ -106,6 +106,8 @@ struct convert<Antares::Solver::ModelParser::Variable>
         rhs.upper_bound = node["upper-bound"].as<std::string>("");
         rhs.variable_type = node["variable-type"].as<Antares::Solver::ModelParser::ValueType>(
           Antares::Solver::ModelParser::ValueType::CONTINUOUS);
+        rhs.time_dependent = node["time-dependent"].as<bool>(true);
+        rhs.scenario_dependent = node["scenario-dependent"].as<bool>(true);
         return true;
     }
 };

diff --git a/src/solver/modelParser/include/antares/solver/modelParser/Library.h b/src/solver/modelParser/include/antares/solver/modelParser/Library.h
@@ -64,6 +64,8 @@ struct Variable
     std::string lower_bound;
     std::string upper_bound;
     ValueType variable_type;
+    bool time_dependent;
+    bool scenario_dependent;
 };
 
 struct Port

diff --git a/src/solver/modeler/CMakeLists.txt b/src/solver/modeler/CMakeLists.txt
@@ -31,6 +31,8 @@ target_link_libraries(modeler-lib
 target_link_libraries(antares-modeler
         PRIVATE
         modeler-lib
+        modeler-ortools-impl
+        optim-model-filler
 )
 
 import_std_libs(antares-modeler)

diff --git a/src/solver/modeler/api/CMakeLists.txt b/src/solver/modeler/api/CMakeLists.txt
@@ -22,6 +22,7 @@ add_library(Antares::${PROJ} ALIAS ${PROJ})
 
 set_target_properties(${PROJ} PROPERTIES LINKER_LANGUAGE CXX)
 
+
 target_include_directories(${PROJ}
         PUBLIC
 	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>

diff --git a/src/solver/modeler/api/include/antares/solver/modeler/api/linearProblem.h b/src/solver/modeler/api/include/antares/solver/modeler/api/linearProblem.h
@@ -44,16 +44,49 @@ class ILinearProblem
 
     /// Create a continuous variable
     virtual IMipVariable* addNumVariable(double lb, double ub, const std::string& name) = 0;
+
+    /// Create range of continuous variables
+    virtual std::vector<IMipVariable*> addNumVariable(double lb,
+                                                      double ub,
+                                                      const std::string& name,
+                                                      unsigned int number_new_variables)
+      = 0;
+
     /// Create a integer variable
     virtual IMipVariable* addIntVariable(double lb, double ub, const std::string& name) = 0;
+
+    /// Create range of integer variables
+    virtual std::vector<IMipVariable*> addIntVariable(double lb,
+                                                      double ub,
+                                                      const std::string& name,
+                                                      unsigned int number_new_variables)
+      = 0;
+
     /// Create a continuous or integer variable
     virtual IMipVariable* addVariable(double lb, double ub, bool integer, const std::string& name)
       = 0;
+
+    /// Create range continuous or integer variables
+    virtual std::vector<IMipVariable*> addVariable(double lb,
+                                                   double ub,
+                                                   bool integer,
+                                                   const std::string& name,
+                                                   unsigned int number_new_variables)
+      = 0;
+
     virtual IMipVariable* getVariable(const std::string& name) const = 0;
     virtual int variableCount() const = 0;
 
     /// Add a bounded constraint to the problem
     virtual IMipConstraint* addConstraint(double lb, double ub, const std::string& name) = 0;
+
+    /// Add range of bounded constraints to the problem
+    virtual std::vector<IMipConstraint*> addConstraint(double lb,
+                                                       double ub,
+                                                       const std::string& name,
+                                                       unsigned int number_new_constraints)
+      = 0;
+
     virtual IMipConstraint* getConstraint(const std::string& name) const = 0;
     virtual int constraintCount() const = 0;
-Original file line number
+Diff line change
@@ Expand Up / @@ -22,6 +22,7 @@ add_library(Antares::${PROJ} ALIAS ${PROJ}) @@
     set_target_properties(${PROJ} PROPERTIES LINKER_LANGUAGE CXX)
     target_include_directories(${PROJ}
             PUBLIC
     	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
@@ Expand Down @@