MueLu  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MueLu_Aggregates_decl.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 #ifndef MUELU_AGGREGATES_DECL_HPP
11 #define MUELU_AGGREGATES_DECL_HPP
12 
13 #include "MueLu_ConfigDefs.hpp"
14 
15 #include "MueLu_Aggregates_fwd.hpp"
16 
17 #include <Xpetra_Map_fwd.hpp>
18 #include <Xpetra_Vector_fwd.hpp>
21 
22 #include "MueLu_BaseClass.hpp"
23 
24 #include "MueLu_LWGraph_kokkos.hpp"
25 
26 #include "MueLu_LWGraph.hpp"
27 #include "MueLu_IndexManager.hpp"
28 #include "MueLu_IndexManager_kokkos.hpp"
29 
30 #define MUELU_UNAGGREGATED -1 /* indicates that a node is unassigned to */
31  /* any aggregate. */
32 
33 #define MUELU_UNASSIGNED -1 /* indicates a vertex is not yet claimed */
34  /* by a processor during aggregation. */
35  /* Note, it is possible at */
36  /* this stage that some processors may have*/
37  /* claimed their copy of a vertex for one */
38  /* of their aggregates. However, some */
39  /* arbitration still needs to occur. */
40  /* The corresponding procWinner[]'s remain */
41  /* as MUELU_UNASSIGNED until */
42  /* ArbitrateAndCommunicate() is */
43  /* invoked to arbitrate. */
44 
45 /*****************************************************************************
46 
47 ****************************************************************************/
48 
49 namespace MueLu {
50 
66 template <class LocalOrdinal, class GlobalOrdinal, class Node>
67 class Aggregates : public BaseClass {
68  public:
71  using execution_space = typename Node::execution_space;
72  using node_type = Node;
73  using device_type = typename Node::device_type;
74  using range_type = Kokkos::RangePolicy<local_ordinal_type, execution_space>;
75  using LO_view = Kokkos::View<local_ordinal_type*, device_type>;
76 
77  using aggregates_sizes_type = Kokkos::View<LocalOrdinal*, device_type>;
78 
79  private:
80 #undef MUELU_AGGREGATES_SHORT
82 
83  public:
84  // Defining types that require the short names included above
86  using colors_view_type = Kokkos::View<typename local_graph_type::entries_type::data_type,
87  typename local_graph_type::device_type::memory_space>;
88 
96  Aggregates(const LWGraph& graph);
97 
105  Aggregates(LWGraph_kokkos graph);
106 
112  Aggregates(const RCP<const Map>& map);
113 
117  virtual ~Aggregates() {}
118 
120 
121 
126 
130  void SetIndexManagerKokkos(RCP<IndexManager_kokkos>& geoDataKokkos) { geoDataKokkos_ = geoDataKokkos; }
131 
136 
140  void SetIndexManager(RCP<IndexManager>& geoData) { geoData_ = geoData; }
141 
146 
150  void SetGraphColors(colors_view_type graphColors) { graphColors_ = graphColors; }
151 
155 
158  void SetGraphNumColors(const LO graphNumColors) { graphNumColors_ = graphNumColors; }
159 
161 
166  void SetNumAggregates(LO nAggregates) { numAggregates_ = nAggregates; }
167 
172  void SetNumGlobalAggregates(GO nGlobalAggregates) { numGlobalAggregates_ = nGlobalAggregates; }
173 
175  KOKKOS_INLINE_FUNCTION LO GetNumAggregates() const {
176  return numAggregates_;
177  }
178 
180  KOKKOS_INLINE_FUNCTION void AggregatesCrossProcessors(const bool& flag) {
182  }
183 
188  KOKKOS_INLINE_FUNCTION bool AggregatesCrossProcessors() const {
190  }
191 
197 
208 
213  const RCP<LOVector>& GetProcWinner() const { return procWinner_; }
214 
216  inline bool IsRoot(LO i) const { return isRoot_[i]; }
217 
222  inline void SetIsRoot(LO i, bool value = true) { isRoot_[i] = value; }
223 
224  const RCP<const Map> GetMap() const;
225 
235  typename aggregates_sizes_type::const_type ComputeAggregateSizes(bool forceRecompute = false) const;
236 
246  Teuchos::ArrayRCP<LocalOrdinal> ComputeAggregateSizesArrayRCP(bool forceRecompute = false) const;
247 
248  local_graph_type GetGraph() const;
249 
254  void ComputeNodesInAggregate(LO_view& aggPtr, LO_view& aggNodes, LO_view& unaggregated) const;
255 
257  // If # of global aggregates is unknown, this method does coummunication and internally record the value
259 
261 
262 
264  std::string description() const;
265 
267  // using MueLu::Describable::describe; // overloading, not hiding
268  void print(Teuchos::FancyOStream& out, const Teuchos::EVerbosityLevel verbLevel = verbLevel_default) const;
269 
270  private:
273 
279 
285 
290 
295 
300 
305 
308 
311 
314 
319  mutable
320  typename aggregates_sizes_type::HostMirror aggregateSizesHost_;
321 
324 };
325 
326 } // namespace MueLu
327 
328 #define MUELU_AGGREGATES_SHORT
329 #endif // MUELU_AGGREGATES_DECL_HPP
Kokkos::View< LocalOrdinal *, device_type > aggregates_sizes_type
virtual ~Aggregates()
Destructor.
MueLu::DefaultLocalOrdinal LocalOrdinal
void SetIndexManagerKokkos(RCP< IndexManager_kokkos > &geoDataKokkos)
Set the index manager used by structured aggregation algorithms. This has to be done by the aggregati...
typename Node::execution_space execution_space
typename Node::device_type device_type
Lightweight MueLu representation of a compressed row storage graph.
const RCP< LOVector > & GetProcWinner() const
Returns constant vector that maps local node IDs to owning processor IDs.
RCP< IndexManager > geoData_
void SetGraphNumColors(const LO graphNumColors)
Set the number of colors needed by the distance 2 coloring.
Container class for aggregation information.
RCP< IndexManager > & GetIndexManager()
Get the index manager used by various aggregation algorithms. This has to be done by the aggregation ...
bool aggregatesIncludeGhosts_
Set to false iff aggregates do not include any DOFs belong to other processes.
KOKKOS_INLINE_FUNCTION LO GetNumAggregates() const
typename std::conditional< OnHost, typename local_graph_device_type::HostMirror, local_graph_device_type >::type local_graph_type
GlobalOrdinal GO
const RCP< const Map > GetMap() const
returns (overlapping) map of aggregate/node distribution
LocalOrdinal LO
colors_view_type graphColors_
void SetIndexManager(RCP< IndexManager > &geoData)
Set the index manager used by various aggregation algorithms. This has to be done by the aggregation ...
MueLu::DefaultNode Node
void SetIsRoot(LO i, bool value=true)
Set root node information.
GlobalOrdinal global_ordinal_type
RCP< LOMultiVector > & GetVertex2AggIdNonConst()
Returns a nonconstant vector that maps local node IDs to local aggregates IDs.
LO GetGraphNumColors()
Get the number of colors needed by the distance 2 coloring.
MueLu::DefaultGlobalOrdinal GlobalOrdinal
LO numAggregates_
Number of aggregates on this processor.
colors_view_type & GetGraphColors()
Get a distance 2 coloring of the underlying graph. The coloring is computed and set during Phase1 of ...
aggregates_sizes_type::HostMirror aggregateSizesHost_
RCP< IndexManager_kokkos > geoDataKokkos_
typename LWGraph_kokkos::local_graph_type local_graph_type
RCP< LOVector > & GetProcWinnerNonConst()
Returns nonconstant vector that maps local node IDs to owning processor IDs.
void ComputeNodesInAggregate(LO_view &aggPtr, LO_view &aggNodes, LO_view &unaggregated) const
Generates a compressed list of nodes in each aggregate, where the entries in aggNodes[aggPtr[i]] up t...
void SetGraphColors(colors_view_type graphColors)
Set a distance 2 coloring of the underlying graph. The coloring is computed and set during Phase1 of ...
GO GetNumGlobalAggregatesComputeIfNeeded()
Get global number of aggregates.
Teuchos::ArrayRCP< LocalOrdinal > ComputeAggregateSizesArrayRCP(bool forceRecompute=false) const
Compute sizes of aggregates.
Teuchos::ArrayRCP< bool > isRoot_
An ArrayRCP of booleans specifying if a local entry is an aggregate root.
const RCP< LOMultiVector > & GetVertex2AggId() const
Returns constant vector that maps local node IDs to local aggregates IDs.
aggregates_sizes_type aggregateSizes_
Array of sizes of each local aggregate.
Kokkos::RangePolicy< local_ordinal_type, execution_space > range_type
Kokkos::View< typename local_graph_type::entries_type::data_type, typename local_graph_type::device_type::memory_space > colors_view_type
void SetNumGlobalAggregates(GO nGlobalAggregates)
Set number of global aggregates on current processor.
static const EVerbosityLevel verbLevel_default
Base class for MueLu classes.
RCP< LOMultiVector > vertex2AggId_
Kokkos::View< local_ordinal_type *, device_type > LO_view
GO numGlobalAggregates_
Number of global aggregates.
Lightweight MueLu representation of a compressed row storage graph.
bool IsRoot(LO i) const
Returns true if node with given local node id is marked to be a root node.
Aggregates(const LWGraph &graph)
Standard constructor for Aggregates structure.
KOKKOS_INLINE_FUNCTION void AggregatesCrossProcessors(const bool &flag)
Record whether aggregates include DOFs from other processes.
void print(Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel=verbLevel_default) const
Print the object with some verbosity level to an FancyOStream object.
std::string description() const
Return a simple one-line description of this object.
local_graph_type GetGraph() const
KOKKOS_INLINE_FUNCTION bool AggregatesCrossProcessors() const
Return false if and only if no aggregates include DOFs from other processes.
aggregates_sizes_type::const_type ComputeAggregateSizes(bool forceRecompute=false) const
Compute sizes of aggregates.
local_graph_type graph_
Aggregates represented as Kokkos graph type.
void SetNumAggregates(LO nAggregates)
Set number of local aggregates on current processor.
RCP< IndexManager_kokkos > & GetIndexManagerKokkos()
Get the index manager used by structured aggregation algorithms. This has to be done by the aggregati...