[ANT-4033] Feat: Support setObjectiveOffset

src/optimisation/linear-problem-api/include/antares/optimisation/linear-problem-api/linearProblem.h

@@ -75,6 +75,9 @@ class ILinearProblem
     virtual void setObjectiveCoefficient(IMipVariable* var, double coefficient) = 0;
     virtual double getObjectiveCoefficient(const IMipVariable* var) const = 0;
 
+    virtual void setObjectiveOffset(double offset) = 0;
+    virtual double getObjectiveOffset() const = 0;
+
     /// Sets the optimization direction to minimize
     virtual void setMinimization() = 0;
     /// Sets the optimization direction to maximize

src/optimisation/linear-problem-mpsolver-impl/include/antares/optimisation/linear-problem-mpsolver-impl/linearProblem.h

@@ -72,6 +72,9 @@ class OrtoolsLinearProblem: public LinearProblemApi::ILinearProblem
     void setObjectiveCoefficient(LinearProblemApi::IMipVariable* var, double coefficient) override;
     double getObjectiveCoefficient(const LinearProblemApi::IMipVariable* var) const override;
 
+    void setObjectiveOffset(double offset) override;
+    double getObjectiveOffset() const override;
+
     void setMinimization() override;
     void setMaximization() override;
 

src/optimisation/linear-problem-mpsolver-impl/linearProblem.cpp

@@ -183,6 +183,16 @@ double OrtoolsLinearProblem::getObjectiveCoefficient(
     return objective_->GetCoefficient(getMpVar(var));
 }
 
+void OrtoolsLinearProblem::setObjectiveOffset(double offset)
+{
+    objective_->SetOffset(offset);
+}
+
+double OrtoolsLinearProblem::getObjectiveOffset() const
+{
+    return objective_->offset();
+}
+
 void OrtoolsLinearProblem::setMinimization()
 {
     objective_->SetMinimization();

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

@@ -27,7 +27,10 @@
 #include <antares/expressions/nodes/ExpressionsNodes.h>
 #include <antares/expressions/visitors/EvalVisitor.h>
 #include <antares/solver/optim-model-filler/ComponentFiller.h>
+#include "antares/exception/InvalidArgumentError.hpp"
+#include "antares/exception/RuntimeError.hpp"
 #include "antares/expressions/visitors/TimeIndexVisitor.h"
+#include "antares/logs/logs.h"
 
 namespace
 {
@@ -284,12 +287,12 @@ void ComponentFiller::addVariables(const LinearProblemApi::FillContext& ctx)
         return;
     }
 
-    Expressions::Visitors::EvalVisitor evaluator(optimEntityContainer_, ctx, component_);
+    Visitors::EvalVisitor evaluator(optimEntityContainer_, ctx, component_);
     auto valueOrDefault = [&evaluator](const auto& node, double defaultValue)
     {
         if (node.Empty())
         {
-            return Expressions::Visitors::EvaluationResult(defaultValue);
+            return Visitors::EvaluationResult(defaultValue);
         }
         return evaluator.dispatch(node.RootNode());
     };
@@ -336,7 +339,7 @@ void ComponentFiller::addVariables(const LinearProblemApi::FillContext& ctx)
 }
 
 void ComponentFiller::addStaticConstraint(const LinearConstraint& linear_constraint,
-                                          const std::string& constraint_id)
+                                          const std::string& constraint_id) const
 {
     auto* ct = optimEntityContainer_.Problem().addConstraint(linear_constraint.lb[0],
                                                              linear_constraint.ub[0],
@@ -353,7 +356,7 @@ void ComponentFiller::addStaticConstraint(const LinearConstraint& linear_constra
 
 void ComponentFiller::addTimeDependentConstraints(const LinearConstraint& linear_constraints,
                                                   const std::string& constraint_id,
-                                                  const LinearProblemApi::FillContext& ctx)
+                                                  const LinearProblemApi::FillContext& ctx) const
 {
     auto& pb = optimEntityContainer_.Problem();
     const auto dims = getDimensions(ctx);
@@ -409,6 +412,19 @@ void ComponentFiller::addConstraints(const LinearProblemApi::FillContext& ctx)
     }
 }
 
+namespace
+{
+/*
+ * Given objective ax + b, x being a time dependent variable and b a parameter. b is the offset.
+ * Problems are a_1*x_1+b + a_2*x_2+b + ... + a_n*x_n+b
+ * => offset = n*b
+ */
+double updateOffset(double initialValue, double offset)
+{
+    return initialValue + offset;
+}
+} // namespace
+
 void ComponentFiller::addObjectives(const LinearProblemApi::FillContext& ctx)
 {
     auto* model = component_.getModel();
@@ -420,27 +436,30 @@ void ComponentFiller::addObjectives(const LinearProblemApi::FillContext& ctx)
       [&](const auto& objective)
       { return AreLocationsCompatible(objective.location(), targetLocation_); });
 
+    auto& pb = optimEntityContainer_.Problem();
     for (const auto& objective: model->Objectives() | locationFilter)
     {
         const auto linearExpression = visitor.visitMergeDuplicates(
           objective.expression().RootNode());
 
-        auto& pb = optimEntityContainer_.Problem();
+        double objectiveOffset = 0.0;
         for (const auto& expr: linearExpression)
         {
             for (const auto& [index, value]: expr)
             {
                 pb.setObjectiveCoefficient(solverVariables[static_cast<std::size_t>(index)].get(),
                                            value);
             }
+            objectiveOffset = updateOffset(objectiveOffset, expr.constant());
         }
+        pb.setObjectiveOffset(objectiveOffset);
     }
 }
 
 TimeIndex ComponentFiller::getConstraintTimeIndex(const Nodes::Node* node,
                                                   const Component& component) const
 {
-    Expressions::Visitors::TimeIndexVisitor timeIndexVisitor(optimEntityContainer_, component);
+    Visitors::TimeIndexVisitor timeIndexVisitor(optimEntityContainer_, component);
     return timeIndexVisitor.dispatch(node);
 }
 } // namespace Antares::Optimisation