Cabana_Grid_GlobalGrid.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_GLOBALGRID_HPP
#define CABANA_GRID_GLOBALGRID_HPP
 
#include <Cabana_Grid_GlobalMesh.hpp>
#include <Cabana_Grid_Partitioner.hpp>
#include <Cabana_Grid_Types.hpp>
 
#include <array>
#include <memory>
 
#include <mpi.h>
 
namespace Cabana
{
namespace Grid
{
//---------------------------------------------------------------------------//
template <class MeshType>
class GlobalGrid
{
  public:
    using mesh_type = MeshType;

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

    GlobalGrid( MPI_Comm comm,
                const std::shared_ptr<GlobalMesh<MeshType>>& global_mesh,
                const std::array<bool, num_space_dim>& periodic,
                const BlockPartitioner<num_space_dim>& partitioner );
 
    // Destructor.
    ~GlobalGrid();

    MPI_Comm comm() const;

    const GlobalMesh<MeshType>& globalMesh() const;

    bool isPeriodic( const int dim ) const;

    bool onLowBoundary( const int dim ) const;

    bool onHighBoundary( const int dim ) const;

    int dimNumBlock( const int dim ) const;

    int totalNumBlock() const;

    int dimBlockId( const int dim ) const;

    int blockId() const;

    int blockRank( const std::array<int, num_space_dim>& ijk ) const;

    template <std::size_t NSD = num_space_dim>
    std::enable_if_t<3 == NSD, int> blockRank( const int i, const int j,
                                               const int k ) const;

    template <std::size_t NSD = num_space_dim>
    std::enable_if_t<2 == NSD, int> blockRank( const int i, const int j ) const;

    int globalNumEntity( Cell, const int dim ) const;
    int globalNumEntity( Node, const int dim ) const;
    int globalNumEntity( Face<Dim::I>, const int dim ) const;
    int globalNumEntity( Face<Dim::J>, const int dim ) const;

    template <std::size_t NSD = num_space_dim>
    std::enable_if_t<3 == NSD, int> globalNumEntity( Face<Dim::K>,
                                                     const int dim ) const;
    template <std::size_t NSD = num_space_dim>
    std::enable_if_t<3 == NSD, int> globalNumEntity( Edge<Dim::I>,
                                                     const int dim ) const;
    template <std::size_t NSD = num_space_dim>
    std::enable_if_t<3 == NSD, int> globalNumEntity( Edge<Dim::J>,
                                                     const int dim ) const;
    template <std::size_t NSD = num_space_dim>
    std::enable_if_t<3 == NSD, int> globalNumEntity( Edge<Dim::K>,
                                                     const int dim ) const;

    int ownedNumCell( const int dim ) const;

    int globalOffset( const int dim ) const;

    void setNumCellAndOffset( const std::array<int, num_space_dim>& num_cell,
                              const std::array<int, num_space_dim>& offset );
 
  private:
    std::shared_ptr<MPI_Comm> _cart_comm_ptr;
    std::shared_ptr<GlobalMesh<MeshType>> _global_mesh;
    std::array<bool, num_space_dim> _periodic;
    std::array<int, num_space_dim> _ranks_per_dim;
    std::array<int, num_space_dim> _cart_rank;
    std::array<int, num_space_dim> _owned_num_cell;
    std::array<int, num_space_dim> _global_cell_offset;
    std::array<bool, num_space_dim> _boundary_lo;
    std::array<bool, num_space_dim> _boundary_hi;
};
 
//---------------------------------------------------------------------------//
// Creation function.
//---------------------------------------------------------------------------//
template <class MeshType>
std::shared_ptr<GlobalGrid<MeshType>>
createGlobalGrid( MPI_Comm comm,
                  const std::shared_ptr<GlobalMesh<MeshType>>& global_mesh,
                  const std::array<bool, MeshType::num_space_dim>& periodic,
                  const BlockPartitioner<MeshType::num_space_dim>& partitioner )
{
    return std::make_shared<GlobalGrid<MeshType>>( comm, global_mesh, periodic,
                                                   partitioner );
}

template <class Scalar, std::size_t NumSpaceDim>
std::shared_ptr<GlobalGrid<SparseMesh<Scalar, NumSpaceDim>>> createGlobalGrid(
    MPI_Comm comm,
    const std::shared_ptr<GlobalMesh<SparseMesh<Scalar, NumSpaceDim>>>&
        global_mesh,
    const std::array<bool, SparseMesh<Scalar, NumSpaceDim>::num_space_dim>&
        periodic,
    const BlockPartitioner<SparseMesh<Scalar, NumSpaceDim>::num_space_dim>&
        partitioner )
{
    for ( long unsigned int d = 0; d < NumSpaceDim; ++d )
        if ( periodic[d] )
            std::runtime_error(
                "Sparse grid doesn't support periodic BC so far!" );
    return std::make_shared<GlobalGrid<SparseMesh<Scalar, NumSpaceDim>>>(
        comm, global_mesh, periodic, partitioner );
}
 
//---------------------------------------------------------------------------//
 
} // namespace Grid
} // namespace Cabana
 
//---------------------------------------------------------------------------//
// Template implementation
//---------------------------------------------------------------------------//
 
#include <Cabana_Grid_GlobalGrid_impl.hpp>
 
//---------------------------------------------------------------------------//
 
#endif // end CABANA_GRID_GLOBALGRID_HPP