LocalToGlobalIndexMap.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#ifndef NDEBUG
#include <iosfwd>
#endif  // NDEBUG
 
#include <Eigen/Core>
#include <vector>
 
#include "MathLib/LinAlg/RowColumnIndices.h"
#include "MeshComponentMap.h"
 
namespace MeshLib
{
class Node;
class Element;
}  // namespace MeshLib
 
namespace NumLib
{
class LocalToGlobalIndexMap final
{
    // Enables using std::make_unique with private constructors from within
    // member functions of LocalToGlobalIndexMap. Cf.
    // https://web.archive.org/web/20210302195245/https://seanmiddleditch.com/enabling-make-unique-with-private-constructors/
    struct ConstructorTag
    {
        explicit ConstructorTag() = default;
    };
 
public:
    using RowColumnIndices = MathLib::RowColumnIndices<GlobalIndexType>;
    using LineIndex = RowColumnIndices::LineIndex;
 
public:
    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;

    std::vector<GlobalIndexType> const& getGhostIndices() const;

    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;

    explicit 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 /*unused*/);
 
private:
    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);

    std::vector<MeshLib::MeshSubset> _mesh_subsets;
    NumLib::MeshComponentMap _mesh_component_map;
 
    using Table = Eigen::Matrix<LineIndex, Eigen::Dynamic, Eigen::Dynamic,
                                Eigen::RowMajor>;

    Table _rows;

    Table const& _columns = _rows;
 
    std::vector<int> const _variable_component_offsets;
#ifndef NDEBUG
    friend std::ostream& operator<<(std::ostream& os,
                                    LocalToGlobalIndexMap const& map);
#endif  // NDEBUG
};
 
}  // namespace NumLib
 
#ifndef NDEBUG
template <>
struct fmt::formatter<NumLib::LocalToGlobalIndexMap> : fmt::ostream_formatter
{
};
#endif  // NDEBUG