Anasazi  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Groups Pages
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 
37 namespace Anasazi {
38 
39 class Factory {
40 public:
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 
Anasazi::Eigenproblem
This class defines the interface required by an eigensolver and status test class to compute solution...
Definition: AnasaziEigenproblem.hpp:32
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
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::RTRSolMgr
The Anasazi::RTRSolMgr provides a simple solver manager over the RTR eigensolver. For more informatio...
Definition: AnasaziRTRSolMgr.hpp:52
AnasaziTraceMinSolMgr.hpp
The Anasazi::TraceMinSolMgr provides a solver manager for the TraceMin eigensolver with a constant su...
AnasaziLOBPCGSolMgr.hpp
The Anasazi::LOBPCGSolMgr provides a powerful solver manager for the LOBPCG eigensolver.
Anasazi::BlockKrylovSchurSolMgr
The Anasazi::BlockKrylovSchurSolMgr provides a flexible solver manager over the BlockKrylovSchur eige...
Definition: AnasaziBlockKrylovSchurSolMgr.hpp:125
AnasaziBlockDavidsonSolMgr.hpp
The Anasazi::BlockDavidsonSolMgr provides a solver manager for the BlockDavidson eigensolver.
AnasaziBasicEigenproblem.hpp
Basic implementation of the Anasazi::Eigenproblem class.
AnasaziGeneralizedDavidsonSolMgr.hpp
The Anasazi::GeneralizedDavidsonSolMgr provides a solver manager for the GeneralizedDavidson eigensol...
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Anasazi::SimpleLOBPCGSolMgr
The Anasazi::SimpleLOBPCGSolMgr provides a simple solver manager over the LOBPCG eigensolver.
Definition: AnasaziSimpleLOBPCGSolMgr.hpp:73
AnasaziConfigDefs.hpp
Anasazi header file which uses auto-configuration information to include necessary C++ headers...
Anasazi::Experimental::TraceMinSolMgr
The Anasazi::TraceMinSolMgr provides a flexible solver manager over the TraceMin eigensolver.
Definition: AnasaziTraceMinSolMgr.hpp:81
AnasaziSimpleLOBPCGSolMgr.hpp
The Anasazi::SimpleLOBPCGSolMgr provides a simple solver manager over the LOBPCG eigensolver.
Anasazi::Experimental::TraceMinDavidsonSolMgr
The Anasazi::TraceMinDavidsonSolMgr provides a flexible solver manager over the TraceMinDavidson eige...
Definition: AnasaziTraceMinDavidsonSolMgr.hpp:78
AnasaziTraceMinDavidsonSolMgr.hpp
The Anasazi::TraceMinDavidsonSolMgr provides a solver manager for the TraceMinDavidson eigensolver wi...
Anasazi::BasicEigenproblem
This provides a basic implementation for defining standard or generalized eigenvalue problems...
Definition: AnasaziBasicEigenproblem.hpp:29
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
AnasaziRTRSolMgr.hpp
The Anasazi::RTRSolMgr provides a simple solver manager over the IRTR eigensolvers.
Anasazi::BlockDavidsonSolMgr
The BlockDavidsonSolMgr provides a powerful solver manager over the BlockDavidson eigensolver...
Definition: AnasaziBlockDavidsonSolMgr.hpp:89
AnasaziBlockKrylovSchurSolMgr.hpp
The Anasazi::BlockKrylovSchurSolMgr class provides a user interface for the block Krylov-Schur eigens...
Anasazi::GeneralizedDavidsonSolMgr
Solver Manager for GeneralizedDavidson.
Definition: AnasaziGeneralizedDavidsonSolMgr.hpp:60
Anasazi::Factory
This provides a factory to build Anasazi solvers using parameter lists.
Definition: AnasaziFactory.hpp:39
Anasazi::LOBPCGSolMgr
User interface for the LOBPCG eigensolver.
Definition: AnasaziLOBPCGSolMgr.hpp:142
Generated on Fri Dec 20 2024 09:18:33 for Anasazi by   doxygen 1.8.5