48 #ifndef AMESOS2_FACTORY_HPP
49 #define AMESOS2_FACTORY_HPP
51 #include "Amesos2_config.h"
53 #include "Teuchos_CompilerCodeTweakMacros.hpp"
55 #include "Amesos2_Solver.hpp"
58 #include "Teuchos_ScalarTraits.hpp"
60 #include "Amesos2_MatrixTraits.hpp"
63 #ifdef HAVE_AMESOS2_BASKER
64 #include "Amesos2_Basker.hpp"
67 #ifdef HAVE_AMESOS2_SHYLU_NODEBASKER
68 #include "Amesos2_ShyLUBasker.hpp"
71 #if defined(HAVE_AMESOS2_KLU2)
72 #include "Amesos2_KLU2.hpp"
75 #ifdef HAVE_AMESOS2_SUPERLUDIST // Distributed-memory SuperLU
76 #include "Amesos2_Superludist.hpp"
79 #ifdef HAVE_AMESOS2_SUPERLUMT // Multi-threaded SuperLU
80 #include "Amesos2_Superlumt.hpp"
83 #ifdef HAVE_AMESOS2_UMFPACK // Umfpack
84 #include "Amesos2_Umfpack.hpp"
87 #ifdef HAVE_AMESOS2_SHYLU_NODETACHO // Tacho
88 #include "Amesos2_Tacho.hpp"
91 #ifdef HAVE_AMESOS2_SUPERLU // Sequential SuperLU
92 #include "Amesos2_Superlu.hpp"
95 #ifdef HAVE_AMESOS2_PARDISO_MKL // MKL version of Pardiso
96 #include "Amesos2_PardisoMKL.hpp"
99 #ifdef HAVE_AMESOS2_CSS_MKL // Cluster-Sparse solver from MKL
100 #include "Amesos2_CssMKL.hpp"
103 #ifdef HAVE_AMESOS2_LAPACK
104 #include "Amesos2_Lapack.hpp"
107 #if defined (HAVE_AMESOS2_CHOLMOD) && defined (HAVE_AMESOS2_EXPERIMENTAL)
108 #include "Amesos2_Cholmod.hpp"
111 #if defined (HAVE_AMESOS2_CUSOLVER) && defined (HAVE_AMESOS2_CUSPARSE)
112 #include "Amesos2_cuSOLVER.hpp"
115 #ifdef HAVE_AMESOS2_MUMPS
116 #include "Amesos2_MUMPS.hpp"
119 #ifdef HAVE_AMESOS2_STRUMPACK
120 #include "Amesos2_STRUMPACK.hpp"
126 template <
class,
class>
class Solver;
131 std::string tolower(
const std::string& s);
148 template <
class Matrix,
150 Solver<Matrix,Vector>*
151 create(
const Matrix* A, Vector* X,
const Vector* B);
168 template <
class Matrix,
170 Teuchos::RCP<Solver<Matrix,Vector> >
171 create(Teuchos::RCP<const Matrix> A,
172 Teuchos::RCP<Vector> X,
173 Teuchos::RCP<const Vector> B);
193 template <
class Matrix,
195 Solver<Matrix,Vector>*
196 create(
const char* solverName,
const Matrix* A, Vector* X,
const Vector* B);
215 template <
class Matrix,
217 Teuchos::RCP<Solver<Matrix,Vector> >
218 create(
const char* solverName,
219 const Teuchos::RCP<const Matrix> A,
220 const Teuchos::RCP<Vector> X,
221 const Teuchos::RCP<const Vector> B);
240 template <
class Matrix,
242 Solver<Matrix,Vector>*
243 create(
const std::string& solverName,
const Matrix* A, Vector* X,
const Vector* B);
262 template <
class Matrix,
264 Teuchos::RCP<Solver<Matrix,Vector> >
265 create(
const std::string& solverName,
266 const Teuchos::RCP<const Matrix> A,
267 const Teuchos::RCP<Vector> X,
268 const Teuchos::RCP<const Vector> B);
289 template <
class Matrix,
291 Solver<Matrix,Vector>*
292 create(
const std::string& solverName,
const Matrix* A);
313 template <
class Matrix,
315 Teuchos::RCP<Solver<Matrix,Vector> >
316 create(
const std::string& solverName,
317 const Teuchos::RCP<const Matrix> A);
324 template <
template <
class,
class>
class ConcreteSolver,
327 struct create_solver_with_supported_type {
328 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
329 Teuchos::RCP<Vector> X,
330 Teuchos::RCP<const Vector> B )
334 typename MatrixTraits<Matrix>::scalar_t,
335 typename MultiVecAdapter<Vector>::scalar_t
337 > same_scalar_assertion;
338 (void)same_scalar_assertion;
341 return rcp(
new ConcreteSolver<Matrix,Vector>(A, X, B) );
353 template <
template <
class,
class>
class ConcreteSolver,
356 struct throw_no_scalar_support_exception {
357 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
358 Teuchos::RCP<Vector> X,
359 Teuchos::RCP<const Vector> B )
362 typedef typename MatrixTraits<Matrix>::scalar_t scalar_t;
363 TEUCHOS_TEST_FOR_EXCEPTION(
true,
364 std::invalid_argument,
365 "The requested Amesos2 "
367 " solver interface does not support the " <<
368 Teuchos::ScalarTraits<scalar_t>::name() <<
373 template <
template <
class,
class>
class ConcreteSolver,
376 struct throw_no_matrix_support_exception {
377 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
378 Teuchos::RCP<Vector> X,
379 Teuchos::RCP<const Vector> B )
381 TEUCHOS_TEST_FOR_EXCEPTION(
true,
382 std::invalid_argument,
383 "This solver does not support the kokkos adapter." );
396 template <
template <
class,
class>
class ConcreteSolver,
399 struct handle_solver_scalar_type_support {
400 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
401 Teuchos::RCP<Vector> X,
402 Teuchos::RCP<const Vector> B )
404 return std::conditional_t<
405 solver_supports_scalar<ConcreteSolver, typename MatrixTraits<Matrix>::scalar_t>::value,
406 create_solver_with_supported_type<ConcreteSolver,Matrix,Vector>,
407 throw_no_scalar_support_exception<ConcreteSolver,Matrix,Vector> >::apply(A, X, B);
420 template <
template <
class,
class>
class ConcreteSolver,
423 struct handle_solver_matrix_and_type_support {
424 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
425 Teuchos::RCP<Vector> X,
426 Teuchos::RCP<const Vector> B )
428 return std::conditional_t<
429 solver_supports_matrix<ConcreteSolver, Matrix>::value,
430 handle_solver_scalar_type_support<ConcreteSolver,Matrix,Vector>,
431 throw_no_matrix_support_exception<ConcreteSolver,Matrix,Vector> >::apply(A, X, B);
446 bool query(
const char* solverName);
456 bool query(
const std::string& solverName);
463 template <
class Matrix,
465 Solver<Matrix,Vector>*
466 create(Matrix* A, Vector* X, Vector* B)
468 std::string solver =
"Klu2";
470 return( create(solver, rcp(A,
false), rcp(X,
false), rcp(B,
false)).getRawPtr() );
474 template <
class Matrix,
476 Teuchos::RCP<Solver<Matrix,Vector> >
477 create(Teuchos::RCP<const Matrix> A,
478 Teuchos::RCP<Vector> X,
479 Teuchos::RCP<const Vector> B)
481 std::string solver =
"Klu2";
482 return( create(solver, A, X, B) );
486 template <
class Matrix,
488 Solver<Matrix,Vector>*
489 create(
const char* solverName,
const Matrix* A, Vector* X,
const Vector* B)
491 std::string solver = solverName;
493 return( create(solver, rcp(A,
false), rcp(X,
false), rcp(B,
false)).getRawPtr() );
497 template <
class Matrix,
499 Teuchos::RCP<Solver<Matrix,Vector> >
500 create(
const char* solverName,
501 const Teuchos::RCP<const Matrix> A,
502 const Teuchos::RCP<Vector> X,
503 const Teuchos::RCP<const Vector> B)
505 std::string solver = solverName;
506 return( create(solver, A, X, B) );
510 template <
class Matrix,
512 Solver<Matrix,Vector>*
513 create(
const std::string& solverName,
const Matrix* A){
514 return( create(solverName, rcp(A,
false),
515 Teuchos::RCP<Vector>(),
516 Teuchos::RCP<const Vector>()).getRawPtr() );
520 template <
class Matrix,
522 Teuchos::RCP<Solver<Matrix,Vector> >
523 create(
const std::string& solverName,
const Teuchos::RCP<const Matrix> A){
524 return( create(solverName, A, Teuchos::RCP<Vector>(), Teuchos::RCP<const Vector>()) );
528 template <
class Matrix,
530 Teuchos::RCP<Solver<Matrix,Vector> >
531 create(
const std::string& solverName,
const Matrix* A, Vector* X,
const Vector* B)
534 return( create(solverName, rcp(A,
false), rcp(X,
false), rcp(B,
false)) );
538 template <
class Matrix,
540 Teuchos::RCP<Solver<Matrix,Vector> >
541 create(
const std::string& solver_name,
542 const Teuchos::RCP<const Matrix> A,
543 const Teuchos::RCP<Vector> X,
544 const Teuchos::RCP<const Vector> B)
546 std::string solverName = tolower(solver_name);
551 #ifdef HAVE_AMESOS2_SHYLU_NODEBASKER
552 if((solverName ==
"ShyLUBasker") || (solverName ==
"shylubasker") || (solverName ==
"amesos2_shylubasker"))
554 return handle_solver_matrix_and_type_support<ShyLUBasker, Matrix,Vector>::apply(A,X,B);
558 #ifdef HAVE_AMESOS2_BASKER
559 if((solverName ==
"Basker") || (solverName ==
"basker") || (solverName ==
"amesos2_basker"))
561 return handle_solver_matrix_and_type_support<Basker, Matrix,Vector>::apply(A,X,B);
566 #ifdef HAVE_AMESOS2_KLU2
567 if((solverName ==
"amesos2_klu2") || (solverName ==
"klu2") ||
568 (solverName ==
"amesos2_klu") || (solverName ==
"klu")){
569 return handle_solver_matrix_and_type_support<KLU2,Matrix,Vector>::apply(A, X, B);
573 #ifdef HAVE_AMESOS2_SUPERLUDIST
574 if((solverName ==
"amesos2_superludist") ||
575 (solverName ==
"superludist") ||
576 (solverName ==
"amesos2_superlu_dist") ||
577 (solverName ==
"superlu_dist")){
578 return handle_solver_matrix_and_type_support<Superludist,Matrix,Vector>::apply(A, X, B);
582 #ifdef HAVE_AMESOS2_SUPERLUMT
583 if((solverName ==
"amesos2_superlumt") ||
584 (solverName ==
"superlumt") ||
585 (solverName ==
"amesos2_superlu_mt") ||
586 (solverName ==
"superlu_mt")){
587 return handle_solver_matrix_and_type_support<Superlumt,Matrix,Vector>::apply(A, X, B);
591 #ifdef HAVE_AMESOS2_UMFPACK
592 if((solverName ==
"amesos2_umfpack") ||
593 (solverName ==
"umfpack")){
594 return handle_solver_matrix_and_type_support<Umfpack,Matrix,Vector>::apply(A, X, B);
598 #ifdef HAVE_AMESOS2_SHYLU_NODETACHO
599 if((solverName ==
"amesos2_tacho") ||
600 (solverName ==
"tacho")){
601 return handle_solver_matrix_and_type_support<TachoSolver,Matrix,Vector>::apply(A, X, B);
606 #ifdef HAVE_AMESOS2_SUPERLU
607 if((solverName ==
"amesos2_superlu") ||
608 (solverName ==
"superlu")){
609 return handle_solver_matrix_and_type_support<Superlu,Matrix,Vector>::apply(A, X, B);
613 #ifdef HAVE_AMESOS2_PARDISO_MKL
614 if((solverName ==
"amesos2_pardiso_mkl") ||
615 (solverName ==
"pardiso_mkl") ||
616 (solverName ==
"amesos2_pardisomkl") ||
617 (solverName ==
"pardisomkl")){
618 return handle_solver_matrix_and_type_support<PardisoMKL,Matrix,Vector>::apply(A, X, B);
621 #ifdef HAVE_AMESOS2_CSS_MKL
622 if((solverName ==
"amesos2_css_mkl") ||
623 (solverName ==
"css_mkl") ||
624 (solverName ==
"amesos2_cssmkl") ||
625 (solverName ==
"cssmkl")){
626 return handle_solver_matrix_and_type_support<CssMKL,Matrix,Vector>::apply(A, X, B);
630 #ifdef HAVE_AMESOS2_LAPACK
631 if((solverName ==
"amesos2_lapack") ||
632 (solverName ==
"lapack")){
633 return handle_solver_matrix_and_type_support<Lapack,Matrix,Vector>::apply(A, X, B);
638 #ifdef HAVE_AMESOS2_MUMPS
639 if((solverName ==
"MUMPS") || (solverName ==
"mumps") ||
640 (solverName ==
"amesos2_MUMPS") || (solverName ==
"amesos2_mumps"))
642 return handle_solver_matrix_and_type_support<MUMPS,Matrix,Vector>::apply(A,X,B);
646 #ifdef HAVE_AMESOS2_STRUMPACK
647 if((solverName ==
"STRUMPACK") || (solverName ==
"strumpack") ||
648 (solverName ==
"amesos2_STRUMPACK") || (solverName ==
"amesos2_strumpack"))
650 return handle_solver_matrix_and_type_support<STRUMPACK,Matrix,Vector>::apply(A,X,B);
654 #if defined (HAVE_AMESOS2_CHOLMOD) && defined (HAVE_AMESOS2_EXPERIMENTAL)
655 if(solverName ==
"amesos2_cholmod" || solverName ==
"cholmod")
656 return handle_solver_matrix_and_type_support<Cholmod,Matrix,Vector>::apply(A, X, B);
659 #if defined (HAVE_AMESOS2_CUSOLVER) && defined (HAVE_AMESOS2_CUSPARSE)
660 if(solverName ==
"amesos2_cusolver" || solverName ==
"cusolver")
661 return handle_solver_matrix_and_type_support<cuSOLVER,Matrix,Vector>::apply(A, X, B);
668 std::string err_msg = solver_name +
" is not enabled or is not supported";
669 TEUCHOS_TEST_FOR_EXCEPTION(
true, std::invalid_argument, err_msg);
671 TEUCHOS_UNREACHABLE_RETURN(Teuchos::null);
676 #endif // AMESOS2_FACTORY_HPP
A templated adapter/wrapper class for Trilinos Multivector type classes. Provides the functions neces...
Simple compile-time assertion class.
Provides access to interesting solver traits.