Amesos2 - Direct Sparse Solver Interfaces  Version of the Day
Amesos2_KLU2_def.hpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // Amesos2: Templated Direct Sparse Solver Package
4 //
5 // Copyright 2011 NTESS and the Amesos2 contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
18 #ifndef AMESOS2_KLU2_DEF_HPP
19 #define AMESOS2_KLU2_DEF_HPP
20 
21 #include <Teuchos_Tuple.hpp>
22 #include <Teuchos_ParameterList.hpp>
23 #include <Teuchos_StandardParameterEntryValidators.hpp>
24 
26 #include "Amesos2_KLU2_decl.hpp"
27 
28 namespace Amesos2 {
29 
30 
31 template <class Matrix, class Vector>
33  Teuchos::RCP<const Matrix> A,
34  Teuchos::RCP<Vector> X,
35  Teuchos::RCP<const Vector> B )
36  : SolverCore<Amesos2::KLU2,Matrix,Vector>(A, X, B)
37  , transFlag_(0)
38  , is_contiguous_(true)
39  , use_gather_(true)
40 {
41  ::KLU2::klu_defaults<klu2_dtype, local_ordinal_type> (&(data_.common_)) ;
42  data_.symbolic_ = NULL;
43  data_.numeric_ = NULL;
44 
45  // Override some default options
46  // TODO: use data_ here to init
47 }
48 
49 
50 template <class Matrix, class Vector>
52 {
53  /* Free KLU2 data_types
54  * - Matrices
55  * - Vectors
56  * - Other data
57  */
58  if (data_.symbolic_ != NULL)
59  ::KLU2::klu_free_symbolic<klu2_dtype, local_ordinal_type>
60  (&(data_.symbolic_), &(data_.common_)) ;
61  if (data_.numeric_ != NULL)
62  ::KLU2::klu_free_numeric<klu2_dtype, local_ordinal_type>
63  (&(data_.numeric_), &(data_.common_)) ;
64 
65  // Storage is initialized in numericFactorization_impl()
66  //if ( data_.A.Store != NULL ){
67  // destoy
68  //}
69 
70  // only root allocated these SuperMatrices.
71  //if ( data_.L.Store != NULL ){ // will only be true for this->root_
72  // destroy ..
73  //}
74 }
75 
76 template <class Matrix, class Vector>
77 bool
79  return (this->root_ && (this->matrixA_->getComm()->getSize() == 1) && is_contiguous_);
80 }
81 
82 template<class Matrix, class Vector>
83 int
85 {
86  /* TODO: Define what it means for KLU2
87  */
88 #ifdef HAVE_AMESOS2_TIMERS
89  Teuchos::TimeMonitor preOrderTimer(this->timers_.preOrderTime_);
90 #endif
91 
92  return(0);
93 }
94 
95 
96 template <class Matrix, class Vector>
97 int
99 {
100  if (data_.symbolic_ != NULL) {
101  ::KLU2::klu_free_symbolic<klu2_dtype, local_ordinal_type>
102  (&(data_.symbolic_), &(data_.common_)) ;
103  }
104 
105  if ( single_proc_optimization() ) {
106  host_ordinal_type_array host_row_ptr_view;
107  host_ordinal_type_array host_cols_view;
108  this->matrixA_->returnRowPtr_kokkos_view(host_row_ptr_view);
109  this->matrixA_->returnColInd_kokkos_view(host_cols_view);
110  data_.symbolic_ = ::KLU2::klu_analyze<klu2_dtype, local_ordinal_type>
111  ((local_ordinal_type)this->globalNumCols_, host_row_ptr_view.data(),
112  host_cols_view.data(), &(data_.common_)) ;
113  }
114  else
115  {
116  data_.symbolic_ = ::KLU2::klu_analyze<klu2_dtype, local_ordinal_type>
117  ((local_ordinal_type)this->globalNumCols_, host_col_ptr_view_.data(),
118  host_rows_view_.data(), &(data_.common_)) ;
119 
120  } //end single_process_optim_check = false
121 
122  return(0);
123 }
124 
125 
126 template <class Matrix, class Vector>
127 int
129 {
130  using Teuchos::as;
131 
132  // Cleanup old L and U matrices if we are not reusing a symbolic
133  // factorization. Stores and other data will be allocated in gstrf.
134  // Only rank 0 has valid pointers, TODO: for KLU2
135 
136  int info = 0;
137  if ( this->root_ ) {
138 
139  { // Do factorization
140 #ifdef HAVE_AMESOS2_TIMERS
141  Teuchos::TimeMonitor numFactTimer(this->timers_.numFactTime_);
142 #endif
143 
144  if (data_.numeric_ != NULL) {
145  ::KLU2::klu_free_numeric<klu2_dtype, local_ordinal_type>
146  (&(data_.numeric_), &(data_.common_));
147  }
148 
149  if ( single_proc_optimization() ) {
150  host_ordinal_type_array host_row_ptr_view;
151  host_ordinal_type_array host_cols_view;
152  this->matrixA_->returnRowPtr_kokkos_view(host_row_ptr_view);
153  this->matrixA_->returnColInd_kokkos_view(host_cols_view);
154  this->matrixA_->returnValues_kokkos_view(host_nzvals_view_);
155  klu2_dtype * pValues = function_map::convert_scalar(host_nzvals_view_.data());
156  data_.numeric_ = ::KLU2::klu_factor<klu2_dtype, local_ordinal_type>
157  (host_row_ptr_view.data(), host_cols_view.data(), pValues,
158  data_.symbolic_, &(data_.common_));
159  }
160  else {
161  klu2_dtype * pValues = function_map::convert_scalar(host_nzvals_view_.data());
162  data_.numeric_ = ::KLU2::klu_factor<klu2_dtype, local_ordinal_type>
163  (host_col_ptr_view_.data(), host_rows_view_.data(), pValues,
164  data_.symbolic_, &(data_.common_));
165  } //end single_process_optim_check = false
166 
167  // To have a test which confirms a throw, we need MPI to throw on all the
168  // ranks. So we delay and broadcast first. Others throws in Amesos2 which
169  // happen on just the root rank would also have the same problem if we
170  // tested them but we decided to fix just this one for the present. This
171  // is the only error/throw we currently have a unit test for.
172  if(data_.numeric_ == nullptr) {
173  info = 1;
174  }
175 
176  // This is set after numeric factorization complete as pivoting can be used;
177  // In this case, a discrepancy between symbolic and numeric nnz total can occur.
178  if(info == 0) { // skip if error code so we don't segfault - will throw
179  this->setNnzLU( as<size_t>((data_.numeric_)->lnz) + as<size_t>((data_.numeric_)->unz) );
180  }
181  } // end scope
182 
183  } // end this->root_
184 
185  /* All processes should have the same error code */
186  Teuchos::broadcast(*(this->matrixA_->getComm()), 0, &info);
187 
188  TEUCHOS_TEST_FOR_EXCEPTION(info > 0, std::runtime_error,
189  "KLU2 numeric factorization failed(info="+std::to_string(info)+")");
190 
191  return(info);
192 }
193 
194 template <class Matrix, class Vector>
195 int
197  const Teuchos::Ptr<MultiVecAdapter<Vector> > X,
198  const Teuchos::Ptr<const MultiVecAdapter<Vector> > B) const
199 {
200  using Teuchos::as;
201  int ierr = 0; // returned error code
202 
203  const global_size_type ld_rhs = this->root_ ? X->getGlobalLength() : 0;
204  const size_t nrhs = X->getGlobalNumVectors();
205 
206  bool bDidAssignX;
207  bool bDidAssignB;
208  bool use_gather = use_gather_; // user param
209  use_gather = (use_gather && this->matrixA_->getComm()->getSize() > 1); // only with multiple MPIs
210  use_gather = (use_gather && (std::is_same<scalar_type, float>::value || std::is_same<scalar_type, double>::value)); // only for double or float
211  {
212 #ifdef HAVE_AMESOS2_TIMERS
213  Teuchos::TimeMonitor mvConvTimer(this->timers_.vecConvTime_);
214 #endif
215  const bool initialize_data = true;
216  const bool do_not_initialize_data = false;
217  if ( single_proc_optimization() && nrhs == 1 ) {
218  // no msp creation
219  bDidAssignB = Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
220  host_solve_array_t>::do_get(initialize_data, B, bValues_, as<size_t>(ld_rhs));
221 
222  bDidAssignX = Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
223  host_solve_array_t>::do_get(do_not_initialize_data, X, xValues_, as<size_t>(ld_rhs));
224  }
225  else {
226  if (use_gather) {
227  int rval = B->gather(bValues_, this->perm_g2l, this->recvCountRows, this->recvDisplRows,
228  (is_contiguous_ == true) ? ROOTED : CONTIGUOUS_AND_ROOTED);
229  if (rval == 0) {
230  X->gather(xValues_, this->perm_g2l, this->recvCountRows, this->recvDisplRows,
231  (is_contiguous_ == true) ? ROOTED : CONTIGUOUS_AND_ROOTED);
232  bDidAssignB = true; // TODO : find when we can avoid deep-copy
233  bDidAssignX = false; // TODO : find when we can avoid scatter
234  } else {
235  use_gather = false;
236  }
237  }
238  if (!use_gather) {
239  bDidAssignB = Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
240  host_solve_array_t>::do_get(initialize_data, B, bValues_,
241  as<size_t>(ld_rhs),
242  (is_contiguous_ == true) ? ROOTED : CONTIGUOUS_AND_ROOTED,
243  this->rowIndexBase_);
244  // see Amesos2_Tacho_def.hpp for an explanation of why we 'get' X
245  bDidAssignX = Util::get_1d_copy_helper_kokkos_view<MultiVecAdapter<Vector>,
246  host_solve_array_t>::do_get(do_not_initialize_data, X, xValues_,
247  as<size_t>(ld_rhs),
248  (is_contiguous_ == true) ? ROOTED : CONTIGUOUS_AND_ROOTED,
249  this->rowIndexBase_);
250  }
251 
252  // klu_tsolve is going to put the solution x into the input b.
253  // Copy b to x then solve in x.
254  // We do not want to solve in b, then copy to x, because if b was assigned
255  // then the solve will change b permanently and mess up the next test cycle.
256  // However if b was actually a copy (bDidAssignB = false) then we can avoid
257  // this deep_copy and just assign xValues_ = bValues_.
258  if(bDidAssignB) {
259  Kokkos::deep_copy(xValues_, bValues_); // need deep_copy or solve will change adapter's b memory which should never happen
260  }
261  else {
262  xValues_ = bValues_; // safe because bValues_ does not point straight to adapter's memory space
263  }
264  }
265  }
266 
267  klu2_dtype * pxValues = function_map::convert_scalar(xValues_.data());
268  klu2_dtype * pbValues = function_map::convert_scalar(bValues_.data());
269 
270  // can be null for non root
271  if( this->root_) {
272  TEUCHOS_TEST_FOR_EXCEPTION(pbValues == nullptr,
273  std::runtime_error, "Amesos2 Runtime Error: b_vector returned null ");
274 
275  TEUCHOS_TEST_FOR_EXCEPTION(pxValues == nullptr,
276  std::runtime_error, "Amesos2 Runtime Error: x_vector returned null ");
277  }
278 
279  if ( single_proc_optimization() && nrhs == 1 ) {
280 #ifdef HAVE_AMESOS2_TIMERS
281  Teuchos::TimeMonitor solveTimer(this->timers_.solveTime_);
282 #endif
283 
284  // For this case, Crs matrix raw pointers were used, so the non-transpose default solve
285  // is actually the transpose solve as klu_solve expects Ccs matrix pointers
286  // Thus, if the transFlag_ is true, the non-transpose solve should be used
287  if (transFlag_ == 0)
288  {
289  ::KLU2::klu_tsolve2<klu2_dtype, local_ordinal_type>
290  (data_.symbolic_, data_.numeric_,
291  (local_ordinal_type)this->globalNumCols_,
292  (local_ordinal_type)nrhs,
293  pbValues, pxValues, &(data_.common_)) ;
294  }
295  else {
296  ::KLU2::klu_solve2<klu2_dtype, local_ordinal_type>
297  (data_.symbolic_, data_.numeric_,
298  (local_ordinal_type)this->globalNumCols_,
299  (local_ordinal_type)nrhs,
300  pbValues, pxValues, &(data_.common_)) ;
301  }
302 
303  /* All processes should have the same error code */
304  // Teuchos::broadcast(*(this->getComm()), 0, &ierr);
305 
306  } // end single_process_optim_check && nrhs == 1
307  else // single proc optimizations but nrhs > 1,
308  // or distributed over processes case
309  {
310  if ( this->root_ ) {
311 #ifdef HAVE_AMESOS2_TIMERS
312  Teuchos::TimeMonitor solveTimer(this->timers_.solveTime_);
313 #endif
314  if (transFlag_ == 0)
315  {
316  // For this case, Crs matrix raw pointers were used, so the non-transpose default solve
317  // is actually the transpose solve as klu_solve expects Ccs matrix pointers
318  // Thus, if the transFlag_ is true, the non-transpose solve should be used
319  if ( single_proc_optimization() ) {
320  ::KLU2::klu_tsolve<klu2_dtype, local_ordinal_type>
321  (data_.symbolic_, data_.numeric_,
322  (local_ordinal_type)this->globalNumCols_,
323  (local_ordinal_type)nrhs,
324  pxValues, &(data_.common_)) ;
325  }
326  else {
327  ::KLU2::klu_solve<klu2_dtype, local_ordinal_type>
328  (data_.symbolic_, data_.numeric_,
329  (local_ordinal_type)this->globalNumCols_,
330  (local_ordinal_type)nrhs,
331  pxValues, &(data_.common_)) ;
332  }
333  }
334  else
335  {
336  // For this case, Crs matrix raw pointers were used, so the non-transpose default solve
337  // is actually the transpose solve as klu_solve expects Ccs matrix pointers
338  // Thus, if the transFlag_ is true, the non- transpose solve should be used
339  if ( single_proc_optimization() ) {
340  ::KLU2::klu_solve<klu2_dtype, local_ordinal_type>
341  (data_.symbolic_, data_.numeric_,
342  (local_ordinal_type)this->globalNumCols_,
343  (local_ordinal_type)nrhs,
344  pxValues, &(data_.common_)) ;
345  }
346  else {
347  ::KLU2::klu_tsolve<klu2_dtype, local_ordinal_type>
348  (data_.symbolic_, data_.numeric_,
349  (local_ordinal_type)this->globalNumCols_,
350  (local_ordinal_type)nrhs,
351  pxValues, &(data_.common_)) ;
352  }
353  }
354  } // end root_
355  } //end else
356 
357  // if bDidAssignX, then we solved straight to the adapter's X memory space without
358  // requiring additional memory allocation, so the x data is already in place.
359  if(!bDidAssignX) {
360 #ifdef HAVE_AMESOS2_TIMERS
361  Teuchos::TimeMonitor redistTimer( this->timers_.vecRedistTime_ );
362 #endif
363  if (use_gather) {
364  int rval = X->scatter(xValues_, this->perm_g2l, this->recvCountRows, this->recvDisplRows,
365  (is_contiguous_ == true) ? ROOTED : CONTIGUOUS_AND_ROOTED);
366  if (rval != 0) use_gather = false;
367  }
368  if (!use_gather) {
369  Util::put_1d_data_helper_kokkos_view<
370  MultiVecAdapter<Vector>,host_solve_array_t>::do_put(X, xValues_,
371  as<size_t>(ld_rhs),
372  (is_contiguous_ == true) ? ROOTED : CONTIGUOUS_AND_ROOTED,
373  this->rowIndexBase_);
374  }
375  }
376  return(ierr);
377 }
378 
379 
380 template <class Matrix, class Vector>
381 bool
383 {
384  // The KLU2 factorization routines can handle square as well as
385  // rectangular matrices, but KLU2 can only apply the solve routines to
386  // square matrices, so we check the matrix for squareness.
387  return( this->matrixA_->getGlobalNumRows() == this->matrixA_->getGlobalNumCols() );
388 }
389 
390 
391 template <class Matrix, class Vector>
392 void
393 KLU2<Matrix,Vector>::setParameters_impl(const Teuchos::RCP<Teuchos::ParameterList> & parameterList )
394 {
395  using Teuchos::RCP;
396  using Teuchos::getIntegralValue;
397  using Teuchos::ParameterEntryValidator;
398 
399  RCP<const Teuchos::ParameterList> valid_params = getValidParameters_impl();
400 
401  transFlag_ = this->control_.useTranspose_ ? 1: 0;
402  // The KLU2 transpose option can override the Amesos2 option
403  if( parameterList->isParameter("Trans") ){
404  RCP<const ParameterEntryValidator> trans_validator = valid_params->getEntry("Trans").validator();
405  parameterList->getEntry("Trans").setValidator(trans_validator);
406 
407  transFlag_ = getIntegralValue<int>(*parameterList, "Trans");
408  }
409 
410  if( parameterList->isParameter("IsContiguous") ){
411  is_contiguous_ = parameterList->get<bool>("IsContiguous");
412  }
413  if( parameterList->isParameter("UseCustomGather") ){
414  use_gather_ = parameterList->get<bool>("UseCustomGather");
415  }
416 }
417 
418 
419 template <class Matrix, class Vector>
420 Teuchos::RCP<const Teuchos::ParameterList>
422 {
423  using std::string;
424  using Teuchos::tuple;
425  using Teuchos::ParameterList;
426  using Teuchos::setStringToIntegralParameter;
427 
428  static Teuchos::RCP<const Teuchos::ParameterList> valid_params;
429 
430  if( is_null(valid_params) )
431  {
432  Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
433 
434  pl->set("Equil", true, "Whether to equilibrate the system before solve, does nothing now");
435  pl->set("IsContiguous", true, "Whether GIDs contiguous");
436  pl->set("UseCustomGather", true, "Whether to use new matrix-gather routine");
437 
438  setStringToIntegralParameter<int>("Trans", "NOTRANS",
439  "Solve for the transpose system or not",
440  tuple<string>("NOTRANS","TRANS","CONJ"),
441  tuple<string>("Solve with transpose",
442  "Do not solve with transpose",
443  "Solve with the conjugate transpose"),
444  tuple<int>(0, 1, 2),
445  pl.getRawPtr());
446  valid_params = pl;
447  }
448 
449  return valid_params;
450 }
451 
452 
453 template <class Matrix, class Vector>
454 bool
456 {
457  using Teuchos::as;
458 #ifdef HAVE_AMESOS2_TIMERS
459  Teuchos::TimeMonitor convTimer(this->timers_.mtxConvTime_);
460 #endif
461 
462  if(current_phase == SOLVE)return(false);
463 
464  if ( single_proc_optimization() ) {
465  // Do nothing in this case - Crs raw pointers will be used
466  }
467  else
468  {
469  // Only the root image needs storage allocated
470  if( this->root_ ) {
471  if (host_nzvals_view_.extent(0) != this->globalNumNonZeros_)
472  Kokkos::resize(host_nzvals_view_, this->globalNumNonZeros_);
473  if (host_rows_view_.extent(0) != this->globalNumNonZeros_)
474  Kokkos::resize(host_rows_view_, this->globalNumNonZeros_);
475  if (host_col_ptr_view_.extent(0) != (this->globalNumRows_ + 1))
476  Kokkos::resize(host_col_ptr_view_, this->globalNumRows_ + 1);
477  }
478  local_ordinal_type nnz_ret = -1;
479  bool use_gather = use_gather_; // user param
480  use_gather = (use_gather && this->matrixA_->getComm()->getSize() > 1); // only with multiple MPIs
481  use_gather = (use_gather && (std::is_same<scalar_type, float>::value || std::is_same<scalar_type, double>::value)); // only for double or float
482  {
483 #ifdef HAVE_AMESOS2_TIMERS
484  Teuchos::TimeMonitor mtxRedistTimer( this->timers_.mtxRedistTime_ );
485 #endif
486  if (use_gather) {
487  bool column_major = true;
488  if (!is_contiguous_) {
489  auto contig_mat = this->matrixA_->reindex(this->contig_rowmap_, this->contig_colmap_, current_phase);
490  nnz_ret = contig_mat->gather(host_nzvals_view_, host_rows_view_, host_col_ptr_view_, this->perm_g2l, this->recvCountRows, this->recvDisplRows, this->recvCounts, this->recvDispls,
491  this->transpose_map, this->nzvals_t, column_major, current_phase);
492  } else {
493  nnz_ret = this->matrixA_->gather(host_nzvals_view_, host_rows_view_, host_col_ptr_view_, this->perm_g2l, this->recvCountRows, this->recvDisplRows, this->recvCounts, this->recvDispls,
494  this->transpose_map, this->nzvals_t, column_major, current_phase);
495  }
496  // gather failed (e.g., not implemened for KokkosCrsMatrix)
497  // in case of the failure, it falls back to the original "do_get"
498  if (nnz_ret < 0) use_gather = false;
499  }
500  if (!use_gather) {
502  MatrixAdapter<Matrix>,host_value_type_array,host_ordinal_type_array,host_ordinal_type_array>
503  ::do_get(this->matrixA_.ptr(), host_nzvals_view_, host_rows_view_, host_col_ptr_view_, nnz_ret,
504  (is_contiguous_ == true) ? ROOTED : CONTIGUOUS_AND_ROOTED,
505  ARBITRARY,
506  this->rowIndexBase_);
507  }
508  }
509 
510  // gather return the total nnz_ret on every MPI process
511  if (use_gather || this->root_) {
512  TEUCHOS_TEST_FOR_EXCEPTION( nnz_ret != as<local_ordinal_type>(this->globalNumNonZeros_),
513  std::runtime_error,
514  "Amesos2_KLU2 loadA_impl: Did not get the expected number of non-zero vals("
515  +std::to_string(nnz_ret)+" vs "+std::to_string(this->globalNumNonZeros_)+")");
516  }
517  } //end else single_process_optim_check = false
518 
519  return true;
520 }
521 
522 
523 template<class Matrix, class Vector>
524 const char* KLU2<Matrix,Vector>::name = "KLU2";
525 
526 
527 } // end namespace Amesos2
528 
529 #endif // AMESOS2_KLU2_DEF_HPP
Amesos2::SolverCore: A templated interface for interaction with third-party direct sparse solvers...
Definition: Amesos2_SolverCore_decl.hpp:71
KLU2(Teuchos::RCP< const Matrix > A, Teuchos::RCP< Vector > X, Teuchos::RCP< const Vector > B)
Initialize from Teuchos::RCP.
Definition: Amesos2_KLU2_def.hpp:32
A generic helper class for getting a CCS representation of a Matrix.
Definition: Amesos2_Util.hpp:614
int solve_impl(const Teuchos::Ptr< MultiVecAdapter< Vector > > X, const Teuchos::Ptr< const MultiVecAdapter< Vector > > B) const
KLU2 specific solve.
Definition: Amesos2_KLU2_def.hpp:196
EPhase
Used to indicate a phase in the direct solution.
Definition: Amesos2_TypeDecl.hpp:31
Amesos2 KLU2 declarations.
bool loadA_impl(EPhase current_phase)
Reads matrix data into internal structures.
Definition: Amesos2_KLU2_def.hpp:455
~KLU2()
Destructor.
Definition: Amesos2_KLU2_def.hpp:51
void setParameters_impl(const Teuchos::RCP< Teuchos::ParameterList > &parameterList)
Definition: Amesos2_KLU2_def.hpp:393
int symbolicFactorization_impl()
Perform symbolic factorization of the matrix using KLU2.
Definition: Amesos2_KLU2_def.hpp:98
int preOrdering_impl()
Performs pre-ordering on the matrix to increase efficiency.
Definition: Amesos2_KLU2_def.hpp:84
bool matrixShapeOK_impl() const
Determines whether the shape of the matrix is OK for this solver.
Definition: Amesos2_KLU2_def.hpp:382
A Matrix adapter interface for Amesos2.
Definition: Amesos2_MatrixAdapter_decl.hpp:42
int numericFactorization_impl()
KLU2 specific numeric factorization.
Definition: Amesos2_KLU2_def.hpp:128
Amesos2 interface to the KLU2 package.
Definition: Amesos2_KLU2_decl.hpp:38
bool single_proc_optimization() const
can we optimize size_type and ordinal_type for straight pass through, also check that is_contiguous_ ...
Definition: Amesos2_KLU2_def.hpp:78
Teuchos::RCP< const Teuchos::ParameterList > getValidParameters_impl() const
Definition: Amesos2_KLU2_def.hpp:421
A templated MultiVector class adapter for Amesos2.
Definition: Amesos2_MultiVecAdapter_decl.hpp:142