Modeler 6.5: valid location [ANT-4045]

src/io/inputs/model-converter/convertorVisitor.cpp

@@ -444,18 +444,16 @@ std::any ConvertorVisitor::handleReducedCost(ExprParser::ArgListContext* context
                                     + params);
     }
 
-    std::vector<Node*> nodes;
-    try
+    for (const auto& var: model_.variables)
     {
-        nodes = std::any_cast<std::vector<Node*>>(context->accept(this));
-    }
-    catch (const NoParameterOrVariableWithThisName&) // to print accurate message
-    {
-        throw NoVariableWithThisName(model_.id, context->expr(0)->getText());
+        if (var.id == variableId.at(0)->getText())
+        {
+            std::vector<Node*> nodes = std::any_cast<std::vector<Node*>>(context->accept(this));
+            return static_cast<Node*>(
+              registry_.create<FunctionNode>(FunctionNodeType::reduced_cost, nodes.at(0)));
+        }
     }
-
-    return static_cast<Node*>(
-      registry_.create<FunctionNode>(FunctionNodeType::reduced_cost, nodes.at(0)));
+    throw NoVariableWithThisName(model_.id, context->expr(0)->getText());
 }
 
 template<class T>

src/modeler/modeler/Modeler.cpp

@@ -24,7 +24,9 @@
 
 #include <chrono>
 #include <fstream>
+#include <stdexcept>
 
+#include <antares/expressions/iterators/pre-order.h>
 #include <antares/logs/logs.h>
 #include <antares/optimisation/linear-problem-api/linearProblem.h>
 #include <antares/optimisation/linear-problem-api/linearProblemBuilder.h>
@@ -36,6 +38,8 @@
 #include "antares/solver/modeler/IWriter.h"
 #include "antares/utils/utils.h"
 
+#include "include/antares/solver/modeler/data.h"
+
 using namespace Antares::Optimisation::LinearProblemMpsolverImpl;
 using namespace Antares;
 using namespace Antares::Optimization;
@@ -103,6 +107,133 @@
     BendersDecomposition* bendersDecomposition_ = nullptr;
 };
 
+void checkFunctionNode(Antares::Expressions::Nodes::Node& node,
+                       Antares::ModelerStudy::SystemModel::Model& model)
+{
+    // dual and reduced_cost can only be used in subproblems
+    if (auto* functionNode = dynamic_cast<Antares::Expressions::Nodes::FunctionNode*>(&node);
+        functionNode)
+    {
+        if (functionNode->type() == Antares::Expressions::Nodes::FunctionNodeType::reduced_cost)
+        {
+            const auto varNode = dynamic_cast<Nodes::VariableNode*>(
+              functionNode->getOperands().at(0));
+            for (const auto& variable: model.Variables())
+            {
+                if (variable.Id() == varNode->value())
+                {
+                    if (variable.location() != Antares::Modeler::Config::Location::SUBPROBLEMS)
+                    {
+                        throw std::runtime_error("Reduced costs can only be used in subproblems");
+                    }
+                }
+            }
+        }
+
+        if (functionNode->type() == Antares::Expressions::Nodes::FunctionNodeType::dual)
+        {
+            // This node contains the constraint name
+            const auto n = dynamic_cast<Nodes::LiteralNode*>(functionNode->getOperands().at(0));
+            for (const auto& constraint: model.Constraints())
+            {
+                if (constraint.Id() == n->name())
+                {
+                    if (constraint.location() != Antares::Modeler::Config::Location::SUBPROBLEMS)
+                    {
+                        throw std::runtime_error("Duals can only be used in subproblems");
+                    }
+                }
+            }
+        }
+    }
+}
+
+void checkExpression(Antares::Expressions::Nodes::Node* expression,
+                     const Antares::Modeler::Config::Location& location,
+                     Antares::ModelerStudy::SystemModel::Model& model)
+{
+    for (auto& node: Antares::Expressions::Nodes::AST(expression))
+    {
+        auto checkVariableLocation =
+          [&model](const std::string& varName, const Antares::Modeler::Config::Location& location)
+        {
+            for (const auto& variable: model.Variables())
+            {
+                if (variable.Id() == varName)
+                {
+                    if (!AreLocationsCompatible(variable.location(), location))
+                    {
+                        throw std::runtime_error("Variable mismatch locations");
+                    }
+                }
+            }
+        };
+
+        // base variable
+        if (auto* varNode = dynamic_cast<Antares::Expressions::Nodes::VariableNode*>(&node);
+            varNode)
+        {
+            checkVariableLocation(varNode->value(), location);
+            continue;
+        }
+
+        // Portfields can contains variables, we recursively check their expressions
+        auto checkPortFieldExpr = [&](auto* n)
+        {
+            ModelerStudy::SystemModel::PortFieldKey key(n->getPortName(), n->getFieldName());
+            checkExpression(model.PortFieldDefinitions().at(key).Definition().RootNode(),
+                            location,
+                            model);
+        };
+
+        if (auto* n = dynamic_cast<Antares::Expressions::Nodes::PortFieldNode*>(&node); n)
+        {
+            checkPortFieldExpr(n);
+            continue;
+        }
+
+        /*if (auto* n = dynamic_cast<Antares::Expressions::Nodes::PortFieldSumNode*>(&node); n)*/
+        /*{*/
+        /*    checkPortFieldExpr(n);*/
+        /*    continue;*/
+        /*}*/
+
+        checkFunctionNode(node, model);
+    }
+}
+
+void checkModel(Antares::ModelerStudy::SystemModel::Model& model)
+{
+    for (const auto& constraint: model.Constraints())
+    {
+        checkExpression(constraint.expression().RootNode(), constraint.location(), model);
+    }
+
+    for (const auto& objective: model.Objectives())
+    {
+        checkExpression(objective.expression().RootNode(), objective.location(), model);
+    }
+
+    // Extra outputs must be evaluated, they need to contain only subproblem objects
+    for (const auto& [_, extraOutput]: model.ExtraOutputs())
+    {
+        checkExpression(extraOutput.expression().RootNode(),
+                        Antares::Modeler::Config::Location::SUBPROBLEMS,
+                        model);
+    }
+}
+
+void checkLocations(Antares::Modeler::Data& data)
+{
+    for (auto& lib: data.libraries)
+    {
+        for (auto& [modelName, model]: lib.Models())
+        {
+            checkModel(model);
+        }
+    }
+}
+
 void Modeler::run() const
 {
     Antares::Solver::ModelerParameters parameters;
@@ -113,6 +244,7 @@
         parameters = loader_.loadParameters();
         logs.info() << "Parameters loaded";
         data = loader_.loadAll();
+        checkLocations(data);
     }
     catch (const LoadFiles::ErrorLoadingYaml&)
     {