Support more quadratic solvers

docs/developer-guide/CHANGELOG.md

@@ -12,6 +12,7 @@ toc_depth: 2
 * Short term storage costs [ANT-1854] (#2302)
 * Add ts-generation for links [ANT-1084] (#1986)
 * Make it possible to specify the final hydro reservoir level [ANT-1084] (#1521)
+* Add support for more QP solvers [ANT-2546] (#2574)
 
 #### Removed features
 * Remove hydro hotstart (#2131)
@@ -69,7 +70,7 @@ toc_depth: 2
 #### Build
 * vcpkg (linux, sirius) (#2078) (#2090) (#2145)
 * Remove src/antares-deps (#2182)
-* Use OR-Tools v9.11-rte1.1 (#2437)
+* Use OR-Tools v9.11-rte1.2 (#2574)
 * Fix or-tools integration (#2402)
 * Better dependencies with cmake, antares matrix (#2369)
 

docs/user-guide/solver/02-command-line.md

@@ -17,7 +17,8 @@ hide:
 | --adequacy             | Force the simulation in [adequacy](static-modeler/04-parameters.md#mode) mode                                                      |
 | --parallel             | Enable [parallel](optional-features/multi-threading.md) computation of MC years                                                   |
 | --force-parallel=VALUE | Override the max number of years computed [simultaneously](optional-features/multi-threading.md)                                  |
-| --solver=VALUE | The optimization solver to use. Possible values are: `sirius` (default), `coin`, `xpress`, `scip` |
+| --linear-solver=VALUE | The optimization solver to use for linear problems. Possible values are: `sirius` (default), `coin`, `xpress`, `scip` |
+| --quadratic-solver=VALUE | The optimization solver to use for quadratic problems. Possible values are: `sirius` (default), `pdlp` |
 
 ## Parameters
 
@@ -43,7 +44,8 @@ hide:
 | -m, --mps-export         | Export anonymous MPS, weekly or daily optimal UC+dispatch linear (MPS will be named if the problem is infeasible)                                                                                                                                      |
 | -s, --named-mps-problems | Export named MPS, weekly or daily optimal UC+dispatch linear                                                                                                                                                                                           |
 | --solver-logs            | Print solver logs                                                                                                                                                                                                                                      |
-| --solver-parameters      | Set solver-specific parameters, for instance `--solver-parameters="THREADS 1 PRESOLVE 1"` for XPRESS or `--solver-parameters="parallel/maxnthreads 1, lp/presolving TRUE"` for SCIP. Syntax is solver-dependent, and only supported for SCIP & XPRESS. |
+| --linear-solver-parameters      | Set solver-specific parameters for linear problems, for instance `--solver-parameters="THREADS 1 PRESOLVE 1"` for XPRESS or `--solver-parameters="parallel/maxnthreads 1, lp/presolving TRUE"` for SCIP. Syntax is solver-dependent, and only supported for SCIP & XPRESS. |
+| --quadratic-solver-parameters      | Set solver-specific parameters for quadratic problems. |
 
 ## Misc.
 

docs/user-guide/solver/static-modeler/04-parameters.md

@@ -483,14 +483,20 @@ _**This section is under construction**_
 > _**Note:**_ You can find more information on this parameter [here](../03-appendix.md#details-on-the-include-unfeasible-problem-behavior-parameter).
 
 ---
-#### solver-parameters
-[//]: # (TODO: document this parameter)
-_**This section is under construction**_  
+#### linear-solver-parameters
+- **Expected value:** a string
+- **Required:** **no**
+- **Default value:** empty
+- **Usage:** Set solver-specific parameters for linear problems, for instance `--solver-parameters="THREADS 1 PRESOLVE 1"` 
+  for XPRESS or `--solver-parameters="parallel/maxnthreads 1, lp/presolving TRUE"` for SCIP. Syntax is solver-dependent, and only supported for SCIP & XPRESS.
 
-- **Expected value:**
-- **Required:** **yes**
-- **Default value:**
-- **Usage:**
+---
+#### quadratic-solver-parameters
+- **Expected value:** a string
+- **Required:** **no**
+- **Default value:** empty
+- **Usage:** Set solver-specific parameters for quadratic problems, for instance `--solver-parameters="THREADS 1 PRESOLVE 1"` 
+  for XPRESS or `--solver-parameters="parallel/maxnthreads 1, lp/presolving TRUE"` for SCIP. Syntax is solver-dependent, and only supported for SCIP & XPRESS.
 
 ---
 ## Adequacy-patch parameters

ortools_tag

@@ -1 +1 @@
-v9.11-rte1.1
+v9.11-rte1.2

src/libs/antares/InfoCollection/StudyInfoCollector.cpp

@@ -145,8 +145,11 @@ void StudyInfoCollector::solverVersionToFileContent(FileContent& file_content)
 
 void StudyInfoCollector::ORToolsSolver(FileContent& file_content)
 {
-    std::string solverName = study_.parameters.optOptions.ortoolsSolver;
-    file_content.addItemToSection("study", "ortools solver", solverName);
+    std::string linearSolverName = study_.parameters.optOptions.linearSolver;
+    file_content.addItemToSection("study", "linear solver", linearSolverName);
+
+    std::string quadraticSolverName = study_.parameters.optOptions.linearSolver;
+    file_content.addItemToSection("study", "quadratic solver", quadraticSolverName);
 }
 
 // Collecting data optimization problem

src/libs/antares/optimization-options/include/antares/optimization-options/options.h

@@ -28,8 +28,10 @@ namespace Antares::Solver::Optimization
 struct OptimizationOptions
 {
     //! The solver name, sirius is the default
-    std::string ortoolsSolver = "sirius";
+    std::string linearSolver = "sirius";
+    std::string quadraticSolver = "sirius";
+    std::string linearSolverParameters;
+    std::string quadraticSolverParameters;
     bool solverLogs = false;
-    std::string solverParameters;
 };
 } // namespace Antares::Solver::Optimization

src/libs/antares/study/include/antares/study/load-options.h

@@ -81,7 +81,7 @@ class StudyLoadOptions
     //! A non-zero value if the data will be used for a simulation
     bool usedByTheSolver;
 
-    //! All options related to optimization
+    //! All options related to linear & quadratic optimization
     Antares::Solver::Optimization::OptimizationOptions optOptions;
 
     //! Temporary string for passing log message

src/libs/antares/study/include/antares/study/parameters.h

@@ -503,7 +503,7 @@ class Parameters final
     // Naming constraints and variables in problems
     bool namedProblems;
 
-    // All options related to optimization
+    // All options related to linear & quadratic optimization
     Antares::Solver::Optimization::OptimizationOptions optOptions;
 
 private:

src/libs/antares/study/parameters.cpp

@@ -1283,8 +1283,10 @@ bool Parameters::loadFromINI(const IniFile& ini, const StudyVersion& version)
 void Parameters::handleOptimizationOptions(const StudyLoadOptions& options)
 {
     // Options only set from the command-line
-    optOptions.ortoolsSolver = options.optOptions.ortoolsSolver;
-    optOptions.solverParameters = options.optOptions.solverParameters;
+    optOptions.linearSolver = options.optOptions.linearSolver;
+    optOptions.linearSolverParameters = options.optOptions.linearSolverParameters;
+    optOptions.quadraticSolver = options.optOptions.quadraticSolver;
+    optOptions.quadraticSolverParameters = options.optOptions.quadraticSolverParameters;
 
     // Options that can be set both in command-line and file
     optOptions.solverLogs = options.optOptions.solverLogs || optOptions.solverLogs;
@@ -1780,8 +1782,11 @@ void Parameters::prepareForSimulation(const StudyLoadOptions& options)
         logs.info() << "  :: ignoring solution export";
     }
 
-    logs.info() << "  :: solver " << options.optOptions.ortoolsSolver
-                << " is used for problem resolution";
+    logs.info() << "  :: solver " << options.optOptions.linearSolver
+                << " is used for linear problem resolution";
+
+    logs.info() << "  :: solver " << options.optOptions.quadraticSolver
+                << " is used for quadratic problem resolution";
 
     // indicated that Problems will be named
     if (namedProblems)

src/solver/application/application.cpp

@@ -48,7 +48,10 @@ namespace
 {
 void printSolvers()
 {
-    std::cout << "Available solvers: " << availableOrToolsSolversString() << std::endl;
+    std::cout << "Available linear solvers: "                                        // NOSONAR
+              << availableOrToolsSolversString(SolverClass::LINEAR) << std::endl;    // NOSONAR
+    std::cout << "Available quadratic solvers: "                                     // NOSONAR
+              << availableOrToolsSolversString(SolverClass::QUADRATIC) << std::endl; // NOSONAR
 }
 } // namespace
 
@@ -275,7 +278,7 @@ void Application::postParametersChecks() const
 { // Some more checks require the existence of pParameters, hence of a study.
     // Their execution is delayed up to this point.
     checkSolverMILPincompatibility(pParameters->unitCommitment.ucMode,
-                                   pParameters->optOptions.ortoolsSolver);
+                                   pParameters->optOptions.linearSolver);
 
     checkSimplexRangeHydroPricing(pParameters->simplexOptimizationRange,
                                   pParameters->hydroPricing.hpMode);

src/solver/misc/include/antares/solver/misc/options.h

@@ -75,5 +75,5 @@ std::unique_ptr<Yuni::GetOpt::Parser> CreateParser(Settings& settings,
 
 void checkAndCorrectSettingsAndOptions(Settings& settings, Data::StudyLoadOptions& options);
 
-void checkOrtoolsSolver(const Antares::Solver::Optimization::OptimizationOptions& optOptions);
+void checkSolvers(Data::StudyLoadOptions& options);
 #endif /* __SOLVER_MISC_GETOPT_H__ */

src/solver/misc/options.cpp

@@ -27,6 +27,8 @@
 #include <limits>
 #include <string.h>
 
+#include <boost/algorithm/string/join.hpp>
+
 #include <yuni/yuni.h>
 
 #include <antares/antares/constants.h>
@@ -75,22 +77,53 @@ std::unique_ptr<Yuni::GetOpt::Parser> CreateParser(Settings& settings, StudyLoad
                 "force-parallel",
                 "Override the max number of years computed simultaneously");
 
+    //--linear-solver
+    parser->add(options.optOptions.linearSolver,
+                ' ',
+                "linear-solver",
+                "Solver used for linear optimizations during simulation\nAvailable solver list : "
+                  + availableOrToolsSolversString(SolverClass::LINEAR));
+
     //--solver
-    parser->add(options.optOptions.ortoolsSolver,
+    parser->add(options.optOptions.linearSolver,
                 ' ',
                 "solver",
-                "Solver used for simulation\nAvailable solver list : "
-                  + availableOrToolsSolversString());
+                "Deprecated, use linear-solver instead.");
 
-    //--solver-parameters
+    //--linear-solver-parameters
     parser->add(
-      options.optOptions.solverParameters,
+      options.optOptions.linearSolverParameters,
       ' ',
-      "solver-parameters",
-      "Set solver-specific parameters, for instance --solver-parameters=\"THREADS 1 PRESOLVE 1\""
+      "linear-solver-parameters",
+      "Set linear solver-specific parameters, for instance --linear-solver-parameters=\"THREADS 1 "
+      "PRESOLVE 1\""
       "for XPRESS or --solver-parameters=\"parallel/maxnthreads 1, lp/presolving TRUE\" for SCIP."
       "Syntax is solver-dependent, and only supported for SCIP & XPRESS.");
 
+    //--solver-parameters
+    parser->add(options.optOptions.linearSolverParameters,
+                ' ',
+                "solver-parameters",
+                "Deprecated, use linear-solver-parameters instead.");
+
+    //--quadratic-solver
+    parser->add(
+      options.optOptions.quadraticSolver,
+      ' ',
+      "quadratic-solver",
+      "Solver used for quadratic optimizations during simulation\nAvailable solver list : "
+        + availableOrToolsSolversString(SolverClass::QUADRATIC));
+
+    //--quadratic-solver-parameters
+    parser->add(
+      options.optOptions.quadraticSolverParameters,
+      ' ',
+      "quadratic-solver-parameters",
+      "Set quadratic solver-specific parameters, for instance "
+      "--quadratic-solver-parameters=\"THREADS 1 PRESOLVE 1\""
+      "for XPRESS or --solver-parameters=\"parallel/maxnthreads 1, lp/presolving TRUE\" for SCIP."
+      "Syntax is solver-dependent.");
+
     parser->addParagraph("\nParameters");
     // --name
     parser->add(settings.simulationName,
@@ -246,7 +279,7 @@ void checkAndCorrectSettingsAndOptions(Settings& settings, Data::StudyLoadOption
     }
 
     options.checkForceSimulationMode();
-    checkOrtoolsSolver(options.optOptions);
+    checkSolvers(options);
 
     // no-output and force-zip-output
     if (settings.noOutput && settings.forceZipOutput)
@@ -255,19 +288,24 @@ void checkAndCorrectSettingsAndOptions(Settings& settings, Data::StudyLoadOption
     }
 }
 
-void checkOrtoolsSolver(const Antares::Solver::Optimization::OptimizationOptions& optOptions)
+void checkSolverExists(std::string solverName, const std::list<std::string> availableSolversList)
 {
-    const std::string& solverName = optOptions.ortoolsSolver;
-    const std::list<std::string> availableSolverList = getAvailableOrtoolsSolverName();
-
     // Check if solver is available
-    bool found = (std::ranges::find(availableSolverList, solverName) != availableSolverList.end());
+    bool found = std::ranges::find(availableSolversList, solverName) != availableSolversList.end();
     if (!found)
     {
-        throw Error::InvalidSolver(optOptions.ortoolsSolver, availableOrToolsSolversString());
+        throw Error::InvalidSolver(solverName, boost::algorithm::join(availableSolversList, ","));
     }
 }
 
+void checkSolvers(StudyLoadOptions& options)
+{
+    checkSolverExists(options.optOptions.linearSolver,
+                      getAvailableSolverNames(SolverClass::LINEAR));
+    checkSolverExists(options.optOptions.quadraticSolver,
+                      getAvailableSolverNames(SolverClass::QUADRATIC));
+}
+
 void Settings::checkAndSetStudyFolder(const std::string& folder)
 {
     // The study folder

src/solver/optimisation/adequacy_patch_csr/adq_patch_curtailment_sharing.cpp

@@ -198,18 +198,18 @@ void HourlyCSRProblem::setProblemCost()
     }
 }
 
-void HourlyCSRProblem::solveProblem(uint week, int year)
+void HourlyCSRProblem::solveProblem(uint week, int year, const OptimizationOptions& options)
 {
-    ADQ_PATCH_CSR(problemeAResoudre_, *this, adqPatchParams_, week, year);
+    ADQ_PATCH_CSR(options, problemeAResoudre_, *this, adqPatchParams_, week, year);
 }
 
-void HourlyCSRProblem::run(uint week, uint year)
+void HourlyCSRProblem::run(uint week, uint year, const OptimizationOptions& options)
 {
     calculateCsrParameters();
     buildProblemVariables();
     buildProblemConstraintsLHS();
     setVariableBounds();
     buildProblemConstraintsRHS();
     setProblemCost();
-    solveProblem(week, year);
+    solveProblem(week, year, options);
 }