Modeler 6.5: valid location [ANT-4045]

src/expressions/include/antares/expressions/iterators/pre-order.h

@@ -54,4 +54,51 @@ class AST
     // End iterator (indicating traversal is complete)
     ASTPreOrderIterator end();
 };
+
+// PreOrder Iterator for AST const version
+class ASTPreOrderIteratorConst
+{
+    std::stack<const Node*> nodeStack;
+
+public:
+    // Iterator type aliases
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = Node;
+    using difference_type = std::ptrdiff_t;
+    using pointer = const Node*;
+    using reference = const Node&;
+
+    // Constructor
+    explicit ASTPreOrderIteratorConst(const Node* root = nullptr);
+
+    // Dereference operator
+    reference operator*() const;
+
+    // Pointer access operator
+    pointer operator->() const;
+
+    // Increment operator (pre-order traversal)
+    ASTPreOrderIteratorConst& operator++();
+
+    // Equality comparison
+    bool operator==(const ASTPreOrderIteratorConst& other) const;
+
+    // Inequality comparison
+    bool operator!=(const ASTPreOrderIteratorConst& other) const;
+};
+
+// AST container class to expose begin/end iterators
+class ASTconst
+{
+    const Node* root;
+
+public:
+    explicit ASTconst(const Node* rootNode);
+
+    // Begin iterator
+    ASTPreOrderIteratorConst begin();
+
+    // End iterator (indicating traversal is complete)
+    ASTPreOrderIteratorConst end();
+};
 } // namespace Antares::Expressions::Nodes

src/expressions/include/antares/expressions/nodes/ParentNode.h

@@ -72,6 +72,7 @@ class ParentNode: public Node
      * @return A vector of pointers to the operands of the parent node.
      */
     const std::vector<Node*>& getOperands() const;
+    const std::vector<const Node*> getConstOperands() const;
 
     Node* operator[](std::size_t idx) const;
 

src/expressions/iterators/pre-order.cpp

@@ -24,6 +24,24 @@ std::vector<Node*> childrenLeftToRight(Node* node)
     }
     return {};
 }
+
+// const version
+std::vector<const Node*> childrenLeftToRight(const Node* node)
+{
+    if (auto* bin = dynamic_cast<const BinaryNode*>(node))
+    {
+        return {bin->left(), bin->right()};
+    }
+    else if (auto* unary = dynamic_cast<const UnaryNode*>(node))
+    {
+        return {unary->child()};
+    }
+    else if (auto* sum = dynamic_cast<const SumNode*>(node))
+    {
+        return sum->getConstOperands();
+    }
+    return {};
+}
 } // namespace
 
 // Constructor
@@ -104,4 +122,87 @@ ASTPreOrderIterator AST::end()
 {
     return ASTPreOrderIterator(nullptr);
 }
+
+//
+// CONST VERSION
+//
+
+// Constructor
+ASTPreOrderIteratorConst::ASTPreOrderIteratorConst(const Node* root)
+{
+    if (root)
+    {
+        nodeStack.push(root);
+    }
+}
+
+// Dereference operator
+ASTPreOrderIteratorConst::reference ASTPreOrderIteratorConst::operator*() const
+{
+    return *nodeStack.top();
+}
+
+// Pointer access operator
+ASTPreOrderIteratorConst::pointer ASTPreOrderIteratorConst::operator->() const
+{
+    return nodeStack.top();
+}
+
+// Increment operator (pre-order traversal)
+ASTPreOrderIteratorConst& ASTPreOrderIteratorConst::operator++()
+{
+    if (nodeStack.empty())
+    {
+        return *this;
+    }
+
+    const Node* current = nodeStack.top();
+    nodeStack.pop();
+
+    const auto children = childrenLeftToRight(current);
+    // Push children in reverse order to process them in left-to-right order
+    for (auto* it: children | std::views::reverse)
+    {
+        nodeStack.push(it);
+    }
+
+    return *this;
+}
+
+// Equality comparison
+bool ASTPreOrderIteratorConst::operator==(const ASTPreOrderIteratorConst& other) const
+{
+    if (nodeStack.empty() && other.nodeStack.empty())
+    {
+        return true;
+    }
+    if (nodeStack.empty() || other.nodeStack.empty())
+    {
+        return false;
+    }
+    return nodeStack.top() == other.nodeStack.top();
+}
+
+// Inequality comparison
+bool ASTPreOrderIteratorConst::operator!=(const ASTPreOrderIteratorConst& other) const
+{
+    return !(*this == other);
+}
+
+ASTconst::ASTconst(const Node* rootNode):
+    root(rootNode)
+{
+}
+
+// Begin iterator
+ASTPreOrderIteratorConst ASTconst::begin()
+{
+    return ASTPreOrderIteratorConst(root);
+}
+
+// End iterator (indicating traversal is complete)
+ASTPreOrderIteratorConst ASTconst::end()
+{
+    return ASTPreOrderIteratorConst(nullptr);
+}
 } // namespace Antares::Expressions::Nodes

src/expressions/nodes/ParentNode.cpp

@@ -33,6 +33,12 @@ const std::vector<Node*>& ParentNode::getOperands() const
     return operands_;
 }
 
+const std::vector<const Node*> ParentNode::getConstOperands() const
+{
+    std::vector<const Node*> constOperands(operands_.begin(), operands_.end());
+    return constOperands;
+}
+
 size_t ParentNode::size() const
 {
     return operands_.size();

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

@@ -424,7 +424,7 @@ std::any ConvertorVisitor::handleDual(ExprParser::ArgListContext* context)
         return node;
     }
 
-    throw NoConstraintWithThisName(model_.id, constraint_id);
+    throw DualNoConstraintWithThisName(model_.id, constraint_id);
 }
 
 std::any ConvertorVisitor::handleReducedCost(ExprParser::ArgListContext* context)
@@ -446,18 +446,18 @@ std::any ConvertorVisitor::handleReducedCost(ExprParser::ArgListContext* context
                                     + 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-optimisation-container/OptimEntityContainer.cpp

@@ -52,7 +52,7 @@ void OptimEntityContainer::addFromSystemComponents(const std::vector<Component>&
         modelVariableGlobalIndices.reserve(variables.size());
         for (const auto& variable: variables)
         {
-            if (AreLocationsCompatible(variable.location(), targetLocation))
+            if (AreLocationsCompatibleForFillers(variable.location(), targetLocation))
             {
                 modelVariableGlobalIndices.push_back(variableGlobalIndex);
                 ++variableGlobalIndex;

src/modeler/CMakeLists.txt

@@ -1,6 +1,7 @@
 add_subdirectory(loadFiles)
 add_subdirectory(modeler)
 add_subdirectory(parameters)
+add_subdirectory(checks)
 
 OMESSAGE("  :: modeler")
 

src/modeler/checks/CMakeLists.txt

@@ -0,0 +1,29 @@
+set(SOURCES
+        checkLocation.cpp
+
+        include/antares/solver/modeler/checks/checkLocation.h
+)
+
+# Create the library
+add_library(modeler-checks ${SOURCES})
+add_library(Antares::modeler-checks ALIAS modeler-checks)
+
+# Specify include directories
+target_include_directories(modeler-checks
+        PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+)
+
+find_package(fmt REQUIRED)
+# Link dependencies (if any)
+target_link_libraries(modeler-checks
+        PUBLIC
+        Antares::antares-study-system-model
+        PRIVATE
+        modeler-lib
+        fmt::fmt
+)
+
+install(DIRECTORY include/antares
+        DESTINATION "include"
+)