// Copyright (C) 2012 Anders Logg // // This file is part of DOLFIN. // // DOLFIN is free software: you can redistribute it and/or modify // it under the terms of the GNU Lesser General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // // DOLFIN 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 // GNU Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License // along with DOLFIN. If not, see . // // Unit tests for matrix-free linear solvers (LinearOperator) #include #include "forms/ReactionDiffusion.h" #include "forms/ReactionDiffusionAction.h" #include using namespace dolfin; //----------------------------------------------------------------------------- TEST_CASE("Testing LinearOperator", "[linear_operator]") { // Backends supporting the LinearOperator interface //std::vector backends = {"PETSc", "Eigen"}; std::vector backends = {"PETSc"}; // Define linear operator class MyLinearOperator : public LinearOperator { public: MyLinearOperator(Form& a_action, Function& u) : LinearOperator(*u.vector(), *u.vector()), a_action(a_action), u(u) { // Do nothing } std::size_t size(std::size_t dim) const { return u.function_space()->dim(); } void mult(const GenericVector& x, GenericVector& y) const { // Update coefficient vector *u.vector() = x; // Assemble action Assembler assembler; assembler.assemble(y, a_action); } private: Form& a_action; Function& u; }; SECTION("using linear operator") { // Iterate over backends supporting linear operators for (std::size_t i = 0; i < backends.size(); i++) { // Check whether backend is available if (!has_linear_algebra_backend(backends[i])) continue; // Skip testing Eigen in parallel if (dolfin::MPI::size(MPI_COMM_WORLD) > 1 && backends[i] == "Eigen") { info("Not running Eigen test in parallel"); continue; } // Set linear algebra backend parameters["linear_algebra_backend"] = backends[i]; // Compute reference value by solving ordinary linear system auto mesh = std::make_shared(8, 8); auto V = std::make_shared(mesh); ReactionDiffusion::BilinearForm a(V, V); ReactionDiffusion::LinearForm L(V); auto f = std::make_shared(1.0); L.f = f; Matrix A; Vector x, b; assemble(A, a); assemble(b, L); solve(A, x, b, "gmres", "none"); const double norm_ref = norm(x, "l2"); //continue; // Solve using linear operator defined by form action ReactionDiffusionAction::LinearForm a_action(V); auto u = std::make_shared(V); a_action.u = u; MyLinearOperator O(a_action, *u); solve(O, x, b, "gmres", "none"); const double norm_action = norm(x, "l2"); // Check results CHECK(norm_ref == Approx(norm_action)); } } } //-----------------------------------------------------------------------------