[core] allow parsing type=matrix::Identity

Author: MarcelKoch

core/CMakeLists.txt

@@ -48,6 +48,7 @@ target_sources(
         components/range_minimum_query.cpp
         config/config.cpp
         config/config_helper.cpp
+        config/matrix.cpp
         config/property_tree.cpp
         config/stop_config.cpp
         config/type_descriptor.cpp

core/config/config_helper.hpp

@@ -71,7 +71,8 @@ enum class LinOpFactoryType : int {
     Sor,
     Multigrid,
     Pgm,
-    Schwarz
+    Schwarz,
+    Identity
 };
 
 

core/config/matrix.cpp

@@ -0,0 +1,33 @@
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <ginkgo/core/base/exception_helpers.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/config/registry.hpp>
+#include <ginkgo/core/matrix/identity.hpp>
+
+#include "core/config/config_helper.hpp"
+#include "core/config/dispatch.hpp"
+#include "core/config/parse_macro.hpp"
+
+
+namespace gko {
+namespace config {
+
+
+template <typename ValueType>
+struct IdentityParser {
+    static typename matrix::IdentityFactory<ValueType>::parameters_type parse(
+        const pnode& config, const registry& context,
+        const type_descriptor& td_for_child)
+    {
+        return {};
+    }
+};
+
+GKO_PARSE_VALUE_TYPE(Identity, IdentityParser);
+
+
+}  // namespace config
+}  // namespace gko

core/config/registry.cpp

@@ -53,10 +53,9 @@ configuration_map generate_config_map()
             {"solver::Multigrid", parse<LinOpFactoryType::Multigrid>},
             {"multigrid::Pgm", parse<LinOpFactoryType::Pgm>},
 #if GINKGO_BUILD_MPI
-        {
-            "preconditioner::Schwarz", parse<LinOpFactoryType::Schwarz>
-        }
+            {"preconditioner::Schwarz", parse<LinOpFactoryType::Schwarz>},
 #endif
+            {"matrix::Identity", parse<LinOpFactoryType::Identity>},
     };
 }
 

core/test/config/CMakeLists.txt

@@ -1,5 +1,6 @@
 ginkgo_create_test(config)
 ginkgo_create_test(factorization)
+ginkgo_create_test(matrix)
 ginkgo_create_test(multigrid)
 ginkgo_create_test(preconditioner)
 ginkgo_create_test(property_tree)

core/test/config/matrix.cpp

@@ -0,0 +1,48 @@
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
+//
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include <typeinfo>
+
+#include <gtest/gtest.h>
+
+#include <ginkgo/core/base/exception.hpp>
+#include <ginkgo/core/base/executor.hpp>
+#include <ginkgo/core/config/config.hpp>
+#include <ginkgo/core/matrix/identity.hpp>
+
+#include "cmake-build-debug/_deps/googletest-src/googletest/include/gtest/gtest-typed-test.h"
+#include "core/config/config_helper.hpp"
+#include "core/config/registry_accessor.hpp"
+#include "core/test/utils.hpp"
+
+
+using namespace gko::config;
+
+
+template <typename ValueType>
+class Identity : public ::testing::Test {
+protected:
+    using value_type = ValueType;
+
+    std::shared_ptr<const gko::Executor> exec =
+        gko::ReferenceExecutor::create();
+    std::shared_ptr<const gko::matrix::Identity<value_type>> ans =
+        gko::matrix::Identity<value_type>::create(exec, 4u);
+};
+
+TYPED_TEST_SUITE(Identity, gko::test::ValueTypes, TypenameNameGenerator);
+
+
+TYPED_TEST(Identity, CanParse)
+{
+    using value_type = typename TestFixture::value_type;
+    auto config = pnode({{"type", pnode("matrix::Identity")}});
+
+    auto res = parse(config, {}, make_type_descriptor<value_type>())
+                   .on(this->exec)
+                   ->generate(this->ans);
+
+    ASSERT_TRUE(dynamic_cast<gko::matrix::Identity<value_type>*>(res.get()));
+    GKO_ASSERT_EQUAL_DIMENSIONS(res, this->ans);
+}

include/ginkgo/core/matrix/identity.hpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
+// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
 //
 // SPDX-License-Identifier: BSD-3-Clause
 
@@ -88,11 +88,12 @@ class Identity : public EnableLinOp<Identity<ValueType>>, public Transposable {
 template <typename ValueType = default_precision>
 class IdentityFactory
     : public EnablePolymorphicObject<IdentityFactory<ValueType>, LinOpFactory> {
-    friend class EnablePolymorphicObject<IdentityFactory, LinOpFactory>;
-
 public:
     using value_type = ValueType;
 
+    struct parameters_type
+        : enable_parameters_type<parameters_type, IdentityFactory> {};
+
     /**
      * Creates a new Identity factory.
      *
@@ -108,10 +109,14 @@ class IdentityFactory
     }
 
 protected:
+    friend class EnablePolymorphicObject<IdentityFactory, LinOpFactory>;
+    friend class enable_parameters_type<parameters_type, IdentityFactory>;
+
     std::unique_ptr<LinOp> generate_impl(
         std::shared_ptr<const LinOp> base) const override;
 
-    IdentityFactory(std::shared_ptr<const Executor> exec)
+    explicit IdentityFactory(std::shared_ptr<const Executor> exec,
+                             const parameters_type& params = {})
         : EnablePolymorphicObject<IdentityFactory, LinOpFactory>(exec)
     {}
 };