Cabana_Grid_SparseLocalGrid.hpp

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2018-2023 by the Cabana authors                            *
 * All rights reserved.                                                     *
 *                                                                          *
 * This file is part of the Cabana library. Cabana is distributed under a   *
 * BSD 3-clause license. For the licensing terms see the LICENSE file in    *
 * the top-level directory.                                                 *
 *                                                                          *
 * SPDX-License-Identifier: BSD-3-Clause                                    *
 ****************************************************************************/

#ifndef CABANA_GRID_LOCALGRID_SPARSE_HPP
#define CABANA_GRID_LOCALGRID_SPARSE_HPP
 
#include <Cabana_Grid_GlobalGrid.hpp>
#include <Cabana_Grid_IndexSpace.hpp>
#include <Cabana_Grid_SparseIndexSpace.hpp>
#include <Cabana_Grid_Types.hpp>
 
#include <array>
#include <vector>
 
namespace Cabana
{
namespace Grid
{
namespace Experimental
{
//---------------------------------------------------------------------------//
template <class MeshType>
class LocalGrid;
 
//---------------------------------------------------------------------------//
template <class Scalar, std::size_t NumSpaceDim>
class LocalGrid<SparseMesh<Scalar, NumSpaceDim>>
{
  public:
    using mesh_type = SparseMesh<Scalar, NumSpaceDim>;

    static constexpr std::size_t num_space_dim = mesh_type::num_space_dim;

    LocalGrid( const std::shared_ptr<GlobalGrid<mesh_type>>& global_grid,
               const int halo_cell_width, const long cell_num_per_tile_dim );

    const GlobalGrid<mesh_type>& globalGrid() const;
    GlobalGrid<mesh_type>& globalGrid();

    int haloCellWidth() const;

    int haloTileWidth() const;

    int totalNumCell( const int d ) const;

    int totalNumCell() const;

    int neighborRank( const std::array<int, num_space_dim>& off_ijk ) const;

    int neighborRank( const int off_i, const int off_j, const int off_k ) const;

    template <class DecompositionTag, class EntityType, class IndexType>
    IndexSpace<num_space_dim> indexSpace( DecompositionTag t1, EntityType t2,
                                          IndexType t3 ) const;

    template <unsigned long long cellBitsPerTileDim, class DecompositionTag,
              class EntityType>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpace( DecompositionTag t1, EntityType t2,
                          const std::array<int, num_space_dim>& off_ijk,
                          const int halo_width = -1 ) const;

    template <unsigned long long cellBitsPerTileDim, class DecompositionTag,
              class EntityType, std::size_t NSD = num_space_dim>
    std::enable_if_t<3 == NSD, TileIndexSpace<3, cellBitsPerTileDim>>
    sharedTileIndexSpace( DecompositionTag t1, EntityType t2, const int off_i,
                          const int off_j, const int off_k,
                          const int halo_width = -1 ) const;
 
  private:
    // Node related index space implementations
    template <class DecompositionTag, class IndexType>
    IndexSpace<num_space_dim> indexSpaceImpl( DecompositionTag t1, Node,
                                              IndexType t3 ) const;
 
    template <unsigned long long cellBitsPerTileDim, class DecompositionTag>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( DecompositionTag t1, Node,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
 
    // Cell related index space implementations
    template <class DecompositionTag, class IndexType>
    IndexSpace<num_space_dim> indexSpaceImpl( DecompositionTag t1, Cell,
                                              IndexType t3 ) const;
 
    template <unsigned long long cellBitsPerTileDim, class DecompositionTag>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( DecompositionTag t1, Cell,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
 
    // Face related index space implementations
    template <class DecompositionTag, class IndexType>
    IndexSpace<num_space_dim> indexSpaceImpl( DecompositionTag t1, Face<Dim::I>,
                                              IndexType t3 ) const;
    template <class DecompositionTag, class IndexType>
    IndexSpace<num_space_dim> indexSpaceImpl( DecompositionTag t1, Face<Dim::J>,
                                              IndexType t3 ) const;
    template <class DecompositionTag, class IndexType>
    IndexSpace<num_space_dim> indexSpaceImpl( DecompositionTag t1, Face<Dim::K>,
                                              IndexType t3 ) const;
 
    template <unsigned long long cellBitsPerTileDim, class DecompositionTag>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( DecompositionTag t1, Face<Dim::I>,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
    template <unsigned long long cellBitsPerTileDim, class DecompositionTag>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( DecompositionTag t1, Face<Dim::J>,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
    template <unsigned long long cellBitsPerTileDim, class DecompositionTag>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( DecompositionTag t1, Face<Dim::K>,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
    // Edge related index space implementations1
 
    template <class DecompositionTag, class IndexType>
    IndexSpace<num_space_dim> indexSpaceImpl( DecompositionTag t1, Edge<Dim::I>,
                                              IndexType t3 ) const;
    template <class DecompositionTag, class IndexType>
    IndexSpace<num_space_dim> indexSpaceImpl( DecompositionTag t1, Edge<Dim::J>,
                                              IndexType t3 ) const;
    template <class DecompositionTag, class IndexType>
    IndexSpace<num_space_dim> indexSpaceImpl( DecompositionTag t1, Edge<Dim::K>,
                                              IndexType t3 ) const;
 
    template <unsigned long long cellBitsPerTileDim, class DecompositionTag>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( DecompositionTag t1, Edge<Dim::I>,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
    template <unsigned long long cellBitsPerTileDim, class DecompositionTag>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( DecompositionTag t1, Edge<Dim::J>,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
    template <unsigned long long cellBitsPerTileDim, class DecompositionTag>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( DecompositionTag t1, Edge<Dim::K>,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
 
    // More general implementations for node and cell center indices
    // Note: In Sparse grid, each cell considers the left-most node and its cell
    // center as belongings, i.e., Node and Cell share the same element-to-cell
    // mapping, thus sharse the same interface.
    IndexSpace<num_space_dim> indexSpaceImpl( Own, Local ) const;
    IndexSpace<num_space_dim> indexSpaceImpl( Ghost, Local ) const;
    IndexSpace<num_space_dim> indexSpaceImpl( Own, Global ) const;
 
    template <unsigned long long cellBitsPerTileDim>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( Own,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
    template <unsigned long long cellBitsPerTileDim>
    TileIndexSpace<num_space_dim, cellBitsPerTileDim>
    sharedTileIndexSpaceImpl( Ghost,
                              const std::array<int, num_space_dim>& off_ijk,
                              const int halo_width ) const;
 
  private:
    std::shared_ptr<GlobalGrid<mesh_type>> _global_grid;
    int _halo_cell_width;
    const long _cell_num_per_tile_dim;
 
}; // end LocalGrid<SparseMesh<Scalar, NumSpaceDim>>
 
//---------------------------------------------------------------------------//
// Creation function.
//---------------------------------------------------------------------------//
template <class MeshType>
std::shared_ptr<LocalGrid<MeshType>>
createSparseLocalGrid( const std::shared_ptr<GlobalGrid<MeshType>>& global_grid,
                       const int halo_cell_width,
                       const int cell_num_per_tile_dim )
{
    static_assert( isSparseMesh<MeshType>::value,
                   "createSparseLocalGrid supports only SparseMesh" );
    return std::make_shared<LocalGrid<MeshType>>( global_grid, halo_cell_width,
                                                  cell_num_per_tile_dim );
}
 
} // namespace Experimental
} // namespace Grid
} // namespace Cabana
//---------------------------------------------------------------------------//
 
//---------------------------------------------------------------------------//
// Template implementations
//---------------------------------------------------------------------------//
 
#include <Cabana_Grid_SparseLocalGrid_impl.hpp>
 
//---------------------------------------------------------------------------//
#endif // end CABANA_GRID_LOCALGRID_SPARSE_HPP