NumLib::LocalToGlobalIndexMap Class Reference

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 40 of file LocalToGlobalIndexMap.h.

#include <LocalToGlobalIndexMap.h>

Collaboration diagram for NumLib::LocalToGlobalIndexMap:

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 52 of file LocalToGlobalIndexMap.h.

RowColumnIndices

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

Definition at line 51 of file LocalToGlobalIndexMap.h.

Table

using NumLib::LocalToGlobalIndexMap::Table

private

Initial value:

 Eigen::Matrix<LineIndex, Eigen::Dynamic, Eigen::Dynamic,
                                Eigen::RowMajor>

Definition at line 197 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 118 of file LocalToGlobalIndexMap.cpp.

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

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 126 of file LocalToGlobalIndexMap.cpp.

    : _mesh_subsets(std::move(mesh_subsets)),
      _mesh_component_map(_mesh_subsets, order),
      _variable_component_offsets(to_cumulative(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_subsets, 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 156 of file LocalToGlobalIndexMap.cpp.

    : _mesh_subsets(std::move(mesh_subsets)),
      _mesh_component_map(_mesh_subsets, order),
      _variable_component_offsets(to_cumulative(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_subsets, _rows, 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 203 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_subsets, findGlobalIndices(), and OGS_FATAL.

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 237 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, global_component_ids);
 
    // 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(), NumLib::MeshComponentMap::getSubset(), and OGS_FATAL.

Referenced by ProcessLib::ConstraintDirichletBoundaryCondition::ConstraintDirichletBoundaryCondition(), ProcessLib::DirichletBoundaryCondition::DirichletBoundaryCondition(), ProcessLib::PrimaryVariableConstraintDirichletBoundaryCondition::PrimaryVariableConstraintDirichletBoundaryCondition(), ProcessLib::PythonBoundaryCondition::PythonBoundaryCondition(), ProcessLib::SolutionDependentDirichletBoundaryCondition::SolutionDependentDirichletBoundaryCondition(), anonymous_namespace{ProcessOutputData.cpp}::computeDofTablesForSubmesh(), ProcessLib::DeactivatedSubdomainDirichlet::config(), ProcessLib::DirichletBoundaryConditionWithinTimeInterval::config(), ProcessLib::createSourceTerm(), and ProcessLib::createVariableDependentNeumannBoundaryCondition().

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 280 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, global_component_ids);
 
    // 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(), getNumberOfGlobalComponents(), and NumLib::MeshComponentMap::getSubset().

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 315 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.dofSizeWithGhosts();
}

References _mesh_component_map, and NumLib::MeshComponentMap::dofSizeWithGhosts().

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 320 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.dofSizeWithoutGhosts();
}

References _mesh_component_map, and NumLib::MeshComponentMap::dofSizeWithoutGhosts().

Referenced by NumLib::LocalLinearLeastSquaresExtrapolator::extrapolate().

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 75 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, NumLib::MeshComponentMap::getGlobalIndex(), 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 40 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, NumLib::MeshComponentMap::getGlobalIndex(), and MeshLib::Node.

Referenced by LocalToGlobalIndexMap().

getElementVariableIDs()

std::vector< int > NumLib::LocalToGlobalIndexMap::getElementVariableIDs

(

std::size_t const

mesh_item_id

)

const

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

Referenced by ProcessLib::LIE::SmallDeformation::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()().

getGhostIndices()

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

(

)

const

Get ghost indices, forwarded from MeshComponentMap.

Definition at line 425 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.getGhostIndices();
}

References _mesh_component_map, and NumLib::MeshComponentMap::getGhostIndices().

Referenced by NumLib::LocalLinearLeastSquaresExtrapolator::extrapolate().

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 33 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(), and getMeshSubset().

getGlobalIndex() [1/2]

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

Definition at line 411 of file LocalToGlobalIndexMap.cpp.

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

References _mesh_component_map, and NumLib::MeshComponentMap::getGlobalIndex().

getGlobalIndex() [2/2]

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

Definition at line 402 of file LocalToGlobalIndexMap.cpp.

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

References _mesh_component_map, getGlobalComponent(), and NumLib::MeshComponentMap::getGlobalIndex().

Referenced by anonymous_namespace{CollectAndInterpolateNodalDof.cpp}::collectDofsToMatrixSingleComponentForSomeNodes(), ProcessLib::getEssentialBCValuesLocal(), NumLib::getNodalValue(), NumLib::getNonGhostNodalValue(), ProcessLib::LIE::SmallDeformation::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()(), ProcessLib::PhaseFieldIrreversibleDamageOracleBoundaryCondition::preTimestep(), 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 418 of file LocalToGlobalIndexMap.cpp.

{
    return _mesh_component_map.getGlobalIndices(l);
}

References _mesh_component_map, and NumLib::MeshComponentMap::getGlobalIndices().

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 433 of file LocalToGlobalIndexMap.cpp.

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

References _mesh_component_map, and NumLib::MeshComponentMap::getLocalIndex().

Referenced by getIndexForComponentInSolutionVector().

getMeshSubset() [1/2]

MeshLib::MeshSubset const & NumLib::LocalToGlobalIndexMap::getMeshSubset

(

int const

global_component_id

)

const

Definition at line 447 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 441 of file LocalToGlobalIndexMap.cpp.

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

References getGlobalComponent(), and getMeshSubset().

Referenced by addPrimaryVariablesToMesh(), ProcessLib::createSourceTerm(), getMeshSubset(), NumLib::anonymous_namespace{DOFTableUtil.cpp}::norm(), ProcessLib::LIE::SmallDeformation::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()(), NumLib::transformVariableFromGlobalVector(), and NumLib::transformVariableFromGlobalVector().

getNumberOfElementComponents()

std::size_t NumLib::LocalToGlobalIndexMap::getNumberOfElementComponents

(

std::size_t const

mesh_item_id

)

const

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

Referenced by ProcessLib::LIE::SmallDeformation::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()().

getNumberOfElementDOF()

std::size_t NumLib::LocalToGlobalIndexMap::getNumberOfElementDOF

(

std::size_t const

mesh_item_id

)

const

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

Referenced by ProcessLib::LIE::SmallDeformation::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()(), and ProcessLib::GenericLocalAssemblerFactory< LocalAssemblerInterface, IntegrationMethodProvider, ConstructorArgs >::operator()().

getNumberOfGlobalComponents()

int NumLib::LocalToGlobalIndexMap::getNumberOfGlobalComponents

(

)

const

Definition at line 337 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(), NumLib::ConvergenceCriterionPerComponentDeltaX::setDOFTable(), and NumLib::ConvergenceCriterionPerComponentResidual::setDOFTable().

getNumberOfVariableComponents()

int NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents

(

int

variable_id

)

const

Definition at line 330 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::createSourceTerm(), getElementVariableIDs(), ProcessLib::LIE::SmallDeformation::LocalDataInitializer< LocalAssemblerInterface, LocalAssemblerDataMatrix, LocalAssemblerDataMatrixNearFracture, LocalAssemblerDataFracture, GlobalDim, ConstructorArgs >::operator()(), NumLib::transformVariableFromGlobalVector(), and NumLib::transformVariableFromGlobalVector().

getNumberOfVariables()

int NumLib::LocalToGlobalIndexMap::getNumberOfVariables

(

)

const

Definition at line 325 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(), 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 347 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 342 of file LocalToGlobalIndexMap.cpp.

{
    return _rows.rows();
}

References _rows.

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

Friends And Related Symbol Documentation

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

Member Data Documentation

_columns

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

private

See also

_rows

Definition at line 206 of file LocalToGlobalIndexMap.h.

Referenced by operator()().

_mesh_component_map

NumLib::MeshComponentMap NumLib::LocalToGlobalIndexMap::_mesh_component_map

private

Definition at line 195 of file LocalToGlobalIndexMap.h.

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

_mesh_subsets

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

private

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

Definition at line 194 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 203 of file LocalToGlobalIndexMap.h.

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

_variable_component_offsets

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

private

Definition at line 208 of file LocalToGlobalIndexMap.h.

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

---

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

• NumLib/DOF/LocalToGlobalIndexMap.h
• NumLib/DOF/LocalToGlobalIndexMap.cpp