ABLASTR: Coarsen Functions

Move coarsen functions to ABLASTR. Rename by property of the coarsening function.
ECP-WarpX · Nov 3, 2022 · ae1182f · ae1182f
1 parent 4f780ff
commit ae1182f
Show file tree

Hide file tree

Showing 32 changed files with 643 additions and 547 deletions.
diff --git a/Source/Diagnostics/BTDiagnostics.cpp b/Source/Diagnostics/BTDiagnostics.cpp
@@ -15,12 +15,12 @@
 #include "Diagnostics/FlushFormats/FlushFormat.H"
 #include "ComputeDiagFunctors/BackTransformParticleFunctor.H"
 #include "Utils/Algorithms/IsIn.H"
-#include "Utils/CoarsenIO.H"
 #include "Utils/Parser/ParserUtils.H"
 #include "Utils/TextMsg.H"
 #include "Utils/WarpXConst.H"
 #include "WarpX.H"
 
+#include <ablastr/coarsen/sample.H>
 #include <ablastr/utils/Communication.H>
 #include <ablastr/utils/SignalHandling.H>
 #include <ablastr/warn_manager/WarnManager.H>
@@ -768,8 +768,8 @@ BTDiagnostics::PrepareFieldDataForOutput ()
     // Flattening out MF over levels
 
     for (int lev = warpx.finestLevel(); lev > 0; --lev) {
-        CoarsenIO::Coarsen( *m_cell_centered_data[lev-1], *m_cell_centered_data[lev], 0, 0,
-                             m_cellcenter_varnames.size(), 0, WarpX::RefRatio(lev-1) );
+        ablastr::coarsen::sample::Coarsen(*m_cell_centered_data[lev - 1], *m_cell_centered_data[lev], 0, 0,
+                                          m_cellcenter_varnames.size(), 0, WarpX::RefRatio(lev-1) );
     }
 
     int num_BT_functors = 1;

diff --git a/Source/Diagnostics/ComputeDiagFunctors/CellCenterFunctor.cpp b/Source/Diagnostics/ComputeDiagFunctors/CellCenterFunctor.cpp
@@ -1,11 +1,12 @@
 #include "CellCenterFunctor.H"
 
-#include "Utils/CoarsenIO.H"
 #include "Utils/TextMsg.H"
 #ifdef WARPX_DIM_RZ
 #   include "WarpX.H"
 #endif
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX.H>
 #include <AMReX_IntVect.H>
 #include <AMReX_MultiFab.H>
@@ -35,14 +36,14 @@ CellCenterFunctor::operator()(amrex::MultiFab& mf_dst, int dcomp, const int /*i_
             // All modes > 0
             amrex::MultiFab::Add(mf_dst_stag, *m_mf_src, ic, 0, 1, m_mf_src->nGrowVect());
         }
-        CoarsenIO::Coarsen( mf_dst, mf_dst_stag, dcomp, 0, nComp(), 0,  m_crse_ratio);
+        ablastr::coarsen::sample::Coarsen( mf_dst, mf_dst_stag, dcomp, 0, nComp(), 0,  m_crse_ratio);
     } else {
-        CoarsenIO::Coarsen( mf_dst, *m_mf_src, dcomp, 0, nComp(), 0, m_crse_ratio);
+        ablastr::coarsen::sample::Coarsen( mf_dst, *m_mf_src, dcomp, 0, nComp(), 0, m_crse_ratio);
     }
 #else
     // In cartesian geometry, coarsen and interpolate from simulation MultiFab, m_mf_src,
     // to output diagnostic MultiFab, mf_dst.
-    CoarsenIO::Coarsen( mf_dst, *m_mf_src, dcomp, 0, nComp(), mf_dst.nGrowVect(), m_crse_ratio);
+    ablastr::coarsen::sample::Coarsen(mf_dst, *m_mf_src, dcomp, 0, nComp(), mf_dst.nGrowVect(), m_crse_ratio);
     amrex::ignore_unused(m_lev, m_convertRZmodes2cartesian);
 #endif
 }
diff --git a/Source/Diagnostics/ComputeDiagFunctors/DivBFunctor.cpp b/Source/Diagnostics/ComputeDiagFunctors/DivBFunctor.cpp
@@ -1,8 +1,9 @@
 #include "DivBFunctor.H"
 
-#include "Utils/CoarsenIO.H"
 #include "WarpX.H"
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX_IntVect.H>
 #include <AMReX_MultiFab.H>
 
@@ -25,7 +26,7 @@ DivBFunctor::operator()(amrex::MultiFab& mf_dst, int dcomp, const int /*i_buffer
     amrex::MultiFab divB( warpx.boxArray(m_lev), warpx.DistributionMap(m_lev), warpx.ncomps, ng );
     warpx.ComputeDivB(divB, 0, m_arr_mf_src, WarpX::CellSize(m_lev) );
     // // Coarsen and Interpolate from divB to coarsened/reduced_domain mf_dst
-    // CoarsenIO::Coarsen( mf_dst, divB, dcomp, 0, nComp(), 0, m_crse_ratio);
+    // ablastr::coarsen::sample::Coarsen( mf_dst, divB, dcomp, 0, nComp(), 0, m_crse_ratio);
 #ifdef WARPX_DIM_RZ
     if (m_convertRZmodes2cartesian) {
         // In cylindrical geometry, sum real part of all modes of divE in
@@ -41,15 +42,15 @@ DivBFunctor::operator()(amrex::MultiFab& mf_dst, int dcomp, const int /*i_buffer
             amrex::MultiFab::Add(mf_dst_stag, divB, ic, 0, 1, divB.nGrowVect());
         }
         // TODO check if coarsening is needed, otherwise copy
-        CoarsenIO::Coarsen( mf_dst, mf_dst_stag, dcomp, 0, nComp(), 0,  m_crse_ratio);
+        ablastr::coarsen::sample::Coarsen( mf_dst, mf_dst_stag, dcomp, 0, nComp(), 0,  m_crse_ratio);
     } else {
         // TODO check if coarsening is needed, otherwise copy
-        CoarsenIO::Coarsen( mf_dst, divB, dcomp, 0, nComp(), 0, m_crse_ratio);
+        ablastr::coarsen::sample::Coarsen( mf_dst, divB, dcomp, 0, nComp(), 0, m_crse_ratio);
     }
 #else
     // In cartesian geometry, coarsen and interpolate from simulation MultiFab, divE,
     // to output diagnostic MultiFab, mf_dst.
-    CoarsenIO::Coarsen( mf_dst, divB, dcomp, 0, nComp(), 0, m_crse_ratio);
+    ablastr::coarsen::sample::Coarsen(mf_dst, divB, dcomp, 0, nComp(), 0, m_crse_ratio);
     amrex::ignore_unused(m_convertRZmodes2cartesian);
 #endif
 }
diff --git a/Source/Diagnostics/ComputeDiagFunctors/DivEFunctor.cpp b/Source/Diagnostics/ComputeDiagFunctors/DivEFunctor.cpp
@@ -1,12 +1,13 @@
 #include "DivEFunctor.H"
 
-#include "Utils/CoarsenIO.H"
 #include "Utils/TextMsg.H"
 #ifdef WARPX_DIM_RZ
 #   include "Utils/WarpXAlgorithmSelection.H"
 #endif
 #include "WarpX.H"
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX.H>
 #include <AMReX_BoxArray.H>
 #include <AMReX_IntVect.H>
@@ -55,14 +56,14 @@ DivEFunctor::operator()(amrex::MultiFab& mf_dst, const int dcomp, const int /*i_
             // Real part of all modes > 0
             amrex::MultiFab::Add(mf_dst_stag, divE, ic, 0, 1, divE.nGrowVect());
         }
-        CoarsenIO::Coarsen( mf_dst, mf_dst_stag, dcomp, 0, nComp(), 0,  m_crse_ratio);
+        ablastr::coarsen::sample::Coarsen( mf_dst, mf_dst_stag, dcomp, 0, nComp(), 0,  m_crse_ratio);
     } else {
-        CoarsenIO::Coarsen( mf_dst, divE, dcomp, 0, nComp(), 0, m_crse_ratio);
+        ablastr::coarsen::sample::Coarsen( mf_dst, divE, dcomp, 0, nComp(), 0, m_crse_ratio);
     }
 #else
     // In cartesian geometry, coarsen and interpolate from simulation MultiFab, divE,
     // to output diagnostic MultiFab, mf_dst.
-    CoarsenIO::Coarsen( mf_dst, divE, dcomp, 0, nComp(), 0, m_crse_ratio);
+    ablastr::coarsen::sample::Coarsen(mf_dst, divE, dcomp, 0, nComp(), 0, m_crse_ratio);
     amrex::ignore_unused(m_convertRZmodes2cartesian);
 #endif
 }
diff --git a/Source/Diagnostics/ComputeDiagFunctors/PartPerCellFunctor.cpp b/Source/Diagnostics/ComputeDiagFunctors/PartPerCellFunctor.cpp
@@ -2,9 +2,10 @@
 
 #include "Diagnostics/ComputeDiagFunctors/ComputeDiagFunctor.H"
 #include "Particles/MultiParticleContainer.H"
-#include "Utils/CoarsenIO.H"
 #include "WarpX.H"
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX_BLassert.H>
 #include <AMReX_IntVect.H>
 #include <AMReX_MultiFab.H>
@@ -36,5 +37,5 @@ PartPerCellFunctor::operator()(amrex::MultiFab& mf_dst, const int dcomp, const i
     // Compute ppc which includes a summation over all species.
     warpx.GetPartContainer().Increment(ppc_mf, m_lev);
     // Coarsen and interpolate from ppc_mf to the output diagnostic MultiFab, mf_dst.
-    CoarsenIO::Coarsen(mf_dst, ppc_mf, dcomp, 0, nComp(), 0, m_crse_ratio);
+    ablastr::coarsen::sample::Coarsen(mf_dst, ppc_mf, dcomp, 0, nComp(), 0, m_crse_ratio);
 }
diff --git a/Source/Diagnostics/ComputeDiagFunctors/PartPerGridFunctor.cpp b/Source/Diagnostics/ComputeDiagFunctors/PartPerGridFunctor.cpp
@@ -2,9 +2,10 @@
 
 #include "Diagnostics/ComputeDiagFunctors/ComputeDiagFunctor.H"
 #include "Particles/MultiParticleContainer.H"
-#include "Utils/CoarsenIO.H"
 #include "WarpX.H"
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX_BLassert.H>
 #include <AMReX_Config.H>
 #include <AMReX_FArrayBox.H>
@@ -48,5 +49,5 @@ PartPerGridFunctor::operator()(amrex::MultiFab& mf_dst, const int dcomp, const i
     }
 
     // Coarsen and interpolate from ppg_mf to the output diagnostic MultiFab, mf_dst.
-    CoarsenIO::Coarsen(mf_dst, ppg_mf, dcomp, 0, nComp(), 0, m_crse_ratio);
+    ablastr::coarsen::sample::Coarsen(mf_dst, ppg_mf, dcomp, 0, nComp(), 0, m_crse_ratio);
 }
diff --git a/Source/Diagnostics/ComputeDiagFunctors/ParticleReductionFunctor.cpp b/Source/Diagnostics/ComputeDiagFunctors/ParticleReductionFunctor.cpp
@@ -4,9 +4,10 @@
 #include "Diagnostics/ComputeDiagFunctors/ComputeDiagFunctor.H"
 #include "Particles/MultiParticleContainer.H"
 #include "Particles/WarpXParticleContainer.H"
-#include "Utils/CoarsenIO.H"
 #include "WarpX.H"
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX_Array.H>
 #include <AMReX_BLassert.H>
 #include <AMReX_IntVect.H>
@@ -153,5 +154,5 @@ ParticleReductionFunctor::operator() (amrex::MultiFab& mf_dst, const int dcomp,
     }
 
     // Coarsen and interpolate from ppc_mf to the output diagnostic MultiFab, mf_dst.
-    CoarsenIO::Coarsen(mf_dst, red_mf, dcomp, 0, nComp(), 0, m_crse_ratio);
+    ablastr::coarsen::sample::Coarsen(mf_dst, red_mf, dcomp, 0, nComp(), 0, m_crse_ratio);
 }
diff --git a/Source/Diagnostics/ComputeDiagFunctors/RhoFunctor.cpp b/Source/Diagnostics/ComputeDiagFunctors/RhoFunctor.cpp
@@ -8,10 +8,11 @@
 #endif
 #include "Particles/MultiParticleContainer.H"
 #include "Particles/WarpXParticleContainer.H"
-#include "Utils/CoarsenIO.H"
 #include "Utils/TextMsg.H"
 #include "WarpX.H"
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX.H>
 #include <AMReX_IntVect.H>
 #include <AMReX_MultiFab.H>
@@ -83,14 +84,14 @@ RhoFunctor::operator() ( amrex::MultiFab& mf_dst, const int dcomp, const int /*i
             // Real part of all modes > 0
             amrex::MultiFab::Add( mf_dst_stag, *rho, ic, 0, 1, rho->nGrowVect() );
         }
-        CoarsenIO::Coarsen( mf_dst, mf_dst_stag, dcomp, 0, nComp(), 0, m_crse_ratio );
+        ablastr::coarsen::sample::Coarsen( mf_dst, mf_dst_stag, dcomp, 0, nComp(), 0, m_crse_ratio );
     } else {
-        CoarsenIO::Coarsen( mf_dst, *rho, dcomp, 0, nComp(), 0, m_crse_ratio );
+        ablastr::coarsen::sample::Coarsen( mf_dst, *rho, dcomp, 0, nComp(), 0, m_crse_ratio );
     }
 #else
     // In Cartesian geometry, coarsen and interpolate from temporary MultiFab rho
     // to output diagnostic MultiFab mf_dst
-    CoarsenIO::Coarsen( mf_dst, *rho, dcomp, 0, nComp(), mf_dst.nGrowVect(), m_crse_ratio );
+    ablastr::coarsen::sample::Coarsen(mf_dst, *rho, dcomp, 0, nComp(), mf_dst.nGrowVect(), m_crse_ratio );
     amrex::ignore_unused(m_convertRZmodes2cartesian);
 #endif
 }
diff --git a/Source/Diagnostics/FieldIO.cpp b/Source/Diagnostics/FieldIO.cpp
@@ -7,9 +7,10 @@
  */
 #include "FieldIO.H"
 
-#include "Utils/CoarsenIO.H"
 #include "Utils/TextMsg.H"
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX.H>
 #include <AMReX_IntVect.H>
 #include <AMReX_MultiFab.H>
@@ -183,9 +184,9 @@ AverageAndPackVectorField( MultiFab& mf_avg,
     const std::array<std::unique_ptr<MultiFab>,3> &vector_total = vector_field;
 #endif
 
-    CoarsenIO::Coarsen( mf_avg, *(vector_total[0]), dcomp  , 0, 1, ngrow );
-    CoarsenIO::Coarsen( mf_avg, *(vector_total[1]), dcomp+1, 0, 1, ngrow );
-    CoarsenIO::Coarsen( mf_avg, *(vector_total[2]), dcomp+2, 0, 1, ngrow );
+    ablastr::coarsen::sample::Coarsen(mf_avg, *(vector_total[0]), dcomp  , 0, 1, ngrow );
+    ablastr::coarsen::sample::Coarsen(mf_avg, *(vector_total[1]), dcomp + 1, 0, 1, ngrow );
+    ablastr::coarsen::sample::Coarsen(mf_avg, *(vector_total[2]), dcomp + 2, 0, 1, ngrow );
 }
 
 /** \brief Take a MultiFab `scalar_field`
@@ -220,7 +221,7 @@ AverageAndPackScalarField (MultiFab& mf_avg,
         MultiFab::Copy( mf_avg, *scalar_total, 0, dcomp, 1, ngrow);
     } else if ( scalar_total->is_nodal() ){
         // - Fully nodal
-        CoarsenIO::Coarsen( mf_avg, *scalar_total, dcomp, 0, 1, ngrow );
+        ablastr::coarsen::sample::Coarsen(mf_avg, *scalar_total, dcomp, 0, 1, ngrow );
     } else {
         amrex::Abort(Utils::TextMsg::Err("Unknown staggering."));
     }

diff --git a/Source/Diagnostics/ReducedDiags/FieldMaximum.cpp b/Source/Diagnostics/ReducedDiags/FieldMaximum.cpp
@@ -7,10 +7,11 @@
 
 #include "FieldMaximum.H"
 
-#include "Utils/CoarsenIO.H"
 #include "Utils/TextMsg.H"
 #include "WarpX.H"
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX_Algorithm.H>
 #include <AMReX_Array.H>
 #include <AMReX_Array4.H>
@@ -192,65 +193,65 @@ void FieldMaximum::ComputeDiags (int step)
             reduceEx_op.eval(box, reduceEx_data,
             [=] AMREX_GPU_DEVICE (int i, int j, int k) -> ReduceTuple
             {
-                const Real Ex_interp = CoarsenIO::Interp(arrEx, Extype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Ex_interp = ablastr::coarsen::sample::Interp(arrEx, Extype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
                 return amrex::Math::abs(Ex_interp);
             });
             reduceEy_op.eval(box, reduceEy_data,
             [=] AMREX_GPU_DEVICE (int i, int j, int k) -> ReduceTuple
             {
-                const Real Ey_interp = CoarsenIO::Interp(arrEy, Eytype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Ey_interp = ablastr::coarsen::sample::Interp(arrEy, Eytype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
                 return amrex::Math::abs(Ey_interp);
             });
             reduceEz_op.eval(box, reduceEz_data,
             [=] AMREX_GPU_DEVICE (int i, int j, int k) -> ReduceTuple
             {
-                const Real Ez_interp = CoarsenIO::Interp(arrEz, Eztype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Ez_interp = ablastr::coarsen::sample::Interp(arrEz, Eztype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
                 return amrex::Math::abs(Ez_interp);
             });
             reduceBx_op.eval(box, reduceBx_data,
             [=] AMREX_GPU_DEVICE (int i, int j, int k) -> ReduceTuple
             {
-                const Real Bx_interp = CoarsenIO::Interp(arrBx, Bxtype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Bx_interp = ablastr::coarsen::sample::Interp(arrBx, Bxtype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
                 return amrex::Math::abs(Bx_interp);
             });
             reduceBy_op.eval(box, reduceBy_data,
             [=] AMREX_GPU_DEVICE (int i, int j, int k) -> ReduceTuple
             {
-                const Real By_interp = CoarsenIO::Interp(arrBy, Bytype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real By_interp = ablastr::coarsen::sample::Interp(arrBy, Bytype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
                 return amrex::Math::abs(By_interp);
             });
             reduceBz_op.eval(box, reduceBz_data,
             [=] AMREX_GPU_DEVICE (int i, int j, int k) -> ReduceTuple
             {
-                const Real Bz_interp = CoarsenIO::Interp(arrBz, Bztype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Bz_interp = ablastr::coarsen::sample::Interp(arrBz, Bztype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
                 return amrex::Math::abs(Bz_interp);
             });
             reduceE_op.eval(box, reduceE_data,
             [=] AMREX_GPU_DEVICE (int i, int j, int k) -> ReduceTuple
             {
-                const Real Ex_interp = CoarsenIO::Interp(arrEx, Extype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
-                const Real Ey_interp = CoarsenIO::Interp(arrEy, Eytype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
-                const Real Ez_interp = CoarsenIO::Interp(arrEz, Eztype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Ex_interp = ablastr::coarsen::sample::Interp(arrEx, Extype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Ey_interp = ablastr::coarsen::sample::Interp(arrEy, Eytype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Ez_interp = ablastr::coarsen::sample::Interp(arrEz, Eztype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
                 return Ex_interp*Ex_interp + Ey_interp*Ey_interp + Ez_interp*Ez_interp;
             });
             reduceB_op.eval(box, reduceB_data,
             [=] AMREX_GPU_DEVICE (int i, int j, int k) -> ReduceTuple
             {
-                const Real Bx_interp = CoarsenIO::Interp(arrBx, Bxtype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
-                const Real By_interp = CoarsenIO::Interp(arrBy, Bytype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
-                const Real Bz_interp = CoarsenIO::Interp(arrBz, Bztype, cellCenteredtype,
-                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Bx_interp = ablastr::coarsen::sample::Interp(arrBx, Bxtype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real By_interp = ablastr::coarsen::sample::Interp(arrBy, Bytype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
+                const Real Bz_interp = ablastr::coarsen::sample::Interp(arrBz, Bztype, cellCenteredtype,
+                                                                        reduction_coarsening_ratio, i, j, k, reduction_comp);
                 return Bx_interp*Bx_interp + By_interp*By_interp + Bz_interp*Bz_interp;
             });
         }

diff --git a/Source/Diagnostics/ReducedDiags/FieldMomentum.cpp b/Source/Diagnostics/ReducedDiags/FieldMomentum.cpp
@@ -7,11 +7,12 @@
 
 #include "FieldMomentum.H"
 
-#include "Utils/CoarsenIO.H"
 #include "Utils/TextMsg.H"
 #include "Utils/WarpXConst.H"
 #include "WarpX.H"
 
+#include <ablastr/coarsen/sample.H>
+
 #include <AMReX_Array.H>
 #include <AMReX_Array4.H>
 #include <AMReX_Box.H>
@@ -162,13 +163,13 @@ void FieldMomentum::ComputeDiags (int step)
             reduce_ops.eval(box, reduce_data,
                 [=] AMREX_GPU_DEVICE (int i, int j, int k) -> amrex::GpuTuple<Real, Real, Real>
                 {
-                    const amrex::Real Ex_cc = CoarsenIO::Interp(Ex_arr, Ex_stag, cc, cr, i, j, k, comp);
-                    const amrex::Real Ey_cc = CoarsenIO::Interp(Ey_arr, Ey_stag, cc, cr, i, j, k, comp);
-                    const amrex::Real Ez_cc = CoarsenIO::Interp(Ez_arr, Ez_stag, cc, cr, i, j, k, comp);
+                    const amrex::Real Ex_cc = ablastr::coarsen::sample::Interp(Ex_arr, Ex_stag, cc, cr, i, j, k, comp);
+                    const amrex::Real Ey_cc = ablastr::coarsen::sample::Interp(Ey_arr, Ey_stag, cc, cr, i, j, k, comp);
+                    const amrex::Real Ez_cc = ablastr::coarsen::sample::Interp(Ez_arr, Ez_stag, cc, cr, i, j, k, comp);
 
-                    const amrex::Real Bx_cc = CoarsenIO::Interp(Bx_arr, Bx_stag, cc, cr, i, j, k, comp);
-                    const amrex::Real By_cc = CoarsenIO::Interp(By_arr, By_stag, cc, cr, i, j, k, comp);
-                    const amrex::Real Bz_cc = CoarsenIO::Interp(Bz_arr, Bz_stag, cc, cr, i, j, k, comp);
+                    const amrex::Real Bx_cc = ablastr::coarsen::sample::Interp(Bx_arr, Bx_stag, cc, cr, i, j, k, comp);
+                    const amrex::Real By_cc = ablastr::coarsen::sample::Interp(By_arr, By_stag, cc, cr, i, j, k, comp);
+                    const amrex::Real Bz_cc = ablastr::coarsen::sample::Interp(Bz_arr, Bz_stag, cc, cr, i, j, k, comp);
 
                     return {Ey_cc * Bz_cc - Ez_cc * By_cc,
                             Ez_cc * Bx_cc - Ex_cc * Bz_cc,

diff --git a/Source/Diagnostics/ReducedDiags/FieldProbeParticleContainer.cpp b/Source/Diagnostics/ReducedDiags/FieldProbeParticleContainer.cpp
@@ -12,7 +12,6 @@
 #include "Particles/Pusher/GetAndSetPosition.H"
 #include "Particles/Pusher/UpdatePosition.H"
 #include "Particles/ParticleBoundaries_K.H"
-#include "Utils/CoarsenMR.H"
 #include "Utils/TextMsg.H"
 #include "Utils/WarpXAlgorithmSelection.H"
 #include "Utils/WarpXConst.H"