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 Resource_t                          = Grid_t;
 
         /*** \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 Resource_t = 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/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,21 @@ 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 particle_pack_t     = core::ParticlesPack<particle_array_type>;
+    using resources_manager_type
+        = amr::ResourcesManager<gridlayout_type, grid_type, particle_pack_t>;
     using ParticleInitializerFactory
         = core::ParticleInitializerFactory<particle_array_type, gridlayout_type>;
 

src/amr/resources_manager/field_resource.hpp

@@ -12,7 +12,7 @@ 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>;

src/amr/resources_manager/particle_resource.hpp

@@ -9,16 +9,15 @@ 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 ParticleResource, std::size_t interp>
+    struct ParticleViewInfo
     {
-        static constexpr auto dimension    = ResourcesUser::dimension;
+        static constexpr auto dimension    = ParticleResource::dimension;
         static constexpr auto interp_order = interp;
 
-        using particle_array_type = typename ResourcesUser::particle_array_type;
+        using particle_array_type = typename ParticleResource::particle_array_type;
         using variable_type       = ParticlesVariable<particle_array_type, interp_order>;
         using patch_data_type     = ParticlesData<particle_array_type>;
     };

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_;
     };