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

@@ -16,7 +16,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"
@@ -117,7 +116,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>>;
 
@@ -343,22 +341,6 @@ namespace amr
             domainParticlesRefiners_.regrid(hierarchy, levelNumber, oldLevel, 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
@@ -703,19 +685,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);
             }
         }
 
@@ -768,7 +754,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
@@ -877,9 +863,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);
 
@@ -1120,6 +1103,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};
 
         TensorFieldT sumTensor_{"PHARE_sumTensor", core::HybridQuantity::Tensor::M};
         VecFieldT sumVec_{"PHARE_sumVec", core::HybridQuantity::Vector::V};
@@ -1222,7 +1206,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

@@ -97,7 +97,6 @@ namespace amr
                         std::shared_ptr<SAMRAI::xfer::VariableFillPattern> fillPattern = nullptr);
 
 
-
         /**
          * add a refiner that will use time and spatial interpolation.
          * time interpolation will be done between data represented by model and oldModel

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

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