1#ifndef AMREX_WRITE_BINARY_PARTICLE_DATA_H
2#define AMREX_WRITE_BINARY_PARTICLE_DATA_H
3#include <AMReX_Config.H>
14 template <
typename SrcData>
16 int operator() (
const SrcData& src,
int i)
const noexcept
18 return (src.id(i).is_valid());
23namespace particle_detail {
25template <
typename ParticleReal>
26std::size_t PSizeInFile (
const Vector<int>& wrc,
const Vector<int>& wic)
28 std::size_t rsize =
sizeof(ParticleReal)*std::accumulate(wrc.begin(), wrc.end(), 0);
29 std::size_t isize =
sizeof(int)*std::accumulate(wic.begin(), wic.end(), 0);
30 return rsize + isize + AMREX_SPACEDIM*
sizeof(ParticleReal) + 2*
sizeof(
int);
33template <
class Container,
37fillFlagsGpu (Container& pflags,
const PTile& ptile, F
const& f)
39 const auto& ptd = ptile.getConstParticleTileData();
40 const auto np = ptile.numParticles();
42 auto flag_ptr = pflags.data();
46 const auto p = ptd.getSuperParticle(k);
48 if constexpr (IsCallable<
F,
decltype(
p),RandomEngine>::value) {
49 flag_ptr[k] = f(
p,engine);
50 }
else if constexpr (IsCallable<
F,
decltype(
p)>::value) {
52 }
else if constexpr (IsCallable<
F,
decltype(ptd),
int,RandomEngine>::value) {
53 flag_ptr[k] = f(ptd,k,engine);
55 flag_ptr[k] = f(ptd,k);
60template <
class Container,
64fillFlagsCpu (Container& pflags,
const PTile& ptile, F
const& f)
66 const auto& ptd = ptile.getConstParticleTileData();
67 const auto np = ptile.numParticles();
69 auto flag_ptr = pflags.data();
70 for (
int k = 0; k < np; ++k) {
71 const auto p = ptd.getSuperParticle(k);
72 if constexpr (IsCallable<
F,
decltype(
p),RandomEngine>::value) {
74 }
else if constexpr (IsCallable<
F,
decltype(
p)>::value) {
76 }
else if constexpr (IsCallable<
F,
decltype(ptd),
int,RandomEngine>::value) {
79 flag_ptr[k] = f(ptd,k);
84template <
template <
class,
class>
class Container,
89fillFlags (Container<int, Allocator>& pflags,
const PTile& ptile, F
const& f)
91 if constexpr (IsPolymorphicArenaAllocator<Allocator>::value) {
92 if (pflags.arena()->isManaged() || pflags.arena()->isDevice()) {
93 fillFlagsGpu(pflags, ptile, f);
95 fillFlagsCpu(pflags, ptile, f);
98 if constexpr (RunOnGpu<Allocator>::value) {
99 fillFlagsGpu(pflags, ptile, f);
101 fillFlagsCpu(pflags, ptile, f);
106template <
class Container,
class PC>
108countFlagsGpu (
const Vector<std::map<std::pair<int,int>,Container>>& particle_io_flags,
const PC& pc)
110 ReduceOps<ReduceOpSum> reduce_op;
111 ReduceData<Long> reduce_data(reduce_op);
112 using ReduceTuple =
typename decltype(reduce_data)::Type;
114 for (
int lev = 0; lev < pc.GetParticles().size(); lev++)
116 const auto& pmap = pc.GetParticles(lev);
117 for (
const auto& kv : pmap)
119 const auto& pflags = particle_io_flags[lev].at(kv.first);
120 const auto flag_ptr = pflags.data();
121 reduce_op.eval(pflags.size(), reduce_data,
124 return flag_ptr[i] ? 1 : 0;
128 ReduceTuple hv = reduce_data.value(reduce_op);
132template <
class Container>
134countFlagsGpu (
const Container& pflags)
136 ReduceOps<ReduceOpSum> reduce_op;
137 ReduceData<Long> reduce_data(reduce_op);
138 using ReduceTuple =
typename decltype(reduce_data)::Type;
140 const auto flag_ptr = pflags.data();
141 reduce_op.eval(pflags.size(), reduce_data,
144 return flag_ptr[i] ? 1 : 0;
146 ReduceTuple hv = reduce_data.value(reduce_op);
150template <
class Container,
class PC>
152countFlagsCpu (
const Vector<std::map<std::pair<int,int>,Container>>& particle_io_flags,
const PC& pc)
155 for (
int lev = 0; lev < pc.GetParticles().size(); lev++)
157 const auto& pmap = pc.GetParticles(lev);
158 for (
const auto& kv : pmap)
160 const auto& pflags = particle_io_flags[lev].at(kv.first);
161 for (
int k = 0; k < kv.second.numParticles(); ++k)
163 if (pflags[k]) { nparticles++; }
170template <
class Container>
172countFlagsCpu (
const Container& pflags)
175 for (std::size_t k = 0; k < pflags.size(); ++k)
177 if (pflags[k]) { nparticles++; }
182template <
template <
class,
class>
class Container,
class Allocator,
class PC>
184countFlags (
const Vector<std::map<std::pair<int,int>,Container<int,Allocator>>>& particle_io_flags,
const PC& pc)
186 if constexpr (IsPolymorphicArenaAllocator<Allocator>::value) {
187 if (pc.arena()->isManaged() || pc.arena()->isDevice()) {
188 return countFlagsGpu(particle_io_flags, pc);
190 return countFlagsCpu(particle_io_flags, pc);
193 if constexpr (RunOnGpu<Allocator>::value) {
194 return countFlagsGpu(particle_io_flags, pc);
196 return countFlagsCpu(particle_io_flags, pc);
201template <
template <
class,
class>
class Container,
class Allocator>
203countFlags (
const Container<int,Allocator>& pflags)
205 if constexpr (IsPolymorphicArenaAllocator<Allocator>::value) {
206 if (pflags.arena()->isManaged() || pflags.arena()->isDevice()) {
207 return countFlagsGpu(pflags);
209 return countFlagsCpu(pflags);
212 if constexpr (RunOnGpu<Allocator>::value) {
213 return countFlagsGpu(pflags);
215 return countFlagsCpu(pflags);
220template <
typename Int>
222void packParticleIDs (Int* idata,
const std::uint64_t idcpu,
bool is_checkpoint)
noexcept
226 std::uint32_t xu, yu;
227 xu = (std::uint32_t)((idcpu & 0xFFFFFFFF00000000LL) >> 32);
228 yu = (std::uint32_t)( idcpu & 0xFFFFFFFFLL);
234 idata[0] = ConstParticleIDWrapper{idcpu};
235 idata[1] = ConstParticleCPUWrapper{idcpu};
241rPackParticleData (
const PTD& ptd,
int idx, std::remove_const_t<typename PTD::RealType> * rdata_ptr,
242 const int * write_real_comp)
244 std::size_t rout_index = 0;
246 if constexpr (!PTD::ParticleType::is_rtsoa_particle) {
247 for (
int j = 0; j < AMREX_SPACEDIM; ++j) {
248 rdata_ptr[rout_index] = ptd.pos(j, idx);
252 if constexpr (!PTD::ParticleType::is_soa_particle) {
253 const auto&
p = ptd[idx];
255 for (
int j = 0; j < PTD::ParticleType::NReal; ++j) {
256 if (write_real_comp[j]) {
257 rdata_ptr[rout_index] =
p.rdata(j);
263 constexpr int real_start_offset = PTD::ParticleType::is_soa_particle ? AMREX_SPACEDIM : 0;
265 if constexpr (PTD::NAR > 0) {
266 for (
int j = real_start_offset; j < PTD::NAR; ++j) {
267 if (write_real_comp[PTD::ParticleType::NReal + j - real_start_offset]) {
268 rdata_ptr[rout_index] = ptd.rdata(j)[idx];
274 for (
int j = 0; j < ptd.m_num_runtime_real; ++j) {
275 if (write_real_comp[PTD::ParticleType::NReal + PTD::NAR + j - real_start_offset]) {
276 rdata_ptr[rout_index] = ptd.m_runtime_rdata[j][idx];
281 for (
int j = 0; j < ptd.m_n_real; ++j) {
282 if ((j < AMREX_SPACEDIM) || write_real_comp[j - AMREX_SPACEDIM]) {
283 rdata_ptr[rout_index] = ptd.rdata(j)[idx];
292iPackParticleData (
const PTD& ptd,
int idx, std::remove_const_t<typename PTD::IntType> * idata_ptr,
293 const int * write_int_comp,
bool is_checkpoint)
295 std::size_t iout_index = 0;
297 packParticleIDs(&idata_ptr[iout_index], ptd.idcpu(idx), is_checkpoint);
300 if constexpr (!PTD::ParticleType::is_rtsoa_particle) {
301 if constexpr (!PTD::ParticleType::is_soa_particle) {
302 const auto&
p = ptd[idx];
304 for (
int j = 0; j < PTD::ParticleType::NInt; ++j) {
305 if (write_int_comp[j]) {
306 idata_ptr[iout_index] =
p.idata(j);
312 if constexpr (PTD::NAI > 0) {
313 for (
int j = 0; j < PTD::NAI; ++j) {
314 if (write_int_comp[PTD::ParticleType::NInt + j]) {
315 idata_ptr[iout_index] = ptd.idata(j)[idx];
321 for (
int j = 0; j < ptd.m_num_runtime_int; ++j) {
322 if (write_int_comp[PTD::ParticleType::NInt + PTD::NAI + j]) {
323 idata_ptr[iout_index] = ptd.m_runtime_idata[j][idx];
328 for (
int j = 0; j < ptd.m_n_int; ++j) {
329 if (write_int_comp[j]) {
330 idata_ptr[iout_index] = ptd.idata(j)[idx];
339packIODataGpu (Vector<int>& idata, Vector<ParticleReal>& rdata,
const PC& pc,
int lev,
int grid,
340 const Vector<int>& write_real_comp,
const Vector<int>& write_int_comp,
341 const Vector<std::map<std::pair<int, int>,
typename PC::FlagsVector>>& particle_io_flags,
342 const Vector<int>& tiles,
int np,
bool is_checkpoint)
344 int num_output_int = 0;
345 for (
int i = 0; i < pc.NumIntComps() + PC::NStructInt; ++i) {
346 if (write_int_comp[i]) { ++num_output_int; }
349 const Long iChunkSize = 2 + num_output_int;
350 idata.resize(np*iChunkSize);
352 int num_output_real = 0;
353 for (
int i : write_real_comp) {
354 if (i) { ++num_output_real; }
357 const Long rChunkSize = AMREX_SPACEDIM + num_output_real;
358 rdata.resize(np*rChunkSize);
360 Gpu::DeviceVector<int> write_int_comp_d(write_int_comp.size());
361 Gpu::DeviceVector<int> write_real_comp_d(write_real_comp.size());
362 Gpu::copyAsync(Gpu::hostToDevice, write_int_comp.begin(), write_int_comp.end(),
363 write_int_comp_d.begin());
364 Gpu::copyAsync(Gpu::hostToDevice, write_real_comp.begin(), write_real_comp.end(),
365 write_real_comp_d.begin());
367 const auto* write_int_comp_d_ptr = write_int_comp_d.data();
368 const auto* write_real_comp_d_ptr = write_real_comp_d.data();
370 std::size_t poffset = 0;
371 for (
int tile : tiles) {
372 const auto& ptile = pc.ParticlesAt(lev, grid, tile);
373 const auto& pflags = particle_io_flags[lev].at(std::make_pair(grid, tile));
374 int np_tile = ptile.numParticles();
375 Gpu::DeviceVector<int> offsets(np_tile);
376 int num_copies = Scan::ExclusiveSum(np_tile, pflags.begin(), offsets.begin(), Scan::retSum);
378 Gpu::DeviceVector<int> idata_d(num_copies*iChunkSize);
379 Gpu::DeviceVector<ParticleReal> rdata_d(num_copies*rChunkSize);
381 const auto* flag_ptr = pflags.data();
382 const auto* offset_ptr = offsets.data();
384 auto* idata_d_ptr = idata_d.data();
385 auto* rdata_d_ptr = rdata_d.data();
387 const auto& ptd = ptile.getConstParticleTileData();
391 if (flag_ptr[pindex]) {
392 const int out_indx = offset_ptr[pindex];
393 iPackParticleData(ptd, pindex, idata_d_ptr + out_indx * iChunkSize,
394 write_int_comp_d_ptr, is_checkpoint);
396 rPackParticleData(ptd, pindex, rdata_d_ptr + out_indx * rChunkSize,
397 write_real_comp_d_ptr);
401 Gpu::copyAsync(Gpu::deviceToHost, idata_d.begin(), idata_d.end(),
402 idata.begin() +
static_cast<Long>(poffset * iChunkSize));
403 Gpu::copyAsync(Gpu::deviceToHost, rdata_d.begin(), rdata_d.end(),
404 rdata.begin() +
static_cast<Long>(poffset * rChunkSize));
405 Gpu::Device::streamSynchronize();
407 poffset += num_copies;
413packIODataCpu (Vector<int>& idata, Vector<ParticleReal>& rdata,
const PC& pc,
int lev,
int grid,
414 const Vector<int>& write_real_comp,
const Vector<int>& write_int_comp,
415 const Vector<std::map<std::pair<int, int>,
typename PC::FlagsVector>>& particle_io_flags,
416 const Vector<int>& tiles,
int np,
bool is_checkpoint)
418 int num_output_int = 0;
419 for (
int i = 0; i < pc.NumIntComps() + PC::NStructInt; ++i) {
420 if (write_int_comp[i]) { ++num_output_int; }
423 const Long iChunkSize = 2 + num_output_int;
424 idata.resize(np*iChunkSize);
426 int num_output_real = 0;
427 for (
int i : write_real_comp) {
428 if (i) { ++num_output_real; }
431 const Long rChunkSize = AMREX_SPACEDIM + num_output_real;
432 rdata.resize(np*rChunkSize);
434 int* iptr = idata.dataPtr();
436 for (
int tile : tiles) {
437 const auto& ptile = pc.ParticlesAt(lev, grid, tile);
438 const auto& pflags = particle_io_flags[lev].at(std::make_pair(grid, tile));
439 const auto& ptd = ptile.getConstParticleTileData();
441 for (
int pindex = 0; pindex < ptile.numParticles(); ++pindex) {
442 if (pflags[pindex]) {
443 iPackParticleData(ptd, pindex, iptr,
444 write_int_comp.dataPtr(), is_checkpoint);
447 rPackParticleData(ptd, pindex, rptr,
448 write_real_comp.dataPtr());
457packIOData (Vector<int>& idata, Vector<ParticleReal>& rdata,
const PC& pc,
int lev,
int grid,
458 const Vector<int>& write_real_comp,
const Vector<int>& write_int_comp,
459 const Vector<std::map<std::pair<int, int>,
typename PC::FlagsVector>>& particle_io_flags,
460 const Vector<int>& tiles,
int np,
bool is_checkpoint)
462 if constexpr (IsPolymorphicArenaAllocator<typename PC::FlagsVector::allocator_type>::value) {
463 if (pc.arena()->isManaged() || pc.arena()->isDevice()) {
464 packIODataGpu(idata, rdata, pc, lev, grid, write_real_comp, write_int_comp,
465 particle_io_flags, tiles, np, is_checkpoint);
467 packIODataCpu(idata, rdata, pc, lev, grid, write_real_comp, write_int_comp,
468 particle_io_flags, tiles, np, is_checkpoint);
471 if constexpr (RunOnGpu<typename PC::FlagsVector::allocator_type>::value) {
472 packIODataGpu(idata, rdata, pc, lev, grid, write_real_comp, write_int_comp,
473 particle_io_flags, tiles, np, is_checkpoint);
475 packIODataCpu(idata, rdata, pc, lev, grid, write_real_comp, write_int_comp,
476 particle_io_flags, tiles, np, is_checkpoint);
484template <
class PC,
class F>
487 const std::string& dir,
const std::string& name,
492 F const& f,
bool is_checkpoint)
499 AMREX_ASSERT(
sizeof(
typename PC::ParticleType::RealType) == 4 ||
500 sizeof(
typename PC::ParticleType::RealType) == 8);
502 constexpr int NStructReal = PC::NStructReal;
503 constexpr int NStructInt = PC::NStructInt;
508 if constexpr(PC::ParticleType::is_soa_particle) {
515 std::string pdir = dir;
516 if ( ! pdir.empty() && pdir[pdir.size()-1] !=
'/') { pdir +=
'/'; }
519 if ( ! pc.GetLevelDirectoriesCreated()) {
530 std::ofstream HdrFile;
537 particle_io_flags(pc.GetParticles().size());
539 for (
int lev = 0; lev < pc.GetParticles().size(); lev++)
541 const auto& pmap = pc.GetParticles(lev);
542 for (
const auto& kv : pmap)
544 auto& flags = particle_io_flags[lev][kv.first];
545 if constexpr (PC::has_polymorphic_allocator) {
546 flags.setArena(pc.arena());
548 particle_detail::fillFlags(flags, kv.second, f);
554 if(pc.GetUsePrePost())
556 nparticles = pc.GetNParticlesPrePost();
557 maxnextid = pc.GetMaxNextIDPrePost();
561 nparticles = particle_detail::countFlags(particle_io_flags, pc);
562 maxnextid = PC::ParticleType::NextID();
564 PC::ParticleType::NextID(maxnextid);
570 std::string HdrFileName = pdir;
572 if ( ! HdrFileName.empty() && HdrFileName[HdrFileName.size()-1] !=
'/') {
576 HdrFileName +=
"Header";
577 pc.HdrFileNamePrePost = HdrFileName;
579 HdrFile.open(HdrFileName.c_str(), std::ios::out|std::ios::trunc);
588 std::string version_string = is_checkpoint ? PC::CheckpointVersion() : PC::PlotfileVersion();
589 if (
sizeof(
typename PC::ParticleType::RealType) == 4)
591 HdrFile << version_string <<
"_single" <<
'\n';
595 HdrFile << version_string <<
"_double" <<
'\n';
598 int num_output_real = 0;
599 for (
int i : write_real_comp) {
600 if (i) { ++num_output_real; }
603 int num_output_int = 0;
604 for (
int i = 0; i < pc.NumIntComps() + NStructInt; ++i) {
605 if (write_int_comp[i]) { ++num_output_int; }
609 HdrFile << AMREX_SPACEDIM <<
'\n';
612 HdrFile << num_output_real <<
'\n';
615 for (
int i = 0; i < (
int) real_comp_names.
size(); ++i ) {
616 if (write_real_comp[i]) { HdrFile << real_comp_names[i] <<
'\n'; }
620 HdrFile << num_output_int <<
'\n';
623 for (
int i = 0; i < NStructInt + pc.NumIntComps(); ++i ) {
624 if (write_int_comp[i]) { HdrFile << int_comp_names[i] <<
'\n'; }
627 bool is_checkpoint_legacy =
true;
628 HdrFile << is_checkpoint_legacy <<
'\n';
631 HdrFile << nparticles <<
'\n';
634 HdrFile << maxnextid <<
'\n';
637 HdrFile << pc.finestLevel() <<
'\n';
640 for (
int lev = 0; lev <= pc.finestLevel(); lev++) {
641 HdrFile << pc.ParticleBoxArray(lev).size() <<
'\n';
650 pp.
queryAdd(
"particles_nfiles",nOutFiles);
651 if(nOutFiles == -1) { nOutFiles = NProcs; }
652 nOutFiles = std::max(1, std::min(nOutFiles,NProcs));
653 pc.nOutFilesPrePost = nOutFiles;
655 for (
int lev = 0; lev <= pc.finestLevel(); lev++)
660 gotsome = (pc.nParticlesAtLevelPrePost[lev] > 0);
664 gotsome = (pc.NumberOfParticlesAtLevel(lev) > 0);
668 std::string LevelDir = pdir;
672 if ( ! LevelDir.empty() && LevelDir[LevelDir.size()-1] !=
'/') { LevelDir +=
'/'; }
676 if ( ! pc.GetLevelDirectoriesCreated())
689 std::string HeaderFileName = LevelDir;
690 HeaderFileName +=
"/Particle_H";
702 MultiFab state(pc.ParticleBoxArray(lev),
703 pc.ParticleDistributionMap(lev),
712 std::string filePrefix(LevelDir);
714 filePrefix += PC::DataPrefix();
716 pc.filePrefixPrePost[lev] = filePrefix;
718 bool groupSets(
false), setBuf(
true);
724 auto& myStream = (std::ofstream&) nfi.Stream();
725 pc.WriteParticles(lev, myStream, nfi.FileNumber(), which, count, where,
726 write_real_comp, write_int_comp, particle_io_flags, is_checkpoint);
730 pc.whichPrePost[lev] = which;
731 pc.countPrePost[lev] = count;
732 pc.wherePrePost[lev] = where;
742 if(pc.GetUsePrePost()) {
745 for (
int j = 0; j < state.
size(); j++)
747 HdrFile << which[j] <<
' ' << count[j] <<
' ' << where[j] <<
'\n';
750 if (gotsome && pc.doUnlink)
755 for (
int i = 0, N=
static_cast<int>(count.
size()); i < N; i++) {
756 cnt[which[i]] += count[i];
759 for (
int i = 0, N=
static_cast<int>(cnt.
size()); i < N; i++)
779 if ( ! HdrFile.good())
781 amrex::Abort(
"amrex::WriteBinaryParticleDataSync(): problem writing HdrFile");
787requires (IsParticleContainer<PC>::value)
789 const std::string& dir,
const std::string& name,
800 AMREX_ASSERT(
sizeof(
typename PC::ParticleType::RealType) == 4 ||
801 sizeof(
typename PC::ParticleType::RealType) == 8);
803 constexpr int NStructReal = PC::NStructReal;
804 constexpr int NStructInt = PC::NStructInt;
805 constexpr int NArrayReal = PC::NArrayReal;
806 constexpr int NArrayInt = PC::NArrayInt;
810 const int IOProcNumber = NProcs - 1;
812 if constexpr(PC::ParticleType::is_soa_particle) {
820 for (
int lev = 0; lev <= pc.finestLevel(); lev++)
822 np_per_grid_local[lev].define(pc.ParticleBoxArray(lev), pc.ParticleDistributionMap(lev));
823 using ParIter =
typename PC::ParConstIterType;
824 for (
ParIter pti(pc, lev); pti.isValid(); ++pti)
826 int gid = pti.index();
827 const auto& ptile = pc.ParticlesAt(lev, pti);
828 const auto& ptd = ptile.getConstParticleTileData();
829 const int np = ptile.numParticles();
833 using ReduceTuple =
typename decltype(reduce_data)::Type;
835 reduce_op.
eval(np, reduce_data,
838 return (ptd.id(i).is_valid()) ? 1 : 0;
842 np_per_grid_local[lev][gid] += np_valid;
849 for (
int lev = 0; lev <= pc.finestLevel(); lev++)
851 np_per_grid_global[lev].resize(np_per_grid_local[lev].size());
853 np_per_grid_global[lev],
855 np_per_level[lev] = std::accumulate(np_per_grid_global[lev].
begin(),
856 np_per_grid_global[lev].
end(), 0L);
857 total_np += np_per_level[lev];
860 std::string pdir = dir;
861 if ( ! pdir.empty() && pdir[pdir.size()-1] !=
'/') { pdir +=
'/'; }
864 if (MyProc == IOProcNumber)
866 if ( ! pc.GetLevelDirectoriesCreated())
874 for (
int lev = 0; lev <= pc.finestLevel(); lev++)
876 std::string LevelDir = pdir;
877 bool gotsome = np_per_level[lev];
881 if ( ! LevelDir.empty() && LevelDir[LevelDir.size()-1] !=
'/') { LevelDir +=
'/'; }
885 if ( ! pc.GetLevelDirectoriesCreated())
893 std::string HeaderFileName = LevelDir;
894 HeaderFileName +=
"/Particle_H";
907 Long maxnextid = PC::ParticleType::NextID();
911 std::size_t
psize = particle_detail::PSizeInFile<ParticleReal>(write_real_comp, write_int_comp);
913 if (MyProc == IOProcNumber)
915 for (
int lev = 0; lev <= pc.finestLevel(); lev++)
917 for (
int k = 0; k < pc.ParticleBoxArray(lev).size(); ++k)
919 int rank = pc.ParticleDistributionMap(lev)[k];
920 np_on_rank[rank] += np_per_grid_global[lev][k];
924 for (
int ip = 0; ip < NProcs; ++ip)
927 rank_start_offset[ip] = (info.ispot == 0) ? 0 :
static_cast<int64_t
>(rank_start_offset[ip-1] + np_on_rank[ip-1]*
psize);
932 using PinnedPTile = std::conditional_t<
934 typename PC::ParticleTileType,
937 auto myptiles = std::make_shared<Vector<std::map<std::pair<int, int>,PinnedPTile> > >();
938 myptiles->
resize(pc.finestLevel()+1);
939 for (
int lev = 0; lev <= pc.finestLevel(); lev++)
943 auto& new_ptile = (*myptiles)[lev][std::make_pair(mfi.index(),
944 mfi.LocalTileIndex())];
946 if (np_per_grid_local[lev][mfi.index()] > 0)
948 const auto& ptile = pc.ParticlesAt(lev, mfi);
950 const auto np = np_per_grid_local[lev][mfi.index()];
952 const auto runtime_real_comps = ptile.NumRuntimeRealComps();
953 const auto runtime_int_comps = ptile.NumRuntimeIntComps();
955 new_ptile.define(runtime_real_comps, runtime_int_comps,
958 new_ptile.resize(np);
965 int finest_level = pc.finestLevel();
968 for (
int lev = 0; lev <= pc.finestLevel(); lev++)
970 bas.push_back(pc.ParticleBoxArray(lev));
971 dms.push_back(pc.ParticleDistributionMap(lev));
974 int nic = pc.NumIntComps();
975 int rnames_size = (
int) real_comp_names.
size();
977 auto RD = pc.ParticleRealDescriptor;
980#
if defined(__GNUC__) && (__GNUC__ == 8) && (__GNUC_MINOR__ == 1)
984 if (MyProc == IOProcNumber)
986 std::string HdrFileName = pdir;
987 std::ofstream HdrFile;
989 if ( ! HdrFileName.empty() && HdrFileName[HdrFileName.size()-1] !=
'/') {
993 HdrFileName +=
"Header";
995 HdrFile.open(HdrFileName.c_str(), std::ios::out|std::ios::trunc);
999 std::string version_string = is_checkpoint ? PC::CheckpointVersion() : PC::PlotfileVersion();
1000 if (
sizeof(
typename PC::ParticleType::RealType) == 4)
1002 HdrFile << version_string <<
"_single" <<
'\n';
1006 HdrFile << version_string <<
"_double" <<
'\n';
1009 int num_output_real = 0;
1010 for (
int i = 0; i < rnames_size; ++i) {
1011 if (write_real_comp[i]) { ++num_output_real; }
1014 int num_output_int = 0;
1015 for (
int i = 0; i < nic + NStructInt; ++i) {
1016 if (write_int_comp[i]) { ++num_output_int; }
1020 HdrFile << AMREX_SPACEDIM <<
'\n';
1023 HdrFile << num_output_real <<
'\n';
1026 for (
int i = 0; i < rnames_size; ++i ) {
1027 if (write_real_comp[i]) { HdrFile << real_comp_names[i] <<
'\n'; }
1031 HdrFile << num_output_int <<
'\n';
1034 for (
int i = 0; i < NStructInt + nic; ++i ) {
1035 if (write_int_comp[i]) { HdrFile << int_comp_names[i] <<
'\n'; }
1038 bool is_checkpoint_legacy =
true;
1039 HdrFile << is_checkpoint_legacy <<
'\n';
1042 HdrFile << total_np <<
'\n';
1045 HdrFile << maxnextid <<
'\n';
1048 HdrFile << finest_level <<
'\n';
1051 for (
int lev = 0; lev <= finest_level; lev++) {
1052 HdrFile << dms[lev].
size() <<
'\n';
1055 for (
int lev = 0; lev <= finest_level; lev++)
1058 for (
int k = 0; k < bas[lev].
size(); ++k)
1060 int rank = dms[lev][k];
1062 HdrFile << info.ifile <<
' '
1063 << np_per_grid_global[lev][k] <<
' '
1064 << grid_offset[rank] + rank_start_offset[rank] <<
'\n';
1065 grid_offset[rank] +=
static_cast<int64_t
>(np_per_grid_global[lev][k]*
psize);
1071 if ( ! HdrFile.good())
1073 amrex::Abort(
"amrex::WriteBinaryParticleDataAsync(): problem writing HdrFile");
1079 for (
int lev = 0; lev <= finest_level; lev++)
1082 std::map<int, Vector<int> > tile_map;
1084 for (
const auto& kv : (*myptiles)[lev])
1086 const int grid = kv.first.first;
1087 const int tile = kv.first.second;
1088 tile_map[grid].push_back(tile);
1091 std::string LevelDir = pdir;
1092 if ( ! LevelDir.empty() && LevelDir[LevelDir.size()-1] !=
'/') { LevelDir +=
'/'; }
1094 std::string filePrefix(LevelDir);
1096 filePrefix += PC::DataPrefix();
1100 ofs.open(file_name.c_str(), (info.ispot == 0) ? (std::ios::binary | std::ios::trunc)
1101 : (std::ios::binary | std::ios::app));
1103 for (
int k = 0; k < bas[lev].
size(); ++k)
1105 int rank = dms[lev][k];
1106 if (rank != MyProc) {
continue; }
1108 if (np_per_grid_local[lev][grid] == 0) {
continue; }
1111 int num_output_int = 0;
1112 for (
int i = 0; i < nic + NStructInt; ++i) {
1113 if (write_int_comp[i]) { ++num_output_int; }
1116 const Long iChunkSize = 2 + num_output_int;
1117 Vector<int> istuff(np_per_grid_local[lev][grid]*iChunkSize);
1120 for (
unsigned i = 0; i < tile_map[grid].size(); i++) {
1121 auto ptile_index = std::make_pair(grid, tile_map[grid][i]);
1122 const auto& pbox = (*myptiles)[lev][ptile_index];
1123 const auto& ptd = pbox.getConstParticleTileData();
1124 for (
int pindex = 0; pindex < pbox.numParticles(); ++pindex)
1126 if (!ptd.id(pindex).is_valid()) {
continue; }
1128 particle_detail::iPackParticleData(ptd, pindex, iptr,
1129 write_int_comp.
dataPtr(), is_checkpoint);
1138 int num_output_real = 0;
1139 for (
int i = 0; i < rnames_size; ++i) {
1140 if (write_real_comp[i]) { ++num_output_real; }
1143 const Long rChunkSize = AMREX_SPACEDIM + num_output_real;
1145 typename PC::ParticleType::RealType* rptr = rstuff.
dataPtr();
1147 for (
unsigned i = 0; i < tile_map[grid].size(); i++) {
1148 auto ptile_index = std::make_pair(grid, tile_map[grid][i]);
1149 const auto& pbox = (*myptiles)[lev][ptile_index];
1150 const auto& ptd = pbox.getConstParticleTileData();
1151 for (
int pindex = 0; pindex < pbox.numParticles(); ++pindex)
1153 if (!ptd.id(pindex).is_valid()) {
continue; }
1155 particle_detail::rPackParticleData(ptd, pindex, rptr,
1161 if (
sizeof(
typename PC::ParticleType::RealType) == 4) {
1164 else if (
sizeof(
typename PC::ParticleType::RealType) == 8) {
1177#ifdef AMREX_USE_HDF5
#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
#define AMREX_GPU_DEVICE
Definition AMReX_GpuQualifiers.H:18
#define AMREX_GPU_HOST_DEVICE
Definition AMReX_GpuQualifiers.H:20
int psize
Definition AMReX_Parser_Exe_Body.H:12
while parser_exe_t p
Definition AMReX_Parser_Exe_Body.H:33
int size() const noexcept
Return the number of FABs in the FabArray.
Definition AMReX_FabArrayBase.H:115
static void streamSynchronize() noexcept
Definition AMReX_GpuDevice.cpp:992
Iterator for looping ever tiles and boxes of amrex::FabArray based containers.
Definition AMReX_MFIter.H:88
bool isValid() const noexcept
Is the iterator valid i.e. is it associated with a FAB?
Definition AMReX_MFIter.H:176
A collection (stored as an array) of FArrayBox objects.
Definition AMReX_MultiFab.H:40
This class encapsulates writing to nfiles.
Definition AMReX_NFiles.H:27
bool ReadyToWrite(bool appendFirst=false)
if appendFirst is true, the first set for this iterator will open the files in append mode
Definition AMReX_NFiles.cpp:211
const std::string & FileName() const
Definition AMReX_NFiles.H:167
Parse Parameters From Command Line and Input Files.
Definition AMReX_ParmParse.H:355
int queryAdd(std::string_view name, T &ref)
If name is found, the value in the ParmParse database will be stored in the ref argument....
Definition AMReX_ParmParse.H:1062
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
This class is a thin wrapper around std::vector. Unlike vector, Vector::operator[] provides bound che...
Definition AMReX_Vector.H:29
T * dataPtr() noexcept
get access to the underlying data pointer
Definition AMReX_Vector.H:50
Long size() const noexcept
Definition AMReX_Vector.H:54
static bool GetBarrierAfterLevel()
Definition AMReX_VisMF.H:287
amrex_particle_real ParticleReal
Floating Point Type for Particles.
Definition AMReX_REAL.H:91
amrex_long Long
Definition AMReX_INT.H:30
WriteInfo GetWriteInfo(int rank)
Compute this rank's write slot information for multi-file output.
Definition AMReX_AsyncOut.cpp:72
void Wait()
Called inside a submitted user job function to wait for this rank's turn to access the file.
Definition AMReX_AsyncOut.cpp:112
void Notify()
Called inside a submitted user job function to notify the next rank sharing the file that it may proc...
Definition AMReX_AsyncOut.cpp:127
void Submit(std::function< void()> &&a_f)
Submit a job functor to the asynchronous writer thread.
Definition AMReX_AsyncOut.cpp:95
Arena * The_Pinned_Arena()
Definition AMReX_Arena.cpp:879
int MyProc() noexcept
Definition AMReX_ParallelDescriptor.H:128
void ReduceIntSum(int &)
Definition AMReX_ParallelDescriptor.cpp:1269
int NProcs() noexcept
Definition AMReX_ParallelDescriptor.H:255
void ReduceLongSum(Long &)
Definition AMReX_ParallelDescriptor.cpp:1240
int IOProcessorNumber() noexcept
The MPI rank number of the I/O Processor (probably rank 0). This rank is usually used to write to std...
Definition AMReX_ParallelDescriptor.H:279
void ReduceLongMax(Long &)
Definition AMReX_ParallelDescriptor.cpp:1241
void Barrier(const std::string &)
Definition AMReX_ParallelDescriptor.cpp:1219
bool IOProcessor() noexcept
Is this CPU the I/O Processor? To get the rank number, call IOProcessorNumber().
Definition AMReX_ParallelDescriptor.H:289
bool Remove(std::string const &filename)
Remove a file, symbolic link, or empty directory.
Definition AMReX_FileSystem.cpp:41
__host__ __device__ void * memcpy(void *dest, const void *src, std::size_t count)
Definition AMReX_GpuUtility.H:203
void GatherLayoutDataToVector(const LayoutData< T > &sendbuf, Vector< T > &recvbuf, int root)
Gather LayoutData values to a vector on root.
Definition AMReX_ParallelDescriptor.H:1286
Definition AMReX_Amr.cpp:50
void writeIntData(const From *data, std::size_t size, std::ostream &os, const amrex::IntDescriptor &id)
Definition AMReX_IntConv.H:23
__host__ __device__ void ignore_unused(const Ts &...)
No-op helper that marks variables as intentionally unused.
Definition AMReX.H:273
void FileOpenFailed(const std::string &file)
Output a message and abort when couldn't open the file.
Definition AMReX_Utility.cpp:62
@ F
Definition AMReX_Order.H:7
void WriteBinaryParticleDataAsync(PC const &pc, const std::string &dir, const std::string &name, const Vector< int > &write_real_comp, const Vector< int > &write_int_comp, const Vector< std::string > &real_comp_names, const Vector< std::string > &int_comp_names, bool is_checkpoint)
Definition AMReX_WriteBinaryParticleData.H:788
__host__ __device__ Dim3 begin(BoxND< dim > const &box) noexcept
Return the iterator begin coordinate of box as Dim3.
Definition AMReX_Box.H:2241
void writeFloatData(const float *data, std::size_t size, std::ostream &os, const RealDescriptor &rd=FPC::Native32RealDescriptor())
Definition AMReX_VectorIO.cpp:130
void ParallelFor(TypeList< CTOs... > ctos, std::array< int, sizeof...(CTOs)> const &runtime_options, T N, F &&f)
Definition AMReX_CTOParallelForImpl.H:202
void WriteBinaryParticleDataSync(PC const &pc, const std::string &dir, const std::string &name, const Vector< int > &write_real_comp, const Vector< int > &write_int_comp, const Vector< std::string > &real_comp_names, const Vector< std::string > &int_comp_names, F const &f, bool is_checkpoint)
Definition AMReX_WriteBinaryParticleData.H:486
std::string Concatenate(const std::string &root, int num, int mindigits)
Returns rootNNNN where NNNN == num.
Definition AMReX_String.cpp:35
void CreateDirectoryFailed(const std::string &dir)
Output a message and abort when couldn't create the directory.
Definition AMReX_Utility.cpp:54
RandomEngine getInvalidRandomEngine()
Definition AMReX_RandomEngine.H:86
bool UtilCreateDirectory(const std::string &path, mode_t mode, bool verbose=false)
Creates the specified directories. path may be either a full pathname or a relative pathname....
Definition AMReX_Utility.cpp:41
void writeDoubleData(const double *data, std::size_t size, std::ostream &os, const RealDescriptor &rd=FPC::Native64RealDescriptor())
Definition AMReX_VectorIO.cpp:142
AMREX_ATTRIBUTE_FLATTEN_FOR void ParallelForRNG(T n, L const &f) noexcept
Definition AMReX_GpuLaunchFunctsC.H:1157
ParIter_impl< Particle< T_NStructReal, T_NStructInt >, T_NArrayReal, T_NArrayInt, Allocator, CellAssignor > ParIter
Definition AMReX_ParIter.H:239
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
__host__ __device__ Dim3 end(BoxND< dim > const &box) noexcept
Return the iterator end coordinate of box as Dim3.
Definition AMReX_Box.H:2259
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:389
__host__ __device__ constexpr int get(IntVectND< dim > const &iv) noexcept
Get the Idx-th element of IntVectND<dim>.
Definition AMReX_IntVect.H:1367
Definition AMReX_TypeTraits.H:90
Definition AMReX_WriteBinaryParticleData.H:13
__host__ __device__ int operator()(const SrcData &src, int i) const noexcept
Definition AMReX_WriteBinaryParticleData.H:16
FabArray memory allocation information.
Definition AMReX_FabArray.H:73
MFInfo & SetAlloc(bool a) noexcept
Control whether FAB storage is allocated when the FabArray is defined.
Definition AMReX_FabArray.H:81
Metadata prefix of an AMReX particle "Header" file.
Definition AMReX_ParticleHeader.H:38
Definition AMReX_ParticleTile.H:764
void resize(std::size_t count, GrowthStrategy strategy=GrowthStrategy::Poisson)
Definition AMReX_ParticleTile.H:1043