NumLib::MeshComponentMap Class Reference

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, std::vector< int > const &new_global_component_ids) const
std::size_t	dofSizeWithGhosts () const
	The number of dofs including the those located in the ghost nodes. More...
std::vector< int >	getComponentIDs (const Location &l) const
GlobalIndexType	getGlobalIndex (Location const &l, int const comp_id) const
std::vector< GlobalIndexType >	getGlobalIndices (const Location &l) const
std::vector< GlobalIndexType >	getGlobalIndicesByLocation (const std::vector< Location > &ls) const
std::vector< GlobalIndexType >	getGlobalIndicesByComponent (const std::vector< Location > &ls) const
std::size_t	dofSizeWithoutGhosts () const
std::vector< GlobalIndexType > const &	getGhostIndices () const
	Get ghost indices (for DDC). More...
GlobalIndexType	getLocalIndex (Location const &l, int const comp_id, std::size_t const range_begin, std::size_t const range_end) const
const detail::ComponentGlobalIndexDict &	getDictionary () const

Static Public Attributes
static NUMLIB_EXPORT GlobalIndexType const	nop

Private Member Functions
	MeshComponentMap (detail::ComponentGlobalIndexDict &dict)
	Private constructor used by internally created mesh component maps. More...
detail::Line	getLine (Location const &l, int const comp_id) const
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. More...
std::vector< GlobalIndexType >	_ghosts_indices
	Global ID for ghost entries. More...

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

Member Typedef Documentation

Location

using NumLib::MeshComponentMap::Location = MeshLib::Location

Definition at line 32 of file MeshComponentMap.h.

Constructor & Destructor Documentation

MeshComponentMap() [1/2]

NumLib::MeshComponentMap::MeshComponentMap	(	std::vector< MeshLib::MeshSubset > const &	components,
		ComponentOrder	order
	)

Parameters

components	a vector of components
order	type of ordering values in a vector

Definition at line 30 of file MeshComponentMap.cpp.

{
    // Use PETSc with single thread
    const MeshLib::NodePartitionedMesh& partitioned_mesh =
        static_cast<const MeshLib::NodePartitionedMesh&>(
            components[0].getMesh());
    if (partitioned_mesh.isForSingleThread())
    {
        createSerialMeshComponentMap(components, order);
        return;
    }
    else
    {
        createParallelMeshComponentMap(components, order);
    }
}

References MeshLib::NodePartitionedMesh::isForSingleThread().

MeshComponentMap() [2/2]

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

inlineexplicitprivate

Private constructor used by internally created mesh component maps.

Definition at line 159 of file MeshComponentMap.h.

        : _dict(dict)
    {
    }

Member Function Documentation

createParallelMeshComponentMap()

void NumLib::MeshComponentMap::createParallelMeshComponentMap ( std::vector< MeshLib::MeshSubset > const &  components, ComponentOrder  order  )

private

Parameters

components	a vector of components
order	type of ordering values in a vector

Definition at line 325 of file MeshComponentMap.cpp.

{
    if (order != ComponentOrder::BY_LOCATION)
    {
        // Not allowed in parallel case since this is not suitable to
        // arrange non ghost entries of a partition within
        // a rank in the parallel computing.
        OGS_FATAL(
            "Global index in the system of equations can only be numbered by "
            "the order type of ComponentOrder::BY_LOCATION");
    }
 
    // get number of unknowns
    GlobalIndexType num_unknowns = 0;
    for (auto const& c : components)
    {
        const MeshLib::NodePartitionedMesh& partitioned_mesh =
            static_cast<const MeshLib::NodePartitionedMesh&>(c.getMesh());
        num_unknowns += partitioned_mesh.getNumberOfGlobalNodes();
    }
 
    // construct dict (and here we number global_index by component type)
    int comp_id = 0;
    _num_global_dof = 0;
    _num_local_dof = 0;
    for (auto const& c : components)
    {
        assert(dynamic_cast<MeshLib::NodePartitionedMesh const*>(
                   &c.getMesh()) != nullptr);
        std::size_t const mesh_id = c.getMeshID();
        const MeshLib::NodePartitionedMesh& partitioned_mesh =
            static_cast<const MeshLib::NodePartitionedMesh&>(c.getMesh());
 
        // mesh items are ordered first by node, cell, ....
        for (std::size_t j = 0; j < c.getNumberOfNodes(); j++)
        {
            GlobalIndexType global_index = static_cast<GlobalIndexType>(
                components.size() * partitioned_mesh.getGlobalNodeID(j) +
                comp_id);
            const bool is_ghost = partitioned_mesh.isGhostNode(
                partitioned_mesh.getNode(j)->getID());
            if (is_ghost)
            {
                _ghosts_indices.push_back(global_index);
                global_index = -global_index;
                // If the ghost entry has an index of 0,
                // its index is set to the negative value of unknowns.
                if (global_index == 0)
                {
                    global_index = -num_unknowns;
                }
            }
            else
            {
                _num_local_dof++;
            }
 
            _dict.insert(Line(Location(mesh_id, MeshLib::MeshItemType::Node, j),
                              comp_id, global_index));
        }
 
        _num_global_dof += partitioned_mesh.getNumberOfGlobalNodes();
        comp_id++;
    }
}

References NumLib::BY_LOCATION, MaterialPropertyLib::c, MeshLib::NodePartitionedMesh::getGlobalNodeID(), MathLib::Point3dWithID::getID(), MeshLib::Mesh::getNode(), MeshLib::NodePartitionedMesh::getNumberOfGlobalNodes(), MeshLib::NodePartitionedMesh::isGhostNode(), MeshLib::Node, and OGS_FATAL.

createSerialMeshComponentMap()

void NumLib::MeshComponentMap::createSerialMeshComponentMap ( std::vector< MeshLib::MeshSubset > const &  components, ComponentOrder  order  )

private

Parameters

components	a vector of components
order	type of ordering values in a vector

Definition at line 298 of file MeshComponentMap.cpp.

{
    // construct dict (and here we number global_index by component type)
    GlobalIndexType global_index = 0;
    int comp_id = 0;
    for (auto const& c : components)
    {
        std::size_t const mesh_id = c.getMeshID();
        // mesh items are ordered first by node, cell, ....
        for (std::size_t j = 0; j < c.getNumberOfNodes(); j++)
        {
            _dict.insert(Line(
                Location(mesh_id, MeshLib::MeshItemType::Node, c.getNodeID(j)),
                comp_id, global_index++));
        }
        comp_id++;
    }
    _num_local_dof = _dict.size();
 
    if (order == ComponentOrder::BY_LOCATION)
    {
        renumberByLocation();
    }
}

References NumLib::BY_LOCATION, MaterialPropertyLib::c, and MeshLib::Node.

dofSizeWithGhosts()

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

inline

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

Definition at line 58 of file MeshComponentMap.h.

{ 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 121 of file MeshComponentMap.h.

{ 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 156 of file MeshComponentMap.cpp.

{
    auto const& m = _dict.get<ByLocation>();
    auto const p = m.equal_range(Line(l));
    std::vector<int> vec_compID;
    for (auto itr = p.first; itr != p.second; ++itr)
    {
        vec_compID.push_back(itr->comp_id);
    }
    return vec_compID;
}

getDictionary()

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

inline

Definition at line 143 of file MeshComponentMap.h.

    {
        return _dict;
    }

References _dict.

getGhostIndices()

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

inline

Get ghost indices (for DDC).

Definition at line 124 of file MeshComponentMap.h.

    {
        return _ghosts_indices;
    }

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 176 of file MeshComponentMap.cpp.

{
    auto const& m = _dict.get<ByLocationAndComponent>();
    auto const itr = m.find(Line(l, comp_id));
    return itr != m.end() ? itr->global_index : nop;
}

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

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 184 of file MeshComponentMap.cpp.

{
    auto const& m = _dict.get<ByLocation>();
    auto const p = m.equal_range(Line(l));
    std::vector<GlobalIndexType> global_indices;
    for (auto itr = p.first; itr != p.second; ++itr)
    {
        global_indices.push_back(itr->global_index);
    }
    return global_indices;
}

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 219 of file MeshComponentMap.cpp.

{
    // vector of (Component, global Index) pairs.
    using CIPair = std::pair<int, GlobalIndexType>;
    std::vector<CIPair> pairs;
    pairs.reserve(ls.size());
 
    // Create a sub dictionary containing all lines with location from ls.
    auto const& m = _dict.get<ByLocation>();
    for (const auto& l : ls)
    {
        auto const p = m.equal_range(Line(l));
        for (auto itr = p.first; itr != p.second; ++itr)
        {
            pairs.emplace_back(itr->comp_id, itr->global_index);
        }
    }
 
    auto CIPairLess = [](CIPair const& a, CIPair const& b)
    { return a.first < b.first; };
 
    // Create vector of global indices from sub dictionary sorting by component.
    if (!std::is_sorted(pairs.begin(), pairs.end(), CIPairLess))
    {
        std::stable_sort(pairs.begin(), pairs.end(), CIPairLess);
    }
 
    std::vector<GlobalIndexType> global_indices;
    global_indices.reserve(pairs.size());
    transform(cbegin(pairs), cend(pairs), back_inserter(global_indices),
              [&](const auto& pair) { return pair.second; });
 
    return global_indices;
}

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 197 of file MeshComponentMap.cpp.

{
    // Create vector of global indices sorted by location containing all
    // locations given in ls parameter.
 
    std::vector<GlobalIndexType> global_indices;
    global_indices.reserve(ls.size());
 
    auto const& m = _dict.get<ByLocation>();
    for (const auto& l : ls)
    {
        auto const p = m.equal_range(Line(l));
        for (auto itr = p.first; itr != p.second; ++itr)
        {
            global_indices.push_back(itr->global_index);
        }
    }
 
    return global_indices;
}

getLine()

Line NumLib::MeshComponentMap::getLine ( Location const &  l, int const  comp_id  ) const

private

Looks up if a line is already stored in the dictionary.

Attention

The line for the location l and component id must exist, the behaviour is undefined otherwise.

Returns

a copy of the line.

Definition at line 168 of file MeshComponentMap.cpp.

{
    auto const& m = _dict.get<ByLocationAndComponent>();
    auto const itr = m.find(Line(l, comp_id));
    assert(itr != m.end());  // The line must exist in the current dictionary.
    return *itr;
}

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 255 of file MeshComponentMap.cpp.

{
    GlobalIndexType const global_index = getGlobalIndex(l, comp_id);
#ifndef USE_PETSC
    (void)range_begin;
    (void)range_end;
    return global_index;
#else
    if (global_index >= 0)  // non-ghost location.
        return global_index - range_begin;
 
    //
    // For a ghost location look up the global index in ghost indices.
    //
 
    // A special case for a ghost location with global index equal to the size
    // of the local vector:
    GlobalIndexType const real_global_index =
        (-global_index == static_cast<GlobalIndexType>(_num_global_dof))
            ? 0
            : -global_index;
 
    // TODO Find in ghost indices is O(n^2/2) for n being the length of
    // _ghosts_indices. Providing an inverted table would be faster.
    auto const ghost_index_it = std::find(
        _ghosts_indices.begin(), _ghosts_indices.end(), real_global_index);
    if (ghost_index_it == _ghosts_indices.end())
    {
        OGS_FATAL("index {:d} not found in ghost_indices", real_global_index);
    }
 
    // Using std::distance on a std::vector is O(1). As long as _ghost_indices
    // remains of std::vector type, this shall be fast.
    return range_end - range_begin +
           std::distance(_ghosts_indices.begin(), ghost_index_it);
 
#endif
}

References 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,
		std::vector< int > const &	new_global_component_ids
	)		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_subsets	components that should remain in the created subset, one for each global component.
new_mesh_subset	The constraining mesh subset with a mapping of node ids to the bulk mesh nodes.
new_global_component_ids	The components for which the bulk_mesh_subsets should be intersected with the new_mesh_subset.

Definition at line 55 of file MeshComponentMap.cpp.

{
    {  // Testing first an assumption met later in the code that the meshes for
       // all the bulk_mesh_subsets are equal.
        auto const first_mismatch =
            std::adjacent_find(begin(bulk_mesh_subsets), end(bulk_mesh_subsets),
                               [](auto const& a, auto const& b)
                               { return a.getMeshID() != b.getMeshID(); });
        if (first_mismatch != end(bulk_mesh_subsets))
        {
            OGS_FATAL(
                "Assumption in the MeshComponentMap violated. Expecting all of "
                "mesh ids to be the same, but it is not true for "
                "the mesh '{:s}' with id {:d}.",
                first_mismatch->getMesh().getName(),
                first_mismatch->getMeshID());
        }
    }
 
    // Mapping of the nodes in the new_mesh_subset to the bulk mesh nodes
    auto const& new_mesh_properties = new_mesh_subset.getMesh().getProperties();
    if (!new_mesh_properties.template existsPropertyVector<std::size_t>(
            "bulk_node_ids"))
    {
        OGS_FATAL(
            "Bulk node ids map expected in the construction of the mesh "
            "subset.");
    }
    auto const& bulk_node_ids_map =
        *new_mesh_properties.template getPropertyVector<std::size_t>(
            "bulk_node_ids", MeshLib::MeshItemType::Node, 1);
 
    // New dictionary for the subset.
    ComponentGlobalIndexDict subset_dict;
 
    std::size_t const new_mesh_id = new_mesh_subset.getMeshID();
    // Lookup the locations in the current mesh component map and
    // insert the full lines into the new subset dictionary.
    for (auto* const node : new_mesh_subset.getNodes())
    {
        auto const node_id = node->getID();
        bool const is_base_node = MeshLib::isBaseNode(
            *node,
            new_mesh_subset.getMesh().getElementsConnectedToNode(node_id));
 
        MeshLib::Location const new_location{
            new_mesh_id, MeshLib::MeshItemType::Node, node_id};
 
        // Assuming the meshes for all the bulk_mesh_subsets are equal.
        MeshLib::Location const bulk_location{
            bulk_mesh_subsets.front().getMeshID(), MeshLib::MeshItemType::Node,
            bulk_node_ids_map[node_id]};
 
        for (auto component_id : new_global_component_ids)
        {
            auto const global_index =
                getGlobalIndex(bulk_location, component_id);
            if (global_index == nop)
            {
                if (is_base_node)
                {
                    OGS_FATAL(
                        "Could not find a global index for global component "
                        "{:d} for the mesh '{:s}', node {:d}, in the "
                        "corresponding bulk mesh '{:s}' and node {:d}. This "
                        "happens because the boundary mesh is larger then the "
                        "definition region of the bulk component, usually "
                        "because the geometry for the boundary condition is "
                        "too large.",
                        component_id,
                        new_mesh_subset.getMesh().getName(),
                        node_id,
                        bulk_mesh_subsets.front().getMesh().getName(),
                        bulk_node_ids_map[node_id]);
                }
                continue;
            }
            subset_dict.insert({new_location, component_id, global_index});
        }
    }
 
    return MeshComponentMap(subset_dict);
}

References MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::MeshSubset::getMesh(), MeshLib::MeshSubset::getMeshID(), MeshLib::Mesh::getName(), MeshLib::MeshSubset::getNodes(), MeshLib::Mesh::getProperties(), MeshLib::isBaseNode(), MeshLib::Node, and OGS_FATAL.

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

renumberByLocation()

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

private

Definition at line 142 of file MeshComponentMap.cpp.

{
    GlobalIndexType global_index = offset;
 
    auto& m = _dict.get<ByLocation>();  // view as sorted by mesh item
    for (auto itr_mesh_item = m.begin(); itr_mesh_item != m.end();
         ++itr_mesh_item)
    {
        Line pos = *itr_mesh_item;
        pos.global_index = global_index++;
        m.replace(itr_mesh_item, pos);
    }
}

References NumLib::detail::Line::global_index.

Friends And Related Function Documentation

operator<<

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

friend

Definition at line 148 of file MeshComponentMap.h.

    {
        os << "Dictionary size: " << m._dict.size() << "\n";
        for (auto l : m._dict)
            os << l << "\n";
        return os;
    }

Member Data Documentation

_dict

detail::ComponentGlobalIndexDict NumLib::MeshComponentMap::_dict

private

Definition at line 172 of file MeshComponentMap.h.

Referenced by dofSizeWithGhosts(), and getDictionary().

_ghosts_indices

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

private

Global ID for ghost entries.

Definition at line 184 of file MeshComponentMap.h.

Referenced by getGhostIndices().

_num_global_dof

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

private

Number of global unknowns. Used internally only.

Definition at line 180 of file MeshComponentMap.h.

_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 176 of file MeshComponentMap.h.

Referenced by dofSizeWithoutGhosts().

nop

GlobalIndexType const NumLib::MeshComponentMap::nop

static

Initial value:

=
    std::numeric_limits<GlobalIndexType>::max()

A value returned if no global index was found for the requested location/component. The value is implementation dependent.

Definition at line 140 of file MeshComponentMap.h.

Referenced by ProcessLib::PythonBoundaryConditionLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble(), ProcessLib::SourceTerms::Python::PythonSourceTermLocalAssembler< ShapeFunction, IntegrationMethod, GlobalDim >::assemble(), ProcessLib::ConstraintDirichletBoundaryCondition::getEssentialBCValues(), ProcessLib::PythonBoundaryCondition::getEssentialBCValues(), ProcessLib::PrimaryVariableConstraintDirichletBoundaryCondition::getEssentialBCValues(), ProcessLib::getEssentialBCValuesLocal(), NumLib::getNodalValue(), NumLib::getNonGhostNodalValue(), ProcessLib::NodalSourceTerm::integrate(), ProcessLib::LIE::HydroMechanics::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()(), and ProcessLib::LIE::SmallDeformation::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()().

---

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

• NumLib/DOF/MeshComponentMap.h
• NumLib/DOF/MeshComponentMap.cpp