Infeasibility more cleaning

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

@@ -25,40 +25,26 @@
 #include <iomanip>
 #include <sstream>
 
+#include <boost/algorithm/string.hpp>
+#include <boost/algorithm/string/regex.hpp>
+#include <boost/regex.hpp>
+
 namespace
 {
 const std::string kUnknown = "<unknown>";
 }
 
 namespace Antares::Optimization
 {
-Constraint::Constraint(const std::string& input, const double slackValue):
-    name_(input),
+Constraint::Constraint(const std::string& name, const double slackValue):
+    name_(name),
     slackValue_(slackValue)
 {
 }
 
-std::size_t Constraint::extractComponentsFromName()
+void Constraint::extractComponentsFromName()
 {
-    const auto beg = name_.begin();
-    const auto end = name_.end();
-    std::size_t newPos = 0;
-    const std::size_t sepSize = 2;
-    const std::size_t inputSize = name_.size();
-    for (std::size_t pos = 0; pos < inputSize; pos = newPos + sepSize)
-    {
-        newPos = name_.find("::", pos);
-        if (newPos == std::string::npos)
-        {
-            nameComponents_.emplace_back(beg + pos, end);
-            break;
-        }
-        if (newPos > pos)
-        {
-            nameComponents_.emplace_back(beg + pos, beg + newPos);
-        }
-    }
-    return nameComponents_.size();
+    boost::algorithm::split_regex(nameComponents_, name_, boost::regex("::"));
 }
 
 double Constraint::getSlackValue() const
@@ -75,67 +61,36 @@ class StringIsNotWellFormated: public std::runtime_error
     }
 };
 
-std::string StringBetweenAngleBrackets(const std::string& str)
+std::string StringBetweenAngleBrackets(const std::string& constraintName)
 {
-    const auto& begin = str.begin();
-    const auto& end = str.end();
+    std::vector<std::string> split_name;
+    boost::split(split_name, constraintName, boost::is_any_of("<>"));
 
-    auto left = std::find(begin, end, '<');
-
-    if (left == end)
+    std::string err_msg = "Error: ";
+    if (split_name.size() < 3)
     {
-        std::ostringstream stream;
-        stream << std::string("Error the string: ") << std::quoted(str)
-               << " does not contains the left angle bracket " << std::quoted("<");
-        throw StringIsNotWellFormated(stream.str());
+        err_msg += "constraint name '" + constraintName + "' misses '<' and/or '>' bracket";
+        throw StringIsNotWellFormated(err_msg);
     }
-
-    auto right = std::find(begin, end, '>');
-    if (right == end)
+    if (split_name[1].empty())
     {
-        std::ostringstream stream;
-        stream << std::string("Error the string: ") << std::quoted(str)
-               << " does not contains the right angle bracket " << std::quoted(">");
-        throw StringIsNotWellFormated(stream.str());
+        err_msg += "constraint name '" + constraintName + "' must be of format '*<str>*'";
+        throw StringIsNotWellFormated(err_msg);
     }
-
-    if (std::distance(left, right) <= 1)
-    {
-        std::ostringstream stream;
-        stream << std::string("Error the string: ") << std::quoted(str) << " must be of format  "
-               << std::quoted("*<str>*");
-        throw StringIsNotWellFormated(stream.str());
-    }
-    return std::string(left + 1, right);
+    return split_name[1];
 }
 
-std::string Constraint::getAreaName() const
+std::string Constraint::areaName() const
 {
-    if ((getType() == ConstraintType::binding_constraint_hourly)
-        || (getType() == ConstraintType::binding_constraint_daily)
-        || (getType() == ConstraintType::binding_constraint_weekly))
-    {
-        return "<none>";
-    }
     return StringBetweenAngleBrackets(nameComponents_.at(1));
 }
 
-std::string Constraint::getTimeStepInYear() const
+std::string Constraint::timeStep() const
 {
-    switch (getType())
-    {
-    case ConstraintType::binding_constraint_hourly:
-    case ConstraintType::binding_constraint_daily:
-    case ConstraintType::fictitious_load:
-    case ConstraintType::hydro_reservoir_level:
-    case ConstraintType::short_term_storage_level:
-        return StringBetweenAngleBrackets(nameComponents_.at(nameComponents_.size() - 2));
-    default:
-        return kUnknown;
-    }
+    return StringBetweenAngleBrackets(nameComponents_.at(nameComponents_.size() - 2));
 }
 
-ConstraintType Constraint::getType() const
+ConstraintType Constraint::type() const
 {
     assert(nameComponents_.size() > 1);
     if (nameComponents_.at(1) == "hourly")
@@ -158,61 +113,46 @@ ConstraintType Constraint::getType() const
     {
         return ConstraintType::hydro_reservoir_level;
     }
+    if (nameComponents_.at(0) == "HydroPower")
+    {
+        return ConstraintType::hydro_production_weekly;
+    }
     if (nameComponents_.at(0) == "Level")
     {
         return ConstraintType::short_term_storage_level;
     }
     return ConstraintType::none;
 }
 
-std::string Constraint::getBindingConstraintName() const
+std::string Constraint::shortName() const
 {
-    switch (getType())
-    {
-    case ConstraintType::binding_constraint_hourly:
-    case ConstraintType::binding_constraint_daily:
-    case ConstraintType::binding_constraint_weekly:
-        return nameComponents_.at(0);
-    default:
-        return kUnknown;
-    }
+    return nameComponents_.at(0);
 }
 
-std::string Constraint::getSTSName() const
+std::string Constraint::STSname() const
 {
-    if (getType() == ConstraintType::short_term_storage_level)
-    {
-        return StringBetweenAngleBrackets(nameComponents_.at(2));
-    }
-    else
-    {
-        return kUnknown;
-    }
+    return StringBetweenAngleBrackets(nameComponents_.at(2));
 }
 
 std::string Constraint::prettyPrint() const
 {
-    switch (getType())
+    switch (type())
     {
     case ConstraintType::binding_constraint_hourly:
-        return "Hourly binding constraint '" + getBindingConstraintName() + "' at hour "
-               + getTimeStepInYear();
+        return "Hourly binding constraint '" + shortName() + "' at hour " + timeStep();
     case ConstraintType::binding_constraint_daily:
-        return "Daily binding constraint '" + getBindingConstraintName() + "' at day "
-               + getTimeStepInYear();
+        return "Daily binding constraint '" + shortName() + "' at day " + timeStep();
     case ConstraintType::binding_constraint_weekly:
-        return "Weekly binding constraint '" + getBindingConstraintName();
-
+        return "Weekly binding constraint '" + shortName();
     case ConstraintType::fictitious_load:
-        return "Last resort shedding status at area '" + getAreaName() + "' at hour "
-               + getTimeStepInYear();
+        return "Last resort shedding status at area '" + areaName() + "' at hour " + timeStep();
     case ConstraintType::hydro_reservoir_level:
-        return "Hydro reservoir constraint at area '" + getAreaName() + "' at hour "
-               + getTimeStepInYear();
+        return "Hydro reservoir constraint at area '" + areaName() + "' at hour " + timeStep();
+    case ConstraintType::hydro_production_weekly:
+        return "Hydro weekly production at area '" + areaName() + "'";
     case ConstraintType::short_term_storage_level:
-        return "Short-term-storage reservoir constraint at area '" + getAreaName() + "' in STS '"
-               + getSTSName() + "' at hour " + getTimeStepInYear();
-
+        return "Short-term-storage reservoir constraint at area '" + areaName() + "' in STS '"
+               + STSname() + "' at hour " + timeStep();
     default:
         return kUnknown;
     }

src/solver/infeasible-problem-analysis/include/antares/solver/infeasible-problem-analysis/constraint-slack-analysis.h

@@ -57,7 +57,8 @@ class ConstraintSlackAnalysis: public UnfeasibilityAnalysis
 
     std::vector<const operations_research::MPVariable*> slackVariables_;
     const std::string constraint_name_pattern = "^AreaHydroLevel::|::hourly::|::daily::|::weekly::|"
-                                                "^FictiveLoads::|^Level::";
+                                                "^FictiveLoads::|^Level::|"
+                                                "^HydroPower::";
 };
 
 } // namespace Antares::Optimization

src/solver/infeasible-problem-analysis/include/antares/solver/infeasible-problem-analysis/constraint.h

@@ -32,34 +32,31 @@ enum class ConstraintType
     binding_constraint_weekly,
     fictitious_load,
     hydro_reservoir_level,
+    hydro_production_weekly,
     short_term_storage_level,
     none
 };
 
 class Constraint
 {
 public:
-    // Construct object
     Constraint() = default;
-    Constraint(const std::string& input, const double slackValue);
+    Constraint(const std::string& name, const double slackValue);
 
-    // Raw members
     double getSlackValue() const;
 
-    // Extract items, check consistency
-    std::size_t extractComponentsFromName();
+    void extractComponentsFromName();
     std::string prettyPrint() const;
-    ConstraintType getType() const;
+    ConstraintType type() const;
 
 private:
     std::string name_;
     std::vector<std::string> nameComponents_;
     double slackValue_;
 
-    // Get specific items
-    std::string getAreaName() const;
-    std::string getSTSName() const;
-    std::string getTimeStepInYear() const;
-    std::string getBindingConstraintName() const;
+    std::string areaName() const;
+    std::string STSname() const;
+    std::string timeStep() const;
+    std::string shortName() const;
 };
 } // namespace Antares::Optimization

src/solver/infeasible-problem-analysis/include/antares/solver/infeasible-problem-analysis/report.h

@@ -44,10 +44,11 @@ class InfeasibleProblemReport
 private:
     void turnSlackVarsIntoConstraints(
       const std::vector<const operations_research::MPVariable*>& slackVariables);
-    void sortConstraints();
+    void sortConstraintsBySlackValue();
     void trimConstraints();
     void sortConstraintsByType();
     void logSuspiciousConstraints();
+    void logInfeasibilityCauses();
 
     std::vector<Constraint> constraints_;
     std::map<ConstraintType, unsigned int> nbConstraintsByType_;

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

@@ -43,8 +43,9 @@ InfeasibleProblemReport::InfeasibleProblemReport(
   const std::vector<const MPVariable*>& slackVariables)
 {
     turnSlackVarsIntoConstraints(slackVariables);
-    sortConstraints();
+    sortConstraintsBySlackValue();
     trimConstraints();
+    sortConstraintsByType();
 }
 
 void InfeasibleProblemReport::turnSlackVarsIntoConstraints(
@@ -56,28 +57,23 @@ void InfeasibleProblemReport::turnSlackVarsIntoConstraints(
     }
 }
 
-void InfeasibleProblemReport::sortConstraints()
+void InfeasibleProblemReport::sortConstraintsBySlackValue()
 {
     std::sort(std::begin(constraints_), std::end(constraints_), ::compareSlackSolutions);
 }
 
 void InfeasibleProblemReport::trimConstraints()
 {
-    if (nbMaxVariables <= constraints_.size())
-    {
-        constraints_.resize(nbMaxVariables);
-    }
+    unsigned int nbConstraints = constraints_.size();
+    constraints_.resize(std::min(nbMaxVariables, nbConstraints));
 }
 
 void InfeasibleProblemReport::sortConstraintsByType()
 {
     for (auto& c: constraints_)
     {
-        if (c.extractComponentsFromName() == 0)
-        {
-            return;
-        }
-        nbConstraintsByType_[c.getType()]++;
+        c.extractComponentsFromName();
+        nbConstraintsByType_[c.type()]++;
     }
 }
 
@@ -88,12 +84,20 @@ void InfeasibleProblemReport::logSuspiciousConstraints()
     {
         Antares::logs.error() << c.prettyPrint();
     }
+}
+
+void InfeasibleProblemReport::logInfeasibilityCauses()
+{
     Antares::logs.error() << "Possible causes of infeasibility:";
     if (nbConstraintsByType_[ConstraintType::hydro_reservoir_level] > 0)
     {
         Antares::logs.error() << "* Hydro reservoir impossible to manage with cumulative options "
                                  "\"hard bounds without heuristic\"";
     }
+    if (nbConstraintsByType_[ConstraintType::hydro_production_weekly] > 0)
+    {
+        Antares::logs.error() << "* impossible to generate exactly the weekly hydro target";
+    }
     if (nbConstraintsByType_[ConstraintType::fictitious_load] > 0)
     {
         Antares::logs.error() << "* Last resort shedding status,";
@@ -112,14 +116,12 @@ void InfeasibleProblemReport::logSuspiciousConstraints()
     {
         Antares::logs.error() << "* Binding constraints,";
     }
-
-    Antares::logs.error() << "* Negative hurdle costs on lines with infinite capacity (rare).";
 }
 
 void InfeasibleProblemReport::prettyPrint()
 {
-    sortConstraintsByType();
     logSuspiciousConstraints();
+    logInfeasibilityCauses();
 }
 
 } // namespace Antares::Optimization

src/tests/src/solver/infeasible-problem-analysis/test-unfeasible-problem-analyzer.cpp

@@ -171,9 +171,9 @@ std::unique_ptr<MPSolver> createUnfeasibleProblem(const std::string& constraintN
 }
 
 static const std::string validConstraintNames[] = {
-  "BC::hourly::hour<36>",
-  "BC::daily::day<67>",
-  "BC::weekly::week<12>",
+  "BC-name-1::hourly::hour<36>",
+  "BC-name-2::daily::day<67>",
+  "BC-name-3::weekly::week<12>",
   "FictiveLoads::hour<25>",
   "AreaHydroLevel::hour<8>",
 };