[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
 {
@@ -279,12 +282,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());
     };
@@ -331,7 +334,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],
@@ -348,7 +351,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);
@@ -404,6 +407,60 @@ void ComponentFiller::addConstraints(const LinearProblemApi::FillContext& ctx)
     }
 }
 
+namespace
+{
+std::optional<double> updateOffset(std::optional<double> objectiveOffset,
+                                   double offset,
+                                   std::string objectiveId,
+                                   LinearProblemApi::ILinearProblem& pb)
+{
+    constexpr double eps = 1e-6; // tolérance numérique pour les comparaisons
+
+    if (!std::isfinite(offset))
+    {
+        throw Error::InvalidArgumentError(
+          fmt::format("Invalid objective offset (non-finite) for objective: {}. Value: {}",
+                      objectiveId,
+                      offset));
+    }
+
+    if (std::abs(offset) < eps)
+    {
+        logs.debug() << fmt::format("Ignoring near-zero objective offset for objective: "
+                                    "{}.\n\tCurrent value: {}\n\tIgnored value: {}",
+                                    objectiveId,
+                                    objectiveOffset.value_or(0),
+                                    offset);
+        return objectiveOffset;
+    }
+
+    if (!objectiveOffset.has_value())
+    {
+        pb.setObjectiveOffset(offset);
+        return offset;
+    }
+
+    if (std::abs(offset - *objectiveOffset) > eps)
+    {
+        throw Error::RuntimeError(
+          fmt::format("Trying to set multiple objective offset for the same objective."
+                      "\n\tObjective: {}"
+                      "\n\tExisting offset: {}"
+                      "\n\tNew offset: {}",
+                      objectiveId,
+                      *objectiveOffset,
+                      offset));
+    }
+
+    logs.debug() << fmt::format("Duplicate objective offset equals existing value for objective: "
+                                "{}.\n\tExisting: {}\n\tDuplicate: {}",
+                                objectiveId,
+                                objectiveOffset.value_or(0),
+                                offset);
+    return objectiveOffset;
+}
+} // namespace
+
 void ComponentFiller::addObjectives(const LinearProblemApi::FillContext& ctx)
 {
     auto* model = component_.getModel();
@@ -421,21 +478,23 @@ void ComponentFiller::addObjectives(const LinearProblemApi::FillContext& ctx)
           objective.expression().RootNode());
 
         auto& pb = optimEntityContainer_.Problem();
+        std::optional<double> objectiveOffset;
         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(), objective.Id(), pb);
         }
     }
 }
 
 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