Stratimikos Package Browser (Single Doxygen Collection) Version of the Day
Loading...
Searching...
No Matches
Stratimikos_LinearSolverBuilder_def.hpp
Go to the documentation of this file.
1// @HEADER
2// ***********************************************************************
3//
4// Stratimikos: Thyra-based strategies for linear solvers
5// Copyright (2006) Sandia Corporation
6//
7// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
8// license for use of this work by or on behalf of the U.S. Government.
9//
10// Redistribution and use in source and binary forms, with or without
11// modification, are permitted provided that the following conditions are
12// met:
13//
14// 1. Redistributions of source code must retain the above copyright
15// notice, this list of conditions and the following disclaimer.
16//
17// 2. Redistributions in binary form must reproduce the above copyright
18// notice, this list of conditions and the following disclaimer in the
19// documentation and/or other materials provided with the distribution.
20//
21// 3. Neither the name of the Corporation nor the names of the
22// contributors may be used to endorse or promote products derived from
23// this software without specific prior written permission.
24//
25// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36//
37// Questions? Contact Roscoe A. Bartlett (rabartl@sandia.gov)
38//
39// ***********************************************************************
40// @HEADER
41
42#ifndef STRATIMIKOS_LINEARSOLVERBUILDER_DEF_HPP
43#define STRATIMIKOS_LINEARSOLVERBUILDER_DEF_HPP
44
45//#define THYRA_DEFAULT_REAL_LINEAR_SOLVER_BUILDER_DUMP
46
47#include "Stratimikos_InternalConfig.h"
48#include "Thyra_DelayedLinearOpWithSolveFactory.hpp"
49#include "Teuchos_AbstractFactoryStd.hpp"
50#include "Teuchos_CommandLineProcessor.hpp"
51#include "Teuchos_XMLParameterListHelpers.hpp"
52#include "Teuchos_GlobalMPISession.hpp"
53
54#ifdef HAVE_STRATIMIKOS_AMESOS
56#endif
57#ifdef HAVE_STRATIMIKOS_AMESOS2
58# include "Thyra_Amesos2LinearOpWithSolveFactory.hpp"
59#endif
60#if defined(HAVE_STRATIMIKOS_EPETRAEXT) && defined(HAVE_STRATIMIKOS_AZTECOO)
62#endif
63#ifdef HAVE_STRATIMIKOS_BELOS
64# include "Thyra_BelosLinearOpWithSolveFactory.hpp"
65#endif
66#ifdef HAVE_STRATIMIKOS_IFPACK
68#endif
69#ifdef HAVE_STRATIMIKOS_ML
71#endif
72
73
74namespace {
75
76
77const std::string LinearSolverType_name = "Linear Solver Type";
78const std::string LinearSolverTypes_name = "Linear Solver Types";
79const std::string PreconditionerType_name = "Preconditioner Type";
80const std::string PreconditionerTypes_name = "Preconditioner Types";
81const std::string None_name = "None";
82const std::string EnableDelayedSolverConstruction_name = "Enable Delayed Solver Construction";
83const bool EnableDelayedSolverConstruction_default = false;
84
85
86} // namespace
87
88
89namespace Stratimikos {
90
91
92// Constructors/Initializers/Accessors
93
94
95template<class Scalar>
97 const std::string &paramsXmlFileName_in
98 ,const std::string &extraParamsXmlString_in
99 ,const std::string &paramsUsedXmlOutFileName_in
100 ,const std::string &paramsXmlFileNameOption_in
101 ,const std::string &extraParamsXmlStringOption_in
102 ,const std::string &paramsUsedXmlOutFileNameOption_in
103 )
104 :paramsXmlFileName_(paramsXmlFileName_in)
105 ,extraParamsXmlString_(extraParamsXmlString_in)
106 ,paramsUsedXmlOutFileName_(paramsUsedXmlOutFileName_in)
107 ,paramsXmlFileNameOption_(paramsXmlFileNameOption_in)
108 ,extraParamsXmlStringOption_(extraParamsXmlStringOption_in)
109 ,paramsUsedXmlOutFileNameOption_(paramsUsedXmlOutFileNameOption_in)
110 ,enableDelayedSolverConstruction_(EnableDelayedSolverConstruction_default)
111{
112 this->initializeDefaults();
113}
114
115
116template<class Scalar>
118{
119#ifdef TEUCHOS_DEBUG
120 // Validate that we read the parameters correctly!
121 if (nonnull(paramList_)) {
122 paramList_->validateParameters(*this->getValidParameters());
123 }
124#endif
125}
126
127
128template<class Scalar>
130 const RCP<const AbstractFactory<Thyra::LinearOpWithSolveFactoryBase<Scalar> > >
131 &solveStrategyFactory,
132 const std::string &solveStrategyName,
133 const bool makeDefault
134 )
135{
136 validLowsfNames_.push_back(solveStrategyName);
137 lowsfArray_.push_back(solveStrategyFactory);
138 validParamList_ = Teuchos::null;
139 if (makeDefault) {
140 setDefaultLinearSolveStrategyFactoryName(solveStrategyName);
141 }
142}
143
144
145template<class Scalar>
147 const std::string &solveStrategyName)
148{
149 defaultLOWSF_ = solveStrategyName;
150}
151
152
153template<class Scalar>
155 const RCP<const AbstractFactory<Thyra::PreconditionerFactoryBase<Scalar> > >
156 &precStrategyFactory,
157 const std::string &precStrategyName,
158 const bool makeDefault
159 )
160{
161 validPfNames_.push_back(precStrategyName);
162 pfArray_.push_back(precStrategyFactory);
163 validParamList_ = Teuchos::null;
164 if (makeDefault) {
165 setDefaultPreconditioningStrategyFactoryName(precStrategyName);
166 }
167}
168
169
170template<class Scalar>
172 const std::string &precStrategyName)
173{
174 defaultPF_ = precStrategyName;
175}
176
177
178template<class Scalar>
179void LinearSolverBuilder<Scalar>::setupCLP( Teuchos::CommandLineProcessor *clp )
180{
181 TEUCHOS_TEST_FOR_EXCEPT(clp==NULL);
182 clp->setOption(
183 paramsXmlFileNameOption().c_str(),&paramsXmlFileName_
184 ,"Name of an XML file containing parameters for linear solver "
185 "options to be appended first."
186 );
187 clp->setOption(
188 extraParamsXmlStringOption().c_str(),&extraParamsXmlString_
189 ,"An XML string containing linear solver parameters to be appended second."
190 );
191 clp->setOption(
192 paramsUsedXmlOutFileNameOption().c_str(),&paramsUsedXmlOutFileName_
193 ,"Name of an XML file that can be written with the parameter list after it "
194 "has been used on completion of this program."
195 );
196}
197
198
199template<class Scalar>
201{
202 using Teuchos::parameterList;
203 using Teuchos::ptr;
204 using Teuchos::updateParametersFromXmlFile;
205 using Teuchos::updateParametersFromXmlString;
206 using std::endl;
207
208 if (!paramList_.get()) {
209 paramList_ = parameterList("LinearSolverBuilder");
210 }
211 if (paramsXmlFileName().length()) {
212 if (out) {
213 *out << endl << "Reading parameters from XML file \""
214 << paramsXmlFileName() << "\" ..." << endl;
215 }
216 updateParametersFromXmlFile (paramsXmlFileName (), paramList_.ptr());
217 }
218 if (extraParamsXmlString().length()) {
219 if (out) {
220 *out << endl << "Appending extra parameters from the XML string \""
221 << extraParamsXmlString() << "\" ..." << endl;
222 }
223 updateParametersFromXmlString (extraParamsXmlString (), paramList_.ptr());
224 }
225 setParameterList(paramList_);
226}
227
228
229template<class Scalar>
231 const Thyra::LinearOpWithSolveFactoryBase<Scalar> &/* lowsFactory */,
232 const std::string &outputXmlFileName
233 ) const
234{
235 justInTimeInitialize();
236 const std::string xmlOutputFile =
237 ( outputXmlFileName.length() ? outputXmlFileName : paramsUsedXmlOutFileName() );
238 if (xmlOutputFile.length()) {
239 Teuchos::writeParameterListToXmlFile(*paramList_, xmlOutputFile);
240 }
241}
242
243
244template<class Scalar>
245std::string
247{
248 justInTimeInitialize();
249 return lowsfValidator_->getStringValue(*paramList_, LinearSolverType_name,
250 defaultLOWSF_);
251}
252
253
254template<class Scalar>
255std::string
257{
258 justInTimeInitialize();
259 return pfValidator_->getStringValue(*paramList_, PreconditionerType_name,
260 defaultPF_);
261}
262
263
264// Overridden from ParameterListAcceptor
265
266
267template<class Scalar>
269 RCP<Teuchos::ParameterList> const& paramList
270 )
271{
272 TEUCHOS_TEST_FOR_EXCEPT(is_null(paramList));
273 paramList->validateParameters(*this->getValidParameters());
274 paramList_ = paramList;
275 enableDelayedSolverConstruction_ = paramList_->get(
276 EnableDelayedSolverConstruction_name, EnableDelayedSolverConstruction_default );
277}
278
279
280template<class Scalar>
281RCP<Teuchos::ParameterList>
283{
284 return paramList_;
285}
286
287
288template<class Scalar>
289RCP<Teuchos::ParameterList>
291{
292 RCP<Teuchos::ParameterList> _paramList = paramList_;
293 paramList_ = Teuchos::null;
294 return _paramList;
295}
296
297
298template<class Scalar>
299RCP<const Teuchos::ParameterList>
301{
302 return paramList_;
303}
304
305
306template<class Scalar>
307RCP<const Teuchos::ParameterList>
309{
310 using Teuchos::rcp_implicit_cast;
311 typedef Teuchos::ParameterEntryValidator PEV;
312 if (is_null(validParamList_)) {
313 RCP<Teuchos::ParameterList>
314 validParamList = Teuchos::rcp(new Teuchos::ParameterList);
315 // Linear Solver Types
316 lowsfValidator_ = Teuchos::rcp(
317 new Teuchos::StringToIntegralParameterEntryValidator<int>(
318 validLowsfNames_,LinearSolverType_name
319 )
320 );
321 validParamList->set(
322 LinearSolverType_name, defaultLOWSF_,
323 (std::string("Determines the type of linear solver that will be used.\n")
324 + "The parameters for each solver type are specified in the sublist \""
325 + LinearSolverTypes_name + "\"").c_str(),
326 rcp_implicit_cast<const PEV>(lowsfValidator_)
327 );
328 Teuchos::ParameterList &linearSolverTypesSL = validParamList->sublist(
329 LinearSolverTypes_name,false,
330 "Sublists for each of the linear solver types set using the parameter\n"
331 "\"" + LinearSolverType_name + "\". Note that the options for each\n"
332 "linear solver type given below will only be used if linear solvers\n"
333 "of that type are created. It is fine to list parameter sublists for\n"
334 "linear solver types that are not used."
335 );
336 for( int i = 0; i < static_cast<int>(lowsfArray_.size()); ++i ) {
337 const std::string
338 &lsname = validLowsfNames_[i];
339 const RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
340 lowsf = lowsfArray_[i]->create();
341 linearSolverTypesSL.sublist(lsname).setParameters(*lowsf->getValidParameters()
342 ).disableRecursiveValidation();
343 }
344 // Preconditioner Type
345 pfValidator_ = Teuchos::rcp(
346 new Teuchos::StringToIntegralParameterEntryValidator<int>(
347 validPfNames_, PreconditionerType_name ) );
348 validParamList->set(
349 PreconditionerType_name, defaultPF_,
350 (std::string("Determines the type of preconditioner that will be used.\n")
351 + "This option is only meaningful for linear solvers that accept preconditioner"
352 + " factory objects!\n"
353 + "The parameters for each preconditioner are specified in the sublist \""
354 + PreconditionerTypes_name + "\"").c_str(),
355 rcp_implicit_cast<const PEV>(pfValidator_)
356 );
357 Teuchos::ParameterList &precTypesSL = validParamList->sublist(
358 PreconditionerTypes_name,false,
359 "Sublists for each of the preconditioner types set using the parameter\n"
360 "\"" + PreconditionerType_name + "\". Note that the options for each\n"
361 "preconditioner type given below will only be used if preconditioners\n"
362 "of that type are created. It is fine to list parameter sublists for\n"
363 "preconditioner types that are not used."
364 );
365 for( int i = 0; i < static_cast<int>(pfArray_.size()); ++i ) {
366 const std::string
367 &pfname = validPfNames_[i+1]; // "None" is the 0th entry!
368 const RCP<Thyra::PreconditionerFactoryBase<Scalar> >
369 pf = pfArray_[i]->create();
370 precTypesSL.sublist(pfname).setParameters(*pf->getValidParameters()
371 ).disableRecursiveValidation();
372 }
373 //
374 validParamList->set(
375 EnableDelayedSolverConstruction_name, EnableDelayedSolverConstruction_default,
376 "When this option is set to true, the linear solver factory will be wrapped\n"
377 "in a delayed evaluation Decorator factory object. This results in a delay\n"
378 "in the creation of a linear solver (and the associated preconditioner) until\n"
379 "the first solve is actually performed. This helps in cases where it is not\n"
380 "known a-priori if a linear solve will be needed on a given linear operator and\n"
381 "therefore can significantly improve performance for some types of algorithms\n"
382 "such as NOX and LOCA."
383 );
384 //
385 validParamList_ = validParamList;
386 }
387 return validParamList_;
388}
389
390
391// Overridden from LinearSolverBuilderBase.
392
393
394template<class Scalar>
395RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
397 const std::string &linearSolveStrategyName
398 ) const
399{
400 justInTimeInitialize();
401
402 // Get the name of the linear solve strategy
403#ifdef THYRA_DEFAULT_REAL_LINEAR_SOLVER_BUILDER_DUMP
404 std::cout << "\nEntering LinearSolverBuilder"
405 << "::createLinearSolveStrategy(...) ...\n";
406 std::cout << "\nlinearSolveStrategyName = \""
407 << linearSolveStrategyName << "\"\n";
408 std::cout << "\nlinearSolveStrategyName.length() = "
409 << linearSolveStrategyName.length() << "\n";
410 std::cout << "\ndefaultLOWSF_ = \"" << defaultLOWSF_ << "\"\n";
411 std::cout << "\nthis->getLinearSolveStrategyName() = \""
412 << this->getLinearSolveStrategyName() << "\"\n";
413#endif
414 const std::string
415 lsname = ( linearSolveStrategyName.length()
416 ? linearSolveStrategyName
417 : this->getLinearSolveStrategyName() );
418#ifdef THYRA_DEFAULT_REAL_LINEAR_SOLVER_BUILDER_DUMP
419 std::cout << "\nlsname = \"" << lsname << "\"\n";
420#endif
421
422 // Get the index of this linear solver strategy (this will validate!)
423 const int
424 ls_idx = lowsfValidator_->getIntegralValue(lsname, LinearSolverType_name);
425
426 // Create the uninitialized LOWSFB object
427 RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
428 lowsf = lowsfArray_[ls_idx]->create();
429
430 // First, set the preconditioner factory and its parameters
431 if(lowsf->acceptsPreconditionerFactory()) {
432 const std::string &pfName = this->getPreconditionerStrategyName();
433 RCP<Thyra::PreconditionerFactoryBase<Scalar> >
434 pf = this->createPreconditioningStrategy(pfName);
435 if(pf.get())
436 lowsf->setPreconditionerFactory(pf,pfName);
437 }
438
439 // Now set the parameters for the linear solver (some of which might
440 // override some preconditioner factory parameters).
441 lowsf->setParameterList(
442 sublist(sublist(paramList_, LinearSolverTypes_name), lsname));
443 //
444 if (enableDelayedSolverConstruction_) {
445 return Teuchos::rcp(
446 new Thyra::DelayedLinearOpWithSolveFactory<Scalar>(lowsf)
447 );
448 }
449
450 return lowsf;
451
452}
453
454
455template<class Scalar>
456RCP<Thyra::PreconditionerFactoryBase<Scalar> >
458 const std::string &preconditioningStrategyName
459 ) const
460{
461 justInTimeInitialize();
462
463 // Get the name of the preconditioning strategy
464 const std::string
465 pfname = ( preconditioningStrategyName.length()
466 ? preconditioningStrategyName
467 : this->getPreconditionerStrategyName() );
468 RCP<Thyra::PreconditionerFactoryBase<Scalar> >
469 pf = Teuchos::null;
470
471 // Get the index of this preconditioning strategy (this will validate!)
472 const int
473 pf_idx = pfValidator_->getIntegralValue(pfname, PreconditionerType_name);
474 if( pf_idx != 0 ) {
475 pf = pfArray_[pf_idx-1]->create(); // We offset by -1 since "None" is first!
476 pf->setParameterList(
477 sublist(sublist(paramList_, PreconditionerTypes_name), pfname));
478 }
479
480 return pf;
481
482}
483
484
485// private
486
487template<class Scalar>
489{
490
491 using Teuchos::rcp;
492 using Teuchos::abstractFactoryStd;
493
494 defaultLOWSF_ = "";
495 defaultPF_ = None_name;
496 validLowsfNames_.resize(0);
497 validPfNames_.resize(0);
498 validPfNames_.push_back(None_name); // This will offset everything!
499
500 //
501 // Linear Solvers
502 //
503
504#ifdef HAVE_STRATIMIKOS_AMESOS2
505 setLinearSolveStrategyFactory(
506 abstractFactoryStd<Thyra::LinearOpWithSolveFactoryBase<Scalar>,
508 "Amesos2", true
509 );
510#endif
511
512#ifdef HAVE_STRATIMIKOS_BELOS
513 setLinearSolveStrategyFactory(
514 abstractFactoryStd<Thyra::LinearOpWithSolveFactoryBase<Scalar>,
516 "Belos", true
517 );
518#endif
519
520 // Note: Above, the last PF object set will be the default!
521
522}
523
524template<>
526{
527 using Scalar = double;
528 using Teuchos::rcp;
529 using Teuchos::abstractFactoryStd;
530
531 defaultLOWSF_ = "";
532 defaultPF_ = None_name;
533 validLowsfNames_.resize(0);
534 validPfNames_.resize(0);
535 validPfNames_.push_back(None_name); // This will offset everything!
536
537 //
538 // Linear Solvers
539 //
540
541#ifdef HAVE_STRATIMIKOS_AMESOS2
542 setLinearSolveStrategyFactory(
543 abstractFactoryStd<Thyra::LinearOpWithSolveFactoryBase<Scalar>,
545 "Amesos2", true
546 );
547#endif
548
549#ifdef HAVE_STRATIMIKOS_BELOS
550 setLinearSolveStrategyFactory(
551 abstractFactoryStd<Thyra::LinearOpWithSolveFactoryBase<Scalar>,
553 "Belos", true
554 );
555#endif
556
557#ifdef HAVE_STRATIMIKOS_AMESOS
558 setLinearSolveStrategyFactory(
559 abstractFactoryStd<Thyra::LinearOpWithSolveFactoryBase<Scalar>,
561 "Amesos", true
562 );
563#endif
564
565#if defined(HAVE_STRATIMIKOS_EPETRAEXT) && defined(HAVE_STRATIMIKOS_AZTECOO)
566 setLinearSolveStrategyFactory(
567 abstractFactoryStd<Thyra::LinearOpWithSolveFactoryBase<Scalar>,
569 "AztecOO", true
570 );
571#endif
572
573 // Note: Above, the last LOWSF object set will be the default!
574 // (unless we have only one processor, see below:)
575
576#ifdef HAVE_STRATIMIKOS_AMESOS
577 if (Teuchos::GlobalMPISession::getNProc() == 1) {
578 setDefaultLinearSolveStrategyFactoryName("Amesos");
579 }
580#endif
581
582 //
583 // Preconditioners
584 //
585
586#ifdef HAVE_STRATIMIKOS_ML
587 setPreconditioningStrategyFactory(
588 abstractFactoryStd<Thyra::PreconditionerFactoryBase<Scalar>,
590 "ML", true
591 );
592#endif
593
594#ifdef HAVE_STRATIMIKOS_IFPACK
595 setPreconditioningStrategyFactory(
596 abstractFactoryStd<Thyra::PreconditionerFactoryBase<Scalar>,
598 "Ifpack", true
599 );
600#endif
601
602 // Note: Above, the last PF object set will be the default!
603
604}
605
606template<class Scalar>
608{
609 paramList_.assert_not_null();
610 if (is_null(validParamList_)) {
611 // Create the validators
612 this->getValidParameters();
613 }
614}
615
616
617//
618// Explicit instantiation macro
619//
620// Must be expanded from within the Stratimikos namespace!
621//
622
623
624#define STRATIMIKOS_LINEARSOLVERBUILDER_INSTANT(SCALAR) \
625 \
626 template class LinearSolverBuilder<SCALAR >;
627
628
629
630} // namespace Stratimikos
631
632#endif // STRATIMIKOS_LINEARSOLVERBUILDER_DEF_HPP
Concrete subclass of Thyra::LinearSolverBuilderBase for creating LinearOpWithSolveFactoryBase objects...
void setLinearSolveStrategyFactory(const RCP< const AbstractFactory< Thyra::LinearOpWithSolveFactoryBase< Scalar > > > &solveStrategyFactory, const std::string &solveStrategyName, const bool makeDefault=false)
Set a new linear solver strategy factory object.
RCP< Thyra::PreconditionerFactoryBase< Scalar > > createPreconditioningStrategy(const std::string &preconditioningStrategyName) const
RCP< const ParameterList > getParameterList() const
std::string getLinearSolveStrategyName() const
Get the name of the linear solver strategy that will be created on the next call to this->createLinea...
void setDefaultPreconditioningStrategyFactoryName(const std::string &precStrategyName)
Set the default linear solver factory name.
RCP< const ParameterList > getValidParameters() const
RCP< Thyra::LinearOpWithSolveFactoryBase< Scalar > > createLinearSolveStrategy(const std::string &linearSolveStrategyName) const
std::string getPreconditionerStrategyName() const
Get the name of the preconditioner strategy that will be created on the next call to this->createPrec...
void setParameterList(RCP< ParameterList > const &paramList)
LinearSolverBuilder(const std::string &paramsXmlFileName="", const std::string &extraParamsXmlString="", const std::string &paramsUsedXmlOutFileName="", const std::string &paramsXmlFileNameOption="linear-solver-params-file", const std::string &extraParamsXmlStringOption="extra-linear-solver-params", const std::string &paramsUsedXmlOutFileNameOption="linear-solver-params-used-file")
Construct with default parameters.
void setDefaultLinearSolveStrategyFactoryName(const std::string &solveStrategyName)
Set the default linear solver factory name.
void setupCLP(Teuchos::CommandLineProcessor *clp)
Setup the command-line processor to read in the needed data to extra the parameters from.
void readParameters(std::ostream *out)
Force the parameters to be read from a file and/or an extra XML string.
void setPreconditioningStrategyFactory(const RCP< const AbstractFactory< Thyra::PreconditionerFactoryBase< Scalar > > > &precStrategyFactory, const std::string &precStrategyName, const bool makeDefault=false)
Set a new preconditioner strategy factory object.
void writeParamsFile(const Thyra::LinearOpWithSolveFactoryBase< Scalar > &lowsFactory, const std::string &outputXmlFileName="") const
Write the parameters list for a LinearOpWithSolveFactoryBase object to a file after the parameters ar...
Concrete LinearOpWithSolveFactoryBase adapter subclass that uses Amesos direct solvers.
LinearOpWithSolveFactoryBase subclass implemented in terms of AztecOO.
LinearOpWithSolveFactoryBase subclass implemented in terms of Belos.
Concrete preconditioner factory subclass based on Ifpack.
Concrete preconditioner factory subclass based on ML.