MueLu  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MueLu_UseShortNamesOrdinal.hpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // MueLu: A package for multigrid based preconditioning
4 //
5 // Copyright 2012 NTESS and the MueLu contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 // Type definitions for templated classes (generally graph-related) that do not require a scalar.
11 
12 #include <Xpetra_UseShortNamesOrdinal.hpp>
13 
14 #ifdef MUELU_AGGREGATES_SHORT
15 using Aggregates [[maybe_unused]] = MueLu::Aggregates<LocalOrdinal, GlobalOrdinal, Node>;
16 #endif
17 #ifdef MUELU_AGGREGATIONPHASE1ALGORITHM_SHORT
18 using AggregationPhase1Algorithm [[maybe_unused]] = MueLu::AggregationPhase1Algorithm<LocalOrdinal, GlobalOrdinal, Node>;
19 #endif
20 #ifdef MUELU_AGGREGATIONPHASE2AALGORITHM_SHORT
21 using AggregationPhase2aAlgorithm [[maybe_unused]] = MueLu::AggregationPhase2aAlgorithm<LocalOrdinal, GlobalOrdinal, Node>;
22 #endif
23 #ifdef MUELU_AGGREGATIONPHASE2BALGORITHM_SHORT
24 using AggregationPhase2bAlgorithm [[maybe_unused]] = MueLu::AggregationPhase2bAlgorithm<LocalOrdinal, GlobalOrdinal, Node>;
25 #endif
26 #ifdef MUELU_AGGREGATIONPHASE3ALGORITHM_SHORT
27 using AggregationPhase3Algorithm [[maybe_unused]] = MueLu::AggregationPhase3Algorithm<LocalOrdinal, GlobalOrdinal, Node>;
28 #endif
29 #ifdef MUELU_AGGREGATIONSTRUCTUREDALGORITHM_SHORT
30 using AggregationStructuredAlgorithm [[maybe_unused]] = MueLu::AggregationStructuredAlgorithm<LocalOrdinal, GlobalOrdinal, Node>;
31 #endif
32 #ifdef MUELU_AMALGAMATIONINFO_SHORT
33 using AmalgamationInfo [[maybe_unused]] = MueLu::AmalgamationInfo<LocalOrdinal, GlobalOrdinal, Node>;
34 #endif
35 #ifdef MUELU_GLOBALLEXICOGRAPHICINDEXMANAGER_SHORT
36 using GlobalLexicographicIndexManager [[maybe_unused]] = MueLu::GlobalLexicographicIndexManager<LocalOrdinal, GlobalOrdinal, Node>;
37 #endif
38 #ifdef MUELU_HYBRIDAGGREGATIONFACTORY_SHORT
39 using HybridAggregationFactory [[maybe_unused]] = MueLu::HybridAggregationFactory<LocalOrdinal, GlobalOrdinal, Node>;
40 #endif
41 #ifdef MUELU_INDEXMANAGER_SHORT
42 using IndexManager [[maybe_unused]] = MueLu::IndexManager<LocalOrdinal, GlobalOrdinal, Node>;
43 #endif
44 #ifdef MUELU_INDEXMANAGER_KOKKOS_SHORT
45 using IndexManager_kokkos [[maybe_unused]] = MueLu::IndexManager_kokkos<LocalOrdinal, GlobalOrdinal, Node>;
46 #endif
47 #ifdef MUELU_INTERFACEAGGREGATIONALGORITHM_SHORT
48 using InterfaceAggregationAlgorithm [[maybe_unused]] = MueLu::InterfaceAggregationAlgorithm<LocalOrdinal, GlobalOrdinal, Node>;
49 #endif
50 #ifdef MUELU_INTERFACEMAPPINGTRANSFERFACTORY_SHORT
51 using InterfaceMappingTransferFactory [[maybe_unused]] = MueLu::InterfaceMappingTransferFactory<LocalOrdinal, GlobalOrdinal, Node>;
52 #endif
53 #ifdef MUELU_ISORROPIAINTERFACE_SHORT
54 using IsorropiaInterface [[maybe_unused]] = MueLu::IsorropiaInterface<LocalOrdinal, GlobalOrdinal, Node>;
55 #endif
56 #ifdef MUELU_LWGRAPH_SHORT
57 using LWGraph [[maybe_unused]] = MueLu::LWGraph<LocalOrdinal, GlobalOrdinal, Node>;
58 #endif
59 #ifdef MUELU_LWGRAPH_KOKKOS_SHORT
60 using LWGraph_kokkos [[maybe_unused]] = MueLu::LWGraph_kokkos<LocalOrdinal, GlobalOrdinal, Node>;
61 #endif
62 #ifdef MUELU_LOCALLEXICOGRAPHICINDEXMANAGER_SHORT
63 using LocalLexicographicIndexManager [[maybe_unused]] = MueLu::LocalLexicographicIndexManager<LocalOrdinal, GlobalOrdinal, Node>;
64 #endif
65 #ifdef MUELU_LOCALORDINALTRANSFERFACTORY_SHORT
66 using LocalOrdinalTransferFactory [[maybe_unused]] = MueLu::LocalOrdinalTransferFactory<LocalOrdinal, GlobalOrdinal, Node>;
67 #endif
68 #ifdef MUELU_ONEPTAGGREGATIONALGORITHM_SHORT
69 using OnePtAggregationAlgorithm [[maybe_unused]] = MueLu::OnePtAggregationAlgorithm<LocalOrdinal, GlobalOrdinal, Node>;
70 #endif
71 #ifdef MUELU_PRESERVEDIRICHLETAGGREGATIONALGORITHM_SHORT
72 using PreserveDirichletAggregationAlgorithm [[maybe_unused]] = MueLu::PreserveDirichletAggregationAlgorithm<LocalOrdinal, GlobalOrdinal, Node>;
73 #endif
74 #ifdef MUELU_PRFACTORY_SHORT
75 using PRFactory [[maybe_unused]] = MueLu::PRFactory<LocalOrdinal, GlobalOrdinal, Node>;
76 #endif
77 #ifdef MUELU_REBALANCEMAPFACTORY_SHORT
78 using RebalanceMapFactory [[maybe_unused]] = MueLu::RebalanceMapFactory<LocalOrdinal, GlobalOrdinal, Node>;
79 #endif
80 #ifdef MUELU_REPARTITIONINTERFACE_SHORT
81 using RepartitionInterface [[maybe_unused]] = MueLu::RepartitionInterface<LocalOrdinal, GlobalOrdinal, Node>;
82 #endif
83 #ifdef MUELU_STRUCTUREDAGGREGATIONFACTORY_KOKKOS_SHORT
84 using StructuredAggregationFactory_kokkos [[maybe_unused]] = MueLu::StructuredAggregationFactory_kokkos<LocalOrdinal, GlobalOrdinal, Node>;
85 #endif
86 #ifdef MUELU_UNCOUPLEDAGGREGATIONFACTORY_SHORT
87 using UncoupledAggregationFactory [[maybe_unused]] = MueLu::UncoupledAggregationFactory<LocalOrdinal, GlobalOrdinal, Node>;
88 #endif
89 #ifdef MUELU_UNCOUPLEDINDEXMANAGER_SHORT
90 using UncoupledIndexManager [[maybe_unused]] = MueLu::UncoupledIndexManager<LocalOrdinal, GlobalOrdinal, Node>;
91 #endif
92 #ifdef MUELU_USERAGGREGATIONFACTORY_SHORT
93 using UserAggregationFactory [[maybe_unused]] = MueLu::UserAggregationFactory<LocalOrdinal, GlobalOrdinal, Node>;
94 #endif
95 #ifdef MUELU_FACTORY_SHORT
96 using Factory [[maybe_unused]] = MueLu::Factory;
97 #endif
98 #ifdef MUELU_FACTORYBASE_SHORT
99 using FactoryBase [[maybe_unused]] = MueLu::FactoryBase;
100 #endif
101 #ifdef MUELU_FACTORYMANAGERBASE_SHORT
102 using FactoryManagerBase [[maybe_unused]] = MueLu::FactoryManagerBase;
103 #endif
104 #ifdef MUELU_LEVEL_SHORT
105 using Level [[maybe_unused]] = MueLu::Level;
106 #endif
107 #ifdef MUELU_PFACTORY_SHORT
108 using PFactory [[maybe_unused]] = MueLu::PFactory;
109 #endif
110 #ifdef MUELU_RFACTORY_SHORT
111 using RFactory [[maybe_unused]] = MueLu::RFactory;
112 #endif
113 #ifdef MUELU_SINGLELEVELFACTORYBASE_SHORT
114 using SingleLevelFactoryBase [[maybe_unused]] = MueLu::SingleLevelFactoryBase;
115 #endif
116 #ifdef MUELU_TWOLEVELFACTORYBASE_SHORT
117 using TwoLevelFactoryBase [[maybe_unused]] = MueLu::TwoLevelFactoryBase;
118 #endif
119 #ifdef MUELU_VARIABLECONTAINER_SHORT
120 using VariableContainer [[maybe_unused]] = MueLu::VariableContainer;
121 #endif
122 #ifdef MUELU_SMOOTHERFACTORYBASE_SHORT
123 using SmootherFactoryBase [[maybe_unused]] = MueLu::SmootherFactoryBase;
124 #endif
125 #ifdef MUELU_AMESOSSMOOTHER_SHORT
126 typedef MueLu::AmesosSmoother<Node> AmesosSmoother;
127 #endif
128 #ifdef MUELU_IFPACKSMOOTHER_SHORT
129 typedef MueLu::IfpackSmoother<Node> IfpackSmoother;
130 #endif
MueLu::OnePtAggregationAlgorithm
Algorithm for coarsening a graph with uncoupled aggregation. keep special marked nodes as singleton n...
Definition: MueLu_OnePtAggregationAlgorithm_decl.hpp:51
Xpetra_UseShortNamesOrdinal.hpp
MueLu::LWGraph_kokkos
Lightweight MueLu representation of a compressed row storage graph.
Definition: MueLu_LWGraph_kokkos_decl.hpp:30
MueLu::Aggregates
Container class for aggregation information.
Definition: MueLu_Aggregates_decl.hpp:69
MueLu::IsorropiaInterface
Interface to IsorropiaInterface to Isorropia allowing to access other rebalancing/repartitioning algo...
Definition: MueLu_IsorropiaInterface_decl.hpp:82
MueLu::AggregationStructuredAlgorithm
Algorithm for coarsening a graph with structured aggregation.
Definition: MueLu_AggregationStructuredAlgorithm_decl.hpp:48
MueLu::HybridAggregationFactory
Factory for building aggregates on meshes partly structured and partly unstructured.
Definition: MueLu_HybridAggregationFactory_decl.hpp:96
MueLu::LocalOrdinalTransferFactory
Class for transferring a vector of local ordinals from a finer level to a coarser one...
Definition: MueLu_LocalOrdinalTransferFactory_decl.hpp:60
MueLu::TwoLevelFactoryBase
Base class for factories that use two levels (fineLevel and coarseLevel).
Definition: MueLu_TwoLevelFactoryBase.hpp:31
MueLu::FactoryBase
Base class for factories (e.g., R, P, and A_coarse).
Definition: MueLu_FactoryBase.hpp:24
MueLu::InterfaceAggregationAlgorithm
Algorithm for coarsening a graph with uncoupled aggregation. creates aggregates along an interface us...
Definition: MueLu_InterfaceAggregationAlgorithm_decl.hpp:48
MueLu::PreserveDirichletAggregationAlgorithm
Builds one-to-one aggregates for all Dirichlet boundary nodes. For some applications this might be ne...
Definition: MueLu_PreserveDirichletAggregationAlgorithm_decl.hpp:49
MueLu::Level
Class that holds all level-specific information.
Definition: MueLu_Level.hpp:63
MueLu::FactoryManagerBase
Class that provides default factories within Needs class.
Definition: MueLu_FactoryManagerBase.hpp:27
MueLu::InterfaceMappingTransferFactory
Transfer mapping data for interface aggregation to the coarse level.
Definition: MueLu_InterfaceMappingTransferFactory_decl.hpp:43
MueLu::RebalanceMapFactory
Factory which rebalances a map on current level using the Importer object generated by the Repartitio...
Definition: MueLu_RebalanceMapFactory_decl.hpp:34
MueLu::AggregationPhase2aAlgorithm
Among unaggregated points, see if we can make a reasonable size aggregate out of it.IdeaAmong unaggregated points, see if we can make a reasonable size aggregate out of it. We do this by looking at neighbors and seeing how many are unaggregated and on my processor. Loosely, base the number of new aggregates created on the percentage of unaggregated nodes.
Definition: MueLu_AggregationPhase2aAlgorithm_decl.hpp:48
MueLu::RepartitionInterface
Helper class which transforms an &quot;AmalgamatedPartition&quot; array to an unamalgamated &quot;Partition&quot;...
Definition: MueLu_RepartitionInterface_decl.hpp:80
MueLu::AggregationPhase2bAlgorithm
Add leftovers to existing aggregatesIdeaIn phase 2b non-aggregated nodes are added to existing aggreg...
Definition: MueLu_AggregationPhase2bAlgorithm_decl.hpp:47
MueLu::LWGraph
Lightweight MueLu representation of a compressed row storage graph.
Definition: MueLu_LWGraph_decl.hpp:32
MueLu::AggregationPhase1Algorithm
Algorithm for coarsening a graph with uncoupled aggregation.
Definition: MueLu_AggregationPhase1Algorithm_decl.hpp:49
MueLu::IndexManager_kokkos
Container class for mesh layout and indices calculation.
Definition: MueLu_IndexManager_kokkos_decl.hpp:41
MueLu::VariableContainer
Class that stores all relevant data for a variable.
Definition: MueLu_VariableContainer.hpp:37
MueLu::PFactory
Factory that provides an interface for a concrete implementation of a prolongation operator...
Definition: MueLu_PFactory_decl.hpp:28
MueLu::AggregationPhase3Algorithm
Handle leftover nodes. Try to avoid singleton nodesIdeaIn phase 3 we try to stick unaggregated nodes ...
Definition: MueLu_AggregationPhase3Algorithm_decl.hpp:42
MueLu::StructuredAggregationFactory_kokkos
Factory for building structured aggregates or CrsGraph for interpolation base prolongator.
Definition: MueLu_StructuredAggregationFactory_kokkos_decl.hpp:73
MueLu::UncoupledAggregationFactory
Factory for building uncoupled aggregates.
Definition: MueLu_UncoupledAggregationFactory_decl.hpp:104
MueLu::AmalgamationInfo
minimal container class for storing amalgamation information
Definition: MueLu_AmalgamationInfo_decl.hpp:45
MueLu::SingleLevelFactoryBase
Base class for factories that use one level (currentLevel).
Definition: MueLu_SingleLevelFactoryBase.hpp:26
MueLu::IndexManager
Container class for mesh layout and indices calculation.
Definition: MueLu_IndexManager_decl.hpp:43
MueLu::IfpackSmoother
Class that encapsulates Ifpack smoothers.
Definition: MueLu_IfpackSmoother.hpp:41
MueLu::AmesosSmoother
Class that encapsulates Amesos direct solvers.
Definition: MueLu_AmesosSmoother.hpp:40