Rm

src/amr/data/field/field_data.hpp

@@ -46,6 +46,7 @@ namespace amr
         static constexpr std::size_t dimension    = GridLayoutT::dimension;
         static constexpr std::size_t interp_order = GridLayoutT::interp_order;
         using Geometry                            = FieldGeometry<GridLayoutT, PhysicalQuantity>;
+        using view_type                           = Grid_t::field_type;
 
         /*** \brief Construct a FieldData from information associated to a patch
          *

src/amr/data/particles/particles_data.hpp

@@ -112,6 +112,8 @@ namespace amr
         static constexpr int ghostSafeMapLayer = 1;
 
     public:
+        using view_type = typename core::ParticlesPack<ParticleArray>;
+
         ParticlesData(SAMRAI::hier::Box const& box, SAMRAI::hier::IntVector const& ghost,
                       std::string const& name)
             : SAMRAI::hier::PatchData::PatchData(box, ghost)

src/amr/multiphysics_integrator.hpp

@@ -278,25 +278,6 @@ namespace solver
 
         /**
          * @brief see SAMRAI documentation. This function initializes the data on the given level.
-         *
-         * The method first checks wether allocation of patch data must be performed.
-         * If it does, all objects using resources on patches must see their allocate() function
-         * called.
-         *
-         * This is:
-         * - the model (by definition the model has data defined on patches)
-         * - the solver (Some solvers has internal data that needs to exist on patches)
-         * - the messenger (the messenger has data defined on patches for internal reasons)
-         *
-         *
-         * then the level needs to be registered to the messenger.
-         *
-         * Then data initialization per se begins and one can be on one of the following cases:
-         *
-         * - regridding
-         * - initialization of the root level
-         * - initialization of a new level from scratch (not a regridding)
-         *
          */
         void initializeLevelData(std::shared_ptr<SAMRAI::hier::PatchHierarchy> const& hierarchy,
                                  int const levelNumber, double const initDataTime,
@@ -342,7 +323,8 @@ namespace solver
                 // this level is the source or destination
                 // we therefore need to rebuild them
                 auto const finestLvlNbr = hierarchy->getFinestLevelNumber();
-                auto nextFiner = (levelNumber == finestLvlNbr) ? levelNumber : levelNumber + 1;
+                auto const nextFiner
+                    = (levelNumber == finestLvlNbr) ? levelNumber : levelNumber + 1;
 
                 for (auto ilvl = levelNumber; ilvl <= nextFiner; ++ilvl)
                 {
@@ -369,10 +351,13 @@ namespace solver
             else
                 load_balancer_manager_->estimate(*level, model);
 
-            if (static_cast<std::size_t>(levelNumber) == model_views_.size())
-                model_views_.push_back(solver.make_view(*level, model));
-            else
-                model_views_[levelNumber] = solver.make_view(*level, model);
+
+            model.resources_manager().makeLevelViews(*hierarchy, levelNumber);
+
+            // if (static_cast<std::size_t>(levelNumber) == model_views_.size())
+            //     model_views_.push_back(solver.make_view(*level, model));
+            // else
+            //     model_views_[levelNumber] = solver.make_view(*level, model);
         }
 
 

src/amr/physical_models/hybrid_model.hpp

@@ -11,6 +11,7 @@
 #include "amr/messengers/hybrid_messenger_info.hpp"
 #include "core/data/vecfield/vecfield.hpp"
 #include "core/def.hpp"
+#include "core/data/ions/ion_population/particle_pack.hpp"
 
 namespace PHARE::solver
 {
@@ -27,19 +28,20 @@ class HybridModel : public IPhysicalModel<AMR_Types>
 
     using type_list
         = PHARE::core::type_list<GridLayoutT, Electromag, Ions, Electrons, AMR_Types, Grid_t>;
-    using Interface              = IPhysicalModel<AMR_Types>;
-    using amr_types              = AMR_Types;
-    using electrons_t            = Electrons;
-    using patch_t                = typename AMR_Types::patch_t;
-    using level_t                = typename AMR_Types::level_t;
-    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              = Grid_t;
-    using ions_type              = Ions;
-    using particle_array_type    = typename Ions::particle_array_type;
-    using resources_manager_type = amr::ResourcesManager<gridlayout_type, grid_type>;
+    using Interface           = IPhysicalModel<AMR_Types>;
+    using amr_types           = AMR_Types;
+    using electrons_t         = Electrons;
+    using patch_t             = typename AMR_Types::patch_t;
+    using level_t             = typename AMR_Types::level_t;
+    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           = Grid_t;
+    using ions_type           = Ions;
+    using particle_array_type = typename Ions::particle_array_type;
+    using resources_manager_type
+        = amr::ResourcesManager<gridlayout_type, grid_type, particle_array_type>;
     using ParticleInitializerFactory
         = core::ParticleInitializerFactory<particle_array_type, gridlayout_type>;
 
@@ -53,6 +55,11 @@ class HybridModel : public IPhysicalModel<AMR_Types>
     virtual void initialize(level_t& level) override;
 
 
+    virtual amr::IResourcesManager& resources_manager() const override
+    {
+        return *std::dynamic_pointer_cast<amr::IResourcesManager>(resourcesManager);
+    }
+
     /**
      * @brief allocate uses the ResourcesManager to allocate HybridState physical quantities on
      * the given Patch at the given allocateTime

src/amr/physical_models/mhd_model.hpp

@@ -41,6 +41,10 @@ namespace solver
 
         virtual void initialize(level_t& /*level*/) override {}
 
+        virtual amr::IResourcesManager& resources_manager() const override
+        {
+            return *std::dynamic_pointer_cast<amr::IResourcesManager>(resourcesManager);
+        }
 
         virtual void allocate(patch_t& patch, double const allocateTime) override
         {

src/amr/physical_models/physical_model.hpp

@@ -1,13 +1,11 @@
-
-
-
 #ifndef PHARE_PHYSICAL_MODEL_HPP
 #define PHARE_PHYSICAL_MODEL_HPP
 
 #include <memory>
 #include <string>
 
 #include "amr/messengers/messenger_info.hpp"
+#include "amr/resources_manager/resources_manager.hpp"
 
 namespace PHARE
 {
@@ -43,6 +41,9 @@ namespace solver
         virtual void initialize(level_t& level) = 0;
 
 
+        virtual amr::IResourcesManager& resources_manager() const = 0;
+
+
         /**
          * @brief allocate must be implemented by concrete subclasses to allocate the model
          * quantities onto the given patch at the given allocateTime.

src/amr/resources_manager/field_resource.hpp

@@ -12,10 +12,11 @@ namespace amr
      * also says the type of the actual data buffer
      */
     template<typename Grid_t, typename GridLayoutT>
-    struct UserFieldType
+    struct FieldViewInfo
     {
         using patch_data_type = FieldData<GridLayoutT, Grid_t>;
         using variable_type   = FieldVariable<GridLayoutT, Grid_t>;
+        using view_type       = patch_data_type::view_type;
     };
 
 

src/amr/resources_manager/particle_resource.hpp

@@ -9,18 +9,20 @@ namespace PHARE
 {
 namespace amr
 {
-    /** @brief tells SAMRAI which kind of variable, patchdata are used for a Field Resource
-     * also says the type of the actual data buffer
+    /** @brief tells SAMRAI which kind of variable, patchdata are used for a Particle resource
      */
-    template<typename ResourcesUser, std::size_t interp>
-    struct UserParticleType
+    template<typename ParticleArray, std::size_t interp>
+    struct ParticleViewInfo
     {
-        static constexpr auto dimension    = ResourcesUser::dimension;
+        static constexpr auto dimension    = ParticleArray::dimension;
         static constexpr auto interp_order = interp;
 
-        using particle_array_type = typename ResourcesUser::particle_array_type;
+        // TODORM this class could be templated by the ParticleArray type and rather
+        // hard code the link to the ParticlePack here
+        using particle_array_type = ParticleArray;
         using variable_type       = ParticlesVariable<particle_array_type, interp_order>;
         using patch_data_type     = ParticlesData<particle_array_type>;
+        using view_type           = patch_data_type::view_type;
     };
 
 } // namespace amr

src/amr/resources_manager/resources_guards.hpp

@@ -15,67 +15,50 @@ namespace PHARE
 {
 namespace amr
 {
-    /** \brief ResourcesGuards maintain a link with several resources in order to give them
-     * an access to the data.
-     *
-     *  At construction it will take the patch, and all resourcesManagerUser object that need to
-     *  be set via the ResourcesManager. Upon destruction, it will put all the previous
-     *  object in an inactive state (for now it just put nullptr on them)
-
-     * TODO: add the active mechanism
+    /** \brief ViewGuard ... TODO fix doc
      */
-    template<typename ResourcesManager, typename... ResourcesUsers>
-    class ResourcesGuard
+    template<typename ResourcesManager, typename... Views>
+    class ViewGuard
     {
     public:
-        /**
-         *  \brief At construction, each resourcesUser will be valid. At destruction time, each
-         * resourcesUser will be invalid
-         *
-         *  \param[in] patch
-         *  \param[in] resourcesManager
-         *  \param[in,out] resourcesUsers
-         */
-        ResourcesGuard(SAMRAI::hier::Patch const& patch, ResourcesManager const& resourcesManager,
-                       ResourcesUsers&... resourcesUsers)
-            : resourcesUsers_{resourcesUsers...}
+        ViewGuard(SAMRAI::hier::Patch const& patch, ResourcesManager const& resourcesManager,
+                  Views&... views)
+            : views_{views...}
             , patch_{patch}
             , resourcesManager_{resourcesManager}
         {
             std::apply(
                 [this](auto&... user) {
                     ((resourcesManager_.setResources_(user, UseResourcePtr{}, patch_)), ...);
                 },
-                resourcesUsers_);
+                views_);
         }
 
 
 
 
-        ~ResourcesGuard()
+        ~ViewGuard()
         {
-            // set nullptr to all users in resourcesUsers_
             std::apply(
-                [this](auto&... user) {
-                    ((resourcesManager_.setResources_(user, UseNullPtr{}, patch_)), ...);
+                [this](auto&... view) {
+                    ((resourcesManager_.setResources_(view, UseNullPtr{}, patch_)), ...);
                 },
-                resourcesUsers_);
+                views_);
         }
 
 
 
 
-        // We just need the move constructor for using ResourceManager::createResourcesGuards
-        ResourcesGuard(ResourcesGuard&&)                        = default;
-        ResourcesGuard()                                        = delete;
-        ResourcesGuard(ResourcesGuard const&)                   = delete;
-        ResourcesGuard& operator=(ResourcesGuard const& source) = delete;
-        ResourcesGuard& operator=(ResourcesGuard&&)             = delete;
+        ViewGuard(ViewGuard&&)                        = default;
+        ViewGuard()                                   = delete;
+        ViewGuard(ViewGuard const&)                   = delete;
+        ViewGuard& operator=(ViewGuard const& source) = delete;
+        ViewGuard& operator=(ViewGuard&&)             = delete;
 
 
 
     private:
-        std::tuple<ResourcesUsers&...> resourcesUsers_;
+        std::tuple<Views&...> views_;
         SAMRAI::hier::Patch const& patch_;
         ResourcesManager const& resourcesManager_;
     };