[ANT-2749] Support time dependency

src/solver/optim-model-filler/LinearExpression.cpp

@@ -19,6 +19,7 @@
  * along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
  */
 
+#include <algorithm>
 #include <stdexcept>
 
 #include <antares/solver/optim-model-filler/LinearExpression.h>
@@ -83,6 +84,13 @@ LinearExpression LinearExpression::operator+(const LinearExpression& other) cons
     return {offset_ + other.offset_, add_maps(coef_per_var_, other.coef_per_var_, 1)};
 }
 
+LinearExpression& LinearExpression::operator+=(const LinearExpression& other)
+{
+    this->offset_ += other.offset_;
+    this->coef_per_var_ = add_maps(coef_per_var_, other.coef_per_var_, 1);
+    return *this;
+}
+
 LinearExpression LinearExpression::operator-(const LinearExpression& other) const
 {
     return {offset_ - other.offset_, add_maps(coef_per_var_, other.coef_per_var_, -1)};
@@ -117,4 +125,97 @@ LinearExpression LinearExpression::negate() const
 {
     return {-offset_, scale_map(coef_per_var_, -1)};
 }
+
+TimeDependentLinearExpression::TimeDependentLinearExpression(
+  const std::map<unsigned int, LinearExpression>& linearExpressions):
+    linearExpressions_(linearExpressions)
+
+{
+}
+
+TimeDependentLinearExpression TimeDependentLinearExpression::operator+(
+  const TimeDependentLinearExpression& other) const
+{
+    const auto& linear_expressions = GetLinearExpressions();
+    const auto& other_linear_expressions = other.GetLinearExpressions();
+
+    std::map result(linear_expressions);
+    for (auto [key, value]: other_linear_expressions)
+    {
+        if (result.contains(key))
+        {
+            result[key] += value;
+        }
+        else
+        {
+            result[key] = value;
+        }
+    }
+
+    return TimeDependentLinearExpression(std::move(result));
+}
+
+TimeDependentLinearExpression TimeDependentLinearExpression::operator-(
+  const TimeDependentLinearExpression& other) const
+{
+    checkOtherLength(other);
+    const auto& linear_expressions = GetLinearExpressions();
+    const auto& other_linear_expressions = other.GetLinearExpressions();
+    std::map<unsigned int, LinearExpression> result(linear_expressions.size());
+    for (size_t i = 0; i < linear_expressions.size(); ++i)
+    {
+        result[i] = linear_expressions[i] - other_linear_expressions[i];
+    }
+    return TimeDependentLinearExpression(std::move(result));
+}
+
+TimeDependentLinearExpression TimeDependentLinearExpression::operator*(
+  const TimeDependentLinearExpression& other) const
+{
+    checkOtherLength(other);
+    const auto& linear_expressions = GetLinearExpressions();
+    const auto& other_linear_expressions = other.GetLinearExpressions();
+    std::map<unsigned int, LinearExpression> result(linear_expressions.size());
+    for (size_t i = 0; i < linear_expressions.size(); ++i)
+    {
+        result[i] = linear_expressions[i] * other_linear_expressions[i];
+    }
+    return TimeDependentLinearExpression(std::move(result));
+}
+
+TimeDependentLinearExpression TimeDependentLinearExpression::operator/(
+  const TimeDependentLinearExpression& other) const
+{
+    checkOtherLength(other);
+    const auto& linear_expressions = GetLinearExpressions();
+    const auto& other_linear_expressions = other.GetLinearExpressions();
+    std::map<unsigned int, LinearExpression> result(linear_expressions.size());
+    for (size_t i = 0; i < linear_expressions.size(); ++i)
+    {
+        result[i] = linear_expressions[i] / other_linear_expressions[i];
+    }
+    return TimeDependentLinearExpression(std::move(result));
+}
+
+TimeDependentLinearExpression TimeDependentLinearExpression::negate() const
+{
+    const auto& linear_expressions = GetLinearExpressions();
+    std::map<unsigned int, LinearExpression> result(linear_expressions.size());
+    for (size_t i = 0; i < linear_expressions.size(); ++i)
+    {
+        result[i] = linear_expressions[i].negate();
+    }
+    return TimeDependentLinearExpression(std::move(result));
+}
+
+std::map<unsigned int, LinearExpression> TimeDependentLinearExpression::GetLinearExpressions() const
+{
+    linearExpressions_;
+}
+
+size_t TimeDependentLinearExpression::getSize() const
+{
+    return linearExpressions_.size();
+}
+
 } // namespace Antares::Optimization

src/solver/optim-model-filler/ReadLinearExpressionVisitor.cpp

@@ -32,8 +32,16 @@ namespace Antares::Optimization
 {
 
 ReadLinearExpressionVisitor::ReadLinearExpressionVisitor(
-  Solver::Visitors::EvaluationContext context):
-    context_(std::move(context))
+  Solver::Visitors::EvaluationContext context,
+  const std::vector<unsigned int>& timesteps):
+    context_(std::move(context)),
+    timesteps_(timesteps)
+{
+}
+
+ReadLinearExpressionVisitor::ReadLinearExpressionVisitor(
+  const std::vector<unsigned int>& timesteps):
+    timesteps_(timesteps)
 {
 }
 
@@ -42,82 +50,82 @@ std::string ReadLinearExpressionVisitor::name() const
     return "ReadLinearExpressionVisitor";
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const SumNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const SumNode* node)
 {
     auto operands = node->getOperands();
     return std::accumulate(std::begin(operands),
                            std::end(operands),
-                           LinearExpression(),
-                           [this](LinearExpression sum, Node* operand)
+                           TimeDependentLinearExpression(),
+                           [this](TimeDependentLinearExpression sum, Node* operand)
                            { return sum + dispatch(operand); });
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const SubtractionNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const SubtractionNode* node)
 {
     return dispatch(node->left()) - dispatch(node->right());
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const MultiplicationNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const MultiplicationNode* node)
 {
     return dispatch(node->left()) * dispatch(node->right());
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const DivisionNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const DivisionNode* node)
 {
     return dispatch(node->left()) / dispatch(node->right());
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const EqualNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const EqualNode* node)
 {
     throw std::invalid_argument("A linear expression can't contain comparison operators.");
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const LessThanOrEqualNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const LessThanOrEqualNode* node)
 {
     throw std::invalid_argument("A linear expression can't contain comparison operators.");
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const GreaterThanOrEqualNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const GreaterThanOrEqualNode* node)
 {
     throw std::invalid_argument("A linear expression can't contain comparison operators.");
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const NegationNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const NegationNode* node)
 {
     return dispatch(node->child()).negate();
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const VariableNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const VariableNode* node)
 {
     return LinearExpression(0, {{node->value(), 1}});
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const ParameterNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const ParameterNode* node)
 {
     return {context_.getParameterValue(node->value()), {}};
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const LiteralNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const LiteralNode* node)
 {
     return {node->value(), {}};
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const PortFieldNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const PortFieldNode* node)
 {
     throw std::invalid_argument("ReadLinearExpressionVisitor cannot visit PortFieldNodes");
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const PortFieldSumNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const PortFieldSumNode* node)
 {
     throw std::invalid_argument("ReadLinearExpressionVisitor cannot visit PortFieldSumNodes");
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const ComponentVariableNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const ComponentVariableNode* node)
 {
     throw std::invalid_argument("ReadLinearExpressionVisitor cannot visit ComponentVariableNodes");
 }
 
-LinearExpression ReadLinearExpressionVisitor::visit(const ComponentParameterNode* node)
+TimeDependentLinearExpression ReadLinearExpressionVisitor::visit(const ComponentParameterNode* node)
 {
     throw std::invalid_argument("ReadLinearExpressionVisitor cannot visit ComponentParameterNodes");
 }

src/solver/optim-model-filler/include/antares/solver/optim-model-filler/LinearExpression.h

@@ -23,6 +23,7 @@
 
 #include <map>
 #include <string>
+#include <vector>
 
 namespace Antares::Optimization
 {
@@ -66,8 +67,36 @@ class LinearExpression
         return coef_per_var_;
     }
 
+    LinearExpression& operator+=(const LinearExpression& value);
+
 private:
     double offset_ = 0;
     std::map<std::string, double> coef_per_var_;
 };
+// time dependent parameter
+class TimeDependentLinearExpression
+{
+public:
+    TimeDependentLinearExpression() = default;
+    TimeDependentLinearExpression(const std::map<unsigned, LinearExpression>& linearExpressions);
+    void checkOtherLength(const TimeDependentLinearExpression& other) const;
+
+    /// Sum two linear expressions
+    TimeDependentLinearExpression operator+(const TimeDependentLinearExpression& other) const;
+    /// Subtract two linear expressions
+    TimeDependentLinearExpression operator-(const TimeDependentLinearExpression& other) const;
+    /// Multiply two linear expressions
+    /// Only one can have non-zero coefficients, otherwise the result cannot be linear
+    TimeDependentLinearExpression operator*(const TimeDependentLinearExpression& other) const;
+    /// Divide two linear expressions
+    /// Only first expression can have non-zero coefficients, otherwise the result cannot be linear
+    TimeDependentLinearExpression operator/(const TimeDependentLinearExpression& other) const;
+    /// Multiply linear expression by -1
+    TimeDependentLinearExpression negate() const;
+    std::map<unsigned, LinearExpression> GetLinearExpressions() const;
+    size_t getSize() const;
+
+private:
+    std::map<unsigned, LinearExpression> linearExpressions_;
+};
 } // namespace Antares::Optimization

src/solver/optim-model-filler/include/antares/solver/optim-model-filler/ReadLinearExpressionVisitor.h

@@ -34,29 +34,33 @@
 namespace Antares::Optimization
 {
 
-class ReadLinearExpressionVisitor: public Solver::Visitors::NodeVisitor<LinearExpression>
+class ReadLinearExpressionVisitor
+    : public Solver::Visitors::NodeVisitor<TimeDependentLinearExpression>
 {
 public:
-    ReadLinearExpressionVisitor() = default;
-    explicit ReadLinearExpressionVisitor(Solver::Visitors::EvaluationContext context);
+    explicit ReadLinearExpressionVisitor(const std::vector<unsigned int>& timesteps);
+    explicit ReadLinearExpressionVisitor(Solver::Visitors::EvaluationContext context,
+                                         const std::vector<unsigned int>& timesteps);
     std::string name() const override;
 
 private:
     const Solver::Visitors::EvaluationContext context_;
-    LinearExpression visit(const Solver::Nodes::SumNode* node) override;
-    LinearExpression visit(const Solver::Nodes::SubtractionNode* node) override;
-    LinearExpression visit(const Solver::Nodes::MultiplicationNode* node) override;
-    LinearExpression visit(const Solver::Nodes::DivisionNode* node) override;
-    LinearExpression visit(const Solver::Nodes::EqualNode* node) override;
-    LinearExpression visit(const Solver::Nodes::LessThanOrEqualNode* node) override;
-    LinearExpression visit(const Solver::Nodes::GreaterThanOrEqualNode* node) override;
-    LinearExpression visit(const Solver::Nodes::NegationNode* node) override;
-    LinearExpression visit(const Solver::Nodes::VariableNode* node) override;
-    LinearExpression visit(const Solver::Nodes::ParameterNode* node) override;
-    LinearExpression visit(const Solver::Nodes::LiteralNode* node) override;
-    LinearExpression visit(const Solver::Nodes::PortFieldNode* node) override;
-    LinearExpression visit(const Solver::Nodes::PortFieldSumNode* node) override;
-    LinearExpression visit(const Solver::Nodes::ComponentVariableNode* node) override;
-    LinearExpression visit(const Solver::Nodes::ComponentParameterNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::SumNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::SubtractionNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::MultiplicationNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::DivisionNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::EqualNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::LessThanOrEqualNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::GreaterThanOrEqualNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::NegationNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::VariableNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::ParameterNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::LiteralNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::PortFieldNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::PortFieldSumNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::ComponentVariableNode* node) override;
+    TimeDependentLinearExpression visit(const Solver::Nodes::ComponentParameterNode* node) override;
+
+    std::vector<unsigned int> timesteps_ = {};
 };
 } // namespace Antares::Optimization