adding get_attribute with tools for finding missing attributes

components/multimesh/src/wmtk/components/multimesh/utils/AttributeDescription.cpp

@@ -1,10 +1,11 @@
 #include "AttributeDescription.hpp"
 #include <nlohmann/json.hpp>
 
+#include <wmtk/components/utils/json_serialize_enum.hpp>
 namespace wmtk::attribute {
 // TODO: this definitely will cause a conflict someday if someone else wants to serialize
 // attributetype
-NLOHMANN_JSON_SERIALIZE_ENUM(
+WMTK_NLOHMANN_JSON_SERIALIZE_ENUM(
     AttributeType,
     {
         {AttributeType::Char, "char"},
@@ -31,18 +32,39 @@ NLOHMANN_JSON_SERIALIZE_ENUM(
 } // namespace
 WMTK_NLOHMANN_JSON_FRIEND_TO_JSON_PROTOTYPE(AttributeDescription)
 {
-    WMTK_NLOHMANN_ASSIGN_TYPE_TO_JSON(path, dimension, type);
+    WMTK_NLOHMANN_ASSIGN_TYPE_TO_JSON(path);
+    if (nlohmann_json_t.dimension.has_value()) {
+        nlohmann_json_j["dimension"] = nlohmann_json_t.dimension.value();
+    }
+    if (nlohmann_json_t.type.has_value()) {
+        nlohmann_json_j["type"] = nlohmann_json_t.type.value();
+    }
 }
 WMTK_NLOHMANN_JSON_FRIEND_FROM_JSON_PROTOTYPE(AttributeDescription)
 {
-    WMTK_NLOHMANN_ASSIGN_TYPE_FROM_JSON(path, dimension, type);
+    if (nlohmann_json_j.is_string()) {
+        nlohmann_json_t.path = nlohmann_json_j.get<std::string>();
+    } else {
+        nlohmann_json_t.path = nlohmann_json_j["path"];
+    }
+    if (nlohmann_json_j.contains("dimension")) {
+        nlohmann_json_t.dimension = nlohmann_json_j["dimension"];
+    }
+    if (nlohmann_json_j.contains("type")) {
+        nlohmann_json_t.type = nlohmann_json_j["type"];
+    }
 }
 
-PrimitiveType AttributeDescription::primitive_type() const
+std::optional<PrimitiveType> AttributeDescription::primitive_type() const
 {
-    assert(dimension < 4);
+    if (this->dimension.has_value()) {
+        int8_t d = this->dimension.value();
+        assert(d < 4);
 
-    return get_primitive_type_from_id(dimension);
+        return get_primitive_type_from_id(d);
+    } else {
+        return {};
+    }
 }
 
 } // namespace wmtk::components::multimesh::utils

components/multimesh/src/wmtk/components/multimesh/utils/AttributeDescription.hpp

@@ -1,28 +1,33 @@
 #pragma once
 #include <compare>
+#include <optional>
 #include <wmtk/PrimitiveType.hpp>
 #include <wmtk/attribute/AttributeType.hpp>
 #include <wmtk/components/utils/json_macros.hpp>
 
+namespace wmtk::attribute {
+WMTK_NLOHMANN_JSON_DECLARATION(AttributeType)
+}
+
 namespace wmtk::components::multimesh::utils {
 
 
 // the minimal information to uniquely extract an attribute handle
 struct AttributeDescription
 {
     // Avoiding defining any constructors to enable aggregate construction
-    //AttributeDescription() = default;
-    //AttributeDescription(const AttributeDescription&) = default;
-    //AttributeDescription(AttributeDescription&&) = default;
-    //AttributeDescription& operator=(const AttributeDescription&) = default;
-    //AttributeDescription& operator=(AttributeDescription&&) = default;
+    // AttributeDescription() = default;
+    // AttributeDescription(const AttributeDescription&) = default;
+    // AttributeDescription(AttributeDescription&&) = default;
+    // AttributeDescription& operator=(const AttributeDescription&) = default;
+    // AttributeDescription& operator=(AttributeDescription&&) = default;
     //~AttributeDescription() = default;
 
     std::string path;
-    uint8_t dimension; // internally the primitive type
-    attribute::AttributeType type;
+    std::optional<uint8_t> dimension;
+    std::optional<attribute::AttributeType> type;
 
-    PrimitiveType primitive_type() const;
+    std::optional<PrimitiveType> primitive_type() const;
 
     auto operator<=>(const AttributeDescription&) const -> std::strong_ordering;
     auto operator==(const AttributeDescription&) const -> bool;

components/multimesh/src/wmtk/components/multimesh/utils/get_attribute.cpp

@@ -2,13 +2,76 @@
 #include "get_attribute.hpp"
 #include <ranges>
 #include <wmtk/Mesh.hpp>
+#include <wmtk/utils/primitive_range.hpp>
 #include "..//MeshCollection.hpp"
 #include "../NamedMultiMesh.hpp"
 #include "AttributeDescription.hpp"
 #include "get_attribute.hpp"
 #include "wmtk/utils/Logger.hpp"
 
 namespace wmtk::components::multimesh::utils {
+class attribute_missing_error : public std::range_error
+{
+public:
+    static std::string make_message(
+        std::string path,
+        std::optional<uint8_t> dimension,
+        std::optional<attribute::AttributeType> type)
+    {
+        std::string typestr;
+        if (type.has_value()) {
+            nlohmann::json j;
+            j = type.value(); // just using the fact we can generate a strnig for this using json
+                              // to get a printable string
+            typestr = j;
+        }
+        if (type.has_value() && dimension.has_value()) {
+            return fmt::format(
+                "Could not find attribute named {} on {}-simplices of type {}",
+                path,
+                dimension.value(),
+                typestr);
+        } else if (type.has_value()) {
+            return fmt::format(
+                "Could not find attribute named {} on {}-simplices",
+                path,
+                dimension.value());
+        } else if (dimension.has_value()) {
+            return fmt::format("Could not find attribute named {} of type {}", path, typestr);
+        } else {
+            return fmt::format("Could not find attribute named {}", path);
+        }
+    }
+    static std::string make_message(const AttributeDescription& ad)
+    {
+        return make_message(ad.path, ad.dimension, ad.type);
+    }
+
+    attribute_missing_error(const std::string_view& message, const AttributeDescription& ad)
+        : std::range_error(std::string(message))
+        , description(ad)
+    {}
+    attribute_missing_error(const AttributeDescription& ad)
+        : attribute_missing_error(make_message(ad), ad)
+    {}
+    attribute_missing_error(
+        const std::string_view& path,
+        const std::optional<uint8_t>& dimension,
+        const std::optional<attribute::AttributeType>& type)
+        : attribute_missing_error(AttributeDescription(std::string(path), dimension, type))
+    {}
+    attribute_missing_error(
+        const std::string_view& path,
+        const std::optional<PrimitiveType>& pt,
+        const std::optional<attribute::AttributeType>& type)
+        : attribute_missing_error(
+              path,
+              pt.has_value() ? std::optional<uint8_t>{wmtk::get_primitive_type_id(pt.value())}
+                             : std::optional<uint8_t>{},
+              type)
+    {}
+    AttributeDescription description;
+};
 
 
 namespace detail {
@@ -66,7 +129,14 @@ template <typename T>
 wmtk::attribute::MeshAttributeHandle
 get_attribute(const Mesh& mesh, const std::string_view& name, PrimitiveType pt)
 {
-    return mesh.get_attribute_handle<T>(std::string(name), pt);
+    if (mesh.has_attribute<T>(std::string(name), pt)) {
+        return mesh.get_attribute_handle<T>(std::string(name), pt);
+    } else {
+        throw attribute_missing_error(
+            std::string(name),
+            wmtk::get_primitive_type_id(pt),
+            wmtk::attribute ::attribute_type_enum_from_type<T>());
+    }
 }
 
 wmtk::attribute::MeshAttributeHandle get_attribute(
@@ -92,6 +162,50 @@ wmtk::attribute::MeshAttributeHandle get_attribute(
     }
     return {};
 }
+wmtk::attribute::MeshAttributeHandle get_attribute(
+    const Mesh& mesh,
+    const std::string_view& name,
+    std::optional<PrimitiveType> pt,
+    std::optional<attribute::AttributeType> type)
+{
+    using AT = attribute::AttributeType;
+    // This order matches wmtk::components::utils::get_attributes
+    constexpr static std::array<AT, 4> types{{AT::Char, AT::Int64, AT::Double, AT::Rational}};
+    // constexpr static std::array<AT, 4> types{{AT::Int64, AT::Double, AT::Char, AT::Rational}};
+    if (pt.has_value() && type.has_value()) {
+        return get_attribute(mesh, name, pt.value(), type.value());
+    } else if (pt.has_value()) {
+        for (AT at : types) {
+            try {
+                return get_attribute(mesh, name, pt.value(), at);
+            } catch (const attribute_missing_error& e) {
+                continue;
+            }
+        }
+    } else if (type.has_value()) {
+        for (PrimitiveType p : wmtk::utils::primitive_below(mesh.top_simplex_type())) {
+            try {
+                return get_attribute(mesh, name, p, type.value());
+            } catch (const attribute_missing_error& e) {
+                continue;
+            }
+        }
+    } else {
+        for (AT at : types) {
+            for (PrimitiveType p : wmtk::utils::primitive_below(mesh.top_simplex_type())) {
+                try {
+                    return get_attribute(mesh, name, p, at);
+                } catch (const attribute_missing_error& e) {
+                    continue;
+                }
+            }
+        }
+    }
+
+
+    throw attribute_missing_error(name, pt, type);
+    return {};
+}
 } // namespace detail
 
 wmtk::attribute::MeshAttributeHandle get_attribute(

components/multimesh/src/wmtk/components/multimesh/utils/get_attribute.hpp

@@ -7,7 +7,7 @@ class Mesh;
 namespace components::multimesh {
 class NamedMultiMesh;
 class MeshCollection;
-}
+} // namespace components::multimesh
 } // namespace wmtk
 
 namespace wmtk::components::multimesh {
@@ -21,6 +21,9 @@ struct AttributeDescription;
 // * simplex (int, dimension attribute belongs to
 // if type and simplex are missing code will search in lexicographical of (primitive_type, type)
 //    where double < int < char < rational for type
+//
+// this is somewhat redundant to wmtk::components::utils::get_attributes, but is designed around
+// supporting multimesh paths.
 
 wmtk::attribute::MeshAttributeHandle get_attribute(
     const NamedMultiMesh& mesh,
@@ -32,5 +35,5 @@ wmtk::attribute::MeshAttributeHandle get_attribute(
     const Mesh& mesh,
     const AttributeDescription& description);
 
-}
-} // namespace wmtk::components::multimesh::utils
+} // namespace utils
+} // namespace wmtk::components::multimesh

components/multimesh/tests/CMakeLists.txt

@@ -1,4 +1,9 @@
 
-add_component_test(wmtk::${COMPONENT_NAME} named_multimesh.cpp)
+add_component_test(wmtk::${COMPONENT_NAME} 
+    named_multimesh.cpp 
+    get_attributes.cpp
+    utils.hpp
+    utils.cpp
+)
 
 target_link_libraries(${WMTK_COMPONENT_TEST_TARGET} PRIVATE wmtk::input)