have default solver again from ValueType through triangular solver

Author: yhmtsai

examples/file-config-solver/config/parilu-gmres.json

@@ -2,12 +2,6 @@
     "type": "solver::Gmres",
     "preconditioner": {
         "type": "preconditioner::Ilu",
-        "l_solver": {
-            "type": "solver::LowerTrs"
-        },
-        "u_solver": {
-            "type": "solver::UpperTrs"
-        },
         "reverse_apply": false,
         "factorization": {
             "type": "factorization::ParIlu"

include/ginkgo/core/preconditioner/ic.hpp

@@ -402,22 +402,30 @@ class Ic : public EnableLinOp<Ic<LSolverTypeOrValueType, IndexType>>,
         // If no factories are provided, generate default ones
         if (!parameters_.l_solver_factory) {
             if constexpr (std::is_same_v<l_solver_type, LinOp>) {
-                // linop can not have a default factory generation
-                GKO_NOT_IMPLEMENTED;
+                // use LowerTrs as the default
+                l_solver_ = generate_default_solver<
+                    solver::LowerTrs<value_type, index_type>>(exec, l_factor);
             } else {
                 l_solver_ =
                     generate_default_solver<l_solver_type>(exec, l_factor);
-                // If comp contains both factors: use the transposed factor to
-                // avoid transposing twice
-                if (comp->get_operators().size() == 2) {
-                    auto lh_factor = comp->get_operators()[1];
-                    GKO_ASSERT_EQUAL_DIMENSIONS(l_factor, lh_factor);
-                    lh_solver_ = as<lh_solver_type>(
-                        as<Transposable>(l_solver_)->conj_transpose());
+            }
+            // If comp contains both factors: use the transposed factor to
+            // avoid transposing twice
+            if (comp->get_operators().size() == 2) {
+                auto lh_factor = comp->get_operators()[1];
+                GKO_ASSERT_EQUAL_DIMENSIONS(l_factor, lh_factor);
+                if constexpr (std::is_same_v<lh_solver_type, LinOp>) {
+                    // use UpperTrs as the default
+                    lh_solver_ = generate_default_solver<
+                        solver::UpperTrs<value_type, index_type>>(exec,
+                                                                  lh_factor);
                 } else {
-                    lh_solver_ = as<lh_solver_type>(
-                        as<Transposable>(l_solver_)->conj_transpose());
+                    lh_solver_ = generate_default_solver<lh_solver_type>(
+                        exec, lh_factor);
                 }
+            } else {
+                lh_solver_ = as<lh_solver_type>(
+                    as<Transposable>(l_solver_)->conj_transpose());
             }
         } else {
             l_solver_ = parameters_.l_solver_factory->generate(l_factor);

include/ginkgo/core/preconditioner/ilu.hpp

@@ -468,8 +468,8 @@ class Ilu
         // If no factories are provided, generate default ones
         if (!parameters_.l_solver_factory) {
             if constexpr (std::is_same_v<l_solver_type, LinOp>) {
-                // linop can not have a default factory generation
-                GKO_NOT_IMPLEMENTED;
+                l_solver_ = generate_default_solver<
+                    solver::LowerTrs<value_type, index_type>>(exec, l_factor);
             } else {
                 l_solver_ =
                     generate_default_solver<l_solver_type>(exec, l_factor);
@@ -479,8 +479,8 @@ class Ilu
         }
         if (!parameters_.u_solver_factory) {
             if constexpr (std::is_same_v<u_solver_type, LinOp>) {
-                // linop can not have a default factory generation
-                GKO_NOT_IMPLEMENTED;
+                u_solver_ = generate_default_solver<
+                    solver::LowerTrs<value_type, index_type>>(exec, u_factor);
             } else {
                 u_solver_ =
                     generate_default_solver<u_solver_type>(exec, u_factor);

reference/test/preconditioner/ic.cpp

@@ -104,10 +104,12 @@ TYPED_TEST(Ic, BuildsSymmetricTwoFactor)
 {
     auto precond = this->ic_pre_factory->generate(this->l_lh_composition);
 
-    // the first factor should be identical, the second not as it was transposed
+    // the first factor should be identical, the second should also be identical
+    // as we generate the transposed_solver on the second factor directly if it
+    // is provided.
     ASSERT_EQ(precond->get_l_solver()->get_system_matrix().get(),
               this->l_factor.get());
-    ASSERT_NE(precond->get_lh_solver()->get_system_matrix().get(),
+    ASSERT_EQ(precond->get_lh_solver()->get_system_matrix().get(),
               this->lh_factor.get());
 }