OGS
NumLib::MeshComponentMap Class Referencefinal

Detailed Description

Multidirectional mapping between mesh entities and degrees of freedom.

Definition at line 29 of file MeshComponentMap.h.

#include <MeshComponentMap.h>

Public Types

using Location = MeshLib::Location
 

Public Member Functions

 MeshComponentMap (std::vector< MeshLib::MeshSubset > const &components, ComponentOrder order)
 
MeshComponentMap getSubset (std::vector< MeshLib::MeshSubset > const &bulk_mesh_subsets, MeshLib::MeshSubset const &new_mesh_subset) const
 
std::size_t dofSizeWithGhosts () const
 The number of dofs including the those located in the ghost nodes.
 
std::vector< int > getComponentIDs (const Location &l) const
 
GlobalIndexType getGlobalIndex (Location const &l, int const comp_id) const
 
std::vector< GlobalIndexTypegetGlobalIndices (const Location &l) const
 
std::vector< GlobalIndexTypegetGlobalIndicesByLocation (const std::vector< Location > &ls) const
 
std::vector< GlobalIndexTypegetGlobalIndicesByComponent (const std::vector< Location > &ls) const
 
std::size_t dofSizeWithoutGhosts () const
 
std::vector< GlobalIndexType > const & getGhostIndices () const
 Get ghost indices (for DDC).
 
GlobalIndexType getLocalIndex (Location const &l, int const comp_id, std::size_t const range_begin, std::size_t const range_end) const
 
const detail::ComponentGlobalIndexDictgetDictionary () const
 

Static Public Attributes

static constexpr NUMLIB_EXPORT GlobalIndexType const nop
 

Private Member Functions

 MeshComponentMap (detail::ComponentGlobalIndexDict &dict)
 Private constructor used by internally created mesh component maps.
 
void renumberByLocation (GlobalIndexType offset=0)
 
void createSerialMeshComponentMap (std::vector< MeshLib::MeshSubset > const &components, ComponentOrder order)
 
void createParallelMeshComponentMap (std::vector< MeshLib::MeshSubset > const &components, ComponentOrder order)
 

Private Attributes

detail::ComponentGlobalIndexDict _dict
 
std::size_t _num_local_dof = 0
 
std::size_t _num_global_dof = 0
 Number of global unknowns. Used internally only.
 
std::vector< GlobalIndexType_ghosts_indices
 Global ID for ghost entries.
 

Friends

std::ostream & operator<< (std::ostream &os, MeshComponentMap const &m)
 

Member Typedef Documentation

◆ Location

Constructor & Destructor Documentation

◆ MeshComponentMap() [1/2]

NumLib::MeshComponentMap::MeshComponentMap ( std::vector< MeshLib::MeshSubset > const & components,
ComponentOrder order )
Parameters
componentsa vector of components
ordertype of ordering values in a vector

Definition at line 28 of file MeshComponentMap.cpp.

30{
31 // Use PETSc with single thread
32 const MeshLib::NodePartitionedMesh& partitioned_mesh =
33 static_cast<const MeshLib::NodePartitionedMesh&>(
34 components[0].getMesh());
35 if (partitioned_mesh.isForSingleThread())
36 {
37 createSerialMeshComponentMap(components, order);
38 return;
39 }
40 else
41 {
42 createParallelMeshComponentMap(components, order);
43 }
44}
void createParallelMeshComponentMap(std::vector< MeshLib::MeshSubset > const &components, ComponentOrder order)
void createSerialMeshComponentMap(std::vector< MeshLib::MeshSubset > const &components, ComponentOrder order)

References createParallelMeshComponentMap(), createSerialMeshComponentMap(), and MeshLib::NodePartitionedMesh::isForSingleThread().

Referenced by getSubset().

◆ MeshComponentMap() [2/2]

NumLib::MeshComponentMap::MeshComponentMap ( detail::ComponentGlobalIndexDict & dict)
inlineexplicitprivate

Private constructor used by internally created mesh component maps.

Definition at line 157 of file MeshComponentMap.h.

158 : _dict(dict)
159 {
160 }
detail::ComponentGlobalIndexDict _dict

Member Function Documentation

◆ createParallelMeshComponentMap()

void NumLib::MeshComponentMap::createParallelMeshComponentMap ( std::vector< MeshLib::MeshSubset > const & components,
ComponentOrder order )
private
Parameters
componentsa vector of components
ordertype of ordering values in a vector

Definition at line 384 of file MeshComponentMap.cpp.

386{
387 if (order != ComponentOrder::BY_LOCATION)
388 {
389 // Not allowed in parallel case since this is not suitable to
390 // arrange non ghost entries of a partition within
391 // a rank in the parallel computing.
392 OGS_FATAL(
393 "Global index in the system of equations can only be numbered by "
394 "the order type of ComponentOrder::BY_LOCATION");
395 }
396
397 const MeshLib::NodePartitionedMesh& partitioned_mesh =
398 static_cast<const MeshLib::NodePartitionedMesh&>(
399 components[0].getMesh());
400
401 //
402 // get the number of unknowns and the number of components at extra node
403 //
404 GlobalIndexType num_unknowns = 0;
405 int components_at_high_order_nodes = 0;
406 for (auto const& c : components)
407 {
408 if (partitioned_mesh.getNumberOfNodes() == c.getNodes().size())
409 {
410 components_at_high_order_nodes++;
411 num_unknowns += partitioned_mesh.getNumberOfGlobalNodes();
412 }
413 else
414 {
415 num_unknowns += partitioned_mesh.getNumberOfGlobalBaseNodes();
416 }
417 }
418
419 // construct dict (and here we number global_index by component type)
420 //
421 int const n_components = components.size();
422
423 int comp_id = 0;
424 int comp_id_at_high_order_node = 0;
425 _num_global_dof = 0;
426 _num_local_dof = 0;
427 for (auto const& c : components)
428 {
429 assert(dynamic_cast<MeshLib::NodePartitionedMesh const*>(
430 &c.getMesh()) != nullptr);
431 std::size_t const mesh_id = c.getMeshID();
432 const MeshLib::NodePartitionedMesh& partitioned_mesh =
433 static_cast<const MeshLib::NodePartitionedMesh&>(c.getMesh());
434 const auto& sub_mesh_nodes = c.getNodes();
435
436 // mesh items are ordered first by node, cell, ....
437 for (std::size_t j = 0; j < sub_mesh_nodes.size(); j++)
438 {
439 const auto node_id = sub_mesh_nodes[j]->getID();
440 const bool is_base_node =
441 MeshLib::isBaseNode(*sub_mesh_nodes[j],
442 partitioned_mesh.getElementsConnectedToNode(
443 *sub_mesh_nodes[j]));
444
445 const auto global_node_id =
446 partitioned_mesh.getGlobalNodeID(node_id);
447 GlobalIndexType global_index =
448 (!c.useTaylorHoodElements())
449 ? static_cast<GlobalIndexType>(
450 n_components * global_node_id + comp_id)
452 partitioned_mesh, global_node_id, n_components,
453 components_at_high_order_nodes, comp_id,
454 comp_id_at_high_order_node, is_base_node);
455 const bool is_ghost = partitioned_mesh.isGhostNode(node_id);
456 if (is_ghost)
457 {
458 _ghosts_indices.push_back(global_index);
459 global_index = -global_index;
460 // If the ghost entry has an index of 0,
461 // its index is set to the negative value of unknowns.
462 if (global_index == 0)
463 {
464 global_index = -num_unknowns;
465 }
466 }
467 else
468 {
470 }
471
472 _dict.insert(
473 Line(Location(mesh_id, MeshLib::MeshItemType::Node, node_id),
474 comp_id, global_index));
475 }
476
477 bool const use_whole_nodes =
478 (partitioned_mesh.getNumberOfNodes() == c.getNodes().size());
479 if (use_whole_nodes)
480 {
481 _num_global_dof += partitioned_mesh.getNumberOfGlobalNodes();
482 comp_id_at_high_order_node++;
483 }
484 else
485 {
486 _num_global_dof += partitioned_mesh.getNumberOfGlobalBaseNodes();
487 }
488
489 comp_id++;
490 }
491}
#define OGS_FATAL(...)
Definition Error.h:26
GlobalMatrix::IndexType GlobalIndexType
std::size_t getNumberOfNodes() const
Get the number of nodes.
Definition Mesh.h:100
std::vector< Element const * > const & getElementsConnectedToNode(std::size_t node_id) const
Definition Mesh.cpp:256
bool isGhostNode(const std::size_t node_id) const
Check whether a node with ID of node_id is a ghost node.
std::size_t getGlobalNodeID(const std::size_t node_id) const
Get the global node ID of a node with its local ID.
std::size_t getNumberOfGlobalNodes() const
Get the number of all nodes of the global mesh.
std::size_t getNumberOfGlobalBaseNodes() const
Get the number of nodes of the global mesh for linear elements.
MeshLib::Location Location
std::size_t _num_global_dof
Number of global unknowns. Used internally only.
std::vector< GlobalIndexType > _ghosts_indices
Global ID for ghost entries.
TemplateElement< MeshLib::LineRule2 > Line
Definition Line.h:25
bool isBaseNode(Node const &node, std::vector< Element const * > const &elements_connected_to_node)
Definition Mesh.cpp:346
GlobalIndexType getGlobalIndexWithTaylorHoodElement(MeshLib::NodePartitionedMesh const &partitioned_mesh, std::size_t const global_node_id, int const number_of_components_at_base_node, int const number_of_components_at_high_order_node, int const component_id_at_base_node, int const component_id_at_high_order_node, bool const is_base_node)
@ BY_LOCATION
Ordering data by spatial location.

References _dict, _ghosts_indices, _num_global_dof, _num_local_dof, NumLib::BY_LOCATION, MeshLib::Mesh::getElementsConnectedToNode(), NumLib::getGlobalIndexWithTaylorHoodElement(), MeshLib::NodePartitionedMesh::getGlobalNodeID(), MeshLib::NodePartitionedMesh::getNumberOfGlobalBaseNodes(), MeshLib::NodePartitionedMesh::getNumberOfGlobalNodes(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::isBaseNode(), MeshLib::NodePartitionedMesh::isGhostNode(), MeshLib::Node, and OGS_FATAL.

Referenced by MeshComponentMap().

◆ createSerialMeshComponentMap()

void NumLib::MeshComponentMap::createSerialMeshComponentMap ( std::vector< MeshLib::MeshSubset > const & components,
ComponentOrder order )
private
Parameters
componentsa vector of components
ordertype of ordering values in a vector

Definition at line 295 of file MeshComponentMap.cpp.

297{
298 // construct dict (and here we number global_index by component type)
299 GlobalIndexType global_index = 0;
300 int comp_id = 0;
301 for (auto const& c : components)
302 {
303 std::size_t const mesh_id = c.getMeshID();
304 // mesh items are ordered first by node, cell, ....
305 for (auto const node_id : c.getNodes() | MeshLib::views::ids)
306 {
307 _dict.insert(
308 Line(Location(mesh_id, MeshLib::MeshItemType::Node, node_id),
309 comp_id, global_index++));
310 }
311 comp_id++;
312 }
313 _num_local_dof = _dict.size();
314
315 if (order == ComponentOrder::BY_LOCATION)
316 {
318 }
319}
void renumberByLocation(GlobalIndexType offset=0)
constexpr ranges::views::view_closure ids
For an element of a range view return its id.
Definition Mesh.h:225

References _dict, _num_local_dof, NumLib::BY_LOCATION, MeshLib::views::ids, MeshLib::Node, and renumberByLocation().

Referenced by MeshComponentMap().

◆ dofSizeWithGhosts()

std::size_t NumLib::MeshComponentMap::dofSizeWithGhosts ( ) const
inline

The number of dofs including the those located in the ghost nodes.

Definition at line 55 of file MeshComponentMap.h.

55{ return _dict.size(); }

References _dict.

Referenced by NumLib::LocalToGlobalIndexMap::dofSizeWithGhosts().

◆ dofSizeWithoutGhosts()

std::size_t NumLib::MeshComponentMap::dofSizeWithoutGhosts ( ) const
inline

Get the number of local unknowns excluding those associated with ghost nodes (for DDC with node-wise mesh partitioning).

Definition at line 118 of file MeshComponentMap.h.

118{ return _num_local_dof; }

References _num_local_dof.

Referenced by NumLib::LocalToGlobalIndexMap::dofSizeWithoutGhosts().

◆ getComponentIDs()

std::vector< int > NumLib::MeshComponentMap::getComponentIDs ( const Location & l) const

Component ids at given location l.

Location ComponentID
l comp_id_1
l ...
l comp_id_n

Definition at line 154 of file MeshComponentMap.cpp.

155{
156 auto const& m = _dict.get<ByLocation>();
157 auto const p = m.equal_range(Line(l));
158 std::vector<int> vec_compID;
159 for (auto itr = p.first; itr != p.second; ++itr)
160 {
161 vec_compID.push_back(itr->comp_id);
162 }
163 return vec_compID;
164}

References _dict.

Referenced by getSubset().

◆ getDictionary()

const detail::ComponentGlobalIndexDict & NumLib::MeshComponentMap::getDictionary ( ) const
inline

Definition at line 141 of file MeshComponentMap.h.

142 {
143 return _dict;
144 }

References _dict.

◆ getGhostIndices()

std::vector< GlobalIndexType > const & NumLib::MeshComponentMap::getGhostIndices ( ) const
inline

Get ghost indices (for DDC).

Definition at line 121 of file MeshComponentMap.h.

122 {
123 return _ghosts_indices;
124 }

References _ghosts_indices.

Referenced by NumLib::LocalToGlobalIndexMap::getGhostIndices().

◆ getGlobalIndex()

GlobalIndexType NumLib::MeshComponentMap::getGlobalIndex ( Location const & l,
int const comp_id ) const

Global index of the given component id at given location l.

Location ComponentID GlobalIndex
l comp_id gi

Definition at line 166 of file MeshComponentMap.cpp.

168{
169 auto const& m = _dict.get<ByLocationAndComponent>();
170 auto const itr = m.find(Line(l, comp_id));
171 return itr != m.end() ? itr->global_index : nop;
172}
static constexpr NUMLIB_EXPORT GlobalIndexType const nop

References _dict, and nop.

Referenced by NumLib::LocalToGlobalIndexMap::findGlobalIndices(), NumLib::LocalToGlobalIndexMap::findGlobalIndicesWithElementID(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), NumLib::LocalToGlobalIndexMap::getGlobalIndex(), getLocalIndex(), and getSubset().

◆ getGlobalIndices()

std::vector< GlobalIndexType > NumLib::MeshComponentMap::getGlobalIndices ( const Location & l) const

Global indices for all components at the given location l.

If there is more than one component at the given location, the function returns a vector containing global indices for each component.

Location ComponentID GlobalIndex
l comp_id_1 gi23
... ... ...
l comp_id_k gi45

Definition at line 174 of file MeshComponentMap.cpp.

176{
177 auto const& m = _dict.get<ByLocation>();
178 auto const p = m.equal_range(Line(l));
179 std::vector<GlobalIndexType> global_indices;
180 for (auto itr = p.first; itr != p.second; ++itr)
181 {
182 global_indices.push_back(itr->global_index);
183 }
184 return global_indices;
185}

References _dict.

Referenced by NumLib::LocalToGlobalIndexMap::getGlobalIndices().

◆ getGlobalIndicesByComponent()

std::vector< GlobalIndexType > NumLib::MeshComponentMap::getGlobalIndicesByComponent ( const std::vector< Location > & ls) const

Global indices for all components at all given locations ls ordered by component ids. The return list is sorted first by component ids.

Location ComponentID GlobalIndex
l_1 comp_id_1 gi23
... ... ...
l_k comp_id_1 gi45
l_1 comp_id_2 gi46
... ... ...
l_m comp_id_2 gi78
... ... ...
l_n comp_id_n gi89

Definition at line 209 of file MeshComponentMap.cpp.

211{
212 // vector of (Component, global Index) pairs.
213 using CIPair = std::pair<int, GlobalIndexType>;
214 std::vector<CIPair> pairs;
215 pairs.reserve(ls.size());
216
217 // Create a sub dictionary containing all lines with location from ls.
218 auto const& m = _dict.get<ByLocation>();
219 for (const auto& l : ls)
220 {
221 auto const p = m.equal_range(Line(l));
222 for (auto itr = p.first; itr != p.second; ++itr)
223 {
224 pairs.emplace_back(itr->comp_id, itr->global_index);
225 }
226 }
227
228 auto CIPairLess = [](CIPair const& a, CIPair const& b)
229 { return a.first < b.first; };
230
231 // Create vector of global indices from sub dictionary sorting by component.
232 if (!std::is_sorted(pairs.begin(), pairs.end(), CIPairLess))
233 {
234 std::stable_sort(pairs.begin(), pairs.end(), CIPairLess);
235 }
236
237 std::vector<GlobalIndexType> global_indices;
238 global_indices.reserve(pairs.size());
239 transform(cbegin(pairs), cend(pairs), back_inserter(global_indices),
240 [&](const auto& pair) { return pair.second; });
241
242 return global_indices;
243}

References _dict.

◆ getGlobalIndicesByLocation()

std::vector< GlobalIndexType > NumLib::MeshComponentMap::getGlobalIndicesByLocation ( const std::vector< Location > & ls) const

Global indices for all components at all given locations ls ordered by location. The return list is sorted first by location.

Location ComponentID GlobalIndex
l_1 comp_id_1 gi23
... ... ...
l_1 comp_id_k gi45
l_2 comp_id_1 gi46
... ... ...
l_2 comp_id_m gi67
... ... ...
l_n comp_id_n gi78

Definition at line 187 of file MeshComponentMap.cpp.

189{
190 // Create vector of global indices sorted by location containing all
191 // locations given in ls parameter.
192
193 std::vector<GlobalIndexType> global_indices;
194 global_indices.reserve(ls.size());
195
196 auto const& m = _dict.get<ByLocation>();
197 for (const auto& l : ls)
198 {
199 auto const p = m.equal_range(Line(l));
200 for (auto itr = p.first; itr != p.second; ++itr)
201 {
202 global_indices.push_back(itr->global_index);
203 }
204 }
205
206 return global_indices;
207}

References _dict.

◆ getLocalIndex()

GlobalIndexType NumLib::MeshComponentMap::getLocalIndex ( Location const & l,
int const comp_id,
std::size_t const range_begin,
std::size_t const range_end ) const

Computes the index in a local (for DDC) vector for a given location and component. When domain decomposition is not used, it is equal to getGlobalIndex(). The range is needed to compute the offset for non-ghost locations and also to map ghost locations.

Definition at line 245 of file MeshComponentMap.cpp.

250{
251 GlobalIndexType const global_index = getGlobalIndex(l, comp_id);
252 // request for index of linear quantities at higher order nodes
253 // results in returning nop
254 // That index shall not be modified like a usual global index.
255 if (global_index == nop)
256 {
257 return nop;
258 }
259#ifndef USE_PETSC
260 (void)range_begin;
261 (void)range_end;
262 return global_index;
263#else
264 if (global_index >= 0) // non-ghost location.
265 return global_index - range_begin;
266
267 //
268 // For a ghost location look up the global index in ghost indices.
269 //
270
271 // A special case for a ghost location with global index equal to the size
272 // of the local vector:
273 GlobalIndexType const real_global_index =
274 (-global_index == static_cast<GlobalIndexType>(_num_global_dof))
275 ? 0
276 : -global_index;
277
278 // TODO Find in ghost indices is O(n^2/2) for n being the length of
279 // _ghosts_indices. Providing an inverted table would be faster.
280 auto const ghost_index_it = std::find(
281 _ghosts_indices.begin(), _ghosts_indices.end(), real_global_index);
282 if (ghost_index_it == _ghosts_indices.end())
283 {
284 OGS_FATAL("index {:d} not found in ghost_indices", real_global_index);
285 }
286
287 // Using std::distance on a std::vector is O(1). As long as _ghost_indices
288 // remains of std::vector type, this shall be fast.
289 return range_end - range_begin +
290 std::distance(_ghosts_indices.begin(), ghost_index_it);
291
292#endif
293}
GlobalIndexType getGlobalIndex(Location const &l, int const comp_id) const

References _ghosts_indices, _num_global_dof, getGlobalIndex(), nop, and OGS_FATAL.

Referenced by NumLib::LocalToGlobalIndexMap::getLocalIndex().

◆ getSubset()

MeshComponentMap NumLib::MeshComponentMap::getSubset ( std::vector< MeshLib::MeshSubset > const & bulk_mesh_subsets,
MeshLib::MeshSubset const & new_mesh_subset ) const

Creates a multi-component subset of the current mesh component map. The order (BY_LOCATION/BY_COMPONENT) of components is the same as of the current map.

Attention
For each component the same new_mesh_subset will be used.
Parameters
bulk_mesh_subsetscomponents that should remain in the created subset, one for each global component.
new_mesh_subsetThe constraining mesh subset with a mapping of node ids to the bulk mesh nodes.

Definition at line 53 of file MeshComponentMap.cpp.

56{
57 { // Testing first an assumption met later in the code that the meshes for
58 // all the bulk_mesh_subsets are equal.
59 auto const first_mismatch =
60 std::adjacent_find(begin(bulk_mesh_subsets), end(bulk_mesh_subsets),
61 [](auto const& a, auto const& b)
62 { return a.getMeshID() != b.getMeshID(); });
63 if (first_mismatch != end(bulk_mesh_subsets))
64 {
66 "Assumption in the MeshComponentMap violated. Expecting all of "
67 "mesh ids to be the same, but it is not true for "
68 "the mesh '{:s}' with id {:d}.",
69 first_mismatch->getMesh().getName(),
70 first_mismatch->getMeshID());
71 }
72 }
73
74 // Mapping of the nodes in the new_mesh_subset to the bulk mesh nodes
75 auto bulk_node_ids = [](auto const& mesh)
76 {
77 auto const* bulk_node_ids_ptr = MeshLib::bulkNodeIDs(mesh);
78 if (bulk_node_ids_ptr == nullptr)
79 {
81 "Bulk node ids map expected in the construction of the mesh "
82 "subset.");
83 }
84 return *bulk_node_ids_ptr;
85 };
86 auto const& bulk_node_ids_map = bulk_node_ids(new_mesh_subset.getMesh());
87
88 // New dictionary for the subset.
89 ComponentGlobalIndexDict subset_dict;
90
91 std::size_t const new_mesh_id = new_mesh_subset.getMeshID();
92 // Lookup the locations in the current mesh component map and
93 // insert the full lines into the new subset dictionary.
94 for (auto* const node : new_mesh_subset.getNodes())
95 {
96 auto const node_id = node->getID();
97 bool const is_base_node = MeshLib::isBaseNode(
98 *node,
99 new_mesh_subset.getMesh().getElementsConnectedToNode(node_id));
100
101 MeshLib::Location const new_location{
102 new_mesh_id, MeshLib::MeshItemType::Node, node_id};
103
104 // Assuming the meshes for all the bulk_mesh_subsets are equal.
105 MeshLib::Location const bulk_location{
106 bulk_mesh_subsets.front().getMeshID(), MeshLib::MeshItemType::Node,
107 bulk_node_ids_map[node_id]};
108
109 for (auto component_id : getComponentIDs(bulk_location))
110 {
111 auto const global_index =
112 getGlobalIndex(bulk_location, component_id);
113 if (global_index == nop)
114 {
115 if (is_base_node)
116 {
117 OGS_FATAL(
118 "Could not find a global index for global component "
119 "{:d} for the mesh '{:s}', node {:d}, in the "
120 "corresponding bulk mesh '{:s}' and node {:d}. This "
121 "happens because the boundary mesh is larger than the "
122 "definition region of the bulk component, usually "
123 "because the geometry for the boundary condition is "
124 "too large.",
125 component_id,
126 new_mesh_subset.getMesh().getName(),
127 node_id,
128 bulk_mesh_subsets.front().getMesh().getName(),
129 bulk_node_ids_map[node_id]);
130 }
131 continue;
132 }
133 subset_dict.insert({new_location, component_id, global_index});
134 }
135 }
136
137 return MeshComponentMap(subset_dict);
138}
std::vector< int > getComponentIDs(const Location &l) const
MeshComponentMap(std::vector< MeshLib::MeshSubset > const &components, ComponentOrder order)
PropertyVector< std::size_t > const * bulkNodeIDs(Mesh const &mesh)
Definition Mesh.cpp:292
boost::multi_index::multi_index_container< Line, boost::multi_index::indexed_by< boost::multi_index::ordered_unique< boost::multi_index::tag< ByLocationAndComponent >, boost::multi_index::identity< Line >, LineByLocationAndComponentComparator >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< ByLocation >, boost::multi_index::identity< Line >, LineByLocationComparator >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< ByComponent >, boost::multi_index::member< Line, int, &Line::comp_id > >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< ByGlobalIndex >, boost::multi_index::member< Line, GlobalIndexType, &Line::global_index > > > > ComponentGlobalIndexDict

References MeshComponentMap(), MeshLib::bulkNodeIDs(), getComponentIDs(), MeshLib::Mesh::getElementsConnectedToNode(), getGlobalIndex(), MeshLib::MeshSubset::getMesh(), MeshLib::MeshSubset::getMeshID(), MeshLib::Mesh::getName(), MeshLib::MeshSubset::getNodes(), MeshLib::isBaseNode(), MeshLib::Node, nop, and OGS_FATAL.

Referenced by NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap(), and NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap().

◆ renumberByLocation()

void NumLib::MeshComponentMap::renumberByLocation ( GlobalIndexType offset = 0)
private

Definition at line 140 of file MeshComponentMap.cpp.

141{
142 GlobalIndexType global_index = offset;
143
144 auto& m = _dict.get<ByLocation>(); // view as sorted by mesh item
145 for (auto itr_mesh_item = m.begin(); itr_mesh_item != m.end();
146 ++itr_mesh_item)
147 {
148 Line pos = *itr_mesh_item;
149 pos.global_index = global_index++;
150 m.replace(itr_mesh_item, pos);
151 }
152}

References _dict, and NumLib::detail::Line::global_index.

Referenced by createSerialMeshComponentMap().

Friends And Related Symbol Documentation

◆ operator<<

std::ostream & operator<< ( std::ostream & os,
MeshComponentMap const & m )
friend

Definition at line 146 of file MeshComponentMap.h.

147 {
148 os << "Dictionary size: " << m._dict.size() << "\n";
149 for (auto l : m._dict)
150 os << l << "\n";
151 return os;
152 }

Member Data Documentation

◆ _dict

◆ _ghosts_indices

std::vector<GlobalIndexType> NumLib::MeshComponentMap::_ghosts_indices
private

Global ID for ghost entries.

Definition at line 176 of file MeshComponentMap.h.

Referenced by createParallelMeshComponentMap(), getGhostIndices(), and getLocalIndex().

◆ _num_global_dof

std::size_t NumLib::MeshComponentMap::_num_global_dof = 0
private

Number of global unknowns. Used internally only.

Definition at line 172 of file MeshComponentMap.h.

Referenced by createParallelMeshComponentMap(), and getLocalIndex().

◆ _num_local_dof

std::size_t NumLib::MeshComponentMap::_num_local_dof = 0
private

Number of local unknowns excluding those associated with ghost nodes (for domain decomposition).

Definition at line 168 of file MeshComponentMap.h.

Referenced by createParallelMeshComponentMap(), createSerialMeshComponentMap(), and dofSizeWithoutGhosts().

◆ nop


The documentation for this class was generated from the following files: