54#ifndef AMESOS2_SHYLUBASKER_DEF_HPP
55#define AMESOS2_SHYLUBASKER_DEF_HPP
57#include <Teuchos_Tuple.hpp>
58#include <Teuchos_ParameterList.hpp>
59#include <Teuchos_StandardParameterEntryValidators.hpp>
67template <
class Matrix,
class Vector>
68ShyLUBasker<Matrix,Vector>::ShyLUBasker(
69 Teuchos::RCP<const Matrix> A,
70 Teuchos::RCP<Vector> X,
71 Teuchos::RCP<const Vector> B )
72 : SolverCore<Amesos2::ShyLUBasker,Matrix,Vector>(A, X, B)
73 , is_contiguous_(true)
80#if defined(HAVE_AMESOS2_KOKKOS) && defined(KOKKOS_ENABLE_OPENMP)
85 typedef Kokkos::OpenMP Exe_Space;
87 ShyLUbasker = new ::BaskerNS::BaskerTrilinosInterface<local_ordinal_type, shylubasker_dtype, Exe_Space>();
88 ShyLUbasker->Options.no_pivot = BASKER_FALSE;
89 ShyLUbasker->Options.static_delayed_pivot = 0;
90 ShyLUbasker->Options.symmetric = BASKER_FALSE;
91 ShyLUbasker->Options.realloc = BASKER_TRUE;
92 ShyLUbasker->Options.verbose = BASKER_FALSE;
93 ShyLUbasker->Options.prune = BASKER_TRUE;
94 ShyLUbasker->Options.btf_matching = 2;
95 ShyLUbasker->Options.blk_matching = 1;
96 ShyLUbasker->Options.matrix_scaling = 0;
97 ShyLUbasker->Options.min_block_size = 0;
98 ShyLUbasker->Options.amd_dom = BASKER_TRUE;
99 ShyLUbasker->Options.use_metis = BASKER_TRUE;
100 ShyLUbasker->Options.use_nodeNDP = BASKER_TRUE;
101 ShyLUbasker->Options.run_nd_on_leaves = BASKER_TRUE;
102 ShyLUbasker->Options.run_amd_on_leaves = BASKER_FALSE;
103 ShyLUbasker->Options.transpose = BASKER_FALSE;
104 ShyLUbasker->Options.replace_tiny_pivot = BASKER_FALSE;
105 ShyLUbasker->Options.verbose_matrix_out = BASKER_FALSE;
107 ShyLUbasker->Options.user_fill = (double)BASKER_FILL_USER;
108 ShyLUbasker->Options.use_sequential_diag_facto = BASKER_FALSE;
109#ifdef KOKKOS_ENABLE_DEPRECATED_CODE
110 num_threads = Kokkos::OpenMP::max_hardware_threads();
112 num_threads = Kokkos::OpenMP::impl_max_hardware_threads();
115 ShyLUbaskerTr = new ::BaskerNS::BaskerTrilinosInterface<local_ordinal_type, shylubasker_dtype, Exe_Space>();
116 ShyLUbaskerTr->Options.no_pivot = BASKER_FALSE;
117 ShyLUbaskerTr->Options.static_delayed_pivot = 0;
118 ShyLUbaskerTr->Options.symmetric = BASKER_FALSE;
119 ShyLUbaskerTr->Options.realloc = BASKER_TRUE;
120 ShyLUbaskerTr->Options.verbose = BASKER_FALSE;
121 ShyLUbaskerTr->Options.prune = BASKER_TRUE;
122 ShyLUbaskerTr->Options.btf_matching = 2;
123 ShyLUbaskerTr->Options.blk_matching = 1;
124 ShyLUbaskerTr->Options.matrix_scaling = 0;
125 ShyLUbaskerTr->Options.min_block_size = 0;
126 ShyLUbaskerTr->Options.amd_dom = BASKER_TRUE;
127 ShyLUbaskerTr->Options.use_metis = BASKER_TRUE;
128 ShyLUbaskerTr->Options.use_nodeNDP = BASKER_TRUE;
129 ShyLUbaskerTr->Options.run_nd_on_leaves = BASKER_TRUE;
130 ShyLUbaskerTr->Options.run_amd_on_leaves = BASKER_FALSE;
131 ShyLUbaskerTr->Options.transpose = BASKER_TRUE;
132 ShyLUbaskerTr->Options.replace_tiny_pivot = BASKER_FALSE;
133 ShyLUbaskerTr->Options.verbose_matrix_out = BASKER_FALSE;
135 ShyLUbaskerTr->Options.user_fill = (double)BASKER_FILL_USER;
136 ShyLUbaskerTr->Options.use_sequential_diag_facto = BASKER_FALSE;
138 TEUCHOS_TEST_FOR_EXCEPTION(1 != 0,
140 "Amesos2_ShyLUBasker Exception: Do not have supported Kokkos node type (OpenMP) enabled for ShyLUBasker");
145template <
class Matrix,
class Vector>
146ShyLUBasker<Matrix,Vector>::~ShyLUBasker( )
149#if defined(HAVE_AMESOS2_KOKKOS) && defined(KOKKOS_ENABLE_OPENMP)
150 ShyLUbasker->Finalize();
151 ShyLUbaskerTr->Finalize();
153 delete ShyLUbaskerTr;
157template <
class Matrix,
class Vector>
160 return (this->root_ && (this->matrixA_->getComm()->getSize() == 1) && is_contiguous_);
163template<
class Matrix,
class Vector>
169#ifdef HAVE_AMESOS2_TIMERS
170 Teuchos::TimeMonitor preOrderTimer(this->timers_.preOrderTime_);
177template <
class Matrix,
class Vector>
185 ShyLUbasker->SetThreads(num_threads);
186 ShyLUbaskerTr->SetThreads(num_threads);
194 if ( single_proc_optimization() ) {
196 host_ordinal_type_array sp_rowptr;
197 host_ordinal_type_array sp_colind;
199 this->matrixA_->returnRowPtr_kokkos_view(sp_rowptr);
200 TEUCHOS_TEST_FOR_EXCEPTION(sp_rowptr.data() ==
nullptr,
201 std::runtime_error,
"Amesos2 Runtime Error: sp_rowptr returned null ");
202 this->matrixA_->returnColInd_kokkos_view(sp_colind);
203 TEUCHOS_TEST_FOR_EXCEPTION(sp_colind.data() ==
nullptr,
204 std::runtime_error,
"Amesos2 Runtime Error: sp_colind returned null ");
206 host_value_type_array hsp_values;
207 this->matrixA_->returnValues_kokkos_view(hsp_values);
208 shylubasker_dtype * sp_values = function_map::convert_scalar(hsp_values.data());
210 TEUCHOS_TEST_FOR_EXCEPTION(sp_values ==
nullptr,
211 std::runtime_error,
"Amesos2 Runtime Error: sp_values returned null ");
214 info = ShyLUbasker->Symbolic(this->globalNumRows_,
215 this->globalNumCols_,
216 this->globalNumNonZeros_,
222 TEUCHOS_TEST_FOR_EXCEPTION(info != 0,
223 std::runtime_error,
"Error in ShyLUBasker Symbolic");
225 if (info == BASKER_SUCCESS) {
226 info = ShyLUbaskerTr->Symbolic(this->globalNumRows_,
227 this->globalNumCols_,
228 this->globalNumNonZeros_,
234 TEUCHOS_TEST_FOR_EXCEPTION(info != 0,
235 std::runtime_error,
"Error in ShyLUBaskerTr Symbolic");
241 shylubasker_dtype * sp_values = function_map::convert_scalar(nzvals_view_.data());
242 info = ShyLUbasker->Symbolic(this->globalNumRows_,
243 this->globalNumCols_,
244 this->globalNumNonZeros_,
249 TEUCHOS_TEST_FOR_EXCEPTION(info != 0,
250 std::runtime_error,
"Error in ShyLUBasker Symbolic");
252 if (info == BASKER_SUCCESS) {
253 info = ShyLUbaskerTr->Symbolic(this->globalNumRows_,
254 this->globalNumCols_,
255 this->globalNumNonZeros_,
261 TEUCHOS_TEST_FOR_EXCEPTION(info != 0,
262 std::runtime_error,
"Error in ShyLUBaskerTr Symbolic");
269 Teuchos::broadcast(*(this->matrixA_->getComm()), 0, &info);
274template <
class Matrix,
class Vector>
283#ifdef HAVE_AMESOS2_TIMERS
284 Teuchos::TimeMonitor numFactTimer(this->timers_.numFactTime_);
293 if ( single_proc_optimization() ) {
295 host_ordinal_type_array sp_rowptr;
296 host_ordinal_type_array sp_colind;
297 this->matrixA_->returnRowPtr_kokkos_view(sp_rowptr);
298 TEUCHOS_TEST_FOR_EXCEPTION(sp_rowptr.data() ==
nullptr,
299 std::runtime_error,
"Amesos2 Runtime Error: sp_rowptr returned null ");
300 this->matrixA_->returnColInd_kokkos_view(sp_colind);
301 TEUCHOS_TEST_FOR_EXCEPTION(sp_colind.data() ==
nullptr,
302 std::runtime_error,
"Amesos2 Runtime Error: sp_colind returned null ");
304 host_value_type_array hsp_values;
305 this->matrixA_->returnValues_kokkos_view(hsp_values);
306 shylubasker_dtype * sp_values = function_map::convert_scalar(hsp_values.data());
309 TEUCHOS_TEST_FOR_EXCEPTION(sp_values ==
nullptr,
310 std::runtime_error,
"Amesos2 Runtime Error: sp_values returned null ");
313 info = ShyLUbasker->Factor( this->globalNumRows_,
314 this->globalNumCols_,
315 this->globalNumNonZeros_,
320 TEUCHOS_TEST_FOR_EXCEPTION(info != 0,
321 std::runtime_error,
"Error ShyLUBasker Factor");
324 info = ShyLUbaskerTr->Factor( this->globalNumRows_,
325 this->globalNumCols_,
326 this->globalNumNonZeros_,
331 TEUCHOS_TEST_FOR_EXCEPTION(info != 0,
332 std::runtime_error,
"Error ShyLUBaskerTr Factor");
338 shylubasker_dtype * sp_values = function_map::convert_scalar(nzvals_view_.data());
339 info = ShyLUbasker->Factor(this->globalNumRows_,
340 this->globalNumCols_,
341 this->globalNumNonZeros_,
346 TEUCHOS_TEST_FOR_EXCEPTION(info != 0,
347 std::runtime_error,
"Error ShyLUBasker Factor");
350 info = ShyLUbaskerTr->Factor(this->globalNumRows_,
351 this->globalNumCols_,
352 this->globalNumNonZeros_,
357 TEUCHOS_TEST_FOR_EXCEPTION(info != 0,
358 std::runtime_error,
"Error ShyLUBaskerTr Factor");
365 local_ordinal_type blnnz = local_ordinal_type(0);
366 local_ordinal_type bunnz = local_ordinal_type(0);
367 ShyLUbasker->GetLnnz(blnnz);
368 ShyLUbasker->GetUnnz(bunnz);
370 local_ordinal_type Trblnnz = local_ordinal_type(0);
371 local_ordinal_type Trbunnz = local_ordinal_type(0);
372 ShyLUbaskerTr->GetLnnz(Trblnnz);
373 ShyLUbaskerTr->GetUnnz(Trbunnz);
377 this->setNnzLU( as<size_t>( blnnz + bunnz ) );
383 Teuchos::broadcast(*(this->matrixA_->getComm()), 0, &info);
387 TEUCHOS_TEST_FOR_EXCEPTION(info == -1,
389 "ShyLUBasker: Could not alloc space for L and U");
390 TEUCHOS_TEST_FOR_EXCEPTION(info == -2,
392 "ShyLUBasker: Could not alloc needed work space");
393 TEUCHOS_TEST_FOR_EXCEPTION(info == -3,
395 "ShyLUBasker: Could not alloc additional memory needed for L and U");
396 TEUCHOS_TEST_FOR_EXCEPTION(info > 0,
398 "ShyLUBasker: Zero pivot found at: " << info );
404template <
class Matrix,
class Vector>
407 const Teuchos::Ptr<MultiVecAdapter<Vector> > X,
408 const Teuchos::Ptr<
const MultiVecAdapter<Vector> > B)
const
410#ifdef HAVE_AMESOS2_TIMERS
411 Teuchos::TimeMonitor solveTimer(this->timers_.solveTime_);
418 const global_size_type ld_rhs = this->root_ ? X->getGlobalLength() : 0;
419 const size_t nrhs = X->getGlobalNumVectors();
421 bool ShyluBaskerTransposeRequest = this->control_.useTranspose_;
422 const bool initialize_data =
true;
423 const bool do_not_initialize_data =
false;
425 if ( single_proc_optimization() && nrhs == 1 ) {
428 Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
429 host_solve_array_t>::do_get(initialize_data, B, bValues_, as<size_t>(ld_rhs));
431 Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
432 host_solve_array_t>::do_get(do_not_initialize_data, X, xValues_, as<size_t>(ld_rhs));
437 if ( is_contiguous_ ==
true ) {
438 Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
439 host_solve_array_t>::do_get(initialize_data, B, bValues_, as<size_t>(ld_rhs),
ROOTED, this->rowIndexBase_);
442 Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
443 host_solve_array_t>::do_get(initialize_data, B, bValues_, as<size_t>(ld_rhs),
CONTIGUOUS_AND_ROOTED, this->rowIndexBase_);
446 if ( is_contiguous_ ==
true ) {
447 Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
448 host_solve_array_t>::do_get(do_not_initialize_data, X, xValues_, as<size_t>(ld_rhs),
ROOTED, this->rowIndexBase_);
451 Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
452 host_solve_array_t>::do_get(do_not_initialize_data, X, xValues_, as<size_t>(ld_rhs),
CONTIGUOUS_AND_ROOTED, this->rowIndexBase_);
457 shylubasker_dtype * pxValues = function_map::convert_scalar(xValues_.data());
458 shylubasker_dtype * pbValues = function_map::convert_scalar(bValues_.data());
459 if (!ShyluBaskerTransposeRequest)
460 ierr = ShyLUbasker->Solve(nrhs, pbValues, pxValues);
462 ierr = ShyLUbaskerTr->Solve(nrhs, pbValues, pxValues);
466 Teuchos::broadcast(*(this->getComm()), 0, &ierr);
468 TEUCHOS_TEST_FOR_EXCEPTION( ierr > 0,
470 "Encountered zero diag element at: " << ierr);
471 TEUCHOS_TEST_FOR_EXCEPTION( ierr == -1,
473 "Could not alloc needed working memory for solve" );
475 if ( is_contiguous_ ==
true ) {
476 Util::put_1d_data_helper_kokkos_view<
477 MultiVecAdapter<Vector>,host_solve_array_t>::do_put(X, xValues_,
482 Util::put_1d_data_helper_kokkos_view<
483 MultiVecAdapter<Vector>,host_solve_array_t>::do_put(X, xValues_,
492template <
class Matrix,
class Vector>
497 return( this->globalNumRows_ == this->globalNumCols_ );
501template <
class Matrix,
class Vector>
506 using Teuchos::getIntegralValue;
507 using Teuchos::ParameterEntryValidator;
509 RCP<const Teuchos::ParameterList> valid_params = getValidParameters_impl();
511 if(parameterList->isParameter(
"IsContiguous"))
513 is_contiguous_ = parameterList->get<
bool>(
"IsContiguous");
516 if(parameterList->isParameter(
"num_threads"))
518 num_threads = parameterList->get<
int>(
"num_threads");
520 if(parameterList->isParameter(
"pivot"))
522 ShyLUbasker->Options.no_pivot = (!parameterList->get<
bool>(
"pivot"));
523 ShyLUbaskerTr->Options.no_pivot = (!parameterList->get<
bool>(
"pivot"));
525 if(parameterList->isParameter(
"delayed pivot"))
527 ShyLUbasker->Options.static_delayed_pivot = (parameterList->get<
int>(
"delayed pivot"));
528 ShyLUbaskerTr->Options.static_delayed_pivot = (parameterList->get<
int>(
"delayed pivot"));
530 if(parameterList->isParameter(
"pivot_tol"))
532 ShyLUbasker->Options.pivot_tol = parameterList->get<
double>(
"pivot_tol");
533 ShyLUbaskerTr->Options.pivot_tol = parameterList->get<
double>(
"pivot_tol");
535 if(parameterList->isParameter(
"symmetric"))
537 ShyLUbasker->Options.symmetric = parameterList->get<
bool>(
"symmetric");
538 ShyLUbaskerTr->Options.symmetric = parameterList->get<
bool>(
"symmetric");
540 if(parameterList->isParameter(
"realloc"))
542 ShyLUbasker->Options.realloc = parameterList->get<
bool>(
"realloc");
543 ShyLUbaskerTr->Options.realloc = parameterList->get<
bool>(
"realloc");
545 if(parameterList->isParameter(
"verbose"))
547 ShyLUbasker->Options.verbose = parameterList->get<
bool>(
"verbose");
548 ShyLUbaskerTr->Options.verbose = parameterList->get<
bool>(
"verbose");
550 if(parameterList->isParameter(
"verbose_matrix"))
552 ShyLUbasker->Options.verbose_matrix_out = parameterList->get<
bool>(
"verbose_matrix");
553 ShyLUbaskerTr->Options.verbose_matrix_out = parameterList->get<
bool>(
"verbose_matrix");
555 if(parameterList->isParameter(
"btf"))
557 ShyLUbasker->Options.btf = parameterList->get<
bool>(
"btf");
558 ShyLUbaskerTr->Options.btf = parameterList->get<
bool>(
"btf");
560 if(parameterList->isParameter(
"use_metis"))
562 ShyLUbasker->Options.use_metis = parameterList->get<
bool>(
"use_metis");
563 ShyLUbaskerTr->Options.use_metis = parameterList->get<
bool>(
"use_metis");
565 if(parameterList->isParameter(
"use_nodeNDP"))
567 ShyLUbasker->Options.use_nodeNDP = parameterList->get<
bool>(
"use_nodeNDP");
568 ShyLUbaskerTr->Options.use_nodeNDP = parameterList->get<
bool>(
"use_nodeNDP");
570 if(parameterList->isParameter(
"run_nd_on_leaves"))
572 ShyLUbasker->Options.run_nd_on_leaves = parameterList->get<
bool>(
"run_nd_on_leaves");
573 ShyLUbaskerTr->Options.run_nd_on_leaves = parameterList->get<
bool>(
"run_nd_on_leaves");
575 if(parameterList->isParameter(
"run_amd_on_leaves"))
577 ShyLUbasker->Options.run_amd_on_leaves = parameterList->get<
bool>(
"run_amd_on_leaves");
578 ShyLUbaskerTr->Options.run_amd_on_leaves = parameterList->get<
bool>(
"run_amd_on_leaves");
580 if(parameterList->isParameter(
"amd_on_blocks"))
582 ShyLUbasker->Options.amd_dom = parameterList->get<
bool>(
"amd_on_blocks");
583 ShyLUbaskerTr->Options.amd_dom = parameterList->get<
bool>(
"amd_on_blocks");
585 if(parameterList->isParameter(
"transpose"))
588 const auto transpose = parameterList->get<
bool>(
"transpose");
589 if (transpose ==
true)
590 this->control_.useTranspose_ =
true;
594 if(parameterList->isParameter(
"use_sequential_diag_facto"))
596 ShyLUbasker->Options.use_sequential_diag_facto = parameterList->get<
bool>(
"use_sequential_diag_facto");
597 ShyLUbaskerTr->Options.use_sequential_diag_facto = parameterList->get<
bool>(
"use_sequential_diag_facto");
599 if(parameterList->isParameter(
"user_fill"))
601 ShyLUbasker->Options.user_fill = parameterList->get<
double>(
"user_fill");
602 ShyLUbaskerTr->Options.user_fill = parameterList->get<
double>(
"user_fill");
604 if(parameterList->isParameter(
"prune"))
606 ShyLUbasker->Options.prune = parameterList->get<
bool>(
"prune");
607 ShyLUbaskerTr->Options.prune = parameterList->get<
bool>(
"prune");
609 if(parameterList->isParameter(
"replace_tiny_pivot"))
611 ShyLUbasker->Options.replace_tiny_pivot = parameterList->get<
bool>(
"replace_tiny_pivot");
612 ShyLUbaskerTr->Options.replace_tiny_pivot = parameterList->get<
bool>(
"replace_tiny_pivot");
614 if(parameterList->isParameter(
"btf_matching"))
616 ShyLUbasker->Options.btf_matching = parameterList->get<
int>(
"btf_matching");
617 ShyLUbaskerTr->Options.btf_matching = parameterList->get<
int>(
"btf_matching");
618 if (ShyLUbasker->Options.btf_matching == 1 || ShyLUbasker->Options.btf_matching == 2) {
619 ShyLUbasker->Options.matching =
true;
620 ShyLUbaskerTr->Options.matching =
true;
622 ShyLUbasker->Options.matching =
false;
623 ShyLUbaskerTr->Options.matching =
false;
626 if(parameterList->isParameter(
"blk_matching"))
628 ShyLUbasker->Options.blk_matching = parameterList->get<
int>(
"blk_matching");
629 ShyLUbaskerTr->Options.blk_matching = parameterList->get<
int>(
"blk_matching");
631 if(parameterList->isParameter(
"matrix_scaling"))
633 ShyLUbasker->Options.matrix_scaling = parameterList->get<
int>(
"matrix_scaling");
634 ShyLUbaskerTr->Options.matrix_scaling = parameterList->get<
int>(
"matrix_scaling");
636 if(parameterList->isParameter(
"min_block_size"))
638 ShyLUbasker->Options.min_block_size = parameterList->get<
int>(
"min_block_size");
639 ShyLUbaskerTr->Options.min_block_size = parameterList->get<
int>(
"min_block_size");
643template <
class Matrix,
class Vector>
644Teuchos::RCP<const Teuchos::ParameterList>
647 using Teuchos::ParameterList;
649 static Teuchos::RCP<const Teuchos::ParameterList> valid_params;
651 if( is_null(valid_params) )
653 Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
654 pl->set(
"IsContiguous",
true,
655 "Are GIDs contiguous");
656 pl->set(
"num_threads", 1,
657 "Number of threads");
658 pl->set(
"pivot",
false,
660 pl->set(
"delayed pivot", 0,
661 "Apply static delayed pivot on a big block");
662 pl->set(
"pivot_tol", .0001,
663 "Tolerance before pivot, currently not used");
664 pl->set(
"symmetric",
false,
665 "Should Symbolic assume symmetric nonzero pattern");
666 pl->set(
"realloc" ,
false,
667 "Should realloc space if not enough");
668 pl->set(
"verbose",
false,
669 "Information about factoring");
670 pl->set(
"verbose_matrix",
false,
671 "Give Permuted Matrices");
674 pl->set(
"prune",
false,
675 "Use prune on BTF blocks (Not Supported)");
676 pl->set(
"btf_matching", 2,
677 "Matching option for BTF: 0 = none, 1 = Basker, 2 = Trilinos (default), (3 = MC64 if enabled)");
678 pl->set(
"blk_matching", 1,
679 "Matching optioon for block: 0 = none, 1 or anything else = Basker (default), (2 = MC64 if enabled)");
680 pl->set(
"matrix_scaling", 0,
681 "Use matrix scaling to biig A BTF block: 0 = no-scaling, 1 = symmetric diagonal scaling, 2 = row-max, and then col-max scaling");
682 pl->set(
"min_block_size", 0,
683 "Size of the minimum diagonal blocks");
684 pl->set(
"replace_tiny_pivot",
false,
685 "Replace tiny pivots during the numerical factorization");
686 pl->set(
"use_metis",
true,
688 pl->set(
"use_nodeNDP",
true,
689 "Use nodeND to compute ND partition");
690 pl->set(
"run_nd_on_leaves",
false,
691 "Run ND on the final leaf-nodes for ND factorization");
692 pl->set(
"run_amd_on_leaves",
false,
693 "Run AMD on the final leaf-nodes for ND factorization");
694 pl->set(
"amd_on_blocks",
true,
695 "Run AMD on each diagonal blocks");
696 pl->set(
"transpose",
false,
697 "Solve the transpose A");
698 pl->set(
"use_sequential_diag_facto",
false,
699 "Use sequential algorithm to factor each diagonal block");
700 pl->set(
"user_fill", (
double)BASKER_FILL_USER,
701 "User-provided padding for the fill ratio");
708template <
class Matrix,
class Vector>
713 if(current_phase == SOLVE)
return (
false);
715 #ifdef HAVE_AMESOS2_TIMERS
716 Teuchos::TimeMonitor convTimer(this->timers_.mtxConvTime_);
721 if ( single_proc_optimization() ) {
730 Kokkos::resize(nzvals_view_, this->globalNumNonZeros_);
731 Kokkos::resize(rowind_view_, this->globalNumNonZeros_);
732 Kokkos::resize(colptr_view_, this->globalNumCols_ + 1);
735 local_ordinal_type nnz_ret = 0;
737 #ifdef HAVE_AMESOS2_TIMERS
738 Teuchos::TimeMonitor mtxRedistTimer( this->timers_.mtxRedistTime_ );
741 if ( is_contiguous_ ==
true ) {
743 MatrixAdapter<Matrix>, host_value_type_array, host_ordinal_type_array, host_ordinal_type_array>
744 ::do_get(this->matrixA_.ptr(), nzvals_view_, rowind_view_, colptr_view_,
749 MatrixAdapter<Matrix>, host_value_type_array, host_ordinal_type_array, host_ordinal_type_array>
750 ::do_get(this->matrixA_.ptr(), nzvals_view_, rowind_view_, colptr_view_,
756 TEUCHOS_TEST_FOR_EXCEPTION( nnz_ret != as<local_ordinal_type>(this->globalNumNonZeros_),
758 "Amesos2_ShyLUBasker loadA_impl: Did not get the expected number of non-zero vals");
766template<
class Matrix,
class Vector>
Amesos2 ShyLUBasker declarations.
@ ROOTED
Definition Amesos2_TypeDecl.hpp:127
@ CONTIGUOUS_AND_ROOTED
Definition Amesos2_TypeDecl.hpp:128
@ ARBITRARY
Definition Amesos2_TypeDecl.hpp:143
Amesos2 interface to the Baker package.
Definition Amesos2_ShyLUBasker_decl.hpp:77
EPhase
Used to indicate a phase in the direct solution.
Definition Amesos2_TypeDecl.hpp:65
void transpose(ArrayView< Scalar > vals, ArrayView< GlobalOrdinal > indices, ArrayView< GlobalSizeT > ptr, ArrayView< Scalar > trans_vals, ArrayView< GlobalOrdinal > trans_indices, ArrayView< GlobalSizeT > trans_ptr)
A generic helper class for getting a CCS representation of a Matrix.
Definition Amesos2_Util.hpp:652