From e721d2ae4e5fc28b0330b739331921a40e23da7a Mon Sep 17 00:00:00 2001 From: PhilipDeegan Date: Thu, 5 Sep 2024 15:19:20 +0200 Subject: [PATCH] ++ --- .../electromag/electromag_initializer.hpp | 94 +++++++++ .../samrai_hdf5_field_initializer.hpp | 56 +++++ .../initializers/samrai_hdf5_initializer.hpp | 192 ++++++++++++++++++ .../particle_initializer_factory.hpp | 1 + .../samrai_hdf5_particle_initializer.hpp | 69 +------ src/amr/physical_models/hybrid_model.hpp | 59 +++++- src/core/data/electromag/electromag.hpp | 16 +- .../electromag/electromag_initializer.hpp | 55 ----- src/core/utilities/types.hpp | 9 + src/hdf5/detail/h5/group_scanner.hpp | 72 +++++++ src/hdf5/detail/h5/h5_file.hpp | 50 +---- tests/amr/tagging/test_tagging.cpp | 19 +- .../numerics/ion_updater/test_updater.cpp | 5 +- 13 files changed, 501 insertions(+), 196 deletions(-) create mode 100644 src/amr/data/electromag/electromag_initializer.hpp create mode 100644 src/amr/data/field/initializers/samrai_hdf5_field_initializer.hpp create mode 100644 src/amr/data/initializers/samrai_hdf5_initializer.hpp delete mode 100644 src/core/data/electromag/electromag_initializer.hpp create mode 100644 src/hdf5/detail/h5/group_scanner.hpp diff --git a/src/amr/data/electromag/electromag_initializer.hpp b/src/amr/data/electromag/electromag_initializer.hpp new file mode 100644 index 000000000..f8dc7d8b1 --- /dev/null +++ b/src/amr/data/electromag/electromag_initializer.hpp @@ -0,0 +1,94 @@ +#ifndef _PHARE_AMR_DATA_ELECTROMAG_ELECTROMAG_INITIALIZER_HPP_ +#define _PHARE_AMR_DATA_ELECTROMAG_ELECTROMAG_INITIALIZER_HPP_ + +// #include "core/data/electromag/electromag.hpp" + +#include "core/data/vecfield/vecfield_initializer.hpp" +#include "amr/data/field/initializers/samrai_hdf5_field_initializer.hpp" +#include "initializer/data_provider.hpp" + + +#include + +namespace PHARE::amr +{ + +template +class ElectromagInitializer +{ +public: + virtual void init(Electromag_t& /*em*/, GridLayout const& /*layout*/) const { /*noop*/ } + virtual ~ElectromagInitializer() {} +}; + +template +class ElectromagUserFuncInitializer : public ElectromagInitializer +{ + using VecFieldInit = core::VecFieldInitializer; + +public: + ElectromagUserFuncInitializer(initializer::PHAREDict const& dict) + : Binit_{dict["magnetic"]["initializer"]} + { + } + virtual ~ElectromagUserFuncInitializer() {} + + void init(Electromag_t& em, GridLayout const& layout) const override + { + Binit_.initialize(em.B, layout); + } + + VecFieldInit Binit_; +}; + + +/* +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/EM_B_y##default/d_box +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/EM_B_x##default/field_EM_B_x +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/EM_B_y##default/field_EM_B_y +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/EM_B_z##default/field_EM_B_z +*/ + + +template +class ElectromagSamraiH5Initializer : public ElectromagInitializer +{ + using vecfield_type = typename Electromag_t::vecfield_type; + using field_type = typename vecfield_type::field_type; + + +public: + ElectromagSamraiH5Initializer(initializer::PHAREDict const& dict) + : dict_{dict} + { + } + virtual ~ElectromagSamraiH5Initializer() {} + + void init(Electromag_t& em, GridLayout const& layout) const override + { + for (auto& field : em.B) + SamraiHDF5FieldInitializer{}.load(field, layout); + } + + initializer::PHAREDict const dict_; +}; + + + +class ElectromagInitializerFactory +{ +public: + template + NO_DISCARD static std::unique_ptr> + create(initializer::PHAREDict const& dict) + { + if (dict["magnetic"]["initializer"].contains("x_component")) + return std::make_unique>(dict); + else + return std::make_unique>(dict); + } +}; + +} // namespace PHARE::amr + +#endif // _PHARE_AMR_DATA_ELECTROMAG_ELECTROMAG_INITIALIZER_HPP_ diff --git a/src/amr/data/field/initializers/samrai_hdf5_field_initializer.hpp b/src/amr/data/field/initializers/samrai_hdf5_field_initializer.hpp new file mode 100644 index 000000000..43af05546 --- /dev/null +++ b/src/amr/data/field/initializers/samrai_hdf5_field_initializer.hpp @@ -0,0 +1,56 @@ +#ifndef _PHARE_AMR_DATA_FIELD_INITIAZILIZERS_SAMRAI_HDF5_INITIALIZER_HPP_ +#define _PHARE_AMR_DATA_FIELD_INITIAZILIZERS_SAMRAI_HDF5_INITIALIZER_HPP_ + +#include +#include +#include +#include + +#include "core/data/grid/gridlayoutdefs.hpp" +#include "core/hybrid/hybrid_quantities.hpp" +#include "core/utilities/types.hpp" +#include "core/data/ions/particle_initializers/particle_initializer.hpp" +#include "core/data/particles/particle.hpp" +#include "initializer/data_provider.hpp" +#include "core/utilities/point/point.hpp" +#include "core/def.hpp" +#include "core/logger.hpp" + +#include "hdf5/detail/h5/h5_file.hpp" + + +#include "SAMRAI/hier/PatchDataRestartManager.h" + +#include "amr/data/initializers/samrai_hdf5_initializer.hpp" + + +namespace PHARE::amr +{ + + +template +class SamraiHDF5FieldInitializer // no virtual classes needed (yet) +{ +public: + static constexpr auto dimension = GridLayout::dimension; + + SamraiHDF5FieldInitializer() {} + + void load(Field_t& Field, GridLayout const& layout) const; +}; + + + +template +void SamraiHDF5FieldInitializer::load(Field_t& field, + GridLayout const& layout) const +{ + PHARE_LOG_LINE_STR("SamraiHDF5FieldInitializer::loadParticles"); +} + + + +} // namespace PHARE::amr + + +#endif diff --git a/src/amr/data/initializers/samrai_hdf5_initializer.hpp b/src/amr/data/initializers/samrai_hdf5_initializer.hpp new file mode 100644 index 000000000..f2211b6c5 --- /dev/null +++ b/src/amr/data/initializers/samrai_hdf5_initializer.hpp @@ -0,0 +1,192 @@ +#ifndef _PHARE_AMR_DATA_INITIAZILIZERS_SAMRAI_HDF5_INITIALIZER_HPP_ +#define _PHARE_AMR_DATA_INITIAZILIZERS_SAMRAI_HDF5_INITIALIZER_HPP_ + +#include +#include +#include +#include + +#include "core/data/grid/gridlayoutdefs.hpp" +#include "core/hybrid/hybrid_quantities.hpp" +#include "core/utilities/types.hpp" +#include "core/data/ions/particle_initializers/particle_initializer.hpp" +#include "core/data/particles/particle.hpp" +#include "initializer/data_provider.hpp" +#include "core/utilities/point/point.hpp" +#include "core/def.hpp" +#include "core/logger.hpp" + +#include "hdf5/detail/h5/h5_file.hpp" +#include "amr/utilities/box/amr_box.hpp" + +#include "SAMRAI/hier/PatchDataRestartManager.h" + + +namespace PHARE::amr +{ + +/* +example paths + +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/d_box +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/d_ghost_box +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/d_ghosts +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/d_timestamp +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_charge +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_delta +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_iCell +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_v +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_weight + + +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/EM_B_y##default/d_box +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/EM_B_x##default/field_EM_B_x +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/EM_B_y##default/field_EM_B_y +/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/EM_B_z##default/field_EM_B_z +*/ + + +template +class SamraiH5Interface +{ + struct SamraiHDF5File; // : PHARE::hdf5::h5::HighFiveFile; + +public: + static SamraiH5Interface& INSTANCE() + { + static SamraiH5Interface i; + return i; + } + + void populate_from(std::string const& dir, int const& idx, int const& mpi_size); + + NO_DISCARD auto static getRestartFileFullPath(std::string path, int const& idx, + int const& mpi_size, int const& rank) + { + return path // + + "/restore." + SAMRAI::tbox::Utilities::intToString(idx, 6) // + + "/nodes." + SAMRAI::tbox::Utilities::nodeToString(mpi_size) // + + "/proc." + SAMRAI::tbox::Utilities::processorToString(rank); + } + + + +private: + std::vector> restart_files; + std::unordered_map box2dataset; +}; + +template +struct SamraiH5Interface::SamraiHDF5File : public hdf5::h5::HighFiveFile +{ + using Super = hdf5::h5::HighFiveFile; + using Box_t = core::Box; + + SamraiHDF5File(std::string const& filepath) + : Super{filepath, HighFive::File::ReadOnly, /*para=*/false} + { + // auto box_type = box_compound_type(); + // box_type.commit(file(), "d_box"); + + // getBoxFromPath("/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/" + // "EM_B_y##default/d_box"); + } + + + + /* + DATASET "d_box" { + DATATYPE H5T_COMPOUND { + H5T_STD_I32BE "dim"; + H5T_ARRAY { [3] H5T_STD_I32BE } "lo"; + H5T_ARRAY { [3] H5T_STD_I32BE } "hi"; + } + DATASPACE SIMPLE { ( 1 ) / ( 1 ) } + DATA { + (0): { + 1, + [ 0, 0, 0 ], + [ 199, 0, 0 ] + } + } + ATTRIBUTE "Type" { + DATATYPE H5T_STD_I8BE + DATASPACE SCALAR + DATA { + (0): 2 + } + } + } + */ + + struct BoxData + { + std::int32_t dim; + std::array lo; + std::array hi; + }; + + // struct BoxData + // { + // int dim; + // int lo0, lo1, lo2; + // int hi0, hi1, hi2; + // }; + + HighFive::CompoundType static box_compound_type() + { + return {{"dim", HighFive::create_datatype()}, + {"lo", HighFive::create_datatype>()}, + {"hi", HighFive::create_datatype>()}}; + } + + auto getBoxFromPath(std::string const& path) const + { + // auto const& data = Super::read_data_set(path); + // PHARE_LOG_LINE_STR(data.size()); + std::vector boxes; + Super::file().getDataSet(path).read(boxes); + assert(boxes.size() == 1); + + // auto const& bx = boxes[0]; + // return Box_t{core::as_sized_array(bx.lo0, bx.lo1, bx.lo2), + // core::as_sized_array(bx.hi0, bx.hi1, bx.hi2)}; + + return Box_t{core::sized_array(boxes[0].lo), + core::sized_array(boxes[0].hi)}; + } +}; + + + +template +void SamraiH5Interface::populate_from(std::string const& dir, + int const& idx, + int const& mpi_size) +{ + for (int rank = 0; rank < mpi_size; ++rank) + { + auto const hdf5_filepath = getRestartFileFullPath(dir, idx, mpi_size, rank); + + hdf5::h5::HighFiveFile h5File{hdf5_filepath, HighFive::File::ReadOnly, /*para=*/false}; + + PHARE_LOG_LINE_STR("SamraiH5Interface::populate_from"); + + auto groups = h5File.scan_for_groups({"level_0000", "domainParticles_charge"}); + + for (auto const& g : groups) + { + PHARE_LOG_LINE_STR(g); + } + + restart_files.emplace_back(std::make_unique(hdf5_filepath)); + } +} + + + + +} // namespace PHARE::amr + + +#endif diff --git a/src/amr/data/particles/initializers/particle_initializer_factory.hpp b/src/amr/data/particles/initializers/particle_initializer_factory.hpp index 568a76ff5..e6b68db6c 100644 --- a/src/amr/data/particles/initializers/particle_initializer_factory.hpp +++ b/src/amr/data/particles/initializers/particle_initializer_factory.hpp @@ -10,6 +10,7 @@ #include "core/data/ions/particle_initializers/maxwellian_particle_initializer.hpp" #include "samrai_hdf5_particle_initializer.hpp" +#include "amr/data/initializers/samrai_hdf5_initializer.hpp" #include diff --git a/src/amr/data/particles/initializers/samrai_hdf5_particle_initializer.hpp b/src/amr/data/particles/initializers/samrai_hdf5_particle_initializer.hpp index b6ae3d742..94c5158a8 100644 --- a/src/amr/data/particles/initializers/samrai_hdf5_particle_initializer.hpp +++ b/src/amr/data/particles/initializers/samrai_hdf5_particle_initializer.hpp @@ -1,5 +1,5 @@ -#ifndef _PHARE_CORE_DATA_IONS_PARTICLE_INITIAZILIZERS_SAMRAI_HDF5_INITIALIZER_HPP_ -#define _PHARE_CORE_DATA_IONS_PARTICLE_INITIAZILIZERS_SAMRAI_HDF5_INITIALIZER_HPP_ +#ifndef _PHARE_AMR_DATA_PARTICLE_INITIAZILIZERS_SAMRAI_HDF5_INITIALIZER_HPP_ +#define _PHARE_AMR_DATA_PARTICLE_INITIAZILIZERS_SAMRAI_HDF5_INITIALIZER_HPP_ #include #include @@ -14,6 +14,7 @@ #include "initializer/data_provider.hpp" #include "core/utilities/point/point.hpp" #include "core/def.hpp" +#include "core/logger.hpp" #include "hdf5/detail/h5/h5_file.hpp" @@ -25,70 +26,6 @@ namespace PHARE::amr { -template -class SamraiH5Interface -{ -public: - static SamraiH5Interface& INSTANCE() - { - static SamraiH5Interface i; - return i; - } - - void populate_from(std::string const& dir, int const& idx, int const& mpi_size); - - NO_DISCARD auto static getRestartFileFullPath(std::string path, int const& idx, - int const& mpi_size, int const& rank) - { - return path // - + "/restore." + SAMRAI::tbox::Utilities::intToString(idx, 6) // - + "/nodes." + SAMRAI::tbox::Utilities::nodeToString(mpi_size) // - + "/proc." + SAMRAI::tbox::Utilities::processorToString(rank); - } - - -private: - std::unordered_map box2dataset; -}; - - -/* -/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/d_box -/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/d_ghost_box -/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/d_ghosts -/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/d_timestamp -/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_charge -/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_delta -/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_iCell -/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_v -/PHARE_hierarchy/level_0000/level_0000-patch_0000000-block_0000000/protons##default/domainParticles_weight -*/ - - -template -void SamraiH5Interface::populate_from(std::string const& dir, - int const& idx, - int const& mpi_size) -{ - for (int rank = 0; rank < mpi_size; ++rank) - { - auto const hdf5_filepath = getRestartFileFullPath(dir, idx, mpi_size, rank); - - hdf5::h5::HighFiveFile h5File{hdf5_filepath, HighFive::File::ReadOnly, /*para=*/false}; - - PHARE_LOG_LINE_STR("SamraiH5Interface::populate_from"); - - auto groups = h5File.scan_for_groups({"level_0000", "domainParticles_charge"}); - - for (auto const& g : groups) - { - PHARE_LOG_LINE_STR(g); - } - } -} - - - template class SamraiHDF5ParticleInitializer : public core::ParticleInitializer { diff --git a/src/amr/physical_models/hybrid_model.hpp b/src/amr/physical_models/hybrid_model.hpp index 4033a8436..7488ab021 100644 --- a/src/amr/physical_models/hybrid_model.hpp +++ b/src/amr/physical_models/hybrid_model.hpp @@ -1,6 +1,7 @@ #ifndef PHARE_HYBRID_MODEL_HPP #define PHARE_HYBRID_MODEL_HPP +#include #include #include "core/def.hpp" @@ -12,6 +13,8 @@ #include "amr/physical_models/physical_model.hpp" #include "amr/data/particles/initializers/particle_initializer_factory.hpp" +#include "amr/data/electromag/electromag_initializer.hpp" + #include "amr/resources_manager/resources_manager.hpp" #include "amr/messengers/hybrid_messenger_info.hpp" @@ -26,6 +29,9 @@ template class HybridModel : public IPhysicalModel { + struct _Initializers; + + public: static constexpr auto dimension = GridLayoutT::dimension; @@ -46,11 +52,11 @@ class HybridModel : public IPhysicalModel using resources_manager_type = amr::ResourcesManager; using ParticleInitializerFactory = amr::ParticleInitializerFactory; - + using HybridState_t = core::HybridState; static const inline std::string model_name = "HybridModel"; - core::HybridState state; + HybridState_t state; std::shared_ptr resourcesManager; @@ -88,6 +94,7 @@ class HybridModel : public IPhysicalModel : IPhysicalModel{model_name} , state{dict} , resourcesManager{std::move(_resourcesManager)} + , initializers_{std::make_unique<_Initializers>(dict, state)} { } @@ -111,6 +118,9 @@ class HybridModel : public IPhysicalModel //------------------------------------------------------------------------- std::unordered_map>> tags; + std::unique_ptr<_Initializers> initializers_; + + auto& initializers() { return *initializers_; } }; @@ -134,17 +144,12 @@ void HybridModel::i auto _ = this->resourcesManager->setOnPatch(*patch, state.electromag, state.ions); for (auto& pop : ions) - { - auto const& info = pop.particleInitializerInfo(); - auto particleInitializer = ParticleInitializerFactory::create(info); - particleInitializer->loadParticles(pop.domainParticles(), layout, pop.name()); - } - - state.electromag.initialize(layout); + initializers_->particles(pop).loadParticles(pop.domainParticles(), layout, pop.name()); + initializers_->electromag().init(state.electromag, layout); } - resourcesManager->registerForRestarts(*this); + initializers_.release(); } @@ -195,6 +200,40 @@ struct type_list_to_hybrid_model template using type_list_to_hybrid_model_t = typename type_list_to_hybrid_model::type; + + +template +struct HybridModel::_Initializers +{ + using particle_array_type = typename Ions::particle_array_type; + using ParticleInitializer_t = core::ParticleInitializer; + using ParticleInitializerFactory + = amr::ParticleInitializerFactory; + using ElectromagInitializer_t = amr::ElectromagInitializer; + + _Initializers(initializer::PHAREDict const& dict, HybridState_t const& state) + : dict_{dict} + , electromag_init{amr::ElectromagInitializerFactory::create( + dict["electromag"])} + { + for (auto& pop : state.ions) + particle_pop_init.emplace( + pop.name(), ParticleInitializerFactory::create(pop.particleInitializerInfo())); + } + + auto& electromag() { return *electromag_init; } + + auto& particles(typename Ions::value_type& pop) { return *particle_pop_init[pop.name()]; } + + initializer::PHAREDict dict_; + std::unique_ptr electromag_init; + std::unordered_map> particle_pop_init; +}; + + + + } // namespace PHARE::solver #endif diff --git a/src/core/data/electromag/electromag.hpp b/src/core/data/electromag/electromag.hpp index 237a72bc8..880c12e00 100644 --- a/src/core/data/electromag/electromag.hpp +++ b/src/core/data/electromag/electromag.hpp @@ -4,12 +4,11 @@ #include #include +#include "core/def.hpp" #include "core/hybrid/hybrid_quantities.hpp" -#include "core/data/vecfield/vecfield_initializer.hpp" + #include "initializer/data_provider.hpp" -#include "core/def.hpp" -#include "electromag_initializer.hpp" namespace PHARE { @@ -38,18 +37,10 @@ namespace core , B{dict["name"].template to() + "_" + dict["magnetic"]["name"].template to(), HybridQuantity::Vector::B} - , dict_{dict} { } - template - void initialize(GridLayout const& layout) - { - ElectromagInitializerFactory::create(dict_)->init(*this, layout); - // dict = initializer::PHAREDict{}; // clear ? - } - //------------------------------------------------------------------------- // start the ResourcesUser interface @@ -79,9 +70,6 @@ namespace core VecFieldT E; VecFieldT B; - - private: - initializer::PHAREDict dict_{}; }; diff --git a/src/core/data/electromag/electromag_initializer.hpp b/src/core/data/electromag/electromag_initializer.hpp deleted file mode 100644 index 1aa780695..000000000 --- a/src/core/data/electromag/electromag_initializer.hpp +++ /dev/null @@ -1,55 +0,0 @@ -#ifndef _PHARE_CORE_DATA_ELECTROMAG_ELECTROMAG_INITIALIZER_HPP_ -#define _PHARE_CORE_DATA_ELECTROMAG_ELECTROMAG_INITIALIZER_HPP_ - -#include "initializer/data_provider.hpp" - -#include - - -namespace PHARE::core -{ - -template -class ElectromagInitializer -{ -public: - virtual void init(Electromag_t& /*em*/, GridLayout const& /*layout*/) const { /*noop*/ } - virtual ~ElectromagInitializer() {} -}; - -template -class ElectromagUserFuncInitializer : public ElectromagInitializer -{ -public: - ElectromagUserFuncInitializer(initializer::PHAREDict const& dict) - : Binit_{dict["magnetic"]["initializer"]} - { - } - virtual ~ElectromagUserFuncInitializer() {} - - void init(Electromag_t& em, GridLayout const& layout) const override - { - Binit_.initialize(em.B, layout); - } - - VecFieldInitializer Binit_; -}; - - -template -class ElectromagInitializerFactory -{ -public: - NO_DISCARD static std::unique_ptr> - create(initializer::PHAREDict const& dict) - { - if (dict["magnetic"]["initializer"].contains("x_component")) - return std::make_unique>(dict); - else - return std::make_unique>(); - } -}; - -} // namespace PHARE::core - -#endif // _PHARE_CORE_DATA_ELECTROMAG_ELECTROMAG_INITIALIZER_HPP_ diff --git a/src/core/utilities/types.hpp b/src/core/utilities/types.hpp index 412456da7..5b7dc168e 100644 --- a/src/core/utilities/types.hpp +++ b/src/core/utilities/types.hpp @@ -156,6 +156,15 @@ namespace core return to; } + template + NO_DISCARD std::array to_array(std::vector const& from) + { + std::array to{}; + for (std::size_t i = 0; i < to.size(); i++) + to[i] = from[i]; + return to; + } + template NO_DISCARD constexpr auto as_sized_array(Args&&... args) diff --git a/src/hdf5/detail/h5/group_scanner.hpp b/src/hdf5/detail/h5/group_scanner.hpp new file mode 100644 index 000000000..a876a62bb --- /dev/null +++ b/src/hdf5/detail/h5/group_scanner.hpp @@ -0,0 +1,72 @@ +#ifndef _PHARE_HDF5_DETAIL_H5_GROUP_SCANNER_HPP_ +#define _PHARE_HDF5_DETAIL_H5_GROUP_SCANNER_HPP_ + +#include "core/def.hpp" +#include "core/def/phare_mpi.hpp" + +#include "highfive/H5File.hpp" +#include "highfive/H5Easy.hpp" + +#include "core/utilities/types.hpp" +#include "core/utilities/mpi_utils.hpp" +#include "core/utilities/meta/meta_utilities.hpp" + +#include + +namespace PHARE::hdf5::h5 +{ + +template +struct GroupScanner +{ + GroupScanner(HighFiveFile_t const& h5_, std::vector const& contains_ = {}) + : h5{h5_} + , contains{contains_} + { + } + + + auto& scan(std::string const& from = "/") + { + scan(h5.file().getGroup(from), from); + return groups; + } + void scan(HighFive::Group const& group, std::string const& path) + { + for (auto const& node : group.listObjectNames()) + { + if (group.getObjectType(node) == HighFive::ObjectType::Group) + scan(group.getGroup(node), path + "/" + node); + else + { + auto fpath = path + "/" + node; + if (contains.size() == 0) + groups.insert(fpath); + else + { + bool cont = false; + for (auto const& c : contains) + if (fpath.find(c) == std::string::npos) + { + cont = true; + break; + } + if (cont) // next node in listObjectNames + continue; + groups.insert(fpath); + } + } + } + } + + + HighFiveFile_t const& h5; + std::vector contains; + std::unordered_set groups{}; +}; + + +} // namespace PHARE::hdf5::h5 + + +#endif /* _PHARE_HDF5_DETAIL_H5_GROUP_SCANNER_HPP_ */ diff --git a/src/hdf5/detail/h5/h5_file.hpp b/src/hdf5/detail/h5/h5_file.hpp index d18e0a4f0..9ee4d43da 100644 --- a/src/hdf5/detail/h5/h5_file.hpp +++ b/src/hdf5/detail/h5/h5_file.hpp @@ -12,6 +12,9 @@ #include +#include "group_scanner.hpp" + + namespace PHARE::hdf5::h5 { using HiFile = HighFive::File; @@ -41,6 +44,7 @@ NO_DISCARD auto vector_for_dim() return std::vector>>(); } + class HighFiveFile { public: @@ -247,54 +251,11 @@ class HighFiveFile return attr; } - // std::unordered_set scan_for_groups(){} - - // std::unordered_set scan_for_groups(std::string const& contains){} - - struct GroupScanner - { - auto& scan(std::string const& from = "/") - { - scan(h5.file().getGroup(from), from); - return groups; - } - void scan(HighFive::Group const& group, std::string const& path) - { - for (auto const& node : group.listObjectNames()) - { - if (group.getObjectType(node) == HighFive::ObjectType::Group) - scan(group.getGroup(node), path + "/" + node); - else - { - auto fpath = path + "/" + node; - if (contains.size() == 0) - groups.insert(fpath); - else - { - bool cont = false; - for (auto const& c : contains) - if (fpath.find(c) == std::string::npos) - { - cont = true; - break; - } - if (cont) // next node in listObjectNames - continue; - groups.insert(fpath); - } - } - } - } - - HighFiveFile const& h5; - std::vector contains{}; - std::unordered_set groups{}; - }; std::unordered_set scan_for_groups(std::vector const& contains) { - return GroupScanner{*this, contains}.scan(); + return GroupScanner{*this, contains}.scan(); } @@ -340,7 +301,6 @@ class HighFiveFile - } // namespace PHARE::hdf5::h5 diff --git a/tests/amr/tagging/test_tagging.cpp b/tests/amr/tagging/test_tagging.cpp index 238126749..6096e0f8c 100644 --- a/tests/amr/tagging/test_tagging.cpp +++ b/tests/amr/tagging/test_tagging.cpp @@ -179,9 +179,18 @@ struct TestTagger : public ::testing::Test { using gridlayout_type = GridLayout>; static auto constexpr dimension = dim; - HybridState state; + + PHARE::initializer::PHAREDict dict_; + HybridState state{dict_}; + + void init(Electromag& em, GridLayoutT const& layout) + { + ElectromagUserFuncInitializer{dict_["electromag"]}.init( + em, layout); + } }; + PHARE::initializer::PHAREDict dict_; GridLayoutT layout; UsableVecField B, E; @@ -190,15 +199,17 @@ struct TestTagger : public ::testing::Test std::vector tags; TestTagger() - : layout{TestGridLayout::make(20)} + : dict_{createDict()} + , layout{TestGridLayout::make(20)} , B{"EM_B", layout, HybridQuantity::Vector::B} , E{"EM_E", layout, HybridQuantity::Vector::E} - , model{createDict()} + , model{dict_} , tags(20 + layout.nbrGhosts(PHARE::core::QtyCentering::dual)) { B.set_on(model.state.electromag.B); E.set_on(model.state.electromag.E); - model.state.electromag.initialize(layout); + + model.init(model.state.electromag, layout); } }; diff --git a/tests/core/numerics/ion_updater/test_updater.cpp b/tests/core/numerics/ion_updater/test_updater.cpp index eeeae2e43..c73b5a887 100644 --- a/tests/core/numerics/ion_updater/test_updater.cpp +++ b/tests/core/numerics/ion_updater/test_updater.cpp @@ -3,6 +3,7 @@ #include "phare_core.hpp" #include "core/numerics/ion_updater/ion_updater.hpp" +#include "amr/data/electromag/electromag_initializer.hpp" #include "amr/data/particles/initializers/particle_initializer_factory.hpp" #include "tests/core/data/vecfield/test_vecfield_fixtures.hpp" @@ -357,6 +358,7 @@ struct IonUpdaterTest : public ::testing::Test using ParticleInitializerFactory = PHARE::amr::ParticleInitializerFactory; + using ElectromagInitializerFactory_t = PHARE::amr::ElectromagInitializerFactory; using IonUpdater = typename PHARE::core::IonUpdater; @@ -394,8 +396,7 @@ struct IonUpdaterTest : public ::testing::Test // now let's initialize Electromag fields to user input functions // and ion population particles to user supplied moments - - EM.initialize(layout); + ElectromagInitializerFactory_t::create(init_dict)->init(EM, layout); for (auto& pop : ions) { auto const& info = pop.particleInitializerInfo();