Modeler 6.5: valid location [ANT-4045]

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

@@ -20,6 +20,7 @@
  */
 
 #include <ExprVisitor.h>
+#include <any>
 
 #include <antares/expressions/nodes/ExpressionsNodes.h>
 #include <antares/io/inputs/model-converter/convertorVisitor.h>
@@ -422,7 +423,7 @@
         return node;
     }
 
-    throw NoConstraintWithThisName(model_.id, constraint_id);
+    throw DualNoConstraintWithThisName(model_.id, constraint_id);
 }
 
 std::any ConvertorVisitor::handleReducedCost(ExprParser::ArgListContext* context)
@@ -444,18 +445,18 @@
                                     + params);
     }
 
-    std::vector<Node*> nodes;
-    try
-    {
-        nodes = std::any_cast<std::vector<Node*>>(context->accept(this));
-    }
-    catch (const NoParameterOrVariableWithThisName&) // to print accurate message
+    unsigned index = 0;
+    for (const auto& var: model_.variables)
     {
-        throw NoVariableWithThisName(model_.id, context->expr(0)->getText());
+        if (var.id == variableId.at(0)->getText())
+        {
+            auto varNode = registry_.create<VariableNode>(var.id, index);
+            return static_cast<Node*>(
+              registry_.create<FunctionNode>(FunctionNodeType::reduced_cost, varNode));
+        }
+        ++index;
     }
-
-    return static_cast<Node*>(
-      registry_.create<FunctionNode>(FunctionNodeType::reduced_cost, nodes.at(0)));
+    throw ReducedCostNoVariableWithThisName(model_.id, variableId.at(0)->getText());
 }
 
 template<class T>

src/io/inputs/model-converter/include/antares/io/inputs/model-converter/convertorVisitor.h

@@ -43,21 +43,22 @@ class NoParameterOrVariableWithThisName final: public std::runtime_error
     }
 };
 
-class NoVariableWithThisName final: public std::runtime_error
+class ReducedCostNoVariableWithThisName final: public std::runtime_error
 {
 public:
-    explicit NoVariableWithThisName(const std::string& modelName, const std::string& varName):
+    explicit ReducedCostNoVariableWithThisName(const std::string& modelName,
+                                               const std::string& varName):
         runtime_error("reduced_cost called with unknown variable '" + varName + "' in model '"
                       + modelName + "'")
     {
     }
 };
 
-class NoConstraintWithThisName final: public std::runtime_error
+class DualNoConstraintWithThisName final: public std::runtime_error
 {
 public:
-    explicit NoConstraintWithThisName(const std::string& modelName,
-                                      const std::string& constraintName):
+    explicit DualNoConstraintWithThisName(const std::string& modelName,
+                                          const std::string& constraintName):
         runtime_error("dual called with unknown constraint '" + constraintName + "' in model '"
                       + modelName + "'")
     {

src/modeler/loadFiles/CMakeLists.txt

@@ -10,6 +10,7 @@ set(SOURCES
         readScenarioGroup.cpp
         readSystem.cpp
         readOptimConfig.cpp
+        checkLocation.cpp
 
         include/antares/solver/modeler/loadFiles/loadFiles.h
         include/antares/solver/modeler/loadFiles/Fileloader.h

src/modeler/loadFiles/checkLocation.cpp

@@ -0,0 +1,143 @@
+/*
+ * Copyright 2007-2025, RTE (https://www.rte-france.com)
+ * See AUTHORS.txt
+ * SPDX-License-Identifier: MPL-2.0
+ * This file is part of Antares-Simulator,
+ * Adequacy and Performance assessment for interconnected energy networks.
+ *
+ * Antares_Simulator is free software: you can redistribute it and/or modify
+ * it under the terms of the Mozilla Public Licence 2.0 as published by
+ * the Mozilla Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Antares_Simulator is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * Mozilla Public Licence 2.0 for more details.
+ *
+ * You should have received a copy of the Mozilla Public Licence 2.0
+ * along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
+ */
+
+#include <antares/expressions/iterators/pre-order.h>
+#include <antares/expressions/nodes/ExpressionsNodes.h>
+#include <antares/solver/modeler/data.h>
+#include <antares/solver/modeler/loadFiles/loadFiles.h>
+
+using namespace Antares::Expressions::Nodes;
+using namespace Antares::ModelerStudy::SystemModel;
+using namespace Antares::Modeler::Config;
+
+namespace Antares::Solver::LoadFiles
+{
+
+void checkFunctionNode(Node& node, Model& model)
+{
+    // dual and reduced_cost can only be used in subproblems
+    if (auto* functionNode = dynamic_cast<FunctionNode*>(&node); functionNode)
+    {
+        if (functionNode->type() == FunctionNodeType::reduced_cost)
+        {
+            const auto* varNode = dynamic_cast<VariableNode*>(functionNode->getOperands().at(0));
+            for (const auto& variable: model.Variables())
+            {
+                if (variable.Id() == varNode->value()
+                    && variable.location() != Location::SUBPROBLEMS)
+                {
+                    throw std::runtime_error("Reduced costs can only be used in subproblems");
+                }
+            }
+        }
+
+        if (functionNode->type() == FunctionNodeType::dual)
+        {
+            // This node contains the constraint name
+            const auto* n = dynamic_cast<LiteralNode*>(functionNode->getOperands().at(0));
+            for (const auto& constraint: model.Constraints())
+            {
+                if (constraint.Id() == n->name())
+                {
+                    if (constraint.location() != Location::SUBPROBLEMS)
+                    {
+                        throw std::runtime_error("Duals can only be used in subproblems");
+                    }
+                }
+            }
+        }
+    }
+}
+
+void checkExpression(Node* expression, const Location& location, Model& model)
+{
+    for (auto& node: AST(expression))
+    {
+        // base variable
+        if (const auto* varNode = dynamic_cast<VariableNode*>(&node); varNode)
+        {
+            for (const auto& variable: model.Variables())
+            {
+                if (variable.Id() == varNode->value()
+                    && !AreLocationsCompatible(variable.location(), location))
+                {
+                    throw std::runtime_error("Variable mismatch locations"); // TODO Better ex
+                }
+            }
+            continue;
+        }
+
+        // Portfields can contains variables, we recursively check their expressions
+        if (const auto* n = dynamic_cast<PortFieldNode*>(&node); n)
+        {
+            PortFieldKey key(n->getPortName(), n->getFieldName());
+            checkExpression(model.PortFieldDefinitions().at(key).Definition().RootNode(),
+                            location,
+                            model);
+            continue;
+        }
+
+        if (const auto* portFieldSumNode = dynamic_cast<PortFieldSumNode*>(&node); portFieldSumNode)
+        {
+            for (const auto& connection: model.ComponentConnections())
+            {
+                auto* n = connection.component()->nodeAtPortField(portFieldSumNode->getPortName(),
+                                                                  portFieldSumNode->getFieldName());
+                checkExpression(n, location, *connection.component()->getModel());
+            }
+            continue;
+        }
+
+        checkFunctionNode(node, model);
+    }
+}
+
+void checkModel(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(), Location::SUBPROBLEMS, model);
+    }
+}
+
+void checkLocations(Modeler::Data& data)
+{
+    for (auto& lib: data.libraries)
+    {
+        for (auto& [modelName, model]: lib.Models())
+        {
+            checkModel(model);
+        }
+    }
+}
+
+} // namespace Antares::Solver::LoadFiles

src/modeler/loadFiles/include/antares/solver/modeler/loadFiles/loadFiles.h

@@ -56,6 +56,8 @@ void loadOptimConfig(const std::filesystem::path& studyPath,
 
 void handleYamlError(const YAML::Exception& e, const std::string& filename);
 
+void checkLocations(Antares::Modeler::Data& data);
+
 /// Generic error class for all loading errors to catch in the main
 class ErrorLoadingYaml final: public std::runtime_error
 {

src/modeler/modeler/Modeler.cpp

@@ -1,4 +1,3 @@
-
 /*
  * Copyright 2007-2025, RTE (https://www.rte-france.com)
  * See AUTHORS.txt
@@ -22,7 +21,6 @@
 
 #include "antares/solver/modeler/Modeler.h"
 
-#include <chrono>
 #include <fstream>
 
 #include <antares/logs/logs.h>
@@ -36,11 +34,12 @@
 #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;
 using namespace Antares::Optimisation;
-using namespace Antares::Solver;
 using namespace Antares::Optimisation::LinearProblemApi;
 
 namespace Antares::Solver
@@ -113,6 +112,7 @@ void Modeler::run() const
         parameters = loader_.loadParameters();
         logs.info() << "Parameters loaded";
         data = loader_.loadAll();
+        LoadFiles::checkLocations(data);
     }
     catch (const LoadFiles::ErrorLoadingYaml&)
     {

src/study/system-model/component.cpp

@@ -64,6 +64,7 @@ Component::Component(const ComponentData& component_data)
 
 void Component::addComponentConnection(const std::string localPortId, ConnectionEnd&& connexionEnd)
 {
+    getModel()->addComponentConnection(connexionEnd); // used to check location later
     componentConnectionEnds_[localPortId].push_back(std::move(connexionEnd));
 }
 
@@ -76,7 +77,7 @@ std::vector<ConnectionEnd> Component::componentConnectionsViaPort(const std::str
     return {};
 }
 
-const Node* Component::nodeAtPortField(const std::string& portId, const std::string& fieldId) const
+Node* Component::nodeAtPortField(const std::string& portId, const std::string& fieldId) const
 {
     try
     {

src/study/system-model/include/antares/study/system-model/component.h

@@ -109,8 +109,8 @@ class Component final
     void addComponentConnection(const std::string localPortId, ConnectionEnd&& connection);
     std::vector<ConnectionEnd> componentConnectionsViaPort(const std::string& portId) const;
 
-    const Expressions::Nodes::Node* nodeAtPortField(const std::string& portId,
-                                                    const std::string& fieldId) const;
+    Expressions::Nodes::Node* nodeAtPortField(const std::string& portId,
+                                              const std::string& fieldId) const;
 
     void addAreaConnection(const std::string& localPortId, const std::string& areaId);
 

src/study/system-model/include/antares/study/system-model/model.h

@@ -26,6 +26,7 @@
 
 #include <antares/expressions/expression.h>
 
+#include "connection.h"
 #include "constraint.h"
 #include "extraOutput.h"
 #include "objective.h"
@@ -107,6 +108,16 @@ class Model final
         return extraOutputs_;
     }
 
+    void addComponentConnection(ConnectionEnd connection)
+    {
+        componentsConnections_.push_back(connection);
+    }
+
+    const std::vector<ConnectionEnd>& ComponentConnections() const
+    {
+        return componentsConnections_;
+    }
+
 private:
     friend class ModelBuilder;
     std::string id_;
@@ -119,6 +130,7 @@ class Model final
     std::vector<Objective> objectives_;
 
     PortFieldMap portFieldDefinitions_;
+    std::vector<ConnectionEnd> componentsConnections_; // used to check location for portFieldSum
 };
 
 // List of IDs used internally to check for uniqueness of IDs at component level