AMReX_Array.H

Go to the documentation of this file.

#ifndef AMREX_ARRAY_H_
#define AMREX_ARRAY_H_
#include <AMReX_Config.H>
 
#include <AMReX.H>
#include <AMReX_GpuQualifiers.H>
#include <AMReX_GpuControl.H>
#include <AMReX_BLassert.H>
#include <AMReX_SPACE.H>
#include <AMReX_REAL.H>
#include <AMReX_Algorithm.H>
#include <AMReX_Dim3.H>
#include <AMReX_SmallMatrix.H>
 
#include <array>
#include <memory>
#include <utility>
#include <sstream>
#include <type_traits>
 
namespace amrex {
 
    template <class T, std::size_t N>
    using Array = std::array<T,N>;
 
    using RealArray = Array<Real, AMREX_SPACEDIM>;
    using IntArray  = Array<int , AMREX_SPACEDIM>;
 
}
 
namespace amrex {
    template <class T, unsigned int N>
    struct GpuArray
    {
        using value_type = T;
        using reference_type = T&;
 
        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T& operator [] (int i) const noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i);
#endif
            return arr[i];
        }
 
        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T& operator [] (int i) noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i);
#endif
            return arr[i];
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T* data () const noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T* data () noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int size () noexcept { return N; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T* begin () const noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T* end () const noexcept { return arr + N; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T* begin () noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T* end () noexcept { return arr + N; }
 
        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        void fill ( const T& value ) noexcept
        { for (unsigned int i = 0; i < N; ++i) { arr[i] = value; } }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T sum () const noexcept
        {
            T s = 0;
            for (unsigned int i = 0; i < N; ++i) { s += arr[i]; }
            return s;
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T product () const noexcept
        {
            T p = 1;
            for (unsigned int i = 0; i < N; ++i) { p *= arr[i]; }
            return p;
        }
 
        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        GpuArray<T,N>& operator+= (GpuArray<T,N> const& a) noexcept
        {
            for (unsigned int i = 0; i < N; ++i) {
                arr[i] += a.arr[i];
            }
            return *this;
        }
 
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static void index_assert (int i)
        {
            if (i < 0 || static_cast<unsigned int>(i) >= N) {
                AMREX_IF_ON_DEVICE((
                    AMREX_DEVICE_PRINTF(" (%d) is out of bound (0:%d)\n",
                                        i, N-1);
                    amrex::Abort();
                ))
                AMREX_IF_ON_HOST((
                    std::stringstream ss;
                    ss << " (" << i << ") is out of bound (0:" << N-1 <<")";
                    amrex::Abort(ss.str());
                ))
            }
        }
#endif
        T arr[amrex::max(N,1U)];
    };
}
 
namespace amrex {
 
    template <class T, int XLO, int XHI>
    struct Array1D
    {
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int size () noexcept { return (XHI-XLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int lo () noexcept { return XLO; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int hi () noexcept { return XHI; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int len () noexcept { return (XHI-XLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T* begin () const noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T* end () const noexcept { return arr + XHI-XLO+1; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T* begin () noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T* end () noexcept { return arr + XHI-XLO+1; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T& operator() (int i) const noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i);
#endif
            return arr[i-XLO];
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T& operator() (int i) noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i);
#endif
            return arr[i-XLO];
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T sum () const noexcept
        {
            T s = 0;
            for (int i = XLO; i <= XHI; ++i) { s += arr[i-XLO]; }
            return s;
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T product() const noexcept
        {
            T p = 1;
            for (int i = 0; i < (XHI-XLO+1); ++i) {
                p *= arr[i];
            }
            return p;
        }
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static void index_assert (int i)
        {
            if (i<XLO || i>XHI) {
                AMREX_IF_ON_DEVICE((
                    AMREX_DEVICE_PRINTF(" (%d) is out of bound (%d:%d)\n",
                                        i, XLO, XHI);
                    amrex::Abort();
                ))
                AMREX_IF_ON_HOST((
                    std::stringstream ss;
                    ss << " (" << i << ") is out of bound ("
                    << XLO << ":" << XHI << ")";
                    amrex::Abort(ss.str());
                ))
            }
        }
#endif
 
        T arr[(XHI-XLO+1)];
    };
 
    template <class T, int XLO, int XHI, int YLO, int YHI,
              Order ORDER = Order::F>
    struct Array2D
    {
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int size() noexcept { return (XHI-XLO+1)*(YHI-YLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int xlo () noexcept { return XLO; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int xhi () noexcept { return XHI; }
 
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int xlen () noexcept { return (XHI-XLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int ylo () noexcept { return YLO; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int yhi () noexcept { return YHI; }
 
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int ylen () noexcept { return (YHI-YLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T* begin () const noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T* end () const noexcept { return arr + (XHI-XLO+1)*(YHI-YLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T* begin () noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T* end () noexcept { return arr + (XHI-XLO+1)*(YHI-YLO+1); }
 
        template <Order Ord=ORDER, std::enable_if_t<Ord==Order::F,int> = 0>
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T& operator() (int i, int j) const noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i, j);
#endif
            return arr[i+j*(XHI-XLO+1)-(YLO*(XHI-XLO+1)+XLO)];
        }
 
        template <Order Ord=ORDER, std::enable_if_t<Ord==Order::F,int> = 0>
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T& operator() (int i, int j) noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i, j);
#endif
            return arr[i+j*(XHI-XLO+1)-(YLO*(XHI-XLO+1)+XLO)];
        }
 
        template <Order Ord=ORDER, std::enable_if_t<Ord==Order::C,int> = 0>
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T& operator() (int i, int j) const noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i, j);
#endif
            return arr[j+i*(YHI-YLO+1)-(XLO*(YHI-YLO+1)+YLO)];
        }
 
        template <Order Ord=ORDER, std::enable_if_t<Ord==Order::C,int> = 0>
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T& operator() (int i, int j) noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i, j);
#endif
            return arr[j+i*(YHI-YLO+1)-(XLO*(YHI-YLO+1)+YLO)];
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T sum () const noexcept
        {
            T s = 0;
            for (int i = 0; i < (XHI-XLO+1)*(YHI-YLO+1); ++i) {
                s += arr[i];
            }
            return s;
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T sum (int axis, int loc) const noexcept
        {
            T s = 0;
            if        (axis == 0) {
                int j = loc;
                for (int i = XLO; i <= XHI; ++i) {
                    s += this->operator()(i,j);
                }
            } else if (axis == 1) {
                int i = loc;
                for (int j = YLO; j <= YHI; ++j) {
                    s += this->operator()(i,j);
                }
            }
            return s;
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T product () const noexcept
        {
            T p = 1;
            for (int i = 0; i < (XHI-XLO+1)*(YHI-YLO+1); ++i) {
                p *= arr[i];
            }
            return p;
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T product (int axis, int loc) const noexcept
        {
            T p = 1;
            if        (axis == 0) {
                int j = loc;
                for (int i = XLO; i <= XHI; ++i) {
                    p *= this->operator()(i,j);
                }
            } else if (axis == 1) {
                int i = loc;
                for (int j = YLO; j <= YHI; ++j) {
                    p *= this->operator()(i,j);
                }
            }
            return p;
        }
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static void index_assert (int i, int j)
        {
            if (i<XLO || i>XHI || j<YLO || j>YHI) {
                AMREX_IF_ON_DEVICE((
                    AMREX_DEVICE_PRINTF(" (%d,%d) is out of bound (%d:%d,%d:%d)\n",
                                        i, j, XLO, XHI, YLO, YHI);
                    amrex::Abort();
                ))
                AMREX_IF_ON_HOST((
                    std::stringstream ss;
                    ss << " (" << i << "," << j
                    << ") is out of bound ("
                    << XLO << ":" << XHI << ","
                    << YLO << ":" << YHI << ")";
                    amrex::Abort(ss.str());
                ))
            }
        }
#endif
        T arr[(XHI-XLO+1)*(YHI-YLO+1)];
    };
 
 
    template <class T, int XLO, int XHI, int YLO, int YHI, int ZLO, int ZHI,
              Order ORDER=Order::F>
    struct Array3D
    {
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int size () noexcept { return (XHI-XLO+1)*(YHI-YLO+1)*(ZHI-ZLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int xlo () noexcept { return XLO; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int xhi () noexcept { return XHI; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int xlen () noexcept { return (XHI-XLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int ylo () noexcept { return YLO; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int yhi () noexcept { return YHI; }
 
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int ylen () noexcept { return (YHI-YLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int zlo () noexcept { return ZLO; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr int zhi () noexcept { return ZHI; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static constexpr unsigned int zlen () noexcept { return (ZHI-ZLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T* begin () const noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T* end () const noexcept { return arr + (XHI-XLO+1)*(YHI-YLO+1)*(ZHI-ZLO+1); }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T* begin () noexcept { return arr; }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T* end () noexcept { return arr + (XHI-XLO+1)*(YHI-YLO+1)*(ZHI-ZLO+1); }
 
        template <Order Ord=ORDER, std::enable_if_t<Ord==Order::F,int> = 0>
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T& operator() (int i, int j, int k) const noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i, j, k);
#endif
            return arr[i+j*(XHI-XLO+1)+k*((XHI-XLO+1)*(YHI-YLO+1))
                       -(ZLO*((XHI-XLO+1)*(YHI-YLO+1))+YLO*(XHI-XLO+1)+XLO)];
        }
 
        template <Order Ord=ORDER, std::enable_if_t<Ord==Order::F,int> = 0>
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T& operator() (int i, int j, int k) noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i, j, k);
#endif
            return arr[i+j*(XHI-XLO+1)+k*((XHI-XLO+1)*(YHI-YLO+1))
                       -(ZLO*((XHI-XLO+1)*(YHI-YLO+1))+YLO*(XHI-XLO+1)+XLO)];
        }
 
        template <Order Ord=ORDER, std::enable_if_t<Ord==Order::C,int> = 0>
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        const T& operator() (int i, int j, int k) const noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i, j, k);
#endif
            return arr[k+j*(ZHI-ZLO+1)+i*((ZHI-ZLO+1)*(YHI-YLO+1))
                       -(XLO*((ZHI-ZLO+1)*(YHI-YLO+1))+YLO*(ZHI-ZLO+1)+ZLO)];
        }
 
        template <Order Ord=ORDER, std::enable_if_t<Ord==Order::C,int> = 0>
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        T& operator() (int i, int j, int k) noexcept {
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
            index_assert(i, j, k);
#endif
            return arr[k+j*(ZHI-ZLO+1)+i*((ZHI-ZLO+1)*(YHI-YLO+1))
                       -(XLO*((ZHI-ZLO+1)*(YHI-YLO+1))+YLO*(ZHI-ZLO+1)+ZLO)];
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T sum () const noexcept
        {
            T s = 0;
            for (int i = 0; i < (XHI-XLO+1)*(YHI-YLO+1)*(ZHI-ZLO+1); ++i) {
                s += arr[i];
            }
            return s;
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T sum (int axis, int loc0, int loc1) const noexcept
        {
            T s = 0;
            if        (axis == 0) {
                int j = loc0;
                int k = loc1;
                for (int i = XLO; i <= XHI; ++i) {
                    s += this->operator()(i,j,k);
                }
            } else if (axis == 1) {
                int i = loc0;
                int k = loc1;
                for (int j = YLO; j <= YHI; ++j) {
                    s += this->operator()(i,j,k);
                }
            } else if (axis == 2) {
                int i = loc0;
                int j = loc1;
                for (int k = ZLO; k <= ZHI; ++k) {
                    s += this->operator()(i,j,k);
                }
            }
            return s;
        }
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T product () const noexcept
        {
            T p = 1;
            for (int i = 0; i < (XHI-XLO+1)*(YHI-YLO+1)*(ZHI-ZLO+1); ++i) {
                p *= arr[i];
            }
            return p;
        }
 
 
        [[nodiscard]] AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        constexpr T product (const int axis, const int loc0, const int loc1) const noexcept
        {
            T p = 1;
            if        (axis == 0) {
                int j = loc0;
                int k = loc1;
                for (int i = XLO; i <= XHI; ++i) {
                    p *= this->operator()(i,j,k);
                }
            } else if (axis == 1) {
                int i = loc0;
                int k = loc1;
                for (int j = YLO; j <= YHI; ++j) {
                    p *= this->operator()(i,j,k);
                }
            } else if (axis == 2) {
                int i = loc0;
                int j = loc1;
                for (int k = ZLO; k <= ZHI; ++k) {
                    p *= this->operator()(i,j,k);
                }
            }
            return p;
        }
 
#if defined(AMREX_DEBUG) || defined(AMREX_BOUND_CHECK)
        AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE
        static void index_assert (int i, int j, int k)
        {
            if (i<XLO || i>XHI || j<YLO || j>YHI || k<ZLO || k>ZHI) {
                AMREX_IF_ON_DEVICE((
                    AMREX_DEVICE_PRINTF(" (%d,%d,%d) is out of bound (%d:%d,%d:%d,%d:%d)\n",
                                        i, j, k, XLO, XHI, YLO, YHI, ZLO, ZHI);
                    amrex::Abort();
                ))
                AMREX_IF_ON_HOST((
                    std::stringstream ss;
                    ss << " (" << i << "," << j << "," << k
                    << ") is out of bound ("
                    << XLO << ":" << XHI << ","
                    << YLO << ":" << YHI << ","
                    << ZLO << ":" << ZHI << ")";
                    amrex::Abort(ss.str());
                ))
            }
        }
#endif
 
        T arr[(XHI-XLO+1)*(YHI-YLO+1)*(ZHI-ZLO+1)];
    };
}
 
namespace amrex
{
    template <class T, typename = typename T::FABType>
    std::array<T*,AMREX_SPACEDIM> GetArrOfPtrs (std::array<T,AMREX_SPACEDIM>& a) noexcept
    {
        return {{AMREX_D_DECL(a.data(), a.data()+1, a.data()+2)}};
    }
 
    template <class T>
    std::array<T*,AMREX_SPACEDIM> GetArrOfPtrs (const std::array<std::unique_ptr<T>,AMREX_SPACEDIM>& a) noexcept
    {
        return {{AMREX_D_DECL(a[0].get(), a[1].get(), a[2].get())}};
    }
 
    template <class T>
    std::array<T const*,AMREX_SPACEDIM> GetArrOfConstPtrs (const std::array<T,AMREX_SPACEDIM>& a) noexcept
    {
        return {{AMREX_D_DECL(a.data(), a.data()+1, a.data()+2)}};
    }
 
    template <class T>
    std::array<T const*,AMREX_SPACEDIM> GetArrOfConstPtrs (const std::array<T*,AMREX_SPACEDIM>& a) noexcept
    {
        return {{AMREX_D_DECL(a[0], a[1], a[2])}};
    }
 
    template <class T>
    std::array<T const*,AMREX_SPACEDIM> GetArrOfConstPtrs (const std::array<std::unique_ptr<T>,AMREX_SPACEDIM>& a) noexcept
    {
        return {{AMREX_D_DECL(a[0].get(), a[1].get(), a[2].get())}};
    }
 
}
 
namespace amrex
{
    inline XDim3 makeXDim3 (const Array<Real,AMREX_SPACEDIM>& a) noexcept
    {
#if (AMREX_SPACEDIM == 1)
        return XDim3{a[0], 0., 0.};
#elif (AMREX_SPACEDIM == 2)
        return XDim3{a[0], a[1], 0.};
#else
        return XDim3{a[0], a[1], a[2]};
#endif
    }
}
 
#endif