Anasazi Version of the Day
Loading...
Searching...
No Matches
AnasaziFactory.hpp
Go to the documentation of this file.
1// @HEADER
2// *****************************************************************************
3// Anasazi: Block Eigensolvers Package
4//
5// Copyright 2004 NTESS and the Anasazi contributors.
6// SPDX-License-Identifier: BSD-3-Clause
7// *****************************************************************************
8// @HEADER
9
10#ifndef ANASAZI_FACTORY_HPP
11#define ANASAZI_FACTORY_HPP
12
17#include "AnasaziConfigDefs.hpp"
18
19#include "AnasaziBasicEigenproblem.hpp"
20#include "AnasaziBlockDavidsonSolMgr.hpp"
21#include "AnasaziBlockKrylovSchurSolMgr.hpp"
22#include "AnasaziGeneralizedDavidsonSolMgr.hpp"
23#include "AnasaziLOBPCGSolMgr.hpp"
24#include "AnasaziRTRSolMgr.hpp"
25#include "AnasaziSimpleLOBPCGSolMgr.hpp"
26#include "AnasaziTraceMinDavidsonSolMgr.hpp"
27#include "AnasaziTraceMinSolMgr.hpp"
28
29#include <algorithm>
30#include <string>
31
37namespace Anasazi {
38
39class Factory {
40public:
41
53 template<class ScalarType, class MV, class OP>
54 static
55 Teuchos::RCP<SolverManager<ScalarType,MV,OP> >
56 create ( const std::string& solverType,
57 const Teuchos::RCP<Eigenproblem<ScalarType,MV,OP> > problem,
58 Teuchos::ParameterList &pl ) {
59 using Teuchos::rcp;
60
61 std::string type = solverType;
62 std::transform(type.begin(), type.end(), type.begin(), ::tolower);
63
64 if (type == "block_davidson" || type == "block davidson")
65 return rcp(new BlockDavidsonSolMgr<ScalarType,MV,OP>(problem, pl));
66
67 else if (type == "block_krylov_schur" || type == "block krylov schur")
68 return rcp(new BlockKrylovSchurSolMgr<ScalarType,MV,OP>(problem, pl));
69
70 else if (type == "lobpcg")
71 return rcp(new LOBPCGSolMgr<ScalarType,MV,OP>(problem, pl));
72
73 else if (type == "rtr")
74 return rcp(new RTRSolMgr<ScalarType,MV,OP>(problem, pl));
75
76 else if (type == "simple_lobpcg" || type == "simple lobpcg")
77 return rcp(new SimpleLOBPCGSolMgr<ScalarType,MV,OP>(problem, pl));
78
79 else
80 TEUCHOS_TEST_FOR_EXCEPTION(true, std::invalid_argument,
81 "Anasazi::Factory::create: Invalid solver type \"" << solverType << "\".");
82
83 return Teuchos::null;
84 }
85
86 template<class MV, class OP>
87 static
88 Teuchos::RCP<SolverManager<double,MV,OP> >
89 create ( const std::string& solverType,
90 const Teuchos::RCP<Eigenproblem<double,MV,OP> > problem,
91 Teuchos::ParameterList &pl ) {
92 using Teuchos::rcp;
93 using ScalarType = double;
94
95 std::string type = solverType;
96 std::transform(type.begin(), type.end(), type.begin(), ::tolower);
97
98 if (type == "block_davidson" || type == "block davidson")
99 return rcp(new BlockDavidsonSolMgr<ScalarType,MV,OP>(problem, pl));
100
101 else if (type == "block_krylov_schur" || type == "block krylov schur")
102 return rcp(new BlockKrylovSchurSolMgr<ScalarType,MV,OP>(problem, pl));
103
104 else if (type == "generalized_davidson" || type == "generalized davidson")
105 return rcp(new GeneralizedDavidsonSolMgr<ScalarType,MV,OP>(problem, pl));
106
107 else if (type == "lobpcg")
108 return rcp(new LOBPCGSolMgr<ScalarType,MV,OP>(problem, pl));
109
110 else if (type == "rtr")
111 return rcp(new RTRSolMgr<ScalarType,MV,OP>(problem, pl));
112
113 else if (type == "simple_lobpcg" || type == "simple lobpcg")
114 return rcp(new SimpleLOBPCGSolMgr<ScalarType,MV,OP>(problem, pl));
115
116 else if (type == "TRACE_MIN" || type == "trace min")
117 return rcp(new Experimental::TraceMinSolMgr<ScalarType,MV,OP>(problem, pl));
118
119 else if (type == "trace_min_davidson" || type == "trace min davidson")
120 return rcp(new Experimental::TraceMinDavidsonSolMgr<ScalarType,MV,OP>(problem, pl));
121
122 else
123 TEUCHOS_TEST_FOR_EXCEPTION( true, std::invalid_argument,
124 "Anasazi::Factory::create: Invalid solverType type \"" << solverType << "\".");
125
126 return Teuchos::null;
127 }
128
130 template<class ScalarType, class MV, class OP>
131 static
132 Teuchos::RCP<SolverManager<ScalarType,MV,OP> >
133 create ( const std::string& solverType,
134 const Teuchos::RCP<BasicEigenproblem<ScalarType,MV,OP> > &problem,
135 Teuchos::ParameterList &pl ) {
136 Teuchos::RCP<Eigenproblem<ScalarType,MV,OP>> eproblem =
137 Teuchos::rcp_static_cast<Eigenproblem<ScalarType,MV,OP>>(problem);
138 return create(solverType, eproblem, pl);
139 }
140};
141
142
143} // end Anasazi namespace
144
145#endif /* ANASAZI_FACTORY_HPP */
146
AnasaziBasicEigenproblem.hpp
Basic implementation of the Anasazi::Eigenproblem class.
AnasaziBlockDavidsonSolMgr.hpp
The Anasazi::BlockDavidsonSolMgr provides a solver manager for the BlockDavidson eigensolver.
AnasaziBlockKrylovSchurSolMgr.hpp
The Anasazi::BlockKrylovSchurSolMgr class provides a user interface for the block Krylov-Schur eigens...
AnasaziConfigDefs.hpp
Anasazi header file which uses auto-configuration information to include necessary C++ headers.
AnasaziGeneralizedDavidsonSolMgr.hpp
The Anasazi::GeneralizedDavidsonSolMgr provides a solver manager for the GeneralizedDavidson eigensol...
AnasaziLOBPCGSolMgr.hpp
The Anasazi::LOBPCGSolMgr provides a powerful solver manager for the LOBPCG eigensolver.
AnasaziRTRSolMgr.hpp
The Anasazi::RTRSolMgr provides a simple solver manager over the IRTR eigensolvers.
AnasaziSimpleLOBPCGSolMgr.hpp
The Anasazi::SimpleLOBPCGSolMgr provides a simple solver manager over the LOBPCG eigensolver.
AnasaziTraceMinDavidsonSolMgr.hpp
The Anasazi::TraceMinDavidsonSolMgr provides a solver manager for the TraceMinDavidson eigensolver wi...
AnasaziTraceMinSolMgr.hpp
The Anasazi::TraceMinSolMgr provides a solver manager for the TraceMin eigensolver with a constant su...
Anasazi::BasicEigenproblem
This provides a basic implementation for defining standard or generalized eigenvalue problems.
Definition AnasaziBasicEigenproblem.hpp:29
Anasazi::BlockDavidsonSolMgr
The BlockDavidsonSolMgr provides a powerful solver manager over the BlockDavidson eigensolver.
Definition AnasaziBlockDavidsonSolMgr.hpp:89
Anasazi::BlockKrylovSchurSolMgr
The Anasazi::BlockKrylovSchurSolMgr provides a flexible solver manager over the BlockKrylovSchur eige...
Definition AnasaziBlockKrylovSchurSolMgr.hpp:125
Anasazi::Eigenproblem
This class defines the interface required by an eigensolver and status test class to compute solution...
Definition AnasaziEigenproblem.hpp:32
Anasazi::Experimental::TraceMinDavidsonSolMgr
The Anasazi::TraceMinDavidsonSolMgr provides a flexible solver manager over the TraceMinDavidson eige...
Definition AnasaziTraceMinDavidsonSolMgr.hpp:78
Anasazi::Experimental::TraceMinSolMgr
The Anasazi::TraceMinSolMgr provides a flexible solver manager over the TraceMin eigensolver.
Definition AnasaziTraceMinSolMgr.hpp:77
Anasazi::Factory
This provides a factory to build Anasazi solvers using parameter lists.
Definition AnasaziFactory.hpp:39
Anasazi::Factory::create
static Teuchos::RCP< SolverManager< ScalarType, MV, OP > > create(const std::string &solverType, const Teuchos::RCP< Eigenproblem< ScalarType, MV, OP > > problem, Teuchos::ParameterList &pl)
Create an instance of Anasazi::SolverManager given the string name of the solver type.
Definition AnasaziFactory.hpp:56
Anasazi::Factory::create
static Teuchos::RCP< SolverManager< ScalarType, MV, OP > > create(const std::string &solverType, const Teuchos::RCP< BasicEigenproblem< ScalarType, MV, OP > > &problem, Teuchos::ParameterList &pl)
Specialize create for BasicEigenproblem type.
Definition AnasaziFactory.hpp:133
Anasazi::GeneralizedDavidsonSolMgr
Solver Manager for GeneralizedDavidson.
Definition AnasaziGeneralizedDavidsonSolMgr.hpp:61
Anasazi::LOBPCGSolMgr
User interface for the LOBPCG eigensolver.
Definition AnasaziLOBPCGSolMgr.hpp:142
Anasazi::RTRSolMgr
The Anasazi::RTRSolMgr provides a simple solver manager over the RTR eigensolver. For more informatio...
Definition AnasaziRTRSolMgr.hpp:52
Anasazi::SimpleLOBPCGSolMgr
The Anasazi::SimpleLOBPCGSolMgr provides a simple solver manager over the LOBPCG eigensolver.
Definition AnasaziSimpleLOBPCGSolMgr.hpp:73
Anasazi
Namespace Anasazi contains the classes, structs, enums and utilities used by the Anasazi package.
Generated by doxygen 1.9.8