MeshComponentMap.h

Go to the documentation of this file.

 
#pragma once
 
#include "ComponentGlobalIndexDict.h"
#include "MeshLib/MeshSubset.h"
#include "numlib_export.h"
 
namespace NumLib
{
enum class ComponentOrder
{
    BY_COMPONENT,  
    BY_LOCATION    
};
 
class MeshComponentMap final
{
public:
    using Location = MeshLib::Location;
 
public:
    MeshComponentMap(std::vector<MeshLib::MeshSubset> const& components,
                     ComponentOrder order);
 
    MeshComponentMap getSubset(
        std::vector<MeshLib::MeshSubset> const& bulk_mesh_subsets,
        MeshLib::MeshSubset const& new_mesh_subset,
        std::vector<int> const& new_global_component_ids) const;
 
    std::size_t dofSizeWithGhosts() const { return _dict.size(); }
 
    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 { return _num_local_dof; }
 
    std::vector<GlobalIndexType> const& getGhostIndices() const
    {
        return _ghosts_indices;
    }
 
    GlobalIndexType getLocalIndex(Location const& l, int const comp_id,
                                  std::size_t const range_begin,
                                  std::size_t const range_end) const;
 
    static constexpr NUMLIB_EXPORT GlobalIndexType const nop =
        std::numeric_limits<GlobalIndexType>::max();
 
#ifndef NDEBUG
    const detail::ComponentGlobalIndexDict& getDictionary() const
    {
        return _dict;
    }
 
    friend std::ostream& operator<<(std::ostream& os, MeshComponentMap const& m)
    {
        os << "Dictionary size: " << m._dict.size() << "\n";
        for (auto l : m._dict)
            os << l << "\n";
        return os;
    }
#endif  // NDEBUG
 
private:
    explicit MeshComponentMap(detail::ComponentGlobalIndexDict& dict)
        : _dict(dict)
    {
    }
 
    void renumberByLocation(GlobalIndexType offset = 0);
 
    detail::ComponentGlobalIndexDict _dict;
 
    std::size_t _num_local_dof = 0;
 
#ifdef USE_PETSC
    std::size_t _num_global_dof = 0;
#endif
 
    std::vector<GlobalIndexType> _ghosts_indices;
 
    void createSerialMeshComponentMap(
        std::vector<MeshLib::MeshSubset> const& components,
        ComponentOrder order);
 
#ifdef USE_PETSC
    void createParallelMeshComponentMap(
        std::vector<MeshLib::MeshSubset> const& components,
        ComponentOrder order);
#endif
};
 
}  // namespace NumLib