From b669159d6f601ee284faed7cc5cd172d13dbbc13 Mon Sep 17 00:00:00 2001 From: dekken Date: Thu, 30 Nov 2023 15:50:56 +0100 Subject: [PATCH 1/4] views init field -> grid more more more --- res/cmake/dep.cmake | 2 +- res/cmake/test.cmake | 2 +- src/amr/data/field/field_data.hpp | 6 +- .../hybrid_hybrid_messenger_strategy.hpp | 55 +-- src/amr/multiphysics_integrator.hpp | 16 +- src/amr/physical_models/hybrid_model.hpp | 22 +- src/amr/resources_manager/field_resource.hpp | 4 +- .../resources_manager/resources_manager.hpp | 5 +- src/amr/solvers/solver.hpp | 31 +- src/amr/solvers/solver_mhd.hpp | 22 +- src/amr/solvers/solver_ppc.hpp | 316 ++++++------------ src/amr/solvers/solver_ppc_model_view.hpp | 212 ++++++++++++ .../default_hybrid_tagger_strategy.hpp | 2 +- src/amr/tagging/hybrid_tagger.hpp | 2 +- src/core/data/electrons/electrons.hpp | 67 ++-- src/core/data/field/field.hpp | 108 +++--- src/core/data/grid/grid.hpp | 97 ++++++ src/core/data/grid/gridlayout.hpp | 38 +-- .../ions/ion_population/ion_population.hpp | 1 + src/core/data/ions/ions.hpp | 3 + src/core/data/ndarray/ndarray_vector.hpp | 36 +- src/core/data/vecfield/vecfield.hpp | 18 +- src/core/models/hybrid_state.hpp | 4 +- src/core/numerics/ampere/ampere.hpp | 11 + src/core/numerics/faraday/faraday.hpp | 11 + src/core/numerics/ohm/ohm.hpp | 12 + src/core/utilities/box/box.hpp | 6 - src/core/utilities/types.hpp | 113 ++++++- src/diagnostic/detail/types/fluid.hpp | 2 +- src/phare_core.hpp | 11 +- src/simulator/phare_types.hpp | 1 + .../field/coarsening/test_linear_coarsen.hpp | 5 +- .../field/copy_pack/field_data_test_param.hpp | 5 +- .../field/geometry/test_field_geometry.cpp | 3 +- .../data/field/refine/test_field_refine.cpp | 2 +- .../test_field_refinement_on_hierarchy.cpp | 4 +- .../test_field_refinement_on_hierarchy.hpp | 1 + .../test_field_data_time_interpolate.cpp | 4 +- .../field/variable/test_field_variable.cpp | 4 +- tests/amr/models/test_models.cpp | 21 +- tests/amr/resources_manager/CMakeLists.txt | 1 - tests/amr/resources_manager/input_config.h | 15 + .../test_resources_manager.cpp | 23 +- ...test_resources_manager_basic_hierarchy.cpp | 51 --- ...test_resources_manager_basic_hierarchy.hpp | 52 +++ tests/amr/tagging/test_tagging.cpp | 2 +- tests/core/data/electrons/test_electrons.cpp | 126 +++---- tests/core/data/field/test_field.hpp | 37 +- .../core/data/{field => grid}/CMakeLists.txt | 4 +- .../test_field.cpp => grid/test_grid.cpp} | 108 +++--- .../gridlayout/gridlayout_base_params.hpp | 14 +- .../core/data/gridlayout/gridlayout_deriv.hpp | 14 +- .../data/gridlayout/gridlayout_laplacian.hpp | 20 +- .../ion_population/test_ion_population.cpp | 1 + tests/core/data/ions/test_ions.cpp | 5 +- tests/core/data/vecfield/test_main.cpp | 50 +-- tests/core/numerics/ampere/test_main.cpp | 90 +++-- tests/core/numerics/faraday/test_main.cpp | 139 ++++---- .../core/numerics/interpolator/test_main.cpp | 76 +++-- .../numerics/ion_updater/test_updater.cpp | 6 +- tests/core/numerics/ohm/test_main.cpp | 37 +- tests/functional/harris/harris_2d_2.py | 183 ++++++++++ 62 files changed, 1472 insertions(+), 867 deletions(-) create mode 100644 src/amr/solvers/solver_ppc_model_view.hpp create mode 100644 src/core/data/grid/grid.hpp create mode 100644 tests/amr/resources_manager/input_config.h delete mode 100644 tests/amr/resources_manager/test_resources_manager_basic_hierarchy.cpp rename tests/core/data/{field => grid}/CMakeLists.txt (86%) rename tests/core/data/{field/test_field.cpp => grid/test_grid.cpp} (57%) create mode 100644 tests/functional/harris/harris_2d_2.py diff --git a/res/cmake/dep.cmake b/res/cmake/dep.cmake index 027cfe5ef..1caaa2355 100644 --- a/res/cmake/dep.cmake +++ b/res/cmake/dep.cmake @@ -6,7 +6,7 @@ include("${PHARE_PROJECT_DIR}/res/cmake/dep/samrai.cmake") # caliper build option # enabled with -DCALIPER_ROOT=/path/to/caliper -# or -DwithCaliper, which dowloads to subprojects dir +# or -DwithCaliper, which downloads to subprojects dir include("${PHARE_PROJECT_DIR}/res/cmake/dep/caliper.cmake") # pybind diff --git a/res/cmake/test.cmake b/res/cmake/test.cmake index 3d395c8bb..1f7331b1d 100644 --- a/res/cmake/test.cmake +++ b/res/cmake/test.cmake @@ -8,7 +8,7 @@ if (test AND ${PHARE_EXEC_LEVEL_MIN} GREATER 0) # 0 = no tests add_subdirectory(tests/core/data/ndarray) - add_subdirectory(tests/core/data/field) + add_subdirectory(tests/core/data/grid) add_subdirectory(tests/core/data/gridlayout) add_subdirectory(tests/core/data/vecfield) add_subdirectory(tests/core/data/particles) diff --git a/src/amr/data/field/field_data.hpp b/src/amr/data/field/field_data.hpp index 8c0de41b9..565b9e234 100644 --- a/src/amr/data/field/field_data.hpp +++ b/src/amr/data/field/field_data.hpp @@ -86,7 +86,9 @@ namespace amr { Super::getFromRestart(restart_db); - restart_db->getVector("field_" + field.name(), field.vector()); + assert(field.vector().size() > 0); + restart_db->getDoubleArray("field_" + field.name(), field.vector().data(), + field.vector().size()); // do not reallocate! } void putToRestart(std::shared_ptr const& restart_db) const override @@ -309,7 +311,7 @@ namespace amr - FieldImpl* getPointer() { return &field; } + auto* getPointer() { return &field; } static GridLayoutT const& getLayout(SAMRAI::hier::Patch const& patch, int id) diff --git a/src/amr/messengers/hybrid_hybrid_messenger_strategy.hpp b/src/amr/messengers/hybrid_hybrid_messenger_strategy.hpp index 5e790bd25..e129c97b5 100644 --- a/src/amr/messengers/hybrid_hybrid_messenger_strategy.hpp +++ b/src/amr/messengers/hybrid_hybrid_messenger_strategy.hpp @@ -48,30 +48,43 @@ namespace amr // this structure is a wrapper of a field* // so to serve as a ResourcesUser for the ResourcesManager - template + template struct FieldUser { + using grid_type = GridT; + using field_type = typename GridT::field_type; + struct Property { std::string name; typename PHARE::core::HybridQuantity::Scalar qty; }; - FieldUser(std::string fieldName, FieldT* ptr, + + FieldUser(std::string fieldName, field_type* ptr, typename PHARE::core::HybridQuantity::Scalar qty) : name{fieldName} , f{ptr} , quantity{qty} { } - std::string name; - FieldT* f; - typename PHARE::core::HybridQuantity::Scalar quantity; - using field_type = FieldT; std::vector getFieldNamesAndQuantities() const { return {{name, quantity}}; } - void setBuffer(std::string const& /*bufferName*/, FieldT* field) { f = field; } - void copyData(FieldT const& source) { f->copyData(source); } + void setBuffer(std::string const& /*bufferName*/, field_type* field) + { + f = field; + } + + template + void copyData(That const& that) + { + assert(f); + f->copyData(that); + } + + std::string name; + field_type* f{nullptr}; + typename PHARE::core::HybridQuantity::Scalar quantity; }; @@ -82,29 +95,31 @@ namespace amr template class HybridHybridMessengerStrategy : public HybridMessengerStrategy { - using IonsT = typename HybridModel::ions_type; - using ElectromagT = typename HybridModel::electromag_type; - using VecFieldT = typename HybridModel::vecfield_type; - using GridLayoutT = typename HybridModel::gridlayout_type; - using FieldT = typename VecFieldT::field_type; - using ResourcesManagerT = typename HybridModel::resources_manager_type; + using GridT = typename HybridModel::grid_type; + using IonsT = typename HybridModel::ions_type; + using ElectromagT = typename HybridModel::electromag_type; + using VecFieldT = typename HybridModel::vecfield_type; + using GridLayoutT = typename HybridModel::gridlayout_type; + using FieldT = typename VecFieldT::field_type; + using ResourcesManagerT = typename HybridModel::resources_manager_type; + using IPhysicalModel = typename HybridModel::Interface; + static constexpr std::size_t dimension = GridLayoutT::dimension; static constexpr std::size_t interpOrder = GridLayoutT::interp_order; - using IPhysicalModel = typename HybridModel::Interface; using InteriorParticleRefineOp = typename RefinementParams::InteriorParticleRefineOp; using CoarseToFineRefineOpOld = typename RefinementParams::CoarseToFineRefineOpOld; using CoarseToFineRefineOpNew = typename RefinementParams::CoarseToFineRefineOpNew; template - using BaseRefineOp = FieldRefineOperator; + using BaseRefineOp = FieldRefineOperator; using DefaultFieldRefineOp = BaseRefineOp>; using MagneticFieldRefineOp = BaseRefineOp>; using ElectricFieldRefineOp = BaseRefineOp>; - using FieldTimeInterp = FieldLinearTimeInterpolate; + using FieldTimeInterp = FieldLinearTimeInterpolate; template - using BaseCoarsenOp = FieldCoarsenOperator; + using BaseCoarsenOp = FieldCoarsenOperator; using MagneticCoarsenOp = BaseCoarsenOp>; using DefaultCoarsenOp = BaseCoarsenOp>; @@ -991,8 +1006,8 @@ namespace amr VecFieldT Jold_{stratName + "_Jold", core::HybridQuantity::Vector::J}; VecFieldT ViOld_{stratName + "_VBulkOld", core::HybridQuantity::Vector::V}; FieldT* NiOld_{nullptr}; - FieldUser NiOldUser_{stratName + "_NiOld", NiOld_, - core::HybridQuantity::Scalar::rho}; + FieldUser NiOldUser_{stratName + "_NiOld", NiOld_, + core::HybridQuantity::Scalar::rho}; //! ResourceManager shared with other objects (like the HybridModel) diff --git a/src/amr/multiphysics_integrator.hpp b/src/amr/multiphysics_integrator.hpp index 9e198bcab..b9c982d48 100644 --- a/src/amr/multiphysics_integrator.hpp +++ b/src/amr/multiphysics_integrator.hpp @@ -344,6 +344,11 @@ namespace solver levelInitializer.initialize(hierarchy, levelNumber, oldLevel, model, messenger, initDataTime, isRegridding); + + if (static_cast(levelNumber) == model_views_.size()) + model_views_.push_back(solver.make_view(*level, model)); + else + model_views_[levelNumber] = solver.make_view(*level, model); } @@ -360,7 +365,11 @@ namespace solver { auto& messenger = getMessengerWithCoarser_(coarsestLevel); for (auto ilvl = coarsestLevel; ilvl <= finestLevel; ++ilvl) + { messenger.registerLevel(hierarchy, ilvl); + model_views_.push_back(getSolver_(ilvl).make_view( + AMR_Types::getLevel(*hierarchy, ilvl), getModel_(ilvl))); + } restartInitialized_ = true; } } @@ -486,7 +495,8 @@ namespace solver fromCoarser.prepareStep(model, *level, currentTime); - solver.advanceLevel(hierarchy, iLevel, model, fromCoarser, currentTime, newTime); + solver.advanceLevel(*hierarchy, iLevel, model, fromCoarser, currentTime, newTime, + getModelView_(iLevel)); if (lastStep) { @@ -565,6 +575,9 @@ namespace solver std::vector levelDescriptors_; std::vector>> solvers_; std::vector>> models_; + + std::vector> model_views_; + std::vector> taggers_; std::map> messengers_; std::map> levelInitializers_; @@ -791,6 +804,7 @@ namespace solver } + auto& getModelView_(int iLevel) { return *model_views_[iLevel]; } IPhysicalModel& getModel_(int iLevel) diff --git a/src/amr/physical_models/hybrid_model.hpp b/src/amr/physical_models/hybrid_model.hpp index 9f6308666..ad826cb87 100644 --- a/src/amr/physical_models/hybrid_model.hpp +++ b/src/amr/physical_models/hybrid_model.hpp @@ -4,6 +4,7 @@ #include #include "initializer/data_provider.hpp" +#include "core/data/grid/grid.hpp" // !?! #include "core/models/hybrid_state.hpp" #include "amr/physical_models/physical_model.hpp" #include "core/data/ions/particle_initializers/particle_initializer_factory.hpp" @@ -23,23 +24,26 @@ template { public: + static constexpr auto dimension = GridLayoutT::dimension; using type_list = PHARE::core::type_list; using Interface = IPhysicalModel; using amr_types = AMR_Types; using patch_t = typename AMR_Types::patch_t; using level_t = typename AMR_Types::level_t; - static const std::string model_name; - using gridlayout_type = GridLayoutT; - using electromag_type = Electromag; - using vecfield_type = typename Electromag::vecfield_type; - using field_type = typename vecfield_type::field_type; - using ions_type = Ions; - using particle_array_type = typename Ions::particle_array_type; - using resources_manager_type = amr::ResourcesManager; - static constexpr auto dimension = GridLayoutT::dimension; + using gridlayout_type = GridLayoutT; + using electromag_type = Electromag; + using vecfield_type = typename Electromag::vecfield_type; + using field_type = typename vecfield_type::field_type; + using grid_type = core::Grid, + typename field_type::physical_quantity_type>; + using ions_type = Ions; + using particle_array_type = typename Ions::particle_array_type; + using resources_manager_type = amr::ResourcesManager; using ParticleInitializerFactory = core::ParticleInitializerFactory; + static const std::string model_name; + core::HybridState state; std::shared_ptr resourcesManager; diff --git a/src/amr/resources_manager/field_resource.hpp b/src/amr/resources_manager/field_resource.hpp index 1304c07d3..329e620e2 100644 --- a/src/amr/resources_manager/field_resource.hpp +++ b/src/amr/resources_manager/field_resource.hpp @@ -14,8 +14,8 @@ namespace amr template struct UserFieldType { - using patch_data_type = FieldData; - using variable_type = FieldVariable; + using patch_data_type = FieldData; + using variable_type = FieldVariable; using internal_type_ptr = typename ResourcesUser::field_type*; }; diff --git a/src/amr/resources_manager/resources_manager.hpp b/src/amr/resources_manager/resources_manager.hpp index 4b8c89ecd..a3f8bb1ed 100644 --- a/src/amr/resources_manager/resources_manager.hpp +++ b/src/amr/resources_manager/resources_manager.hpp @@ -571,9 +571,8 @@ namespace amr //! \brief Allocate the data on the given level template - void allocate_([[maybe_unused]] ResourcesUser const& obj, - ResourcesProperties const& resourcesProperties, SAMRAI::hier::Patch& patch, - double const allocateTime) const + void allocate_(ResourcesUser const& /*obj*/, ResourcesProperties const& resourcesProperties, + SAMRAI::hier::Patch& patch, double const allocateTime) const { for (auto const& properties : resourcesProperties) { diff --git a/src/amr/solvers/solver.hpp b/src/amr/solvers/solver.hpp index 1efcc0ada..c8f52a35d 100644 --- a/src/amr/solvers/solver.hpp +++ b/src/amr/solvers/solver.hpp @@ -12,6 +12,21 @@ #include "amr/physical_models/physical_model.hpp" #include "core/def.hpp" +namespace PHARE::solver +{ + + +class ISolverModelView +{ +public: + using This = ISolverModelView; + + virtual ~ISolverModelView() = default; +}; + + +} // namespace PHARE::solver + namespace PHARE @@ -29,6 +44,10 @@ namespace solver class ISolver { public: + using patch_t = typename AMR_Types::patch_t; + using level_t = typename AMR_Types::level_t; + using hierarchy_t = typename AMR_Types::hierarchy_t; + /** * @brief return the name of the ISolver */ @@ -67,10 +86,11 @@ namespace solver /** * @brief advanceLevel advances the given level from t to t+dt */ - virtual void advanceLevel(std::shared_ptr const& hierarchy, - int const levelNumber, IPhysicalModel& model, + virtual void advanceLevel(hierarchy_t const& hierarchy, int const levelNumber, + IPhysicalModel& model, amr::IMessenger>& fromCoarser, - const double currentTime, const double newTime) + const double currentTime, const double newTime, + ISolverModelView& view) = 0; @@ -80,7 +100,7 @@ namespace solver * @brief allocate is used to allocate ISolver variables previously registered to the * ResourcesManager of the given model, onto the given Patch, at the given time. */ - virtual void allocate(IPhysicalModel& model, SAMRAI::hier::Patch& patch, + virtual void allocate(IPhysicalModel& model, patch_t& patch, double const allocateTime) const = 0; @@ -89,6 +109,9 @@ namespace solver virtual ~ISolver() = default; + virtual std::shared_ptr make_view(level_t&, IPhysicalModel&) + = 0; + protected: explicit ISolver(std::string name) : solverName{std::move(name)} diff --git a/src/amr/solvers/solver_mhd.hpp b/src/amr/solvers/solver_mhd.hpp index 7e08bfc29..492c4d821 100644 --- a/src/amr/solvers/solver_mhd.hpp +++ b/src/amr/solvers/solver_mhd.hpp @@ -14,6 +14,10 @@ namespace solver class SolverMHD : public ISolver { public: + using patch_t = typename AMR_Types::patch_t; + using level_t = typename AMR_Types::level_t; + using hierarchy_t = typename AMR_Types::hierarchy_t; + SolverMHD() : ISolver{"MHDSolver"} { @@ -34,17 +38,23 @@ namespace solver virtual void registerResources(IPhysicalModel& /*model*/) override {} // TODO make this a resourcesUser - virtual void allocate(IPhysicalModel& /*model*/, SAMRAI::hier::Patch& /*patch*/, + virtual void allocate(IPhysicalModel& /*model*/, patch_t& /*patch*/, double const /*allocateTime*/) const override { } - virtual void - advanceLevel(std::shared_ptr const& /*hierarchy*/, - int const /*levelNumber*/, IPhysicalModel& /*model*/, - amr::IMessenger>& /*fromCoarser*/, - const double /*currentTime*/, const double /*newTime*/) override + virtual void advanceLevel(hierarchy_t const& /*hierarchy*/, int const /*levelNumber*/, + IPhysicalModel& /*model*/, + amr::IMessenger>& /*fromCoarser*/, + const double /*currentTime*/, const double /*newTime*/, + ISolverModelView& /*view*/) override + { + } + + std::shared_ptr make_view(level_t&, IPhysicalModel&) override { + throw std::runtime_error("Not implemented in mhd solver"); + return nullptr; } }; } // namespace solver diff --git a/src/amr/solvers/solver_ppc.hpp b/src/amr/solvers/solver_ppc.hpp index ea0442af1..7b3503628 100644 --- a/src/amr/solvers/solver_ppc.hpp +++ b/src/amr/solvers/solver_ppc.hpp @@ -11,7 +11,7 @@ #include "amr/resources_manager/amr_utils.hpp" #include "amr/solvers/solver.hpp" - +#include "amr/solvers/solver_ppc_model_view.hpp" #include "core/numerics/ion_updater/ion_updater.hpp" #include "core/numerics/ampere/ampere.hpp" @@ -46,6 +46,7 @@ class SolverPPC : public ISolver using IMessenger = amr::IMessenger; using HybridMessenger = amr::HybridMessenger; + using HybridModelView_t = HybridPPCModelView; Electromag electromagPred_{"EMPred"}; Electromag electromagAvg_{"EMAvg"}; @@ -73,50 +74,54 @@ class SolverPPC : public ISolver { } - virtual ~SolverPPC() = default; - + ~SolverPPC() override = default; - virtual std::string modelName() const override { return HybridModel::model_name; } - virtual void fillMessengerInfo(std::unique_ptr const& info) const override; + std::string modelName() const override { return HybridModel::model_name; } + void fillMessengerInfo(std::unique_ptr const& info) const override; - virtual void registerResources(IPhysicalModel_t& model) override; + void registerResources(IPhysicalModel_t& model) override; - virtual void allocate(IPhysicalModel_t& model, SAMRAI::hier::Patch& patch, - double const allocateTime) const override; + void allocate(IPhysicalModel_t& model, SAMRAI::hier::Patch& patch, + double const allocateTime) const override; - virtual void advanceLevel(std::shared_ptr const& hierarchy, int const levelNumber, - IPhysicalModel_t& model, IMessenger& fromCoarserMessenger, - double const currentTime, double const newTime) override; + void advanceLevel(hierarchy_t const& hierarchy, int const levelNumber, IPhysicalModel_t& model, + IMessenger& fromCoarserMessenger, double const currentTime, + double const newTime, ISolverModelView& view) override; + std::shared_ptr make_view(level_t& level, IPhysicalModel_t& model) override + { + return std::make_shared(level, dynamic_cast(model)); + } private: using Messenger = amr::HybridMessenger; void predictor1_(level_t& level, HybridModel& model, Messenger& fromCoarser, - double const currentTime, double const newTime); + double const currentTime, double const newTime, HybridModelView_t& view); void predictor2_(level_t& level, HybridModel& model, Messenger& fromCoarser, - double const currentTime, double const newTime); + double const currentTime, double const newTime, HybridModelView_t& view); void corrector_(level_t& level, HybridModel& model, Messenger& fromCoarser, - double const currentTime, double const newTime); + double const currentTime, double const newTime, HybridModelView_t& view); - void average_(level_t& level, HybridModel& model, Messenger& fromCoarser, double const newTime); + void average_(level_t& level, HybridModel& model, Messenger& fromCoarser, double const newTime, + HybridModelView_t& view); void moveIons_(level_t& level, Ions& ions, Electromag& electromag, ResourcesManager& rm, Messenger& fromCoarser, double const currentTime, double const newTime, - core::UpdaterMode mode); + core::UpdaterMode mode, HybridModelView_t& view); void saveState_(level_t& level, Ions& ions, ResourcesManager& rm); @@ -217,43 +222,42 @@ void SolverPPC::restoreState_(level_t& level, Ions& ions template -void SolverPPC::advanceLevel(std::shared_ptr const& hierarchy, +void SolverPPC::advanceLevel(hierarchy_t const& hierarchy, int const levelNumber, IPhysicalModel_t& model, IMessenger& fromCoarserMessenger, - double const currentTime, double const newTime) + double const currentTime, double const newTime, + ISolverModelView& view) { PHARE_LOG_SCOPE("SolverPPC::advanceLevel"); auto& hybridModel = dynamic_cast(model); + auto& modelView = dynamic_cast(view); auto& hybridState = hybridModel.state; auto& fromCoarser = dynamic_cast(fromCoarserMessenger); auto& resourcesManager = *hybridModel.resourcesManager; - auto level = hierarchy->getPatchLevel(levelNumber); + auto level = hierarchy.getPatchLevel(levelNumber); - predictor1_(*level, hybridModel, fromCoarser, currentTime, newTime); + predictor1_(*level, hybridModel, fromCoarser, currentTime, newTime, modelView); - average_(*level, hybridModel, fromCoarser, newTime); + average_(*level, hybridModel, fromCoarser, newTime, modelView); saveState_(*level, hybridState.ions, resourcesManager); moveIons_(*level, hybridState.ions, electromagAvg_, resourcesManager, fromCoarser, currentTime, - newTime, core::UpdaterMode::domain_only); + newTime, core::UpdaterMode::domain_only, modelView); - predictor2_(*level, hybridModel, fromCoarser, currentTime, newTime); + predictor2_(*level, hybridModel, fromCoarser, currentTime, newTime, modelView); - average_(*level, hybridModel, fromCoarser, newTime); + average_(*level, hybridModel, fromCoarser, newTime, modelView); restoreState_(*level, hybridState.ions, resourcesManager); moveIons_(*level, hybridState.ions, electromagAvg_, resourcesManager, fromCoarser, currentTime, - newTime, core::UpdaterMode::all); - - corrector_(*level, hybridModel, fromCoarser, currentTime, newTime); + newTime, core::UpdaterMode::all, modelView); - - // return newTime; + corrector_(*level, hybridModel, fromCoarser, currentTime, newTime, modelView); } @@ -262,76 +266,37 @@ void SolverPPC::advanceLevel(std::shared_ptr void SolverPPC::predictor1_(level_t& level, HybridModel& model, Messenger& fromCoarser, - double const currentTime, double const newTime) + double const currentTime, double const newTime, + HybridModelView_t& view) { PHARE_LOG_SCOPE("SolverPPC::predictor1_"); - auto& hybridState = model.state; auto& resourcesManager = model.resourcesManager; auto dt = newTime - currentTime; - auto& electromag = hybridState.electromag; - auto levelNumber = level.getLevelNumber(); - { PHARE_LOG_SCOPE("SolverPPC::predictor1_.faraday"); - - auto& Bpred = electromagPred_.B; - auto& B = electromag.B; - auto& E = electromag.E; - - for (auto& patch : level) - { - auto _ = resourcesManager->setOnPatch(*patch, Bpred, B, E); - auto layout = PHARE::amr::layoutFromPatch(*patch); - auto __ = core::SetLayout(&layout, faraday_); - faraday_(B, E, Bpred, dt); - resourcesManager->setTime(Bpred, *patch, newTime); - } + faraday_( + view, [](auto& state) { return state.ppc_predictor1_faraday(); }, dt); + for (auto& state : view) + resourcesManager->setTime(state.electromagPred.B, *state.patch, newTime); } - - { PHARE_LOG_SCOPE("SolverPPC::predictor1_.ampere"); - - auto& Bpred = electromagPred_.B; - auto& J = hybridState.J; - - for (auto& patch : level) - { - auto _ = resourcesManager->setOnPatch(*patch, Bpred, J); - auto layout = PHARE::amr::layoutFromPatch(*patch); - auto __ = core::SetLayout(&layout, ampere_); - ampere_(Bpred, J); - - resourcesManager->setTime(J, *patch, newTime); - } - fromCoarser.fillCurrentGhosts(J, levelNumber, newTime); + ampere_.op(view, [](auto& state) { return state.ppc_predictor1_ampere(); }); + for (auto& state : view) + resourcesManager->setTime(state.J, *state.patch, newTime); + fromCoarser.fillCurrentGhosts(model.state.J, level.getLevelNumber(), newTime); } - - { PHARE_LOG_SCOPE("SolverPPC::predictor1_.ohm"); - - auto& electrons = hybridState.electrons; - auto& Bpred = electromagPred_.B; - auto& Epred = electromagPred_.E; - auto& J = hybridState.J; - - for (auto& patch : level) - { - auto layout = PHARE::amr::layoutFromPatch(*patch); - auto _ = resourcesManager->setOnPatch(*patch, Bpred, Epred, J, electrons); - electrons.update(layout); - auto& Ve = electrons.velocity(); - auto& Ne = electrons.density(); - auto& Pe = electrons.pressure(); - auto __ = core::SetLayout(&layout, ohm_); - ohm_(Ne, Ve, Pe, Bpred, J, Epred); - resourcesManager->setTime(Epred, *patch, newTime); - } + for (auto& state : view) + state.electrons.update(state.layout); + ohm_(view, [](auto& state) { return state.ppc_predictor1_ohm(); }); + for (auto& state : view) + resourcesManager->setTime(state.electromagPred.E, *state.patch, newTime); } } @@ -339,76 +304,37 @@ void SolverPPC::predictor1_(level_t& level, HybridModel& template void SolverPPC::predictor2_(level_t& level, HybridModel& model, Messenger& fromCoarser, - double const currentTime, double const newTime) + double const currentTime, double const newTime, + HybridModelView_t& view) { PHARE_LOG_SCOPE("SolverPPC::predictor2_"); - auto& hybridState = model.state; auto& resourcesManager = model.resourcesManager; auto dt = newTime - currentTime; - auto levelNumber = level.getLevelNumber(); - - { PHARE_LOG_SCOPE("SolverPPC::predictor2_.faraday"); - - auto& Bpred = electromagPred_.B; - auto& B = hybridState.electromag.B; - auto& Eavg = electromagAvg_.E; - - for (auto& patch : level) - { - auto _ = resourcesManager->setOnPatch(*patch, Bpred, B, Eavg); - auto layout = PHARE::amr::layoutFromPatch(*patch); - auto __ = core::SetLayout(&layout, faraday_); - faraday_(B, Eavg, Bpred, dt); - - resourcesManager->setTime(Bpred, *patch, newTime); - } + faraday_( + view, [](auto& state) { return state.ppc_predictor2_faraday(); }, dt); + for (auto& state : view) + resourcesManager->setTime(state.electromagPred.B, *state.patch, newTime); } - { PHARE_LOG_SCOPE("SolverPPC::predictor2_.ampere"); - - auto& Bpred = electromagPred_.B; - auto& J = hybridState.J; - - - for (auto& patch : level) - { - auto _ = resourcesManager->setOnPatch(*patch, Bpred, J); - auto layout = PHARE::amr::layoutFromPatch(*patch); - auto __ = core::SetLayout(&layout, ampere_); - ampere_(Bpred, J); - - resourcesManager->setTime(J, *patch, newTime); - } - fromCoarser.fillCurrentGhosts(J, levelNumber, newTime); + ampere_.op(view, [](auto& state) { return state.ppc_predictor2_ampere(); }); + for (auto& state : view) + resourcesManager->setTime(state.J, *state.patch, newTime); + fromCoarser.fillCurrentGhosts(model.state.J, level.getLevelNumber(), newTime); } - { PHARE_LOG_SCOPE("SolverPPC::predictor2_.ohm"); - - auto& electrons = hybridState.electrons; - auto& Bpred = electromagPred_.B; - auto& Epred = electromagPred_.E; - auto& J = hybridState.J; - - for (auto& patch : level) - { - auto layout = PHARE::amr::layoutFromPatch(*patch); - auto _ = resourcesManager->setOnPatch(*patch, Bpred, Epred, J, electrons); - electrons.update(layout); - auto& Ve = electrons.velocity(); - auto& Ne = electrons.density(); - auto& Pe = electrons.pressure(); - auto __ = core::SetLayout(&layout, ohm_); - ohm_(Ne, Ve, Pe, Bpred, J, Epred); - resourcesManager->setTime(Epred, *patch, newTime); - } + for (auto& state : view) + state.electrons.update(state.layout); + ohm_(view, [](auto& state) { return state.ppc_predictor2_ohm(); }); + for (auto& state : view) + resourcesManager->setTime(state.electromagPred.E, *state.patch, newTime); } } @@ -418,72 +344,39 @@ void SolverPPC::predictor2_(level_t& level, HybridModel& template void SolverPPC::corrector_(level_t& level, HybridModel& model, Messenger& fromCoarser, double const currentTime, - double const newTime) + double const newTime, HybridModelView_t& view) { PHARE_LOG_SCOPE("SolverPPC::corrector_"); - auto& hybridState = model.state; auto& resourcesManager = model.resourcesManager; auto dt = newTime - currentTime; auto levelNumber = level.getLevelNumber(); { PHARE_LOG_SCOPE("SolverPPC::corrector_.faraday"); - - auto& B = hybridState.electromag.B; - auto& Eavg = electromagAvg_.E; - - for (auto& patch : level) - { - auto _ = resourcesManager->setOnPatch(*patch, B, Eavg); - auto layout = PHARE::amr::layoutFromPatch(*patch); - auto __ = core::SetLayout(&layout, faraday_); - faraday_(B, Eavg, B, dt); - - resourcesManager->setTime(B, *patch, newTime); - } + faraday_( + view, [](auto& state) { return state.ppc_corrector_faraday(); }, dt); + for (auto& state : view) + resourcesManager->setTime(state.electromag.B, *state.patch, newTime); } { PHARE_LOG_SCOPE("SolverPPC::corrector_.ampere"); - - auto& B = hybridState.electromag.B; - auto& J = hybridState.J; - - for (auto& patch : level) - { - auto _ = resourcesManager->setOnPatch(*patch, B, J); - auto layout = PHARE::amr::layoutFromPatch(*patch); - auto __ = core::SetLayout(&layout, ampere_); - ampere_(B, J); - - resourcesManager->setTime(J, *patch, newTime); - } - fromCoarser.fillCurrentGhosts(J, levelNumber, newTime); + ampere_.op(view, [](auto& state) { return state.ppc_corrector_ampere(); }); + for (auto& state : view) + resourcesManager->setTime(state.J, *state.patch, newTime); + fromCoarser.fillCurrentGhosts(model.state.J, level.getLevelNumber(), newTime); } { PHARE_LOG_SCOPE("SolverPPC::corrector_.ohm"); + for (auto& state : view) + state.electrons.update(state.layout); + ohm_(view, [](auto& state) { return state.ppc_corrector_ohm(); }); + for (auto& state : view) + resourcesManager->setTime(state.electromag.E, *state.patch, newTime); - auto& electrons = hybridState.electrons; - auto& B = hybridState.electromag.B; - auto& E = hybridState.electromag.E; - auto& J = hybridState.J; - - for (auto& patch : level) - { - auto layout = PHARE::amr::layoutFromPatch(*patch); - auto _ = resourcesManager->setOnPatch(*patch, B, E, J, electrons); - electrons.update(layout); - auto& Ve = electrons.velocity(); - auto& Ne = electrons.density(); - auto& Pe = electrons.pressure(); - auto __ = core::SetLayout(&layout, ohm_); - ohm_(Ne, Ve, Pe, B, J, E); - resourcesManager->setTime(E, *patch, newTime); - } - - fromCoarser.fillElectricGhosts(E, levelNumber, newTime); + fromCoarser.fillElectricGhosts(model.state.electromag.E, levelNumber, newTime); } } @@ -491,31 +384,22 @@ void SolverPPC::corrector_(level_t& level, HybridModel& template void SolverPPC::average_(level_t& level, HybridModel& model, - Messenger& fromCoarser, double const newTime) + Messenger& fromCoarser, double const newTime, + HybridModelView_t& view) { PHARE_LOG_SCOPE("SolverPPC::average_"); - auto& hybridState = model.state; - auto& resourcesManager = model.resourcesManager; - - auto& Epred = electromagPred_.E; - auto& Bpred = electromagPred_.B; - auto& Bavg = electromagAvg_.B; - auto& Eavg = electromagAvg_.E; - auto& B = hybridState.electromag.B; - auto& E = hybridState.electromag.E; - - for (auto& patch : level) + auto _average = [](auto&... args) { PHARE::core::average(args...); }; + for (auto& state : view) { - auto _ = resourcesManager->setOnPatch(*patch, electromagAvg_, electromagPred_, - hybridState.electromag); - PHARE::core::average(B, Bpred, Bavg); - PHARE::core::average(E, Epred, Eavg); + std::apply(_average, state.ppc_average_B()); + std::apply(_average, state.ppc_average_E()); } + // the following will fill E on all edges of all ghost cells, including those // on domain border. For level ghosts, electric field will be obtained from // next coarser level E average - fromCoarser.fillElectricGhosts(Eavg, level.getLevelNumber(), newTime); + fromCoarser.fillElectricGhosts(electromagAvg_.E, level.getLevelNumber(), newTime); } @@ -524,7 +408,8 @@ template void SolverPPC::moveIons_(level_t& level, Ions& ions, Electromag& electromag, ResourcesManager& rm, Messenger& fromCoarser, double const currentTime, - double const newTime, core::UpdaterMode mode) + double const newTime, core::UpdaterMode mode, + HybridModelView_t& view) { PHARE_LOG_SCOPE("SolverPPC::moveIons_"); @@ -556,34 +441,33 @@ void SolverPPC::moveIons_(level_t& level, Ions& ions, auto dt = newTime - currentTime; - for (auto& patch : level) + for (auto& state : view) { - auto _ = rm.setOnPatch(*patch, electromag, ions); - - auto layout = PHARE::amr::layoutFromPatch(*patch); - ionUpdater_.updatePopulations(ions, electromag, layout, dt, mode); - + auto const& [layout, ionz, em] = state.ppc_update_populations(); + ionUpdater_.updatePopulations(ionz, em, layout, dt, mode); // this needs to be done before calling the messenger - rm.setTime(ions, *patch, newTime); + rm.setTime(ionz, *state.patch, newTime); } - fromCoarser.fillIonGhostParticles(ions, level, newTime); fromCoarser.fillIonPopMomentGhosts(ions, level, newTime); - for (auto& patch : level) + for (auto& state : view) { - auto _ = rm.setOnPatch(*patch, electromag, ions); - auto layout = PHARE::amr::layoutFromPatch(*patch); - ionUpdater_.updateIons(ions, layout); - + ionUpdater_.updateIons(state.ions, state.layout); // no need to update time, since it has been done before } + // now Ni and Vi are calculated we can fill pure ghost nodes // these were not completed by the deposition of patch and levelghost particles fromCoarser.fillIonMomentGhosts(ions, level, newTime); } + + + } // namespace PHARE::solver + + #endif diff --git a/src/amr/solvers/solver_ppc_model_view.hpp b/src/amr/solvers/solver_ppc_model_view.hpp new file mode 100644 index 000000000..e43972feb --- /dev/null +++ b/src/amr/solvers/solver_ppc_model_view.hpp @@ -0,0 +1,212 @@ +#ifndef PHARE_SOLVER_SOLVER_PPC_MODEL_VIEW_HPP +#define PHARE_SOLVER_SOLVER_PPC_MODEL_VIEW_HPP + +#include "amr/solvers/solver.hpp" + +namespace PHARE::solver +{ + +template +struct HybridPPCModelView : public ISolverModelView +{ + using This = HybridPPCModelView; + using HybridModel_t = HybridModel_; + using HybridModel_args = typename HybridModel_t::type_list::Tuple; + using IPhysicalModel_t = typename HybridModel_t::Interface; + + using Electrons = std::tuple_element_t<3, HybridModel_args>; + + using level_t = typename HybridModel_t::amr_types::level_t; + using Electromag = typename HybridModel_t::electromag_type; + using Ions = typename HybridModel_t::ions_type; + using ParticleArray_t = typename Ions::particle_array_type; + using Particle_t = typename ParticleArray_t::value_type; + using VecFieldT = typename HybridModel_t::vecfield_type; + using GridLayout = typename HybridModel_t::gridlayout_type; + + struct PatchState_t; + + using value_type = PatchState_t; + + template + struct iterator; + + HybridPPCModelView(level_t& level, IPhysicalModel_t& model) { regrid(level, model); } + + void regrid(level_t& level, HybridModel_t& hybridModel); + + void regrid(level_t& level, IPhysicalModel_t& model) + { + regrid(level, dynamic_cast(model)); + } + + auto begin() { return iterator{*this}; } + auto begin() const { return iterator{*this}; } + + auto end() { return iterator{*this, states.size()}; } + auto end() const { return iterator{*this, states.size()}; } + + std::vector> states; + + Electromag electromagPred_{"EMPred"}; + Electromag electromagAvg_{"EMAvg"}; +}; + + +template +void HybridPPCModelView::regrid(level_t& level, HybridModel_t& hybridModel) +{ + auto& hybridState = hybridModel.state; + auto& rm = *hybridModel.resourcesManager; + + states.clear(); + + for (auto& patch : level) + { + { + auto _ = rm.setOnPatch(*patch, hybridState, electromagPred_, electromagAvg_); + states.emplace_back( // + PHARE::amr::layoutFromPatch(*patch), // + hybridState.ions, // + hybridState.J, // + hybridState.electromag, // + electromagPred_, // + electromagAvg_, // + hybridState.electrons, // + patch // + ); + } + assert(states.back() == true); + } +} + + +template +template +struct HybridPPCModelView::iterator +{ + iterator(HybridPPCModelView& view_, std::size_t const& i = 0) + : view{view_} + , idx{i} + { + } + + auto& operator*() + { + assert(view.states[idx] == true); + return view.states[idx]; + } + auto& operator*() const + { + assert(view.states[idx] == true); + return view.states[idx]; + } + + auto& operator++() + { + idx += 1; + return *this; + } + + bool operator!=(iterator const& that) const { return &view != &that.view or idx != that.idx; } + + HybridPPCModelView& view; + std::size_t idx = 0; +}; + +template +struct HybridPPCModelView::PatchState_t +{ + GridLayout layout; + Ions ions; + VecFieldT J; + Electromag electromag, electromagPred, electromagAvg; + Electrons electrons; + std::shared_ptr patch; + + auto ppc_predictor1_faraday() + { + return std::forward_as_tuple(layout, electromag.B, electromag.E, electromagPred.B); + } + auto ppc_predictor1_ampere() { return std::forward_as_tuple(layout, electromagPred.B, J); } + auto ppc_predictor1_ohm() + { + auto& Ve = electrons.velocity(); + auto& Ne = electrons.density(); + auto& Pe = electrons.pressure(); + return std::forward_as_tuple(layout, Ne, Ve, Pe, electromagPred.B, J, electromagPred.E); + } + + + auto ppc_predictor2_faraday() + { + return std::forward_as_tuple(layout, electromag.B, electromagAvg.E, electromagPred.B); + } + auto ppc_predictor2_ampere() { return ppc_predictor1_ampere(); } + auto ppc_predictor2_ohm() { return ppc_predictor1_ohm(); } + + + auto ppc_corrector_faraday() + { + return std::forward_as_tuple(layout, electromag.B, electromagAvg.E, electromag.B); + } + auto ppc_corrector_ampere() { return std::forward_as_tuple(layout, electromag.B, J); } + auto ppc_corrector_ohm() + { + auto& Ve = electrons.velocity(); + auto& Ne = electrons.density(); + auto& Pe = electrons.pressure(); + return std::forward_as_tuple(layout, Ne, Ve, Pe, electromag.B, J, electromag.E); + } + + + auto ppc_average_B() + { + return std::forward_as_tuple(electromag.B, electromagPred.B, electromagAvg.B); + } + auto ppc_average_E() + { + return std::forward_as_tuple(electromag.E, electromagPred.E, electromagAvg.E); + } + + + auto ppc_update_populations() { return std::forward_as_tuple(layout, ions, electromagAvg); } + + + operator bool() const + { + using Tuple = decltype((*this)()); + auto constexpr tuple_size = std::tuple_size_v; + Tuple tup = (*this)(); + + return core::for_N_all([&](auto i) { + auto const& [k, v] = std::get(tup); + auto isUsable = v->isUsable(); + if (!isUsable) + { + PHARE_LOG_LINE_STR("NOT USABLE: " << k); + } + return isUsable; + }); + } + + auto operator()() const + { + return core::make_named_tuple( // + std::make_pair("J", &J), // + std::make_pair("ions", &ions), // + std::make_pair("electrons", &electrons), // + std::make_pair("electromag", &electromag), // + std::make_pair("electromagAvg", &electromagAvg), // + std::make_pair("electromagPred", &electromagPred) // + ); + } +}; + + +} // namespace PHARE::solver + + + + +#endif /* PHARE_SOLVER_SOLVER_PPC_MODEL_VIEW_HPP */ diff --git a/src/amr/tagging/default_hybrid_tagger_strategy.hpp b/src/amr/tagging/default_hybrid_tagger_strategy.hpp index ede42a936..6ab30fb07 100644 --- a/src/amr/tagging/default_hybrid_tagger_strategy.hpp +++ b/src/amr/tagging/default_hybrid_tagger_strategy.hpp @@ -42,7 +42,7 @@ void DefaultHybridTaggerStrategy::tag(HybridModel& model, // SAMRAI tags int* buffer is FORTRAN ordering so we set false to the view bool constexpr c_ordering = false; - auto tagsv = core::NdArrayView(tags, layout.nbrCells()); + auto tagsv = core::NdArrayView(tags, layout.nbrCells()); if constexpr (dimension == 1 and false) { diff --git a/src/amr/tagging/hybrid_tagger.hpp b/src/amr/tagging/hybrid_tagger.hpp index 901996172..ea8e4b036 100644 --- a/src/amr/tagging/hybrid_tagger.hpp +++ b/src/amr/tagging/hybrid_tagger.hpp @@ -90,7 +90,7 @@ void HybridTagger::tag(PHARE::solver::IPhysicalModel& model, auto tagsv = core::NdArrayView(hybridModel.tags[key]->data(), layout.nbrCells()); auto tagsvF - = core::NdArrayView(tags, layout.nbrCells()); + = core::NdArrayView(tags, layout.nbrCells()); if constexpr (HybridModel::dimension == 2) { for (auto iTag_x = 0u; iTag_x < nbrCells[0]; ++iTag_x) diff --git a/src/core/data/electrons/electrons.hpp b/src/core/data/electrons/electrons.hpp index 3d785ce95..8d01918be 100644 --- a/src/core/data/electrons/electrons.hpp +++ b/src/core/data/electrons/electrons.hpp @@ -7,6 +7,7 @@ #include "core/data/grid/gridlayoutdefs.hpp" #include "core/utilities/index/index.hpp" #include "core/def.hpp" +#include "core/logger.hpp" #include "initializer/data_provider.hpp" #include @@ -14,6 +15,8 @@ namespace PHARE::core { + + template class StandardHybridElectronFluxComputer { @@ -130,27 +133,29 @@ class StandardHybridElectronFluxComputer } + auto& getIons() const { return ions_; } private: - Ions& ions_; - VecField& J_; + Ions ions_; + VecField J_; VecField Ve_; - -}; // namespace PHARE::core +}; -template +template class IsothermalElectronPressureClosure { - using GridLayout = typename FluxComputer::GridLayout; - using VecField = typename FluxComputer::VecField; - using Field = typename VecField::field_type; + using GridLayout = typename Ions::gridlayout_type; + using VecField = typename Ions::vecfield_type; + using Field = typename Ions::field_type; public: - IsothermalElectronPressureClosure(PHARE::initializer::PHAREDict const& dict, - FluxComputer const& fc) - : fluxComputer_{fc} + using field_type = Field; + using grid_type = typename VecField::grid_type; + + IsothermalElectronPressureClosure(PHARE::initializer::PHAREDict const& dict, Ions const& ions) + : ions_{ions} , Te_{dict["Te"].template to()} { } @@ -160,11 +165,10 @@ class IsothermalElectronPressureClosure // start the ResourcesUser interface //------------------------------------------------------------------------- - using field_type = Field; - NO_DISCARD bool isUsable() { return Pe_ != nullptr; } + NO_DISCARD bool isUsable() const { return Pe_ != nullptr and ions_.isUsable(); } - NO_DISCARD bool isSettable() { return Pe_ == nullptr; } + NO_DISCARD bool isSettable() const { return Pe_ == nullptr; } struct PressureProperty { @@ -189,6 +193,9 @@ class IsothermalElectronPressureClosure throw std::runtime_error("Error - Pe is not usable"); } + NO_DISCARD auto getCompileTimeResourcesUserList() const { return std::forward_as_tuple(ions_); } + + NO_DISCARD auto getCompileTimeResourcesUserList() { return std::forward_as_tuple(ions_); } //------------------------------------------------------------------------- // ends the ResourcesUser interface @@ -200,18 +207,22 @@ class IsothermalElectronPressureClosure { if (Pe_ != nullptr) return *Pe_; - else - throw std::runtime_error("Error - isothermal closure pressure not usable"); + throw std::runtime_error("Error - isothermal closure pressure not usable"); + } + NO_DISCARD Field const& pressure() const + { + if (Pe_ != nullptr) + return *Pe_; + throw std::runtime_error("Error - isothermal closure pressure not usable"); } - NO_DISCARD Field const& pressure() const { return *Pe_; } - void computePressure([[maybe_unused]] GridLayout const& layout) + void computePressure(GridLayout const& /*layout*/) { if (Pe_ != nullptr) { static_assert(Field::is_contiguous, "Error - assumes Field date is contiguous"); - auto const& Ne_ = fluxComputer_.density(); + auto const& Ne_ = ions_.density(); std::transform(std::begin(Ne_), std::end(Ne_), std::begin(*Pe_), [this](auto n) { return n * Te_; }); @@ -221,9 +232,9 @@ class IsothermalElectronPressureClosure } private: - FluxComputer const& fluxComputer_; - const double Te_; - Field* Pe_; + Ions ions_; + double const Te_ = 0; + Field* Pe_ = nullptr; }; @@ -240,7 +251,7 @@ class ElectronMomentModel public: ElectronMomentModel(PHARE::initializer::PHAREDict const& dict, Ions& ions, VecField& J) : fluxComput_{ions, J} - , pressureClosure_{dict["pressure_closure"], fluxComput_} + , pressureClosure_{dict["pressure_closure"], fluxComput_.getIons()} { } @@ -248,7 +259,10 @@ class ElectronMomentModel // start the ResourcesUser interface //------------------------------------------------------------------------- - NO_DISCARD bool isUsable() const { return fluxComput_.isUsable(); } + NO_DISCARD bool isUsable() const + { + return fluxComput_.isUsable() and pressureClosure_.isUsable(); + } NO_DISCARD bool isSettable() const { return fluxComput_.isSettable(); } @@ -288,7 +302,7 @@ class ElectronMomentModel private: FluxComputer fluxComput_; - IsothermalElectronPressureClosure pressureClosure_; + IsothermalElectronPressureClosure pressureClosure_; }; @@ -306,6 +320,9 @@ class Electrons : public LayoutHolder { } + Electrons(Electrons const&) = default; + Electrons(Electrons&&) = delete; + void update(GridLayout const& layout) { if (isUsable()) diff --git a/src/core/data/field/field.hpp b/src/core/data/field/field.hpp index 575dda734..9eacb97e4 100644 --- a/src/core/data/field/field.hpp +++ b/src/core/data/field/field.hpp @@ -8,87 +8,67 @@ #include #include -#include "core/data/ndarray/ndarray_vector.hpp" #include "core/def.hpp" - - -namespace PHARE +namespace PHARE::core { -namespace core +//! Class Field represents a multidimensional (1,2 or 3D) scalar field +/** Users of Field objects needing to know which physical quantity a specific + * Field instance represents can get this info by calling physicalQuantity(). + * Users may also give a string name to a field object and get a name by calling + * name(). + */ +template +class Field : public NdArrayImpl { - //! Class Field represents a multidimensional (1,2 or 3D) scalar field - /** Users of Field objects needing to know which physical quantity a specific - * Field instance represents can get this info by calling physicalQuantity(). - * Users may also give a string name to a field object and get a name by calling - * name(). - */ - template - class Field : public NdArrayImpl + using Super = NdArrayImpl; // only view now +public: + using value_type = typename NdArrayImpl::type; + using physical_quantity_type = PhysicalQuantity; + using NdArrayImpl::dimension; + + template + Field(std::string const& name, PhysicalQuantity qty, value_type* data, + std::array const& dims) + : Super{data, dims} + , name_{name} + , qty_{qty} { - public: - using impl_type = NdArrayImpl; - using type = typename NdArrayImpl::type; - using physical_quantity_type = PhysicalQuantity; - using NdArrayImpl::dimension; - - - Field() = delete; - Field(Field const& source) = delete; - Field(Field&& source) = default; - Field& operator=(Field&& source) = delete; - Field& operator=(Field const& source) = delete; - - template - Field(std::string name, PhysicalQuantity qty, Dims... dims) - : NdArrayImpl{dims...} - , name_{std::move(name)} - , qty_{qty} - { - static_assert(sizeof...(Dims) == NdArrayImpl::dimension, "Invalid dimension"); - } + } - template - Field(std::string name, PhysicalQuantity qty, std::array const& dims) - : NdArrayImpl{dims} - , name_{std::move(name)} - , qty_{qty} - { - } + Field(Field const& source) = default; + Field(Field&& source) = default; + Field& operator=(Field&& source) = default; + Field& operator=(Field const& source) = default; - NO_DISCARD std::string name() const { return name_; } + NO_DISCARD auto& name() const { return name_; } + NO_DISCARD auto& physicalQuantity() const { return qty_; } + void copyData(Field const& source) { Super::fill_from(source); } - NO_DISCARD constexpr PhysicalQuantity physicalQuantity() const { return qty_; } +private: + std::string name_{"No Name"}; + PhysicalQuantity qty_; +}; - void copyData(Field const& source) - { - static_cast(*this) = static_cast(source); - } - private: - std::string name_{"No Name"}; - PhysicalQuantity qty_; - }; +template +void average(Field const& f1, + Field const& f2, + Field& avg) +{ + std::transform(std::begin(f1), std::end(f1), std::begin(f2), std::begin(avg), + std::plus()); + std::transform(std::begin(avg), std::end(avg), std::begin(avg), + [](double x) { return x * 0.5; }); +} - template - void average(Field const& f1, - Field const& f2, - Field& avg) - { - std::transform(std::begin(f1), std::end(f1), std::begin(f2), std::begin(avg), - std::plus()); - - std::transform(std::begin(avg), std::end(avg), std::begin(avg), - [](double x) { return x * 0.5; }); - } +} // namespace PHARE::core -} // namespace core -} // namespace PHARE #endif diff --git a/src/core/data/grid/grid.hpp b/src/core/data/grid/grid.hpp new file mode 100644 index 000000000..59e121f43 --- /dev/null +++ b/src/core/data/grid/grid.hpp @@ -0,0 +1,97 @@ +#ifndef PHARE_CORE_DATA_GRID_GRID_BASE_HPP +#define PHARE_CORE_DATA_GRID_GRID_BASE_HPP + +#include +#include +#include +#include +#include +#include +#include + +#include "core/def.hpp" +#include "core/data/field/field.hpp" +#include "core/data/ndarray/ndarray_vector.hpp" + +namespace PHARE::core +{ + + +template +class Grid : public NdArrayImpl +{ + using Super = NdArrayImpl; + +public: + using value_type = typename NdArrayImpl::type; + using physical_quantity_type = PhysicalQuantity; + using NdArrayImpl::dimension; + using field_type = Field, PhysicalQuantity>; + + + Grid() = delete; + Grid(Grid const& source) = delete; + Grid(Grid&& source) = default; + Grid& operator=(Grid&& source) = delete; + Grid& operator=(Grid const& source) = delete; + + template + Grid(std::string const& name, PhysicalQuantity qty, Dims... dims) + : Super{dims...} + , name_{name} + , qty_{qty} + , field_{name, qty, Super::data(), Super::shape()} + { + static_assert(sizeof...(Dims) == dimension, "Invalid dimension"); + } + + template + Grid(std::string const& name, PhysicalQuantity qty, std::array const& dims) + : Super{dims} + , name_{name} + , qty_{qty} + , field_{name, qty, Super::data(), Super::shape()} + { + } + + NO_DISCARD std::string name() const { return name_; } + + NO_DISCARD constexpr PhysicalQuantity physicalQuantity() const { return qty_; } + + template + void copyData(That const& that) + { + assert(Super::size() == that.size()); + std::copy(that.data(), that.data() + Super::size(), Super::data()); + } + + // returns view when getting address of this object, could be misleading, but convenient + auto operator&() { return &field_; } + auto operator&() const { return &field_; } + +private: + std::string name_{"No Name"}; + PhysicalQuantity qty_; + field_type field_; +}; + + + + +template +void average(Grid const& f1, + Grid const& f2, + Grid& avg) +{ + std::transform(std::begin(f1), std::end(f1), std::begin(f2), std::begin(avg), + std::plus()); + + std::transform(std::begin(avg), std::end(avg), std::begin(avg), + [](double x) { return x * 0.5; }); +} + + + +} // namespace PHARE::core + +#endif diff --git a/src/core/data/grid/gridlayout.hpp b/src/core/data/grid/gridlayout.hpp index d737adab3..a815ce47b 100644 --- a/src/core/data/grid/gridlayout.hpp +++ b/src/core/data/grid/gridlayout.hpp @@ -325,10 +325,8 @@ namespace core - template - NO_DISCARD std::uint32_t - physicalStartIndex(Field const& field, - Direction direction) const + template + NO_DISCARD std::uint32_t physicalStartIndex(Field_t const& field, Direction direction) const { return physicalStartIndex(field.physicalQuantity(), direction); } @@ -369,10 +367,8 @@ namespace core - template - NO_DISCARD std::uint32_t - physicalEndIndex(Field const& field, - Direction direction) const + template + NO_DISCARD std::uint32_t physicalEndIndex(Field_t const& field, Direction direction) const { return physicalEndIndex(field.physicalQuantity(), direction); } @@ -408,17 +404,16 @@ namespace core } - template - NO_DISCARD std::uint32_t - ghostStartIndex([[maybe_unused]] Field const& field, - [[maybe_unused]] Direction direction) const + template + NO_DISCARD std::uint32_t ghostStartIndex(Field_t const& /*field*/, + Direction /*direction*/) const { // ghostStartIndex is always the first node return 0; } - NO_DISCARD auto ghostStartIndex([[maybe_unused]] QtyCentering centering) const + NO_DISCARD auto ghostStartIndex(QtyCentering /*centering*/) const { return std::array{}; } @@ -451,10 +446,8 @@ namespace core - template - NO_DISCARD std::uint32_t - ghostEndIndex(Field const& field, - Direction direction) const + template + NO_DISCARD std::uint32_t ghostEndIndex(Field_t const& field, Direction direction) const { return ghostEndIndex(field.physicalQuantity(), direction); } @@ -471,10 +464,10 @@ namespace core * @brief fieldNodeCoordinates returns the coordinate of a multidimensional index * associated with a given Field, in physical coordinates. */ - template + template NO_DISCARD Point - fieldNodeCoordinates(const Field& field, - const Point& origin, Indexes... index) const + fieldNodeCoordinates(Field_t const& field, Point const& origin, + Indexes... index) const { static_assert(sizeof...(Indexes) == dimension, "Error dimension does not match number of arguments"); @@ -965,9 +958,8 @@ namespace core /** @brief return the centering of a given Field along a given direction */ - template - NO_DISCARD QtyCentering - fieldCentering(Field const& field, Direction dir) const + template + NO_DISCARD QtyCentering fieldCentering(Field_t const& field, Direction dir) const { std::uint32_t iDir = static_cast(dir); std::uint32_t iQty = static_cast(field.physicalQuantity()); diff --git a/src/core/data/ions/ion_population/ion_population.hpp b/src/core/data/ions/ion_population/ion_population.hpp index 2611b92c9..f9dd70484 100644 --- a/src/core/data/ions/ion_population/ion_population.hpp +++ b/src/core/data/ions/ion_population/ion_population.hpp @@ -24,6 +24,7 @@ namespace core class IonPopulation { public: + using grid_type = typename VecField::grid_type; using field_type = typename VecField::field_type; static constexpr std::size_t dimension = VecField::dimension; using particle_array_type = ParticleArray; diff --git a/src/core/data/ions/ions.hpp b/src/core/data/ions/ions.hpp index 97c21b03e..a82cfdd48 100644 --- a/src/core/data/ions/ions.hpp +++ b/src/core/data/ions/ions.hpp @@ -26,6 +26,7 @@ namespace core class Ions { public: + using grid_type = typename IonPopulation::grid_type; using field_type = typename IonPopulation::field_type; using vecfield_type = typename IonPopulation::vecfield_type; using Float = typename field_type::type; @@ -36,6 +37,8 @@ namespace core static constexpr auto dimension = GridLayout::dimension; + Ions(Ions const&) = default; + Ions(Ions&&) = default; explicit Ions(PHARE::initializer::PHAREDict const& dict) diff --git a/src/core/data/ndarray/ndarray_vector.hpp b/src/core/data/ndarray/ndarray_vector.hpp index c9bef9837..c471fa5e2 100644 --- a/src/core/data/ndarray/ndarray_vector.hpp +++ b/src/core/data/ndarray/ndarray_vector.hpp @@ -128,22 +128,23 @@ class MaskedView -template -class NdArrayView : NdArrayViewer +template +class NdArrayView { public: static constexpr bool is_contiguous = 1; static const std::size_t dimension = dim; using type = DataType; + using pointer_type = DataType*; + using viewer = NdArrayViewer; - explicit NdArrayView(Pointer ptr, std::array const& nCells) + explicit NdArrayView(pointer_type ptr, std::array const& nCells) : ptr_{ptr} , nCells_{nCells} { } - explicit NdArrayView(std::vector const& v, + explicit NdArrayView(std::vector> const& v, std::array const& nbCell) : NdArrayView{v.data(), nbCell} { @@ -152,7 +153,7 @@ class NdArrayView : NdArrayViewer template NO_DISCARD DataType const& operator()(Indexes... indexes) const { - return NdArrayViewer::at(ptr_, nCells_, indexes...); + return viewer::at(ptr_, nCells_, indexes...); } template @@ -164,7 +165,7 @@ class NdArrayView : NdArrayViewer template NO_DISCARD DataType const& operator()(std::array const& indexes) const { - return NdArrayViewer::at(ptr_, nCells_, indexes); + return viewer::at(ptr_, nCells_, indexes); } template @@ -180,8 +181,23 @@ class NdArrayView : NdArrayViewer } NO_DISCARD auto shape() const { return nCells_; } + void fill_from(NdArrayView const& that) + { + if (size() != that.size()) + throw std::runtime_error("ArrayView::fill_from: Incompatible input size"); + std::copy(that.data(), that.data() + size(), data()); + } + + NO_DISCARD auto begin() const { return ptr_; } + NO_DISCARD auto begin() { return ptr_; } + + NO_DISCARD auto end() const { return ptr_ + size(); } + NO_DISCARD auto end() { return ptr_ + size(); } + + void zero() { std::fill(begin(), end(), 0); } + private: - Pointer ptr_ = nullptr; + pointer_type ptr_ = nullptr; std::array nCells_; }; @@ -228,10 +244,6 @@ class NdArrayVector NO_DISCARD auto end() const { return std::end(data_); } NO_DISCARD auto end() { return std::end(data_); } - void zero() { std::fill(data_.begin(), data_.end(), 0); } - - - template NO_DISCARD DataType const& operator()(Indexes... indexes) const diff --git a/src/core/data/vecfield/vecfield.hpp b/src/core/data/vecfield/vecfield.hpp index f18ee26df..228797dea 100644 --- a/src/core/data/vecfield/vecfield.hpp +++ b/src/core/data/vecfield/vecfield.hpp @@ -23,18 +23,22 @@ namespace core * VecField class is templated by the type of NdArray Field use and which * physical quantities they represent. */ - template + template class VecField { public: + static constexpr std::size_t dimension = Grid_t::dimension; + + using grid_type = Grid_t; + using field_type = typename Grid_t::field_type; + + VecField() = delete; - VecField(VecField const& source) = delete; + VecField(VecField const& source) = default; VecField(VecField&& source) = default; VecField& operator=(VecField const& source) = delete; VecField& operator=(VecField&& source) = default; - static constexpr std::size_t dimension = NdArrayImpl::dimension; - /** * @brief builds a VecField from a name and for a specific vector physical quantity @@ -62,7 +66,6 @@ namespace core using resources_properties = std::vector; - using field_type = Field; resources_properties getFieldNamesAndQuantities() const { @@ -121,7 +124,7 @@ namespace core - Field& getComponent(Component component) + auto& getComponent(Component component) { if (isUsable()) { @@ -138,8 +141,7 @@ namespace core - Field const& - getComponent(Component component) const + auto const& getComponent(Component component) const { if (isUsable()) { diff --git a/src/core/models/hybrid_state.hpp b/src/core/models/hybrid_state.hpp index 8485df1e9..5ba06efdc 100644 --- a/src/core/models/hybrid_state.hpp +++ b/src/core/models/hybrid_state.hpp @@ -74,12 +74,12 @@ namespace core NO_DISCARD auto getCompileTimeResourcesUserList() const { - return std::forward_as_tuple(electromag, ions, electrons); + return std::forward_as_tuple(electromag, ions, electrons, J); } NO_DISCARD auto getCompileTimeResourcesUserList() { - return std::forward_as_tuple(electromag, ions, electrons); + return std::forward_as_tuple(electromag, ions, electrons, J); } diff --git a/src/core/numerics/ampere/ampere.hpp b/src/core/numerics/ampere/ampere.hpp index c65e30ae5..616a5143c 100644 --- a/src/core/numerics/ampere/ampere.hpp +++ b/src/core/numerics/ampere/ampere.hpp @@ -37,6 +37,17 @@ class Ampere : public LayoutHolder layout_->evalOnBox(Jz, [&](auto&... args) mutable { JzEq_(Jz, B, args...); }); } + template + void op(ViewStates& states, Accessor fn) + { + for (auto& state : states) + { + auto const& [layout, B, J] = fn(state); + this->layout_ = &layout; + (*this)(B, J); + } + } + private: template void JxEq_(Field& Jx, VecField const& B, Indexes const&... ijk) const diff --git a/src/core/numerics/faraday/faraday.hpp b/src/core/numerics/faraday/faraday.hpp index 1b9b4e2b5..a82dc339a 100644 --- a/src/core/numerics/faraday/faraday.hpp +++ b/src/core/numerics/faraday/faraday.hpp @@ -47,6 +47,17 @@ class Faraday : public LayoutHolder [&](auto&... args) mutable { BzEq_(Bz, E, Bznew, args...); }); } + template + void operator()(ViewStates& states, Accessor fn, double dt) + { + // not thread safe, would probably need to copy (*this) per thread + for (auto& state : states) + { + auto const& [layout, B, E, Bnew] = fn(state); + this->layout_ = &layout; + (*this)(B, E, Bnew, dt); + } + } private: double dt_; diff --git a/src/core/numerics/ohm/ohm.hpp b/src/core/numerics/ohm/ohm.hpp index 80ad56705..42adf3b47 100644 --- a/src/core/numerics/ohm/ohm.hpp +++ b/src/core/numerics/ohm/ohm.hpp @@ -50,6 +50,18 @@ class Ohm : public LayoutHolder }); } + + template + void operator()(ViewStates& states, Accessor fn) + { + for (auto& state : states) + { + auto const& [layout, n, Ve, Pe, B, J, Enew] = fn(state); + this->layout_ = &layout; + (*this)(n, Ve, Pe, B, J, Enew); + } + } + double const eta_; double const nu_; diff --git a/src/core/utilities/box/box.hpp b/src/core/utilities/box/box.hpp index fd3e1fe09..05e45c604 100644 --- a/src/core/utilities/box/box.hpp +++ b/src/core/utilities/box/box.hpp @@ -179,12 +179,6 @@ class box_iterator increment(dim - 1); return *this; } - box_iterator& operator++() const - { - increment(dim - 1); - return *this; - } - bool operator!=(box_iterator const& other) const { diff --git a/src/core/utilities/types.hpp b/src/core/utilities/types.hpp index 301d89ffa..fa91d5b26 100644 --- a/src/core/utilities/types.hpp +++ b/src/core/utilities/types.hpp @@ -72,6 +72,7 @@ namespace core template // this is so we can specialize struct type_list // templates with only the outter most type { + using Tuple = std::tuple; // }; template @@ -327,24 +328,25 @@ auto constexpr static to_bool = [](auto const& v) { return bool{v}; }; template -NO_DISCARD auto all(Container const& container, Fn fn = to_bool) +NO_DISCARD auto constexpr all(Container const& container, Fn fn = to_bool) { return std::all_of(container.begin(), container.end(), fn); } - template -NO_DISCARD auto any(Container const& container, Fn fn = to_bool) +NO_DISCARD auto constexpr any(Container const& container, Fn fn = to_bool) { return std::any_of(container.begin(), container.end(), fn); } template -NO_DISCARD auto none(Container const& container, Fn fn = to_bool) +NO_DISCARD auto constexpr none(Container const& container, Fn fn = to_bool) { return std::none_of(container.begin(), container.end(), fn); } + + auto inline float_equals(float const& a, float const& b, float diff = 1e-6) { return std::abs(a - b) < diff; @@ -355,6 +357,109 @@ auto inline float_equals(double const& a, double const& b, double diff = 1e-12) return std::abs(a - b) < diff; } +template +struct Apply +{ + template + auto constexpr operator()() + { + return std::integral_constant{}; + } +}; + +template +constexpr auto apply_N(Apply& f, std::integer_sequence const&) +{ + if constexpr (!std::is_same_v()), void>) + return std::make_tuple(f.template operator()()...); + (f.template operator()(), ...); +} + +template +constexpr auto apply_N(Apply&& f) +{ + return apply_N(f, std::make_integer_sequence{}); +} + +enum class for_N_R_mode { + make_tuple = 0, + make_array, + forward_tuple, +}; + +template +constexpr auto for_N(Fn& fn) +{ + /* // how to use + for_N<2>([](auto ic) { + constexpr auto i = ic(); + // ... + }); + */ + + static_assert(std::is_same_v); + using return_type + = std::decay_t)>>; + constexpr bool returns = !std::is_same_v; + + if constexpr (returns) + { + return std::apply( + [&](auto... ics) { + if constexpr (M == for_N_R_mode::make_tuple) + return std::make_tuple(fn(ics)...); + else if constexpr (M == for_N_R_mode::make_array) + return std::array{fn(ics)...}; + else if constexpr (M == for_N_R_mode::forward_tuple) + return std::forward_as_tuple(fn(ics)...); + else + throw std::runtime_error("unknown return mode"); + }, + apply_N(Apply{})); + } + else + std::apply([&](auto... ics) { (fn(ics), ...); }, apply_N(Apply{})); +} + +template +constexpr auto for_N(Fn&& fn) +{ + return for_N(fn); +} + +template +NO_DISCARD constexpr auto for_N_all(Fn&& fn) +{ + return all(for_N(fn)); +} + +template +NO_DISCARD constexpr auto for_N_any(Fn&& fn) +{ + return any(for_N(fn)); +} + + + +template +constexpr auto named_pair_seq_(Tuple, std::index_sequence const&&) + -> decltype(std::make_tuple( + (Is, std::declval>>())...)); + +template +auto constexpr named_pair_seq() + -> decltype(named_pair_seq_(std::tuple{}, + std::make_index_sequence{})); + +template +using NamedTuple = decltype(named_pair_seq()); + +template +auto make_named_tuple(Pairs&&... pairs) +{ + return std::make_tuple(pairs...); +} + } // namespace PHARE::core diff --git a/src/diagnostic/detail/types/fluid.hpp b/src/diagnostic/detail/types/fluid.hpp index e56811ebe..59d29d192 100644 --- a/src/diagnostic/detail/types/fluid.hpp +++ b/src/diagnostic/detail/types/fluid.hpp @@ -191,7 +191,7 @@ void FluidDiagnosticWriter::write(DiagnosticProperties& diagnostic) auto checkActive = [&](auto& tree, auto var) { return diagnostic.quantity == tree + var; }; auto writeDS = [&](auto path, auto& field) { - h5file.template write_data_set_flat(path, &(*field.begin())); + h5file.template write_data_set_flat(path, field.data()); }; auto writeVF = [&](auto path, auto& vecF) { h5Writer.writeVecFieldAsDataset(h5file, path, vecF); }; diff --git a/src/phare_core.hpp b/src/phare_core.hpp index 3c77eb6ed..89f7eba61 100644 --- a/src/phare_core.hpp +++ b/src/phare_core.hpp @@ -2,6 +2,7 @@ #ifndef PHARE_CORE_INCLUDE_HPP #define PHARE_CORE_INCLUDE_HPP +#include "core/data/grid/grid.hpp" #include "core/data/electromag/electromag.hpp" #include "core/data/electrons/electrons.hpp" #include "core/data/grid/gridlayout.hpp" @@ -34,9 +35,12 @@ struct PHARE_Types static auto constexpr dimension = dimension_; static auto constexpr interp_order = interp_order_; - using Array_t = PHARE::core::NdArrayVector; - using VecField_t = PHARE::core::VecField; - using Field_t = PHARE::core::Field; + using Array_t = PHARE::core::NdArrayVector; + using Grid_t = PHARE::core::Grid; + + using ArrayView_t = PHARE::core::NdArrayView; + using VecField_t = PHARE::core::VecField; + using Field_t = PHARE::core::Field; using Electromag_t = PHARE::core::Electromag; using YeeLayout_t = PHARE::core::GridLayoutImplYee; using GridLayout_t = PHARE::core::GridLayout; @@ -46,7 +50,6 @@ struct PHARE_Types using ParticleArray_t = ParticleAoS_t; using ParticleSoA_t = PHARE::core::ContiguousParticles; - using MaxwellianParticleInitializer_t = PHARE::core::MaxwellianParticleInitializer; using IonPopulation_t = PHARE::core::IonPopulation; diff --git a/src/simulator/phare_types.hpp b/src/simulator/phare_types.hpp index c8d65f6c0..08d2c7707 100644 --- a/src/simulator/phare_types.hpp +++ b/src/simulator/phare_types.hpp @@ -18,6 +18,7 @@ struct PHARE_Types using core_types = PHARE::core::PHARE_Types; using Array_t = typename core_types::Array_t; + using Grid_t = typename core_types::Grid_t; using Field_t = typename core_types::Field_t; using VecField_t = typename core_types::VecField_t; using Electromag_t = typename core_types::Electromag_t; diff --git a/tests/amr/data/field/coarsening/test_linear_coarsen.hpp b/tests/amr/data/field/coarsening/test_linear_coarsen.hpp index 3cd688a31..34f2624c3 100644 --- a/tests/amr/data/field/coarsening/test_linear_coarsen.hpp +++ b/tests/amr/data/field/coarsening/test_linear_coarsen.hpp @@ -5,6 +5,7 @@ #include "amr/data/field/coarsening/magnetic_field_coarsener.hpp" #include "amr/data/field/coarsening/field_coarsen_operator.hpp" #include "amr/data/field/coarsening/field_coarsen_index_weight.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "gmock/gmock.h" @@ -54,7 +55,7 @@ struct Files template struct EMData { - using Field_t = Field, HybridQuantity::Scalar>; + using Field_t = Grid, HybridQuantity::Scalar>; using FieldPtr = std::shared_ptr; std::string em_key; @@ -90,7 +91,7 @@ struct FieldCoarsenTestData static constexpr double absError = 1.e-8; using GridYee_t = GridLayout>; - using Field_t = Field, HybridQuantity::Scalar>; + using Field_t = Grid, HybridQuantity::Scalar>; EMData em; diff --git a/tests/amr/data/field/copy_pack/field_data_test_param.hpp b/tests/amr/data/field/copy_pack/field_data_test_param.hpp index 385d8b783..0632317fd 100644 --- a/tests/amr/data/field/copy_pack/field_data_test_param.hpp +++ b/tests/amr/data/field/copy_pack/field_data_test_param.hpp @@ -15,10 +15,11 @@ #include - #include "amr/data/field/field_data.hpp" #include "amr/data/field/field_overlap.hpp" #include "amr/data/field/field_variable.hpp" + +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "core/utilities/point/point.hpp" @@ -277,7 +278,7 @@ struct AFieldData1DCenteredOnEy : public ::testing::Test // Using used later in test -using Field1D = Field, HybridQuantity::Scalar>; +using Field1D = Grid, HybridQuantity::Scalar>; using FieldDataTest1DOrder1 = FieldDataTestParam>, Field1D>; using FieldDataTest1DOrder2 = FieldDataTestParam>, Field1D>; diff --git a/tests/amr/data/field/geometry/test_field_geometry.cpp b/tests/amr/data/field/geometry/test_field_geometry.cpp index 3f3f6b238..e33a68466 100644 --- a/tests/amr/data/field/geometry/test_field_geometry.cpp +++ b/tests/amr/data/field/geometry/test_field_geometry.cpp @@ -10,6 +10,7 @@ #include "amr/data/field/field_geometry.hpp" #include "amr/data/field/field_variable.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" @@ -31,7 +32,7 @@ using namespace PHARE::amr; -using Field1D = Field, HybridQuantity::Scalar>; +using Field1D = Grid, HybridQuantity::Scalar>; template struct FieldGeometryParam diff --git a/tests/amr/data/field/refine/test_field_refine.cpp b/tests/amr/data/field/refine/test_field_refine.cpp index 8b3a1b4e8..c3ad7632a 100644 --- a/tests/amr/data/field/refine/test_field_refine.cpp +++ b/tests/amr/data/field/refine/test_field_refine.cpp @@ -78,7 +78,7 @@ TYPED_TEST(aFieldRefineOperator, canBeCreated) static constexpr auto interp = typename TypeParam::second_type{}(); using GridYee = GridLayout>; - using FieldT = Field, HybridQuantity::Scalar>; + using FieldT = Grid, HybridQuantity::Scalar>; FieldRefineOperator> linearRefine{}; } diff --git a/tests/amr/data/field/refine/test_field_refinement_on_hierarchy.cpp b/tests/amr/data/field/refine/test_field_refinement_on_hierarchy.cpp index a0e299f2c..247499a86 100644 --- a/tests/amr/data/field/refine/test_field_refinement_on_hierarchy.cpp +++ b/tests/amr/data/field/refine/test_field_refinement_on_hierarchy.cpp @@ -20,7 +20,7 @@ struct ALinearFieldRefineTest : public ::testing::Test static constexpr auto refine = 2; using GridYee = GridLayout>; - using FieldND = Field, HybridQuantity::Scalar>; + using FieldND = Grid, HybridQuantity::Scalar>; public: void SetUp() override @@ -51,7 +51,7 @@ TYPED_TEST(ALinearFieldRefineTest, ConserveLinearFunction) auto constexpr interp = pair.second(); using GridYee = GridLayout>; - using FieldND = Field, HybridQuantity::Scalar>; + using FieldND = Grid, HybridQuantity::Scalar>; auto& basicHierarchy = this->basicHierarchy_; diff --git a/tests/amr/data/field/refine/test_field_refinement_on_hierarchy.hpp b/tests/amr/data/field/refine/test_field_refinement_on_hierarchy.hpp index cb4dde6db..cea0c5dc5 100644 --- a/tests/amr/data/field/refine/test_field_refinement_on_hierarchy.hpp +++ b/tests/amr/data/field/refine/test_field_refinement_on_hierarchy.hpp @@ -6,6 +6,7 @@ #include "amr/data/field/field_variable.hpp" #include "amr/data/field/refine/field_refine_operator.hpp" #include "amr/data/field/refine/field_refiner.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "test_tag_strategy.hpp" diff --git a/tests/amr/data/field/time_interpolate/test_field_data_time_interpolate.cpp b/tests/amr/data/field/time_interpolate/test_field_data_time_interpolate.cpp index 2807e7857..ec3c99e95 100644 --- a/tests/amr/data/field/time_interpolate/test_field_data_time_interpolate.cpp +++ b/tests/amr/data/field/time_interpolate/test_field_data_time_interpolate.cpp @@ -12,7 +12,7 @@ #include "amr/data/field/time_interpolate/field_linear_time_interpolate.hpp" -#include "core/data/field/field.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "core/hybrid/hybrid_quantities.hpp" @@ -48,7 +48,7 @@ struct aFieldLinearTimeInterpolate : public ::testing::Test static constexpr auto interp = typename TypeInfo::second_type{}(); using GridYee = GridLayout>; - using FieldND = Field, HybridQuantity::Scalar>; + using FieldND = Grid, HybridQuantity::Scalar>; using FieldDataT = FieldData; FieldLinearTimeInterpolate timeOp{}; diff --git a/tests/amr/data/field/variable/test_field_variable.cpp b/tests/amr/data/field/variable/test_field_variable.cpp index 3657c7c54..5c6e52aaf 100644 --- a/tests/amr/data/field/variable/test_field_variable.cpp +++ b/tests/amr/data/field/variable/test_field_variable.cpp @@ -8,8 +8,8 @@ #include "gtest/gtest.h" -#include "core/data/field/field.hpp" #include "amr/data/field/field_variable.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "core/data/ndarray/ndarray_vector.hpp" @@ -50,7 +50,7 @@ struct FieldVariableTest : public ::testing::TestWithParam using FieldVar = FieldVariable>, - Field, HybridQuantity::Scalar>>; + Grid, HybridQuantity::Scalar>>; // The interp order is of no importance to know if a quantity diff --git a/tests/amr/models/test_models.cpp b/tests/amr/models/test_models.cpp index 41f022ba3..d22757983 100644 --- a/tests/amr/models/test_models.cpp +++ b/tests/amr/models/test_models.cpp @@ -29,18 +29,21 @@ using namespace PHARE::amr; #include "tests/initializer/init_functions.hpp" using namespace PHARE::initializer::test_fn::func_1d; // density/etc are here - static constexpr std::size_t dim = 1; static constexpr std::size_t interpOrder = 1; -using VecField1D = VecField, HybridQuantity>; -using GridImplYee1D = GridLayoutImplYee; -using ParticleArray1D = ParticleArray; -using GridYee1D = GridLayout; + +using Grid1D = Grid, HybridQuantity::Scalar>; +using VecField1D = VecField; +using GridImplYee1D = GridLayoutImplYee; +using ParticleArray1D = ParticleArray; +using GridYee1D = GridLayout; + using MaxwellianParticleInitializer1D = MaxwellianParticleInitializer; -using IonsPop1D = IonPopulation; -using Ions1D = Ions; -using Electromag1D = Electromag; -using Electrons1D = Electrons; + +using IonsPop1D = IonPopulation; +using Ions1D = Ions; +using Electromag1D = Electromag; +using Electrons1D = Electrons; using HybridModelT = HybridModel; using MHDModelT = MHDModel; using ResourcesManagerT = ResourcesManager; diff --git a/tests/amr/resources_manager/CMakeLists.txt b/tests/amr/resources_manager/CMakeLists.txt index fbe72ff84..70a6f07c9 100644 --- a/tests/amr/resources_manager/CMakeLists.txt +++ b/tests/amr/resources_manager/CMakeLists.txt @@ -11,7 +11,6 @@ set(SOURCES_INC ) set(SOURCES_CPP - test_resources_manager_basic_hierarchy.cpp test_resources_manager.cpp ) diff --git a/tests/amr/resources_manager/input_config.h b/tests/amr/resources_manager/input_config.h new file mode 100644 index 000000000..51998fd06 --- /dev/null +++ b/tests/amr/resources_manager/input_config.h @@ -0,0 +1,15 @@ +#ifndef TESTS_AMR_TOOLS_RESOURCES_MANAGER_INPUT_CONFIG_HPP +#define TESTS_AMR_TOOLS_RESOURCES_MANAGER_INPUT_CONFIG_HPP + +#include +#include + +namespace PHARE +{ +namespace amr +{ + const std::string inputBase = "/home/p/git/phare/master/tests/amr/resources_manager/"; +} +} // namespace PHARE + +#endif diff --git a/tests/amr/resources_manager/test_resources_manager.cpp b/tests/amr/resources_manager/test_resources_manager.cpp index ae2b0280d..21e6f1003 100644 --- a/tests/amr/resources_manager/test_resources_manager.cpp +++ b/tests/amr/resources_manager/test_resources_manager.cpp @@ -5,6 +5,7 @@ #include "test_resources_manager.hpp" #include "core/data/electromag/electromag.hpp" #include "core/data/electrons/electrons.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "core/data/ions/particle_initializers/maxwellian_particle_initializer.hpp" @@ -30,19 +31,21 @@ using namespace PHARE::initializer::test_fn::func_1d; // density/etc are here static constexpr std::size_t dim = 1; static constexpr std::size_t interpOrder = 1; -using GridImplYee1D = GridLayoutImplYee; -using GridYee1D = GridLayout; -using VecField1D = VecField, HybridQuantity>; -using IonPopulation1D = IonPopulation, VecField1D, GridYee1D>; -using Ions1D = Ions; -using Electromag1D = Electromag; -using Electrons1D = Electrons; -using MaxwellianParticleInitializer1D = MaxwellianParticleInitializer, GridYee1D>; -using HybridState1D = HybridState; +using GridImplYee1D = GridLayoutImplYee; +using GridYee1D = GridLayout; +using Grid1D = Grid, HybridQuantity::Scalar>; +using VecField1D = VecField; +using IonPopulation1D = IonPopulation, VecField1D, GridYee1D>; +using Ions1D = Ions; +using Electromag1D = Electromag; +using Electrons1D = Electrons; +using HybridState1D = HybridState; +using MaxwellianParticleInitializer1D + = MaxwellianParticleInitializer, GridYee1D>; -using InitFunctionT = PHARE::initializer::InitFunction<1>; +using InitFunctionT = PHARE::initializer::InitFunction; PHARE::initializer::PHAREDict createInitDict() { diff --git a/tests/amr/resources_manager/test_resources_manager_basic_hierarchy.cpp b/tests/amr/resources_manager/test_resources_manager_basic_hierarchy.cpp deleted file mode 100644 index f09962f7a..000000000 --- a/tests/amr/resources_manager/test_resources_manager_basic_hierarchy.cpp +++ /dev/null @@ -1,51 +0,0 @@ -#include "test_resources_manager_basic_hierarchy.hpp" - -BasicHierarchy::BasicHierarchy(std::string const& inputFile) - : inputDatabase{SAMRAI::tbox::InputManager::getManager()->parseInputFile(inputFile)} - , dimension{static_cast( - inputDatabase->getDatabase("Main")->getInteger("dim"))} - , patchHierarchyDatabase{inputDatabase->getDatabase("PatchHierarchy")} - , gridGeometry{std::make_shared( - dimension, "cartesian", inputDatabase->getDatabase("CartesianGridGeometry"))} - , hierarchy{std::make_shared("PatchHierarchy", gridGeometry, - patchHierarchyDatabase)} - -{ -} - - - - -void BasicHierarchy::init() -{ - auto dim - = static_cast(inputDatabase->getDatabase("Main")->getInteger("dim")); - std::vector lowerIndex, upperIndex; - for (std::size_t i = 0; i < dim; i++) - { - lowerIndex.emplace_back(0); - upperIndex.emplace_back(64); - } - - SAMRAI::hier::Box boxLevel0{dimension}; - - int const ownerRank = SAMRAI::tbox::SAMRAI_MPI::getSAMRAIWorld().getRank(); - static int counterId = 0; - - auto idLevel0 = SAMRAI::hier::GlobalId{SAMRAI::hier::LocalId{counterId}, ownerRank}; - ++counterId; - - boxLevel0.setBlockId(SAMRAI::hier::BlockId{0}); - boxLevel0.setId(SAMRAI::hier::BoxId{idLevel0}); - - boxLevel0.setLower(SAMRAI::hier::Index(lowerIndex)); - boxLevel0.setUpper(SAMRAI::hier::Index(upperIndex)); - - SAMRAI::hier::BoxContainer level0Container; - - level0Container.push_back(boxLevel0); - - SAMRAI::hier::BoxLevel level0{level0Container, SAMRAI::hier::IntVector::getOne(dimension), - gridGeometry}; - hierarchy->makeNewPatchLevel(0, level0); -} diff --git a/tests/amr/resources_manager/test_resources_manager_basic_hierarchy.hpp b/tests/amr/resources_manager/test_resources_manager_basic_hierarchy.hpp index f7fe9b408..8e21ec7c9 100644 --- a/tests/amr/resources_manager/test_resources_manager_basic_hierarchy.hpp +++ b/tests/amr/resources_manager/test_resources_manager_basic_hierarchy.hpp @@ -27,4 +27,56 @@ class BasicHierarchy void init(); }; + +BasicHierarchy::BasicHierarchy(std::string const& inputFile) + : inputDatabase{SAMRAI::tbox::InputManager::getManager()->parseInputFile(inputFile)} + , dimension{static_cast( + inputDatabase->getDatabase("Main")->getInteger("dim"))} + , patchHierarchyDatabase{inputDatabase->getDatabase("PatchHierarchy")} + , gridGeometry{std::make_shared( + dimension, "cartesian", inputDatabase->getDatabase("CartesianGridGeometry"))} + , hierarchy{std::make_shared("PatchHierarchy", gridGeometry, + patchHierarchyDatabase)} + +{ +} + + + + +void BasicHierarchy::init() +{ + auto dim + = static_cast(inputDatabase->getDatabase("Main")->getInteger("dim")); + std::vector lowerIndex, upperIndex; + for (std::size_t i = 0; i < dim; i++) + { + lowerIndex.emplace_back(0); + upperIndex.emplace_back(64); + } + + SAMRAI::hier::Box boxLevel0{dimension}; + + int const ownerRank = SAMRAI::tbox::SAMRAI_MPI::getSAMRAIWorld().getRank(); + static int counterId = 0; + + auto idLevel0 = SAMRAI::hier::GlobalId{SAMRAI::hier::LocalId{counterId}, ownerRank}; + ++counterId; + + boxLevel0.setBlockId(SAMRAI::hier::BlockId{0}); + boxLevel0.setId(SAMRAI::hier::BoxId{idLevel0}); + + boxLevel0.setLower(SAMRAI::hier::Index(lowerIndex)); + boxLevel0.setUpper(SAMRAI::hier::Index(upperIndex)); + + SAMRAI::hier::BoxContainer level0Container; + + level0Container.push_back(boxLevel0); + + SAMRAI::hier::BoxLevel level0{level0Container, SAMRAI::hier::IntVector::getOne(dimension), + gridGeometry}; + hierarchy->makeNewPatchLevel(0, level0); +} + + #endif diff --git a/tests/amr/tagging/test_tagging.cpp b/tests/amr/tagging/test_tagging.cpp index 9a9f167b1..00d7030fa 100644 --- a/tests/amr/tagging/test_tagging.cpp +++ b/tests/amr/tagging/test_tagging.cpp @@ -161,7 +161,7 @@ struct TestTagger : public ::testing::Test using Electromag = typename phare_types::Electromag_t; using Ions = typename phare_types::Ions_t; using Electrons = typename phare_types::Electrons_t; - using Field = typename phare_types::Field_t; + using Field = typename phare_types::Grid_t; using GridLayoutT = GridLayout>; struct SinglePatchHybridModel diff --git a/tests/core/data/electrons/test_electrons.cpp b/tests/core/data/electrons/test_electrons.cpp index 842c27c9d..32b752dd1 100644 --- a/tests/core/data/electrons/test_electrons.cpp +++ b/tests/core/data/electrons/test_electrons.cpp @@ -2,6 +2,7 @@ #include "initializer/data_provider.hpp" #include "core/data/electrons/electrons.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "core/data/vecfield/vecfield.hpp" @@ -16,6 +17,8 @@ #include "tests/initializer/init_functions.hpp" +#include + using namespace PHARE::core; const double Te = 0.12; @@ -121,12 +124,15 @@ class NDlayout template, InterpConst<1>>*/> struct ElectronsTest : public ::testing::Test { - static constexpr auto dim = typename TypeInfo::first_type{}(); - static constexpr auto interp = typename TypeInfo::second_type{}(); + static constexpr auto dim = typename TypeInfo::first_type{}(); + static constexpr auto interp = typename TypeInfo::second_type{}(); + static constexpr auto densityName = std::string_view{"rho"}; + using GridYee = GridLayout>; - using VecFieldND = VecField, HybridQuantity>; + using GridND = Grid, HybridQuantity::Scalar>; + using VecFieldND = VecField; using FieldND = typename VecFieldND::field_type; using IonPopulationND = IonPopulation, VecFieldND, GridYee>; @@ -136,38 +142,63 @@ struct ElectronsTest : public ::testing::Test GridYee layout = NDlayout::create(); - IonsT ions; + Electromag electromag; + GridND Jx, Jy, Jz; VecFieldND J; - FieldND Nibuffer; - FieldND NiProtons; - FieldND Vix; - FieldND Viy; - FieldND Viz; - FieldND Fxi; - FieldND Fyi; - FieldND Fzi; - PartPackND pack; - FieldND Vex; - FieldND Vey; - FieldND Vez; - FieldND Jx; - FieldND Jy; - FieldND Jz; + + + GridND Nibuffer; + GridND NiProtons; + GridND Fxi, Fyi, Fzi; + GridND Vex, Vey, Vez; + GridND Vix, Viy, Viz; + + IonsT ions; Electrons electrons; - FieldND Pe; + GridND Pe; + PartPackND pack{}; + + template + auto static _ions(Args&... args) + { + auto const& [Fxi, Fyi, Fzi, Nibuffer, NiProtons, Vix, Viy, Viz, pack] + = std::forward_as_tuple(args...); + IonsT ions{createDict()["ions"]}; + ions.setBuffer(ions.densityName(), &Nibuffer); + ions.velocity().setBuffer(Vix.name(), &Vix); + ions.velocity().setBuffer(Viy.name(), &Viy); + ions.velocity().setBuffer(Viz.name(), &Viz); + auto& pops = ions.getRunTimeResourcesUserList(); + pops[0].setBuffer(NiProtons.name(), &NiProtons); + pops[0].flux().setBuffer(Fxi.name(), &Fxi); + pops[0].flux().setBuffer(Fyi.name(), &Fyi); + pops[0].flux().setBuffer(Fzi.name(), &Fzi); + pops[0].setBuffer("protons", &pack); + return ions; + } + + template + auto static _J(Args&... args) + { + auto const& [Jx, Jy, Jz] = std::forward_as_tuple(args...); + VecFieldND J{"J", HybridQuantity::Vector::J}; + J.setBuffer(Jx.name(), &Jx); + J.setBuffer(Jy.name(), &Jy); + J.setBuffer(Jz.name(), &Jz); + return J; + } ElectronsTest() - : ions{createDict()["ions"]} - , electromag{createDict()["electromag"]} - , J{"J", HybridQuantity::Vector::J} - , Nibuffer{ions.densityName(), HybridQuantity::Scalar::rho, + : electromag{createDict()["electromag"]} + , Jx{"J_x", HybridQuantity::Scalar::Jx, layout.allocSize(HybridQuantity::Scalar::Jx)} + , Jy{"J_y", HybridQuantity::Scalar::Jy, layout.allocSize(HybridQuantity::Scalar::Jy)} + , Jz{"J_z", HybridQuantity::Scalar::Jz, layout.allocSize(HybridQuantity::Scalar::Jz)} + , J{_J(Jx, Jy, Jz)} + , Nibuffer{std::string{densityName}, HybridQuantity::Scalar::rho, layout.allocSize(HybridQuantity::Scalar::rho)} , NiProtons{"protons_rho", HybridQuantity::Scalar::rho, layout.allocSize(HybridQuantity::Scalar::rho)} - , Vix{"bulkVel_x", HybridQuantity::Scalar::Vx, layout.allocSize(HybridQuantity::Scalar::Vx)} - , Viy{"bulkVel_y", HybridQuantity::Scalar::Vy, layout.allocSize(HybridQuantity::Scalar::Vy)} - , Viz{"bulkVel_z", HybridQuantity::Scalar::Vz, layout.allocSize(HybridQuantity::Scalar::Vz)} , Fxi{"protons_flux_x", HybridQuantity::Scalar::Vx, layout.allocSize(HybridQuantity::Scalar::Vx)} , Fyi{"protons_flux_y", HybridQuantity::Scalar::Vy, @@ -180,29 +211,13 @@ struct ElectronsTest : public ::testing::Test layout.allocSize(HybridQuantity::Scalar::Vy)} , Vez{"StandardHybridElectronFluxComputer_Ve_z", HybridQuantity::Scalar::Vz, layout.allocSize(HybridQuantity::Scalar::Vz)} - , Jx{"J_x", HybridQuantity::Scalar::Jx, layout.allocSize(HybridQuantity::Scalar::Jx)} - , Jy{"J_y", HybridQuantity::Scalar::Jy, layout.allocSize(HybridQuantity::Scalar::Jy)} - , Jz{"J_z", HybridQuantity::Scalar::Jz, layout.allocSize(HybridQuantity::Scalar::Jz)} + , Vix{"bulkVel_x", HybridQuantity::Scalar::Vx, layout.allocSize(HybridQuantity::Scalar::Vx)} + , Viy{"bulkVel_y", HybridQuantity::Scalar::Vy, layout.allocSize(HybridQuantity::Scalar::Vy)} + , Viz{"bulkVel_z", HybridQuantity::Scalar::Vz, layout.allocSize(HybridQuantity::Scalar::Vz)} + , ions{_ions(Fxi, Fyi, Fzi, Nibuffer, NiProtons, Vix, Viy, Viz, pack)} , electrons{createDict()["electrons"], ions, J} , Pe{"Pe", HybridQuantity::Scalar::P, layout.allocSize(HybridQuantity::Scalar::P)} { - J.setBuffer(Jx.name(), &Jx); - J.setBuffer(Jy.name(), &Jy); - J.setBuffer(Jz.name(), &Jz); - - ions.setBuffer(ions.densityName(), &Nibuffer); - ions.velocity().setBuffer(Vix.name(), &Vix); - ions.velocity().setBuffer(Viy.name(), &Viy); - ions.velocity().setBuffer(Viz.name(), &Viz); - - auto& pops = ions.getRunTimeResourcesUserList(); - - pops[0].setBuffer(NiProtons.name(), &NiProtons); - pops[0].flux().setBuffer(Fxi.name(), &Fxi); - pops[0].flux().setBuffer(Fyi.name(), &Fyi); - pops[0].flux().setBuffer(Fzi.name(), &Fzi); - pops[0].setBuffer("protons", &pack); - auto&& emm = std::get<0>(electrons.getCompileTimeResourcesUserList()); auto&& fc = std::get<0>(emm.getCompileTimeResourcesUserList()); auto&& Ve = std::get<0>(fc.getCompileTimeResourcesUserList()); @@ -217,7 +232,7 @@ struct ElectronsTest : public ::testing::Test if constexpr (dim == 1) { - auto fill = [this](FieldND& field, auto const& filler) { + auto fill = [this](auto& field, auto const& filler) { auto gsi_X = this->layout.ghostStartIndex(field, Direction::X); auto gei_X = this->layout.ghostEndIndex(field, Direction::X); @@ -240,7 +255,7 @@ struct ElectronsTest : public ::testing::Test } else if constexpr (dim == 2) { - auto fill = [this](FieldND& field, auto const& filler) { + auto fill = [this](auto& field, auto const& filler) { auto gsi_X = this->layout.ghostStartIndex(field, Direction::X); auto gei_X = this->layout.ghostEndIndex(field, Direction::X); auto gsi_Y = this->layout.ghostStartIndex(field, Direction::Y); @@ -270,7 +285,7 @@ struct ElectronsTest : public ::testing::Test } else if constexpr (dim == 3) { - auto fill = [this](FieldND& field, auto const& filler) { + auto fill = [this](auto& field, auto const& filler) { auto gsi_X = this->layout.ghostStartIndex(field, Direction::X); auto gei_X = this->layout.ghostEndIndex(field, Direction::X); auto gsi_Y = this->layout.ghostStartIndex(field, Direction::Y); @@ -448,21 +463,17 @@ TYPED_TEST(ElectronsTest, ThatElectronsVelocityEqualIonVelocityMinusJ) { static constexpr auto dim = typename TypeParam::first_type{}(); static constexpr auto interp = typename TypeParam::second_type{}(); + using GridYee = GridLayout>; auto& electrons = this->electrons; auto& layout = this->layout; - using VecFieldND = VecField, HybridQuantity>; - using FieldND = typename VecFieldND::field_type; - using GridYee = GridLayout>; - - electrons.update(layout); auto& Ne = electrons.density(); - auto check = [&layout](FieldND const& Vecomp, FieldND const& Vicomp, FieldND const& Jcomp, - FieldND const& Ne_, auto const& projector) -> void { + auto check = [&layout](auto const& Vecomp, auto const& Vicomp, auto const& Jcomp, + auto const& Ne_, auto const& projector) -> void { if constexpr (dim == 1) { auto psi_X = layout.physicalStartIndex(Vicomp, Direction::X); @@ -584,6 +595,7 @@ TYPED_TEST(ElectronsTest, ThatElectronsPressureEqualsNeTe) + int main(int argc, char** argv) { ::testing::InitGoogleTest(&argc, argv); diff --git a/tests/core/data/field/test_field.hpp b/tests/core/data/field/test_field.hpp index 38eff4218..da8e96968 100644 --- a/tests/core/data/field/test_field.hpp +++ b/tests/core/data/field/test_field.hpp @@ -4,10 +4,11 @@ #include #include +#include "core/data/ndarray/ndarray_vector.hpp" + #include "gmock/gmock.h" #include "gtest/gtest.h" - namespace PHARE { template @@ -172,43 +173,21 @@ void test(GridLayout const& layout, } -template -void test(GridLayout const& layout, - PHARE::core::Field const& field0, - PHARE::core::NdArrayView const& field1, FF const ff = FF{}) -{ - static_assert(NdArrayImpl::dimension == dim); - test_fields(layout, field0, field1, ff); -} - -template -void test(GridLayout const& layout, - PHARE::core::Field const& field0, - std::vector const& fieldV, FF const ff = FF{}) +template +void test(GridLayout const& layout, Field const& field0, std::vector const& fieldV, + FF const ff = FF{}) { EXPECT_EQ(field0.size(), fieldV.size()); - core::NdArrayView const field1{fieldV.data(), field0.shape()}; + core::NdArrayView const field1{fieldV.data(), field0.shape()}; test_fields(layout, field0, field1, ff); } -template -void test(GridLayout const& layout, PHARE::core::Field field0, - std::vector&& fieldV, FF const ff = FF{}) -{ - EXPECT_EQ(field0.size(), fieldV.size()); - core::NdArrayView field1{fieldV, field0.shape()}; - test_fields(layout, field0, field1, ff); -} -template -void test(GridLayout const& layout, PHARE::core::Field field0, - PHARE::core::Field field1, FF const ff = FF{}) +void test(GridLayout const& layout, Field0 const& field0, Field1 const& field1, FF const ff = FF{}) { test_fields(layout, field0, field1, ff); } diff --git a/tests/core/data/field/CMakeLists.txt b/tests/core/data/grid/CMakeLists.txt similarity index 86% rename from tests/core/data/field/CMakeLists.txt rename to tests/core/data/grid/CMakeLists.txt index 61c097993..a2ce84ca0 100644 --- a/tests/core/data/field/CMakeLists.txt +++ b/tests/core/data/grid/CMakeLists.txt @@ -1,8 +1,8 @@ cmake_minimum_required (VERSION 3.9) -project(test-field) +project(test-grid) -set(SOURCES test_field.cpp) +set(SOURCES test_grid.cpp) add_executable(${PROJECT_NAME} ${SOURCES}) diff --git a/tests/core/data/field/test_field.cpp b/tests/core/data/grid/test_grid.cpp similarity index 57% rename from tests/core/data/field/test_field.cpp rename to tests/core/data/grid/test_grid.cpp index 8301ddc64..1a33de937 100644 --- a/tests/core/data/field/test_field.cpp +++ b/tests/core/data/grid/test_grid.cpp @@ -2,7 +2,7 @@ #include #include -#include "core/data/field/field.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/ndarray/ndarray_vector.hpp" #include "core/hybrid/hybrid_quantities.hpp" @@ -13,25 +13,25 @@ using namespace PHARE::core; template -class GenericField1D : public ::testing::Test +class GenericGrid1D : public ::testing::Test { public: - GenericField1D() + GenericGrid1D() : f{"test", HybridQuantity::Scalar::rho, nx} { } protected: const std::uint32_t nx = 10; - Field f; + Grid f; }; template -class GenericField2D : public ::testing::Test +class GenericGrid2D : public ::testing::Test { public: - GenericField2D() + GenericGrid2D() : f{"test", HybridQuantity::Scalar::rho, nx, ny} { } @@ -39,15 +39,15 @@ class GenericField2D : public ::testing::Test protected: const std::uint32_t nx = 10u; const std::uint32_t ny = 12u; - Field f; + Grid f; }; template -class GenericField3D : public ::testing::Test +class GenericGrid3D : public ::testing::Test { public: - GenericField3D() + GenericGrid3D() : f{"test", HybridQuantity::Scalar::rho, nx, ny, nz} { } @@ -56,7 +56,7 @@ class GenericField3D : public ::testing::Test const std::uint32_t nx = 10; const std::uint32_t ny = 12; const std::uint32_t nz = 12; - Field f; + Grid f; }; @@ -64,44 +64,44 @@ using NdArrays1D = ::testing::Types>; using NdArrays2D = ::testing::Types>; using NdArrays3D = ::testing::Types>; -TYPED_TEST_SUITE(GenericField1D, NdArrays1D); -TYPED_TEST_SUITE(GenericField2D, NdArrays2D); -TYPED_TEST_SUITE(GenericField3D, NdArrays3D); +TYPED_TEST_SUITE(GenericGrid1D, NdArrays1D); +TYPED_TEST_SUITE(GenericGrid2D, NdArrays2D); +TYPED_TEST_SUITE(GenericGrid3D, NdArrays3D); -TYPED_TEST(GenericField1D, ReturnsTotalNumberOfElements) +TYPED_TEST(GenericGrid1D, ReturnsTotalNumberOfElements) { EXPECT_EQ(this->nx, this->f.size()); } -TYPED_TEST(GenericField2D, ReturnsTotalNumberOfElements) +TYPED_TEST(GenericGrid2D, ReturnsTotalNumberOfElements) { EXPECT_EQ(this->nx * this->ny, this->f.size()); } -TYPED_TEST(GenericField3D, ReturnsTotalNumberOfElements) +TYPED_TEST(GenericGrid3D, ReturnsTotalNumberOfElements) { EXPECT_EQ(this->nx * this->ny * this->nz, this->f.size()); } -TYPED_TEST(GenericField1D, IsModifiable) +TYPED_TEST(GenericGrid1D, IsModifiable) { this->f(3u) = 4.8; EXPECT_FLOAT_EQ(4.8, this->f(3u)); } -TYPED_TEST(GenericField2D, IsModifiable) +TYPED_TEST(GenericGrid2D, IsModifiable) { this->f(3u, 8u) = 8.4; EXPECT_FLOAT_EQ(8.4, this->f(3u, 8u)); } -TYPED_TEST(GenericField3D, IsModifiable) +TYPED_TEST(GenericGrid3D, IsModifiable) { this->f(3u, 8u, 2u) = 84.48; EXPECT_FLOAT_EQ(84.48, this->f(3u, 8u, 2u)); @@ -109,7 +109,7 @@ TYPED_TEST(GenericField3D, IsModifiable) -TYPED_TEST(GenericField1D, CanBeReadOnly) +TYPED_TEST(GenericGrid1D, CanBeReadOnly) { this->f(3u) = 4.8; auto const& ref = this->f; @@ -117,7 +117,7 @@ TYPED_TEST(GenericField1D, CanBeReadOnly) } -TYPED_TEST(GenericField2D, CanBeReadOnly) +TYPED_TEST(GenericGrid2D, CanBeReadOnly) { this->f(3u, 8u) = 8.4; auto const& ref = this->f; @@ -125,7 +125,7 @@ TYPED_TEST(GenericField2D, CanBeReadOnly) } -TYPED_TEST(GenericField3D, CanBeReadOnly) +TYPED_TEST(GenericGrid3D, CanBeReadOnly) { this->f(3u, 8u, 2u) = 84.48; auto const& ref = this->f; @@ -135,34 +135,34 @@ TYPED_TEST(GenericField3D, CanBeReadOnly) -TYPED_TEST(GenericField1D, returnName) +TYPED_TEST(GenericGrid1D, returnName) { EXPECT_EQ(std::string("test"), this->f.name()); } -TYPED_TEST(GenericField2D, returnName) +TYPED_TEST(GenericGrid2D, returnName) { EXPECT_EQ(std::string("test"), this->f.name()); } -TYPED_TEST(GenericField3D, returnName) +TYPED_TEST(GenericGrid3D, returnName) { EXPECT_EQ(std::string("test"), this->f.name()); } -TYPED_TEST(GenericField1D, physiscalQuantity) +TYPED_TEST(GenericGrid1D, physicalQuantity) { EXPECT_EQ(HybridQuantity::Scalar::rho, this->f.physicalQuantity()); } -TYPED_TEST(GenericField2D, physiscalQuantity) +TYPED_TEST(GenericGrid2D, physicalQuantity) { EXPECT_EQ(HybridQuantity::Scalar::rho, this->f.physicalQuantity()); } -TYPED_TEST(GenericField3D, physiscalQuantity) +TYPED_TEST(GenericGrid3D, physicalQuantity) { EXPECT_EQ(HybridQuantity::Scalar::rho, this->f.physicalQuantity()); } @@ -170,11 +170,11 @@ TYPED_TEST(GenericField3D, physiscalQuantity) -TEST(Field1D, canBeAssigned) +TEST(Grid1D, canBeAssigned) { auto nx = 10u; - Field, HybridQuantity::Scalar> f{"test", HybridQuantity::Scalar::rho, nx}; - Field, HybridQuantity::Scalar> other{"other", HybridQuantity::Scalar::rho, nx}; + Grid, HybridQuantity::Scalar> f{"test", HybridQuantity::Scalar::rho, nx}; + Grid, HybridQuantity::Scalar> other{"other", HybridQuantity::Scalar::rho, nx}; for (auto& v : f) { @@ -192,13 +192,13 @@ TEST(Field1D, canBeAssigned) -TEST(Field2D, canBeAssigned) +TEST(Grid2D, canBeAssigned) { auto nx = 10u; auto ny = 11u; - Field, HybridQuantity::Scalar> f{"test", HybridQuantity::Scalar::rho, nx, ny}; - Field, HybridQuantity::Scalar> other{"other", HybridQuantity::Scalar::rho, nx, - ny}; + Grid, HybridQuantity::Scalar> f{"test", HybridQuantity::Scalar::rho, nx, ny}; + Grid, HybridQuantity::Scalar> other{"other", HybridQuantity::Scalar::rho, nx, + ny}; for (auto& v : f) { @@ -216,15 +216,15 @@ TEST(Field2D, canBeAssigned) -TEST(Field3D, canBeAssigned) +TEST(Grid3D, canBeAssigned) { auto nx = 10u; auto ny = 11u; auto nz = 12u; - Field, HybridQuantity::Scalar> f{"test", HybridQuantity::Scalar::rho, nx, ny, - nz}; - Field, HybridQuantity::Scalar> other{"other", HybridQuantity::Scalar::rho, nx, - ny, nz}; + Grid, HybridQuantity::Scalar> f{"test", HybridQuantity::Scalar::rho, nx, ny, + nz}; + Grid, HybridQuantity::Scalar> other{"other", HybridQuantity::Scalar::rho, nx, + ny, nz}; for (auto& v : f) { @@ -242,12 +242,12 @@ TEST(Field3D, canBeAssigned) -TEST(Field1D, canBeAveraged) +TEST(Grid1D, canBeAveraged) { auto nx = 15u; - Field, HybridQuantity::Scalar> f1{"f1", HybridQuantity::Scalar::rho, nx}; - Field, HybridQuantity::Scalar> f2{"f2", HybridQuantity::Scalar::rho, nx}; - Field, HybridQuantity::Scalar> avg{"f2", HybridQuantity::Scalar::rho, nx}; + Grid, HybridQuantity::Scalar> f1{"f1", HybridQuantity::Scalar::rho, nx}; + Grid, HybridQuantity::Scalar> f2{"f2", HybridQuantity::Scalar::rho, nx}; + Grid, HybridQuantity::Scalar> avg{"f2", HybridQuantity::Scalar::rho, nx}; // for (auto& v : f1) @@ -272,13 +272,13 @@ TEST(Field1D, canBeAveraged) -TEST(Field2D, canBeAveraged) +TEST(Grid2D, canBeAveraged) { auto nx = 15u; auto ny = 25u; - Field, HybridQuantity::Scalar> f1{"f1", HybridQuantity::Scalar::rho, nx, ny}; - Field, HybridQuantity::Scalar> f2{"f2", HybridQuantity::Scalar::rho, nx, ny}; - Field, HybridQuantity::Scalar> avg{"f2", HybridQuantity::Scalar::rho, nx, ny}; + Grid, HybridQuantity::Scalar> f1{"f1", HybridQuantity::Scalar::rho, nx, ny}; + Grid, HybridQuantity::Scalar> f2{"f2", HybridQuantity::Scalar::rho, nx, ny}; + Grid, HybridQuantity::Scalar> avg{"f2", HybridQuantity::Scalar::rho, nx, ny}; // for (auto& v : f1) @@ -303,17 +303,17 @@ TEST(Field2D, canBeAveraged) -TEST(Field3D, canBeAveraged) +TEST(Grid3D, canBeAveraged) { auto nx = 15u; auto ny = 25u; auto nz = 35u; - Field, HybridQuantity::Scalar> f1{"f1", HybridQuantity::Scalar::rho, nx, ny, - nz}; - Field, HybridQuantity::Scalar> f2{"f2", HybridQuantity::Scalar::rho, nx, ny, + Grid, HybridQuantity::Scalar> f1{"f1", HybridQuantity::Scalar::rho, nx, ny, + nz}; + Grid, HybridQuantity::Scalar> f2{"f2", HybridQuantity::Scalar::rho, nx, ny, + nz}; + Grid, HybridQuantity::Scalar> avg{"f2", HybridQuantity::Scalar::rho, nx, ny, nz}; - Field, HybridQuantity::Scalar> avg{"f2", HybridQuantity::Scalar::rho, nx, ny, - nz}; // for (auto& v : f1) diff --git a/tests/core/data/gridlayout/gridlayout_base_params.hpp b/tests/core/data/gridlayout/gridlayout_base_params.hpp index e80e7e10a..c34752134 100644 --- a/tests/core/data/gridlayout/gridlayout_base_params.hpp +++ b/tests/core/data/gridlayout/gridlayout_base_params.hpp @@ -4,21 +4,24 @@ #include +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayoutdefs.hpp" #include "core/data/ndarray/ndarray_vector.hpp" -#include "gridlayout_utilities.hpp" #include "core/utilities/point/point.hpp" +#include "gridlayout_utilities.hpp" + using namespace PHARE::core; template struct GridLayoutTestParam { - std::shared_ptr> layout; static constexpr std::size_t dim = GridLayoutImpl::dimension; static constexpr std::size_t interpOrder = GridLayoutImpl::interp_order; + using Grid_t = Grid{})), HybridQuantity::Scalar>; + std::shared_ptr> layout; std::array dxdydz; std::array nbCellXYZ; @@ -26,16 +29,13 @@ struct GridLayoutTestParam HybridQuantity::Scalar currentQuantity; - std::shared_ptr{})), HybridQuantity::Scalar>> - field; + std::shared_ptr field; template auto makeIt_(Container allocSize, std::index_sequence) { - return std::make_shared< - Field{})), HybridQuantity::Scalar>>( - "field", currentQuantity, (allocSize[I])...); + return std::make_shared("field", currentQuantity, (allocSize[I])...); } template diff --git a/tests/core/data/gridlayout/gridlayout_deriv.hpp b/tests/core/data/gridlayout/gridlayout_deriv.hpp index 0562d77cc..9cf6e4b2e 100644 --- a/tests/core/data/gridlayout/gridlayout_deriv.hpp +++ b/tests/core/data/gridlayout/gridlayout_deriv.hpp @@ -2,7 +2,7 @@ #define PHARE_TESTS_CORE_DATA_GRIDLAYOUT_GRIDLAYOUT_DERIV_HPP -#include "core/data/field/field.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "gridlayout_base_params.hpp" @@ -27,8 +27,8 @@ class a1DDerivative : public ::testing::Test protected: GridLayout layout; static constexpr std::size_t interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Ez; + Grid, HybridQuantity::Scalar> By; + Grid, HybridQuantity::Scalar> Ez; public: a1DDerivative() @@ -47,8 +47,8 @@ class a2DDerivative : public ::testing::Test protected: GridLayout layout; static constexpr std::size_t interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Ez; + Grid, HybridQuantity::Scalar> By; + Grid, HybridQuantity::Scalar> Ez; public: a2DDerivative() @@ -67,8 +67,8 @@ class a3DDerivative : public ::testing::Test protected: GridLayout layout; static constexpr std::size_t interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Ez; + Grid, HybridQuantity::Scalar> By; + Grid, HybridQuantity::Scalar> Ez; public: a3DDerivative() diff --git a/tests/core/data/gridlayout/gridlayout_laplacian.hpp b/tests/core/data/gridlayout/gridlayout_laplacian.hpp index 30f88ff9b..6f0e2cada 100644 --- a/tests/core/data/gridlayout/gridlayout_laplacian.hpp +++ b/tests/core/data/gridlayout/gridlayout_laplacian.hpp @@ -2,7 +2,7 @@ #define PHARE_TESTS_CORE_DATA_GRIDLAYOUT_GRIDLAYOUT_LAPLACIAN_HPP -#include "core/data/field/field.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "gridlayout_base_params.hpp" @@ -25,9 +25,9 @@ class a1DLaplacian : public ::testing::Test protected: GridLayout layout; static constexpr std::size_t interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> Jx; - Field, HybridQuantity::Scalar> Jy; - Field, HybridQuantity::Scalar> Jz; + Grid, HybridQuantity::Scalar> Jx; + Grid, HybridQuantity::Scalar> Jy; + Grid, HybridQuantity::Scalar> Jz; public: a1DLaplacian() @@ -47,9 +47,9 @@ class a2DLaplacian : public ::testing::Test protected: GridLayout layout; static constexpr std::size_t interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> Jx; - Field, HybridQuantity::Scalar> Jy; - Field, HybridQuantity::Scalar> Jz; + Grid, HybridQuantity::Scalar> Jx; + Grid, HybridQuantity::Scalar> Jy; + Grid, HybridQuantity::Scalar> Jz; public: a2DLaplacian() @@ -69,9 +69,9 @@ class a3DLaplacian : public ::testing::Test protected: GridLayout layout; static constexpr std::size_t interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> Jx; - Field, HybridQuantity::Scalar> Jy; - Field, HybridQuantity::Scalar> Jz; + Grid, HybridQuantity::Scalar> Jx; + Grid, HybridQuantity::Scalar> Jy; + Grid, HybridQuantity::Scalar> Jz; public: a3DLaplacian() diff --git a/tests/core/data/ion_population/test_ion_population.cpp b/tests/core/data/ion_population/test_ion_population.cpp index 170f51d2a..7aaf84578 100644 --- a/tests/core/data/ion_population/test_ion_population.cpp +++ b/tests/core/data/ion_population/test_ion_population.cpp @@ -24,6 +24,7 @@ struct DummyField struct DummyVecField { static constexpr std::size_t dimension = 1; + using grid_type = DummyField; using field_type = DummyField; DummyVecField(std::string name, [[maybe_unused]] HybridQuantity::Vector v) { (void)name; } bool isUsable() const { return false; } diff --git a/tests/core/data/ions/test_ions.cpp b/tests/core/data/ions/test_ions.cpp index 61012d794..8b11f1144 100644 --- a/tests/core/data/ions/test_ions.cpp +++ b/tests/core/data/ions/test_ions.cpp @@ -9,7 +9,7 @@ #include "core/data/vecfield/vecfield.hpp" #include "core/hybrid/hybrid_quantities.hpp" - +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "core/data/ions/particle_initializers/maxwellian_particle_initializer.hpp" @@ -34,7 +34,8 @@ using MaxwellianParticleInitializer1D = MaxwellianParticleInitializer, HybridQuantity>; + using Grid1D = Grid, HybridQuantity::Scalar>; + using VecField1D = VecField; using InitFunctionT = PHARE::initializer::InitFunction<1>; using IonPopulation1D = IonPopulation, VecField1D, GridYee1D>; diff --git a/tests/core/data/vecfield/test_main.cpp b/tests/core/data/vecfield/test_main.cpp index 7405ad5da..e9aa389a9 100644 --- a/tests/core/data/vecfield/test_main.cpp +++ b/tests/core/data/vecfield/test_main.cpp @@ -3,6 +3,7 @@ #include +#include "core/data/grid/grid.hpp" #include "core/data/field/field.hpp" #include "core/data/ndarray/ndarray_vector.hpp" #include "core/data/vecfield/vecfield.hpp" @@ -26,15 +27,18 @@ class VecFieldGeneric : public ::testing::Test protected: std::string vf2_name = "vf"; - VecField vf2; + VecField, HybridQuantity> vf2; }; -using NdArrays = ::testing::Types, NdArrayVector<2>, NdArrayVector<3>>; - +using NdArrays = ::testing::Types, NdArrayView<2>, NdArrayView<3>>; TYPED_TEST_SUITE(VecFieldGeneric, NdArrays); +template +using VecField_t = VecField, HybridQuantity::Scalar>, HybridQuantity>; + + class VecFieldTest : public ::testing::Test { public: @@ -88,21 +92,21 @@ class VecFieldTest : public ::testing::Test static const std::uint32_t nx; static const std::uint32_t ny; static const std::uint32_t nz; - Field, typename HybridQuantity::Scalar> bx1d_; - Field, typename HybridQuantity::Scalar> by1d_; - Field, typename HybridQuantity::Scalar> bz1d_; + Grid, typename HybridQuantity::Scalar> bx1d_; + Grid, typename HybridQuantity::Scalar> by1d_; + Grid, typename HybridQuantity::Scalar> bz1d_; - Field, typename HybridQuantity::Scalar> bx2d_; - Field, typename HybridQuantity::Scalar> by2d_; - Field, typename HybridQuantity::Scalar> bz2d_; + Grid, typename HybridQuantity::Scalar> bx2d_; + Grid, typename HybridQuantity::Scalar> by2d_; + Grid, typename HybridQuantity::Scalar> bz2d_; - Field, typename HybridQuantity::Scalar> bx3d_; - Field, typename HybridQuantity::Scalar> by3d_; - Field, typename HybridQuantity::Scalar> bz3d_; + Grid, typename HybridQuantity::Scalar> bx3d_; + Grid, typename HybridQuantity::Scalar> by3d_; + Grid, typename HybridQuantity::Scalar> bz3d_; - VecField, HybridQuantity> B1D_; - VecField, HybridQuantity> B2D_; - VecField, HybridQuantity> B3D_; + VecField_t<1> B1D_; + VecField_t<2> B2D_; + VecField_t<3> B3D_; }; const std::uint32_t VecFieldTest::nx = 10; @@ -299,10 +303,10 @@ TEST(aVecField, dataCanBeCopiedIntoAnother) { using Scalar = typename HybridQuantity::Scalar; - Field, Scalar> bx1{"B1_bx1", Scalar::Bx, 2u, 3u, 4u}; - Field, Scalar> by1{"B1_by1", Scalar::By, 2u, 3u, 4u}; - Field, Scalar> bz1{"B1_bz1", Scalar::Bz, 2u, 3u, 4u}; - VecField, HybridQuantity> B1{"B1", HybridQuantity::Vector::B}; + Grid, Scalar> bx1{"B1_bx1", Scalar::Bx, 2u, 3u, 4u}; + Grid, Scalar> by1{"B1_by1", Scalar::By, 2u, 3u, 4u}; + Grid, Scalar> bz1{"B1_bz1", Scalar::Bz, 2u, 3u, 4u}; + VecField_t<3> B1{"B1", HybridQuantity::Vector::B}; B1.setBuffer("B1_x", &bx1); B1.setBuffer("B1_y", &by1); B1.setBuffer("B1_z", &bz1); @@ -311,10 +315,10 @@ TEST(aVecField, dataCanBeCopiedIntoAnother) by1(1, 1, 1) = 13; bz1(1, 1, 1) = 14; - Field, Scalar> bx2{"B2_bx2", Scalar::Bx, 2u, 3u, 4u}; - Field, Scalar> by2{"B2_by2", Scalar::By, 2u, 3u, 4u}; - Field, Scalar> bz2{"B2_bz2", Scalar::Bz, 2u, 3u, 4u}; - VecField, HybridQuantity> B2{"B2", HybridQuantity::Vector::B}; + Grid, Scalar> bx2{"B2_bx2", Scalar::Bx, 2u, 3u, 4u}; + Grid, Scalar> by2{"B2_by2", Scalar::By, 2u, 3u, 4u}; + Grid, Scalar> bz2{"B2_bz2", Scalar::Bz, 2u, 3u, 4u}; + VecField_t<3> B2{"B2", HybridQuantity::Vector::B}; B2.setBuffer("B2_x", &bx2); B2.setBuffer("B2_y", &by2); B2.setBuffer("B2_z", &bz2); diff --git a/tests/core/numerics/ampere/test_main.cpp b/tests/core/numerics/ampere/test_main.cpp index c24a88e63..1ef5fe077 100644 --- a/tests/core/numerics/ampere/test_main.cpp +++ b/tests/core/numerics/ampere/test_main.cpp @@ -5,6 +5,7 @@ #include +#include "core/data/grid/grid.hpp" #include "core/data/field/field.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" @@ -34,14 +35,8 @@ struct GridLayoutMock1D } - std::size_t physicalStartIndex([[maybe_unused]] FieldMock<1>&, [[maybe_unused]] Direction dir) - { - return 0; - } - std::size_t physicalEndIndex([[maybe_unused]] FieldMock<1>&, [[maybe_unused]] Direction dir) - { - return 0; - } + std::size_t physicalStartIndex(FieldMock<1>&, Direction /*dir*/) { return 0; } + std::size_t physicalEndIndex(FieldMock<1>&, Direction /*dir*/) { return 0; } }; struct GridLayoutMock2D @@ -69,18 +64,13 @@ struct GridLayoutMock3D return 0; } - std::size_t physicalStartIndex([[maybe_unused]] FieldMock&, - [[maybe_unused]] Direction dir) - { - return 0; - } - std::size_t physicalEndIndex([[maybe_unused]] FieldMock&, - [[maybe_unused]] Direction dir) - { - return 0; - } + std::size_t physicalStartIndex(FieldMock&, Direction /*dir*/) { return 0; } + std::size_t physicalEndIndex(FieldMock&, Direction /*dir*/) { return 0; } }; +template +using Grid_t = Grid, HybridQuantity::Scalar>; + TEST(Ampere, canBe1D) @@ -135,19 +125,20 @@ std::vector read(std::string filename) class Ampere1DTest : public ::testing::Test { protected: - using GridLayoutImpl = GridLayoutImplYee<1, 1>; + static constexpr std::size_t dim = 1; + static constexpr std::size_t interp_order = 1; + using GridLayoutImpl = GridLayoutImplYee; GridLayout layout; - static constexpr auto interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> Bx; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Bz; - Field, HybridQuantity::Scalar> Jx; - Field, HybridQuantity::Scalar> Jy; - Field, HybridQuantity::Scalar> Jz; + Grid_t Bx; + Grid_t By; + Grid_t Bz; + Grid_t Jx; + Grid_t Jy; + Grid_t Jz; - VecField, HybridQuantity> B; - VecField, HybridQuantity> J; + VecField, HybridQuantity> B; + VecField, HybridQuantity> J; Ampere> ampere; @@ -176,19 +167,20 @@ class Ampere1DTest : public ::testing::Test class Ampere2DTest : public ::testing::Test { protected: - using GridLayoutImpl = GridLayoutImplYee<2, 1>; + static constexpr std::size_t dim = 2; + static constexpr std::size_t interp_order = 1; + using GridLayoutImpl = GridLayoutImplYee; GridLayout layout; - static constexpr auto interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> Bx; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Bz; - Field, HybridQuantity::Scalar> Jx; - Field, HybridQuantity::Scalar> Jy; - Field, HybridQuantity::Scalar> Jz; + Grid_t Bx; + Grid_t By; + Grid_t Bz; + Grid_t Jx; + Grid_t Jy; + Grid_t Jz; - VecField, HybridQuantity> B; - VecField, HybridQuantity> J; + VecField, HybridQuantity> B; + VecField, HybridQuantity> J; Ampere> ampere; @@ -217,19 +209,21 @@ class Ampere2DTest : public ::testing::Test class Ampere3DTest : public ::testing::Test { protected: - using GridLayoutImpl = GridLayoutImplYee<3, 1>; + static constexpr std::size_t dim = 3; + static constexpr std::size_t interp_order = 1; + using GridLayoutImpl = GridLayoutImplYee; GridLayout layout; - static constexpr auto interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> Bx; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Bz; - Field, HybridQuantity::Scalar> Jx; - Field, HybridQuantity::Scalar> Jy; - Field, HybridQuantity::Scalar> Jz; - VecField, HybridQuantity> B; - VecField, HybridQuantity> J; + Grid_t Bx; + Grid_t By; + Grid_t Bz; + Grid_t Jx; + Grid_t Jy; + Grid_t Jz; + + VecField, HybridQuantity> B; + VecField, HybridQuantity> J; Ampere> ampere; diff --git a/tests/core/numerics/faraday/test_main.cpp b/tests/core/numerics/faraday/test_main.cpp index 915bb089d..66fdcf5de 100644 --- a/tests/core/numerics/faraday/test_main.cpp +++ b/tests/core/numerics/faraday/test_main.cpp @@ -5,7 +5,7 @@ #include -#include "core/data/field/field.hpp" +#include "core/data/grid/grid.hpp" #include "core/data/grid/gridlayout.hpp" #include "core/data/grid/gridlayout_impl.hpp" #include "core/data/grid/gridlayoutdefs.hpp" @@ -29,19 +29,13 @@ struct GridLayoutMock1D static const auto dimension = 1u; template - double deriv([[maybe_unused]] FieldMock<1> const& f, [[maybe_unused]] MeshIndex<1u> mi) + double deriv(FieldMock<1> const& /*f*/, MeshIndex<1u> /*mi*/) { return 0; } - std::size_t physicalStartIndex([[maybe_unused]] FieldMock<1>&, [[maybe_unused]] Direction dir) - { - return 0; - } - std::size_t physicalEndIndex([[maybe_unused]] FieldMock<1>&, [[maybe_unused]] Direction dir) - { - return 0; - } + std::size_t physicalStartIndex(FieldMock<1>&, Direction /*dir*/) { return 0; } + std::size_t physicalEndIndex(FieldMock<1>&, Direction /*dir*/) { return 0; } }; struct GridLayoutMock2D @@ -49,21 +43,13 @@ struct GridLayoutMock2D static const auto dimension = 2u; template - double deriv([[maybe_unused]] FieldMock const& f, [[maybe_unused]] MeshIndex<2u> mi) + double deriv(FieldMock const& /*f*/, MeshIndex<2u> /*mi*/) { return 0; } - std::size_t physicalStartIndex([[maybe_unused]] FieldMock&, - [[maybe_unused]] Direction dir) - { - return 0; - } - std::size_t physicalEndIndex([[maybe_unused]] FieldMock&, - [[maybe_unused]] Direction dir) - { - return 0; - } + std::size_t physicalStartIndex(FieldMock&, Direction /*dir*/) { return 0; } + std::size_t physicalEndIndex(FieldMock&, Direction /*dir*/) { return 0; } }; struct GridLayoutMock3D @@ -72,21 +58,13 @@ struct GridLayoutMock3D template - double deriv([[maybe_unused]] FieldMock const& f, [[maybe_unused]] MeshIndex<3u> mi) + double deriv(FieldMock const& /*f*/, MeshIndex<3u> /*mi*/) { return 0; } - std::size_t physicalStartIndex([[maybe_unused]] FieldMock&, - [[maybe_unused]] Direction dir) - { - return 0; - } - std::size_t physicalEndIndex([[maybe_unused]] FieldMock&, - [[maybe_unused]] Direction dir) - { - return 0; - } + std::size_t physicalStartIndex(FieldMock&, Direction /*dir*/) { return 0; } + std::size_t physicalEndIndex(FieldMock&, Direction /*dir*/) { return 0; } }; @@ -158,21 +136,25 @@ std::vector read(std::string filename) class Faraday1DTest : public ::testing::Test { protected: - using GridLayoutImpl = GridLayoutImplYee<1, 1>; + static constexpr auto dim = 1; + static constexpr auto interp_order = 1; + + using Grid_t = Grid, HybridQuantity::Scalar>; + using GridLayoutImpl = GridLayoutImplYee; + GridLayout layout; - static constexpr auto interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> Bx; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Bz; - Field, HybridQuantity::Scalar> Ex; - Field, HybridQuantity::Scalar> Ey; - Field, HybridQuantity::Scalar> Ez; - Field, HybridQuantity::Scalar> Bxnew; - Field, HybridQuantity::Scalar> Bynew; - Field, HybridQuantity::Scalar> Bznew; - VecField, HybridQuantity> B; - VecField, HybridQuantity> E; - VecField, HybridQuantity> Bnew; + Grid_t Bx; + Grid_t By; + Grid_t Bz; + Grid_t Ex; + Grid_t Ey; + Grid_t Ez; + Grid_t Bxnew; + Grid_t Bynew; + Grid_t Bznew; + VecField B; + VecField E; + VecField Bnew; Faraday> faraday; public: @@ -209,21 +191,25 @@ class Faraday1DTest : public ::testing::Test class Faraday2DTest : public ::testing::Test { protected: - using GridLayoutImpl = GridLayoutImplYee<2, 1>; + static constexpr auto dim = 2; + static constexpr auto interp_order = 1; + + using Grid_t = Grid, HybridQuantity::Scalar>; + using GridLayoutImpl = GridLayoutImplYee; + GridLayout layout; - static constexpr auto interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> Bx; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Bz; - Field, HybridQuantity::Scalar> Ex; - Field, HybridQuantity::Scalar> Ey; - Field, HybridQuantity::Scalar> Ez; - Field, HybridQuantity::Scalar> Bxnew; - Field, HybridQuantity::Scalar> Bynew; - Field, HybridQuantity::Scalar> Bznew; - VecField, HybridQuantity> B; - VecField, HybridQuantity> E; - VecField, HybridQuantity> Bnew; + Grid_t Bx; + Grid_t By; + Grid_t Bz; + Grid_t Ex; + Grid_t Ey; + Grid_t Ez; + Grid_t Bxnew; + Grid_t Bynew; + Grid_t Bznew; + VecField B; + VecField E; + VecField Bnew; Faraday> faraday; public: @@ -260,21 +246,26 @@ class Faraday2DTest : public ::testing::Test class Faraday3DTest : public ::testing::Test { protected: - using GridLayoutImpl = GridLayoutImplYee<3, 1>; + static constexpr auto dim = 3; + static constexpr auto interp_order = 1; + + using Grid_t = Grid, HybridQuantity::Scalar>; + using GridLayoutImpl = GridLayoutImplYee; + GridLayout layout; - static constexpr auto interp_order = GridLayoutImpl::interp_order; - Field, HybridQuantity::Scalar> Bx; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Bz; - Field, HybridQuantity::Scalar> Ex; - Field, HybridQuantity::Scalar> Ey; - Field, HybridQuantity::Scalar> Ez; - Field, HybridQuantity::Scalar> Bxnew; - Field, HybridQuantity::Scalar> Bynew; - Field, HybridQuantity::Scalar> Bznew; - VecField, HybridQuantity> B; - VecField, HybridQuantity> E; - VecField, HybridQuantity> Bnew; + + Grid_t Bx; + Grid_t By; + Grid_t Bz; + Grid_t Ex; + Grid_t Ey; + Grid_t Ez; + Grid_t Bxnew; + Grid_t Bynew; + Grid_t Bznew; + VecField B; + VecField E; + VecField Bnew; Faraday> faraday; public: diff --git a/tests/core/numerics/interpolator/test_main.cpp b/tests/core/numerics/interpolator/test_main.cpp index dc0f01635..8d4e3b0b6 100644 --- a/tests/core/numerics/interpolator/test_main.cpp +++ b/tests/core/numerics/interpolator/test_main.cpp @@ -226,8 +226,10 @@ class A1DInterpolator : public ::testing::Test using PHARE_TYPES = PHARE::core::PHARE_Types; using GridLayout_t = typename PHARE_TYPES::GridLayout_t; using NdArray_t = typename PHARE_TYPES::Array_t; + using ArrayView_t = typename PHARE_TYPES::ArrayView_t; using ParticleArray_t = typename PHARE_TYPES::ParticleArray_t; - using VF = VecField; + using Grid_t = Grid; + using VF = VecField; Electromag em; GridLayout_t layout{{0.1}, {nx}, {0.}}; @@ -236,12 +238,12 @@ class A1DInterpolator : public ::testing::Test constexpr static auto safeLayer = static_cast(1 + ghostWidthForParticles()); - Field bx1d_; - Field by1d_; - Field bz1d_; - Field ex1d_; - Field ey1d_; - Field ez1d_; + Grid_t bx1d_; + Grid_t by1d_; + Grid_t bz1d_; + Grid_t ex1d_; + Grid_t ey1d_; + Grid_t ez1d_; static constexpr double ex0 = 2.25; static constexpr double ey0 = 2.50; @@ -334,8 +336,10 @@ class A2DInterpolator : public ::testing::Test using PHARE_TYPES = PHARE::core::PHARE_Types; using GridLayoutImpl = GridLayoutImplYee; using NdArray_t = typename PHARE_TYPES::Array_t; + using ArrayView_t = typename PHARE_TYPES::ArrayView_t; using ParticleArray_t = typename PHARE_TYPES::ParticleArray_t; - using VF = VecField; + using Grid_t = typename PHARE_TYPES::Grid_t; + using VF = typename PHARE_TYPES::VecField_t; Electromag em; GridLayout layout{{0.1, 0.1}, {nx, ny}, {0., 0.}}; @@ -343,12 +347,12 @@ class A2DInterpolator : public ::testing::Test InterpolatorT interp; constexpr static auto safeLayer = static_cast(1 + ghostWidthForParticles()); - Field bx_; - Field by_; - Field bz_; - Field ex_; - Field ey_; - Field ez_; + Grid_t bx_; + Grid_t by_; + Grid_t bz_; + Grid_t ex_; + Grid_t ey_; + Grid_t ez_; static constexpr double ex0 = 2.25; static constexpr double ey0 = 2.50; @@ -445,8 +449,10 @@ class A3DInterpolator : public ::testing::Test using PHARE_TYPES = PHARE::core::PHARE_Types; using GridLayoutImpl = GridLayoutImplYee; using NdArray_t = typename PHARE_TYPES::Array_t; + using ArrayView_t = typename PHARE_TYPES::ArrayView_t; using ParticleArray_t = typename PHARE_TYPES::ParticleArray_t; - using VF = VecField; + using Grid_t = Grid, HybridQuantity::Scalar>; + using VF = VecField; GridLayout layout{{0.1, 0.1, 0.1}, {nx, ny, nz}, {0., 0., 0.}}; constexpr static auto safeLayer = static_cast(1 + ghostWidthForParticles()); @@ -454,12 +460,12 @@ class A3DInterpolator : public ::testing::Test ParticleArray_t particles; InterpolatorT interp; - Field bx_; - Field by_; - Field bz_; - Field ex_; - Field ey_; - Field ez_; + Grid_t bx_; + Grid_t by_; + Grid_t bz_; + Grid_t ex_; + Grid_t ey_; + Grid_t ez_; static constexpr double ex0 = 2.25; static constexpr double ey0 = 2.50; @@ -561,6 +567,8 @@ class ACollectionOfParticles_1d : public ::testing::Test using PHARE_TYPES = PHARE::core::PHARE_Types; using NdArray_t = typename PHARE_TYPES::Array_t; + using ArrayView_t = typename PHARE_TYPES::ArrayView_t; + using Grid_t = typename PHARE_TYPES::Grid_t; using ParticleArray_t = typename PHARE_TYPES::ParticleArray_t; using GridLayout_t = typename PHARE_TYPES::GridLayout_t; using Particle_t = typename ParticleArray_t::Particle_t; @@ -576,11 +584,11 @@ class ACollectionOfParticles_1d : public ::testing::Test Particle_t part; ParticleArray_t particles; - Field rho; - Field vx; - Field vy; - Field vz; - VecField v; + Grid_t rho; + Grid_t vx; + Grid_t vy; + Grid_t vz; + VecField v; std::array weights; @@ -736,12 +744,14 @@ struct ACollectionOfParticles_2d : public ::testing::Test static constexpr std::size_t dim = 2; static constexpr std::uint32_t nx = 15, ny = 15; static constexpr int start = 0, end = 5; + static constexpr auto safeLayer = static_cast(1 + ghostWidthForParticles()); - using PHARE_TYPES = PHARE::core::PHARE_Types; - using NdArray_t = typename PHARE_TYPES::Array_t; - using ParticleArray_t = typename PHARE_TYPES::ParticleArray_t; - using GridLayout_t = typename PHARE_TYPES::GridLayout_t; - constexpr static auto safeLayer = static_cast(1 + ghostWidthForParticles()); + using PHARE_TYPES = PHARE::core::PHARE_Types; + using NdArray_t = typename PHARE_TYPES::Array_t; + using ArrayView_t = typename PHARE_TYPES::ArrayView_t; + using ParticleArray_t = typename PHARE_TYPES::ParticleArray_t; + using GridLayout_t = typename PHARE_TYPES::GridLayout_t; + using Grid_t = typename PHARE_TYPES::Grid_t; ACollectionOfParticles_2d() : particles{grow(layout.AMRBox(), safeLayer)} @@ -772,8 +782,8 @@ struct ACollectionOfParticles_2d : public ::testing::Test GridLayout_t layout{ConstArray(.1), {nx, ny}, ConstArray(0)}; ParticleArray_t particles; - Field rho, vx, vy, vz; - VecField v; + Grid_t rho, vx, vy, vz; + VecField v; Interpolator interpolator; }; TYPED_TEST_SUITE_P(ACollectionOfParticles_2d); diff --git a/tests/core/numerics/ion_updater/test_updater.cpp b/tests/core/numerics/ion_updater/test_updater.cpp index dfa910aa5..357641e5a 100644 --- a/tests/core/numerics/ion_updater/test_updater.cpp +++ b/tests/core/numerics/ion_updater/test_updater.cpp @@ -166,7 +166,7 @@ template struct ElectromagBuffers { using PHARETypes = PHARE::core::PHARE_Types; - using Field = typename PHARETypes::Field_t; + using Field = typename PHARETypes::Grid_t; using GridLayout = typename PHARETypes::GridLayout_t; using Electromag = typename PHARETypes::Electromag_t; @@ -220,7 +220,7 @@ template struct IonsBuffers { using PHARETypes = PHARE::core::PHARE_Types; - using Field = typename PHARETypes::Field_t; + using Field = typename PHARETypes::Grid_t; using GridLayout = typename PHARETypes::GridLayout_t; using Ions = typename PHARETypes::Ions_t; using ParticleArray = typename PHARETypes::ParticleArray_t; @@ -424,7 +424,7 @@ struct IonUpdaterTest : public ::testing::Test // data for electromagnetic fields - using Field = typename PHARETypes::Field_t; + using Field = typename PHARETypes::Grid_t; using VecField = typename PHARETypes::VecField_t; ElectromagBuffers emBuffers; diff --git a/tests/core/numerics/ohm/test_main.cpp b/tests/core/numerics/ohm/test_main.cpp index e54c2e5b8..8b423d8bd 100644 --- a/tests/core/numerics/ohm/test_main.cpp +++ b/tests/core/numerics/ohm/test_main.cpp @@ -66,26 +66,27 @@ struct OhmTest : public ::testing::Test static constexpr auto interp = typename TypeInfo::second_type{}(); using GridYee = GridLayout>; + using Grid_t = Grid, HybridQuantity::Scalar>; GridYee layout = NDlayout::create(); - Field, HybridQuantity::Scalar> n; - Field, HybridQuantity::Scalar> Vx; - Field, HybridQuantity::Scalar> Vy; - Field, HybridQuantity::Scalar> Vz; - Field, HybridQuantity::Scalar> P; - Field, HybridQuantity::Scalar> Bx; - Field, HybridQuantity::Scalar> By; - Field, HybridQuantity::Scalar> Bz; - Field, HybridQuantity::Scalar> Jx; - Field, HybridQuantity::Scalar> Jy; - Field, HybridQuantity::Scalar> Jz; - Field, HybridQuantity::Scalar> Exnew; - Field, HybridQuantity::Scalar> Eynew; - Field, HybridQuantity::Scalar> Eznew; - VecField, HybridQuantity> V; - VecField, HybridQuantity> B; - VecField, HybridQuantity> J; - VecField, HybridQuantity> Enew; + Grid_t n; + Grid_t Vx; + Grid_t Vy; + Grid_t Vz; + Grid_t P; + Grid_t Bx; + Grid_t By; + Grid_t Bz; + Grid_t Jx; + Grid_t Jy; + Grid_t Jz; + Grid_t Exnew; + Grid_t Eynew; + Grid_t Eznew; + VecField V; + VecField B; + VecField J; + VecField Enew; Ohm ohm; OhmTest() diff --git a/tests/functional/harris/harris_2d_2.py b/tests/functional/harris/harris_2d_2.py new file mode 100644 index 000000000..1ea75c5dd --- /dev/null +++ b/tests/functional/harris/harris_2d_2.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 + +import pyphare.pharein as ph +from pyphare.simulator.simulator import Simulator, startMPI + +import numpy as np + +# import matplotlib.pyplot as plt +import matplotlib as mpl + +mpl.use("Agg") + +from pyphare.cpp import cpp_lib +cpp = cpp_lib() +# startMPI() + +diag_outputs = "phare_outputs/test/harris/2d" +# from datetime import datetime + + +def config(): + L = 0.5 + sim = ph.Simulation( + time_step=0.005, + final_time=30.0, + # boundary_types="periodic", + cells=(800, 400), + dl=(0.40, 0.40), + refinement="tagging", + max_nbr_levels=3, + nesting_buffer=1, + clustering="tile", + tag_buffer="10", + hyper_resistivity=0.002, + resistivity=0.001, + diag_options={ + "format": "phareh5", + "options": {"dir": ".", "mode": "overwrite"}, + }, + strict=True, + ) + + def density(x, y): + Ly = sim.simulation_domain()[1] + return ( + 0.4 + + 1.0 / np.cosh((y - Ly * 0.3) / L) ** 2 + + 1.0 / np.cosh((y - Ly * 0.7) / L) ** 2 + ) + + def S(y, y0, l): + return 0.5 * (1.0 + np.tanh((y - y0) / l)) + + def by(x, y): + Lx = sim.simulation_domain()[0] + Ly = sim.simulation_domain()[1] + sigma = 1.0 + dB = 0.1 + + x0 = x - 0.5 * Lx + y1 = y - 0.3 * Ly + y2 = y - 0.7 * Ly + + dBy1 = 2 * dB * x0 * np.exp(-(x0**2 + y1**2) / (sigma) ** 2) + dBy2 = -2 * dB * x0 * np.exp(-(x0**2 + y2**2) / (sigma) ** 2) + + return dBy1 + dBy2 + + def bx(x, y): + Lx = sim.simulation_domain()[0] + Ly = sim.simulation_domain()[1] + sigma = 1.0 + dB = 0.1 + + x0 = x - 0.5 * Lx + y1 = y - 0.3 * Ly + y2 = y - 0.7 * Ly + + dBx1 = -2 * dB * y1 * np.exp(-(x0**2 + y1**2) / (sigma) ** 2) + dBx2 = 2 * dB * y2 * np.exp(-(x0**2 + y2**2) / (sigma) ** 2) + + v1 = -1 + v2 = 1.0 + return v1 + (v2 - v1) * (S(y, Ly * 0.3, L) - S(y, Ly * 0.7, L)) + dBx1 + dBx2 + + def bz(x, y): + return 0.0 + + def b2(x, y): + return bx(x, y) ** 2 + by(x, y) ** 2 + bz(x, y) ** 2 + + def T(x, y): + K = 0.7 + temp = 1.0 / density(x, y) * (K - b2(x, y) * 0.5) + assert np.all(temp > 0) + return temp + + def vx(x, y): + return 0.0 + + def vy(x, y): + return 0.0 + + def vz(x, y): + return 0.0 + + def vthx(x, y): + return np.sqrt(T(x, y)) + + def vthy(x, y): + return np.sqrt(T(x, y)) + + def vthz(x, y): + return np.sqrt(T(x, y)) + + vvv = { + "vbulkx": vx, + "vbulky": vy, + "vbulkz": vz, + "vthx": vthx, + "vthy": vthy, + "vthz": vthz, + "nbr_part_per_cell": 100, + } + + ph.MaxwellianFluidModel( + bx=bx, + by=by, + bz=bz, + protons={ + "charge": 1, + "density": density, + **vvv, + }, # , "init":{"seed":cpp.mpi_rank()+int(sys.argv[1])}} + ) + + ph.ElectronModel(closure="isothermal", Te=0.0) + + dt = 10 * sim.time_step + nt = sim.final_time / dt + 1 + timestamps = dt * np.arange(nt) + + for quantity in ["E", "B"]: + ph.ElectromagDiagnostics( + quantity=quantity, + write_timestamps=timestamps, + compute_timestamps=timestamps, + ) + + return sim + + +def get_time(path, time, datahier=None): + time = "{:.10f}".format(time) + from pyphare.pharesee.hierarchy import hierarchy_from + + datahier = hierarchy_from(h5_filename=path + "/EM_E.h5", time=time, hier=datahier) + datahier = hierarchy_from(h5_filename=path + "/EM_B.h5", time=time, hier=datahier) + return datahier + + +def post_advance(new_time): + if cpp.mpi_rank() == 0: + print(f"running tests at time {new_time}") + from tests.simulator.test_advance import AdvanceTestBase + + test = AdvanceTestBase() + test.base_test_overlaped_fields_are_equal( + get_time(diag_outputs, new_time), new_time + ) + print(f"tests passed") + + +def main(): + sim = config() + s = Simulator(sim) # , post_advance=post_advance) + s.initialize() + post_advance(0) + s.run() + + +if __name__ == "__main__": + main() From e14b58007b958180fd2956d8781c4b0072c96f17 Mon Sep 17 00:00:00 2001 From: dekken Date: Mon, 4 Dec 2023 14:21:36 +0100 Subject: [PATCH 2/4] more --- src/amr/multiphysics_integrator.hpp | 4 +- .../resources_manager/resources_manager.hpp | 2 +- src/amr/solvers/solver.hpp | 5 +- src/amr/solvers/solver_mhd.hpp | 5 +- src/amr/solvers/solver_ppc.hpp | 205 +++++++++--------- src/amr/solvers/solver_ppc_model_view.hpp | 68 +++++- .../ions/ion_population/ion_population.hpp | 12 +- 7 files changed, 180 insertions(+), 121 deletions(-) diff --git a/src/amr/multiphysics_integrator.hpp b/src/amr/multiphysics_integrator.hpp index b9c982d48..25d126e1c 100644 --- a/src/amr/multiphysics_integrator.hpp +++ b/src/amr/multiphysics_integrator.hpp @@ -495,8 +495,8 @@ namespace solver fromCoarser.prepareStep(model, *level, currentTime); - solver.advanceLevel(*hierarchy, iLevel, model, fromCoarser, currentTime, newTime, - getModelView_(iLevel)); + solver.advanceLevel(*hierarchy, iLevel, getModelView_(iLevel), fromCoarser, currentTime, + newTime); if (lastStep) { diff --git a/src/amr/resources_manager/resources_manager.hpp b/src/amr/resources_manager/resources_manager.hpp index a3f8bb1ed..b523ec92a 100644 --- a/src/amr/resources_manager/resources_manager.hpp +++ b/src/amr/resources_manager/resources_manager.hpp @@ -322,7 +322,7 @@ namespace amr template NO_DISCARD auto restart_patch_data_ids(ResourcesUser const& user) const { - // // true for now with https://github.com/PHAREHUB/PHARE/issues/664 + // true for now with https://github.com/PHAREHUB/PHARE/issues/664 constexpr bool ALL_IDS = true; std::vector ids; diff --git a/src/amr/solvers/solver.hpp b/src/amr/solvers/solver.hpp index c8f52a35d..f478f774a 100644 --- a/src/amr/solvers/solver.hpp +++ b/src/amr/solvers/solver.hpp @@ -87,10 +87,9 @@ namespace solver * @brief advanceLevel advances the given level from t to t+dt */ virtual void advanceLevel(hierarchy_t const& hierarchy, int const levelNumber, - IPhysicalModel& model, + ISolverModelView& view, amr::IMessenger>& fromCoarser, - const double currentTime, const double newTime, - ISolverModelView& view) + const double currentTime, const double newTime) = 0; diff --git a/src/amr/solvers/solver_mhd.hpp b/src/amr/solvers/solver_mhd.hpp index 492c4d821..f08c0ce7e 100644 --- a/src/amr/solvers/solver_mhd.hpp +++ b/src/amr/solvers/solver_mhd.hpp @@ -44,10 +44,9 @@ namespace solver } virtual void advanceLevel(hierarchy_t const& /*hierarchy*/, int const /*levelNumber*/, - IPhysicalModel& /*model*/, + ISolverModelView& /*view*/, amr::IMessenger>& /*fromCoarser*/, - const double /*currentTime*/, const double /*newTime*/, - ISolverModelView& /*view*/) override + const double /*currentTime*/, const double /*newTime*/) override { } diff --git a/src/amr/solvers/solver_ppc.hpp b/src/amr/solvers/solver_ppc.hpp index 7b3503628..46be04f6c 100644 --- a/src/amr/solvers/solver_ppc.hpp +++ b/src/amr/solvers/solver_ppc.hpp @@ -47,11 +47,13 @@ class SolverPPC : public ISolver using HybridMessenger = amr::HybridMessenger; using HybridModelView_t = HybridPPCModelView; + using Faraday_t = typename HybridModelView_t::Faraday_t; Electromag electromagPred_{"EMPred"}; Electromag electromagAvg_{"EMAvg"}; + Faraday_t faraday_1; PHARE::core::Faraday faraday_; PHARE::core::Ampere ampere_; PHARE::core::Ohm ohm_; @@ -90,9 +92,9 @@ class SolverPPC : public ISolver - void advanceLevel(hierarchy_t const& hierarchy, int const levelNumber, IPhysicalModel_t& model, + void advanceLevel(hierarchy_t const& hierarchy, int const levelNumber, ISolverModelView& view, IMessenger& fromCoarserMessenger, double const currentTime, - double const newTime, ISolverModelView& view) override; + double const newTime) override; std::shared_ptr make_view(level_t& level, IPhysicalModel_t& model) override { @@ -103,30 +105,29 @@ class SolverPPC : public ISolver using Messenger = amr::HybridMessenger; - void predictor1_(level_t& level, HybridModel& model, Messenger& fromCoarser, - double const currentTime, double const newTime, HybridModelView_t& view); + void predictor1_(level_t& level, HybridModelView_t& view, Messenger& fromCoarser, + double const currentTime, double const newTime); - void predictor2_(level_t& level, HybridModel& model, Messenger& fromCoarser, - double const currentTime, double const newTime, HybridModelView_t& view); + void predictor2_(level_t& level, HybridModelView_t& view, Messenger& fromCoarser, + double const currentTime, double const newTime); - void corrector_(level_t& level, HybridModel& model, Messenger& fromCoarser, - double const currentTime, double const newTime, HybridModelView_t& view); + void corrector_(level_t& level, HybridModelView_t& view, Messenger& fromCoarser, + double const currentTime, double const newTime); - void average_(level_t& level, HybridModel& model, Messenger& fromCoarser, double const newTime, - HybridModelView_t& view); + void average_(level_t& level, HybridModelView_t& view, Messenger& fromCoarser, + double const newTime); - void moveIons_(level_t& level, Ions& ions, Electromag& electromag, ResourcesManager& rm, - Messenger& fromCoarser, double const currentTime, double const newTime, - core::UpdaterMode mode, HybridModelView_t& view); + void moveIons_(level_t& level, HybridModelView_t& view, Messenger& fromCoarser, + double const currentTime, double const newTime, core::UpdaterMode mode); - void saveState_(level_t& level, Ions& ions, ResourcesManager& rm); + void saveState_(level_t& level, HybridModelView_t& view); - void restoreState_(level_t& level, Ions& ions, ResourcesManager& rm); + void restoreState_(level_t& level, HybridModelView_t& view); // extend lifespan @@ -179,15 +180,13 @@ void SolverPPC::fillMessengerInfo( template -void SolverPPC::saveState_(level_t& level, Ions& ions, ResourcesManager& rm) +void SolverPPC::saveState_(level_t& level, HybridModelView_t& view) { - for (auto& patch : level) + for (auto& state : view) { std::stringstream ss; - ss << patch->getGlobalId(); - - auto _ = rm.setOnPatch(*patch, ions); - for (auto& pop : ions) + ss << state.patch->getGlobalId(); + for (auto& pop : state.ions) { auto key = ss.str() + "_" + pop.name(); if (!tmpDomain.count(key)) @@ -203,16 +202,14 @@ void SolverPPC::saveState_(level_t& level, Ions& ions, R } template -void SolverPPC::restoreState_(level_t& level, Ions& ions, - ResourcesManager& rm) +void SolverPPC::restoreState_(level_t& level, HybridModelView_t& view) { - for (auto& patch : level) + for (auto& state : view) { std::stringstream ss; - ss << patch->getGlobalId(); + ss << state.patch->getGlobalId(); - auto _ = rm.setOnPatch(*patch, ions); - for (auto& pop : ions) + for (auto& pop : state.ions) { pop.domainParticles() = std::move(tmpDomain.at(ss.str() + "_" + pop.name())); pop.patchGhostParticles() = std::move(patchGhost.at(ss.str() + "_" + pop.name())); @@ -223,61 +220,60 @@ void SolverPPC::restoreState_(level_t& level, Ions& ions template void SolverPPC::advanceLevel(hierarchy_t const& hierarchy, - int const levelNumber, IPhysicalModel_t& model, + int const levelNumber, ISolverModelView& view, IMessenger& fromCoarserMessenger, - double const currentTime, double const newTime, - ISolverModelView& view) + double const currentTime, double const newTime) { PHARE_LOG_SCOPE("SolverPPC::advanceLevel"); - auto& hybridModel = dynamic_cast(model); - auto& modelView = dynamic_cast(view); - auto& hybridState = hybridModel.state; - auto& fromCoarser = dynamic_cast(fromCoarserMessenger); - auto& resourcesManager = *hybridModel.resourcesManager; - auto level = hierarchy.getPatchLevel(levelNumber); + auto& modelView = dynamic_cast(view); + auto& fromCoarser = dynamic_cast(fromCoarserMessenger); + auto level = hierarchy.getPatchLevel(levelNumber); + predictor1_(*level, modelView, fromCoarser, currentTime, newTime); - predictor1_(*level, hybridModel, fromCoarser, currentTime, newTime, modelView); + average_(*level, modelView, fromCoarser, newTime); - average_(*level, hybridModel, fromCoarser, newTime, modelView); + saveState_(*level, modelView); - saveState_(*level, hybridState.ions, resourcesManager); + moveIons_(*level, modelView, fromCoarser, currentTime, newTime, core::UpdaterMode::domain_only); - moveIons_(*level, hybridState.ions, electromagAvg_, resourcesManager, fromCoarser, currentTime, - newTime, core::UpdaterMode::domain_only, modelView); + predictor2_(*level, modelView, fromCoarser, currentTime, newTime); - predictor2_(*level, hybridModel, fromCoarser, currentTime, newTime, modelView); + average_(*level, modelView, fromCoarser, newTime); - average_(*level, hybridModel, fromCoarser, newTime, modelView); + restoreState_(*level, modelView); - restoreState_(*level, hybridState.ions, resourcesManager); + moveIons_(*level, modelView, fromCoarser, currentTime, newTime, core::UpdaterMode::all); - moveIons_(*level, hybridState.ions, electromagAvg_, resourcesManager, fromCoarser, currentTime, - newTime, core::UpdaterMode::all, modelView); - - corrector_(*level, hybridModel, fromCoarser, currentTime, newTime, modelView); + corrector_(*level, modelView, fromCoarser, currentTime, newTime); } template -void SolverPPC::predictor1_(level_t& level, HybridModel& model, +void SolverPPC::predictor1_(level_t& level, HybridModelView_t& view, Messenger& fromCoarser, - double const currentTime, double const newTime, - HybridModelView_t& view) + double const currentTime, double const newTime) { PHARE_LOG_SCOPE("SolverPPC::predictor1_"); - auto& resourcesManager = model.resourcesManager; auto dt = newTime - currentTime; + auto& resourcesManager = view.model().resourcesManager; { PHARE_LOG_SCOPE("SolverPPC::predictor1_.faraday"); - faraday_( - view, [](auto& state) { return state.ppc_predictor1_faraday(); }, dt); + + faraday_1( + view, + [](auto& state) { + return std::forward_as_tuple( // + state.layout, state.electromag.B, state.electromag.E, state.electromagPred.B); + }, + newTime); + for (auto& state : view) resourcesManager->setTime(state.electromagPred.B, *state.patch, newTime); } @@ -287,7 +283,7 @@ void SolverPPC::predictor1_(level_t& level, HybridModel& ampere_.op(view, [](auto& state) { return state.ppc_predictor1_ampere(); }); for (auto& state : view) resourcesManager->setTime(state.J, *state.patch, newTime); - fromCoarser.fillCurrentGhosts(model.state.J, level.getLevelNumber(), newTime); + fromCoarser.fillCurrentGhosts(view.model().state.J, level.getLevelNumber(), newTime); } { @@ -302,15 +298,14 @@ void SolverPPC::predictor1_(level_t& level, HybridModel& template -void SolverPPC::predictor2_(level_t& level, HybridModel& model, +void SolverPPC::predictor2_(level_t& level, HybridModelView_t& view, Messenger& fromCoarser, - double const currentTime, double const newTime, - HybridModelView_t& view) + double const currentTime, double const newTime) { PHARE_LOG_SCOPE("SolverPPC::predictor2_"); - auto& resourcesManager = model.resourcesManager; auto dt = newTime - currentTime; + auto& resourcesManager = view.model().resourcesManager; { PHARE_LOG_SCOPE("SolverPPC::predictor2_.faraday"); @@ -325,7 +320,7 @@ void SolverPPC::predictor2_(level_t& level, HybridModel& ampere_.op(view, [](auto& state) { return state.ppc_predictor2_ampere(); }); for (auto& state : view) resourcesManager->setTime(state.J, *state.patch, newTime); - fromCoarser.fillCurrentGhosts(model.state.J, level.getLevelNumber(), newTime); + fromCoarser.fillCurrentGhosts(view.model().state.J, level.getLevelNumber(), newTime); } { @@ -342,15 +337,15 @@ void SolverPPC::predictor2_(level_t& level, HybridModel& template -void SolverPPC::corrector_(level_t& level, HybridModel& model, +void SolverPPC::corrector_(level_t& level, HybridModelView_t& view, Messenger& fromCoarser, double const currentTime, - double const newTime, HybridModelView_t& view) + double const newTime) { PHARE_LOG_SCOPE("SolverPPC::corrector_"); - auto& resourcesManager = model.resourcesManager; auto dt = newTime - currentTime; auto levelNumber = level.getLevelNumber(); + auto& resourcesManager = view.model().resourcesManager; { PHARE_LOG_SCOPE("SolverPPC::corrector_.faraday"); @@ -365,7 +360,7 @@ void SolverPPC::corrector_(level_t& level, HybridModel& ampere_.op(view, [](auto& state) { return state.ppc_corrector_ampere(); }); for (auto& state : view) resourcesManager->setTime(state.J, *state.patch, newTime); - fromCoarser.fillCurrentGhosts(model.state.J, level.getLevelNumber(), newTime); + fromCoarser.fillCurrentGhosts(view.model().state.J, levelNumber, newTime); } { @@ -376,16 +371,15 @@ void SolverPPC::corrector_(level_t& level, HybridModel& for (auto& state : view) resourcesManager->setTime(state.electromag.E, *state.patch, newTime); - fromCoarser.fillElectricGhosts(model.state.electromag.E, levelNumber, newTime); + fromCoarser.fillElectricGhosts(view.model().state.electromag.E, levelNumber, newTime); } } template -void SolverPPC::average_(level_t& level, HybridModel& model, - Messenger& fromCoarser, double const newTime, - HybridModelView_t& view) +void SolverPPC::average_(level_t& level, HybridModelView_t& view, + Messenger& fromCoarser, double const newTime) { PHARE_LOG_SCOPE("SolverPPC::average_"); @@ -403,54 +397,59 @@ void SolverPPC::average_(level_t& level, HybridModel& mo } +template +void _debug_log_move_ions(Args const&... args) +{ + auto const& [view] = std::forward_as_tuple(args...); + + std::size_t nbrDomainParticles = 0; + std::size_t nbrPatchGhostParticles = 0; + std::size_t nbrLevelGhostNewParticles = 0; + std::size_t nbrLevelGhostOldParticles = 0; + std::size_t nbrLevelGhostParticles = 0; // + for (auto& state : view) + { + for (auto& pop : state.ions) + { + nbrDomainParticles += pop.domainParticles().size(); + nbrPatchGhostParticles += pop.patchGhostParticles().size(); + nbrLevelGhostNewParticles += pop.levelGhostParticlesNew().size(); + nbrLevelGhostOldParticles += pop.levelGhostParticlesOld().size(); + nbrLevelGhostParticles += pop.levelGhostParticles().size(); + nbrPatchGhostParticles += pop.patchGhostParticles().size(); + + if (nbrLevelGhostOldParticles < nbrLevelGhostParticles + and nbrLevelGhostOldParticles > 0) + throw std::runtime_error("Error - there are less old level ghost particles (" + + std::to_string(nbrLevelGhostOldParticles) + + ") than pushable (" + + std::to_string(nbrLevelGhostParticles) + ")"); + } + } +} + template -void SolverPPC::moveIons_(level_t& level, Ions& ions, - Electromag& electromag, ResourcesManager& rm, +void SolverPPC::moveIons_(level_t& level, HybridModelView_t& view, Messenger& fromCoarser, double const currentTime, - double const newTime, core::UpdaterMode mode, - HybridModelView_t& view) + double const newTime, core::UpdaterMode mode) { PHARE_LOG_SCOPE("SolverPPC::moveIons_"); - PHARE_DEBUG_DO(std::size_t nbrDomainParticles = 0; std::size_t nbrPatchGhostParticles = 0; - std::size_t nbrLevelGhostNewParticles = 0; - std::size_t nbrLevelGhostOldParticles = 0; - std::size_t nbrLevelGhostParticles = 0; for (auto& patch - : level) { - auto _ = rm.setOnPatch(*patch, ions); - - for (auto& pop : ions) - { - nbrDomainParticles += pop.domainParticles().size(); - nbrPatchGhostParticles += pop.patchGhostParticles().size(); - nbrLevelGhostNewParticles += pop.levelGhostParticlesNew().size(); - nbrLevelGhostOldParticles += pop.levelGhostParticlesOld().size(); - nbrLevelGhostParticles += pop.levelGhostParticles().size(); - nbrPatchGhostParticles += pop.patchGhostParticles().size(); - - if (nbrLevelGhostOldParticles < nbrLevelGhostParticles - and nbrLevelGhostOldParticles > 0) - throw std::runtime_error( - "Error - there are less old level ghost particles (" - + std::to_string(nbrLevelGhostOldParticles) + ") than pushable (" - + std::to_string(nbrLevelGhostParticles) + ")"); - } - }) - + PHARE_DEBUG_DO(_debug_log_move_ions(view);) auto dt = newTime - currentTime; for (auto& state : view) { - auto const& [layout, ionz, em] = state.ppc_update_populations(); - ionUpdater_.updatePopulations(ionz, em, layout, dt, mode); + auto const& [layout, ions, em] = state.ppc_update_populations(); + ionUpdater_.updatePopulations(ions, em, layout, dt, mode); // this needs to be done before calling the messenger - rm.setTime(ionz, *state.patch, newTime); + view.model().resourcesManager->setTime(ions, *state.patch, newTime); } - fromCoarser.fillIonGhostParticles(ions, level, newTime); - fromCoarser.fillIonPopMomentGhosts(ions, level, newTime); + fromCoarser.fillIonGhostParticles(view.model().state.ions, level, newTime); + fromCoarser.fillIonPopMomentGhosts(view.model().state.ions, level, newTime); for (auto& state : view) { @@ -460,7 +459,7 @@ void SolverPPC::moveIons_(level_t& level, Ions& ions, // now Ni and Vi are calculated we can fill pure ghost nodes // these were not completed by the deposition of patch and levelghost particles - fromCoarser.fillIonMomentGhosts(ions, level, newTime); + fromCoarser.fillIonMomentGhosts(view.model().state.ions, level, newTime); } diff --git a/src/amr/solvers/solver_ppc_model_view.hpp b/src/amr/solvers/solver_ppc_model_view.hpp index e43972feb..da57d8e12 100644 --- a/src/amr/solvers/solver_ppc_model_view.hpp +++ b/src/amr/solvers/solver_ppc_model_view.hpp @@ -1,11 +1,52 @@ #ifndef PHARE_SOLVER_SOLVER_PPC_MODEL_VIEW_HPP #define PHARE_SOLVER_SOLVER_PPC_MODEL_VIEW_HPP +#include "core/numerics/ampere/ampere.hpp" +#include "core/numerics/faraday/faraday.hpp" +#include "core/numerics/ohm/ohm.hpp" + #include "amr/solvers/solver.hpp" namespace PHARE::solver { +template +class FaradayTransformer +{ + using core_type = PHARE::core::Faraday; + +public: + template + void operator()(ViewStates& states, Accessor fn, double dt) + { + // not thread safe, would probably need to copy (*this) per thread + for (auto& state : states) + { + auto const& [layout, B, E, Bnew] = fn(state); + auto _ = core::SetLayout(&layout, faraday_); + faraday_(B, E, Bnew, dt); + } + } + + core_type faraday_; +}; + +template +class AmpereTransformer +{ + using core_type = PHARE::core::Ampere; + +public: +}; + +template +class OhmTransformer +{ + using core_type = PHARE::core::Ohm; + +public: +}; + template struct HybridPPCModelView : public ISolverModelView { @@ -23,6 +64,9 @@ struct HybridPPCModelView : public ISolverModelView using Particle_t = typename ParticleArray_t::value_type; using VecFieldT = typename HybridModel_t::vecfield_type; using GridLayout = typename HybridModel_t::gridlayout_type; + using Faraday_t = FaradayTransformer; + using Ampere_t = AmpereTransformer; + using Ohm_t = OhmTransformer; struct PatchState_t; @@ -31,21 +75,24 @@ struct HybridPPCModelView : public ISolverModelView template struct iterator; - HybridPPCModelView(level_t& level, IPhysicalModel_t& model) { regrid(level, model); } - - void regrid(level_t& level, HybridModel_t& hybridModel); - - void regrid(level_t& level, IPhysicalModel_t& model) + HybridPPCModelView(level_t& level, IPhysicalModel_t& model) + : model_{dynamic_cast(model)} { - regrid(level, dynamic_cast(model)); + regrid(level, model_); } + void regrid(level_t& level, HybridModel_t& hybridModel); + auto begin() { return iterator{*this}; } auto begin() const { return iterator{*this}; } auto end() { return iterator{*this, states.size()}; } auto end() const { return iterator{*this, states.size()}; } + auto& model() { return model_; } + auto& model() const { return model_; } + + HybridModel_t& model_; std::vector> states; Electromag electromagPred_{"EMPred"}; @@ -85,7 +132,10 @@ template template struct HybridPPCModelView::iterator { - iterator(HybridPPCModelView& view_, std::size_t const& i = 0) + using View = std::conditional_t, + HybridPPCModelView const>; + + iterator(View& view_, std::size_t const& i = 0) : view{view_} , idx{i} { @@ -110,7 +160,7 @@ struct HybridPPCModelView::iterator bool operator!=(iterator const& that) const { return &view != &that.view or idx != that.idx; } - HybridPPCModelView& view; + View& view; std::size_t idx = 0; }; @@ -204,6 +254,8 @@ struct HybridPPCModelView::PatchState_t }; + + } // namespace PHARE::solver diff --git a/src/core/data/ions/ion_population/ion_population.hpp b/src/core/data/ions/ion_population/ion_population.hpp index f9dd70484..ecada25d8 100644 --- a/src/core/data/ions/ion_population/ion_population.hpp +++ b/src/core/data/ions/ion_population/ion_population.hpp @@ -151,6 +151,11 @@ namespace core } } + NO_DISCARD ParticleArray const& levelGhostParticlesOld() const + { + return const_cast(this)->levelGhostParticlesOld(); + } + NO_DISCARD ParticleArray& levelGhostParticlesNew() @@ -165,6 +170,11 @@ namespace core } } + NO_DISCARD ParticleArray const& levelGhostParticlesNew() const + { + return const_cast(this)->levelGhostParticlesNew(); + } + NO_DISCARD field_type const& density() const @@ -182,7 +192,7 @@ namespace core NO_DISCARD field_type& density() { - return const_cast(static_cast(this)->density()); + return const_cast(static_cast(this)->density()); } From 471233b717c4691791f6b3174ae28dd59a8bb781 Mon Sep 17 00:00:00 2001 From: dekken Date: Mon, 4 Dec 2023 16:21:17 +0100 Subject: [PATCH 3/4] :eyes: --- src/amr/solvers/solver_ppc.hpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/amr/solvers/solver_ppc.hpp b/src/amr/solvers/solver_ppc.hpp index 46be04f6c..59af9b55e 100644 --- a/src/amr/solvers/solver_ppc.hpp +++ b/src/amr/solvers/solver_ppc.hpp @@ -272,7 +272,7 @@ void SolverPPC::predictor1_(level_t& level, HybridModelV return std::forward_as_tuple( // state.layout, state.electromag.B, state.electromag.E, state.electromagPred.B); }, - newTime); + dt); for (auto& state : view) resourcesManager->setTime(state.electromagPred.B, *state.patch, newTime); From fd5e69a8516489e014dcada2aa3a50a4fb3ee341 Mon Sep 17 00:00:00 2001 From: dekken Date: Mon, 4 Dec 2023 16:53:50 +0100 Subject: [PATCH 4/4] rm local config file --- tests/amr/resources_manager/input_config.h | 15 --------------- 1 file changed, 15 deletions(-) delete mode 100644 tests/amr/resources_manager/input_config.h diff --git a/tests/amr/resources_manager/input_config.h b/tests/amr/resources_manager/input_config.h deleted file mode 100644 index 51998fd06..000000000 --- a/tests/amr/resources_manager/input_config.h +++ /dev/null @@ -1,15 +0,0 @@ -#ifndef TESTS_AMR_TOOLS_RESOURCES_MANAGER_INPUT_CONFIG_HPP -#define TESTS_AMR_TOOLS_RESOURCES_MANAGER_INPUT_CONFIG_HPP - -#include -#include - -namespace PHARE -{ -namespace amr -{ - const std::string inputBase = "/home/p/git/phare/master/tests/amr/resources_manager/"; -} -} // namespace PHARE - -#endif