AMReX_IndexType.H

Go to the documentation of this file.

 
#ifndef BL_INDEXTYPE_H
#define BL_INDEXTYPE_H
#include <AMReX_Config.H>
 
#include <AMReX_IntVect.H>
#include <AMReX_SPACE.H>
#include <AMReX_Tuple.H>
 
#include <iosfwd>
 
namespace amrex {
 
struct CellIndexEnum {
    enum CellIndex { CELL = 0, NODE = 1 };
};
 
template<int dim>
class IndexTypeND : public CellIndexEnum
{
public:
    static_assert(1 <= dim && dim <= 31, "The number of dimensions of IndexTypeND must be positive"
        " and less than 32");
 
    AMREX_GPU_HOST_DEVICE
    constexpr IndexTypeND () noexcept = default;
    AMREX_GPU_HOST_DEVICE
    explicit IndexTypeND (const IntVectND<dim>& iv) noexcept {
        for (int i=0; i<dim; ++i) {
            itype |= (iv[i] ? 1U : 0U) << i;
        }
    }
    template <class...Args>
    requires ((sizeof...(Args)+1 == dim) &&
              IsConvertible_v<CellIndex, Args...>)
    AMREX_GPU_HOST_DEVICE
    constexpr IndexTypeND (CellIndex i, Args...js) noexcept {
        CellIndex locarr[dim] = {i, static_cast<CellIndex>(js)...};
        for (int s=0; s<dim; ++s) {
            itype |= ((locarr[s] == CellIndex::NODE) ? 1U : 0U) << s;
        }
    }
    // dtor, copy-ctor, copy-op=, move-ctor, and move-op= are compiler generated.
 
    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    void set (int dir) noexcept { itype |= mask(dir); }
    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    void unset (int dir) noexcept { itype &= ~mask(dir); }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool test (int dir) const noexcept { return (itype & mask(dir)) != 0; }
    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE constexpr
    void setall () noexcept { itype = (1U << dim) - 1; }
    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    void clear () noexcept { itype = 0; }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool any () const noexcept { return itype != 0; }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool ok () const noexcept { return itype < (1U << dim); }
    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    void flip (int i) noexcept { itype ^= mask(i); }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool operator== (const IndexTypeND& t) const noexcept { return t.itype == itype; }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool operator!= (const IndexTypeND& t) const noexcept { return t.itype != itype; }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool operator< (const IndexTypeND& t) const noexcept { return itype < t.itype; }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool cellCentered () const noexcept { return itype == 0; }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool cellCentered (int dir) const noexcept { return (itype & mask(dir)) == 0; }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool nodeCentered () const noexcept { return itype == (1U<<dim)-1; }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    bool nodeCentered (int dir) const noexcept { return (itype & mask(dir)) != 0; }
    AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    void setType (int dir, CellIndex t) noexcept { t == CELL ? unset(dir) : set(dir); }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE constexpr
    CellIndex ixType (int dir) const noexcept { return (CellIndex) ((itype & (1U<<dir)) >> dir); }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    int operator[] (int dir) const noexcept { return test(dir); }
    template<std::size_t i>
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE constexpr
    CellIndex get () const noexcept { static_assert(0<=i && i<dim); return ixType(i); }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    IntVectND<dim> ixType () const noexcept {
        IntVectND<dim> retval(0);
        for (int i=0; i<dim; ++i) {
            retval[i] = test(i);
        }
        return retval;
    }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    IntVectND<dim> toIntVect () const noexcept {
        IntVectND<dim> retval(0);
        for (int i=0; i<dim; ++i) {
            retval[i] = test(i);
        }
        return retval;
    }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static constexpr IndexTypeND<dim> TheCellType () noexcept {
        return IndexTypeND<dim>{};
    }
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static constexpr IndexTypeND<dim> TheNodeType () noexcept {
        IndexTypeND<dim> retval{};
        retval.setall();
        return retval;
    }
 
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static constexpr std::size_t size () noexcept {
        return static_cast<std::size_t>(dim);
    }
 
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static constexpr int isize () noexcept {
        return dim;
    }
 
    using value_type = CellIndex;
 
    template<int new_dim>
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    IndexTypeND<new_dim> shrink () const noexcept {
        static_assert(new_dim <= dim);
        IndexTypeND<new_dim> retval{};
        retval.getBits() = itype & ((1U << new_dim) - 1);
        return retval;
    }
 
    template<int new_dim>
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    IndexTypeND<new_dim> expand (CellIndex fill_extra=CellIndex::CELL) const noexcept {
        static_assert(new_dim >= dim);
        IndexTypeND<new_dim> retval{};
        retval.getBits() = itype;
        if (fill_extra == CellIndex::NODE) {
            retval.getBits() |= (1U << new_dim) - (1U << dim);
        }
        return retval;
    }
 
    template<int new_dim>
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    IndexTypeND<new_dim> resize (CellIndex fill_extra=CellIndex::CELL) const noexcept {
        if constexpr (new_dim > dim) {
            return expand<new_dim>(fill_extra);
        } else {
            return shrink<new_dim>();
        }
    }
 
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE constexpr
    unsigned int& getBits () noexcept { return itype; }
 
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE constexpr
    const unsigned int& getBits () const noexcept { return itype; }
 
private:
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
    static constexpr unsigned int mask (int k) noexcept { return 1U<<k; }
    unsigned int itype{0};
};
 
using IndexType = IndexTypeND<AMREX_SPACEDIM>;
 
// Template deduction guide for IndexTypeND
template<int dim>
AMREX_GPU_HOST_DEVICE // __device__ for HIP
IndexTypeND(const IntVectND<dim>&) -> IndexTypeND<dim>;
 
// Template deduction guide for IndexTypeND
template <class...Args>
requires (IsConvertible_v<IndexType::CellIndex, Args...>)
AMREX_GPU_HOST_DEVICE // __device__ for HIP
IndexTypeND(IndexType::CellIndex, Args...) -> IndexTypeND<sizeof...(Args)+1>;
 
namespace detail {
    std::ostream& index_type_write (std::ostream& os, const unsigned int& iv, int dim);
    std::istream& index_type_read (std::istream& is, unsigned int& iv, int dim);
 
    template<class T, std::size_t...Ns>
    [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE constexpr
    T IndexTypeSplit_imp (T& retval, std::index_sequence<Ns...>, unsigned int src) noexcept {
        int dim_shift = 0;
        (
            (
                amrex::get<Ns>(retval).getBits() =
                    (src >> dim_shift) & ((1U << amrex::get<Ns>(retval).isize()) - 1),
                dim_shift += amrex::get<Ns>(retval).isize()
            ), ...
        );
        return retval;
    }
}
 
template<int dim>
std::ostream& operator<< (std::ostream& os, const IndexTypeND<dim>& it) {
    return detail::index_type_write(os, it.getBits(), dim);
}
template<int dim>
std::istream& operator>> (std::istream& is, IndexTypeND<dim>& it) {
    return detail::index_type_read(is, it.getBits(), dim);
}
 
template<int d, int...dims>
[[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
constexpr IndexTypeND<detail::get_sum<d, dims...>()>
IndexTypeCat (const IndexTypeND<d>& v, const IndexTypeND<dims>&...vects) noexcept {
    IndexTypeND<detail::get_sum<d, dims...>()> retval{};
    retval.getBits() |= v.getBits();
    int dim_shift = v.isize();
    (
        (
            retval.getBits() |= (vects.getBits() << dim_shift),
            dim_shift += vects.isize()
        ), ...
    );
    return retval;
}
 
template<int d, int...dims>
[[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
constexpr GpuTuple<IndexTypeND<d>, IndexTypeND<dims>...>
IndexTypeSplit (const IndexTypeND<detail::get_sum<d, dims...>()>& v) noexcept {
    GpuTuple<IndexTypeND<d>, IndexTypeND<dims>...> retval{};
    return detail::IndexTypeSplit_imp(retval,
                                      std::make_index_sequence<1 + sizeof...(dims)>(),
                                      v.getBits());
}
 
template<int new_dim, int old_dim>
[[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
constexpr IndexTypeND<new_dim>
IndexTypeShrink (const IndexTypeND<old_dim>& v) noexcept {
    return v.template shrink<new_dim>();
}
 
template<int new_dim, int old_dim>
[[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
constexpr IndexTypeND<new_dim>
IndexTypeExpand (const IndexTypeND<old_dim>& v,
                 IndexType::CellIndex fill_extra=IndexType::CellIndex::CELL) noexcept {
    return v.template expand<new_dim>(fill_extra);
}
 
template<int new_dim, int old_dim>
[[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
constexpr IndexTypeND<new_dim>
IndexTypeResize (const IndexTypeND<old_dim>& v,
                 IndexType::CellIndex fill_extra=IndexType::CellIndex::CELL) noexcept {
    return v.template resize<new_dim>(fill_extra);
}
 
} // namespace amrex
 
// Spcialize std::tuple_size for IndexTypeND. Used by structured bindings.
template<int dim>
struct std::tuple_size<amrex::IndexTypeND<dim>> {
    static constexpr std::size_t value = dim;
};
 
// Spcialize std::tuple_element for IndexTypeND. Used by structured bindings.
template<std::size_t s, int dim>
struct std::tuple_element<s, amrex::IndexTypeND<dim>> {
    using type = typename amrex::IndexTypeND<dim>::CellIndex;
};
 
#endif /*BL_INDEXTYPE_H*/