Cabana_Grid_Types.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_TYPES_HPP
#define CABANA_GRID_TYPES_HPP
 
#include <type_traits>
 
namespace Cabana
{
namespace Grid
{
 
//---------------------------------------------------------------------------//
struct Dim
{
    enum Values
    {
        I = 0,
        J = 1,
        K = 2
    };
};
 
//---------------------------------------------------------------------------//
// Entity type tags.
//---------------------------------------------------------------------------//

struct Cell
{
};

struct Node
{
};

template <int D>
struct Face;

template <>
struct Face<Dim::I>
{
    static constexpr int dim = Dim::I;
};

template <>
struct Face<Dim::J>
{
    static constexpr int dim = Dim::J;
};

template <>
struct Face<Dim::K>
{
    static constexpr int dim = Dim::K;
};

template <int D>
struct Edge;

template <>
struct Edge<Dim::I>
{
    static constexpr int dim = Dim::I;
};

template <>
struct Edge<Dim::J>
{
    static constexpr int dim = Dim::J;
};

template <>
struct Edge<Dim::K>
{
    static constexpr int dim = Dim::K;
};
 
// Type checkers.
template <class T>
struct isCell : public std::false_type
{
};
 
template <>
struct isCell<Cell> : public std::true_type
{
};
 
template <>
struct isCell<const Cell> : public std::true_type
{
};
 
template <class T>
struct isNode : public std::false_type
{
};
 
template <>
struct isNode<Node> : public std::true_type
{
};
 
template <>
struct isNode<const Node> : public std::true_type
{
};
 
template <class T>
struct isFace : public std::false_type
{
};
 
template <int Dir>
struct isFace<Face<Dir>> : public std::true_type
{
};
 
template <int Dir>
struct isFace<const Face<Dir>> : public std::true_type
{
};
 
template <class T>
struct isEdge : public std::false_type
{
};
 
template <int Dir>
struct isEdge<Edge<Dir>> : public std::true_type
{
};
 
template <int Dir>
struct isEdge<const Edge<Dir>> : public std::true_type
{
};
 
//---------------------------------------------------------------------------//
// Decomposition tags.
//---------------------------------------------------------------------------//

struct Own
{
};

struct Ghost
{
};
 
//---------------------------------------------------------------------------//
// Index type tags.
//---------------------------------------------------------------------------//

struct Local
{
};

struct Global
{
};
 
//---------------------------------------------------------------------------//
// Mesh type tags.
//---------------------------------------------------------------------------//

template <class Scalar, std::size_t NumSpaceDim = 3>
struct UniformMesh
{
    using scalar_type = Scalar;

    static constexpr std::size_t num_space_dim = NumSpaceDim;
};

template <class Scalar, std::size_t NumSpaceDim = 3>
struct NonUniformMesh
{
    using scalar_type = Scalar;

    static constexpr std::size_t num_space_dim = NumSpaceDim;
};

template <class Scalar, std::size_t NumSpaceDim = 3>
struct SparseMesh
{
    using scalar_type = Scalar;

    static constexpr std::size_t num_space_dim = NumSpaceDim;
};
 
// Type checker.
template <class T>
struct isMeshType : public std::false_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isMeshType<UniformMesh<Scalar, NumSpaceDim>> : public std::true_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isMeshType<const UniformMesh<Scalar, NumSpaceDim>>
    : public std::true_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isMeshType<NonUniformMesh<Scalar, NumSpaceDim>> : public std::true_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isMeshType<const NonUniformMesh<Scalar, NumSpaceDim>>
    : public std::true_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isMeshType<SparseMesh<Scalar, NumSpaceDim>> : public std::true_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isMeshType<const SparseMesh<Scalar, NumSpaceDim>> : public std::true_type
{
};
 
// Uniform mesh checker.
template <class T>
struct isUniformMesh : public std::false_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isUniformMesh<UniformMesh<Scalar, NumSpaceDim>> : public std::true_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isUniformMesh<const UniformMesh<Scalar, NumSpaceDim>>
    : public std::true_type
{
};
 
// Non-uniform mesh checker.
template <class T>
struct isNonUniformMesh : public std::false_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isNonUniformMesh<NonUniformMesh<Scalar, NumSpaceDim>>
    : public std::true_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isNonUniformMesh<const NonUniformMesh<Scalar, NumSpaceDim>>
    : public std::true_type
{
};
 
// Sparse mesh checker
template <class T>
struct isSparseMesh : public std::false_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isSparseMesh<SparseMesh<Scalar, NumSpaceDim>> : public std::true_type
{
};
 
template <class Scalar, std::size_t NumSpaceDim>
struct isSparseMesh<const SparseMesh<Scalar, NumSpaceDim>>
    : public std::true_type
{
};
//---------------------------------------------------------------------------//
} // namespace Grid
} // namespace Cabana
 
#endif // CABANA_GRID_TYPES_HPP