// @HEADER // ***************************************************************************** // Belos: Block Linear Solvers Package // // Copyright 2004-2016 NTESS and the Belos contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER // // This driver reads a problem from a file, which must be in Matrix Market (*.mtx). // The problem right-hand side will be generated randomly. // // NOTE: No preconditioner is used in this example. // #include "BelosConfigDefs.hpp" #include "BelosLinearProblem.hpp" #include "BelosBlockGmresSolMgr.hpp" #include "BelosOutputManager.hpp" #include "Teuchos_CommandLineProcessor.hpp" #include "Teuchos_ParameterList.hpp" #include "Teuchos_StandardCatchMacros.hpp" #include "BelosKokkosAdapter.hpp" #include "KokkosKernels_IOUtils.hpp" #include "KokkosSparse_IOUtils.hpp" #ifdef HAVE_MPI #include #endif int main(int argc, char *argv[]) { #ifdef HAVE_MPI MPI_Init(&argc,&argv); #endif bool success = true; Kokkos::initialize(); { typedef double ST; typedef int OT; typedef Kokkos::DefaultExecutionSpace EXSP; typedef Teuchos::ScalarTraits SCT; typedef SCT::magnitudeType MT; typedef Belos::KokkosMultiVec MV; typedef Belos::MultiVec KMV; typedef Belos::Operator KOP; typedef Belos::MultiVecTraits MVT; typedef Belos::OperatorTraits OPT; using Teuchos::ParameterList; using Teuchos::RCP; using Teuchos::rcp; using Teuchos::rcpFromRef; bool verbose = true; try { int frequency = 25; // frequency of status test output. int numrhs = 1; // number of right-hand sides to solve for int maxiters = -1; // maximum number of iterations allowed per linear system int maxsubspace = 50; // maximum number of blocks the solver can use for the subspace int maxrestarts = 35; // number of restarts allowed bool expresidual = false; // use explicit residual std::string filename("bcsstk12.mtx"); // example matrix std::string rhsfile(""); MT tol = 1.0e-5; // relative residual tolerance Teuchos::CommandLineProcessor cmdp(false,true); cmdp.setOption("verbose","quiet",&verbose,"Print messages and results."); cmdp.setOption("expres","impres",&expresidual,"Use explicit residual throughout."); cmdp.setOption("frequency",&frequency,"Solvers frequency for printing residuals (#iters)."); cmdp.setOption("filename",&filename,"Filename for test matrix. Acceptable file extensions: *.hb,*.mtx,*.triU,*.triS"); cmdp.setOption("rhsfile",&rhsfile,"Filename for right-hand side. (*.mtx file) "); cmdp.setOption("tol",&tol,"Relative residual tolerance used by Gmres solver."); cmdp.setOption("num-rhs",&numrhs,"Number of right-hand sides to be solved for."); cmdp.setOption("max-iters",&maxiters,"Maximum number of iterations per linear system (-1 = adapted to problem/block size)."); cmdp.setOption("max-subspace",&maxsubspace,"Maximum number of blocks the solver can use for the subspace."); cmdp.setOption("max-restarts",&maxrestarts,"Maximum number of restarts allowed for GMRES solver."); if (cmdp.parse(argc,argv) != Teuchos::CommandLineProcessor::PARSE_SUCCESSFUL) { return -1; } if (!verbose) frequency = -1; // reset frequency if test is not verbose // Read in a matrix Market file and use it to test the Kokkos Operator. KokkosSparse::CrsMatrix crsMat = KokkosSparse::Impl::read_kokkos_crst_matrix>(filename.c_str()); RCP> A = rcp(new Belos::KokkosCrsOperator(crsMat)); OT numRows = crsMat.numRows(); Teuchos::RCP X = Teuchos::rcp( new MV(numRows, numrhs) ); X->MvRandom(); Teuchos::RCP B = Teuchos::rcp( new MV(numRows, numrhs) ); OPT::Apply(*A,*X,*B); X->MvInit(0.0); // // ********Other information used by block solver*********** // *****************(can be user specified)****************** // const int NumGlobalElements = B->GetGlobalLength(); if (maxiters == -1) maxiters = NumGlobalElements - 1; // maximum number of iterations to run ParameterList belosList; belosList.set( "Maximum Iterations", maxiters ); // Maximum number of iterations allowed belosList.set( "Convergence Tolerance", tol ); // Relative convergence tolerance requested belosList.set( "Num Blocks", maxsubspace); // Maximum number of blocks in Krylov factorization belosList.set( "Maximum Restarts", maxrestarts ); // Maximum number of restarts allowed belosList.set( "Explicit Residual Test", expresidual); // use explicit residual if (verbose) { belosList.set( "Verbosity", Belos::Errors + Belos::Warnings + Belos::StatusTestDetails + Belos::FinalSummary + Belos::TimingDetails); if (frequency > 0) belosList.set( "Output Frequency", frequency ); } else belosList.set( "Verbosity", Belos::Errors + Belos::Warnings ); // // Construct an unpreconditioned linear problem instance. // Belos::LinearProblem problem( A, X, B ); bool set = problem.setProblem(); if (set == false) { std::cout << std::endl << "ERROR: Belos::LinearProblem failed to set up correctly!" << std::endl; return -1; } // // ******************************************************************* // **************Start the block Gmres iteration************************* // ******************************************************************* // // Create an iterative solver manager. RCP< Belos::SolverManager > newSolver = rcp( new Belos::BlockGmresSolMgr(rcpFromRef(problem), rcpFromRef(belosList)) ); // // **********Print out information about problem******************* // std::cout << std::endl << std::endl; std::cout << "Dimension of matrix: " << NumGlobalElements << std::endl; std::cout << "Number of right-hand sides: " << numrhs << std::endl; std::cout << "Max number of Gmres iterations: " << maxiters << std::endl; std::cout << "Relative residual tolerance: " << tol << std::endl; std::cout << std::endl; // // Perform solve // Belos::ReturnType ret; ret = newSolver->solve(); // // Compute actual residuals. // bool badRes = false; std::vector actual_resids( numrhs ); std::vector rhs_norm( numrhs ); MV resid(numRows, numrhs); OPT::Apply( *A, *X, resid ); MVT::MvAddMv( -1.0, resid, 1.0, *B, resid ); MVT::MvNorm( resid, actual_resids ); MVT::MvNorm( *B, rhs_norm ); std::cout<< "---------- Actual Residuals (normalized) ----------"< tol) badRes = true; } if (ret!=Belos::Converged || badRes) { success = false; std::cout << std::endl << "ERROR: Belos did not converge!" << std::endl; } else { success = true; std::cout << std::endl << "SUCCESS: Belos converged!" << std::endl; } } TEUCHOS_STANDARD_CATCH_STATEMENTS(verbose, std::cerr, success); } Kokkos::finalize(); #ifdef HAVE_MPI MPI_Finalize(); #endif return success ? EXIT_SUCCESS : EXIT_FAILURE; }