vtkhdf

Author: PhilipDeegan

pyphare/pyphare/pharein/__init__.py

@@ -328,6 +328,9 @@ def as_paths(rb):
             )
 
     if len(simulation.diagnostics) > 0:
+        if simulation.diag_options is not None and "format" in simulation.diag_options:
+            add_string(diag_path + "format", simulation.diag_options["format"])
+
         if simulation.diag_options is not None and "options" in simulation.diag_options:
             add_string(
                 diag_path + "filePath", simulation.diag_options["options"]["dir"]

pyphare/pyphare/pharein/simulation.py

@@ -481,7 +481,7 @@ def check_directory(directory, key):
 # diag_options = {"format":"phareh5", "options": {"dir": "phare_ouputs/"}}
 def check_diag_options(**kwargs):
     diag_options = kwargs.get("diag_options", None)
-    formats = ["phareh5"]
+    formats = ["phareh5", "pharevtkhdf"]
     if diag_options is not None and "format" in diag_options:
         if diag_options["format"] not in formats:
             raise ValueError("Error - diag_options format is invalid")

src/amr/physical_models/hybrid_model.hpp

@@ -28,15 +28,15 @@ class HybridModel : public IPhysicalModel<AMR_Types>
     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 patch_t                = AMR_Types::patch_t;
+    using level_t                = 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 vecfield_type          = Electromag::vecfield_type;
+    using field_type             = vecfield_type::field_type;
     using grid_type              = Grid_t;
     using ions_type              = Ions;
-    using particle_array_type    = typename Ions::particle_array_type;
+    using particle_array_type    = Ions::particle_array_type;
     using resources_manager_type = amr::ResourcesManager<gridlayout_type, grid_type>;
     using ParticleInitializerFactory
         = core::ParticleInitializerFactory<particle_array_type, gridlayout_type>;

src/amr/resources_manager/amr_utils.hpp

@@ -248,7 +248,7 @@ namespace amr
              iLevel++)
         {
             visitLevel<GridLayout>(*hierarchy.getPatchLevel(iLevel), resman,
-                                   std::forward<Action>(action), std::forward<Args...>(args...));
+                                   std::forward<Action>(action), std::forward<Args>(args)...);
         }
     }
 

src/core/data/grid/gridlayout.hpp

@@ -2,19 +2,17 @@
 #define PHARE_CORE_GRID_GridLayout_HPP
 
 
-#include "core/hybrid/hybrid_quantities.hpp"
+#include "core/def.hpp"
 #include "core/utilities/types.hpp"
-#include "core/data/field/field.hpp"
-#include "gridlayoutdefs.hpp"
-#include "core/utilities/algorithm.hpp"
 #include "core/utilities/box/box.hpp"
 #include "core/utilities/constants.hpp"
 #include "core/utilities/index/index.hpp"
 #include "core/utilities/point/point.hpp"
-#include "core/def.hpp"
+#include "core/hybrid/hybrid_quantities.hpp"
+
+#include "gridlayoutdefs.hpp"
 
 #include <array>
-#include <cmath>
 #include <tuple>
 #include <cstddef>
 #include <functional>
@@ -879,7 +877,6 @@ namespace core
             return GridLayoutImpl::centering(hybridQuantity);
         }
 
-
         NO_DISCARD constexpr static std::array<std::array<QtyCentering, dimension>, 6>
         centering(HybridQuantity::Tensor hybridQuantity)
         {
@@ -1027,6 +1024,29 @@ namespace core
 
 
 
+        /**
+         * @brief BxToMoments return the indexes and associated coef to compute the linear
+         * interpolation necessary to project Bx onto moments.
+         */
+        NO_DISCARD auto static constexpr BxToMoments() { return GridLayoutImpl::BxToMoments(); }
+
+
+        /**
+         * @brief ByToMoments return the indexes and associated coef to compute the linear
+         * interpolation necessary to project By onto moments.
+         */
+        NO_DISCARD auto static constexpr ByToMoments() { return GridLayoutImpl::ByToMoments(); }
+
+
+        /**
+         * @brief BzToMoments return the indexes and associated coef to compute the linear
+         * interpolation necessary to project Bz onto moments.
+         */
+        NO_DISCARD auto static constexpr BzToMoments() { return GridLayoutImpl::BzToMoments(); }
+
+
+
+
         /**
          * @brief ExToMoments return the indexes and associated coef to compute the linear
          * interpolation necessary to project Ex onto moments.
@@ -1157,30 +1177,23 @@ namespace core
 
 
 
-
-        auto AMRGhostBoxFor(auto const& field) const
+        auto AMRBoxFor(auto const& field) const
         {
             auto const centerings = centering(field);
-            auto const growBy     = [&]() {
-                std::array<int, dimension> arr;
-                for (std::uint8_t i = 0; i < dimension; ++i)
-                    arr[i] = nbrGhosts(centerings[i]);
-                return arr;
-            }();
-            auto ghostBox = grow(AMRBox_, growBy);
+            auto box              = AMRBox_;
             for (std::uint8_t i = 0; i < dimension; ++i)
-                ghostBox.upper[i] += (centerings[i] == QtyCentering::primal) ? 1 : 0;
-            return ghostBox;
+                box.upper[i] += (centerings[i] == QtyCentering::primal) ? 1 : 0;
+            return box;
         }
 
-        auto AMRBoxFor(auto const& field) const
+        auto AMRGhostBoxFor(auto const& field) const
         {
             auto const centerings = centering(field);
-            return grow(AMRGhostBoxFor(field), for_N_make_array<dimension>([&](auto i) {
-                            return -1 * nbrGhosts(centerings[i]);
-                        }));
+            return grow(AMRBoxFor(field), for_N_make_array<dimension>(
+                                              [&](auto i) { return nbrGhosts(centerings[i]); }));
         }
 
+
         template<typename Field, typename Fn>
         void evalOnBox(Field& field, Fn&& fn) const
         {
@@ -1203,6 +1216,15 @@ namespace core
 
         auto levelNumber() const { return levelNumber_; }
 
+
+        auto amr_lcl_idx(auto const& box) const { return boxes_iterator{box, AMRToLocal(box)}; }
+        auto amr_lcl_idx() const { return amr_lcl_idx(AMRBox()); }
+        auto domain_amr_lcl_idx(auto const& field) const { return amr_lcl_idx(AMRBoxFor(field)); }
+        auto ghost_amr_lcl_idx(auto const& field) const
+        {
+            return amr_lcl_idx(AMRGhostBoxFor(field));
+        }
+
     private:
         template<typename Field, typename IndicesFn, typename Fn>
         static void evalOnBox_(Field& field, Fn& fn, IndicesFn& startToEnd)
@@ -1515,51 +1537,6 @@ namespace core
         }
 
 
-
-        struct AMRLocalIndexer //
-        {
-            GridLayout const* layout;
-            Box<int, dimension> amr_box;
-            Box<std::uint32_t, dimension> lcl_box = layout->AMRToLocal(amr_box);
-
-            struct iterator
-            {
-                void operator++()
-                {
-                    ++amr_it;
-                    ++lcl_it;
-                }
-                auto operator*() { return std::forward_as_tuple(*amr_it, *lcl_it); }
-                auto operator==(auto const& that) const
-                {
-                    return amr_it == that.amr_it and lcl_it == that.lcl_it;
-                }
-                auto operator!=(auto const& that) const
-                {
-                    return amr_it != that.amr_it or lcl_it != that.lcl_it;
-                }
-
-                AMRLocalIndexer const* amr_lcl_indexer;
-                box_iterator<int, dimension> amr_it;
-                box_iterator<std::uint32_t, dimension> lcl_it;
-            };
-
-            auto begin() const { return iterator{this, amr_box.begin(), lcl_box.begin()}; }
-            auto end() const { return iterator{this, amr_box.end(), lcl_box.end()}; }
-        };
-
-    public:
-        auto amr_lcl_idx(auto const& box) const { return AMRLocalIndexer{this, box}; }
-        auto amr_lcl_idx() const { return amr_lcl_idx(AMRBox()); }
-        auto domain_amr_lcl_idx(auto const& field) const
-        {
-            return AMRLocalIndexer{this, AMRBoxFor(field)};
-        }
-        auto ghost_amr_lcl_idx(auto const& field) const
-        {
-            return AMRLocalIndexer{this, AMRGhostBoxFor(field)};
-        }
-
     private:
         std::array<double, dimension> meshSize_;
         Point<double, dimension> origin_;

src/core/data/grid/gridlayoutdefs.hpp

@@ -1,11 +1,11 @@
 #ifndef PHARE_CORE_GRID_GRIDLAYOUTDEFS_HPP
 #define PHARE_CORE_GRID_GRIDLAYOUTDEFS_HPP
 
-#include <cstddef>
 
-#include "core/hybrid/hybrid_quantities.hpp"
-#include "core/utilities/types.hpp"
 #include "core/utilities/point/point.hpp"
+#include "core/hybrid/hybrid_quantities.hpp"
+
+#include <cstddef>
 
 namespace PHARE
 {