Detailed Description

Row and column indices in global linear algebra objects for each mesh item.

The row and column indices in global matrix and rhs vector for example, required for addition of local contributions from every mesh item (like node or cell) to global objects.

The number of rows should be equal to the number of mesh items and the number of columns should be equal to the number of the components on that mesh item.

Definition at line 33 of file LocalToGlobalIndexMap.h.

#include <LocalToGlobalIndexMap.h>

Collaboration diagram for NumLib::LocalToGlobalIndexMap:

[legend]

Classes
struct	ConstructorTag

Public Types
using	RowColumnIndices = MathLib::RowColumnIndices<GlobalIndexType>
using	LineIndex = RowColumnIndices::LineIndex

Public Member Functions
	LocalToGlobalIndexMap (std::vector< MeshLib::MeshSubset > &&mesh_subsets, NumLib::ComponentOrder const order)
	LocalToGlobalIndexMap (std::vector< MeshLib::MeshSubset > &&mesh_subsets, std::vector< int > const &vec_var_n_components, NumLib::ComponentOrder const order)
	LocalToGlobalIndexMap (std::vector< MeshLib::MeshSubset > &&mesh_subsets, std::vector< int > const &vec_var_n_components, std::vector< std::vector< MeshLib::Element * > const * > const &vec_var_elements, NumLib::ComponentOrder const order)
std::unique_ptr< LocalToGlobalIndexMap >	deriveBoundaryConstrainedMap (int const variable_id, std::vector< int > const &component_ids, MeshLib::MeshSubset &&new_mesh_subset) const
std::unique_ptr< LocalToGlobalIndexMap >	deriveBoundaryConstrainedMap (MeshLib::MeshSubset &&new_mesh_subset) const
std::size_t	dofSizeWithGhosts () const
std::size_t	dofSizeWithoutGhosts () const
std::size_t	size () const
int	getNumberOfVariables () const
int	getNumberOfVariableComponents (int variable_id) const
int	getNumberOfGlobalComponents () const
RowColumnIndices	operator() (std::size_t const mesh_item_id, const int global_component_id) const
std::size_t	getNumberOfElementDOF (std::size_t const mesh_item_id) const
std::size_t	getNumberOfElementComponents (std::size_t const mesh_item_id) const
std::vector< int >	getElementVariableIDs (std::size_t const mesh_item_id) const
GlobalIndexType	getGlobalIndex (MeshLib::Location const &l, int const variable_id, int const component_id) const
GlobalIndexType	getGlobalIndex (MeshLib::Location const &l, int const global_component_id) const
std::vector< GlobalIndexType >	getGlobalIndices (const MeshLib::Location &l) const
	Forwards the respective method from MeshComponentMap.
std::vector< GlobalIndexType > const &	getGhostIndices () const
	Get ghost indices, forwarded from MeshComponentMap.
GlobalIndexType	getLocalIndex (MeshLib::Location const &l, std::size_t const comp_id, std::size_t const range_begin, std::size_t const range_end) const
MeshLib::MeshSubset const &	getMeshSubset (int const variable_id, int const component_id) const
MeshLib::MeshSubset const &	getMeshSubset (int const global_component_id) const
int	getGlobalComponent (int const variable_id, int const component_id) const
	LocalToGlobalIndexMap (std::vector< MeshLib::MeshSubset > &&mesh_subsets, std::vector< int > const &global_component_ids, std::vector< int > const &variable_component_offsets, std::vector< MeshLib::Element * > const &elements, NumLib::MeshComponentMap &&mesh_component_map, ConstructorTag)

Private Types
using	Table

Private Member Functions
template<typename ElementIterator>
void	findGlobalIndices (ElementIterator first, ElementIterator last, std::vector< MeshLib::Node * > const &nodes, std::size_t const mesh_id, const int comp_id, const int comp_id_write)
template<typename ElementIterator>
void	findGlobalIndicesWithElementID (ElementIterator first, ElementIterator last, std::vector< MeshLib::Node * > const &nodes, std::size_t const mesh_id, const int comp_id, const int comp_id_write)

Private Attributes
std::vector< MeshLib::MeshSubset >	_mesh_subsets
	A vector of mesh subsets for each process variables' components.
NumLib::MeshComponentMap	_mesh_component_map
Table	_rows
Table const &	_columns = _rows
std::vector< int > const	_variable_component_offsets

Friends
std::ostream &	operator<< (std::ostream &os, LocalToGlobalIndexMap const &map)
	Prints first rows of the table, every line, and the mesh component map.

Member Typedef Documentation

◆ LineIndex

using NumLib::LocalToGlobalIndexMap::LineIndex = RowColumnIndices::LineIndex

Definition at line 45 of file LocalToGlobalIndexMap.h.

◆ RowColumnIndices

using NumLib::LocalToGlobalIndexMap::RowColumnIndices = MathLib::RowColumnIndices<GlobalIndexType>

Definition at line 44 of file LocalToGlobalIndexMap.h.

◆ Table

using NumLib::LocalToGlobalIndexMap::Table

private

Initial value:

Eigen::Matrix<LineIndex, Eigen::Dynamic, Eigen::Dynamic,

Eigen::RowMajor>

NumLib::LocalToGlobalIndexMap::LineIndex

RowColumnIndices::LineIndex LineIndex

Definition LocalToGlobalIndexMap.h:45

Definition at line 190 of file LocalToGlobalIndexMap.h.

Constructor & Destructor Documentation

◆ LocalToGlobalIndexMap() [1/4]

NumLib::LocalToGlobalIndexMap::LocalToGlobalIndexMap	(	std::vector< MeshLib::MeshSubset > &&	mesh_subsets,
		NumLib::ComponentOrder const	order )

Creates a MeshComponentMap internally and stores the global indices for each mesh element of the given mesh_subsets.

Attention: This constructor assumes the number of the given mesh subsets is equal to the number of variables, i.e. every variable has a single component.

Definition at line 98 of file LocalToGlobalIndexMap.cpp.

    : LocalToGlobalIndexMap(std::move(mesh_subsets),
                            std::vector<int>(mesh_subsets.size(), 1), order)
{
}

References LocalToGlobalIndexMap(), and size().

Referenced by LocalToGlobalIndexMap(), and operator<<.

◆ LocalToGlobalIndexMap() [2/4]

NumLib::LocalToGlobalIndexMap::LocalToGlobalIndexMap	(	std::vector< MeshLib::MeshSubset > &&	mesh_subsets,
		std::vector< int > const &	vec_var_n_components,
		NumLib::ComponentOrder const	order )

Creates a MeshComponentMap internally and stores the global indices for each mesh element of the given mesh_subsets.

Parameters

mesh_subsets	a vector of components
vec_var_n_components	a vector of the number of variable components. The size of the vector should be equal to the number of variables. Sum of the entries should be equal to the size of the mesh_subsets.
order	type of ordering values in a vector

Definition at line 106 of file LocalToGlobalIndexMap.cpp.

    : _mesh_subsets(std::move(mesh_subsets)),
      _mesh_component_map(_mesh_subsets, order),
      _variable_component_offsets(BaseLib::sizesToOffsets(vec_var_n_components))
{
    // For each element of that MeshSubset save a line of global indices.
    for (int variable_id = 0;
         variable_id < static_cast<int>(vec_var_n_components.size());
         ++variable_id)
    {
        for (int component_id = 0;
             component_id < static_cast<int>(vec_var_n_components[variable_id]);
             ++component_id)
        {
            auto const global_component_id =
                getGlobalComponent(variable_id, component_id);
 
            auto const& ms = _mesh_subsets[global_component_id];
            std::size_t const mesh_id = ms.getMeshID();
 
            findGlobalIndices(ms.elementsBegin(), ms.elementsEnd(),
                              ms.getNodes(), mesh_id, global_component_id,
                              global_component_id);
        }
    }
}

References _mesh_component_map, _mesh_subsets, _variable_component_offsets, findGlobalIndices(), and getGlobalComponent().

◆ LocalToGlobalIndexMap() [3/4]

NumLib::LocalToGlobalIndexMap::LocalToGlobalIndexMap	(	std::vector< MeshLib::MeshSubset > &&	mesh_subsets,
		std::vector< int > const &	vec_var_n_components,
		std::vector< std::vector< MeshLib::Element * > const * > const &	vec_var_elements,
		NumLib::ComponentOrder const	order )

Creates a MeshComponentMap internally and stores the global indices for the given mesh elements

Parameters

mesh_subsets	a vector of components
vec_var_n_components	a vector of the number of variable components. The size of the vector should be equal to the number of variables. Sum of the entries should be equal to the size of the mesh_subsets.
vec_var_elements	a vector of active mesh elements for each variable.
order	type of ordering values in a vector

Definition at line 136 of file LocalToGlobalIndexMap.cpp.

    : _mesh_subsets(std::move(mesh_subsets)),
      _mesh_component_map(_mesh_subsets, order),
      _variable_component_offsets(BaseLib::sizesToOffsets(vec_var_n_components))
{
    assert(vec_var_n_components.size() == vec_var_elements.size());
 
    // For each element of that MeshSubset save a line of global indices.
 
    // _rows should be resized based on an element ID
    std::size_t max_elem_id = 0;
    for (std::vector<MeshLib::Element*> const* elements : vec_var_elements)
    {
        for (auto e : *elements)
        {
            max_elem_id = std::max(max_elem_id, e->getID());
        }
    }
    _rows.resize(max_elem_id + 1, _mesh_subsets.size());
 
    for (int variable_id = 0;
         variable_id < static_cast<int>(vec_var_n_components.size());
         ++variable_id)
    {
        std::vector<MeshLib::Element*> const& var_elements =
            *vec_var_elements[variable_id];
        for (int component_id = 0;
             component_id < static_cast<int>(vec_var_n_components[variable_id]);
             ++component_id)
        {
            auto const global_component_id =
                getGlobalComponent(variable_id, component_id);
 
            auto const& ms = _mesh_subsets[global_component_id];
            std::size_t const mesh_id = ms.getMeshID();
 
            findGlobalIndicesWithElementID(
                var_elements.cbegin(), var_elements.cend(), ms.getNodes(),
                mesh_id, global_component_id, global_component_id);
        }
    }
}

References _mesh_component_map, _mesh_subsets, _rows, _variable_component_offsets, findGlobalIndicesWithElementID(), and getGlobalComponent().

◆ LocalToGlobalIndexMap() [4/4]

NumLib::LocalToGlobalIndexMap::LocalToGlobalIndexMap	(	std::vector< MeshLib::MeshSubset > &&	mesh_subsets,
		std::vector< int > const &	global_component_ids,
		std::vector< int > const &	variable_component_offsets,
		std::vector< MeshLib::Element * > const &	elements,
		NumLib::MeshComponentMap &&	mesh_component_map,
		LocalToGlobalIndexMap::ConstructorTag	)

explicit

Private constructor (ensured by ConstructorTag) used by internally created local-to-global index maps. The mesh_component_map is passed as argument instead of being created by the constructor.

Attention: The passed mesh_component_map is in undefined state after this constructor.

Definition at line 183 of file LocalToGlobalIndexMap.cpp.

    : _mesh_subsets(std::move(mesh_subsets)),
      _mesh_component_map(std::move(mesh_component_map)),
      _variable_component_offsets(variable_component_offsets)
{
    // Each subset in the mesh_subsets represents a single component.
    if (_mesh_subsets.size() != global_component_ids.size())
    {
        OGS_FATAL(
            "Number of mesh subsets is not equal to number of components. "
            "There are {:d} mesh subsets and {:d} components.",
            _mesh_subsets.size(), global_component_ids.size());
    }
 
    for (int i = 0; i < static_cast<int>(global_component_ids.size()); ++i)
    {
        auto const& ms = _mesh_subsets[i];
 
        // For all MeshSubset in mesh_subsets and each element of that
        // MeshSubset save a line of global indices.
        std::size_t const mesh_id = ms.getMeshID();
 
        findGlobalIndices(elements.cbegin(), elements.cend(), ms.getNodes(),
                          mesh_id, global_component_ids[i], i);
    }
}

References _mesh_component_map, _mesh_subsets, _variable_component_offsets, and findGlobalIndices().

Member Function Documentation

◆ deriveBoundaryConstrainedMap() [1/2]

std::unique_ptr< LocalToGlobalIndexMap > NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap	(	int const	variable_id,
		std::vector< int > const &	component_ids,
		MeshLib::MeshSubset &&	new_mesh_subset ) const

Derive a LocalToGlobalIndexMap constrained to the mesh subset and mesh subset's elements. A new mesh component map will be constructed using the passed mesh_subset for the given variable and component ids.

Definition at line 217 of file LocalToGlobalIndexMap.cpp.

{
    DBUG("Construct reduced local to global index map.");
 
    if (component_ids.empty())
    {
        OGS_FATAL("Expected non-empty vector of component ids.");
    }
 
    // Elements of the new_mesh_subset's mesh.
    std::vector<MeshLib::Element*> const& elements =
        new_mesh_subset.getMesh().getElements();
 
    // Create a subset of the current mesh component map.
    std::vector<int> global_component_ids;
 
    transform(cbegin(component_ids), cend(component_ids),
              back_inserter(global_component_ids),
              [&](auto const component_id)
              { return getGlobalComponent(variable_id, component_id); });
 
    auto mesh_component_map =
        _mesh_component_map.getSubset(_mesh_subsets, new_mesh_subset);
 
    // Create copies of the new_mesh_subset for each of the global components.
    // The last component is moved after the for-loop.
    std::vector<MeshLib::MeshSubset> all_mesh_subsets;
    for (int i = 0; i < static_cast<int>(global_component_ids.size()) - 1; ++i)
    {
        all_mesh_subsets.emplace_back(new_mesh_subset);
    }
    all_mesh_subsets.emplace_back(std::move(new_mesh_subset));
 
    return std::make_unique<LocalToGlobalIndexMap>(
        std::move(all_mesh_subsets), global_component_ids,
        _variable_component_offsets, elements, std::move(mesh_component_map),
        ConstructorTag{});
}

References _mesh_component_map, _mesh_subsets, _variable_component_offsets, DBUG(), getGlobalComponent(), and OGS_FATAL.

◆ deriveBoundaryConstrainedMap() [2/2]

std::unique_ptr< LocalToGlobalIndexMap > NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap ( MeshLib::MeshSubset && new_mesh_subset ) const

Derive a LocalToGlobalIndexMap constrained to the mesh subset and mesh subset's elements. A new mesh component map will be constructed using the passed mesh_subset for all variables and components of the current LocalToGlobalIndexMap.

Definition at line 260 of file LocalToGlobalIndexMap.cpp.

{
    DBUG("Construct reduced local to global index map.");
 
    // Create a subset of the current mesh component map.
    std::vector<int> global_component_ids;
 
    for (int i = 0; i < getNumberOfGlobalComponents(); ++i)
    {
        global_component_ids.push_back(i);
    }
 
    // Elements of the new_mesh_subset's mesh.
    std::vector<MeshLib::Element*> const& elements =
        new_mesh_subset.getMesh().getElements();
 
    auto mesh_component_map =
        _mesh_component_map.getSubset(_mesh_subsets, new_mesh_subset);
 
    // Create copies of the new_mesh_subset for each of the global components.
    // The last component is moved after the for-loop.
    std::vector<MeshLib::MeshSubset> all_mesh_subsets;
    for (int i = 0; i < static_cast<int>(global_component_ids.size()) - 1; ++i)
    {
        all_mesh_subsets.emplace_back(new_mesh_subset);
    }
    all_mesh_subsets.emplace_back(std::move(new_mesh_subset));
 
    return std::make_unique<LocalToGlobalIndexMap>(
        std::move(all_mesh_subsets), global_component_ids,
        _variable_component_offsets, elements, std::move(mesh_component_map),
        ConstructorTag{});
}

References _mesh_component_map, _mesh_subsets, _variable_component_offsets, DBUG(), and getNumberOfGlobalComponents().

◆ dofSizeWithGhosts()

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

Returns total number of degrees of freedom including those located in the ghost nodes.

Definition at line 295 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.dofSizeWithGhosts();
}

References _mesh_component_map.

◆ dofSizeWithoutGhosts()

std::size_t NumLib::LocalToGlobalIndexMap::dofSizeWithoutGhosts ( ) const

Returns total number of local degrees of freedom of the present rank, which does not count the unknowns associated with ghost nodes (for DDC with node-wise mesh partitioning).

Definition at line 300 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.dofSizeWithoutGhosts();
}

References _mesh_component_map.

◆ findGlobalIndices()

template<typename ElementIterator>

void NumLib::LocalToGlobalIndexMap::findGlobalIndices	(	ElementIterator	first,
		ElementIterator	last,
		std::vector< MeshLib::Node * > const &	nodes,
		std::size_t const	mesh_id,
		const int	comp_id,
		const int	comp_id_write )

private

Definition at line 55 of file LocalToGlobalIndexMap.cpp.

{
    _rows.resize(std::distance(first, last), _mesh_subsets.size());
 
    std::unordered_set<MeshLib::Node*> const set_nodes(nodes.begin(),
                                                       nodes.end());
 
    // For each element find the global indices for node/element
    // components.
    std::size_t elem_id = 0;
    for (ElementIterator e = first; e != last; ++e, ++elem_id)
    {
        LineIndex indices;
        indices.reserve((*e)->getNumberOfNodes());
 
        for (auto* n = (*e)->getNodes();
             n < (*e)->getNodes() + (*e)->getNumberOfNodes();
             ++n)
        {
            // Check if the element's node is in the given list of nodes.
            if (set_nodes.find(*n) == set_nodes.end())
            {
                continue;
            }
            MeshLib::Location l(mesh_id, MeshLib::MeshItemType::Node,
                                (*n)->getID());
            auto const global_index =
                _mesh_component_map.getGlobalIndex(l, comp_id);
            if (global_index == std::numeric_limits<GlobalIndexType>::max())
            {
                continue;
            }
            indices.push_back(global_index);
        }
 
        indices.shrink_to_fit();
        _rows(elem_id, comp_id_write) = std::move(indices);
    }
}

References _mesh_component_map, _mesh_subsets, _rows, and MeshLib::Node.

Referenced by LocalToGlobalIndexMap(), and LocalToGlobalIndexMap().

◆ findGlobalIndicesWithElementID()

template<typename ElementIterator>

void NumLib::LocalToGlobalIndexMap::findGlobalIndicesWithElementID	(	ElementIterator	first,
		ElementIterator	last,
		std::vector< MeshLib::Node * > const &	nodes,
		std::size_t const	mesh_id,
		const int	comp_id,
		const int	comp_id_write )

private

Definition at line 20 of file LocalToGlobalIndexMap.cpp.

{
    std::unordered_set<MeshLib::Node*> const set_nodes(nodes.begin(),
                                                       nodes.end());
 
    // For each element find the global indices for node/element
    // components.
    for (ElementIterator e = first; e != last; ++e)
    {
        LineIndex indices;
        indices.reserve((*e)->getNumberOfNodes());
 
        for (auto* n = (*e)->getNodes();
             n < (*e)->getNodes() + (*e)->getNumberOfNodes();
             ++n)
        {
            // Check if the element's node is in the given list of nodes.
            if (set_nodes.find(*n) == set_nodes.end())
            {
                continue;
            }
            MeshLib::Location l(mesh_id, MeshLib::MeshItemType::Node,
                                (*n)->getID());
            indices.push_back(_mesh_component_map.getGlobalIndex(l, comp_id));
        }
 
        indices.shrink_to_fit();
        _rows((*e)->getID(), comp_id_write) = std::move(indices);
    }
}

References _mesh_component_map, _rows, and MeshLib::Node.

Referenced by LocalToGlobalIndexMap().

◆ getElementVariableIDs()

std::vector< int > NumLib::LocalToGlobalIndexMap::getElementVariableIDs ( std::size_t const mesh_item_id ) const

Definition at line 361 of file LocalToGlobalIndexMap.cpp.

{
    std::vector<int> vec;
    for (int i = 0; i < getNumberOfVariables(); i++)
    {
        for (int j = 0; j < getNumberOfVariableComponents(i); j++)
        {
            auto comp_id = getGlobalComponent(i, j);
            if (!_rows(mesh_item_id, comp_id).empty())
            {
                vec.push_back(i);
            }
        }
    }
    std::sort(vec.begin(), vec.end());
    vec.erase(std::unique(vec.begin(), vec.end()), vec.end());
 
    return vec;
}

References _rows, getGlobalComponent(), getNumberOfVariableComponents(), and getNumberOfVariables().

◆ getGhostIndices()

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

Get ghost indices, forwarded from MeshComponentMap.

Definition at line 405 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.getGhostIndices();
}

References _mesh_component_map.

◆ getGlobalComponent()

int NumLib::LocalToGlobalIndexMap::getGlobalComponent	(	int const	variable_id,
		int const	component_id ) const

The global component id for the specific variable (like velocity) and a component (like x, or y, or z).

Definition at line 13 of file LocalToGlobalIndexMap.cpp.

{
    return _variable_component_offsets[variable_id] + component_id;
}

References _variable_component_offsets.

Referenced by LocalToGlobalIndexMap(), LocalToGlobalIndexMap(), ProcessLib::BoundaryConditionAndSourceTerm::Python::collectDofsToMatrix(), ProcessLib::createPythonBoundaryCondition(), deriveBoundaryConstrainedMap(), getElementVariableIDs(), getGlobalIndex(), NumLib::getIndices(), and getMeshSubset().

◆ getGlobalIndex() [1/2]

GlobalIndexType NumLib::LocalToGlobalIndexMap::getGlobalIndex	(	MeshLib::Location const &	l,
		int const	global_component_id ) const

Definition at line 391 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.getGlobalIndex(l, global_component_id);
}

References _mesh_component_map.

◆ getGlobalIndex() [2/2]

GlobalIndexType NumLib::LocalToGlobalIndexMap::getGlobalIndex	(	MeshLib::Location const &	l,
		int const	variable_id,
		int const	component_id ) const

Definition at line 382 of file LocalToGlobalIndexMap.cpp.

{
    auto const c = getGlobalComponent(variable_id, component_id);
    return _mesh_component_map.getGlobalIndex(l, c);
}

References _mesh_component_map, and getGlobalComponent().

Referenced by anonymous_namespace{CollectAndInterpolateNodalDof.cpp}::collectDofsToMatrixSingleComponentForSomeNodes(), ProcessLib::getEssentialBCValuesLocal(), NumLib::getIndices(), NumLib::getNodalValue(), NumLib::getNonGhostNodalValue(), NumLib::transformVariableFromGlobalVector(), and NumLib::transformVariableFromGlobalVector().

◆ getGlobalIndices()

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

Forwards the respective method from MeshComponentMap.

Definition at line 398 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.getGlobalIndices(l);
}

References _mesh_component_map.

◆ getLocalIndex()

GlobalIndexType NumLib::LocalToGlobalIndexMap::getLocalIndex	(	MeshLib::Location const &	l,
		std::size_t 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; forwarded from MeshComponentMap.

Definition at line 413 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.getLocalIndex(l, comp_id, range_begin,
                                             range_end);
}

References _mesh_component_map.

Referenced by getIndexForComponentInSolutionVector().

◆ getMeshSubset() [1/2]

MeshLib::MeshSubset const & NumLib::LocalToGlobalIndexMap::getMeshSubset ( int const global_component_id ) const

Definition at line 427 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_subsets[global_component_id];
}

References _mesh_subsets.

◆ getMeshSubset() [2/2]

MeshLib::MeshSubset const & NumLib::LocalToGlobalIndexMap::getMeshSubset	(	int const	variable_id,
		int const	component_id ) const

Definition at line 421 of file LocalToGlobalIndexMap.cpp.

{
    return getMeshSubset(getGlobalComponent(variable_id, component_id));
}

References getGlobalComponent(), and getMeshSubset().

Referenced by addPrimaryVariablesToMesh(), ProcessLib::createSourceTerm(), NumLib::getIndices(), getMeshSubset(), NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm(), NumLib::transformVariableFromGlobalVector(), and NumLib::transformVariableFromGlobalVector().

◆ getNumberOfElementComponents()

std::size_t NumLib::LocalToGlobalIndexMap::getNumberOfElementComponents ( std::size_t const mesh_item_id ) const

Definition at line 347 of file LocalToGlobalIndexMap.cpp.

{
    std::size_t n = 0;
    for (Table::Index c = 0; c < _rows.cols(); ++c)
    {
        if (!_rows(mesh_item_id, c).empty())
        {
            n++;
        }
    }
    return n;
}

References _rows.

◆ getNumberOfElementDOF()

std::size_t NumLib::LocalToGlobalIndexMap::getNumberOfElementDOF ( std::size_t const mesh_item_id ) const

Definition at line 334 of file LocalToGlobalIndexMap.cpp.

{
    std::size_t ndof = 0;
 
    for (Table::Index c = 0; c < _rows.cols(); ++c)
    {
        ndof += _rows(mesh_item_id, c).size();
    }
 
    return ndof;
}

References _rows.

◆ getNumberOfGlobalComponents()

int NumLib::LocalToGlobalIndexMap::getNumberOfGlobalComponents ( ) const

Definition at line 317 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_subsets.size();
}

References _mesh_subsets.

Referenced by NumLib::LocalLinearLeastSquaresExtrapolator::LocalLinearLeastSquaresExtrapolator(), addPrimaryVariablesToMesh(), ProcessLib::BoundaryConditionAndSourceTerm::Python::BcAndStLocalAssemblerImpl< BcOrStData, ShapeFunction, LowerOrderShapeFunction, GlobalDim >::assemble(), ProcessLib::BoundaryConditionAndSourceTerm::Python::collectDofsToMatrix(), computeSparsityPatternPETSc(), deriveBoundaryConstrainedMap(), NumLib::getIndices(), NumLib::getRowColumnIndices(), and operator<<.

◆ getNumberOfVariableComponents()

int NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents ( int variable_id ) const

Definition at line 310 of file LocalToGlobalIndexMap.cpp.

{
    assert(variable_id < getNumberOfVariables());
    return _variable_component_offsets[variable_id + 1] -
           _variable_component_offsets[variable_id];
}

References _variable_component_offsets, and getNumberOfVariables().

Referenced by ProcessLib::ConstraintDirichletBoundaryCondition::ConstraintDirichletBoundaryCondition(), ProcessLib::PhaseFieldIrreversibleDamageOracleBoundaryCondition::PhaseFieldIrreversibleDamageOracleBoundaryCondition(), anonymous_namespace{PythonBoundaryCondition.cpp}::checkConsistency(), ProcessLib::checkParametersOfDirichletBoundaryCondition(), ProcessLib::BoundaryConditionAndSourceTerm::Python::collectDofsToMatrix(), ProcessLib::ProcessVariable::createBoundaryConditionsForDeactivatedSubDomains(), ProcessLib::createPythonBoundaryCondition(), ProcessLib::createReleaseNodalForce(), ProcessLib::createSourceTerm(), getElementVariableIDs(), NumLib::transformVariableFromGlobalVector(), and NumLib::transformVariableFromGlobalVector().

◆ getNumberOfVariables()

int NumLib::LocalToGlobalIndexMap::getNumberOfVariables ( ) const

Definition at line 305 of file LocalToGlobalIndexMap.cpp.

{
    return static_cast<int>(_variable_component_offsets.size()) - 1;
}

References _variable_component_offsets.

Referenced by ProcessLib::ConstraintDirichletBoundaryCondition::ConstraintDirichletBoundaryCondition(), ProcessLib::PhaseFieldIrreversibleDamageOracleBoundaryCondition::PhaseFieldIrreversibleDamageOracleBoundaryCondition(), addPrimaryVariablesToMesh(), anonymous_namespace{PythonBoundaryCondition.cpp}::checkConsistency(), ProcessLib::checkParametersOfDirichletBoundaryCondition(), ProcessLib::BoundaryConditionAndSourceTerm::Python::collectDofsToMatrix(), ProcessLib::createPythonBoundaryCondition(), ProcessLib::createSourceTerm(), ProcessLib::createVariableDependentNeumannBoundaryCondition(), ProcessLib::createWellboreCompensateNeumannBoundaryCondition(), getElementVariableIDs(), and getNumberOfVariableComponents().

◆ operator()()

LocalToGlobalIndexMap::RowColumnIndices NumLib::LocalToGlobalIndexMap::operator()	(	std::size_t const	mesh_item_id,
		const int	global_component_id ) const

Definition at line 327 of file LocalToGlobalIndexMap.cpp.

{
    return RowColumnIndices(_rows(mesh_item_id, global_component_id),
                            _columns(mesh_item_id, global_component_id));
}

References _columns, and _rows.

◆ size()

std::size_t NumLib::LocalToGlobalIndexMap::size ( ) const

Definition at line 322 of file LocalToGlobalIndexMap.cpp.

{
    return _rows.rows();
}

References _rows.

Referenced by LocalToGlobalIndexMap(), ProcessLib::BoundaryConditionAndSourceTerm::Python::BcAndStLocalAssemblerImpl< BcOrStData, ShapeFunction, LowerOrderShapeFunction, GlobalDim >::assemble(), NumLib::getIndices(), NumLib::getRowColumnIndices(), and operator<<.

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		LocalToGlobalIndexMap const &	map )

friend

Prints first rows of the table, every line, and the mesh component map.

Definition at line 434 of file LocalToGlobalIndexMap.cpp.

{
    std::size_t const max_lines = 10;
    std::size_t lines_printed = 0;
 
    os << "Rows of the local to global index map; " << map._rows.size()
       << " rows\n";
    for (std::size_t e = 0; e < map.size(); ++e)
    {
        os << "== e " << e << " ==\n";
        for (int c = 0; c < map.getNumberOfGlobalComponents(); ++c)
        {
            auto const& line = map._rows(e, c);
 
            os << "c" << c << " { ";
            std::copy(line.cbegin(), line.cend(),
                      std::ostream_iterator<std::size_t>(os, " "));
            os << " }\n";
        }
 
        if (lines_printed++ > max_lines)
        {
            os << "...\n";
            break;
        }
    }
 
    os << "Mesh component map:\n" << map._mesh_component_map;
    return os;
}

References LocalToGlobalIndexMap(), _mesh_component_map, _rows, getNumberOfGlobalComponents(), and size().

Member Data Documentation

◆ _columns

Table const& NumLib::LocalToGlobalIndexMap::_columns = _rows

private

See also: _rows

Definition at line 199 of file LocalToGlobalIndexMap.h.

Referenced by operator()().

◆ _mesh_component_map

NumLib::MeshComponentMap NumLib::LocalToGlobalIndexMap::_mesh_component_map

private

Definition at line 188 of file LocalToGlobalIndexMap.h.

Referenced by LocalToGlobalIndexMap(), LocalToGlobalIndexMap(), LocalToGlobalIndexMap(), deriveBoundaryConstrainedMap(), deriveBoundaryConstrainedMap(), dofSizeWithGhosts(), dofSizeWithoutGhosts(), findGlobalIndices(), findGlobalIndicesWithElementID(), getGhostIndices(), getGlobalIndex(), getGlobalIndex(), getGlobalIndices(), getLocalIndex(), and operator<<.

◆ _mesh_subsets

std::vector<MeshLib::MeshSubset> NumLib::LocalToGlobalIndexMap::_mesh_subsets

private

A vector of mesh subsets for each process variables' components.

Definition at line 187 of file LocalToGlobalIndexMap.h.

Referenced by LocalToGlobalIndexMap(), LocalToGlobalIndexMap(), LocalToGlobalIndexMap(), deriveBoundaryConstrainedMap(), deriveBoundaryConstrainedMap(), findGlobalIndices(), getMeshSubset(), and getNumberOfGlobalComponents().

◆ _rows

Table NumLib::LocalToGlobalIndexMap::_rows

private

Table contains for each element (first index) and each component (second index) a vector (LineIndex) of indices in the global stiffness matrix or vector

Definition at line 196 of file LocalToGlobalIndexMap.h.

Referenced by LocalToGlobalIndexMap(), findGlobalIndices(), findGlobalIndicesWithElementID(), getElementVariableIDs(), getNumberOfElementComponents(), getNumberOfElementDOF(), operator()(), operator<<, and size().

◆ _variable_component_offsets

std::vector<int> const NumLib::LocalToGlobalIndexMap::_variable_component_offsets

private

Definition at line 201 of file LocalToGlobalIndexMap.h.

Referenced by LocalToGlobalIndexMap(), LocalToGlobalIndexMap(), LocalToGlobalIndexMap(), deriveBoundaryConstrainedMap(), deriveBoundaryConstrainedMap(), getGlobalComponent(), getNumberOfVariableComponents(), and getNumberOfVariables().

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

Detailed Description

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Member Typedef Documentation

◆ LineIndex

◆ RowColumnIndices

◆ Table

Constructor & Destructor Documentation

◆ LocalToGlobalIndexMap() [1/4]

◆ LocalToGlobalIndexMap() [2/4]

◆ LocalToGlobalIndexMap() [3/4]

◆ LocalToGlobalIndexMap() [4/4]

Member Function Documentation

◆ deriveBoundaryConstrainedMap() [1/2]

◆ deriveBoundaryConstrainedMap() [2/2]

◆ dofSizeWithGhosts()

◆ dofSizeWithoutGhosts()

◆ findGlobalIndices()

◆ findGlobalIndicesWithElementID()

◆ getElementVariableIDs()

◆ getGhostIndices()

◆ getGlobalComponent()

◆ getGlobalIndex() [1/2]

◆ getGlobalIndex() [2/2]

◆ getGlobalIndices()

◆ getLocalIndex()

◆ getMeshSubset() [1/2]

◆ getMeshSubset() [2/2]

◆ getNumberOfElementComponents()

◆ getNumberOfElementDOF()

◆ getNumberOfGlobalComponents()

◆ getNumberOfVariableComponents()

◆ getNumberOfVariables()

◆ operator()()

◆ size()

Friends And Related Symbol Documentation

◆ operator<<

Member Data Documentation

◆ _columns

◆ _mesh_component_map

◆ _mesh_subsets

◆ _rows

◆ _variable_component_offsets