46 #ifndef MUELU_FACTORYMANAGER_DEF_HPP
47 #define MUELU_FACTORYMANAGER_DEF_HPP
52 #include "MueLu_AmalgamationFactory.hpp"
53 #include "MueLu_CoalesceDropFactory.hpp"
54 #include "MueLu_CoarseMapFactory.hpp"
55 #include "MueLu_ConstraintFactory.hpp"
56 #include "MueLu_AggregateQualityEstimateFactory.hpp"
57 #include "MueLu_DirectSolver.hpp"
58 #include "MueLu_InitialBlockNumberFactory.hpp"
59 #include "MueLu_LineDetectionFactory.hpp"
62 #include "MueLu_NullspaceFactory.hpp"
63 #include "MueLu_PatternFactory.hpp"
64 #include "MueLu_RAPFactory.hpp"
65 #include "MueLu_RepartitionHeuristicFactory.hpp"
66 #include "MueLu_RepartitionFactory.hpp"
67 #include "MueLu_SaPFactory.hpp"
68 #include "MueLu_ScaledNullspaceFactory.hpp"
69 #include "MueLu_SmootherFactory.hpp"
70 #include "MueLu_TentativePFactory.hpp"
71 #include "MueLu_TransPFactory.hpp"
72 #include "MueLu_TrilinosSmoother.hpp"
73 #include "MueLu_UncoupledAggregationFactory.hpp"
74 #include "MueLu_StructuredAggregationFactory.hpp"
75 #include "MueLu_ZoltanInterface.hpp"
76 #include "MueLu_InterfaceMappingTransferFactory.hpp"
77 #include "MueLu_InterfaceAggregationFactory.hpp"
78 #include "MueLu_InverseApproximationFactory.hpp"
80 #include "MueLu_CoalesceDropFactory_kokkos.hpp"
81 #include "MueLu_TentativePFactory_kokkos.hpp"
87 #define MUELU_KOKKOS_FACTORY(varName, oldFactory, newFactory) \
88 (!useKokkos_) ? SetAndReturnDefaultFactory(varName, rcp(new oldFactory())) : SetAndReturnDefaultFactory(varName, rcp(new newFactory()));
90 template <
class Scalar,
class LocalOrdinal,
class GlobalOrdinal,
class Node>
92 factoryTable_[varName] = factory;
95 template <
class Scalar,
class LocalOrdinal,
class GlobalOrdinal,
class Node>
97 if (factoryTable_.count(varName)) {
99 return factoryTable_.find(varName)->second;
103 return GetDefaultFactory(varName);
106 template <
class Scalar,
class LocalOrdinal,
class GlobalOrdinal,
class Node>
108 return Teuchos::rcp_const_cast<
FactoryBase>(GetFactory(varName));
111 template <
class Scalar,
class LocalOrdinal,
class GlobalOrdinal,
class Node>
113 if (factoryTable_.count(varName))
return true;
117 template <
class Scalar,
class LocalOrdinal,
class GlobalOrdinal,
class Node>
119 if (defaultFactoryTable_.count(varName)) {
121 return defaultFactoryTable_.find(varName)->second;
125 if (varName ==
"A")
return SetAndReturnDefaultFactory(varName,
rcp(
new RAPFactory()));
127 if (varName ==
"RAP Pattern")
return GetFactory(
"A");
128 if (varName ==
"AP Pattern")
return GetFactory(
"A");
130 if (varName ==
"P") {
133 factory->
SetFactory(
"P", GetFactory(
"Ptent"));
134 return SetAndReturnDefaultFactory(varName, factory);
136 if (varName ==
"Nullspace") {
139 factory->
SetFactory(
"Nullspace", GetFactory(
"Ptent"));
140 return SetAndReturnDefaultFactory(varName, factory);
144 if (varName ==
"Coordinates")
return GetFactory(
"Ptent");
145 if (varName ==
"Node Comm")
return GetFactory(
"Ptent");
147 if (varName ==
"R")
return SetAndReturnDefaultFactory(varName,
rcp(
new TransPFactory()));
148 if (varName ==
"RfromPfactory")
return GetFactory(
"P");
149 #if defined(HAVE_MUELU_ZOLTAN) && defined(HAVE_MPI)
150 if (varName ==
"Partition")
return SetAndReturnDefaultFactory(varName,
rcp(
new ZoltanInterface()));
151 #endif // ifdef HAVE_MPI
153 if (varName ==
"Importer") {
160 if (varName ==
"number of partitions") {
167 if (varName ==
"repartition: heuristic target rows per process")
return GetFactory(
"number of partitions");
170 if (varName ==
"UnAmalgamationInfo")
return SetAndReturnDefaultFactory(varName,
rcp(
new AmalgamationFactory()));
173 if (varName ==
"CoarseMap")
return SetAndReturnDefaultFactory(varName,
rcp(
new CoarseMapFactory()));
174 if (varName ==
"DofsPerNode")
return GetFactory(
"Graph");
175 if (varName ==
"Filtering")
return GetFactory(
"Graph");
177 if (varName ==
"LineDetection_VertLineIds")
return SetAndReturnDefaultFactory(varName,
rcp(
new LineDetectionFactory()));
178 if (varName ==
"LineDetection_Layers")
return GetFactory(
"LineDetection_VertLineIds");
179 if (varName ==
"CoarseNumZLayers")
return GetFactory(
"LineDetection_VertLineIds");
185 if (varName ==
"K")
return GetFactory(
"A");
186 if (varName ==
"M")
return GetFactory(
"A");
187 if (varName ==
"Mdiag")
return GetFactory(
"A");
188 if (varName ==
"cfl-based shift array")
return GetFactory(
"A");
191 if (varName ==
"PreSmoother")
return GetFactory(
"Smoother");
192 if (varName ==
"PostSmoother")
return GetFactory(
"Smoother");
194 if (varName ==
"Ppattern") {
197 return SetAndReturnDefaultFactory(varName, PpFact);
199 if (varName ==
"Constraint")
return SetAndReturnDefaultFactory(varName,
rcp(
new ConstraintFactory()));
201 if (varName ==
"Smoother") {
203 smootherParamList.
set(
"relaxation: type",
"Symmetric Gauss-Seidel");
212 #ifdef HAVE_MUELU_INTREPID2
214 if (varName ==
"pcoarsen: element to node map")
return GetFactory(
"P");
226 template <
class Scalar,
class LocalOrdinal,
class GlobalOrdinal,
class Node>
230 GetOStream(
Runtime1) <<
"Using default factory (" << factory->
ShortClassName() <<
"[" << factory->
GetID() <<
"]) for building '" << varName <<
"'." << std::endl;
232 defaultFactoryTable_[varName] = factory;
234 return defaultFactoryTable_[varName];
237 template <
class Scalar,
class LocalOrdinal,
class GlobalOrdinal,
class Node>
239 std::map<std::string, RCP<const FactoryBase> >::const_iterator it;
243 fancy <<
"Users factory table (factoryTable_):" << std::endl;
244 for (it = factoryTable_.begin(); it != factoryTable_.end(); it++) {
245 fancy <<
" " << it->first <<
" -> ";
247 fancy <<
"NoFactory";
248 else if (!it->second.get())
251 fancy << it->second.get()->ShortClassName() <<
"[" << it->second.get()->GetID() <<
"]";
252 #ifdef HAVE_MUELU_DEBUG
259 fancy <<
"Default factory table (defaultFactoryTable_):" << std::endl;
260 for (it = defaultFactoryTable_.begin(); it != defaultFactoryTable_.end(); it++) {
261 fancy <<
" " << it->first <<
" -> ";
263 fancy <<
"NoFactory";
264 else if (!it->second.get())
267 fancy << it->second.get()->ShortClassName() <<
"[" << it->second.get()->GetID() <<
"]";
268 #ifdef HAVE_MUELU_DEBUG
276 #ifdef HAVE_MUELU_DEBUG
277 template <
class Scalar,
class LocalOrdinal,
class GlobalOrdinal,
class Node>
279 std::map<std::string, RCP<const FactoryBase> >::const_iterator it;
281 for (it = factoryTable_.begin(); it != factoryTable_.end(); it++)
282 if (!it->second.is_null())
283 it->second->ResetDebugData();
285 for (it = defaultFactoryTable_.begin(); it != defaultFactoryTable_.end(); it++)
286 if (!it->second.is_null())
287 it->second->ResetDebugData();
291 #undef MUELU_KOKKOS_FACTORY
300 #endif // MUELU_FACTORYMANAGER_DEF_HPP
Generic Smoother Factory for generating the smoothers of the MG hierarchy.
This class specifies the default factory that should generate some data on a Level if the data does n...
Factory for building aggregates on structured grids.
Factory for determing the number of partitions for rebalancing.
Factory for generating coarse level map. Used by TentativePFactory.
Class for generating an initial LocalOrdinal-type BlockNumber vector, based on an input paraemter for...
Class that encapsulates external library smoothers.
ParameterList & set(std::string const &name, T const &value, std::string const &docString="", RCP< const ParameterEntryValidator > const &validator=null)
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Factory for building permutation matrix that can be be used to shuffle data (matrices, vectors) among processes.
Print additional debugging information.
const RCP< const FactoryBase > GetDefaultFactory(const std::string &varName) const
int GetID() const
return unique factory id
bool hasFactory(const std::string &varName) const
Check.
Interface to Zoltan library.This interface provides access to partitioning methods in Zoltan...
const RCP< const FactoryBase > GetFactory(const std::string &varName) const
Get factory associated with a particular data name.
static const NoFactory * get()
Factory for building tentative prolongator.
Class that encapsulates direct solvers. Autoselection of AmesosSmoother or Amesos2Smoother according ...
virtual std::string ShortClassName() const
Return the class name of the object, without template parameters and without namespace.
const RCP< const FactoryBase > SetAndReturnDefaultFactory(const std::string &varName, const RCP< const FactoryBase > &factory) const
Base class for factories (e.g., R, P, and A_coarse).
Factory for building the approximate inverse of a matrix.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Factory for building line detection information.
Transfer mapping data for interface aggregation to the coarse level.
AmalgamationFactory for subblocks of strided map based amalgamation data.
Factory for building the constraint operator.
void SetFactory(const std::string &varName, const RCP< const FactoryBase > &factory)
Set Factory.
const RCP< FactoryBase > GetFactoryNonConst(const std::string &varName)
Get factory associated with a particular data name (NONCONST version)
Factory for generating a very special nullspace.
Factory for building aggregates for Lagrange multipliers in surface-coupled problems.
Factory for creating a graph based on a given matrix.
virtual void SetFactory(const std::string &varName, const RCP< const FactoryBase > &factory)=0
Configuration.
Factory for building nonzero patterns for energy minimization.
#define MUELU_KOKKOS_FACTORY(varName, oldFactory, newFactory)
Factory for building restriction operators.
Factory for creating a graph based on a given matrix.
Exception throws to report errors in the internal logical of the program.
Description of what is happening (more verbose)
Factory for building coarse matrices.
An factory which assigns each aggregate a quality estimate. Originally developed by Napov and Notay i...
Factory for building Smoothed Aggregation prolongators.Input/output of SaPFactory
Factory for building uncoupled aggregates.
std::string toString(const T &t)
Factory for generating nullspace.
static const RCP< const NoFactory > getRCP()
Static Get() functions.