13template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
14 template<
class>
class Allocator,
class CellAssignor>
18 num_real_comm_comps = 0;
19 int comm_comps_start = 0;
20 if constexpr (!ParticleType::is_soa_particle) {
21 comm_comps_start += AMREX_SPACEDIM + NStructReal;
23 for (
int i = comm_comps_start; i < comm_comps_start + NumRealComps(); ++i) {
24 if (h_redistribute_real_comp[i]) {++num_real_comm_comps;}
27 num_int_comm_comps = 0;
28 comm_comps_start = 2 + NStructInt;
29 for (
int i = comm_comps_start; i < comm_comps_start + NumIntComps(); ++i) {
30 if (h_redistribute_int_comp[i]) {++num_int_comm_comps;}
33 if constexpr (ParticleType::is_soa_particle) {
34 particle_size =
sizeof(uint64_t);
38 superparticle_size = particle_size +
39 num_real_comm_comps*
sizeof(ParticleReal) + num_int_comm_comps*
sizeof(
int);
42template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
43 template<
class>
class Allocator,
class CellAssignor>
47 levelDirectoriesCreated =
false;
52 if constexpr (ParticleType::is_soa_particle)
54 h_redistribute_real_comp.resize(NArrayReal,
true);
56 h_redistribute_real_comp.resize(AMREX_SPACEDIM + NStructReal + NArrayReal,
true);
58 h_redistribute_int_comp.resize(2 + NStructInt + NArrayInt,
true);
63 m_soa_rdata_names.clear();
64 for (
int i=0; i<NArrayReal; ++i)
66 m_soa_rdata_names.push_back(getDefaultCompNameReal<ParticleType>(i));
68 m_soa_idata_names.clear();
69 for (
int i=0; i<NArrayInt; ++i)
71 m_soa_idata_names.push_back(getDefaultCompNameInt<ParticleType>(i));
78 "sizeof ParticleType is not a multiple of sizeof RealType");
83 if (
pp.
queryarr(
"tile_size", tilesize, 0, AMREX_SPACEDIM)) {
84 for (
int i=0; i<AMREX_SPACEDIM; ++i) { tile_size[i] = tilesize[i]; }
87 static_assert(std::is_standard_layout<ParticleType>::value,
88 "Particle type must be standard layout");
92 pp.
query(
"use_prepost", usePrePost);
93 pp.
query(
"do_unlink", doUnlink);
94 pp.
queryAdd(
"do_mem_efficient_sort", memEfficientSort);
95 pp.
queryAdd(
"use_comms_arena", use_comms_arena);
102 typename ParticleType,
105 template<
class>
class Allocator,
110 std::vector<std::string>
const & rdata_name, std::vector<std::string>
const & idata_name
117 std::set<std::string>
const unique_r_names(rdata_name.begin(), rdata_name.end());
118 std::set<std::string>
const unique_i_names(idata_name.begin(), idata_name.end());
122 for (
int i=0; i<NArrayReal; ++i)
124 m_soa_rdata_names.at(i) = rdata_name.at(i);
126 for (
int i=0; i<NArrayInt; ++i)
128 m_soa_idata_names.at(i) = idata_name.at(i);
133 typename ParticleType,
136 template<
class>
class Allocator,
142 return std::find(m_soa_rdata_names.begin(), m_soa_rdata_names.end(), name) != std::end(m_soa_rdata_names);
145template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
146 template<
class>
class Allocator,
class CellAssignor>
150 return std::find(m_soa_idata_names.begin(), m_soa_idata_names.end(), name) != std::end(m_soa_idata_names);
154 typename ParticleType,
157 template<
class>
class Allocator,
163 const auto it = std::find(m_soa_rdata_names.begin(), m_soa_rdata_names.end(), name);
165 if (it == m_soa_rdata_names.end())
167 throw std::runtime_error(
"GetRealCompIndex: Component " + name +
" does not exist!");
171 return std::distance(m_soa_rdata_names.begin(), it);
176 typename ParticleType,
179 template<
class>
class Allocator,
185 const auto it = std::find(m_soa_idata_names.begin(), m_soa_idata_names.end(), name);
187 if (it == m_soa_idata_names.end())
189 throw std::runtime_error(
"GetIntCompIndex: Component " + name +
" does not exist!");
193 return std::distance(m_soa_idata_names.begin(), it);
197template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
198 template<
class>
class Allocator,
class CellAssignor>
199template <
typename P,
typename Assignor>
204 const auto& domain = geom.
Domain();
208 return Assignor{}(p, plo, dxi, domain);
211template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
212 template<
class>
class Allocator,
class CellAssignor>
221 int local_grid)
const
227 lev_max = finestLevel();
232 AMREX_ASSERT(nGrow == 0 || (nGrow >= 0 && lev_min == lev_max));
234 std::vector< std::pair<int, Box> > isects;
236 for (
int lev = lev_max; lev >= lev_min; lev--) {
237 const IntVect& iv = Index(p, lev);
238 if (lev == pld.
m_lev) {
252 const BoxArray& ba = ParticleBoxArray(lev);
255 if (local_grid < 0) {
256 bool findfirst = (nGrow == 0) ?
true :
false;
258 grid = isects.empty() ? -1 : isects[0].first;
259 if (nGrow > 0 && isects.size() > 1) {
260 for (
auto & isect : isects) {
262 for (
int dir = 0; dir < AMREX_SPACEDIM; ++dir) {
274 grid = (*redistribute_mask_ptr)[local_grid](iv, 0);
292template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
293 template<
class>
class Allocator,
class CellAssignor>
301 int local_grid)
const
306 if (!Geom(0).isAnyPeriodic()) {
return false; }
309 lev_max = finestLevel();
317 p_prime.
pos(1) = p.pos(1);,
318 p_prime.
pos(2) = p.pos(2));
319 if (PeriodicShift(p_prime)) {
320 std::vector< std::pair<int,Box> > isects;
321 for (
int lev = lev_max; lev >= lev_min; lev--) {
325 const BoxArray& ba = ParticleBoxArray(lev);
328 if (local_grid < 0) {
331 grid = isects.empty() ? -1 : isects[0].first;
334 if (ba[local_grid].contains(iv))
341 grid = isects.empty() ? -1 : isects[0].first;
344 grid = (*redistribute_mask_ptr)[local_grid](Index(p, lev), 0);
351 p.pos(1) = p_prime.
pos(1);,
352 p.pos(2) = p_prime.
pos(2););
371template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
372 template<
class>
class Allocator,
class CellAssignor>
378 const auto& geom = Geom(0);
379 const auto plo = geom.ProbLoArray();
380 const auto phi = geom.ProbHiArray();
381 const auto rlo = geom.ProbLoArrayInParticleReal();
382 const auto rhi = geom.ProbHiArrayInParticleReal();
383 const auto is_per = geom.isPeriodicArray();
388template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
389 template<
class>
class Allocator,
class CellAssignor>
399 bool ok = Where(p, pld);
401 if (!ok && Geom(0).isAnyPeriodic())
412 amrex::AllPrint()<<
"Invalidating out-of-domain particle: " << p <<
'\n';
423template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
424 template<
class>
class Allocator,
class CellAssignor>
429 m_particles.reserve(maxLevel()+1);
432template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
433 template<
class>
class Allocator,
class CellAssignor>
438 int nlevs = std::max(0, finestLevel()+1);
439 m_particles.resize(nlevs);
442template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
443 template<
class>
class Allocator,
class CellAssignor>
447 int lev_min,
int lev_max,
int nGrow,
int local_grid)
const
450 if (Geom(0).outsideRoundoffDomain(
AMREX_D_DECL(p.pos(0), p.pos(1), p.pos(2))))
453 success = EnforcePeriodicWhere(p, pld, lev_min, lev_max, local_grid);
454 if (!success && lev_min == 0)
463 success = Where(p, pld, lev_min, lev_max, 0, local_grid);
468 success = (nGrow > 0) && Where(p, pld, lev_min, lev_min, nGrow);
474 amrex::Abort(
"ParticleContainer::locateParticle(): invalid particle.");
478template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
479 template<
class>
class Allocator,
class CellAssignor>
484 for (
int lev = 0; lev <= finestLevel(); lev++) {
485 nparticles += NumberOfParticlesAtLevel(lev,only_valid,
true);
493template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
494 template<
class>
class Allocator,
class CellAssignor>
498 AMREX_ASSERT(lev >= 0 && lev <
int(m_particles.size()));
501 ParticleDistributionMap(lev));
505 int gid = pti.index();
508 const auto& ptile = ParticlesAt(lev, pti);
509 const int np = ptile.numParticles();
510 auto const ptd = ptile.getConstParticleTileData();
514 using ReduceTuple =
typename decltype(reduce_data)::Type;
516 reduce_op.
eval(np, reduce_data,
519 return (ptd.id(i) > 0) ? 1 : 0;
522 int np_valid = amrex::get<0>(reduce_data.value(reduce_op));
523 np_per_grid_local[gid] += np_valid;
526 np_per_grid_local[gid] += pti.numParticles();
530 Vector<Long> nparticles(np_per_grid_local.
size(), 0);
535 nparticles[pti.index()] = np_per_grid_local[pti.index()];
549template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
550 template<
class>
class Allocator,
class CellAssignor>
555 if (level < 0 || level >=
int(m_particles.size())) {
return nparticles; }
560 using ReduceTuple =
typename decltype(reduce_data)::Type;
562 for (
const auto& kv : GetParticles(level)) {
563 const auto& ptile = kv.second;
564 auto const ptd = ptile.getConstParticleTileData();
566 reduce_op.
eval(ptile.numParticles(), reduce_data,
569 return (ptd.id(i) > 0) ? 1 : 0;
573 nparticles =
static_cast<Long
>(amrex::get<0>(reduce_data.value(reduce_op)));
576 for (
const auto& kv : GetParticles(level)) {
577 const auto& ptile = kv.second;
578 nparticles += ptile.numParticles();
593template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
601 for (
unsigned lev = 0; lev < m_particles.size(); lev++) {
602 const auto& pmap = m_particles[lev];
603 for (
const auto& kv : pmap) {
604 const auto& ptile = kv.second;
605 cnt += ptile.numParticles();
609 Long mn = cnt, mx = mn;
612 const Long sz =
sizeof(ParticleType)+NumRealComps()*
sizeof(ParticleReal)+NumIntComps()*
sizeof(
int);
621 amrex::Print() <<
"ParticleContainer spread across MPI nodes - bytes (num particles): [Min: "
629 <<
" (" << cnt <<
")]\n";
634 return {mn*sz, mx*sz, cnt*sz};
637template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
638 template<
class>
class Allocator,
class CellAssignor>
640ParticleContainer_impl<ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor>
641::PrintCapacity ()
const
645 for (
unsigned lev = 0; lev < m_particles.size(); lev++) {
646 const auto& pmap = m_particles[lev];
647 for (
const auto& kv : pmap) {
648 const auto& ptile = kv.second;
649 cnt += ptile.capacity();
653 Long mn = cnt, mx = mn;
664 amrex::Print() <<
"ParticleContainer spread across MPI nodes - bytes: [Min: "
675 return {mn, mx, cnt};
678template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
679 template<
class>
class Allocator,
class CellAssignor>
683 for (
unsigned lev = 0; lev < m_particles.size(); lev++) {
684 auto& pmap = m_particles[lev];
685 for (
auto& kv : pmap) {
686 auto& ptile = kv.second;
687 ptile.shrink_to_fit();
698template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
706 if (m_particles.empty()) {
return; }
707 AMREX_ASSERT(lev >= 0 && lev <
int(m_particles.size()));
710 const auto& geom = Geom(lev);
711 const auto plo = geom.ProbLoArray();
712 const auto dxi = geom.InvCellSizeArray();
713 const auto domain = geom.Domain();
720 IntVect iv = assignor(p, plo, dxi, domain);
725template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
726 template<
class>
class Allocator,
class CellAssignor>
730 BL_PROFILE(
"ParticleContainer::IncrementWithTotal(lev)");
732 return TotalNumberOfParticles(
true, local);
735template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
736 template<
class>
class Allocator,
class CellAssignor>
740 BL_PROFILE(
"ParticleContainer::RemoveParticlesAtLevel()");
741 if (level >=
int(this->m_particles.size())) {
return; }
743 if (!this->m_particles[level].empty())
749template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
750 template<
class>
class Allocator,
class CellAssignor>
754 BL_PROFILE(
"ParticleContainer::RemoveParticlesNotAtFinestLevel()");
755 AMREX_ASSERT(this->finestLevel()+1 ==
int(this->m_particles.size()));
759 for (
unsigned lev = 0; lev < m_particles.size() - 1; ++lev) {
760 auto& pmap = m_particles[lev];
762 for (
auto& kv : pmap) {
763 const auto& pbx = kv.second;
764 cnt += pbx.numParticles();
773 if (this->m_verbose > 1 && cnt > 0) {
775 <<
" particles not in finest level\n";
791 template <
typename SrcData>
793 int operator() (
const SrcData& src,
int src_i)
const noexcept
802 template <
typename DstData,
typename SrcData>
805 int src_i,
int dst_i)
const noexcept
810 (dst.m_aos[dst_i]).cpu() = 0;
815template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
816 template<
class>
class Allocator,
class CellAssignor>
818ParticleContainer_impl<ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor>
819::CreateVirtualParticles (
int level,
AoS& virts)
const
822 CreateVirtualParticles(level, ptile);
826template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
827 template<
class>
class Allocator,
class CellAssignor>
832 BL_PROFILE(
"ParticleContainer::CreateVirtualParticles()");
836 if (level >=
static_cast<int>(m_particles.size())) {
840 std::string aggregation_type = AggregationType();
841 int aggregation_buffer = AggregationBuffer();
843 if (aggregation_type ==
"None")
848 const auto& src_tile = ParticlesAt(level, pti);
850 auto np = src_tile.numParticles();
851 virts.
resize(virts_offset+np);
856 if (aggregation_type ==
"Cell")
859 int nComp = AMREX_SPACEDIM + NStructReal + NArrayReal;
862 MultiFab mf(ParticleBoxArray(level), ParticleDistributionMap(level),
nComp, nGhost);
864 nComp = 1 + NStructInt + NArrayInt;
865 iMultiFab imf(ParticleBoxArray(level), ParticleDistributionMap(level),
nComp, nGhost);
867 const auto& geom = Geom(level);
868 const auto plo = geom.ProbLoArray();
869 const auto dxi = geom.InvCellSizeArray();
870 const auto domain = geom.Domain();
873 bl_buffer.
complementIn(Geom(level).Domain(), ParticleBoxArray(level));
874 BoxArray buffer(std::move(bl_buffer));
875 buffer.
grow(aggregation_buffer);
878 locator.
build(buffer, geom);
888 if(assign_buffer_grid(iv)==-1)
891 for (
int i = 0; i < NArrayReal; ++i)
893 amrex::Gpu::Atomic::AddNoRet(&partData(iv,AMREX_SPACEDIM+NStructReal+i), partData(iv,AMREX_SPACEDIM)!=0.0 ?
static_cast<Real
>(0) :
static_cast<Real
>(p.rdata(NStructReal+i)));
896 for (
int i = 0; i < AMREX_SPACEDIM; ++i)
901 for (
int i = 1; i < NStructReal; ++i)
906 for (
int i = 0; i < 1; ++i)
922 if(assign_buffer_grid(iv)==-1)
925 if(partData(iv,0)==0)
929 for (
int i = 0; i < NStructInt; ++i)
933 for (
int i = 0; i < NArrayInt; ++i)
947 const auto bx = mfi.tilebox();
948 const auto partData = mf.
array(mfi);
949 const auto imf_arr = imf.
array(mfi);
952 auto *offsets_ptr = offsets.
dataPtr();
957 if(imf_arr(i,j,k,0)!=0)
964 p.
rdata(0) =
static_cast<ParticleReal
>(partData(i,j,k,AMREX_SPACEDIM));
966 for (
int n = 0; n < AMREX_SPACEDIM; ++n)
968 p.
pos(n) =
static_cast<ParticleReal
>(partData(i,j,k,n) / p.
rdata(0));
971 for (
int n = 1; n < NStructReal; ++n)
973 p.
rdata(n) =
static_cast<ParticleReal
>(partData(i,j,k,AMREX_SPACEDIM+n) / p.
rdata(0));
976 for (
int n = 0; n < NArrayReal; ++n)
978 p.
rdata(NStructReal+n) =
static_cast<ParticleReal
>(partData(i,j,k,AMREX_SPACEDIM+NStructReal+n));
981 for (
int n = 0; n < NStructInt; ++n)
983 p.
idata(n) = imf_arr(i,j,k,1+n);
986 for (
int n = 0; n < NArrayInt; ++n)
988 p.
idata(NStructInt+n) = imf_arr(i,j,k,1+NStructInt+n);
991 dst.setSuperParticle(p, last_offset+offsets_ptr[((i-imf_arr.begin.x)+(j-imf_arr.begin.y)*imf_arr.jstride+(k-imf_arr.begin.z)*imf_arr.kstride)]);
995 last_offset+=next_offset;
1000 auto virts_offset = last_offset;
1003 const auto& src_tile = ParticlesAt(level, pti);
1005 auto np = src_tile.numParticles();
1006 virts.
resize(virts_offset+np);
1010 virts.
resize(virts_offset);
1029 template <
typename SrcData>
1035 const auto p_boxes = amrex::get<0>(tup_min);
1036 const auto p_boxes_max = amrex::get<0>(tup_max);
1037 const auto p_levs_max = amrex::get<1>(tup_max);
1038 return p_boxes_max >=0 && p_boxes == m_gid && p_levs_max == m_lev_max;
1045 template <
typename DstData,
typename SrcData>
1047 void operator() (DstData& dst,
const SrcData& src,
1048 int src_i,
int dst_i)
const noexcept
1052 (dst.m_aos[dst_i]).
id() = LongParticleIds::GhostParticleID;
1053 (dst.m_aos[dst_i]).cpu() = 0;
1057template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1058 template<
class>
class Allocator,
class CellAssignor>
1060ParticleContainer_impl<ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor>
1061::CreateGhostParticles (
int level,
int nGrow,
AoS& ghosts)
const
1064 CreateGhostParticles(level, nGrow, ptile);
1068template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1069 template<
class>
class Allocator,
class CellAssignor>
1074 BL_PROFILE(
"ParticleContainer::CreateGhostParticles()");
1078 if (level >=
static_cast<int>(m_particles.size())) {
1082 if (! m_particle_locator.isValid(GetParGDB())) {
1083 m_particle_locator.build(GetParGDB());
1086 m_particle_locator.setGeometry(GetParGDB());
1091 const auto& src_tile = ParticlesAt(level, pti);
1092 int gid = pti.index();
1094 auto np = src_tile.numParticles();
1095 ghosts.
resize(ghost_offset+np);
1098 ghosts.
resize(ghost_offset);
1099 Gpu::streamSynchronize();
1102template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1103 template<
class>
class Allocator,
class CellAssignor>
1108 BL_PROFILE(
"ParticleContainer::clearParticles()");
1110 for (
int lev = 0; lev < static_cast<int>(m_particles.size()); ++lev)
1112 for (
auto& kv : m_particles[lev]) { kv.second.resize(0); }
1113 particle_detail::clearEmptyEntries(m_particles[lev]);
1117template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1118 template<
class>
class Allocator,
class CellAssignor>
1119template <class PCType, std::enable_if_t<IsParticleContainer<PCType>::value,
int> foo>
1128template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1129 template<
class>
class Allocator,
class CellAssignor>
1130template <class PCType, std::enable_if_t<IsParticleContainer<PCType>::value,
int> foo>
1139template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1140 template<
class>
class Allocator,
class CellAssignor>
1141template <
class F,
class PCType,
1142 std::enable_if_t<IsParticleContainer<PCType>::value,
int> foo,
1143 std::enable_if_t<! std::is_integral_v<F>,
int> bar>
1148 BL_PROFILE(
"ParticleContainer::copyParticles");
1150 addParticles(other, std::forward<F>(f), local);
1153template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1154 template<
class>
class Allocator,
class CellAssignor>
1155template <
class F,
class PCType,
1156 std::enable_if_t<IsParticleContainer<PCType>::value,
int> foo,
1157 std::enable_if_t<! std::is_integral_v<F>,
int> bar>
1160addParticles (
const PCType& other, F
const& f,
bool local)
1162 BL_PROFILE(
"ParticleContainer::addParticles");
1164 for (
int lev = 0; lev < other.numLevels(); ++lev)
1166 const auto& plevel_other = other.GetParticles(lev);
1167 for(
MFIter mfi = other.MakeMFIter(lev); mfi.isValid(); ++mfi)
1169 auto index = std::make_pair(mfi.index(), mfi.LocalTileIndex());
1170 if(plevel_other.find(index) == plevel_other.end()) {
continue; }
1172 auto& ptile = DefineAndReturnParticleTile(lev, mfi.index(), mfi.LocalTileIndex());
1173 const auto& ptile_other = plevel_other.at(index);
1174 auto np = ptile_other.numParticles();
1175 if (np == 0) {
continue; }
1177 auto dst_index = ptile.numParticles();
1178 ptile.resize(dst_index + np);
1182 ptile.resize(dst_index + count);
1186 if (! local) { Redistribute(); }
1192template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1193 template<
class>
class Allocator,
class CellAssignor>
1201 if ( Gpu::inLaunchRegion() )
1203 RedistributeGPU(lev_min, lev_max, nGrow, local, remove_negative);
1207 RedistributeCPU(lev_min, lev_max, nGrow, local, remove_negative);
1210 RedistributeCPU(lev_min, lev_max, nGrow, local, remove_negative);
1216template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1217 template<
class>
class Allocator,
class CellAssignor>
1218template <
class index_type>
1223 auto& ptile = ParticlesAt(lev, mfi);
1224 const size_t np = ptile.numParticles();
1225 const size_t np_total = np + ptile.numNeighborParticles();
1227 if (memEfficientSort) {
1228#if defined(AMREX_USE_CUDA) && defined(_WIN32)
1229 if (!ParticleType::is_soa_particle) {
1231 if constexpr (!ParticleType::is_soa_particle) {
1233 static_assert(
sizeof(
ParticleType)%4 == 0 &&
sizeof(uint32_t) == 4);
1234 using tmp_t = std::conditional_t<
sizeof(
ParticleType)%8 == 0,
1235 uint64_t, uint32_t>;
1236 constexpr std::size_t nchunks =
sizeof(
ParticleType) /
sizeof(tmp_t);
1238 auto* ptmp = tmp.
data();
1239 auto* paos = (tmp_t*)(ptile.getParticleTileData().m_aos);
1240 for (std::size_t ichunk = 0; ichunk < nchunks; ++ichunk) {
1244 ptmp[i] = paos[permutations[i]*nchunks+ichunk];
1248 paos[i*nchunks+ichunk] = ptmp[i];
1251 Gpu::streamSynchronize();
1253 typename SoA::IdCPU tmp_idcpu(np_total);
1255 auto src = ptile.GetStructOfArrays().GetIdCPUData().data();
1256 uint64_t* dst = tmp_idcpu.data();
1259 dst[i] = i < np ? src[permutations[i]] : src[i];
1262 Gpu::streamSynchronize();
1264 ptile.GetStructOfArrays().GetIdCPUData().swap(tmp_idcpu);
1268 RealVector tmp_real(np_total);
1269 for (
int comp = 0; comp < NArrayReal + m_num_runtime_real; ++comp) {
1270 auto src = ptile.GetStructOfArrays().GetRealData(comp).data();
1271 ParticleReal* dst = tmp_real.data();
1274 dst[i] = i < np ? src[permutations[i]] : src[i];
1277 Gpu::streamSynchronize();
1279 ptile.GetStructOfArrays().GetRealData(comp).swap(tmp_real);
1283 IntVector tmp_int(np_total);
1284 for (
int comp = 0; comp < NArrayInt + m_num_runtime_int; ++comp) {
1285 auto src = ptile.GetStructOfArrays().GetIntData(comp).data();
1286 int* dst = tmp_int.data();
1289 dst[i] = i < np ? src[permutations[i]] : src[i];
1292 Gpu::streamSynchronize();
1294 ptile.GetStructOfArrays().GetIntData(comp).swap(tmp_int);
1297 ParticleTileType ptile_tmp;
1298 ptile_tmp.define(m_num_runtime_real, m_num_runtime_int, &m_soa_rdata_names, &m_soa_idata_names);
1299 ptile_tmp.resize(np_total);
1304 ptile.swap(ptile_tmp);
1308template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1309 template<
class>
class Allocator,
class CellAssignor>
1316template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1317 template<
class>
class Allocator,
class CellAssignor>
1322 BL_PROFILE(
"ParticleContainer::SortParticlesByBin()");
1324 if (bin_size == IntVect::TheZeroVector()) {
return; }
1326 for (
int lev = 0; lev < numLevels(); ++lev)
1331 const auto domain = geom.
Domain();
1335 auto& ptile = ParticlesAt(lev, mfi);
1336 const size_t np = ptile.numParticles();
1342 m_bins.build(np, ptile.getParticleTileData(), ntiles,
1344 ReorderParticles(lev, mfi, m_bins.permutationPtr());
1349template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1350 template<
class>
class Allocator,
class CellAssignor>
1352ParticleContainer_impl<ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor>
1355 BL_PROFILE(
"ParticleContainer::SortParticlesForDeposition()");
1357 for (
int lev = 0; lev < numLevels(); ++lev)
1363 const auto& ptile = ParticlesAt(lev, mfi);
1364 const size_t np = ptile.numParticles();
1368 using index_type =
typename decltype(m_bins)::index_type;
1370 PermutationForDeposition<index_type>(perm, np, ptile, box, geom, idx_type);
1371 ReorderParticles(lev, mfi, perm.
dataPtr());
1379template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1380 template<
class>
class Allocator,
class CellAssignor>
1392 BL_PROFILE(
"ParticleContainer::RedistributeGPU()");
1395 int theEffectiveFinestLevel = m_gdb->finestLevel();
1396 while (!m_gdb->LevelDefined(theEffectiveFinestLevel)) { theEffectiveFinestLevel--; }
1398 if (
int(m_particles.size()) < theEffectiveFinestLevel+1) {
1400 amrex::Print() <<
"ParticleContainer::Redistribute() resizing containers from "
1401 << m_particles.size() <<
" to "
1402 << theEffectiveFinestLevel + 1 <<
'\n';
1404 m_particles.resize(theEffectiveFinestLevel+1);
1405 m_dummy_mf.resize(theEffectiveFinestLevel+1);
1408 for (
int lev = 0; lev < theEffectiveFinestLevel+1; ++lev) { RedefineDummyMF(lev); }
1410 int finest_lev_particles;
1411 if (lev_max == -1) {
1412 lev_max = theEffectiveFinestLevel;
1413 finest_lev_particles = m_particles.size() - 1;
1415 finest_lev_particles = lev_max;
1419 this->defineBufferMap();
1421 if (! m_particle_locator.isValid(GetParGDB())) { m_particle_locator.build(GetParGDB()); }
1422 m_particle_locator.setGeometry(GetParGDB());
1423 auto assign_grid = m_particle_locator.getGridAssignor();
1427 int num_levels = finest_lev_particles + 1;
1430 const auto plo = Geom(0).ProbLoArray();
1431 const auto phi = Geom(0).ProbHiArray();
1432 const auto rlo = Geom(0).ProbLoArrayInParticleReal();
1433 const auto rhi = Geom(0).ProbHiArrayInParticleReal();
1434 const auto is_per = Geom(0).isPeriodicArray();
1435 for (
int lev = lev_min; lev <= finest_lev_particles; ++lev)
1437 auto& plev = m_particles[lev];
1438 for (
auto& kv : plev)
1440 int gid = kv.first.first;
1441 int tid = kv.first.second;
1442 auto index = std::make_pair(gid, tid);
1444 auto& src_tile = plev[index];
1445 const size_t np = src_tile.numParticles();
1450 plo, phi, rlo, rhi, is_per, lev, gid, tid,
1451 lev_min, lev_max, nGrow, remove_negative);
1453 int num_move = np - num_stay;
1454 new_sizes[lev][gid] = num_stay;
1457 auto p_boxes = op.
m_boxes[lev][gid].dataPtr();
1458 auto p_levs = op.
m_levels[lev][gid].dataPtr();
1461 auto ptd = src_tile.getParticleTileData();
1474 const auto tup = assign_grid(p, lev_min, lev_max, nGrow,
1476 p_boxes[i] = amrex::get<0>(tup);
1477 p_levs[i] = amrex::get<1>(tup);
1480 p_src_indices[i] = i+num_stay;
1488 plan.
build(*
this, op, h_redistribute_int_comp,
1489 h_redistribute_real_comp, local);
1495 if (use_comms_arena) {
1503 for (
int lev = lev_min; lev <= lev_max; ++lev)
1505 auto& plev = m_particles[lev];
1506 for (
auto& kv : plev)
1508 int gid = kv.first.first;
1509 int tid = kv.first.second;
1510 auto index = std::make_pair(gid, tid);
1511 auto& tile = plev[index];
1512 tile.resize(new_sizes[lev][gid]);
1516 for (
int lev = lev_min; lev <= lev_max; lev++)
1518 particle_detail::clearEmptyEntries(m_particles[lev]);
1521 if (
int(m_particles.size()) > theEffectiveFinestLevel+1) {
1522 if (m_verbose > 0) {
1523 amrex::Print() <<
"ParticleContainer::Redistribute() resizing m_particles from "
1524 << m_particles.size() <<
" to " << theEffectiveFinestLevel+1 <<
'\n';
1528 m_particles.resize(theEffectiveFinestLevel + 1);
1529 m_dummy_mf.resize(theEffectiveFinestLevel + 1);
1532 if (ParallelDescriptor::UseGpuAwareMpi())
1536 unpackBuffer(*
this, plan, snd_buffer, RedistributeUnpackPolicy());
1538 unpackRemotes(*
this, plan, rcv_buffer, RedistributeUnpackPolicy());
1542 Gpu::Device::streamSynchronize();
1543 Gpu::PinnedVector<char> pinned_snd_buffer;
1544 Gpu::PinnedVector<char> pinned_rcv_buffer;
1546 if (snd_buffer.arena()->isPinned()) {
1548 Gpu::Device::streamSynchronize();
1551 pinned_snd_buffer.resize(snd_buffer.
size());
1552 Gpu::dtoh_memcpy_async(pinned_snd_buffer.dataPtr(), snd_buffer.
dataPtr(), snd_buffer.
size());
1554 Gpu::Device::streamSynchronize();
1558 rcv_buffer.
resize(pinned_rcv_buffer.size());
1559 unpackBuffer(*
this, plan, snd_buffer, RedistributeUnpackPolicy());
1561 Gpu::htod_memcpy_async(rcv_buffer.
dataPtr(), pinned_rcv_buffer.dataPtr(), pinned_rcv_buffer.size());
1562 unpackRemotes(*
this, plan, rcv_buffer, RedistributeUnpackPolicy());
1565 Gpu::Device::streamSynchronize();
1575template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
1576 template<
class>
class Allocator,
class CellAssignor>
1578ParticleContainer_impl<ParticleType, NArrayReal, NArrayInt, Allocator, CellAssignor>
1579::RedistributeCPU (
int lev_min,
int lev_max,
int nGrow,
int local,
bool remove_negative)
1581 BL_PROFILE(
"ParticleContainer::RedistributeCPU()");
1583 const int MyProc = ParallelContext::MyProcSub();
1586 if (local > 0) { BuildRedistributeMask(0, local); }
1590 int theEffectiveFinestLevel = m_gdb->finestLevel();
1592 while (!m_gdb->LevelDefined(theEffectiveFinestLevel)) {
1593 theEffectiveFinestLevel--;
1596 if (
int(m_particles.size()) < theEffectiveFinestLevel+1) {
1598 amrex::Print() <<
"ParticleContainer::Redistribute() resizing containers from "
1599 << m_particles.size() <<
" to "
1600 << theEffectiveFinestLevel + 1 <<
'\n';
1602 m_particles.resize(theEffectiveFinestLevel+1);
1603 m_dummy_mf.resize(theEffectiveFinestLevel+1);
1608 for (
int lev = 0; lev < theEffectiveFinestLevel+1; ++lev) {
1609 RedefineDummyMF(lev);
1612 int finest_lev_particles;
1613 if (lev_max == -1) {
1614 lev_max = theEffectiveFinestLevel;
1615 finest_lev_particles = m_particles.size() - 1;
1617 finest_lev_particles = lev_max;
1622 std::map<int, Vector<char> > not_ours;
1624 int num_threads = OpenMP::get_max_threads();
1627 std::map<int, Vector<Vector<char> > > tmp_remote;
1630 tmp_local.resize(theEffectiveFinestLevel+1);
1631 soa_local.resize(theEffectiveFinestLevel+1);
1634 for (
int lev = lev_min; lev <= lev_max; lev++) {
1635 for (
MFIter mfi(*m_dummy_mf[lev], this->do_tiling ? this->tile_size : IntVect::TheZeroVector());
1638 tmp_local[lev][index].resize(num_threads);
1639 soa_local[lev][index].resize(num_threads);
1640 for (
int t = 0; t < num_threads; ++t) {
1641 soa_local[lev][index][t].define(m_num_runtime_real, m_num_runtime_int, &m_soa_rdata_names, &m_soa_idata_names);
1646 for (
int i = 0; i < neighbor_procs.size(); ++i) {
1647 tmp_remote[neighbor_procs[i]].resize(num_threads);
1650 for (
int i = 0; i < ParallelContext::NProcsSub(); ++i) {
1651 tmp_remote[i].resize(num_threads);
1657 for (
int lev = lev_min; lev <= finest_lev_particles; lev++) {
1658 auto& pmap = m_particles[lev];
1662 for (
auto& kv : pmap)
1664 grid_tile_ids.push_back(kv.first);
1665 ptile_ptrs.push_back(&(kv.second));
1669#pragma omp parallel for
1671 for (
int pmap_it = 0; pmap_it < static_cast<int>(ptile_ptrs.
size()); ++pmap_it)
1673 int thread_num = OpenMP::get_thread_num();
1674 int grid = grid_tile_ids[pmap_it].first;
1675 int tile = grid_tile_ids[pmap_it].second;
1676 auto& soa = ptile_ptrs[pmap_it]->GetStructOfArrays();
1677 auto& aos = ptile_ptrs[pmap_it]->GetArrayOfStructs();
1683 unsigned npart = ptile_ptrs[pmap_it]->numParticles();
1686 if constexpr (!ParticleType::is_soa_particle){
1689 Long last = npart - 1;
1691 while (pindex <= last) {
1694 if ((remove_negative ==
false) && (p.id() < 0)) {
1701 aos[pindex] = aos[last];
1702 for (
int comp = 0; comp < NumRealComps(); comp++) {
1703 soa.GetRealData(comp)[pindex] = soa.GetRealData(comp)[last];
1705 for (
int comp = 0; comp < NumIntComps(); comp++) {
1706 soa.GetIntData(comp)[pindex] = soa.GetIntData(comp)[last];
1708 correctCellVectors(last, pindex, grid, aos[pindex]);
1713 locateParticle(p, pld, lev_min, lev_max, nGrow, local ? grid : -1);
1715 particlePostLocate(p, pld, lev);
1719 aos[pindex] = aos[last];
1720 for (
int comp = 0; comp < NumRealComps(); comp++) {
1721 soa.GetRealData(comp)[pindex] = soa.GetRealData(comp)[last];
1723 for (
int comp = 0; comp < NumIntComps(); comp++) {
1724 soa.GetIntData(comp)[pindex] = soa.GetIntData(comp)[last];
1726 correctCellVectors(last, pindex, grid, aos[pindex]);
1731 const int who = ParallelContext::global_to_local_rank(ParticleDistributionMap(pld.
m_lev)[pld.
m_grid]);
1732 if (who == MyProc) {
1737 tmp_local[pld.
m_lev][index][thread_num].push_back(p);
1738 for (
int comp = 0; comp < NumRealComps(); ++comp) {
1739 RealVector& arr = soa_local[pld.
m_lev][index][thread_num].GetRealData(comp);
1740 arr.push_back(soa.GetRealData(comp)[pindex]);
1742 for (
int comp = 0; comp < NumIntComps(); ++comp) {
1743 IntVector& arr = soa_local[pld.
m_lev][index][thread_num].GetIntData(comp);
1744 arr.push_back(soa.GetIntData(comp)[pindex]);
1751 auto& particles_to_send = tmp_remote[who][thread_num];
1752 auto old_size = particles_to_send.
size();
1753 auto new_size = old_size + superparticle_size;
1754 particles_to_send.resize(new_size);
1755 std::memcpy(&particles_to_send[old_size], &p, particle_size);
1756 char* dst = &particles_to_send[old_size] + particle_size;
1757 int array_comp_start = 0;
1758 if constexpr (!ParticleType::is_soa_particle) {
1759 array_comp_start = AMREX_SPACEDIM + NStructReal;
1761 for (
int comp = 0; comp < NumRealComps(); comp++) {
1762 if (h_redistribute_real_comp[array_comp_start + comp]) {
1763 std::memcpy(dst, &soa.GetRealData(comp)[pindex],
sizeof(ParticleReal));
1764 dst +=
sizeof(ParticleReal);
1767 array_comp_start = 2 + NStructInt;
1768 for (
int comp = 0; comp < NumIntComps(); comp++) {
1769 if (h_redistribute_int_comp[array_comp_start + comp]) {
1770 std::memcpy(dst, &soa.GetIntData(comp)[pindex],
sizeof(
int));
1780 aos[pindex] = aos[last];
1781 for (
int comp = 0; comp < NumRealComps(); comp++) {
1782 soa.GetRealData(comp)[pindex] = soa.GetRealData(comp)[last];
1784 for (
int comp = 0; comp < NumIntComps(); comp++) {
1785 soa.GetIntData(comp)[pindex] = soa.GetIntData(comp)[last];
1787 correctCellVectors(last, pindex, grid, aos[pindex]);
1795 aos().erase(aos().
begin() + last + 1, aos().
begin() + npart);
1796 for (
int comp = 0; comp < NumRealComps(); comp++) {
1798 rdata.erase(rdata.begin() + last + 1, rdata.begin() + npart);
1800 for (
int comp = 0; comp < NumIntComps(); comp++) {
1801 IntVector& idata = soa.GetIntData(comp);
1802 idata.erase(idata.begin() + last + 1, idata.begin() + npart);
1808 auto particle_tile = ptile_ptrs[pmap_it];
1810 Long last = npart - 1;
1812 auto ptd = particle_tile->getParticleTileData();
1813 while (pindex <= last) {
1816 if ((remove_negative ==
false) && (p.id() < 0)) {
1822 soa.GetIdCPUData()[pindex] = soa.GetIdCPUData()[last];
1823 for (
int comp = 0; comp < NumRealComps(); comp++) {
1824 soa.GetRealData(comp)[pindex] = soa.GetRealData(comp)[last];
1826 for (
int comp = 0; comp < NumIntComps(); comp++) {
1827 soa.GetIntData(comp)[pindex] = soa.GetIntData(comp)[last];
1829 correctCellVectors(last, pindex, grid, ptd[pindex]);
1834 locateParticle(p, pld, lev_min, lev_max, nGrow, local ? grid : -1);
1836 particlePostLocate(p, pld, lev);
1839 soa.GetIdCPUData()[pindex] = soa.GetIdCPUData()[last];
1840 for (
int comp = 0; comp < NumRealComps(); comp++) {
1841 soa.GetRealData(comp)[pindex] = soa.GetRealData(comp)[last];
1843 for (
int comp = 0; comp < NumIntComps(); comp++) {
1844 soa.GetIntData(comp)[pindex] = soa.GetIntData(comp)[last];
1846 correctCellVectors(last, pindex, grid, ptd[pindex]);
1851 const int who = ParallelContext::global_to_local_rank(ParticleDistributionMap(pld.
m_lev)[pld.
m_grid]);
1852 if (who == MyProc) {
1858 auto& arr = soa_local[pld.
m_lev][index][thread_num].GetIdCPUData();
1859 arr.push_back(soa.GetIdCPUData()[pindex]);
1861 for (
int comp = 0; comp < NumRealComps(); ++comp) {
1862 RealVector& arr = soa_local[pld.
m_lev][index][thread_num].GetRealData(comp);
1863 arr.push_back(soa.GetRealData(comp)[pindex]);
1865 for (
int comp = 0; comp < NumIntComps(); ++comp) {
1866 IntVector& arr = soa_local[pld.
m_lev][index][thread_num].GetIntData(comp);
1867 arr.push_back(soa.GetIntData(comp)[pindex]);
1874 auto& particles_to_send = tmp_remote[who][thread_num];
1875 auto old_size = particles_to_send.
size();
1876 auto new_size = old_size + superparticle_size;
1877 particles_to_send.resize(new_size);
1879 char* dst = &particles_to_send[old_size];
1881 std::memcpy(dst, &soa.GetIdCPUData()[pindex],
sizeof(uint64_t));
1882 dst +=
sizeof(uint64_t);
1884 int array_comp_start = 0;
1885 if constexpr (!ParticleType::is_soa_particle) {
1886 array_comp_start = AMREX_SPACEDIM + NStructReal;
1888 for (
int comp = 0; comp < NumRealComps(); comp++) {
1889 if (h_redistribute_real_comp[array_comp_start + comp]) {
1890 std::memcpy(dst, &soa.GetRealData(comp)[pindex],
sizeof(ParticleReal));
1891 dst +=
sizeof(ParticleReal);
1894 array_comp_start = 2 + NStructInt;
1895 for (
int comp = 0; comp < NumIntComps(); comp++) {
1896 if (h_redistribute_int_comp[array_comp_start + comp]) {
1897 std::memcpy(dst, &soa.GetIntData(comp)[pindex],
sizeof(
int));
1905 soa.GetIdCPUData()[pindex] = soa.GetIdCPUData()[last];
1906 for (
int comp = 0; comp < NumRealComps(); comp++) {
1907 soa.GetRealData(comp)[pindex] = soa.GetRealData(comp)[last];
1909 for (
int comp = 0; comp < NumIntComps(); comp++) {
1910 soa.GetIntData(comp)[pindex] = soa.GetIntData(comp)[last];
1912 correctCellVectors(last, pindex, grid, ptd[pindex]);
1921 auto& iddata = soa.GetIdCPUData();
1922 iddata.erase(iddata.begin() + last + 1, iddata.begin() + npart);
1924 for (
int comp = 0; comp < NumRealComps(); comp++) {
1926 rdata.erase(rdata.begin() + last + 1, rdata.begin() + npart);
1928 for (
int comp = 0; comp < NumIntComps(); comp++) {
1929 IntVector& idata = soa.GetIntData(comp);
1930 idata.erase(idata.begin() + last + 1, idata.begin() + npart);
1937 for (
int lev = lev_min; lev <= lev_max; lev++) {
1938 particle_detail::clearEmptyEntries(m_particles[lev]);
1942 for (
int lev = lev_min; lev <= lev_max; lev++) {
1945 if constexpr(!ParticleType::is_soa_particle) {
1950 for (pmap_it=tmp_local[lev].
begin(); pmap_it != tmp_local[lev].end(); pmap_it++)
1952 DefineAndReturnParticleTile(lev, pmap_it->first.first, pmap_it->first.second);
1953 grid_tile_ids.push_back(pmap_it->first);
1954 pvec_ptrs.push_back(&(pmap_it->second));
1958#pragma omp parallel for
1960 for (
int pit = 0; pit < static_cast<int>(pvec_ptrs.
size()); ++pit)
1962 auto index = grid_tile_ids[pit];
1963 auto& ptile = ParticlesAt(lev, index.first, index.second);
1964 auto& aos = ptile.GetArrayOfStructs();
1965 auto& soa = ptile.GetStructOfArrays();
1966 auto& aos_tmp = *(pvec_ptrs[pit]);
1967 auto& soa_tmp = soa_local[lev][index];
1968 for (
int i = 0; i < num_threads; ++i) {
1969 aos.insert(aos.end(), aos_tmp[i].begin(), aos_tmp[i].end());
1970 aos_tmp[i].erase(aos_tmp[i].
begin(), aos_tmp[i].end());
1971 for (
int comp = 0; comp < NumRealComps(); ++comp) {
1973 RealVector& tmp = soa_tmp[i].GetRealData(comp);
1974 arr.insert(arr.end(), tmp.begin(), tmp.end());
1975 tmp.erase(tmp.begin(), tmp.end());
1977 for (
int comp = 0; comp < NumIntComps(); ++comp) {
1979 IntVector& tmp = soa_tmp[i].GetIntData(comp);
1980 arr.insert(arr.end(), tmp.begin(), tmp.end());
1981 tmp.erase(tmp.begin(), tmp.end());
1989 for (
auto soa_map_it=soa_local[lev].
begin(); soa_map_it != soa_local[lev].end(); soa_map_it++)
1991 DefineAndReturnParticleTile(lev, soa_map_it->first.first, soa_map_it->first.second);
1992 grid_tile_ids.push_back(soa_map_it->first);
1996#pragma omp parallel for
1998 for (
int pit = 0; pit < static_cast<int>(grid_tile_ids.
size()); ++pit)
2000 auto index = grid_tile_ids[pit];
2001 auto& ptile = ParticlesAt(lev, index.first, index.second);
2002 auto& soa = ptile.GetStructOfArrays();
2003 auto& soa_tmp = soa_local[lev][index];
2004 for (
int i = 0; i < num_threads; ++i) {
2006 auto& arr = soa.GetIdCPUData();
2007 auto& tmp = soa_tmp[i].GetIdCPUData();
2008 arr.insert(arr.end(), tmp.begin(), tmp.end());
2009 tmp.erase(tmp.begin(), tmp.end());
2011 for (
int comp = 0; comp < NumRealComps(); ++comp) {
2013 RealVector& tmp = soa_tmp[i].GetRealData(comp);
2014 arr.insert(arr.end(), tmp.begin(), tmp.end());
2015 tmp.erase(tmp.begin(), tmp.end());
2017 for (
int comp = 0; comp < NumIntComps(); ++comp) {
2019 IntVector& tmp = soa_tmp[i].GetIntData(comp);
2020 arr.insert(arr.end(), tmp.begin(), tmp.end());
2021 tmp.erase(tmp.begin(), tmp.end());
2028 for (
auto& map_it : tmp_remote) {
2029 int who = map_it.first;
2035 for (
auto& kv : tmp_remote)
2037 dest_proc_ids.push_back(kv.first);
2038 pbuff_ptrs.push_back(&(kv.second));
2042#pragma omp parallel for
2044 for (
int pmap_it = 0; pmap_it < static_cast<int>(pbuff_ptrs.
size()); ++pmap_it)
2046 int who = dest_proc_ids[pmap_it];
2048 for (
int i = 0; i < num_threads; ++i) {
2049 not_ours[who].insert(not_ours[who].
end(), tmp[i].begin(), tmp[i].end());
2050 tmp[i].erase(tmp[i].
begin(), tmp[i].end());
2054 particle_detail::clearEmptyEntries(not_ours);
2056 if (
int(m_particles.size()) > theEffectiveFinestLevel+1) {
2058 if (m_verbose > 0) {
2059 amrex::Print() <<
"ParticleContainer::Redistribute() resizing m_particles from "
2060 << m_particles.size() <<
" to " << theEffectiveFinestLevel+1 <<
'\n';
2064 m_particles.resize(theEffectiveFinestLevel + 1);
2065 m_dummy_mf.resize(theEffectiveFinestLevel + 1);
2068 if (ParallelContext::NProcsSub() == 1) {
2072 RedistributeMPI(not_ours, lev_min, lev_max, nGrow, local);
2077 if (m_verbose > 0) {
2083 Lazy::QueueReduction( [=] ()
mutable {
2085 ParallelReduce::Max(stoptime, ParallelContext::IOProcessorNumberSub(),
2086 ParallelContext::CommunicatorSub());
2088 amrex::Print() <<
"ParticleContainer::Redistribute() time: " << stoptime <<
"\n\n";
2095template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
2096 template<
class>
class Allocator,
class CellAssignor>
2100 int lev_min,
int lev_max,
int nGrow,
int local)
2102 BL_PROFILE(
"ParticleContainer::RedistributeMPI()");
2108 using buffer_type =
unsigned long long;
2110 std::map<int, Vector<buffer_type> > mpi_snd_data;
2111 for (
const auto& kv : not_ours)
2113 auto nbt = (kv.second.size() +
sizeof(buffer_type)-1)/
sizeof(buffer_type);
2114 mpi_snd_data[kv.first].resize(nbt);
2115 std::memcpy((
char*) mpi_snd_data[kv.first].data(), kv.second.data(), kv.second.size());
2118 const int NProcs = ParallelContext::NProcsSub();
2119 const int NNeighborProcs = neighbor_procs.size();
2129 BuildRedistributeMask(0, local);
2137 const int SeqNum = ParallelDescriptor::SeqNum();
2139 if ((! local) && NumSnds == 0) {
2145 Long tot_snds_this_proc = 0;
2146 Long tot_rcvs_this_proc = 0;
2147 for (
int i = 0; i < NNeighborProcs; ++i) {
2148 tot_snds_this_proc += Snds[neighbor_procs[i]];
2149 tot_rcvs_this_proc += Rcvs[neighbor_procs[i]];
2151 if ( (tot_snds_this_proc == 0) && (tot_rcvs_this_proc == 0) ) {
2159 std::size_t TotRcvInts = 0;
2160 std::size_t TotRcvBytes = 0;
2161 for (
int i = 0; i < NProcs; ++i) {
2163 RcvProc.push_back(i);
2164 rOffset.push_back(TotRcvInts);
2165 TotRcvBytes += Rcvs[i];
2166 auto nbt = (Rcvs[i] +
sizeof(buffer_type)-1)/
sizeof(buffer_type);
2171 const auto nrcvs =
static_cast<int>(RcvProc.
size());
2179 for (
int i = 0; i < nrcvs; ++i) {
2180 const auto Who = RcvProc[i];
2181 const auto offset = rOffset[i];
2182 const auto Cnt = (Rcvs[Who] +
sizeof(buffer_type)-1)/
sizeof(buffer_type);
2184 AMREX_ASSERT(Cnt <
size_t(std::numeric_limits<int>::max()));
2187 rreqs[i] = ParallelDescriptor::Arecv(&recvdata[
offset], Cnt, Who, SeqNum,
2188 ParallelContext::CommunicatorSub()).req();
2192 for (
const auto& kv : mpi_snd_data) {
2193 const auto Who = kv.first;
2194 const auto Cnt = kv.second.
size();
2200 ParallelDescriptor::Send(kv.second.data(), Cnt, Who, SeqNum,
2201 ParallelContext::CommunicatorSub());
2205 ParallelDescriptor::Waitall(rreqs, stats);
2209 int npart = TotRcvBytes / superparticle_size;
2217 for (
int j = 0; j < nrcvs; ++j)
2219 const auto offset = rOffset[j];
2220 const auto Who = RcvProc[j];
2221 const auto Cnt = Rcvs[Who] / superparticle_size;
2222 for (
int i = 0; i <
int(Cnt); ++i)
2224 char* pbuf = ((
char*) &recvdata[
offset]) + i*superparticle_size;
2228 if constexpr (ParticleType::is_soa_particle) {
2229 std::memcpy(&p.
m_idcpu, pbuf,
sizeof(uint64_t));
2231 ParticleReal pos[AMREX_SPACEDIM];
2232 std::memcpy(&pos[0], pbuf +
sizeof(uint64_t), AMREX_SPACEDIM*
sizeof(ParticleReal));
2240 bool success = Where(p, pld, lev_min, lev_max, 0);
2243 success = (nGrow > 0) && Where(p, pld, lev_min, lev_min, nGrow);
2248 amrex::Abort(
"RedistributeMPI_locate:: invalid particle.");
2251 rcv_levs[ipart] = pld.
m_lev;
2252 rcv_grid[ipart] = pld.
m_grid;
2253 rcv_tile[ipart] = pld.
m_tile;
2263#ifndef AMREX_USE_GPU
2265 for (
int i = 0; i < nrcvs; ++i)
2267 const auto offset = rOffset[i];
2268 const auto Who = RcvProc[i];
2269 const auto Cnt = Rcvs[Who] / superparticle_size;
2270 for (
int j = 0; j <
int(Cnt); ++j)
2272 auto& ptile = m_particles[rcv_levs[ipart]][std::make_pair(rcv_grid[ipart],
2274 char* pbuf = ((
char*) &recvdata[
offset]) + j*superparticle_size;
2276 if constexpr (ParticleType::is_soa_particle) {
2278 std::memcpy(&idcpudata, pbuf,
sizeof(uint64_t));
2279 pbuf +=
sizeof(uint64_t);
2280 ptile.GetStructOfArrays().GetIdCPUData().push_back(idcpudata);
2288 int array_comp_start = 0;
2289 if constexpr (!ParticleType::is_soa_particle) {
2290 array_comp_start = AMREX_SPACEDIM + NStructReal;
2292 for (
int comp = 0; comp < NumRealComps(); ++comp) {
2293 if (h_redistribute_real_comp[array_comp_start + comp]) {
2295 std::memcpy(&rdata, pbuf,
sizeof(ParticleReal));
2296 pbuf +=
sizeof(ParticleReal);
2297 ptile.push_back_real(comp, rdata);
2299 ptile.push_back_real(comp, 0.0);
2303 array_comp_start = 2 + NStructInt;
2304 for (
int comp = 0; comp < NumIntComps(); ++comp) {
2305 if (h_redistribute_int_comp[array_comp_start + comp]) {
2307 std::memcpy(&idata, pbuf,
sizeof(
int));
2308 pbuf +=
sizeof(
int);
2309 ptile.push_back_int(comp, idata);
2311 ptile.push_back_int(comp, 0);
2320 host_particles.reserve(15);
2321 host_particles.resize(finestLevel()+1);
2324 std::vector<Gpu::HostVector<ParticleReal> > > > host_real_attribs;
2325 host_real_attribs.reserve(15);
2326 host_real_attribs.resize(finestLevel()+1);
2329 std::vector<Gpu::HostVector<int> > > > host_int_attribs;
2330 host_int_attribs.reserve(15);
2331 host_int_attribs.resize(finestLevel()+1);
2334 host_idcpu.reserve(15);
2335 host_idcpu.resize(finestLevel()+1);
2338 for (
int i = 0; i < nrcvs; ++i)
2340 const auto offset = rOffset[i];
2341 const auto Who = RcvProc[i];
2342 const auto Cnt = Rcvs[Who] / superparticle_size;
2343 for (
auto j =
decltype(Cnt)(0); j < Cnt; ++j)
2345 int lev = rcv_levs[ipart];
2346 std::pair<int, int> ind(std::make_pair(rcv_grid[ipart], rcv_tile[ipart]));
2348 char* pbuf = ((
char*) &recvdata[
offset]) + j*superparticle_size;
2350 host_real_attribs[lev][ind].resize(NumRealComps());
2351 host_int_attribs[lev][ind].resize(NumIntComps());
2353 if constexpr (ParticleType::is_soa_particle) {
2355 std::memcpy(&idcpudata, pbuf,
sizeof(uint64_t));
2356 pbuf +=
sizeof(uint64_t);
2357 host_idcpu[lev][ind].push_back(idcpudata);
2362 host_particles[lev][ind].push_back(p);
2365 host_real_attribs[lev][ind].resize(NumRealComps());
2366 host_int_attribs[lev][ind].resize(NumIntComps());
2369 int array_comp_start = 0;
2370 if constexpr (!ParticleType::is_soa_particle) {
2371 array_comp_start = AMREX_SPACEDIM + NStructReal;
2373 for (
int comp = 0; comp < NumRealComps(); ++comp) {
2374 if (h_redistribute_real_comp[array_comp_start + comp]) {
2376 std::memcpy(&rdata, pbuf,
sizeof(Real));
2377 pbuf +=
sizeof(Real);
2378 host_real_attribs[lev][ind][comp].push_back(rdata);
2380 host_real_attribs[lev][ind][comp].push_back(0.0);
2385 array_comp_start = 2 + NStructInt;
2386 for (
int comp = 0; comp < NumIntComps(); ++comp) {
2387 if (h_redistribute_int_comp[array_comp_start + comp]) {
2389 std::memcpy(&idata, pbuf,
sizeof(
int));
2390 pbuf +=
sizeof(
int);
2391 host_int_attribs[lev][ind][comp].push_back(idata);
2393 host_int_attribs[lev][ind][comp].push_back(0);
2400 for (
int host_lev = 0; host_lev < static_cast<int>(host_particles.
size()); ++host_lev)
2402 for (
auto& kv : host_particles[host_lev]) {
2403 auto grid = kv.first.first;
2404 auto tile = kv.first.second;
2405 const auto& src_tile = kv.second;
2407 auto& dst_tile = GetParticles(host_lev)[std::make_pair(grid,tile)];
2408 auto old_size = dst_tile.
size();
2409 auto new_size = old_size + src_tile.size();
2410 dst_tile.resize(new_size);
2412 if constexpr (ParticleType::is_soa_particle) {
2413 Gpu::copyAsync(Gpu::hostToDevice,
2414 host_idcpu[host_lev][std::make_pair(grid,tile)].
begin(),
2415 host_idcpu[host_lev][std::make_pair(grid,tile)].
end(),
2416 dst_tile.GetStructOfArrays().GetIdCPUData().begin() + old_size);
2418 Gpu::copyAsync(Gpu::hostToDevice,
2419 src_tile.begin(), src_tile.end(),
2420 dst_tile.GetArrayOfStructs().begin() + old_size);
2423 for (
int i = 0; i < NumRealComps(); ++i) {
2424 Gpu::copyAsync(Gpu::hostToDevice,
2425 host_real_attribs[host_lev][std::make_pair(grid,tile)][i].
begin(),
2426 host_real_attribs[host_lev][std::make_pair(grid,tile)][i].
end(),
2427 dst_tile.GetStructOfArrays().GetRealData(i).begin() + old_size);
2430 for (
int i = 0; i < NumIntComps(); ++i) {
2431 Gpu::copyAsync(Gpu::hostToDevice,
2432 host_int_attribs[host_lev][std::make_pair(grid,tile)][i].
begin(),
2433 host_int_attribs[host_lev][std::make_pair(grid,tile)][i].
end(),
2434 dst_tile.GetStructOfArrays().GetIntData(i).begin() + old_size);
2439 Gpu::Device::streamSynchronize();
2449template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
2450 template<
class>
class Allocator,
class CellAssignor>
2456 if (lev_max == -1) {
2457 lev_max = finestLevel();
2463template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
2464 template<
class>
class Allocator,
class CellAssignor>
2471 AddParticlesAtLevel(ptile, level, nGrow);
2474template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
2475 template<
class>
class Allocator,
class CellAssignor>
2480 BL_PROFILE(
"ParticleContainer::AddParticlesAtLevel()");
2482 if (
int(m_particles.size()) < level+1)
2486 amrex::Print() <<
"ParticleContainer::AddParticlesAtLevel resizing m_particles from "
2487 << m_particles.size()
2491 m_particles.resize(level+1);
2492 m_dummy_mf.resize(level+1);
2493 for (
int lev = 0; lev < level+1; ++lev) {
2494 RedefineDummyMF(lev);
2498 auto& ptile = DefineAndReturnParticleTile(level, 0, 0);
2499 int old_np = ptile.size();
2500 int num_to_add = particles.
size();
2501 int new_np = old_np + num_to_add;
2502 ptile.resize(new_np);
2504 Redistribute(level, level, nGrow);
2509template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
2510 template<
class>
class Allocator,
class CellAssignor>
2517 int particle_lvl_offset)
const
2519 BL_PROFILE(
"ParticleContainer::AssignCellDensitySingleLevel()");
2521 if (rho_index != 0) {
amrex::Abort(
"AssignCellDensitySingleLevel only works if rho_index = 0"); }
2525 if (OnSameGrids(lev, mf_to_be_filled)) {
2528 mf_pointer = &mf_to_be_filled;
2533 mf_pointer =
new MultiFab(ParticleBoxArray(lev),
2534 ParticleDistributionMap(lev),
2535 ncomp, mf_to_be_filled.
nGrow());
2542 if (mf_pointer->
nGrow() < 1) {
2543 amrex::Error(
"Must have at least one ghost cell when in AssignCellDensitySingleLevel");
2548 const auto dxi = Geom(lev).InvCellSizeArray();
2549 const auto plo = Geom(lev).ProbLoArray();
2550 const auto pdxi = Geom(lev + particle_lvl_offset).InvCellSizeArray();
2552 if (Geom(lev).isAnyPeriodic() && ! Geom(lev).isAllPeriodic())
2554 amrex::Error(
"AssignCellDensitySingleLevel: problem must be periodic in no or all directions");
2561#pragma omp parallel if (Gpu::notInLaunchRegion())
2566 const Long np = pti.numParticles();
2567 auto ptd = pti.GetParticleTile().getConstParticleTileData();
2569 auto rhoarr = fab.
array();
2572 if (Gpu::notInLaunchRegion())
2574 tile_box = pti.tilebox();
2576 local_rho.
resize(tile_box,ncomp);
2577 local_rho.
setVal<RunOn::Host>(0.0);
2578 rhoarr = local_rho.
array();
2582 if (particle_lvl_offset == 0)
2600 if (Gpu::notInLaunchRegion())
2602 fab.
atomicAdd<RunOn::Host>(local_rho, tile_box, tile_box, 0, 0, ncomp);
2613 for (
int n = 1; n < ncomp; n++)
2617 (*mf_pointer)[mfi].protected_divide<RunOn::Device>((*mf_pointer)[mfi],0,n,1);
2624 const Real* dx = Geom(lev).CellSize();
2627 mf_pointer->
mult(Real(1.0)/vol, 0, 1, mf_pointer->
nGrow());
2631 if (mf_pointer != &mf_to_be_filled)
2633 mf_to_be_filled.
ParallelCopy(*mf_pointer,0,0,ncomp,0,0);
2641 ParallelReduce::Max(stoptime, ParallelContext::IOProcessorNumberSub(),
2642 ParallelContext::CommunicatorSub());
2644 amrex::Print() <<
"ParticleContainer::AssignCellDensitySingleLevel) time: "
2645 << stoptime <<
'\n';
2649template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
2650 template<
class>
class Allocator,
class CellAssignor>
2655 int old_size = m_num_runtime_real;
2657 m_runtime_comps_defined = (new_size > 0);
2658 m_num_runtime_real = new_size;
2659 int cur_size = h_redistribute_real_comp.size();
2660 h_redistribute_real_comp.resize(cur_size-old_size+new_size, communicate);
2663 for (
int lev = 0; lev < numLevels(); ++lev) {
2665 auto& tile = DefineAndReturnParticleTile(lev, pti);
2666 auto np = tile.numParticles();
2667 if (np > 0 && new_size > old_size) {
2668 auto& soa = tile.GetStructOfArrays();
2675template <
typename ParticleType,
int NArrayReal,
int NArrayInt,
2676 template<
class>
class Allocator,
class CellAssignor>
2681 int old_size = m_num_runtime_int;
2683 m_runtime_comps_defined = (new_size > 0);
2684 m_num_runtime_int = new_size;
2685 int cur_size = h_redistribute_int_comp.size();
2686 h_redistribute_int_comp.resize(cur_size-old_size+new_size, communicate);
2689 for (
int lev = 0; lev < numLevels(); ++lev) {
2691 auto& tile = DefineAndReturnParticleTile(lev, pti);
2692 auto np = tile.numParticles();
2693 if (np > 0 && new_size > old_size) {
2694 auto& soa = tile.GetStructOfArrays();
#define BL_PROFILE_VAR_START(vname)
Definition AMReX_BLProfiler.H:562
#define BL_PROFILE(a)
Definition AMReX_BLProfiler.H:551
#define BL_PROFILE_VAR_STOP(vname)
Definition AMReX_BLProfiler.H:563
#define BL_PROFILE_SYNC_STOP()
Definition AMReX_BLProfiler.H:645
#define BL_PROFILE_SYNC_START_TIMED(fname)
Definition AMReX_BLProfiler.H:644
#define BL_PROFILE_VAR_NS(fname, vname)
Definition AMReX_BLProfiler.H:561
#define AMREX_ALWAYS_ASSERT_WITH_MESSAGE(EX, MSG)
Definition AMReX_BLassert.H:49
#define AMREX_ASSERT(EX)
Definition AMReX_BLassert.H:38
#define AMREX_ALWAYS_ASSERT(EX)
Definition AMReX_BLassert.H:50
#define AMREX_FORCE_INLINE
Definition AMReX_Extension.H:119
#define AMREX_FOR_1D(...)
Definition AMReX_GpuLaunchMacrosC.nolint.H:97
#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
amrex::ParmParse pp
Input file parser instance for the given namespace.
Definition AMReX_HypreIJIface.cpp:15
Array4< int const > offset
Definition AMReX_HypreMLABecLap.cpp:1089
#define AMREX_D_TERM(a, b, c)
Definition AMReX_SPACE.H:129
#define AMREX_D_DECL(a, b, c)
Definition AMReX_SPACE.H:104
Print on all processors of the default communicator.
Definition AMReX_Print.H:117
BaseFab< T > & atomicAdd(const BaseFab< T > &x) noexcept
Atomic FAB addition (a[i] <- a[i] + b[i]).
Definition AMReX_BaseFab.H:2954
AMREX_FORCE_INLINE Array4< T const > array() const noexcept
Definition AMReX_BaseFab.H:379
void setVal(T const &x, const Box &bx, int dcomp, int ncomp) noexcept
The setVal functions set sub-regions in the BaseFab to a constant value. This most general form speci...
Definition AMReX_BaseFab.H:1869
A collection of Boxes stored in an Array.
Definition AMReX_BoxArray.H:550
IndexType ixType() const noexcept
Return index type of this BoxArray.
Definition AMReX_BoxArray.H:837
BoxArray & grow(int n)
Grow each Box in the BoxArray by the specified amount.
std::vector< std::pair< int, Box > > intersections(const Box &bx) const
Return intersections of Box and BoxArray.
Box getCellCenteredBox(int index) const noexcept
Return cell-centered box at element index of this BoxArray.
Definition AMReX_BoxArray.H:730
A class for managing a List of Boxes that share a common IndexType. This class implements operations ...
Definition AMReX_BoxList.H:52
BoxList & complementIn(const Box &b, const BoxList &bl)
AMREX_GPU_HOST_DEVICE BoxND & grow(int i) noexcept
Definition AMReX_Box.H:627
AMREX_GPU_HOST_DEVICE bool contains(const IntVectND< dim > &p) const noexcept
Returns true if argument is contained within BoxND.
Definition AMReX_Box.H:204
GpuArray< Real, AMREX_SPACEDIM > InvCellSizeArray() const noexcept
Definition AMReX_CoordSys.H:87
A Fortran Array of REALs.
Definition AMReX_FArrayBox.H:229
void resize(const Box &b, int N=1, Arena *ar=nullptr)
For debugging purposes we hide BaseFab version and do some extra work.
Definition AMReX_FArrayBox.cpp:178
int size() const noexcept
Return the number of FABs in the FabArray.
Definition AMReX_FabArrayBase.H:109
int nGrow(int direction=0) const noexcept
Return the grow factor that defines the region of definition.
Definition AMReX_FabArrayBase.H:77
void ParallelCopy(const FabArray< FAB > &src, const Periodicity &period=Periodicity::NonPeriodic(), CpOp op=FabArrayBase::COPY)
Definition AMReX_FabArray.H:840
void SumBoundary(const Periodicity &period=Periodicity::NonPeriodic())
Sum values in overlapped cells. The destination is limited to valid cells.
Definition AMReX_FabArray.H:3174
Array4< typename FabArray< FAB >::value_type const > array(const MFIter &mfi) const noexcept
Definition AMReX_FabArray.H:560
void setVal(value_type val)
Set all components in the entire region of each FAB to val.
Definition AMReX_FabArray.H:2412
Rectangular problem domain geometry.
Definition AMReX_Geometry.H:73
const Box & Domain() const noexcept
Returns our rectangular domain.
Definition AMReX_Geometry.H:210
GpuArray< Real, AMREX_SPACEDIM > ProbLoArray() const noexcept
Definition AMReX_Geometry.H:186
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool cellCentered() const noexcept
True if the IndexTypeND is CELL based in all directions.
Definition AMReX_IndexType.H:101
AMREX_GPU_HOST_DEVICE static AMREX_FORCE_INLINE constexpr IntVectND< dim > TheZeroVector() noexcept
This static member function returns a reference to a constant IntVectND object, all of whose dim argu...
Definition AMReX_IntVect.H:670
a one-thingy-per-box distributed object
Definition AMReX_LayoutData.H:13
Definition AMReX_MFIter.H:57
int LocalTileIndex() const noexcept
The current local tile index in the current grid;.
Definition AMReX_MFIter.H:150
bool isValid() const noexcept
Is the iterator valid i.e. is it associated with a FAB?
Definition AMReX_MFIter.H:141
Box validbox() const noexcept
Return the valid Box in which the current tile resides.
Definition AMReX_MFIter.H:132
int index() const noexcept
The index into the underlying BoxArray of the current FAB.
Definition AMReX_MFIter.H:144
A collection (stored as an array) of FArrayBox objects.
Definition AMReX_MultiFab.H:38
void mult(Real val, int comp, int num_comp, int nghost=0)
Scales the value of each cell in the specified subregion of the MultiFab by the scalar val (a[i] <- a...
Definition AMReX_MultiFab.cpp:1460
Definition AMReX_PODVector.H:262
size_type size() const noexcept
Definition AMReX_PODVector.H:591
T * dataPtr() noexcept
Definition AMReX_PODVector.H:613
void resize(size_type a_new_size)
Definition AMReX_PODVector.H:641
T * data() noexcept
Definition AMReX_PODVector.H:609
Definition AMReX_ParIter.H:142
Definition AMReX_ParIter.H:113
Parse Parameters From Command Line and Input Files.
Definition AMReX_ParmParse.H:320
int queryarr(const char *name, std::vector< int > &ref, int start_ix=FIRST, int num_val=ALL) const
Same as queryktharr() but searches for last occurrence of name.
Definition AMReX_ParmParse.cpp:1378
int queryAdd(const char *name, T &ref)
If name is found, the value in the ParmParse database will be stored in the ref argument....
Definition AMReX_ParmParse.H:1014
int query(const char *name, bool &ref, int ival=FIRST) const
Same as querykth() but searches for the last occurrence of name.
Definition AMReX_ParmParse.cpp:1311
virtual void reserveData()
Definition AMReX_ParticleContainerBase.cpp:41
virtual void resizeData()
Definition AMReX_ParticleContainerBase.cpp:46
A distributed container for Particles sorted onto the levels, grids, and tiles of a block-structured ...
Definition AMReX_ParticleContainer.H:146
IntVect Index(const P &p, int lev) const
Definition AMReX_ParticleContainerI.H:201
std::map< std::pair< int, int >, ParticleTileType > ParticleLevel
Definition AMReX_ParticleContainer.H:187
void SetSoACompileTimeNames(std::vector< std::string > const &rdata_name, std::vector< std::string > const &idata_name)
Definition AMReX_ParticleContainerI.H:109
typename ParticleTileType::AoS AoS
Definition AMReX_ParticleContainer.H:188
typename SoA::RealVector RealVector
Definition AMReX_ParticleContainer.H:191
void locateParticle(P &p, ParticleLocData &pld, int lev_min, int lev_max, int nGrow, int local_grid=-1) const
Definition AMReX_ParticleContainerI.H:446
void SetParticleSize()
Definition AMReX_ParticleContainerI.H:16
void RemoveParticlesAtLevel(int level)
The Following methods are for managing Virtual and Ghost Particles.
Definition AMReX_ParticleContainerI.H:738
void Increment(MultiFab &mf, int level)
Definition AMReX_ParticleContainerI.H:701
bool HasIntComp(std::string const &name)
Definition AMReX_ParticleContainerI.H:148
void ShrinkToFit()
Definition AMReX_ParticleContainerI.H:681
bool HasRealComp(std::string const &name)
Definition AMReX_ParticleContainerI.H:140
void resizeData() override
This resizes the vector of dummy MultiFabs used by the ParticleContainer for the current number of le...
Definition AMReX_ParticleContainerI.H:435
Long IncrementWithTotal(MultiFab &mf, int level, bool local=false)
Definition AMReX_ParticleContainerI.H:728
Long NumberOfParticlesAtLevel(int level, bool only_valid=true, bool only_local=false) const
Returns # of particles at specified the level.
Definition AMReX_ParticleContainerI.H:551
typename Particle< NStructReal, NStructInt >::RealType RealType
The type of the Real data.
Definition AMReX_ParticleContainer.H:173
int GetRealCompIndex(std::string const &name)
Definition AMReX_ParticleContainerI.H:161
int GetIntCompIndex(std::string const &name)
Definition AMReX_ParticleContainerI.H:183
void RemoveParticlesNotAtFinestLevel()
Definition AMReX_ParticleContainerI.H:752
Vector< Long > NumberOfParticlesInGrid(int level, bool only_valid=true, bool only_local=false) const
Definition AMReX_ParticleContainerI.H:496
typename SoA::IntVector IntVector
Definition AMReX_ParticleContainer.H:192
ParticleLocData Reset(ParticleType &prt, bool update, bool verbose=true, ParticleLocData pld=ParticleLocData()) const
Updates a particle's location (Where), tries to periodic shift any particles that have left the domai...
Definition AMReX_ParticleContainerI.H:392
Long TotalNumberOfParticles(bool only_valid=true, bool only_local=false) const
Returns # of particles at all levels.
Definition AMReX_ParticleContainerI.H:481
void reserveData() override
This reserves data in the vector of dummy MultiFabs used by the ParticleContainer for the maximum num...
Definition AMReX_ParticleContainerI.H:426
T_ParticleType ParticleType
Definition AMReX_ParticleContainer.H:148
Definition AMReX_ParticleLocator.H:104
AssignGrid< BinIteratorFactory > getGridAssignor() const noexcept
Definition AMReX_ParticleLocator.H:183
void build(const BoxArray &ba, const Geometry &geom)
Definition AMReX_ParticleLocator.H:111
This class provides the user with a few print options.
Definition AMReX_Print.H:35
Definition AMReX_Reduce.H:249
Definition AMReX_Reduce.H:364
std::enable_if_t< IsFabArray< MF >::value > eval(MF const &mf, IntVect const &nghost, D &reduce_data, F &&f)
Definition AMReX_Reduce.H:441
This class is a thin wrapper around std::vector. Unlike vector, Vector::operator[] provides bound che...
Definition AMReX_Vector.H:27
Long size() const noexcept
Definition AMReX_Vector.H:50
Definition AMReX_iMultiFab.H:32
Long sum(int comp, int nghost=0, bool local=false) const
Returns the sum in component comp.
Definition AMReX_iMultiFab.cpp:392
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void AddNoRet(T *sum, T value) noexcept
Definition AMReX_GpuAtomic.H:281
void streamSynchronize() noexcept
Definition AMReX_GpuDevice.H:237
void QueueReduction(Func f)
Definition AMReX_Lazy.cpp:7
constexpr Long VirtualParticleID
Definition AMReX_Particle.H:19
void Sum(T &v, MPI_Comm comm)
Definition AMReX_ParallelReduce.H:204
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
int IOProcessorNumberSub() noexcept
IO sub-rank in current frame.
Definition AMReX_ParallelContext.H:78
void Bcast(void *, int, MPI_Datatype, int, MPI_Comm)
Definition AMReX_ParallelDescriptor.cpp:1285
void GatherLayoutDataToVector(const LayoutData< T > &sendbuf, Vector< T > &recvbuf, int root)
Gather LayoutData values to a vector on root.
Definition AMReX_ParallelDescriptor.H:1211
void Min(KeyValuePair< K, V > &vi, int root, MPI_Comm comm)
Definition AMReX_ParallelReduce.H:263
void Max(KeyValuePair< K, V > &vi, int root, MPI_Comm comm)
Definition AMReX_ParallelReduce.H:232
void Sum(T &v, int root, MPI_Comm comm)
Definition AMReX_ParallelReduce.H:320
T ExclusiveSum(N n, T const *in, T *out, RetSum a_ret_sum=retSum)
Definition AMReX_Scan.H:1229
static constexpr RetSum retSum
Definition AMReX_Scan.H:29
Definition AMReX_Amr.cpp:49
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void amrex_deposit_cic(P const &p, int nc, amrex::Array4< amrex::Real > const &rho, amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > const &plo, amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > const &dxi)
Definition AMReX_Particle_mod_K.H:13
int nComp(FabArrayBase const &fa)
void communicateParticlesStart(const PC &pc, ParticleCopyPlan &plan, const SndBuffer &snd_buffer, RcvBuffer &rcv_buffer)
Definition AMReX_ParticleCommunication.H:500
std::enable_if_t< std::is_integral_v< T > > ParallelFor(TypeList< CTOs... > ctos, std::array< int, sizeof...(CTOs)> const &runtime_options, T N, F &&f)
Definition AMReX_CTOParallelForImpl.H:191
BoxND< AMREX_SPACEDIM > Box
Definition AMReX_BaseFwd.H:27
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE IntVect getParticleCell(P const &p, amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > const &plo, amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > const &dxi) noexcept
Returns the cell index for a given particle using the provided lower bounds and cell sizes.
Definition AMReX_ParticleUtil.H:374
int partitionParticlesByDest(PTile &ptile, const PLocator &ploc, CellAssignor const &assignor, const ParticleBufferMap &pmap, const GpuArray< Real, AMREX_SPACEDIM > &plo, const GpuArray< Real, AMREX_SPACEDIM > &phi, const GpuArray< ParticleReal, AMREX_SPACEDIM > &rlo, const GpuArray< ParticleReal, AMREX_SPACEDIM > &rhi, const GpuArray< int, AMREX_SPACEDIM > &is_per, int lev, int gid, int, int lev_min, int lev_max, int nGrow, bool remove_negative)
Definition AMReX_ParticleUtil.H:625
void unpackRemotes(PC &pc, const ParticleCopyPlan &plan, Buffer &rcv_buffer, UnpackPolicy const &policy)
Definition AMReX_ParticleCommunication.H:600
void copyParticles(DstTile &dst, const SrcTile &src) noexcept
Copy particles from src to dst. This version copies all the particles, writing them to the beginning ...
Definition AMReX_ParticleTransformation.H:158
Long doHandShake(const std::map< int, Vector< char > > ¬_ours, Vector< Long > &Snds, Vector< Long > &Rcvs)
Definition AMReX_ParticleMPIUtil.cpp:25
Index filterAndTransformParticles(DstTile &dst, const SrcTile &src, Index *mask, F const &f, Index src_start, Index dst_start) noexcept
Conditionally copy particles from src to dst based on the value of mask. A transformation will also b...
Definition AMReX_ParticleTransformation.H:449
bool initialized
Definition AMReX_DistributionMapping.cpp:32
Long doHandShakeLocal(const std::map< int, Vector< char > > ¬_ours, const Vector< int > &neighbor_procs, Vector< Long > &Snds, Vector< Long > &Rcvs)
Definition AMReX_ParticleMPIUtil.cpp:50
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE Dim3 end(BoxND< dim > const &box) noexcept
Definition AMReX_Box.H:1890
double second() noexcept
Definition AMReX_Utility.cpp:922
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int numTilesInBox(const Box &box, const bool a_do_tiling, const IntVect &a_tile_size)
Definition AMReX_ParticleUtil.H:270
void communicateParticlesFinish(const ParticleCopyPlan &plan)
Definition AMReX_ParticleCommunication.cpp:384
Arena * The_Comms_Arena()
Definition AMReX_Arena.cpp:676
Index filterParticles(DstTile &dst, const SrcTile &src, const Index *mask) noexcept
Conditionally copy particles from src to dst based on the value of mask.
Definition AMReX_ParticleTransformation.H:325
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE BoxND< dim > grow(const BoxND< dim > &b, int i) noexcept
Grow BoxND in all directions by given amount.
Definition AMReX_Box.H:1211
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool enforcePeriodic(P &p, amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > const &plo, amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > const &phi, amrex::GpuArray< amrex::ParticleReal, AMREX_SPACEDIM > const &rlo, amrex::GpuArray< amrex::ParticleReal, AMREX_SPACEDIM > const &rhi, amrex::GpuArray< int, AMREX_SPACEDIM > const &is_per) noexcept
Definition AMReX_ParticleUtil.H:459
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void ignore_unused(const Ts &...)
This shuts up the compiler about unused variables.
Definition AMReX.H:127
void ParticleToMesh(PC const &pc, const Vector< MultiFab * > &mf, int lev_min, int lev_max, F &&f, bool zero_out_input=true, bool vol_weight=true)
Definition AMReX_AmrParticles.H:156
void Error(const std::string &msg)
Print out message to cerr and exit via amrex::Abort().
Definition AMReX.cpp:224
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void amrex_deposit_particle_dx_cic(P const &p, int nc, amrex::Array4< amrex::Real > const &rho, amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > const &plo, amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > const &dxi, amrex::GpuArray< amrex::Real, AMREX_SPACEDIM > const &pdxi)
Definition AMReX_Particle_mod_K.H:118
void gatherParticles(PTile &dst, const PTile &src, N np, const Index *inds)
Gather particles copies particles into contiguous order from an arbitrary order. Specifically,...
Definition AMReX_ParticleTransformation.H:666
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE Dim3 begin(BoxND< dim > const &box) noexcept
Definition AMReX_Box.H:1881
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:34
int Verbose() noexcept
Definition AMReX.cpp:169
void Abort(const std::string &msg)
Print out message to cerr and exit via abort().
Definition AMReX.cpp:230
const int[]
Definition AMReX_BLProfiler.cpp:1664
int verbose
Definition AMReX_DistributionMapping.cpp:36
void transformParticles(DstTile &dst, const SrcTile &src, F &&f) noexcept
Apply the function f to all the particles in src, writing the result to dst. This version does all th...
Definition AMReX_ParticleTransformation.H:210
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int getTileIndex(const IntVect &iv, const Box &box, const bool a_do_tiling, const IntVect &a_tile_size, Box &tbx)
Definition AMReX_ParticleUtil.H:222
void unpackBuffer(PC &pc, const ParticleCopyPlan &plan, const Buffer &snd_buffer, UnpackPolicy const &policy)
Definition AMReX_ParticleCommunication.H:435
void packBuffer(const PC &pc, const ParticleCopyOp &op, const ParticleCopyPlan &plan, Buffer &snd_buffer)
Definition AMReX_ParticleCommunication.H:336
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE void copyParticle(const ParticleTileData< T_ParticleType, NAR, NAI > &dst, const ConstParticleTileData< T_ParticleType, NAR, NAI > &src, int src_i, int dst_i) noexcept
A general single particle copying routine that can run on the GPU.
Definition AMReX_ParticleTransformation.H:31
Definition AMReX_ParticleLocator.H:216
Definition AMReX_Array4.H:61
Definition AMReX_ParticleContainerI.H:1016
amrex::AmrAssignGrid< amrex::DenseBinIteratorFactory< amrex::Box > > m_assign_grid
Definition AMReX_ParticleContainerI.H:1019
int m_lev_max
Definition AMReX_ParticleContainerI.H:1018
AssignGridFilter(amrex::AmrAssignGrid< amrex::DenseBinIteratorFactory< amrex::Box > > assign_grid, int gid, int level, int nGrow)
This filters based on matching grids.
Definition AMReX_ParticleContainerI.H:1025
int m_nGrow
Definition AMReX_ParticleContainerI.H:1018
int m_lev_min
Definition AMReX_ParticleContainerI.H:1018
AMREX_GPU_HOST_DEVICE int operator()(const SrcData &src, int src_i) const noexcept
Definition AMReX_ParticleContainerI.H:1031
int m_gid
Definition AMReX_ParticleContainerI.H:1018
Definition AMReX_ParticleLocator.H:14
Definition AMReX_ParticleTile.H:501
Definition AMReX_ParticleUtil.H:432
Definition AMReX_DenseBins.H:32
Definition AMReX_ParticleContainerI.H:780
GpuArray< Real, AMREX_SPACEDIM > m_dxi
Definition AMReX_ParticleContainerI.H:783
Box m_domain
Definition AMReX_ParticleContainerI.H:784
FilterVirt(const amrex::AssignGrid< amrex::DenseBinIteratorFactory< amrex::Box > > &assign_buffer_grid, const GpuArray< Real, AMREX_SPACEDIM > &plo, const GpuArray< Real, AMREX_SPACEDIM > &dxi, const Box &domain)
Definition AMReX_ParticleContainerI.H:786
GpuArray< Real, AMREX_SPACEDIM > m_plo
Definition AMReX_ParticleContainerI.H:783
AMREX_GPU_HOST_DEVICE int operator()(const SrcData &src, int src_i) const noexcept
Definition AMReX_ParticleContainerI.H:793
amrex::AssignGrid< amrex::DenseBinIteratorFactory< amrex::Box > > m_assign_buffer_grid
Definition AMReX_ParticleContainerI.H:782
Definition AMReX_ParticleUtil.H:341
Definition AMReX_Array.H:34
uint64_t m_idcpu
Definition AMReX_Particle.H:252
Definition AMReX_ParticleCommunication.H:58
void setNumLevels(int num_levels)
Definition AMReX_ParticleCommunication.cpp:14
Vector< std::map< int, Gpu::DeviceVector< IntVect > > > m_periodic_shift
Definition AMReX_ParticleCommunication.H:62
Vector< std::map< int, Gpu::DeviceVector< int > > > m_boxes
Definition AMReX_ParticleCommunication.H:59
Vector< std::map< int, Gpu::DeviceVector< int > > > m_levels
Definition AMReX_ParticleCommunication.H:60
Vector< std::map< int, Gpu::DeviceVector< int > > > m_src_indices
Definition AMReX_ParticleCommunication.H:61
void resize(int gid, int lev, int size)
Definition AMReX_ParticleCommunication.cpp:22
Definition AMReX_ParticleCommunication.H:81
void buildMPIFinish(const ParticleBufferMap &map)
Definition AMReX_ParticleCommunication.cpp:213
void build(const PC &pc, const ParticleCopyOp &op, const Vector< int > &int_comp_mask, const Vector< int > &real_comp_mask, bool local)
Definition AMReX_ParticleCommunication.H:131
A struct used for storing a particle's position in the AMR hierarchy.
Definition AMReX_ParticleContainer.H:92
Box m_grown_gridbox
Definition AMReX_ParticleContainer.H:99
IntVect m_cell
Definition AMReX_ParticleContainer.H:96
int m_grid
Definition AMReX_ParticleContainer.H:94
int m_tile
Definition AMReX_ParticleContainer.H:95
int m_lev
Definition AMReX_ParticleContainer.H:93
Box m_tilebox
Definition AMReX_ParticleContainer.H:98
Box m_gridbox
Definition AMReX_ParticleContainer.H:97
Definition AMReX_ParticleTile.H:702
std::size_t size() const
Returns the total number of particles (real and neighbor)
Definition AMReX_ParticleTile.H:832
ParticleTileDataType getParticleTileData()
Definition AMReX_ParticleTile.H:1137
int numParticles() const
Returns the number of real particles (excluding neighbors)
Definition AMReX_ParticleTile.H:845
AoS & GetArrayOfStructs()
Definition AMReX_ParticleTile.H:820
void resize(std::size_t count)
Definition AMReX_ParticleTile.H:911
bool empty() const
Definition AMReX_ParticleTile.H:826
The struct used to store particles.
Definition AMReX_Particle.H:295
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE ParticleIDWrapper id() &
Definition AMReX_Particle.H:315
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE RealVect pos() const &
Definition AMReX_Particle.H:338
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE RealType & rdata(int index) &
Definition AMReX_Particle.H:356
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE ParticleCPUWrapper cpu() &
Definition AMReX_Particle.H:312
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE int & idata(int index) &
Definition AMReX_Particle.H:427
Definition AMReX_MakeParticle.H:18