Unfeasible problem analyzer : add a new check

src/solver/infeasible-problem-analysis/CMakeLists.txt

@@ -7,8 +7,6 @@ set(SRC_INFEASIBLE_PROBLEM_ANALYSIS
   report.cpp
   constraint.h
   constraint.cpp
-  exceptions.h
-  exceptions.cpp
   )
 
 add_library(infeasible_problem_analysis ${SRC_INFEASIBLE_PROBLEM_ANALYSIS})

src/solver/infeasible-problem-analysis/problem.cpp

@@ -1,5 +1,5 @@
 #include "problem.h"
-#include "exceptions.h"
+#include <antares/logs/logs.h>
 
 #include <fstream>
 #include <regex>
@@ -13,8 +13,7 @@ namespace Optimization
 {
 InfeasibleProblemAnalysis::InfeasibleProblemAnalysis(const std::string& solverName, const PROBLEME_SIMPLEXE_NOMME* ProbSpx)
 {
-    mSolver
-      = std::unique_ptr<MPSolver>(ProblemSimplexeNommeConverter(solverName, ProbSpx).Convert());
+    problem_ = std::unique_ptr<MPSolver>(ProblemSimplexeNommeConverter(solverName, ProbSpx).Convert());
 }
 
 void InfeasibleProblemAnalysis::addSlackVariables()
@@ -25,25 +24,25 @@ void InfeasibleProblemAnalysis::addSlackVariables()
        This should not happen in most cases.
     */
     const unsigned int selectedConstraintsInverseRatio = 3;
-    mSlackVariables.reserve(mSolver->NumConstraints() / selectedConstraintsInverseRatio);
+    mSlackVariables.reserve(problem_->NumConstraints() / selectedConstraintsInverseRatio);
     std::regex rgx(constraint_name_pattern);
     const double infinity = MPSolver::infinity();
-    for (MPConstraint* constraint : mSolver->constraints())
+    for (MPConstraint* constraint : problem_->constraints())
     {
         if (std::regex_search(constraint->name(), rgx))
         {
             if (constraint->lb() != -infinity)
             {
                 const MPVariable* slack
-                  = mSolver->MakeNumVar(0, infinity, constraint->name() + "::low");
+                  = problem_->MakeNumVar(0, infinity, constraint->name() + "::low");
                 constraint->SetCoefficient(slack, 1.);
                 mSlackVariables.push_back(slack);
             }
 
             if (constraint->ub() != infinity)
             {
                 const MPVariable* slack
-                  = mSolver->MakeNumVar(0, infinity, constraint->name() + "::up");
+                  = problem_->MakeNumVar(0, infinity, constraint->name() + "::up");
                 constraint->SetCoefficient(slack, -1.);
                 mSlackVariables.push_back(slack);
             }
@@ -53,7 +52,7 @@ void InfeasibleProblemAnalysis::addSlackVariables()
 
 void InfeasibleProblemAnalysis::buildObjective() const
 {
-    MPObjective* objective = mSolver->MutableObjective();
+    MPObjective* objective = problem_->MutableObjective();
     // Reset objective function
     objective->Clear();
     // Only slack variables have a non-zero cost
@@ -66,24 +65,33 @@ void InfeasibleProblemAnalysis::buildObjective() const
 
 MPSolver::ResultStatus InfeasibleProblemAnalysis::Solve() const
 {
-    return mSolver->Solve();
+    return problem_->Solve();
 }
 
-InfeasibleProblemReport InfeasibleProblemAnalysis::produceReport()
+bool InfeasibleProblemAnalysis::run()
 {
+    logs.notice() << " Solver: Starting infeasibility analysis...";
     addSlackVariables();
     if (mSlackVariables.empty())
     {
-        throw SlackVariablesEmpty(
-          "Cannot generate infeasibility report: no constraints have been selected");
+        logs.error() << "Cannot generate infeasibility report: no constraints have been selected";
+        return false;
     }
+
     buildObjective();
+
     const MPSolver::ResultStatus status = Solve();
     if ((status != MPSolver::OPTIMAL) && (status != MPSolver::FEASIBLE))
     {
-        throw ProblemResolutionFailed(
-          "Linear problem could not be solved, and infeasibility analysis could not help");
+        logs.error() << "Linear problem could not be solved, and infeasibility analysis could not help";
+        return false;
     }
+
+    return true;
+}
+
+InfeasibleProblemReport InfeasibleProblemAnalysis::produceReport()
+{
     return InfeasibleProblemReport(mSlackVariables);
 }
 } // namespace Optimization

src/solver/infeasible-problem-analysis/problem.h

@@ -16,17 +16,17 @@ class InfeasibleProblemAnalysis
 public:
     InfeasibleProblemAnalysis() = delete;
     explicit InfeasibleProblemAnalysis(const std::string& solverName, const PROBLEME_SIMPLEXE_NOMME* ProbSpx);
+    bool run();
     InfeasibleProblemReport produceReport();
 
 private:
     void buildObjective() const;
     void addSlackVariables();
     operations_research::MPSolver::ResultStatus Solve() const;
 
-    std::unique_ptr<operations_research::MPSolver> mSolver;
+    std::unique_ptr<operations_research::MPSolver> problem_;
     std::vector<const operations_research::MPVariable*> mSlackVariables;
-    const std::string constraint_name_pattern = "^AreaHydroLevel::|::hourly::|::daily::|::weekly::|^FictiveLoads::";
-
+    const std::string constraint_name_pattern = "^AreaHydroLevel::|::hourly::|::daily::|::weekly::|^FictiveLoads::";                              
 };
 } // namespace Optimization
 } // namespace Antares

src/solver/optimisation/opt_appel_solveur_lineaire.cpp

@@ -47,7 +47,6 @@ extern "C"
 #include "../utils/filename.h"
 
 #include "../infeasible-problem-analysis/problem.h"
-#include "../infeasible-problem-analysis/exceptions.h"
 
 #include <chrono>
 
@@ -376,20 +375,11 @@ bool OPT_AppelDuSimplexe(const OptimizationOptions& options,
 
         Probleme.SetUseNamedProblems(true);
         Optimization::InfeasibleProblemAnalysis analysis(options.solverName, &Probleme);
-        logs.notice() << " Solver: Starting infeasibility analysis...";
-        try
+        if (analysis.run())
         {
             Optimization::InfeasibleProblemReport report = analysis.produceReport();
             report.prettyPrint();
         }
-        catch (const Optimization::SlackVariablesEmpty& ex)
-        {
-            logs.error() << ex.what();
-        }
-        catch (const Optimization::ProblemResolutionFailed& ex)
-        {
-            logs.error() << ex.what();
-        }
 
         auto mps_writer_on_error = simplexResult.mps_writer_factory.createOnOptimizationError();
         const std::string filename = createMPSfilename(optPeriodStringGenerator, optimizationNumber);

src/solver/utils/ortools_utils.cpp

@@ -32,9 +32,9 @@ namespace Antares
 namespace Optimization
 {
 ProblemSimplexeNommeConverter::ProblemSimplexeNommeConverter(
-  const std::string& solverName,
-  const Antares::Optimization::PROBLEME_SIMPLEXE_NOMME* problemeSimplexe) :
- solverName_(solverName), problemeSimplexe_(problemeSimplexe)
+        const std::string& solverName,
+        const Antares::Optimization::PROBLEME_SIMPLEXE_NOMME* problemeSimplexe)
+    : solverName_(solverName), problemeSimplexe_(problemeSimplexe)
 {
     if (problemeSimplexe_->UseNamedProblems())
     {
@@ -364,11 +364,16 @@ MPSolver* MPSolverFactory(const Antares::Optimization::PROBLEME_SIMPLEXE_NOMME*
             solver = MPSolver::CreateSolver((OrtoolsUtils::solverMap.at(solverName)).LPSolverName);
 
         if (!solver)
-            throw Antares::Data::AssertionError("Solver not found: " + solverName);
+        {
+            std::string msg_to_throw = "Solver " + solverName + " not found. \n";
+            msg_to_throw += "Please make sure that your OR-Tools install supports solver " + solverName + ".";
+
+            throw Antares::Data::AssertionError(msg_to_throw);
+        }
     }
     catch (...)
     {
-        Antares::logs.error() << "Solver creation failed";
+        Antares::logs.error() << "Solver creation failed.";
         throw;
     }
 

src/tests/run-study-tests/test_unfeasible_problem.py

@@ -64,5 +64,4 @@ def test_unfeasible_problem_01__warning_dry(study_path, check_runner):
     checks.add(check = unfeasible_problem(study_path, new_behavior="warning-dry",
                                           checks_on_weeks=warnings_on_weeks,
                                           simulation=check_runner.get_simulation()))
-    check_runner.run(checks)
-
+    check_runner.run(checks)