[ANT-4033] Feat: Support setObjectiveOffset

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

@@ -92,6 +92,8 @@ class ILinearProblem
     // Definition of infinity
     [[nodiscard]] virtual double infinity() const = 0;
     virtual bool isLP() const = 0;
+
+    virtual double objectiveValue() const = 0;
 };
 
 } // namespace Antares::Optimisation::LinearProblemApi

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

@@ -105,6 +105,14 @@ class OrtoolsLinearProblem: public LinearProblemApi::ILinearProblem
 
     OrtoolsMipSolution* solve(bool verboseSolver) override;
 
+    /**
+     * Return the last solution or solve if no solution exist.
+     * @param verboseSolver
+     * @return The solution
+     */
+    OrtoolsMipSolution* solution(bool verboseSolver);
+    double objectiveValue() const override;
+
     [[nodiscard]] double infinity() const override;
     [[nodiscard]] bool isLP() const override;
 

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

@@ -231,6 +231,20 @@ OrtoolsMipSolution* OrtoolsLinearProblem::solve(bool verboseSolver)
     return solution_.get();
 }
 
+OrtoolsMipSolution* OrtoolsLinearProblem::solution(bool verboseSolver)
+{
+    if (!solution_)
+    {
+        solve(verboseSolver);
+    }
+    return solution_.get();
+}
+
+double OrtoolsLinearProblem::objectiveValue() const
+{
+    return ::getObjectiveValue(mpSolver_);
+}
+
 double OrtoolsLinearProblem::infinity() const
 {
     return MPSolver::infinity();

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

@@ -26,8 +26,7 @@
 namespace Antares::Optimisation::LinearProblemMpsolverImpl
 {
 
-OrtoolsMipSolution::OrtoolsMipSolution(operations_research::MPSolver::ResultStatus& status,
-                                       operations_research::MPSolver* solver):
+OrtoolsMipSolution::OrtoolsMipSolution(MPSolver::ResultStatus& status, MPSolver* solver):
     status_(status),
     mpSolver_(solver)
 {
@@ -41,13 +40,13 @@ LinearProblemApi::MipStatus OrtoolsMipSolution::getStatus() const
 {
     switch (status_)
     {
-    case operations_research::MPSolver::ResultStatus::OPTIMAL:
+    case MPSolver::ResultStatus::OPTIMAL:
         return LinearProblemApi::MipStatus::OPTIMAL;
-    case operations_research::MPSolver::ResultStatus::FEASIBLE:
+    case MPSolver::ResultStatus::FEASIBLE:
         return LinearProblemApi::MipStatus::FEASIBLE;
-    case operations_research::MPSolver::ResultStatus::UNBOUNDED:
+    case MPSolver::ResultStatus::UNBOUNDED:
         return LinearProblemApi::MipStatus::UNBOUNDED;
-    case operations_research::MPSolver::ResultStatus::INFEASIBLE:
+    case MPSolver::ResultStatus::INFEASIBLE:
         return LinearProblemApi::MipStatus::INFEASIBLE;
     default:
         logs.warning() << "Solve returned an error status";

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

@@ -19,6 +19,7 @@
  * along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
  */
 
+#include <numeric>
 #include <ranges>
 #include <stdexcept>
 #include <variant>
@@ -331,7 +332,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 +349,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);
@@ -413,6 +414,7 @@ void ComponentFiller::addObjectives(const LinearProblemApi::FillContext& ctx)
     auto* model = component_.getModel();
     ReadLinearExpressionVisitor visitor(optimEntityContainer_, ctx, component_);
 
+    double objectiveOffset = 0.0;
     for (const auto& objective: model->Objectives() | locationFilter())
     {
         const auto root_node = objective.expression().RootNode();
@@ -424,7 +426,10 @@ void ComponentFiller::addObjectives(const LinearProblemApi::FillContext& ctx)
             throw Error::RuntimeError("Time dependent objectives are not supported in Antares.");
         }
         addStaticObjective(linearExpression);
+        objectiveOffset += linearExpression.constant()[0];
     }
+    auto& pb = optimEntityContainer_.Problem();
+    pb.setObjectiveOffset(objectiveOffset);
 }
 
 VariabilityType ComponentFiller::getVariability(const Node* node, const Component& component) const

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

@@ -92,11 +92,11 @@ class ComponentFiller: public LinearProblemApi::LinearProblemFiller
 
 private:
     void addStaticConstraint(const LinearConstraint& linear_constraint,
-                             const std::string& constraint_id);
+                             const std::string& constraint_id) const;
 
     void addTimeDependentConstraints(const LinearConstraint& linear_constraints,
                                      const std::string& constraint_id,
-                                     const LinearProblemApi::FillContext& ctx);
+                                     const LinearProblemApi::FillContext& ctx) const;
 
     void addStaticObjective(const Optimization::TimeDependentLinearExpression& expression) const;
 

src/solver/optimisation/LegacyFiller.cpp

@@ -91,6 +91,7 @@ void LegacyFiller::CreateVariable(unsigned idxVar) const
                                            isIntegerVariable,
                                            GetVariableName(idxVar));
     linearProblem_.setObjectiveCoefficient(var, problemeAResoudre_->CoutLineaire[idxVar]);
+    // linearProblem_.setObjectiveOffset(problemeAResoudre_->)
 }
 
 void LegacyFiller::CopyVariables() const

src/solver/optimisation/include/antares/solver/optimisation/LegacyOrtoolsLinearProblem.h

@@ -27,7 +27,7 @@ namespace Antares::Optimization
 {
 
 class LegacyOrtoolsLinearProblem final
-    : public Antares::Optimisation::LinearProblemMpsolverImpl::OrtoolsLinearProblem
+    : public Optimisation::LinearProblemMpsolverImpl::OrtoolsLinearProblem
 {
 public:
     LegacyOrtoolsLinearProblem(bool isMip, const std::string& solverName):
@@ -36,7 +36,7 @@ class LegacyOrtoolsLinearProblem final
         // nothing else to do
     }
 
-    operations_research::MPSolver* getMpSolver()
+    MPSolver* getMpSolver()
     {
         return MpSolver();
     }

src/solver/optimisation/opt_appel_solveur_lineaire.cpp

@@ -176,13 +176,12 @@ static SimplexResult OPT_TryToCallSimplex(const SingleOptimOptions& options,
     FillContext fillCtx = buildFillContext(problemeHebdo, NumIntervalle);
     const auto& modelerData = problemeHebdo->modelerData;
     bool hasModelerData = modelerData != nullptr;
-    const Optimisation::LinearProblemApi::ILinearProblemData* modelerDataSeries = hasModelerData
-                                                                                    ? modelerData
-                                                                                        ->dataSeries
-                                                                                        .get()
-                                                                                    : nullptr;
-    const Optimisation::ScenarioGroupRepository* modelerScenarioGroupRepository
-      = hasModelerData ? &modelerData->scenarioGroupRepository : nullptr;
+    const ILinearProblemData* modelerDataSeries = hasModelerData ? modelerData->dataSeries.get()
+                                                                 : nullptr;
+    const ScenarioGroupRepository* modelerScenarioGroupRepository = hasModelerData
+                                                                      ? &modelerData
+                                                                           ->scenarioGroupRepository
+                                                                      : nullptr;
 
     OptimEntityContainer optimEntityContainer(ortoolsProblem,
                                               modelerDataSeries,
@@ -332,9 +331,9 @@ bool OPT_AppelDuSimplexe(const SingleOptimOptions& options,
         FillContext fillCtx = buildFillContext(problemeHebdo, NumIntervalle);
         const auto& modelerData = problemeHebdo->modelerData;
         bool hasModelerData = modelerData != nullptr;
-        const Optimisation::LinearProblemApi::ILinearProblemData* modelerDataSeries
-          = hasModelerData ? modelerData->dataSeries.get() : nullptr;
-        const Optimisation::ScenarioGroupRepository* modelerScenarioGroupRepository
+        const ILinearProblemData* modelerDataSeries = hasModelerData ? modelerData->dataSeries.get()
+                                                                     : nullptr;
+        const ScenarioGroupRepository* modelerScenarioGroupRepository
           = hasModelerData ? &modelerData->scenarioGroupRepository : nullptr;
 
         OptimEntityContainer optimEntityContainer(infeasibleProblem,

src/tests/cucumber/features/solver-features/hybrid_studies.feature

@@ -85,4 +85,12 @@ Feature: hybrid (simulator+modeler) studies
     Given the solver study path is "Antares_Simulator_Tests_NR/invalid-studies/hybrid/Scenario-independent variable"
     When I run antares simulator
     Then the simulation fails
-    And the message "Scenario-independent variables are not supported in hybrid studies" is reported in the logs
+    And the message "Scenario-independent variables are not supported in hybrid studies" is reported in the logs
+
+  @fast @short
+  Scenario: Two studies with same structure should have the same objective value at each time step
+    Given the study path 1 is "Antares_Simulator_Tests_NR/hybrid/14_1/five_steps_hybrid_fixed_load"
+    And the study path 2 is "Antares_Simulator_Tests_NR/hybrid/14_1/five_steps_hybrid_flexible_load"
+    When I run antares simulator on all studies
+    Then all simulations succeed
+    And for each time step, all studies have the same objective value

src/tests/cucumber/features/steps/common_steps/modeler_output_handler.py

@@ -19,6 +19,7 @@ def __init__(self, master, subproblem, structure):
         self.subproblem = subproblem
         self.structure = structure
 
+
 class modeler_output_handler:
     def __init__(self, simulation_table_location, output_location=None):
         self.simulation_table = modeler_output_handler.__read_simulation_table(simulation_table_location)
@@ -54,7 +55,7 @@ def __read_simulation_table(absolute_path) -> pd.DataFrame:
             df[col] = df[col].astype(float)
         return df
 
-    def get_simulation_table_entry(self, component : str, output : str, block : int, timestep : int, scenario : int):
+    def get_simulation_table_entry(self, component: str, output: str, block: int, timestep: int, scenario: int):
         df = self.simulation_table[(self.simulation_table["component"] == component)
                                    & (self.simulation_table["output"] == output)]
         if not pd.isna(block):
@@ -68,11 +69,28 @@ def get_simulation_table_entry(self, component : str, output : str, block : int,
         else:
             df = df[df["scenario_index"] == scenario]
         if len(df) != 1:
-            raise LookupError(f"Simulation table contains {len(df)} row(s) (expected 1) for component '{component}', output '{output}', block '{block}', timestep '{timestep}', scenario '{scenario}'")
+            raise LookupError(
+                f"Simulation table contains {len(df)} row(s) (expected 1) for component '{component}', output '{output}', block '{block}', timestep '{timestep}', scenario '{scenario}'")
         return df["value"].iloc[0]
 
     def get_objective_value(self):
         df = self.simulation_table[(self.simulation_table["output"] == "OBJECTIVE_VALUE")]
         if len(df) != 1:
             raise LookupError(f"Simulation table contains no or multiple objective values")
         return df["value"].iloc[0]
+
+    def get_objective_values_by_block(self):
+        """
+        Returns a dictionary mapping block number to objective value.
+        Each block represents a time step in the optimization.
+        """
+        df = self.simulation_table[(self.simulation_table["output"] == "OBJECTIVE_VALUE")]
+        if df.empty:
+            raise LookupError(f"Simulation table contains no objective values")
+        # Group by block and get the objective value for each block
+        result = {}
+        for _, row in df.iterrows():
+            block = int(row["block"])
+            value = row["value"]
+            result[block] = value
+        return result

src/tests/cucumber/features/steps/common_steps/solver_steps.py

@@ -389,6 +389,144 @@ def ckeck_log_exists(context, log):
     raise AssertionError(f"Log '{log}' is not reported in the logs")
 
 
+def _initialize_multi_study_context(context):
+    """Initialize context for multiple study simulations"""
+    if not hasattr(context, 'multi_studies'):
+        context.multi_studies = []
+
+
+def _store_simulation_result(context, study_index: int):
+    """Store simulation results for a given study index"""
+    result = {
+        'index': study_index,
+        'path': context.study_path,
+        'return_code': context.return_code,
+        'logs_out': context.logs_out,
+        'logs_err': context.logs_err,
+        'output_path': context.output_path,
+        'soh': context.soh,
+        'moh': context.moh if hasattr(context, 'moh') else None
+    }
+    context.multi_studies.append(result)
+
+
+def _run_study_at_index(context, study_index: int, study_path: Path):
+    """Run a single study and store its results"""
+    context.study_path = study_path
+    init_simulation(context)
+    context.named_mps_problems = False
+    context.parallel = False
+    run_simulation(context)
+    _store_simulation_result(context, study_index)
+
+
+@given('the study path {study_num:d} is "{string}"')
+def nth_study_path_is(context, study_num, string):
+    """Generic step to define the Nth study path"""
+    _initialize_multi_study_context(context)
+    study_path = Path(context.config.userdata["resources-path"]) / Path(string.replace("/", os.sep))
+    assert study_path.exists(), f"Study path {study_num} ({study_path}) does not exist"
+
+    if not hasattr(context, 'study_paths'):
+        context.study_paths = []
+
+    # Extend list if necessary to accommodate the index
+    while len(context.study_paths) < study_num:
+        context.study_paths.append(None)
+
+    # Store at index (1-based to 0-based conversion)
+    context.study_paths[study_num - 1] = study_path
+
+
+@when('I run antares simulator on all studies')
+def run_antares_on_all_studies(context):
+    """Run simulator on all defined studies"""
+    _initialize_multi_study_context(context)
+
+    assert hasattr(context, 'study_paths'), "No study paths defined"
+    assert len(context.study_paths) > 0, "No study paths defined"
+
+    # Run all studies
+    for idx, study_path in enumerate(context.study_paths):
+        assert study_path is not None, f"Study path at index {idx} is not defined"
+        _run_study_at_index(context, idx, study_path)
+
+
+@then('all simulations succeed')
+def all_simulations_succeed(context):
+    """Check that all simulations succeeded"""
+    assert hasattr(context, 'multi_studies'), "No simulations were run"
+    assert len(context.multi_studies) > 0, "No simulations were run"
+
+    failures = []
+    for study in context.multi_studies:
+        if study['return_code'] != 0:
+            failures.append(
+                f"Study {study['index'] + 1} (path: {study['path']}) failed with return code {study['return_code']}: "
+                f"\nSTDOUT: \n{study['logs_out']} \n STDERR: \n{study['logs_err']}"
+            )
+
+    if failures:
+        raise AssertionError("\n\n".join(failures))
+
+
+@then('for each time step, all studies have the same objective value')
+def compare_objective_values_all_studies(context):
+    """Compare objective values across all studies to ensure they are identical"""
+    assert hasattr(context, 'multi_studies'), "No simulations were run"
+    assert len(context.multi_studies) > 1, f"Need at least 2 studies to compare, found {len(context.multi_studies)}"
+
+    # Collect all objective values
+    all_objectives = []
+    for study in context.multi_studies:
+        assert study['moh'] is not None, \
+            f"Study {study['index'] + 1} (path: {study['path']}) does not have modeler outputs (simulation_table)"
+        objectives = study['moh'].get_objective_values_by_block()
+        all_objectives.append({
+            'index': study['index'],
+            'path': study['path'],
+            'objectives': objectives
+        })
+
+    # Use first study as reference
+    reference = all_objectives[0]
+    reference_blocks = set(reference['objectives'].keys())
+
+    # Compare each study against the reference
+    all_mismatches = []
+    for study_data in all_objectives[1:]:
+        study_blocks = set(study_data['objectives'].keys())
+
+        # Check blocks match
+        if reference_blocks != study_blocks:
+            all_mismatches.append(
+                f"Study {study_data['index'] + 1} has different blocks. "
+                f"Reference: {sorted(reference_blocks)}, Study: {sorted(study_blocks)}"
+            )
+            continue
+
+        # Compare values for each block
+        mismatches = []
+        for block in sorted(reference_blocks):
+            ref_value = reference['objectives'][block]
+            study_value = study_data['objectives'][block]
+            if not np.isclose(ref_value, study_value, rtol=1e-9, atol=1e-9):
+                mismatches.append(
+                    f"  Block {block}: reference={ref_value}, study {study_data['index'] + 1}={study_value}, "
+                    f"diff={abs(ref_value - study_value)}"
+                )
+
+        if mismatches:
+            all_mismatches.append(
+                f"Study {study_data['index'] + 1} (path: {study_data['path']}) differs from reference:\n" +
+                "\n".join(mismatches)
+            )
+
+    if all_mismatches:
+        error_msg = "Objective values differ between studies:\n\n" + "\n\n".join(all_mismatches)
+        raise AssertionError(error_msg)
+
+
 @then(
     'in area "{area}", during year {year:d}, hourly value of "{var_name}" for hour {hour:d} is equal to {expected_value:d}')
 def check_hourly_variable_value(context, area, year, var_name, hour, expected_value):