1#ifndef AMREX_PARTICLEUTIL_H_
2#define AMREX_PARTICLEUTIL_H_
3#include <AMReX_Config.H>
34template <
class Iterator>
53template <
class Iterator>
54requires (IsParticleIterator<Iterator>::value)
58 const auto& tile = pti.GetParticleTile();
59 const auto np = tile.numParticles();
60 const auto& ptd = tile.getConstParticleTileData();
61 const auto& geom = pti.Geom(pti.GetLevel());
63 const auto& domain = geom.Domain();
64 const auto& plo = geom.ProbLoArray();
65 const auto& dxi = geom.InvCellSizeArray();
67 Box box = pti.tilebox();
72 using ReduceTuple =
typename decltype(reduce_data)::Type;
74 reduce_op.
eval(np, reduce_data,
78 if (!
p.id().is_valid()) {
return false; }
79 using AssignorType =
typename Iterator::CellAssignor;
80 AssignorType assignor;
81 IntVect iv = assignor(
p, plo, dxi, domain);
101requires (IsParticleContainer<PC>::value)
121requires (IsParticleContainer<PC>::value)
143requires (IsParticleContainer<PC>::value)
168requires (IsParticleContainer<PC>::value)
174 using ParIter =
typename PC::ParConstIterType;
176 for (
int lev = lev_min; lev <= lev_max; ++lev)
179#pragma omp parallel if (Gpu::notInLaunchRegion() && !system::regtest_reduction) reduction(+:num_wrong)
181 for(
ParIter pti(pc, lev); pti.isValid(); ++pti)
195 if (a_do_tiling ==
false) {
202 auto tiling_1d = [](
int i,
int lo,
int hi,
int tilesize,
203 int& ntile,
int& tileidx,
int& tlo,
int& thi) {
204 int ncells = hi-lo+1;
206 int ts_right = ncells/ntile;
207 int ts_left = ts_right+1;
208 int nleft = ncells - ntile*ts_right;
210 int nbndry = nleft*ts_left;
212 tileidx = ii / ts_left;
213 tlo = lo + tileidx * ts_left;
214 thi = tlo + ts_left - 1;
216 tileidx = nleft + (ii-nbndry) / ts_right;
217 tlo = lo + tileidx * ts_right + nleft;
218 thi = tlo + ts_right - 1;
223 IntVect ntiles, ivIndex, tilelo, tilehi;
229 AMREX_D_TERM(tiling_1d(iv0, sml[0], big[0], a_tile_size[0], ntiles[0], ivIndex[0], tilelo[0], tilehi[0]);,
230 tiling_1d(iv1, sml[1], big[1], a_tile_size[1], ntiles[1], ivIndex[1], tilelo[1], tilehi[1]);,
231 tiling_1d(iv2, sml[2], big[2], a_tile_size[2], ntiles[2], ivIndex[2], tilelo[2], tilehi[2]););
233 tbx =
Box(tilelo, tilehi);
235 return AMREX_D_TERM(ivIndex[0], + ntiles[0]*ivIndex[1], + ntiles[0]*ntiles[1]*ivIndex[2]);
265 for (
int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
266 const int lo = box.smallEnd(idim);
267 const int ncells = box.bigEnd(idim) - lo + 1;
268 const int ntile =
amrex::max(ncells/tile_size[idim], 1);
269 const int itile = tile_index % ntile;
271 const int ts_right = ncells/ntile;
272 const int ts_left = ts_right+1;
273 const int nleft = ncells - ntile*ts_right;
276 tilelo[idim] = lo + itile*ts_left;
277 tilehi[idim] = tilelo[idim] + ts_left - 1;
280 tilelo[idim] = lo + itile*ts_right + nleft;
281 tilehi[idim] = tilelo[idim] + ts_right - 1;
284 return Box(tilelo, tilehi);
290 if (a_do_tiling ==
false) {
296 auto tiling_1d = [](
int lo,
int hi,
int tilesize,
int& ntile) {
297 int ncells = hi-lo+1;
305 AMREX_D_TERM(tiling_1d(sml[0], big[0], a_tile_size[0], ntiles[0]);,
306 tiling_1d(sml[1], big[1], a_tile_size[1], ntiles[1]);,
307 tiling_1d(sml[2], big[2], a_tile_size[2], ntiles[2]););
309 return AMREX_D_TERM(ntiles[0], *=ntiles[1], *=ntiles[2]);
320 int* bin_type_array=
nullptr)
321 : m_off_bins_p(off_bins_p), m_dxi_p(dxi_p), m_plo_p(plo_p) ,
322 m_lo_p(lo_p) , m_hi_p(hi_p) , m_bin_type_array(bin_type_array) {}
324 template <
typename T>
329 int type = (m_bin_type_array) ? m_bin_type_array[i] : 0;
330 int offset = m_off_bins_p[type];
333 AMREX_ASSERT((
p.pos(1)-m_plo_p[type][1])*m_dxi_p[type][1] - m_lo_p[type].y >= 0.0);,
334 AMREX_ASSERT((
p.pos(2)-m_plo_p[type][2])*m_dxi_p[type][2] - m_lo_p[type].z >= 0.0));
336 auto iv =
IntVect(
AMREX_D_DECL(
static_cast<int>(amrex::Math::floor((
p.pos(0)-m_plo_p[type][0])*m_dxi_p[type][0])) - m_lo_p[type].x,
337 static_cast<int>(amrex::Math::floor((
p.pos(1)-m_plo_p[type][1])*m_dxi_p[type][1])) - m_lo_p[type].y,
338 static_cast<int>(amrex::Math::floor((
p.pos(2)-m_plo_p[type][2])*m_dxi_p[type][2])) - m_lo_p[type].z));
339 auto iv3 = iv.dim3();
340 int nx = m_hi_p[type].x-m_lo_p[type].x+1;
341 int ny = m_hi_p[type].y-m_lo_p[type].y+1;
342 int nz = m_hi_p[type].z-m_lo_p[type].z+1;
346 return static_cast<unsigned int>( (uiz * ny + uiy) * nx + uix + offset );
350 const int* m_off_bins_p;
355 int* m_bin_type_array;
366 template <
typename ParticleType>
373 return static_cast<unsigned int>(tid);
397 AMREX_D_DECL(
int(amrex::Math::floor((
p.pos(0)-plo[0])*dxi[0])),
398 int(amrex::Math::floor((
p.pos(1)-plo[1])*dxi[1])),
399 int(amrex::Math::floor((
p.pos(2)-plo[2])*dxi[2]))));
422 const Box& domain)
noexcept
425 iv += domain.smallEnd();
429template <
typename PTD>
434 const Box& domain)
noexcept
437 AMREX_D_DECL(
int(amrex::Math::floor((ptd.pos(0, i)-plo[0])*dxi[0])),
438 int(amrex::Math::floor((ptd.pos(1, i)-plo[1])*dxi[1])),
439 int(amrex::Math::floor((ptd.pos(2, i)-plo[2])*dxi[2]))));
440 iv += domain.smallEnd();
447 template <
typename P>
452 const Box& domain)
const noexcept
463 const Box& domain)
noexcept
465 if (!
p.id().is_valid()) {
return -1; }
479 bool shifted =
false;
480 for (
int idim = 0; idim < AMREX_SPACEDIM; ++idim)
482 if (! is_per[idim]) {
continue; }
483 if (
p.pos(idim) > rhi[idim]) {
484 while (
p.pos(idim) > rhi[idim]) {
485 p.pos(idim) =
static_cast<ParticleReal>(
p.pos(idim) - (phi[idim] - plo[idim]));
488 if (
p.pos(idim) < rlo[idim]) {
489 p.pos(idim) = rlo[idim];
493 else if (
p.pos(idim) < rlo[idim]) {
494 while (
p.pos(idim) < rlo[idim]) {
495 p.pos(idim) =
static_cast<ParticleReal>(
p.pos(idim) + (phi[idim] - plo[idim]));
498 if (
p.pos(idim) > rhi[idim]) {
499 p.pos(idim) = rhi[idim];
503 AMREX_ASSERT( (
p.pos(idim) >= rlo[idim] ) && (
p.pos(idim) <= rhi[idim] ));
521template <
typename PTile,
typename ParFunc>
525 const int np = ptile.numParticles();
526 if (np == 0) {
return 0; }
528 auto ptd = ptile.getParticleTileData();
533 return int(is_left(ptd, i));
547 const int max_num_swaps = std::min(num_left, np - num_left);
548 if (max_num_swaps == 0) {
return num_left; }
552 int *
const p_index_left = index_left.
dataPtr();
553 int *
const p_index_right = index_right.
dataPtr();
572 return int(!is_left(ptd, i));
576 if (!is_left(ptd, i)) {
578 if (dst < max_num_swaps) {
579 p_index_right[dst] = i;
582 int dst = num_left-1-(i-s);
583 if (dst < max_num_swaps) {
584 p_index_left[dst] = i;
611 int left_i = p_index_left[i];
612 int right_i = p_index_right[i];
613 if (right_i < left_i) {
638template <
typename PTile,
typename ParFunc>
642 const int np = ptile.numParticles();
643 if (np == 0) {
return; }
645 auto ptd = ptile.getParticleTileData();
647 const int max_num_swaps = std::min(num_left, np - num_left);
648 if (max_num_swaps == 0) {
return; }
652 int *
const p_index_left = index_left.
dataPtr();
653 int *
const p_index_right = index_right.
dataPtr();
658 return int(!is_left(ptd, i));
662 if (!is_left(ptd, i)) {
664 if (dst < max_num_swaps) {
665 p_index_right[dst] = i;
668 int dst = num_left-1-(i-s);
669 if (dst < max_num_swaps) {
670 p_index_left[dst] = i;
679 int left_i = p_index_left[i];
680 int right_i = p_index_right[i];
681 if (right_i < left_i) {
690template <
typename PTile>
696 return ptd.id(i).is_valid();
698 ptile.resize(new_size);
701template <
typename PTile,
typename PLocator,
typename CellAssignor>
710 int lev,
int gid,
int tid,
711 int lev_min,
int lev_max,
IntVect nGrow,
bool remove_negative)
717 uint8_t *
const p_particle_stays = particle_stays.
dataPtr();
718 auto ptd = ptile.getParticleTileData();
729 if (!ptd.id(i).is_valid())
737 auto p_prime = ptd.getSuperParticle(i);
739 auto tup_prime = ploc(p_prime, lev_min, lev_max, nGrow, assignor);
743 if (assigned_grid >= 0)
746 ptd.pos(1, i) = p_prime.pos(1);,
747 ptd.pos(2, i) = p_prime.pos(2););
749 else if (lev_min > 0)
752 p_prime.pos(1) = ptd.pos(1, i);,
753 p_prime.pos(2) = ptd.pos(2, i););
754 auto tup = ploc(p_prime, lev_min, lev_max, nGrow, assignor);
761 p_particle_stays[i] = uint8_t(
762 ((remove_negative ==
false) && (!ptd.id(i).is_valid())) ||
763 ((assigned_grid == gid) && (assigned_tile == tid) &&
764 (assigned_lev == lev) && (getPID(lev, gid, tid) == pid)));
769 return p_particle_stays[i];
773template <
class PC1,
class PC2>
775 if (pc1.numLevels() != pc2.numLevels()) {
return false;}
776 if (pc1.do_tiling != pc2.do_tiling) {
return false;}
777 if (pc1.tile_size != pc2.tile_size) {
return false;}
778 for (
int lev = 0; lev < pc1.numLevels(); ++lev) {
779 if (pc1.ParticleBoxArray(lev) != pc2.ParticleBoxArray(lev)) {
return false;}
780 if (pc1.ParticleDistributionMap(lev) != pc2.ParticleDistributionMap(lev)) {
return false;}
787 using Iter =
typename PC::ParIterType;
788 for (
int lev = 0; lev < pc.numLevels(); ++lev) {
789 for (Iter pti(pc, lev); pti.isValid(); ++pti) {
790 pc.DefineAndReturnParticleTile(lev, pti);
802namespace particle_detail
805void clearEmptyEntries (C& c)
807 for (
auto c_it = c.begin(); c_it != c.end(); )
809 if (c_it->second.empty()) { c.erase(c_it++); }
820template <
typename PTile>
821bool soaIsSized (PTile
const& ptile,
int nreal,
int nint)
823 if constexpr (PTile::ParticleType::is_rtsoa_particle) {
828 auto const& soa = ptile.GetStructOfArrays();
829 if (soa.NumRealComps() != nreal || soa.NumIntComps() != nint) {
return false; }
830 auto const np =
static_cast<std::size_t
>(ptile.numParticles());
831 for (
int i = 0; i < nreal; ++i) {
if (soa.GetRealData(i).size() != np) {
return false; } }
832 for (
int i = 0; i < nint; ++i) {
if (soa.GetIntData(i).size() != np) {
return false; } }
845template <
typename PTile>
846void resizeAndZeroNewSoA (PTile& ptile, Long np,
bool zero_compile_time =
false)
848 auto const n =
static_cast<std::size_t
>(np);
849 if constexpr (PTile::ParticleType::is_rtsoa_particle) {
852 auto const old_n =
static_cast<std::size_t
>(ptile.numParticles());
854 if (n <= old_n) {
return; }
855 auto const ptd = ptile.getParticleTileData();
856 int const nreal = ptile.NumRealComps();
857 int const nint = ptile.NumIntComps();
859 for (
int j = 0; j < nreal; ++j) { ptd.rdata(j, i) = 0; }
860 for (
int j = 0; j < nint; ++j) { ptd.idata(j, i) = 0; }
862 if (ptile.arena()->isDeviceAccessible()) {
864 Gpu::streamSynchronize();
866 for (std::size_t i = old_n; i < n; ++i) {
zero(i); }
869 auto& soa = ptile.GetStructOfArrays();
870 int const first_real = zero_compile_time ? 0 : PTile::NAR;
871 int const first_int = zero_compile_time ? 0 : PTile::NAI;
874 for (
int i = first_real; i < soa.NumRealComps(); ++i) { soa.GetRealData(i).resize(n,
ParticleReal(0)); }
875 for (
int i = first_int; i < soa.NumIntComps(); ++i) { soa.GetIntData(i).resize(n, 0); }
889template <
typename CellAssignor>
890struct SingleBoxLocator
892 GpuArray<Real, AMREX_SPACEDIM> plo;
893 GpuArray<Real, AMREX_SPACEDIM> phi;
894 GpuArray<Real, AMREX_SPACEDIM> dxi;
895 GpuArray<ParticleReal, AMREX_SPACEDIM> rlo;
896 GpuArray<ParticleReal, AMREX_SPACEDIM> rhi;
897 GpuArray<int, AMREX_SPACEDIM> is_per;
901 SingleBoxLocator (Geometry
const& geom, Box
const& box, IntVect
const& nGrow)
902 : plo(geom.ProbLoArray()), phi(geom.ProbHiArray()), dxi(geom.InvCellSizeArray()),
903 rlo(geom.ProbLoArrayInParticleReal()), rhi(geom.ProbHiArrayInParticleReal()),
904 is_per(geom.isPeriodicArray()), domain(geom.Domain()), grown_box(amrex::
grow(box, nGrow))
908 template <
typename PTD>
910 static auto particle (PTD
const& ptd,
int i)
noexcept
912 if constexpr (std::is_same_v<CellAssignor, DefaultAssignor>) {
914 for (
int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
p.pos(idim) = ptd.pos(idim, i); }
917 return ptd.getSuperParticle(i);
922 template <
typename P>
924 bool stays (P&
p,
bool& shifted)
const noexcept
927 return grown_box.contains(CellAssignor{}(
p, plo, dxi, domain));
931 template <
typename P>
933 bool staysUnshifted (P
const&
p)
const noexcept
935 return grown_box.contains(CellAssignor{}(
p, plo, dxi, domain));
950template <
typename CellAssignor,
typename PTile>
951GpuTuple<int, int, int>
952singleBoxRedistributeLocate (PTile& ptile, SingleBoxLocator<CellAssignor>
const& loc,
953 bool remove_negative, uint8_t* stays)
955 auto ptd = ptile.getParticleTileData();
957 ReduceOps<ReduceOpSum, ReduceOpSum, ReduceOpSum> reduce_op;
958 ReduceData<int, int, int> reduce_data(reduce_op);
959 using ReduceTuple =
typename decltype(reduce_data)::Type;
961 reduce_op.eval(ptile.numParticles(), reduce_data,
964 if (!ptd.id(i).is_valid()) {
965 stays[i] = uint8_t(!remove_negative);
969 auto p = loc.particle(ptd, i);
970 bool shifted =
false;
971 if (loc.stays(
p, shifted)) {
974 for (
int idim = 0; idim < AMREX_SPACEDIM; ++idim) { ptd.pos(idim, i) =
p.pos(idim); }
980 const bool kept_unshifted = shifted && loc.staysUnshifted(loc.particle(ptd, i));
981 return {kept_unshifted ? 0 : 1, 0, kept_unshifted ? 1 : 0};
984 return reduce_data.value(reduce_op);
988template <
typename PTile>
989int partitionParticlesByFlag (PTile& ptile, uint8_t
const* flags)
997template <
class index_type,
typename F>
999 index_type nbins,
F const& f)
1003#if defined(AMREX_USE_HIP)
1006 static constexpr index_type gpu_block_size = 64;
1007 static constexpr bool compressed_layout =
true;
1011 static constexpr index_type gpu_block_size = 1024;
1012 static constexpr bool compressed_layout =
false;
1015 static constexpr index_type gpu_block_size_m1 = gpu_block_size - 1;
1016 static constexpr index_type llist_guard = std::numeric_limits<index_type>::max();
1019 nbins = (nbins + gpu_block_size_m1) / gpu_block_size * gpu_block_size;
1027 index_type* pllist_start = llist_start.
dataPtr();
1028 index_type* pllist_next = llist_next.
dataPtr();
1029 index_type* pperm = perm.
dataPtr();
1030 index_type* pglobal_idx = global_idx.
dataPtr();
1038#if defined(AMREX_USE_CUDA) || defined(AMREX_USE_HIP)
1041 __shared__ index_type sdata[gpu_block_size];
1042 __shared__ index_type global_idx_start;
1043 __shared__ index_type idx_start;
1045 index_type current_idx = 0;
1047 if constexpr (compressed_layout) {
1051 current_idx = pllist_start[threadIdx.x + gpu_block_size * blockIdx.x];
1053 index_type num_particles_thread = 0;
1054 while (current_idx != llist_guard) {
1055 ++num_particles_thread;
1056 current_idx = pllist_next[current_idx];
1059 index_type num_particles_block =
1062 if (threadIdx.x == 0) {
1067 current_idx = pllist_start[threadIdx.x + gpu_block_size * blockIdx.x];
1070 sdata[threadIdx.x] = index_type(current_idx != llist_guard);
1074 for (index_type i = 1; i<gpu_block_size; i*=2) {
1076 if (threadIdx.x >= i) {
1077 x = sdata[threadIdx.x - i];
1080 if (threadIdx.x >= i) {
1081 sdata[threadIdx.x] +=
x;
1085 if (sdata[gpu_block_size_m1] == 0) {
1088 if (threadIdx.x == gpu_block_size_m1) {
1089 if constexpr (compressed_layout) {
1090 idx_start = global_idx_start;
1091 global_idx_start += sdata[gpu_block_size_m1];
1097 sdata[threadIdx.x] += idx_start;
1098 if (current_idx != llist_guard) {
1099 pperm[sdata[threadIdx.x] - 1] = current_idx;
1100 current_idx = pllist_next[current_idx];
1106 Abort(
"PermutationForDeposition only implemented for CUDA and HIP");
1112template <
class index_type,
class PTile>
1119 const IntVect type_vect = idx_type - idx_type / 2 * 2;
1121 geom.
refine(refine_vect);
1132 const int ref_product =
AMREX_D_TERM(refine_vect[0], * refine_vect[1], * refine_vect[2]);
1133 const IntVect ref_offset(
AMREX_D_DECL(1, refine_vect[0], refine_vect[0] * refine_vect[1]));
1135 auto ptd = ptile.getConstParticleTileData();
1139 const auto p = ptd[idx];
1141 IntVect iv = ((
p.pos() - pos_offset) * dxi).round();
1143 IntVect iv_coarse = iv / refine_vect;
1144 IntVect iv_remainder = iv - iv_coarse * refine_vect;
1148 return bx.
index(iv_coarse) + bx.
numPts() * (iv_remainder * ref_offset).sum();
1152template <
typename P>
1154 int first_r_name = 0;
1155 if constexpr (P::is_soa_particle) {
1156 if (i < AMREX_SPACEDIM) {
1157 constexpr int x_in_ascii = 120;
1158 std::string
const name{char(x_in_ascii+i)};
1161 first_r_name = AMREX_SPACEDIM;
1163 std::string
const name{(
"real_comp" + std::to_string(i-first_r_name))};
1167template <
typename P>
1169 std::string
const name{(
"int_comp" + std::to_string(i))};
1183template <
class PTile,
class index_type>
1184requires (!PTile::ParticleType::is_rtsoa_particle)
1188 const size_t np = ptile.numParticles();
1189 const size_t np_total = np + ptile.numNeighborParticles();
1191#if defined(AMREX_USE_CUDA) && defined(_WIN32)
1192 if (!PTile::ParticleType::is_soa_particle)
1194 if constexpr (!PTile::ParticleType::is_soa_particle)
1197 static_assert(
sizeof(
typename PTile::ParticleType)%4 == 0 &&
sizeof(uint32_t) == 4);
1198 using tmp_t = std::conditional_t<
sizeof(
typename PTile::ParticleType)%8 == 0,
1199 uint64_t, uint32_t>;
1200 constexpr std::size_t nchunks =
sizeof(
typename PTile::ParticleType) /
sizeof(tmp_t);
1202 auto* ptmp = tmp.
data();
1203 auto* paos = (tmp_t*)(ptile.getParticleTileData().m_aos);
1204 for (std::size_t ichunk = 0; ichunk < nchunks; ++ichunk) {
1208 ptmp[i] = paos[permutations[i]*nchunks+ichunk];
1212 paos[i*nchunks+ichunk] = ptmp[i];
1217 typename PTile::SoA::IdCPU tmp_idcpu;
1218 if constexpr (PTile::has_polymorphic_allocator) {
1219 tmp_idcpu.setArena(ptile.GetStructOfArrays().GetIdCPUData().arena());
1221 tmp_idcpu.resize(np_total);
1222 auto src = ptile.GetStructOfArrays().GetIdCPUData().data();
1223 uint64_t* dst = tmp_idcpu.data();
1226 dst[i] = i < np ? src[permutations[i]] : src[i];
1231 ptile.GetStructOfArrays().GetIdCPUData().swap(tmp_idcpu);
1235 typename PTile::RealVector tmp_real;
1236 if (ptile.NumRealComps() > 0) {
1237 if constexpr (PTile::has_polymorphic_allocator) {
1238 tmp_real.setArena(ptile.GetStructOfArrays().GetRealData(0).arena());
1240 tmp_real.resize(np_total);
1242 for (
int comp = 0; comp < ptile.NumRealComps(); ++comp) {
1243 auto src = ptile.GetStructOfArrays().GetRealData(comp).data();
1247 dst[i] = i < np ? src[permutations[i]] : src[i];
1252 ptile.GetStructOfArrays().GetRealData(comp).swap(tmp_real);
1256 typename PTile::IntVector tmp_int;
1257 if (ptile.NumIntComps() > 0) {
1258 if constexpr (PTile::has_polymorphic_allocator) {
1259 tmp_int.setArena(ptile.GetStructOfArrays().GetIntData(0).arena());
1261 tmp_int.resize(np_total);
1264 for (
int comp = 0; comp < ptile.NumIntComps(); ++comp) {
1265 auto src = ptile.GetStructOfArrays().GetIntData(comp).data();
1266 int* dst = tmp_int.data();
1269 dst[i] = i < np ? src[permutations[i]] : src[i];
1274 ptile.GetStructOfArrays().GetIntData(comp).swap(tmp_int);
1287template <
class PTile,
class index_type>
1288requires (PTile::ParticleType::is_rtsoa_particle)
1292 const size_t np = ptile.numParticles();
1296 auto src = ptile.GetIdCPUData().data();
1297 uint64_t* dst = tmp_idcpu.
data();
1300 dst[i] = src[permutations[i]];
1310 for (
int comp = 0; comp < ptile.NumRealComps(); ++comp) {
1311 auto src = ptile.GetRealData(comp).data();
1312 auto dst = tmp_real.
data();
1315 dst[i] = src[permutations[i]];
1326 for (
int comp = 0; comp < ptile.NumIntComps(); ++comp) {
1327 auto src = ptile.GetIntData(comp).data();
1328 auto dst = tmp_int.
data();
1331 dst[i] = src[permutations[i]];
1343#ifdef AMREX_USE_HDF5_ASYNC
1344void async_vol_es_wait_particle();
1345void async_vol_es_wait_close_particle();
#define BL_PROFILE(a)
Definition AMReX_BLProfiler.H:593
#define AMREX_ASSERT(EX)
Definition AMReX_BLassert.H:38
#define AMREX_ALWAYS_ASSERT(EX)
Definition AMReX_BLassert.H:50
Integer-lattice boxes and helpers for defining index-space regions.
#define AMREX_FORCE_INLINE
Definition AMReX_Extension.H:123
#define AMREX_HOST_DEVICE_FOR_1D(...)
Definition AMReX_GpuLaunchMacrosC.nolint.H:105
#define AMREX_GPU_DEVICE
Definition AMReX_GpuQualifiers.H:18
#define AMREX_GPU_HOST_DEVICE
Definition AMReX_GpuQualifiers.H:20
Convenience header for the core AMReX GPU facilities.
while parser_exe_t p
Definition AMReX_Parser_Exe_Body.H:33
#define AMREX_D_TERM(a, b, c)
Definition AMReX_SPACE.H:172
#define AMREX_D_DECL(a, b, c)
Definition AMReX_SPACE.H:171
__host__ __device__ BoxND & grow(int i) noexcept
Grow in all directions by i cells (negative shrinks).
Definition AMReX_Box.H:668
__host__ __device__ const IntVectND< dim > & bigEnd() const &noexcept
Return the inclusive upper bound of the box.
Definition AMReX_Box.H:136
__host__ __device__ Long numPts() const noexcept
Return the number of points contained in the BoxND.
Definition AMReX_Box.H:385
__host__ __device__ BoxND & convert(IndexTypeND< dim > typ) noexcept
Convert the BoxND from the current type into the argument type. This may change the BoxND coordinates...
Definition AMReX_Box.H:1008
__host__ __device__ bool contains(const IntVectND< dim > &p) const noexcept
Return true if argument is contained within BoxND.
Definition AMReX_Box.H:233
__host__ __device__ Long index(const IntVectND< dim > &v) const noexcept
Return offset of point from smallend; i.e. index(smallend) -> 0, bigend would return numPts()-1....
Definition AMReX_Box.H:1089
__host__ __device__ const IntVectND< dim > & smallEnd() const &noexcept
Return the inclusive lower bound of the box.
Definition AMReX_Box.H:124
const Real * CellSize() const noexcept
Returns the cellsize for each coordinate direction.
Definition AMReX_CoordSys.H:79
const Real * InvCellSize() const noexcept
Returns the inverse cellsize for each coordinate direction.
Definition AMReX_CoordSys.H:91
Rectangular problem domain geometry.
Definition AMReX_Geometry.H:87
void refine(IntVect const &rr)
Refine the Geometry by rr.
Definition AMReX_Geometry.H:502
const Real * ProbHi() const noexcept
Returns the hi end of the problem domain in each dimension.
Definition AMReX_Geometry.H:212
const Box & Domain() const noexcept
Returns our rectangular domain.
Definition AMReX_Geometry.H:246
const Real * ProbLo() const noexcept
Returns the lo end of the problem domain in each dimension.
Definition AMReX_Geometry.H:210
static void streamSynchronize() noexcept
Definition AMReX_GpuDevice.cpp:992
__host__ __device__ constexpr int min() const noexcept
minimum (no absolute values) value
Definition AMReX_IntVect.H:331
__host__ __device__ constexpr bool allGE(const IntVectND< dim > &rhs) const noexcept
Returns true if this is greater than or equal to argument for all components. NOTE: This is NOT a str...
Definition AMReX_IntVect.H:549
__host__ __device__ constexpr int max() const noexcept
maximum (no absolute values) value
Definition AMReX_IntVect.H:320
__host__ __device__ constexpr bool allLE(const IntVectND< dim > &rhs) const noexcept
Returns true if this is less than or equal to argument for all components. NOTE: This is NOT a strict...
Definition AMReX_IntVect.H:499
void resize(size_type a_new_size, GrowthStrategy strategy=GrowthStrategy::Poisson)
Definition AMReX_PODVector.H:734
void free_async() noexcept
Definition AMReX_PODVector.H:861
T * dataPtr() noexcept
Definition AMReX_PODVector.H:676
T * data() noexcept
Definition AMReX_PODVector.H:672
Definition AMReX_ParticleBufferMap.H:59
GetPID getPIDFunctor() const noexcept
Definition AMReX_ParticleBufferMap.H:195
Definition AMReX_Reduce.H:556
Type value()
Definition AMReX_Reduce.H:591
Definition AMReX_Reduce.H:715
void eval(MF const &mf, IntVect const &nghost, D &reduce_data, F &&f)
Definition AMReX_Reduce.H:855
amrex_real Real
Floating Point Type for Fields.
Definition AMReX_REAL.H:80
amrex_particle_real ParticleReal
Floating Point Type for Particles.
Definition AMReX_REAL.H:91
amrex_long Long
Definition AMReX_INT.H:30
T Sum(N n, T const *v, T init_val=0)
Compute the sum of an array of values.
Definition AMReX_Reduce.H:1082
void ParallelForOMP(T n, L const &f) noexcept
Performance-portable kernel launch function with optional OpenMP threading.
Definition AMReX_GpuLaunch.H:328
ArrayND< T, 4, true > Array4
Convenient alias for a 4D ArrayND with three spatial dimensions plus a component dimension.
Definition AMReX_Array4.H:1352
__host__ __device__ BoxND< dim > grow(const BoxND< dim > &b, int i) noexcept
Return a copy of b grown uniformly by i cells in every direction.
Definition AMReX_Box.H:1328
PODVector< T, AsyncArenaAllocator< T > > AsyncVector
A PODVector that uses the async memory arena. Maybe useful for temporary vectors inside MFIters that ...
Definition AMReX_GpuContainers.H:58
PODVector< T, ArenaAllocator< T > > DeviceVector
A PODVector that uses the standard memory Arena. Note that the memory might or might not be managed d...
Definition AMReX_GpuContainers.H:24
void Sum(Gpu::DeviceVector< T > &v, MPI_Comm comm)
Definition AMReX_GpuParallelReduce.H:37
__host__ __device__ constexpr const T & min(const T &a, const T &b) noexcept
Definition AMReX_Algorithm.H:31
__host__ __device__ constexpr const T & max(const T &a, const T &b) noexcept
Definition AMReX_Algorithm.H:54
__host__ __device__ AMREX_FORCE_INLINE T Exch(T *address, T val) noexcept
Definition AMReX_GpuAtomic.H:542
__host__ __device__ AMREX_FORCE_INLINE T Add(T *sum, T value) noexcept
Definition AMReX_GpuAtomic.H:239
void streamSynchronize() noexcept
Definition AMReX_GpuDevice.H:329
gpuStream_t gpuStream() noexcept
Definition AMReX_GpuDevice.H:310
__device__ T blockReduceSum(T source) noexcept
Definition AMReX_GpuReduce.H:353
MPI_Comm CommunicatorSub() noexcept
sub-communicator for current frame
Definition AMReX_ParallelContext.H:70
int MyProcSub() noexcept
my sub-rank in current frame
Definition AMReX_ParallelContext.H:76
static constexpr struct amrex::Scan::Type::Exclusive exclusive
static constexpr RetSum noRetSum
Definition AMReX_Scan.H:35
T PrefixSum(N n, FIN const &fin, FOUT const &fout, TYPE, RetSum a_ret_sum=retSum)
Definition AMReX_Scan.H:815
Definition AMReX_Amr.cpp:50
__host__ __device__ void ignore_unused(const Ts &...)
No-op helper that marks variables as intentionally unused.
Definition AMReX.H:273
__host__ __device__ void swapParticle(const ParticleTileData< T_ParticleType, NAR, NAI > &dst, const ParticleTileData< T_ParticleType, NAR, NAI > &src, int src_i, int dst_i) noexcept
A general single particle swapping routine that can run on the GPU.
Definition AMReX_ParticleTransformation.H:120
__host__ __device__ int getTileIndex(const IntVect &iv, const Box &box, const bool a_do_tiling, const IntVect &a_tile_size, Box &tbx)
Definition AMReX_ParticleUtil.H:192
@ F
Definition AMReX_Order.H:7
@ zero
Definition AMReX.H:560
void EnsureThreadSafeTiles(PC &pc)
Definition AMReX_ParticleUtil.H:786
std::string getDefaultCompNameInt(const int i)
Definition AMReX_ParticleUtil.H:1168
int partitionParticlesByDest(PTile &ptile, const PLocator &ploc, CellAssignor const &assignor, const ParticleBufferMap &pmap, const GpuArray< Real, 3 > &plo, const GpuArray< Real, 3 > &phi, const GpuArray< ParticleReal, 3 > &rlo, const GpuArray< ParticleReal, 3 > &rhi, const GpuArray< int, 3 > &is_per, int lev, int gid, int tid, int lev_min, int lev_max, IntVect nGrow, bool remove_negative)
Definition AMReX_ParticleUtil.H:703
void launch(T const &n, L const &f) noexcept
Definition AMReX_GpuLaunchFunctsC.H:122
void ReorderParticles(PTile &ptile, const index_type *permutations)
Reorder particles on the tile ptile using a the permutations array.
Definition AMReX_ParticleUtil.H:1186
__host__ __device__ bool enforcePeriodic(P &p, amrex::GpuArray< amrex::Real, 3 > const &plo, amrex::GpuArray< amrex::Real, 3 > const &phi, amrex::GpuArray< amrex::ParticleReal, 3 > const &rlo, amrex::GpuArray< amrex::ParticleReal, 3 > const &rhi, amrex::GpuArray< int, 3 > const &is_per) noexcept
Definition AMReX_ParticleUtil.H:472
void ParallelFor(TypeList< CTOs... > ctos, std::array< int, sizeof...(CTOs)> const &runtime_options, T N, F &&f)
Definition AMReX_CTOParallelForImpl.H:202
void removeInvalidParticles(PTile &ptile)
Definition AMReX_ParticleUtil.H:692
__host__ __device__ int numTilesInBox(const Box &box, const bool a_do_tiling, const IntVect &a_tile_size)
Definition AMReX_ParticleUtil.H:288
BoxND< 3 > Box
Box is an alias for amrex::BoxND instantiated with AMREX_SPACEDIM.
Definition AMReX_BaseFwd.H:35
std::string getDefaultCompNameReal(const int i)
Definition AMReX_ParticleUtil.H:1153
@ x
Definition AMReX_Orientation.H:14
Vector< int > computeNeighborProcs(const ParGDBBase *a_gdb, IntVect ngrow)
Definition AMReX_ParticleUtil.cpp:22
__host__ __device__ Box getTileBoxFromIndex(int tile_index, const Box &box, const IntVect &tile_size) noexcept
Return the tile box with the given index.
Definition AMReX_ParticleUtil.H:259
__host__ __device__ int getParticleGrid(P const &p, amrex::Array4< int > const &mask, amrex::GpuArray< amrex::Real, 3 > const &plo, amrex::GpuArray< amrex::Real, 3 > const &dxi, const Box &domain) noexcept
Definition AMReX_ParticleUtil.H:460
ParIter_impl< Particle< T_NStructReal, T_NStructInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > ParIter
Definition AMReX_ParIter.H:239
IntVectND< 3 > IntVect
IntVect is an alias for amrex::IntVectND instantiated with AMREX_SPACEDIM.
Definition AMReX_BaseFwd.H:38
int numParticlesOutOfRange(Iterator const &pti, int nGrow)
Returns the number of particles that are more than nGrow cells from the box correspond to the input i...
Definition AMReX_ParticleUtil.H:37
void PermutationForDeposition(Gpu::DeviceVector< index_type > &perm, index_type nitems, index_type nbins, F const &f)
Definition AMReX_ParticleUtil.H:998
bool SameIteratorsOK(const PC1 &pc1, const PC2 &pc2)
Definition AMReX_ParticleUtil.H:774
int partitionParticles(PTile &ptile, ParFunc const &is_left)
Reorders the ParticleTile into two partitions left [0, num_left-1] and right [num_left,...
Definition AMReX_ParticleUtil.H:523
void Abort(const std::string &msg)
Print a fatal-error message to stderr and abort execution.
Definition AMReX.cpp:239
const int[]
Definition AMReX_BLProfiler.cpp:1665
IntVect computeRefFac(const ParGDBBase *a_gdb, int src_lev, int lev)
Definition AMReX_ParticleUtil.cpp:6
RealVectND< 3 > RealVect
Definition AMReX_ParmParse.H:40
__host__ __device__ IntVect getParticleCell(P const &p, amrex::GpuArray< amrex::Real, 3 > const &plo, amrex::GpuArray< amrex::Real, 3 > const &dxi) noexcept
Returns the cell index for a given particle using the provided lower bounds and cell sizes.
Definition AMReX_ParticleUtil.H:392
__host__ __device__ constexpr int get(IntVectND< dim > const &iv) noexcept
Get the Idx-th element of IntVectND<dim>.
Definition AMReX_IntVect.H:1367
BinMapper(const int *off_bins_p, const GpuArray< Real, 3 > *dxi_p, const GpuArray< Real, 3 > *plo_p, const Dim3 *lo_p, const Dim3 *hi_p, int *bin_type_array=nullptr)
Definition AMReX_ParticleUtil.H:315
__host__ __device__ unsigned int operator()(const T &ptd, int i) const
Definition AMReX_ParticleUtil.H:326
Definition AMReX_ParticleUtil.H:445
__host__ __device__ IntVect operator()(P const &p, amrex::GpuArray< amrex::Real, 3 > const &plo, amrex::GpuArray< amrex::Real, 3 > const &dxi, const Box &domain) const noexcept
Definition AMReX_ParticleUtil.H:449
A simple struct holding 3 int values for a 3D index.
Definition AMReX_Dim3.H:24
Definition AMReX_ParticleUtil.H:359
GpuArray< Real, 3 > plo
Definition AMReX_ParticleUtil.H:360
IntVect bin_size
Definition AMReX_ParticleUtil.H:363
__host__ __device__ unsigned int operator()(const ParticleType &p) const noexcept
Definition AMReX_ParticleUtil.H:368
GpuArray< Real, 3 > dxi
Definition AMReX_ParticleUtil.H:361
Box domain
Definition AMReX_ParticleUtil.H:362
Box box
Definition AMReX_ParticleUtil.H:364
Fixed-size array that can be used on GPU.
Definition AMReX_Array.H:52
Definition AMReX_GpuMemory.H:57
T * dataPtr()
Definition AMReX_GpuMemory.H:91
Definition AMReX_TypeTraits.H:87