NumLib::MeshComponentMap Class Reference

Detailed Description

Multidirectional mapping between mesh entities and degrees of freedom.

Definition at line 20 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< 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).
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 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

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

Definition at line 23 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 19 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 createParallelMeshComponentMap(), createSerialMeshComponentMap(), and MeshLib::NodePartitionedMesh::isForSingleThread().

Referenced by getSubset(), and operator<<.

MeshComponentMap() [2/2]

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

inlineexplicitprivate

Private constructor used by internally created mesh component maps.

Definition at line 148 of file MeshComponentMap.h.

        : _dict(dict)
    {
    }

References _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 375 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");
    }
 
    const MeshLib::NodePartitionedMesh& partitioned_mesh =
        static_cast<const MeshLib::NodePartitionedMesh&>(
            components[0].getMesh());
 
    //
    // get the number of unknowns and the number of components at extra node
    //
    GlobalIndexType num_unknowns = 0;
    int components_at_high_order_nodes = 0;
    for (auto const& c : components)
    {
        if (partitioned_mesh.getNumberOfNodes() == c.getNodes().size())
        {
            components_at_high_order_nodes++;
            num_unknowns += partitioned_mesh.getNumberOfGlobalNodes();
        }
        else
        {
            num_unknowns += partitioned_mesh.getNumberOfGlobalBaseNodes();
        }
    }
 
    // construct dict (and here we number global_index by component type)
    //
    int const n_components = components.size();
 
    int comp_id = 0;
    int comp_id_at_high_order_node = 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());
        const auto& sub_mesh_nodes = c.getNodes();
 
        // mesh items are ordered first by node, cell, ....
        for (std::size_t j = 0; j < sub_mesh_nodes.size(); j++)
        {
            const auto node_id = sub_mesh_nodes[j]->getID();
            const bool is_base_node =
                MeshLib::isBaseNode(*sub_mesh_nodes[j],
                                    partitioned_mesh.getElementsConnectedToNode(
                                        *sub_mesh_nodes[j]));
 
            const auto global_node_id =
                partitioned_mesh.getGlobalNodeID(node_id);
            GlobalIndexType global_index =
                (!c.useTaylorHoodElements())
                    ? static_cast<GlobalIndexType>(
                          n_components * global_node_id + comp_id)
                    : getGlobalIndexWithTaylorHoodElement(
                          partitioned_mesh, global_node_id, n_components,
                          components_at_high_order_nodes, comp_id,
                          comp_id_at_high_order_node, is_base_node);
            const bool is_ghost = partitioned_mesh.isGhostNode(node_id);
            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, node_id),
                     comp_id, global_index));
        }
 
        bool const use_whole_nodes =
            (partitioned_mesh.getNumberOfNodes() == c.getNodes().size());
        if (use_whole_nodes)
        {
            _num_global_dof += partitioned_mesh.getNumberOfGlobalNodes();
            comp_id_at_high_order_node++;
        }
        else
        {
            _num_global_dof += partitioned_mesh.getNumberOfGlobalBaseNodes();
        }
 
        comp_id++;
    }
}

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

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

Definition at line 286 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 (auto const node_id : c.getNodes() | MeshLib::views::ids)
        {
            _dict.insert(
                Line(Location(mesh_id, MeshLib::MeshItemType::Node, node_id),
                     comp_id, global_index++));
        }
        comp_id++;
    }
    _num_local_dof = _dict.size();
 
    if (order == ComponentOrder::BY_LOCATION)
    {
        renumberByLocation();
    }
}

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

{ return _dict.size(); }

References _dict.

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

{ return _num_local_dof; }

References _num_local_dof.

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 145 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;
}

References _dict.

Referenced by getSubset().

getDictionary()

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

inline

Definition at line 132 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 112 of file MeshComponentMap.h.

    {
        return _ghosts_indices;
    }

References _ghosts_indices.

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 157 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;
}

References _dict, and nop.

Referenced by 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 165 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;
}

References _dict.

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 200 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;
}

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 178 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;
}

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

{
    GlobalIndexType const global_index = getGlobalIndex(l, comp_id);
    // request for index of linear quantities at higher order nodes
    // results in returning nop
    // That index shall not be modified like a usual global index.
    if (global_index == nop)
    {
        return nop;
    }
#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 _ghosts_indices, _num_global_dof, getGlobalIndex(), nop, and OGS_FATAL.

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_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.

Definition at line 44 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 bulk_node_ids = [](auto const& mesh)
    {
        auto const* bulk_node_ids_ptr = MeshLib::bulkNodeIDs(mesh);
        if (bulk_node_ids_ptr == nullptr)
        {
            OGS_FATAL(
                "Bulk node ids map expected in the construction of the mesh "
                "subset.");
        }
        return *bulk_node_ids_ptr;
    };
    auto const& bulk_node_ids_map = bulk_node_ids(new_mesh_subset.getMesh());
 
    // 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 : getComponentIDs(bulk_location))
        {
            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 than 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 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.

renumberByLocation()

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

private

Definition at line 131 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 _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 137 of file MeshComponentMap.h.

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

References MeshComponentMap(), and _dict.

Member Data Documentation

_dict

detail::ComponentGlobalIndexDict NumLib::MeshComponentMap::_dict

private

Definition at line 155 of file MeshComponentMap.h.

Referenced by MeshComponentMap(), createParallelMeshComponentMap(), createSerialMeshComponentMap(), dofSizeWithGhosts(), getComponentIDs(), getDictionary(), getGlobalIndex(), getGlobalIndices(), getGlobalIndicesByComponent(), getGlobalIndicesByLocation(), operator<<, and renumberByLocation().

_ghosts_indices

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

private

Global ID for ghost entries.

Definition at line 167 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 163 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 159 of file MeshComponentMap.h.

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

nop

NUMLIB_EXPORT GlobalIndexType const NumLib::MeshComponentMap::nop

staticconstexpr

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

Referenced by addPrimaryVariablesToMesh(), anonymous_namespace{CollectAndInterpolateNodalDof.cpp}::collectDofsToMatrixSingleComponentForSomeNodes(), ProcessLib::PythonBoundaryCondition::collectPrimaryVariables(), ProcessLib::ConstraintDirichletBoundaryCondition::getEssentialBCValues(), ProcessLib::PrimaryVariableConstraintDirichletBoundaryCondition::getEssentialBCValues(), ProcessLib::PythonBoundaryCondition::getEssentialBCValues(), ProcessLib::TimeDecayDirichletBoundaryCondition::getEssentialBCValues(), ProcessLib::getEssentialBCValuesLocal(), getGlobalIndex(), getLocalIndex(), NumLib::getNodalValue(), NumLib::getNonGhostNodalValue(), getSubset(), ProcessLib::NodalSourceTerm::integrate(), ProcessLib::LIE::HydroMechanics::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, DisplacementDim, ConstructorArgs >::operator()(), ProcessLib::LIE::SmallDeformation::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, DisplacementDim, ConstructorArgs >::operator()(), ProcessLib::ReleaseNodalForce::set(), ProcessLib::TimeDecayDirichletBoundaryCondition::setInitialValues(), and NumLib::transformVariableFromGlobalVector().

---

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

• MeshComponentMap.h
• MeshComponentMap.cpp