Block-Structured AMR Software Framework
amrex::detail Namespace Reference

Classes

struct  clzll_tag
 
struct  clzl_tag
 
struct  clz_tag
 
class  SingleChunkArena
 
struct  gpu_tuple_element
 
struct  gpu_tuple_impl
 
struct  gpu_tuple_impl< I, Head, Tail... >
 
struct  gpu_tuple_impl< I, Head >
 
struct  unwrap
 
struct  unwrap< std::reference_wrapper< T > >
 
struct  tuple_cat_result
 
struct  tuple_cat_result< GpuTuple< Ts... > >
 
struct  tuple_cat_result< GpuTuple< T1s... >, GpuTuple< T2s... >, TPs... >
 
struct  SplitIndexList
 
struct  invoke_result
 
struct  invoke_result< decltype(void(INVOKE(std::declval< F >(), std::declval< Args >()...))), F, Args... >
 
struct  apply_result
 
struct  apply_result< F, GpuTuple< Ts... > >
 
struct  TypeListGet
 
struct  TypeListGet< I, TypeList< Head, Tail... > >
 
struct  TypeListGet< 0, TypeList< Head, Tail... > >
 
struct  Nonesuch
 
struct  Detector
 
struct  Detector< Default, Void_t< Op< Args... > >, Op, Args... >
 
struct  IsConvertibleImp
 
struct  IsConvertibleImp< T, U, std::enable_if_t< is_convertible< T >(U{})> >
 
class  CutFabFactory
 

Typedefs

template<typename T >
using tuple_decay_t = typename unwrap< std::decay_t< T > >::type
 
template<class... >
using Void_t = void
 
template<typename T , typename... Args>
using call_result_t = decltype(std::declval< T >()(std::declval< Args >()...))
 

Enumerations

enum  ReduceOp : int {
  max = 0 , min , sum , lor ,
  land
}
 

Functions

template<typename F , typename MF >
auto call_interp_hook (F const &f, MF &mf, int icomp, int ncomp) -> decltype(f(mf[0], Box(), icomp, ncomp))
 
template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF make_mf_crse_patch (FabArrayBase::FPinfo const &fpc, int ncomp)
 
template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF make_mf_crse_patch (FabArrayBase::FPinfo const &fpc, int ncomp, IndexType idx_type)
 
template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF make_mf_fine_patch (FabArrayBase::FPinfo const &fpc, int ncomp)
 
template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF make_mf_fine_patch (FabArrayBase::FPinfo const &fpc, int ncomp, IndexType idx_type)
 
template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF make_mf_refined_patch (FabArrayBase::FPinfo const &fpc, int ncomp, IndexType idx_type, IntVect ratio)
 
template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF make_mf_crse_mask (FabArrayBase::FPinfo const &fpc, int ncomp, IndexType idx_type, IntVect ratio)
 
template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
void mf_set_domain_bndry (MF &mf, Geometry const &geom)
 
template<typename MF , typename BC , typename Interp , typename PreInterpHook , typename PostInterpHook >
std::enable_if_t< IsFabArray< MF >::value, intFillPatchTwoLevels_doit (MF &mf, IntVect const &nghost, Real time, const Vector< MF * > &cmf, const Vector< Real > &ct, const Vector< MF * > &fmf, const Vector< Real > &ft, int scomp, int dcomp, int ncomp, const Geometry &cgeom, const Geometry &fgeom, BC &cbc, int cbccomp, BC &fbc, int fbccomp, const IntVect &ratio, Interp *mapper, const Vector< BCRec > &bcs, int bcscomp, const PreInterpHook &pre_interp, const PostInterpHook &post_interp, EB2::IndexSpace const *index_space, bool return_error_code=false)
 
template<typename MF , typename BC , typename Interp , typename PreInterpHook , typename PostInterpHook >
std::enable_if_t< IsFabArray< MF >::value > FillPatchTwoLevels_doit (Array< MF *, AMREX_SPACEDIM > const &mf, IntVect const &nghost, Real time, const Vector< Array< MF *, AMREX_SPACEDIM > > &cmf, const Vector< Real > &ct, const Vector< Array< MF *, AMREX_SPACEDIM > > &fmf, const Vector< Real > &ft, int scomp, int dcomp, int ncomp, const Geometry &cgeom, const Geometry &fgeom, Array< BC, AMREX_SPACEDIM > &cbc, const Array< int, AMREX_SPACEDIM > &cbccomp, Array< BC, AMREX_SPACEDIM > &fbc, const Array< int, AMREX_SPACEDIM > &fbccomp, const IntVect &ratio, Interp *mapper, const Array< Vector< BCRec >, AMREX_SPACEDIM > &bcs, const Array< int, AMREX_SPACEDIM > &bcscomp, const PreInterpHook &pre_interp, const PostInterpHook &post_interp, EB2::IndexSpace const *index_space)
 
std::ostream & box_write (std::ostream &os, const int *smallend, const int *bigend, const int *type, int dim)
 
std::istream & box_read (std::istream &is, int *smallend, int *bigend, int *type, int dim)
 
template<std::size_t... Ns, class T , class U >
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE auto BoxSplit_imp (std::index_sequence< Ns... >, const T &lo, const T &hi, const U &typ) noexcept
 
template<typename T >
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE GpuComplex< T > complex_pow_unsigned (GpuComplex< T > a_z, unsigned a_n)
 
template<typename F , typename N >
AMREX_FORCE_INLINE auto call_f_scalar_handler (F const &f, N i) noexcept -> decltype(f(0))
 
template<typename F , std::size_t... Ns, class... Args>
AMREX_FORCE_INLINE auto call_f_intvect_inner (std::index_sequence< Ns... >, F const &f, IntVectND< 1 > iv, Args...args) noexcept -> decltype(f(0, 0, 0, args...))
 
template<typename F , std::size_t... Ns, class... Args>
AMREX_FORCE_INLINE auto call_f_intvect_inner (std::index_sequence< Ns... >, F const &f, IntVectND< 2 > iv, Args...args) noexcept -> decltype(f(0, 0, 0, args...))
 
template<typename F , int dim, std::size_t... Ns, class... Args>
AMREX_FORCE_INLINE auto call_f_intvect_inner (std::index_sequence< Ns... >, F const &f, IntVectND< dim > iv, Args...args) noexcept -> decltype(f(iv, args...))
 
template<typename F , int dim>
AMREX_FORCE_INLINE auto call_f_intvect_engine (F const &f, IntVectND< dim > iv, RandomEngine engine) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv, engine))
 
template<typename F , int dim>
AMREX_FORCE_INLINE auto call_f_intvect_handler (F const &f, IntVectND< dim > iv) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv))
 
template<typename F , typename T , int dim>
AMREX_FORCE_INLINE auto call_f_intvect_ncomp_engine (F const &f, IntVectND< dim > iv, T n, RandomEngine engine) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv, n, engine))
 
template<typename F , typename T , int dim>
AMREX_FORCE_INLINE auto call_f_intvect_ncomp_handler (F const &f, IntVectND< dim > iv, T n) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv, n))
 
template<int idim, typename L , int dim>
AMREX_FORCE_INLINE void For_impND (L const &f, IntVectND< dim > const lo, IntVectND< dim > const hi, IntVectND< dim > iv) noexcept
 
template<int idim, typename L , int dim>
AMREX_FORCE_INLINE void ParallelFor_impND (L const &f, IntVectND< dim > const lo, IntVectND< dim > const hi, IntVectND< dim > iv) noexcept
 
template<int idim, typename L , typename T , int dim>
AMREX_FORCE_INLINE void For_impND (L const &f, IntVectND< dim > const lo, IntVectND< dim > const hi, IntVectND< dim > iv, T n) noexcept
 
template<int idim, typename L , typename T , int dim>
AMREX_FORCE_INLINE void ParallelFor_impND (L const &f, IntVectND< dim > const lo, IntVectND< dim > const hi, IntVectND< dim > iv, T n) noexcept
 
template<int idim, typename L , int dim>
AMREX_FORCE_INLINE void ParallelForRNG_impND (L const &f, IntVectND< dim > const lo, IntVectND< dim > const hi, IntVectND< dim > iv) noexcept
 
template<int idim, typename L , typename T , int dim>
AMREX_FORCE_INLINE void ParallelForRNG_impND (L const &f, IntVectND< dim > const lo, IntVectND< dim > const hi, IntVectND< dim > iv, T n) noexcept
 
template<typename F , typename N >
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_scalar_handler (F const &f, N i, Gpu::Handler const &) noexcept -> decltype(f(0))
 
template<typename F , std::size_t... Ns, class... Args>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_intvect_inner (std::index_sequence< Ns... >, F const &f, IntVectND< 1 > iv, Args...args) noexcept -> decltype(f(0, 0, 0, args...))
 
template<typename F , std::size_t... Ns, class... Args>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_intvect_inner (std::index_sequence< Ns... >, F const &f, IntVectND< 2 > iv, Args...args) noexcept -> decltype(f(0, 0, 0, args...))
 
template<typename F , int dim, std::size_t... Ns, class... Args>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_intvect_inner (std::index_sequence< Ns... >, F const &f, IntVectND< dim > iv, Args...args) noexcept -> decltype(f(iv, args...))
 
template<typename F , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_intvect (F const &f, IntVectND< dim > iv) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv))
 
template<typename F , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_intvect_engine (F const &f, IntVectND< dim > iv, RandomEngine engine) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv, engine))
 
template<typename F , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_intvect_handler (F const &f, IntVectND< dim > iv, Gpu::Handler const &) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv))
 
template<typename F , typename T , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_intvect_ncomp (F const &f, IntVectND< dim > iv, T ncomp) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv, 0))
 
template<typename F , typename T , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_intvect_ncomp_engine (F const &f, IntVectND< dim > iv, T ncomp, RandomEngine engine) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv, 0, engine))
 
template<typename F , typename T , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto call_f_intvect_ncomp_handler (F const &f, IntVectND< dim > iv, T ncomp, Gpu::Handler const &) noexcept -> decltype(call_f_intvect_inner(std::make_index_sequence< dim >(), f, iv, 0))
 
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>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINEIndexTypeSplit_imp (T &retval, std::index_sequence< Ns... >, unsigned int src) noexcept
 
std::ostream & int_vector_write (std::ostream &os, const int *iv, int dim)
 
std::istream & int_vector_read (std::istream &is, int *iv, int dim)
 
template<int dim>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE void IntVectCat_imp (int *&dst, const IntVectND< dim > &src) noexcept
 
template<int dim>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE void IntVectSplit_imp2 (IntVectND< dim > &dst, const int *&src) noexcept
 
template<class T , std::size_t... Ns>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINEIntVectSplit_imp (T &retval, std::index_sequence< Ns... >, const int *src) noexcept
 
template<int... dims>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE int get_sum ()
 
void build_par_for_nblocks (char *&a_hp, char *&a_dp, std::pair< int *, int * > &blocks_x, BoxIndexer *&pboxes, Vector< Box > const &boxes, Vector< Long > const &ncells, int nthreads)
 
void destroy_par_for_nblocks (char *hp, char *dp)
 
template<typename T >
void Reduce (ReduceOp, T *, int, int, MPI_Comm)
 
template<typename T >
void Reduce (ReduceOp, T &, int, MPI_Comm)
 
template<typename T >
void Reduce (ReduceOp, Vector< std::reference_wrapper< T > > const &, int, MPI_Comm)
 
template<typename T >
void Gather (const T *, int, T *, int, MPI_Comm)
 
template<typename T >
void Gather (const T &, T *, int, MPI_Comm)
 
template<typename T , typename F >
int amrex_partition_helper (T const *AMREX_RESTRICT pv, T *AMREX_RESTRICT pv2, int n, F &&f)
 
template<typename T >
void amrex_stable_partition_helper (T *p, int n2)
 
template<typename T , typename Size , template< class > class Allocator>
FatPtr< T > allocate_in_place ([[maybe_unused]] T *p, [[maybe_unused]] Size nmin, Size nmax, Allocator< T > &allocator)
 
template<typename T , typename Size , template< class > class Allocator>
T * shrink_in_place ([[maybe_unused]] T *p, Size n, Allocator< T > &allocator)
 
template<typename T , typename Size , template< class > class Allocator>
void uninitializedFillNImpl (T *data, Size count, const T &value, [[maybe_unused]] Allocator< T > const &allocator)
 
template<typename T , template< class > class Allocator>
void initFromListImpl (T *data, std::initializer_list< T > const &list, [[maybe_unused]] Allocator< T > const &allocator)
 
template<typename T , typename Size , template< class > class Allocator>
void fillValuesImpl (T *dst, T const *src, Size count, [[maybe_unused]] Allocator< T > const &allocator)
 
template<typename Allocator >
void memCopyImpl (void *dst, const void *src, std::size_t count, [[maybe_unused]] Allocator const &dst_allocator, [[maybe_unused]] Allocator const &src_allocator, [[maybe_unused]] bool sync=true)
 
template<typename Allocator >
void memMoveImpl (void *dst, const void *src, std::size_t count, [[maybe_unused]] Allocator const &allocator)
 
template<typename T , typename Size , template< class > class Allocator>
void maybe_init_snan (T *data, Size count, Allocator< T > const &allocator)
 
ULong DefaultGpuSeed ()
 
template<typename T , Order >
Table1D< T > make_table (T *p, Array< int, 1 > const &lo, Array< int, 1 > const &hi)
 
template<typename T , Order ORDER>
Table2D< T, ORDER > make_table (T *p, Array< int, 2 > const &lo, Array< int, 2 > const &hi)
 
template<typename T , Order ORDER>
Table3D< T > make_table (T *p, Array< int, 3 > const &lo, Array< int, 3 > const &hi)
 
template<typename T , Order ORDER>
Table4D< T > make_table (T *p, Array< int, 4 > const &lo, Array< int, 4 > const &hi)
 
template<typename T >
std::enable_if_t< std::is_same< std::decay_t< decltype(std::declval< T >).box())>, Box >::value, Long > get_tag_size (T const &tag) noexcept
 
template<typename T >
std::enable_if_t< std::is_integral< std::decay_t< decltype(std::declval< T >).size())> >::value, Long > get_tag_size (T const &tag) noexcept
 
template<typename T , typename F >
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE std::enable_if_t< std::is_same< std::decay_t< decltype(std::declval< T >).box())>, Box >::value > tagparfor_call_f (int icell, T const &tag, F &&f) noexcept
 
template<typename T , typename F >
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE std::enable_if_t< std::is_integral< std::decay_t< decltype(std::declval< T >).size())> >::value > tagparfor_call_f (int i, T const &tag, F &&f) noexcept
 
template<class TagType , class F >
void ParallelFor_doit (Vector< TagType > const &tags, F &&f)
 
template<std::size_t I, typename... Ts>
constexpr AMREX_GPU_HOST_DEVICE GpuTupleElement< I, GpuTuple< Ts... > >::type & get_impl (detail::gpu_tuple_element< I, typename GpuTupleElement< I, GpuTuple< Ts... > >::type > &te) noexcept
 
template<std::size_t I, typename... Ts>
constexpr AMREX_GPU_HOST_DEVICE GpuTupleElement< I, GpuTuple< Ts... > >::type const & get_impl (detail::gpu_tuple_element< I, typename GpuTupleElement< I, GpuTuple< Ts... > >::type > const &te) noexcept
 
template<std::size_t I, typename... Ts>
constexpr AMREX_GPU_HOST_DEVICE GpuTupleElement< I, GpuTuple< Ts... > >::type && get_impl (detail::gpu_tuple_element< I, typename GpuTupleElement< I, GpuTuple< Ts... > >::type > &&te) noexcept
 
template<std::size_t I, std::size_t N, typename TP1 , typename TP2 >
AMREX_GPU_HOST_DEVICE std::enable_if_t<(I< N-1), void > tuple_copy (TP1 &a, TP2 &&b)
 
template<std::size_t I, std::size_t N, typename TP1 , typename TP2 >
AMREX_GPU_HOST_DEVICE std::enable_if_t< I==N-1, void > tuple_copy (TP1 &a, TP2 &&b)
 
template<typename R , typename TP1 , typename TP2 , std::size_t... N1, std::size_t... N2>
constexpr AMREX_GPU_HOST_DEVICEmake_tuple (TP1 const &a, TP2 const &b, std::index_sequence< N1... > const &, std::index_sequence< N2... > const &)
 
template<std::size_t start, typename... Args, std::size_t... Is>
constexpr AMREX_GPU_HOST_DEVICE auto GetSubTuple (const GpuTuple< Args... > &tup, std::index_sequence< Is... >) noexcept
 
template<typename... Args, std::size_t... Is, typename SIL >
constexpr AMREX_GPU_HOST_DEVICE auto TupleSplitImp (const GpuTuple< Args... > &tup, std::index_sequence< Is... >, SIL) noexcept
 
template<typename F , typename... Args>
AMREX_GPU_HOST_DEVICE auto INVOKE (F &&f, Args &&... args) -> decltype(f(std::forward< Args >(args)...))
 
template<typename F , typename TP , std::size_t... N>
constexpr AMREX_GPU_HOST_DEVICE auto apply_impl (F &&f, TP &&t, std::index_sequence< N... >) -> typename detail::apply_result< F, detail::tuple_decay_t< TP > >::type
 
template<typename T , std::size_t... I>
constexpr AMREX_GPU_HOST_DEVICE auto tuple_to_array_helper (T const &tup, std::index_sequence< I... >)
 
template<typename TL , typename F , std::size_t... N>
constexpr void for_each_impl (F const &f, std::index_sequence< N... >)
 
template<typename TL , typename F , std::size_t... N>
constexpr bool for_each_until_impl (F const &f, std::index_sequence< N... >)
 
template<class T , std::size_t N>
constexpr auto SingleTypeMultiplier_impl ()
 
template<class T , std::size_t N>
constexpr auto SingleTypeMultiplier (const T(&)[N])
 
template<class T >
constexpr auto SingleTypeMultiplier (T)
 
template<template< class... > class TParam, class... Args>
constexpr auto TApply (TypeList< Args... >)
 
template<typename T >
constexpr bool is_convertible (T)
 
template<class T , class H >
std::size_t removeDupDoit (Vector< T > &vec, std::size_t start, std::size_t stop)
 
template<typename FAB >
void read_fab (FAB &fab, VisMF::FabOnDisk const &fod, std::string const &name)
 
AMREX_GPU_DEVICE AMREX_FORCE_INLINE RealVect facets_nearest_pt (IntVect const &ind_pt, IntVect const &ind_loop, RealVect const &r_vec, RealVect const &eb_normal, RealVect const &eb_p0, GpuArray< Real, AMREX_SPACEDIM > const &dx)
 
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void comp_bf (Real &bf1, Real &bf2, Real sb, Real h, int bct, Real bcl, int bho)
 
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void comp_bflo (Real &bf1, Real &bf2, Real &bflo, Real sb, Real h, int bct, Real bcl, int bho)
 
template<typename T >
void pack_matrix_gpu (Gpu::DeviceVector< HYPRE_Int > &cols_tmp, Gpu::DeviceVector< HYPRE_Real > mat_tmp, Gpu::DeviceVector< HYPRE_Int > &cols, Gpu::DeviceVector< HYPRE_Real > &mat)
 
template<typename LP >
void applyRobinBCTermsCoeffs (LP &linop)
 
template<typename F , typename SrcData , typename DstData , typename N1 , typename N2 >
AMREX_GPU_HOST_DEVICE auto call_check_pair (F const &check_pair, const SrcData &src_tile, const DstData &dst_tile, N1 i, N2 j) noexcept -> decltype(check_pair(src_tile.m_aos[i], dst_tile.m_aos[j]))
 
template<typename F , typename SrcData , typename DstData , typename N1 , typename N2 , typename N3 , typename N4 , typename N5 >
AMREX_GPU_HOST_DEVICE auto call_check_pair (F const &check_pair, const SrcData &src_tile, const DstData &dst_tile, N1 i, N2 j, N3, N4, N5) noexcept -> decltype(check_pair(src_tile.m_aos[i], dst_tile.m_aos[j]))
 

Typedef Documentation

◆ call_result_t

template<typename T , typename... Args>
using amrex::detail::call_result_t = typedef decltype(std::declval<T>()(std::declval<Args>()...))

◆ tuple_decay_t

template<typename T >
using amrex::detail::tuple_decay_t = typedef typename unwrap<std::decay_t<T> >::type

◆ Void_t

template<class... >
using amrex::detail::Void_t = typedef void

Enumeration Type Documentation

◆ ReduceOp

Enumerator
max 
min 
sum 
lor 
land 

Function Documentation

◆ allocate_in_place()

template<typename T , typename Size , template< class > class Allocator>
FatPtr<T> amrex::detail::allocate_in_place ( [[maybe_unused] ] T *  p,
[[maybe_unused] ] Size  nmin,
Size  nmax,
Allocator< T > &  allocator 
)

◆ amrex_partition_helper()

template<typename T , typename F >
int amrex::detail::amrex_partition_helper ( T const *AMREX_RESTRICT  pv,
T *AMREX_RESTRICT  pv2,
int  n,
F &&  f 
)

◆ amrex_stable_partition_helper()

template<typename T >
void amrex::detail::amrex_stable_partition_helper ( T *  p,
int  n2 
)

◆ apply_impl()

template<typename F , typename TP , std::size_t... N>
constexpr AMREX_GPU_HOST_DEVICE auto amrex::detail::apply_impl ( F &&  f,
TP &&  t,
std::index_sequence< N... >   
) -> typename detail::apply_result<F,detail::tuple_decay_t<TP> >::type
constexpr

◆ applyRobinBCTermsCoeffs()

template<typename LP >
void amrex::detail::applyRobinBCTermsCoeffs ( LP &  linop)

◆ box_read()

std::istream & amrex::detail::box_read ( std::istream &  is,
int smallend,
int bigend,
int type,
int  dim 
)

◆ box_write()

std::ostream & amrex::detail::box_write ( std::ostream &  os,
const int smallend,
const int bigend,
const int type,
int  dim 
)

◆ BoxSplit_imp()

template<std::size_t... Ns, class T , class U >
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE auto amrex::detail::BoxSplit_imp ( std::index_sequence< Ns... >  ,
const T &  lo,
const T &  hi,
const U &  typ 
)
constexprnoexcept

◆ build_par_for_nblocks()

void amrex::detail::build_par_for_nblocks ( char *&  a_hp,
char *&  a_dp,
std::pair< int *, int * > &  blocks_x,
BoxIndexer *&  pboxes,
Vector< Box > const &  boxes,
Vector< Long > const &  ncells,
int  nthreads 
)
inline

◆ call_check_pair() [1/2]

template<typename F , typename SrcData , typename DstData , typename N1 , typename N2 >
AMREX_GPU_HOST_DEVICE auto amrex::detail::call_check_pair ( F const &  check_pair,
const SrcData &  src_tile,
const DstData &  dst_tile,
N1  i,
N2  j 
) -> decltype(check_pair(src_tile.m_aos[i], dst_tile.m_aos[j]))
noexcept

◆ call_check_pair() [2/2]

template<typename F , typename SrcData , typename DstData , typename N1 , typename N2 , typename N3 , typename N4 , typename N5 >
AMREX_GPU_HOST_DEVICE auto amrex::detail::call_check_pair ( F const &  check_pair,
const SrcData &  src_tile,
const DstData &  dst_tile,
N1  i,
N2  j,
N3  type,
N4  ghost_i,
N5  ghost_pid 
) -> decltype(check_pair(src_tile.m_aos[i], dst_tile.m_aos[j]))
noexcept

◆ call_f_intvect()

template<typename F , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect ( F const &  f,
IntVectND< dim >  iv 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv))
noexcept

◆ call_f_intvect_engine() [1/2]

template<typename F , int dim>
AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_engine ( F const &  f,
IntVectND< dim >  iv,
RandomEngine  engine 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv, engine))
noexcept

◆ call_f_intvect_engine() [2/2]

template<typename F , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_engine ( F const &  f,
IntVectND< dim >  iv,
RandomEngine  engine 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv, engine))
noexcept

◆ call_f_intvect_handler() [1/2]

template<typename F , int dim>
AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_handler ( F const &  f,
IntVectND< dim >  iv 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv))
noexcept

◆ call_f_intvect_handler() [2/2]

template<typename F , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_handler ( F const &  f,
IntVectND< dim >  iv,
Gpu::Handler const &  handler 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv))
noexcept

◆ call_f_intvect_inner() [1/6]

template<typename F , std::size_t... Ns, class... Args>
AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_inner ( std::index_sequence< Ns... >  ,
F const &  f,
IntVectND< 1 >  iv,
Args...  args 
) -> decltype(f(0, 0, 0, args...))
noexcept

◆ call_f_intvect_inner() [2/6]

template<typename F , std::size_t... Ns, class... Args>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_inner ( std::index_sequence< Ns... >  ,
F const &  f,
IntVectND< 1 >  iv,
Args...  args 
) -> decltype(f(0, 0, 0, args...))
noexcept

◆ call_f_intvect_inner() [3/6]

template<typename F , std::size_t... Ns, class... Args>
AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_inner ( std::index_sequence< Ns... >  ,
F const &  f,
IntVectND< 2 >  iv,
Args...  args 
) -> decltype(f(0, 0, 0, args...))
noexcept

◆ call_f_intvect_inner() [4/6]

template<typename F , std::size_t... Ns, class... Args>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_inner ( std::index_sequence< Ns... >  ,
F const &  f,
IntVectND< 2 >  iv,
Args...  args 
) -> decltype(f(0, 0, 0, args...))
noexcept

◆ call_f_intvect_inner() [5/6]

template<typename F , int dim, std::size_t... Ns, class... Args>
AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_inner ( std::index_sequence< Ns... >  ,
F const &  f,
IntVectND< dim >  iv,
Args...  args 
) -> decltype(f(iv, args...))
noexcept

◆ call_f_intvect_inner() [6/6]

template<typename F , int dim, std::size_t... Ns, class... Args>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_inner ( std::index_sequence< Ns... >  ,
F const &  f,
IntVectND< dim >  iv,
Args...  args 
) -> decltype(f(iv, args...))
noexcept

◆ call_f_intvect_ncomp()

template<typename F , typename T , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_ncomp ( F const &  f,
IntVectND< dim >  iv,
ncomp 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv, 0))
noexcept

◆ call_f_intvect_ncomp_engine() [1/2]

template<typename F , typename T , int dim>
AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_ncomp_engine ( F const &  f,
IntVectND< dim >  iv,
n,
RandomEngine  engine 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv, n, engine))
noexcept

◆ call_f_intvect_ncomp_engine() [2/2]

template<typename F , typename T , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_ncomp_engine ( F const &  f,
IntVectND< dim >  iv,
ncomp,
RandomEngine  engine 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv, 0, engine))
noexcept

◆ call_f_intvect_ncomp_handler() [1/2]

template<typename F , typename T , int dim>
AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_ncomp_handler ( F const &  f,
IntVectND< dim >  iv,
n 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv, n))
noexcept

◆ call_f_intvect_ncomp_handler() [2/2]

template<typename F , typename T , int dim>
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_intvect_ncomp_handler ( F const &  f,
IntVectND< dim >  iv,
ncomp,
Gpu::Handler const &  handler 
) -> decltype(call_f_intvect_inner(std::make_index_sequence<dim>(), f, iv, 0))
noexcept

◆ call_f_scalar_handler() [1/2]

template<typename F , typename N >
AMREX_FORCE_INLINE auto amrex::detail::call_f_scalar_handler ( F const &  f,
i 
) -> decltype(f(0))
noexcept

◆ call_f_scalar_handler() [2/2]

template<typename F , typename N >
AMREX_GPU_DEVICE AMREX_FORCE_INLINE auto amrex::detail::call_f_scalar_handler ( F const &  f,
i,
Gpu::Handler const &  handler 
) -> decltype(f(0))
noexcept

◆ call_interp_hook()

template<typename F , typename MF >
auto amrex::detail::call_interp_hook ( F const &  f,
MF &  mf,
int  icomp,
int  ncomp 
) -> decltype(f(mf[0],Box(),icomp,ncomp))

◆ comp_bf()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void amrex::detail::comp_bf ( Real &  bf1,
Real &  bf2,
Real  sb,
Real  h,
int  bct,
Real  bcl,
int  bho 
)

◆ comp_bflo()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void amrex::detail::comp_bflo ( Real &  bf1,
Real &  bf2,
Real &  bflo,
Real  sb,
Real  h,
int  bct,
Real  bcl,
int  bho 
)

◆ complex_pow_unsigned()

template<typename T >
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE GpuComplex<T> amrex::detail::complex_pow_unsigned ( GpuComplex< T >  a_z,
unsigned  a_n 
)

◆ DefaultGpuSeed()

ULong amrex::detail::DefaultGpuSeed ( )
inline

◆ destroy_par_for_nblocks()

void amrex::detail::destroy_par_for_nblocks ( char *  hp,
char *  dp 
)
inline

◆ facets_nearest_pt()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE RealVect amrex::detail::facets_nearest_pt ( IntVect const &  ind_pt,
IntVect const &  ind_loop,
RealVect const &  r_vec,
RealVect const &  eb_normal,
RealVect const &  eb_p0,
GpuArray< Real, AMREX_SPACEDIM > const &  dx 
)

◆ FillPatchTwoLevels_doit() [1/2]

template<typename MF , typename BC , typename Interp , typename PreInterpHook , typename PostInterpHook >
std::enable_if_t<IsFabArray<MF>::value> amrex::detail::FillPatchTwoLevels_doit ( Array< MF *, AMREX_SPACEDIM > const &  mf,
IntVect const &  nghost,
Real  time,
const Vector< Array< MF *, AMREX_SPACEDIM > > &  cmf,
const Vector< Real > &  ct,
const Vector< Array< MF *, AMREX_SPACEDIM > > &  fmf,
const Vector< Real > &  ft,
int  scomp,
int  dcomp,
int  ncomp,
const Geometry cgeom,
const Geometry fgeom,
Array< BC, AMREX_SPACEDIM > &  cbc,
const Array< int, AMREX_SPACEDIM > &  cbccomp,
Array< BC, AMREX_SPACEDIM > &  fbc,
const Array< int, AMREX_SPACEDIM > &  fbccomp,
const IntVect ratio,
Interp *  mapper,
const Array< Vector< BCRec >, AMREX_SPACEDIM > &  bcs,
const Array< int, AMREX_SPACEDIM > &  bcscomp,
const PreInterpHook &  pre_interp,
const PostInterpHook &  post_interp,
EB2::IndexSpace const *  index_space 
)

◆ FillPatchTwoLevels_doit() [2/2]

template<typename MF , typename BC , typename Interp , typename PreInterpHook , typename PostInterpHook >
std::enable_if_t<IsFabArray<MF>::value,int> amrex::detail::FillPatchTwoLevels_doit ( MF &  mf,
IntVect const &  nghost,
Real  time,
const Vector< MF * > &  cmf,
const Vector< Real > &  ct,
const Vector< MF * > &  fmf,
const Vector< Real > &  ft,
int  scomp,
int  dcomp,
int  ncomp,
const Geometry cgeom,
const Geometry fgeom,
BC &  cbc,
int  cbccomp,
BC &  fbc,
int  fbccomp,
const IntVect ratio,
Interp *  mapper,
const Vector< BCRec > &  bcs,
int  bcscomp,
const PreInterpHook &  pre_interp,
const PostInterpHook &  post_interp,
EB2::IndexSpace const *  index_space,
bool  return_error_code = false 
)

◆ fillValuesImpl()

template<typename T , typename Size , template< class > class Allocator>
void amrex::detail::fillValuesImpl ( T *  dst,
T const *  src,
Size  count,
[[maybe_unused] ] Allocator< T > const &  allocator 
)

◆ for_each_impl()

template<typename TL , typename F , std::size_t... N>
constexpr void amrex::detail::for_each_impl ( F const &  f,
std::index_sequence< N... >   
)
constexpr

◆ for_each_until_impl()

template<typename TL , typename F , std::size_t... N>
constexpr bool amrex::detail::for_each_until_impl ( F const &  f,
std::index_sequence< N... >   
)
constexpr

◆ For_impND() [1/2]

template<int idim, typename L , int dim>
AMREX_FORCE_INLINE void amrex::detail::For_impND ( L const &  f,
IntVectND< dim > const  lo,
IntVectND< dim > const  hi,
IntVectND< dim >  iv 
)
noexcept

◆ For_impND() [2/2]

template<int idim, typename L , typename T , int dim>
AMREX_FORCE_INLINE void amrex::detail::For_impND ( L const &  f,
IntVectND< dim > const  lo,
IntVectND< dim > const  hi,
IntVectND< dim >  iv,
n 
)
noexcept

◆ Gather() [1/2]

template<typename T >
void amrex::detail::Gather ( const T &  ,
T *  ,
int  ,
MPI_Comm   
)

◆ Gather() [2/2]

template<typename T >
void amrex::detail::Gather ( const T *  ,
int  ,
T *  ,
int  ,
MPI_Comm   
)

◆ get_impl() [1/3]

template<std::size_t I, typename... Ts>
constexpr AMREX_GPU_HOST_DEVICE GpuTupleElement<I, GpuTuple<Ts...> >::type&& amrex::detail::get_impl ( detail::gpu_tuple_element< I, typename GpuTupleElement< I, GpuTuple< Ts... > >::type > &&  te)
constexprnoexcept

◆ get_impl() [2/3]

template<std::size_t I, typename... Ts>
constexpr AMREX_GPU_HOST_DEVICE GpuTupleElement<I, GpuTuple<Ts...> >::type& amrex::detail::get_impl ( detail::gpu_tuple_element< I, typename GpuTupleElement< I, GpuTuple< Ts... > >::type > &  te)
constexprnoexcept

◆ get_impl() [3/3]

template<std::size_t I, typename... Ts>
constexpr AMREX_GPU_HOST_DEVICE GpuTupleElement<I, GpuTuple<Ts...> >::type const& amrex::detail::get_impl ( detail::gpu_tuple_element< I, typename GpuTupleElement< I, GpuTuple< Ts... > >::type > const &  te)
constexprnoexcept

◆ get_sum()

template<int... dims>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE int amrex::detail::get_sum ( )
constexpr

◆ get_tag_size() [1/2]

template<typename T >
std::enable_if_t<std::is_same<std::decay_t<decltype(std::declval<T>).box())>, Box>::value, Long> amrex::detail::get_tag_size ( T const &  tag)
noexcept

◆ get_tag_size() [2/2]

template<typename T >
std::enable_if_t<std::is_integral<std::decay_t<decltype(std::declval<T>).size())> >::value, Long> amrex::detail::get_tag_size ( T const &  tag)
noexcept

◆ GetSubTuple()

template<std::size_t start, typename... Args, std::size_t... Is>
constexpr AMREX_GPU_HOST_DEVICE auto amrex::detail::GetSubTuple ( const GpuTuple< Args... > &  tup,
std::index_sequence< Is... >   
)
constexprnoexcept

◆ index_type_read()

std::istream & amrex::detail::index_type_read ( std::istream &  is,
unsigned int iv,
int  dim 
)

◆ index_type_write()

std::ostream & amrex::detail::index_type_write ( std::ostream &  os,
const unsigned int iv,
int  dim 
)

◆ IndexTypeSplit_imp()

template<class T , std::size_t... Ns>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE T amrex::detail::IndexTypeSplit_imp ( T &  retval,
std::index_sequence< Ns... >  ,
unsigned int  src 
)
constexprnoexcept

◆ initFromListImpl()

template<typename T , template< class > class Allocator>
void amrex::detail::initFromListImpl ( T *  data,
std::initializer_list< T > const &  list,
[[maybe_unused] ] Allocator< T > const &  allocator 
)

◆ int_vector_read()

std::istream & amrex::detail::int_vector_read ( std::istream &  is,
int iv,
int  dim 
)

◆ int_vector_write()

std::ostream & amrex::detail::int_vector_write ( std::ostream &  os,
const int iv,
int  dim 
)

◆ IntVectCat_imp()

template<int dim>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE void amrex::detail::IntVectCat_imp ( int *&  dst,
const IntVectND< dim > &  src 
)
constexprnoexcept

◆ IntVectSplit_imp()

template<class T , std::size_t... Ns>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE T amrex::detail::IntVectSplit_imp ( T &  retval,
std::index_sequence< Ns... >  ,
const int src 
)
constexprnoexcept

◆ IntVectSplit_imp2()

template<int dim>
AMREX_GPU_HOST_DEVICE constexpr AMREX_FORCE_INLINE void amrex::detail::IntVectSplit_imp2 ( IntVectND< dim > &  dst,
const int *&  src 
)
constexprnoexcept

◆ INVOKE()

template<typename F , typename... Args>
AMREX_GPU_HOST_DEVICE auto amrex::detail::INVOKE ( F &&  f,
Args &&...  args 
) -> decltype(f(std::forward< Args >(args)...))

◆ is_convertible()

template<typename T >
constexpr bool amrex::detail::is_convertible ( )
inlineconstexpr

◆ make_mf_crse_mask()

template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF amrex::detail::make_mf_crse_mask ( FabArrayBase::FPinfo const &  fpc,
int  ncomp,
IndexType  idx_type,
IntVect  ratio 
)

◆ make_mf_crse_patch() [1/2]

template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF amrex::detail::make_mf_crse_patch ( FabArrayBase::FPinfo const &  fpc,
int  ncomp 
)

◆ make_mf_crse_patch() [2/2]

template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF amrex::detail::make_mf_crse_patch ( FabArrayBase::FPinfo const &  fpc,
int  ncomp,
IndexType  idx_type 
)

◆ make_mf_fine_patch() [1/2]

template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF amrex::detail::make_mf_fine_patch ( FabArrayBase::FPinfo const &  fpc,
int  ncomp 
)

◆ make_mf_fine_patch() [2/2]

template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF amrex::detail::make_mf_fine_patch ( FabArrayBase::FPinfo const &  fpc,
int  ncomp,
IndexType  idx_type 
)

◆ make_mf_refined_patch()

template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
MF amrex::detail::make_mf_refined_patch ( FabArrayBase::FPinfo const &  fpc,
int  ncomp,
IndexType  idx_type,
IntVect  ratio 
)

◆ make_table() [1/4]

template<typename T , Order >
Table1D<T> amrex::detail::make_table ( T *  p,
Array< int, 1 > const &  lo,
Array< int, 1 > const &  hi 
)

◆ make_table() [2/4]

template<typename T , Order ORDER>
Table2D<T,ORDER> amrex::detail::make_table ( T *  p,
Array< int, 2 > const &  lo,
Array< int, 2 > const &  hi 
)

◆ make_table() [3/4]

template<typename T , Order ORDER>
Table3D<T> amrex::detail::make_table ( T *  p,
Array< int, 3 > const &  lo,
Array< int, 3 > const &  hi 
)

◆ make_table() [4/4]

template<typename T , Order ORDER>
Table4D<T> amrex::detail::make_table ( T *  p,
Array< int, 4 > const &  lo,
Array< int, 4 > const &  hi 
)

◆ make_tuple()

template<typename R , typename TP1 , typename TP2 , std::size_t... N1, std::size_t... N2>
constexpr AMREX_GPU_HOST_DEVICE R amrex::detail::make_tuple ( TP1 const &  a,
TP2 const &  b,
std::index_sequence< N1... > const &  ,
std::index_sequence< N2... > const &   
)
constexpr

◆ maybe_init_snan()

template<typename T , typename Size , template< class > class Allocator>
void amrex::detail::maybe_init_snan ( T *  data,
Size  count,
Allocator< T > const &  allocator 
)

◆ memCopyImpl()

template<typename Allocator >
void amrex::detail::memCopyImpl ( void *  dst,
const void *  src,
std::size_t  count,
[[maybe_unused] ] Allocator const &  dst_allocator,
[[maybe_unused] ] Allocator const &  src_allocator,
[[maybe_unused] ] bool  sync = true 
)

◆ memMoveImpl()

template<typename Allocator >
void amrex::detail::memMoveImpl ( void *  dst,
const void *  src,
std::size_t  count,
[[maybe_unused] ] Allocator const &  allocator 
)

◆ mf_set_domain_bndry()

template<typename MF , std::enable_if_t< std::is_same_v< typename MF::FABType::value_type, FArrayBox >, int > = 0>
void amrex::detail::mf_set_domain_bndry ( MF &  mf,
Geometry const &  geom 
)

◆ pack_matrix_gpu()

template<typename T >
void amrex::detail::pack_matrix_gpu ( Gpu::DeviceVector< HYPRE_Int > &  cols_tmp,
Gpu::DeviceVector< HYPRE_Real >  mat_tmp,
Gpu::DeviceVector< HYPRE_Int > &  cols,
Gpu::DeviceVector< HYPRE_Real > &  mat 
)

◆ ParallelFor_doit()

template<class TagType , class F >
void amrex::detail::ParallelFor_doit ( Vector< TagType > const &  tags,
F &&  f 
)

◆ ParallelFor_impND() [1/2]

template<int idim, typename L , int dim>
AMREX_FORCE_INLINE void amrex::detail::ParallelFor_impND ( L const &  f,
IntVectND< dim > const  lo,
IntVectND< dim > const  hi,
IntVectND< dim >  iv 
)
noexcept

◆ ParallelFor_impND() [2/2]

template<int idim, typename L , typename T , int dim>
AMREX_FORCE_INLINE void amrex::detail::ParallelFor_impND ( L const &  f,
IntVectND< dim > const  lo,
IntVectND< dim > const  hi,
IntVectND< dim >  iv,
n 
)
noexcept

◆ ParallelForRNG_impND() [1/2]

template<int idim, typename L , int dim>
AMREX_FORCE_INLINE void amrex::detail::ParallelForRNG_impND ( L const &  f,
IntVectND< dim > const  lo,
IntVectND< dim > const  hi,
IntVectND< dim >  iv 
)
noexcept

◆ ParallelForRNG_impND() [2/2]

template<int idim, typename L , typename T , int dim>
AMREX_FORCE_INLINE void amrex::detail::ParallelForRNG_impND ( L const &  f,
IntVectND< dim > const  lo,
IntVectND< dim > const  hi,
IntVectND< dim >  iv,
n 
)
noexcept

◆ read_fab()

template<typename FAB >
void amrex::detail::read_fab ( FAB &  fab,
VisMF::FabOnDisk const &  fod,
std::string const &  name 
)

◆ Reduce() [1/3]

template<typename T >
void amrex::detail::Reduce ( ReduceOp  ,
T &  ,
int  ,
MPI_Comm   
)

◆ Reduce() [2/3]

template<typename T >
void amrex::detail::Reduce ( ReduceOp  ,
T *  ,
int  ,
int  ,
MPI_Comm   
)

◆ Reduce() [3/3]

template<typename T >
void amrex::detail::Reduce ( ReduceOp  ,
Vector< std::reference_wrapper< T > > const &  ,
int  ,
MPI_Comm   
)

◆ removeDupDoit()

template<class T , class H >
std::size_t amrex::detail::removeDupDoit ( Vector< T > &  vec,
std::size_t  start,
std::size_t  stop 
)

◆ shrink_in_place()

template<typename T , typename Size , template< class > class Allocator>
T* amrex::detail::shrink_in_place ( [[maybe_unused] ] T *  p,
Size  n,
Allocator< T > &  allocator 
)

◆ SingleTypeMultiplier() [1/2]

template<class T , std::size_t N>
constexpr auto amrex::detail::SingleTypeMultiplier ( const   T(&)[N])
constexpr

◆ SingleTypeMultiplier() [2/2]

template<class T >
constexpr auto amrex::detail::SingleTypeMultiplier ( )
constexpr

◆ SingleTypeMultiplier_impl()

template<class T , std::size_t N>
constexpr auto amrex::detail::SingleTypeMultiplier_impl ( )
constexpr

◆ tagparfor_call_f() [1/2]

template<typename T , typename F >
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE std::enable_if_t<std::is_integral<std::decay_t<decltype(std::declval<T>).size())> >::value> amrex::detail::tagparfor_call_f ( int  i,
T const &  tag,
F &&  f 
)
noexcept

◆ tagparfor_call_f() [2/2]

template<typename T , typename F >
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE std::enable_if_t<std::is_same<std::decay_t<decltype(std::declval<T>).box())>, Box>::value> amrex::detail::tagparfor_call_f ( int  icell,
T const &  tag,
F &&  f 
)
noexcept

◆ TApply()

template<template< class... > class TParam, class... Args>
constexpr auto amrex::detail::TApply ( TypeList< Args... >  )
constexpr

◆ tuple_copy() [1/2]

template<std::size_t I, std::size_t N, typename TP1 , typename TP2 >
AMREX_GPU_HOST_DEVICE std::enable_if_t<(I<N-1),void> amrex::detail::tuple_copy ( TP1 &  a,
TP2 &&  b 
)

◆ tuple_copy() [2/2]

template<std::size_t I, std::size_t N, typename TP1 , typename TP2 >
AMREX_GPU_HOST_DEVICE std::enable_if_t<I==N-1,void> amrex::detail::tuple_copy ( TP1 &  a,
TP2 &&  b 
)

◆ tuple_to_array_helper()

template<typename T , std::size_t... I>
constexpr AMREX_GPU_HOST_DEVICE auto amrex::detail::tuple_to_array_helper ( T const &  tup,
std::index_sequence< I... >   
)
constexpr

◆ TupleSplitImp()

template<typename... Args, std::size_t... Is, typename SIL >
constexpr AMREX_GPU_HOST_DEVICE auto amrex::detail::TupleSplitImp ( const GpuTuple< Args... > &  tup,
std::index_sequence< Is... >  ,
SIL   
)
constexprnoexcept

◆ uninitializedFillNImpl()

template<typename T , typename Size , template< class > class Allocator>
void amrex::detail::uninitializedFillNImpl ( T *  data,
Size  count,
const T &  value,
[[maybe_unused] ] Allocator< T > const &  allocator 
)