added time refinement for E

Author: UCaromel

src/amr/CMakeLists.txt

@@ -11,7 +11,6 @@ set( SOURCES_INC
      data/field/coarsening/field_coarsen_index_weight.hpp
      data/field/coarsening/coarsen_weighter.hpp
      data/field/coarsening/default_field_coarsener.hpp
-     data/field/coarsening/magnetic_field_coarsener.hpp
      data/field/coarsening/electric_field_coarsener.hpp
      data/field/field_data.hpp
      data/field/field_data_factory.hpp

src/amr/data/field/coarsening/electric_field_coarsener.hpp

@@ -7,6 +7,7 @@
 
 
 #include <SAMRAI/hier/Box.h>
+#include <cstddef>
 #include <stdexcept>
 
 namespace PHARE::amr
@@ -35,7 +36,7 @@ class ElectricFieldCoarsener
     ElectricFieldCoarsener(std::array<core::QtyCentering, dimension> const centering,
                            SAMRAI::hier::Box const& sourceBox,
                            SAMRAI::hier::Box const& destinationBox,
-                           SAMRAI::hier::IntVector const& ratio)
+                           SAMRAI::hier::IntVector const& /*ratio*/)
         : centering_{centering}
         , sourceBox_{sourceBox}
         , destinationBox_{destinationBox}
@@ -52,15 +53,9 @@ class ElectricFieldCoarsener
 
         core::Point<int, dimension> fineStartIndex;
 
-        fineStartIndex[dirX] = coarseIndex[dirX] * this->ratio_;
-
-        if constexpr (dimension > 1)
+        for (auto i = std::size_t{0}; i < dimension; ++i)
         {
-            fineStartIndex[dirY] = coarseIndex[dirY] * this->ratio_;
-            if constexpr (dimension > 2)
-            {
-                fineStartIndex[dirZ] = coarseIndex[dirZ] * this->ratio_;
-            }
+            fineStartIndex[i] = coarseIndex[i] * this->ratio_;
         }
 
         fineStartIndex = AMRToLocal(fineStartIndex, sourceBox_);

src/amr/data/field/coarsening/magnetic_field_coarsener.hpp

@@ -12,7 +12,6 @@
 #include "synchronizer_pool.hpp"
 #include "amr/data/field/coarsening/field_coarsen_operator.hpp"
 #include "amr/data/field/coarsening/default_field_coarsener.hpp"
-#include "amr/data/field/coarsening/magnetic_field_coarsener.hpp"
 #include "amr/data/field/coarsening/electric_field_coarsener.hpp"
 #include "amr/data/field/refine/field_refiner.hpp"
 #include "amr/data/field/refine/magnetic_field_refiner.hpp"
@@ -100,7 +99,6 @@ namespace amr
 
         template<typename Policy>
         using BaseCoarsenOp          = FieldCoarsenOperator<GridLayoutT, GridT, Policy>;
-        using MagneticCoarsenOp      = BaseCoarsenOp<MagneticFieldCoarsener<dimension>>;
         using DefaultCoarsenOp       = BaseCoarsenOp<DefaultFieldCoarsener<dimension>>;
         using ElectricFieldCoarsenOp = BaseCoarsenOp<ElectricFieldCoarsener<dimension>>;
 
@@ -118,6 +116,7 @@ namespace amr
             resourcesManager_->registerResources(Jold_);
             resourcesManager_->registerResources(NiOld_);
             resourcesManager_->registerResources(ViOld_);
+            resourcesManager_->registerResources(Eold_);
         }
 
         virtual ~HybridHybridMessengerStrategy() = default;
@@ -138,6 +137,7 @@ namespace amr
             resourcesManager_->allocate(Jold_, patch, allocateTime);
             resourcesManager_->allocate(NiOld_, patch, allocateTime);
             resourcesManager_->allocate(ViOld_, patch, allocateTime);
+            resourcesManager_->allocate(Eold_, patch, allocateTime);
         }
 
 
@@ -328,21 +328,6 @@ namespace amr
             patchGhostPartRefiners_.fill(levelNumber, initDataTime);
 
 
-            // regriding will fill the new level wherever it has points that overlap
-            // old level. This will include its level border points.
-            // These new level border points will thus take values that where previous
-            // domain values. Magnetic flux is thus not necessarily consistent with
-            // the Loring et al. method to sync the induction between coarse and fine faces.
-            // Specifically, we need all fine faces to have equal magnetic field and also
-            // equal to that of the shared coarse face.
-            // This means that we now need to fill ghosts and border included
-
-            if (!isRegriddingL0)
-            {
-                auto& E = hybridModel.state.electromag.E;
-                elecGhostsRefiners_.fill(E, levelNumber, initDataTime);
-            }
-
             // we now call only levelGhostParticlesOld.fill() and not .regrid()
             // regrid() would refine from next coarser in regions of level not overlaping
             // oldLevel, but copy from domain particles of oldLevel where there is an
@@ -638,19 +623,23 @@ namespace amr
             for (auto& patch : level)
             {
                 auto dataOnPatch = resourcesManager_->setOnPatch(
-                    *patch, hybridModel.state.J, hybridModel.state.ions, Jold_, NiOld_, ViOld_);
+                    *patch, hybridModel.state.electromag, hybridModel.state.J,
+                    hybridModel.state.ions, Jold_, NiOld_, ViOld_, Eold_);
 
                 resourcesManager_->setTime(Jold_, *patch, currentTime);
                 resourcesManager_->setTime(NiOld_, *patch, currentTime);
                 resourcesManager_->setTime(ViOld_, *patch, currentTime);
+                resourcesManager_->setTime(Eold_, *patch, currentTime);
 
                 auto& J  = hybridModel.state.J;
                 auto& Vi = hybridModel.state.ions.velocity();
                 auto& Ni = hybridModel.state.ions.chargeDensity();
+                auto& E  = hybridModel.state.electromag.E;
 
                 Jold_.copyData(J);
                 ViOld_.copyData(Vi);
                 NiOld_.copyData(Ni);
+                Eold_.copyData(E);
             }
         }
 
@@ -707,7 +696,7 @@ namespace amr
                     double const syncTime) override
         {
             refluxSchedules[fineLevelNumber]->coarsenData();
-            ghostRefluxedSchedules[coarserLevelNumber]->fillData(syncTime);
+            patchGhostRefluxedSchedules[coarserLevelNumber]->fillData(syncTime);
         }
 
         // after coarsening, domain nodes have been updated and therefore patch ghost nodes
@@ -751,11 +740,13 @@ namespace amr
                 return keys;
             };
 
-            elecSharedNodesRefiners_.addStaticRefiners(info->ghostElectric, EfieldNodeRefineOp_,
-                                                       makeKeys(info->ghostElectric));
+            elecSharedNodesRefiners_.addTimeRefiners(info->ghostElectric, info->ghostElectric,
+                                                     core::VecFieldNames{Eold_},
+                                                     EfieldNodeRefineOp_, fieldTimeOp_);
 
-            elecGhostsRefiners_.addStaticRefiners(info->ghostElectric, EfieldRefineOp_,
-                                                  makeKeys(info->ghostElectric));
+            elecGhostsRefiners_.addTimeRefiners(info->ghostElectric, info->ghostElectric,
+                                                core::VecFieldNames{Eold_}, EfieldRefineOp_,
+                                                fieldTimeOp_);
 
             currentSharedNodesRefiners_.addTimeRefiners(info->ghostCurrent, info->modelCurrent,
                                                         core::VecFieldNames{Jold_},
@@ -814,9 +805,6 @@ namespace amr
 
         void registerSyncComms(std::unique_ptr<HybridMessengerInfo> const& info)
         {
-            magnetoSynchronizers_.add(info->modelMagnetic, magneticCoarseningOp_,
-                                      info->modelMagnetic.vecName);
-
             electroSynchronizers_.add(info->modelElectric, electricFieldCoarseningOp_,
                                       info->modelElectric.vecName);
 
@@ -1057,6 +1045,7 @@ namespace amr
         VecFieldT Jold_{stratName + "_Jold", core::HybridQuantity::Vector::J};
         VecFieldT ViOld_{stratName + "_VBulkOld", core::HybridQuantity::Vector::V};
         FieldT NiOld_{stratName + "_NiOld", core::HybridQuantity::Scalar::rho};
+        VecFieldT Eold_{stratName + "_Eold", core::HybridQuantity::Vector::E};
 
 
         //! ResourceManager shared with other objects (like the HybridModel)
@@ -1154,7 +1143,6 @@ namespace amr
 
         using CoarsenOperator_ptr = std::shared_ptr<SAMRAI::hier::CoarsenOperator>;
         CoarsenOperator_ptr fieldCoarseningOp_{std::make_shared<DefaultCoarsenOp>()};
-        CoarsenOperator_ptr magneticCoarseningOp_{std::make_shared<MagneticCoarsenOp>()};
         CoarsenOperator_ptr electricFieldCoarseningOp_{std::make_shared<ElectricFieldCoarsenOp>()};
 
         MagneticRefinePatchStrategy<ResourcesManagerT, FieldDataT> magneticRefinePatchStrategy_{

src/amr/messengers/hybrid_hybrid_messenger_strategy.hpp

@@ -66,6 +66,11 @@ namespace amr
                              std::shared_ptr<SAMRAI::hier::TimeInterpolateOperator>& timeOp);
 
 
+        void addTimeRefiners(std::vector<core::VecFieldNames> const& destinations,
+                             std::vector<core::VecFieldNames> const& sources,
+                             core::VecFieldNames const& oldSource,
+                             std::shared_ptr<RefineOperator>& refineOp,
+                             std::shared_ptr<SAMRAI::hier::TimeInterpolateOperator>& timeOp);
 
         /**
          * add a refiner that will use time and spatial interpolation.
@@ -126,7 +131,7 @@ namespace amr
 
         /** @brief executes a regridding for all quantities in the pool.*/
         virtual void regrid(std::shared_ptr<SAMRAI::hier::PatchHierarchy> const& hierarchy,
-                            const int levelNumber,
+                            int const levelNumber,
                             std::shared_ptr<SAMRAI::hier::PatchLevel> const& oldLevel,
                             double const initDataTime)
         {
@@ -215,6 +220,20 @@ namespace amr
         }
     }
 
+    template<typename ResourcesManager, RefinerType Type>
+    void RefinerPool<ResourcesManager, Type>::addTimeRefiners(
+        std::vector<core::VecFieldNames> const& destinations,
+        std::vector<core::VecFieldNames> const& sources, core::VecFieldNames const& oldSource,
+        std::shared_ptr<RefineOperator>& refineOp,
+        std::shared_ptr<SAMRAI::hier::TimeInterpolateOperator>& timeOp)
+    {
+        for (std::size_t i = 0; i < destinations.size(); ++i)
+        {
+            addTimeRefiner(destinations[i], sources[i], oldSource, refineOp, timeOp,
+                           destinations[i].vecName);
+        }
+    }
+
     template<typename ResourcesManager, RefinerType Type>
     void RefinerPool<ResourcesManager, Type>::addTimeRefiner(
         core::VecFieldNames const& ghost, core::VecFieldNames const& model,

src/amr/messengers/refiner_pool.hpp

@@ -575,14 +575,15 @@ namespace solver
                 toCoarser.synchronize(fineLevel);
 
                 // refluxing
+                auto& fineSolver   = getSolver_(ilvl);
                 auto iCoarseLevel  = ilvl - 1;
                 auto& coarseLevel  = *hierarchy->getPatchLevel(iCoarseLevel);
                 auto& coarseSolver = getSolver_(iCoarseLevel);
                 auto& coarseModel  = getModel_(iCoarseLevel);
 
                 toCoarser.reflux(iCoarseLevel, ilvl, syncTime);
                 coarseSolver.reflux(coarseModel, coarseLevel, syncTime);
-                coarseSolver.resetFluxSum(coarseModel, fineLevel);
+                fineSolver.resetFluxSum(coarseModel, fineLevel);
 
                 // recopy (patch) ghosts
                 toCoarser.postSynchronize(coarseModel, coarseLevel, syncTime);

src/amr/multiphysics_integrator.hpp

@@ -535,12 +535,17 @@ void SolverPPC<HybridModel, AMR_Types>::average_(level_t& level, ModelViews_t& v
 {
     PHARE_LOG_SCOPE(1, "SolverPPC::average_");
 
+    TimeSetter setTime{views, newTime};
+
     for (auto& state : views)
     {
         PHARE::core::average(state.electromag.B, state.electromagPred.B, state.electromagAvg.B);
         PHARE::core::average(state.electromag.E, state.electromagPred.E, state.electromagAvg.E);
     }
 
+    setTime([](auto& state) -> auto& { return state.electromagAvg.B; });
+    setTime([](auto& state) -> auto& { return state.electromagAvg.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