Block-Structured AMR Software Framework
Loading...
Searching...
No Matches
AMReX_MLLinOp.H
Go to the documentation of this file.
1#ifndef AMREX_ML_LINOP_H_
2#define AMREX_ML_LINOP_H_
3#include <AMReX_Config.H>
4
5#if defined(AMREX_USE_HYPRE) && (AMREX_SPACEDIM > 1)
6#include <AMReX_Hypre.H>
8#endif
9
10#if defined(AMREX_USE_PETSC) && (AMREX_SPACEDIM > 1)
11#include <AMReX_PETSc.H>
12#endif
13
14#ifdef AMREX_USE_EB
16#include <AMReX_MultiCutFab.H>
17#endif
18
19#include <AMReX_Any.H>
20#include <AMReX_BndryRegister.H>
21#include <AMReX_FabDataType.H>
22#include <AMReX_MLMGBndry.H>
23#include <AMReX_MLAlgMG.H>
24#include <AMReX_MultiFab.H>
25#include <AMReX_MultiFabUtil.H>
26
27#include <algorithm>
28#include <iterator>
29#include <typeinfo>
30#include <limits>
31#include <string>
32
33namespace amrex {
34
42
46
53struct LPInfo
54{
55 bool do_agglomeration = true;
56 bool do_consolidation = true;
57 bool do_semicoarsening = false;
58 int agg_grid_size = -1;
59 int con_grid_size = -1;
60 int con_ratio = 2;
61 int con_strategy = 3;
62 bool has_metric_term = true;
67 bool deterministic = false;
68 bool mixed_precision = false;
69
71 LPInfo& setAgglomeration (bool x) noexcept { do_agglomeration = x; return *this; }
73 LPInfo& setConsolidation (bool x) noexcept { do_consolidation = x; return *this; }
75 LPInfo& setSemicoarsening (bool x) noexcept { do_semicoarsening = x; return *this; }
77 LPInfo& setAgglomerationGridSize (int x) noexcept { agg_grid_size = x; return *this; }
79 LPInfo& setConsolidationGridSize (int x) noexcept { con_grid_size = x; return *this; }
81 LPInfo& setConsolidationRatio (int x) noexcept { con_ratio = x; return *this; }
83 LPInfo& setConsolidationStrategy (int x) noexcept { con_strategy = x; return *this; }
85 LPInfo& setMetricTerm (bool x) noexcept { has_metric_term = x; return *this; }
87 LPInfo& setMaxCoarseningLevel (int n) noexcept { max_coarsening_level = n; return *this; }
89 LPInfo& setMaxSemicoarseningLevel (int n) noexcept { max_semicoarsening_level = n; return *this; }
91 LPInfo& setSemicoarseningDirection (int n) noexcept { semicoarsening_direction = n; return *this; }
93 LPInfo& setHiddenDirection (int n) noexcept { hidden_direction = n; return *this; }
96 LPInfo& setDeterministic (bool x) noexcept { deterministic = x; return *this; }
99 LPInfo& setMixedPrecision (bool x) noexcept { mixed_precision = x; return *this; }
100
102 [[nodiscard]] bool hasHiddenDimension () const noexcept {
103 return hidden_direction >=0 && hidden_direction < AMREX_SPACEDIM;
104 }
105
106 static constexpr int getDefaultAgglomerationGridSize () {
107#ifdef AMREX_USE_GPU
108 return 32;
109#else
110 return AMREX_D_PICK(32, 16, 8);
111#endif
112 }
113
114 static constexpr int getDefaultConsolidationGridSize () {
115#ifdef AMREX_USE_GPU
116 return 32;
117#else
118 return AMREX_D_PICK(32, 16, 8);
119#endif
120 }
121};
122
129
130template <typename T> class MLMGT;
131template <typename T> class MLCGSolverT;
132template <typename T> class MLPoissonT;
133template <typename T> class MLABecLaplacianT;
134template <typename T> class GMRESMLMGT;
135
136// Defined if the single precision operators and solver used by mixed
137// precision are compiled (in AMReX_MLMG_float.cpp and in the source files
138// of the other operators that support mixed precision). nvcc on Windows
139// cannot compile the EB code of MLCellLinOp for float (see the if constexpr
140// workarounds there).
141#if !defined(AMREX_USE_FLOAT) && !(defined(AMREX_USE_CUDA) && defined(_WIN32) && defined(AMREX_USE_EB))
142#define AMREX_MLMG_HAS_FLOAT 1
143#endif
144
146
152class HypreMLNodeLap;
153
154template <typename MF>
156{
157public:
158
159 template <typename T> friend class MLLinOpT;
160 template <typename T> friend class MLMGT;
161 template <typename T> friend class MLCGSolverT;
162 template <typename T> friend class MLPoissonT;
163 template <typename T> friend class MLABecLaplacianT;
164 template <typename T> friend class GMRESMLMGT;
165 friend class HypreMLNodeLap;
166
167 using MFType = MF;
170
175
176 MLLinOpT () = default;
177 virtual ~MLLinOpT () = default;
178
179 MLLinOpT (const MLLinOpT<MF>&) = delete;
180 MLLinOpT (MLLinOpT<MF>&&) = delete;
183
195 void define (const Vector<Geometry>& a_geom,
196 const Vector<BoxArray>& a_grids,
197 const Vector<DistributionMapping>& a_dmap,
198 const LPInfo& a_info,
199 const Vector<FabFactory<FAB> const*>& a_factory,
200 bool eb_limit_coarsening = true);
201
202 [[nodiscard]] virtual std::string name () const { return std::string("Unspecified"); }
203
215 const Array<BCType,AMREX_SPACEDIM>& hibc) noexcept;
216
228
240 const Array<Real,AMREX_SPACEDIM>& hi_bcloc) noexcept;
241
249 [[nodiscard]] bool needsCoarseDataForBC () const noexcept { return m_needs_coarse_data_for_bc; }
250
272 void setCoarseFineBC (const MF* crse, int crse_ratio,
273 LinOpBCType bc_type = LinOpBCType::Dirichlet) noexcept;
274
275 void setCoarseFineBC (const MF* crse, IntVect const& crse_ratio,
276 LinOpBCType bc_type = LinOpBCType::Dirichlet) noexcept;
277
278 template <typename AMF>
279 requires (!std::same_as<MF,AMF>)
280 void setCoarseFineBC (const AMF* crse, int crse_ratio,
281 LinOpBCType bc_type = LinOpBCType::Dirichlet) noexcept;
282
283 template <typename AMF>
284 requires (!std::same_as<MF,AMF>)
285 void setCoarseFineBC (const AMF* crse, IntVect const& crse_ratio,
286 LinOpBCType bc_type = LinOpBCType::Dirichlet) noexcept;
287
288
307 virtual void setLevelBC (int /*amrlev*/, const MF* /*levelbcdata*/,
308 const MF* /*robinbc_a*/ = nullptr,
309 const MF* /*robinbc_b*/ = nullptr,
310 const MF* /*robinbc_f*/ = nullptr) = 0;
311
312 template <MultiFabLike AMF>
313 requires (!std::same_as<MF,AMF>)
314 void setLevelBC (int amrlev, const AMF* levelbcdata,
315 const AMF* robinbc_a = nullptr,
316 const AMF* robinbc_b = nullptr,
317 const AMF* robinbc_f = nullptr);
318
324 void setVerbose (int v) noexcept {
325 verbose = v;
326 if (m_sp_linop) { m_sp_linop->setVerbose(v); }
327 }
328
334 void setPrintIndentation (std::string s) { print_ident = std::move(s); }
335
341 void setMaxOrder (int o) noexcept {
342 maxorder = o;
343 if (m_sp_linop) { m_sp_linop->setMaxOrder(o); }
344 }
345
346 [[nodiscard]] int getMaxOrder () const noexcept { return maxorder; }
347
353 void setEnforceSingularSolvable (bool o) noexcept {
355 if (m_sp_linop) { m_sp_linop->setEnforceSingularSolvable(o); }
356 }
357
359 [[nodiscard]] bool getEnforceSingularSolvable () const noexcept { return enforceSingularSolvable; }
360
361 [[nodiscard]] virtual BottomSolver getDefaultBottomSolver () const { return BottomSolver::bicgstab; }
362
364 [[nodiscard]] virtual bool supportCustomBottomSolver () const { return false; }
365
377 virtual void customBottomSolve (MLMGT<MF>* mlmg, MF& x, const MF& b,
378 RT eps_rel, RT eps_abs, int maxiter)
379 {
380 amrex::ignore_unused(mlmg, x, b, eps_rel, eps_abs, maxiter);
381 amrex::Abort("customBottomSolve not implemented");
382 }
383
385 [[nodiscard]] virtual int getNComp () const { return 1; }
386
387 [[nodiscard]] virtual int getNGrow (int /*a_lev*/ = 0, int /*mg_lev*/ = 0) const { return 0; }
388
390 [[nodiscard]] virtual bool needsUpdate () const { return false; }
392 virtual void update () {}
393
403 virtual void restriction (int amrlev, int cmglev, MF& crse, MF& fine) const = 0;
404
413 virtual void interpolation (int amrlev, int fmglev, MF& fine, const MF& crse) const = 0;
414
423 virtual void interpAssign (int amrlev, int fmglev, MF& fine, MF& crse) const
424 {
425 amrex::ignore_unused(amrlev, fmglev, fine, crse);
426 amrex::Abort("MLLinOpT::interpAssign: Must be implemented for FMG cycle");
427 }
428
437 virtual void interpolationAmr (int famrlev, MF& fine, const MF& crse,
438 IntVect const& nghost) const
439 {
440 amrex::ignore_unused(famrlev, fine, crse, nghost);
441 amrex::Abort("MLLinOpT::interpolationAmr: Must be implemented for composite solves across multiple AMR levels");
442 }
443
455 virtual void interpCoarseFineSolution (int famrlev, MF& fine_sol, const MF& crse_sol) const
456 {
457 amrex::ignore_unused(famrlev, fine_sol, crse_sol);
458 }
459
469 virtual void averageDownSolutionRHS (int camrlev, MF& crse_sol, MF& crse_rhs,
470 const MF& fine_sol, const MF& fine_rhs)
471 {
472 amrex::ignore_unused(camrlev, crse_sol, crse_rhs, fine_sol, fine_rhs);
473 amrex::Abort("MLLinOpT::averageDownSolutionRHS: Must be implemented for composite solves across multiple AMR levels");
474 }
475
487 virtual void apply (int amrlev, int mglev, MF& out, MF& in, BCMode bc_mode,
488 StateMode s_mode, const MLMGBndryT<MF>* bndry=nullptr) const = 0;
489
500 virtual void smooth (int amrlev, int mglev, MF& sol, const MF& rhs,
501 bool skip_fillboundary, int niter) const = 0;
502
510 virtual void normalize (int amrlev, int mglev, MF& mf) const {
511 amrex::ignore_unused(amrlev, mglev, mf);
512 }
513
523 virtual void solutionResidual (int amrlev, MF& resid, MF& x, const MF& b,
524 const MF* crse_bcdata=nullptr) = 0;
525
532 virtual void prepareForFluxes (int amrlev, const MF* crse_bcdata = nullptr) {
533 amrex::ignore_unused(amrlev, crse_bcdata);
534 }
535
547 virtual void correctionResidual (int amrlev, int mglev, MF& resid, MF& x, const MF& b,
548 BCMode bc_mode, const MF* crse_bcdata=nullptr) = 0;
549
561 virtual void reflux (int crse_amrlev,
562 MF& res, const MF& crse_sol, const MF& crse_rhs,
563 MF& fine_res, MF& fine_sol, const MF& fine_rhs) const
564 {
565 amrex::ignore_unused(crse_amrlev, res, crse_sol, crse_rhs, fine_res,
566 fine_sol, fine_rhs);
567 amrex::Abort("MLLinOpT::reflux: Must be implemented for composite solves across multiple AMR levels");
568 }
569
578 virtual void compFlux (int amrlev, const Array<MF*,AMREX_SPACEDIM>& fluxes,
579 MF& sol, Location loc) const
580 {
581 amrex::ignore_unused(amrlev, fluxes, sol, loc);
582 amrex::Abort("AMReX_MLLinOp::compFlux::How did we get here?");
583 }
584
593 virtual void compGrad (int amrlev, const Array<MF*,AMREX_SPACEDIM>& grad,
594 MF& sol, Location loc) const
595 {
596 amrex::ignore_unused(amrlev, grad, sol, loc);
597 amrex::Abort("AMReX_MLLinOp::compGrad::How did we get here?");
598 }
599
607 virtual void applyMetricTerm (int amrlev, int mglev, MF& rhs) const {
608 amrex::ignore_unused(amrlev, mglev, rhs);
609 }
610
617 virtual void unapplyMetricTerm (int amrlev, int mglev, MF& rhs) const {
618 amrex::ignore_unused(amrlev, mglev, rhs);
619 }
620
627 virtual void unimposeNeumannBC (int amrlev, MF& rhs) const {
628 amrex::ignore_unused(amrlev, rhs);
629 }
630
637 virtual void applyInhomogNeumannTerm (int amrlev, MF& rhs) const {
638 amrex::ignore_unused(amrlev, rhs);
639 }
640
647 virtual void applyOverset (int amrlev, MF& rhs) const {
648 amrex::ignore_unused(amrlev, rhs);
649 }
650
658 [[nodiscard]] virtual bool scaleRHS (int amrlev, MF* rhs) const {
659 amrex::ignore_unused(amrlev, rhs);
660 return false;
661 }
662
671 virtual Vector<RT> getSolvabilityOffset (int amrlev, int mglev,
672 MF const& rhs) const {
673 amrex::ignore_unused(amrlev, mglev, rhs);
674 return {};
675 }
676
685 virtual void fixSolvabilityByOffset (int amrlev, int mglev, MF& rhs,
686 Vector<RT> const& offset) const {
687 amrex::ignore_unused(amrlev, mglev, rhs, offset);
688 }
689
693 virtual void prepareForSolve () = 0;
694
699 virtual void preparePrecond () {}
700
709 virtual void setDirichletNodesToZero (int amrlev, int mglev,
710 MF& mf) const
711 {
712 amrex::ignore_unused(amrlev, mglev, mf);
713 amrex::Warning("This function might need to be implemented for GMRES to work with this LinOp.");
714 }
715
717 [[nodiscard]] virtual bool isSingular (int amrlev) const = 0;
719 [[nodiscard]] virtual bool isBottomSingular () const = 0;
720
730 virtual RT xdoty (int amrlev, int mglev, const MF& x, const MF& y, bool local) const = 0;
731
741
749 virtual RT norm2Precond (Vector<MF const*> const& x) const;
750
756 virtual std::unique_ptr<MLLinOpT<MF>> makeNLinOp (int grid_size) const
757 {
758 amrex::ignore_unused(grid_size);
759 amrex::Abort("MLLinOp::makeNLinOp: NSolve not supported");
760 return nullptr;
761 }
762
770 virtual void getFluxes (const Vector<Array<MF*,AMREX_SPACEDIM> >& a_flux,
771 const Vector<MF*>& a_sol,
772 Location a_loc) const {
773 amrex::ignore_unused(a_flux, a_sol, a_loc);
774 amrex::Abort("MLLinOp::getFluxes: How did we get here?");
775 }
776
782 virtual void getFluxes (const Vector<MF*>& a_flux,
783 const Vector<MF*>& a_sol) const {
784 amrex::ignore_unused(a_flux, a_sol);
785 amrex::Abort("MLLinOp::getFluxes: How did we get here?");
786 }
787
788#ifdef AMREX_USE_EB
795 virtual void getEBFluxes (const Vector<MF*>& a_flux,
796 const Vector<MF*>& a_sol) const {
797 amrex::ignore_unused(a_flux, a_sol);
798 amrex::Abort("MLLinOp::getEBFluxes: How did we get here?");
799 }
800#endif
801
806 [[nodiscard]] virtual std::unique_ptr<MLAlgMG> makeAlgMG (int mglev) const {
808 amrex::Abort("MLLinOp::makeAlgMG: not supported by this operator");
809 return {nullptr};
810 }
811
813 [[nodiscard]] virtual bool supportsAlgMG () const { return false; }
814
823 [[nodiscard]] virtual bool supportsAnisotropicCoarsening () const { return false; }
824
830 [[nodiscard]] virtual GpuArray<Real,AMREX_SPACEDIM>
831 anisotropicCoarseningCellSize (Geometry const& geom) const { return geom.CellSizeArray(); }
832
833#if defined(AMREX_USE_HYPRE) && (AMREX_SPACEDIM > 1)
839 [[nodiscard]] virtual std::unique_ptr<Hypre> makeHypre (Hypre::Interface hypre_interface) const {
840 amrex::ignore_unused(hypre_interface);
841 amrex::Abort("MLLinOp::makeHypre: How did we get here?");
842 return {nullptr};
843 }
850 [[nodiscard]] virtual std::unique_ptr<HypreNodeLap> makeHypreNodeLap(
851 int bottom_verbose,
852 const std::string& options_namespace) const
853 {
854 amrex::ignore_unused(bottom_verbose, options_namespace);
855 amrex::Abort("MLLinOp::makeHypreNodeLap: How did we get here?");
856 return {nullptr};
857 }
858#endif
859
860#if defined(AMREX_USE_PETSC) && (AMREX_SPACEDIM > 1)
864 [[nodiscard]] virtual std::unique_ptr<PETScABecLap> makePETSc () const {
865 amrex::Abort("MLLinOp::makePETSc: How did we get here?");
866 return {nullptr};
867 }
868#endif
869
873 [[nodiscard]] virtual bool supportNSolve () const { return false; }
874
877 [[nodiscard]] virtual bool supportsMixedPrecision () const { return false; }
878
880 [[nodiscard]] bool isMixedPrecision () const noexcept { return m_sp_linop != nullptr; }
881
888 virtual void copyNSolveSolution (MF& dst, MF const& src) const {
889 amrex::ignore_unused(dst, src);
890 }
891
897 virtual void postSolve (Vector<MF*> const& sol) const {
899 }
900
908 [[nodiscard]] virtual RT normInf (int amrlev, MF const& mf, bool local) const = 0;
909
915 virtual void averageDownAndSync (Vector<MF>& sol) const = 0;
916
917 virtual void avgDownResAmr (int clev, MF& cres, MF const& fres) const
918 {
919 amrex::ignore_unused(clev, cres, fres);
920 amrex::Abort("MLLinOpT::avgDownResAmr: Must be implemented for composite solves across multiple AMR levels");
921 }
922
930 virtual void avgDownResMG (int clev, MF& cres, MF const& fres) const;
931
935 virtual void beginPrecondBC () { m_precond_mode = true; }
939 virtual void endPrecondBC () { m_precond_mode = false; }
940
948 [[nodiscard]] bool isMFIterSafe (int amrlev, int mglev1, int mglev2) const;
949
951 [[nodiscard]] int NAMRLevels () const noexcept { return m_num_amr_levels; }
952
959 [[nodiscard]] int NMGLevels (int amrlev) const noexcept { return m_num_mg_levels[amrlev]; }
960
962 [[nodiscard]] const Geometry& Geom (int amr_lev, int mglev=0) const noexcept { return m_geom[amr_lev][mglev]; }
963
964 // BC
967 // Need to save the original copy because we change the BC type to
968 // Neumann for inhomogeneous Neumann and Robin.
971
972protected:
973
974 static constexpr int mg_coarsen_ratio = 2;
977 int mg_agg_no_split_direction = -1; // keep agglomerated grids whole in it
978 bool mg_odd_coarsening = false; // coarsen by 3 or 5 where 2 does not fit
979 bool mg_independent_coarsening = false; // coarsen directions on their own
980
982
983 int verbose = 0;
984 std::string print_ident;
985
986 int maxorder = 3;
987
989 bool m_mg_deferred = false;
990 bool m_mg_built = false;
991
994
996 const MLLinOpT<MF>* m_parent = nullptr;
997
999
1002
1005
1012
1016 struct CommContainer {
1017 MPI_Comm comm;
1018 CommContainer (MPI_Comm m) noexcept : comm(m) {}
1019 CommContainer (const CommContainer&) = delete;
1020 CommContainer (CommContainer&&) = delete;
1021 void operator= (const CommContainer&) = delete;
1022 void operator= (CommContainer&&) = delete;
1023 ~CommContainer () { // NOLINT(modernize-use-equals-default)
1024#ifdef BL_USE_MPI
1025 if (comm != MPI_COMM_NULL) { MPI_Comm_free(&comm); }
1026#endif
1027 }
1028 };
1030 std::unique_ptr<CommContainer> m_raii_comm;
1031
1034
1039 const MF* m_coarse_data_for_bc = nullptr;
1041
1042 bool m_precond_mode = false;
1043
1047 static constexpr bool mixed_precision_capable =
1048 std::is_same_v<MF,MultiFab>
1049#ifndef AMREX_MLMG_HAS_FLOAT
1050 && false
1051#endif
1052 ;
1053 std::unique_ptr<MLLinOpT<fMultiFab>> m_sp_linop;
1057
1066
1068 static RT spScaleFor (RT x) noexcept {
1069 int e = 0;
1070 if (x > RT(0.0) && std::isfinite(x)) { std::frexp(x, &e); }
1071 return std::ldexp(RT(1.0), -e);
1072 }
1073
1077 static RT spDiagForScale (Vector<RT> const& diag) noexcept {
1078 RT dmin = std::numeric_limits<RT>::max();
1079 RT dmax = RT(0.0);
1080 for (auto d : diag) {
1081 if (d > RT(0.0)) {
1082 dmin = std::min(dmin, d);
1083 dmax = std::max(dmax, d);
1084 }
1085 }
1086 return (dmin < dmax) ? std::sqrt(dmin)*std::sqrt(dmax) : dmax;
1087 }
1088
1091 [[nodiscard]] int spMetricExponent () const noexcept {
1092 if (!m_geom[0][0].IsCartesian() && info.has_metric_term) {
1093 return (AMREX_SPACEDIM == 1) ? 2 : 1;
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1103 {
1104 Real dxmin = std::numeric_limits<Real>::max();
1105 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1106 if (idim != info.hidden_direction) {
1107 dxmin = std::min(dxmin, a_geom.back().CellSize(idim));
1108 }
1109 }
1110 m_sp_length_scale = static_cast<Real>(spScaleFor(static_cast<RT>(dxmin)));
1111 // L ~ 1/dx^2 times the metric term
1112 m_sp_scale = static_cast<RT>(std::pow(m_sp_length_scale, spMetricExponent()-2));
1113 Vector<Geometry> sp_geom;
1114 sp_geom.reserve(a_geom.size());
1115 for (auto const& g : a_geom) {
1117 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1118 lo[idim] = g.ProbLo(idim) * m_sp_length_scale;
1119 hi[idim] = g.ProbHi(idim) * m_sp_length_scale;
1120 }
1121 sp_geom.emplace_back(g.Domain(), RealBox(lo, hi), g.Coord(), g.isPeriodic());
1122 }
1123 return sp_geom;
1124 }
1125
1128 [[nodiscard]] LPInfo dpInfo (LPInfo const& a_info) const
1129 {
1130 LPInfo dp_info = a_info;
1131 if constexpr (mixed_precision_capable) {
1132 if (a_info.mixed_precision) {
1133 dp_info.max_coarsening_level = 0;
1134 }
1135 }
1136 return dp_info;
1137 }
1138
1144 template <typename F>
1145 void makeSPLinOp (LPInfo const& a_info, F const& f)
1146 {
1147 if constexpr (mixed_precision_capable) {
1148 m_sp_linop.reset(); // a re-define may turn mixed precision off
1149 m_sp_scale = RT(1.0);
1150 m_sp_length_scale = Real(1.0);
1151 if (a_info.mixed_precision) {
1152 LPInfo sp_info = a_info;
1153 sp_info.mixed_precision = false;
1154 m_sp_linop = f(sp_info);
1157 }
1158 } else {
1159 amrex::ignore_unused(a_info, f);
1160 }
1161 }
1162
1165 virtual void spCopySettings ()
1166 {
1167 if constexpr (mixed_precision_capable) {
1168 auto* sp = m_sp_linop.get();
1169 sp->setVerbose(verbose);
1170 sp->setMaxOrder(maxorder);
1171 sp->setEnforceSingularSolvable(enforceSingularSolvable);
1172 if (!m_lobc.empty()) { sp->setDomainBC(m_lobc, m_hibc); }
1175 if (m_coarse_data_crse_ratio.allGT(0)) {
1176 sp->setCoarseFineBC(static_cast<fMultiFab const*>(nullptr),
1178 }
1179 }
1180 }
1181
1184 template <template <typename> class Op, typename F>
1185 void spForward (F const& f)
1186 {
1187 if constexpr (mixed_precision_capable) {
1188 if (m_sp_linop) {
1189 f(static_cast<Op<fMultiFab>*>(m_sp_linop.get()));
1190 }
1191 } else {
1193 }
1194 }
1195
1197 [[nodiscard]] const Vector<int>& AMRRefRatio () const noexcept { return m_amr_ref_ratio; }
1198
1200 [[nodiscard]] int AMRRefRatio (int amr_lev) const noexcept { return m_amr_ref_ratio[amr_lev]; }
1201
1203 [[nodiscard]] IntVect AMRRefRatioVect (int amr_lev) const noexcept {
1204 IntVect rr(m_amr_ref_ratio[amr_lev]);
1205 if (info.hasHiddenDimension()) { rr[info.hidden_direction] = 1; }
1206 return rr;
1207 }
1208
1209 [[nodiscard]] FabFactory<FAB> const* Factory (int amr_lev, int mglev=0) const noexcept {
1210 return m_factory[amr_lev][mglev].get();
1211 }
1212
1213 [[nodiscard]] GpuArray<BCType,AMREX_SPACEDIM> LoBC (int icomp = 0) const noexcept {
1215 m_lobc[icomp][1],
1216 m_lobc[icomp][2])}};
1217 }
1218 [[nodiscard]] GpuArray<BCType,AMREX_SPACEDIM> HiBC (int icomp = 0) const noexcept {
1220 m_hibc[icomp][1],
1221 m_hibc[icomp][2])}};
1222 }
1223
1224 [[nodiscard]] bool hasBC (BCType bct) const noexcept;
1225 [[nodiscard]] bool hasInhomogNeumannBC () const noexcept;
1226 [[nodiscard]] bool hasRobinBC () const noexcept;
1227
1228 [[nodiscard]] virtual bool supportRobinBC () const noexcept { return false; }
1229 [[nodiscard]] virtual bool supportInhomogNeumannBC () const noexcept { return false; }
1230
1231#ifdef BL_USE_MPI
1232 [[nodiscard]] bool isBottomActive () const noexcept { return m_bottom_comm != MPI_COMM_NULL; }
1233#else
1234 [[nodiscard]] bool isBottomActive () const noexcept { return true; }
1235#endif
1236 [[nodiscard]] MPI_Comm BottomCommunicator () const noexcept { return m_bottom_comm; }
1237 [[nodiscard]] MPI_Comm Communicator () const noexcept { return m_default_comm; }
1238
1239 void setCoarseFineBCLocation (const RealVect& cloc) noexcept {
1240 m_coarse_bc_loc = cloc;
1241 if (m_sp_linop) { m_sp_linop->setCoarseFineBCLocation(cloc*m_sp_length_scale); }
1242 }
1243
1244 [[nodiscard]] bool doAgglomeration () const noexcept { return m_do_agglomeration; }
1245 [[nodiscard]] bool doConsolidation () const noexcept { return m_do_consolidation; }
1246 [[nodiscard]] bool doSemicoarsening () const noexcept { return m_do_semicoarsening; }
1247
1248 [[nodiscard]] bool isCellCentered () const noexcept { return m_ixtype == 0; }
1249
1250 [[nodiscard]] virtual IntVect getNGrowVectRestriction () const {
1251 return isCellCentered() ? IntVect(0) : IntVect(1);
1252 }
1253
1254 virtual void make (Vector<Vector<MF> >& mf, IntVect const& ng) const;
1255
1256 [[nodiscard]] virtual MF make (int amrlev, int mglev, IntVect const& ng) const;
1257
1259 [[nodiscard]] virtual MF make (int amrlev, int mglev, IntVect const& ng,
1260 MFInfo const& mf_info) const;
1261
1262 [[nodiscard]] virtual MF makeAlias (MF const& mf) const;
1263
1265 [[nodiscard]] virtual MF makeCoarseMG (int amrlev, int mglev, IntVect const& ng) const;
1266
1268 [[nodiscard]] virtual MF makeCoarseMG (int amrlev, int mglev, IntVect const& ng,
1269 MFInfo const& mf_info) const;
1270
1272 [[nodiscard]] virtual MF makeCoarseAmr (int famrlev, IntVect const& ng) const;
1273
1275 [[nodiscard]] virtual MF makeCoarseAmr (int famrlev, IntVect const& ng,
1276 MFInfo const& mf_info) const;
1277
1278 [[nodiscard]] virtual std::unique_ptr<FabFactory<FAB> > makeFactory (int /*amrlev*/, int /*mglev*/) const {
1279 return std::make_unique<DefaultFabFactory<FAB>>();
1280 }
1281
1282 virtual void resizeMultiGrid (int new_size);
1283
1286
1288 virtual void buildMGHierarchy () {
1289 BL_PROFILE("MLLinOp::buildMGHierarchy()");
1290 defineCoarseMGLevels();
1291 }
1292
1293 [[nodiscard]] bool hasHiddenDimension () const noexcept { return info.hasHiddenDimension(); }
1294 [[nodiscard]] int hiddenDirection () const noexcept { return info.hidden_direction; }
1295 [[nodiscard]] Box compactify (Box const& b) const noexcept;
1296
1297 template <typename T>
1298 [[nodiscard]] Array4<T> compactify (Array4<T> const& a) const noexcept
1299 {
1300 if (info.hidden_direction == 0) {
1301 return Array4<T>(a.dataPtr(), {a.begin[1],a.begin[2],0}, {a.end[1],a.end[2],1}, a.nComp());
1302 } else if (info.hidden_direction == 1) {
1303 return Array4<T>(a.dataPtr(), {a.begin[0],a.begin[2],0}, {a.end[0],a.end[2],1}, a.nComp());
1304 } else if (info.hidden_direction == 2) {
1305 return Array4<T>(a.dataPtr(), {a.begin[0],a.begin[1],0}, {a.end[0],a.end[1],1}, a.nComp());
1306 } else {
1307 return a;
1308 }
1309 }
1310
1311 template <typename T>
1312 [[nodiscard]] T get_d0 (T const& dx, T const& dy, T const&) const noexcept
1313 {
1314 if (info.hidden_direction == 0) {
1315 return dy;
1316 } else {
1317 return dx;
1318 }
1319 }
1320
1321 template <typename T>
1322 [[nodiscard]] T get_d1 (T const&, T const& dy, T const& dz) const noexcept
1323 {
1324 if (info.hidden_direction == 0 || info.hidden_direction == 1) {
1325 return dz;
1326 } else {
1327 return dy;
1328 }
1329 }
1330
1331private:
1332
1333 void defineGrids (const Vector<Geometry>& a_geom,
1334 const Vector<BoxArray>& a_grids,
1335 const Vector<DistributionMapping>& a_dmap,
1336 const Vector<FabFactory<FAB> const*>& a_factory);
1337 void defineBC ();
1338 void defineCoarseMGLevels ();
1339 static void makeAgglomeratedDMap (const Vector<BoxArray>& ba, Vector<DistributionMapping>& dm);
1340 static void makeConsolidatedDMap (const Vector<BoxArray>& ba, Vector<DistributionMapping>& dm,
1341 int ratio, int strategy);
1342 [[nodiscard]] MPI_Comm makeSubCommunicator (const DistributionMapping& dm);
1343
1344 virtual void checkPoint (std::string const& /*file_name*/) const {
1345 amrex::Abort("MLLinOp:checkPoint: not implemented");
1346 }
1347
1348 Vector<std::unique_ptr<MF>> levelbc_raii;
1349 Vector<std::unique_ptr<MF>> robin_a_raii;
1350 Vector<std::unique_ptr<MF>> robin_b_raii;
1351 Vector<std::unique_ptr<MF>> robin_f_raii;
1352};
1353
1354template <typename MF>
1355void
1357 const Vector<BoxArray>& a_grids,
1358 const Vector<DistributionMapping>& a_dmap,
1359 const LPInfo& a_info,
1360 const Vector<FabFactory<FAB> const*>& a_factory,
1361 [[maybe_unused]] bool eb_limit_coarsening)
1362{
1363 BL_PROFILE("MLLinOp::define()");
1364
1365 info = a_info;
1366#ifdef AMREX_USE_GPU
1368 {
1369 if (info.agg_grid_size <= 0) { info.agg_grid_size = AMREX_D_PICK(32, 16, 8); }
1370 if (info.con_grid_size <= 0) { info.con_grid_size = AMREX_D_PICK(32, 16, 8); }
1371 }
1372 else
1373#endif
1374 {
1375 if (info.agg_grid_size <= 0) { info.agg_grid_size = LPInfo::getDefaultAgglomerationGridSize(); }
1376 if (info.con_grid_size <= 0) { info.con_grid_size = LPInfo::getDefaultConsolidationGridSize(); }
1377 }
1378
1379#ifdef AMREX_USE_EB
1380 if (!a_factory.empty() && eb_limit_coarsening) {
1381 const auto *f = dynamic_cast<EBFArrayBoxFactory const*>(a_factory[0]);
1382 if (f) {
1383 info.max_coarsening_level = std::min(info.max_coarsening_level,
1384 f->maxCoarseningLevel());
1385 }
1386 }
1387#endif
1388 if (info.mixed_precision) {
1389 if constexpr (mixed_precision_capable) {
1390 // Sees the type of the class whose constructor calls define; a
1391 // class that only delegates to a base constructor is caught in
1392 // MLMG::solve.
1394 "MLLinOp: this operator does not support mixed precision");
1395#ifdef AMREX_USE_EB
1396 for (auto const* f : a_factory) {
1397 auto const* ebf = dynamic_cast<EBFArrayBoxFactory const*>(f);
1398 AMREX_ALWAYS_ASSERT_WITH_MESSAGE(ebf == nullptr || ebf->isAllRegular(),
1399 "MLLinOp: mixed precision does not support EB");
1400 }
1401#endif
1402 } else {
1403 info.mixed_precision = false; // Real is float or MF is not MultiFab
1404 }
1405 }
1407 m_mg_built = false;
1408 defineGrids(a_geom, a_grids, a_dmap, a_factory);
1409 defineBC();
1410}
1411
1412template <typename MF>
1413void
1414MLLinOpT<MF>::defineGrids (const Vector<Geometry>& a_geom,
1415 const Vector<BoxArray>& a_grids,
1416 const Vector<DistributionMapping>& a_dmap,
1417 const Vector<FabFactory<FAB> const*>& a_factory)
1418{
1419 BL_PROFILE("MLLinOp::defineGrids()");
1420
1421#ifdef AMREX_USE_EB
1422 if ( ! a_factory.empty() ) {
1423 auto const* ebf = dynamic_cast<EBFArrayBoxFactory const*>(a_factory[0]);
1424 if (ebf && !(ebf->isAllRegular())) { // Has non-trivial EB
1425 mg_domain_min_width = 4;
1426 }
1427 }
1428#endif
1429
1430 m_num_amr_levels = 0;
1431 for (int amrlev = 0; amrlev < std::ssize(a_geom); amrlev++) {
1432 if (!a_grids[amrlev].empty()) {
1433 m_num_amr_levels++;
1434 }
1435 }
1436
1437 m_amr_ref_ratio.resize(m_num_amr_levels);
1438 m_num_mg_levels.resize(m_num_amr_levels);
1439
1440 m_geom.clear();
1441 m_grids.clear();
1442 m_dmap.clear();
1443 m_factory.clear();
1444 m_domain_covered.clear();
1445 mg_coarsen_ratio_vec.clear();
1446
1447 m_geom.resize(m_num_amr_levels);
1448 m_grids.resize(m_num_amr_levels);
1449 m_dmap.resize(m_num_amr_levels);
1450 m_factory.resize(m_num_amr_levels);
1451
1452 m_default_comm = ParallelContext::CommunicatorSub();
1453
1454 const RealBox& rb = a_geom[0].ProbDomain();
1455 const int coord = a_geom[0].Coord();
1456 const Array<int,AMREX_SPACEDIM>& is_per = a_geom[0].isPeriodic();
1457
1458 IntVect mg_coarsen_ratio_v(mg_coarsen_ratio);
1459 if (hasHiddenDimension()) {
1460 AMREX_ASSERT_WITH_MESSAGE(AMREX_SPACEDIM == 3,
1461 "Hidden direction only supported for 3d");
1462 mg_coarsen_ratio_v[info.hidden_direction] = 1;
1463 }
1464
1465 // fine amr levels
1466 for (int amrlev = m_num_amr_levels-1; amrlev > 0; --amrlev)
1467 {
1468 m_num_mg_levels[amrlev] = 1;
1469 m_geom[amrlev].push_back(a_geom[amrlev]);
1470 m_grids[amrlev].push_back(a_grids[amrlev]);
1471 m_dmap[amrlev].push_back(a_dmap[amrlev]);
1472 if (amrlev < std::ssize(a_factory)) {
1473 m_factory[amrlev].emplace_back(a_factory[amrlev]->clone());
1474 } else {
1475 m_factory[amrlev].push_back(std::make_unique<DefaultFabFactory<FAB>>());
1476 }
1477
1478 IntVect rr = mg_coarsen_ratio_v;
1479 const Box& dom = a_geom[amrlev].Domain();
1480 for (int i = 0; i < 2; ++i)
1481 {
1482 if (!dom.coarsenable(rr)) { amrex::Abort("MLLinOp: Uncoarsenable domain"); }
1483
1484 const Box& cdom = amrex::coarsen(dom,rr);
1485 if (cdom == a_geom[amrlev-1].Domain()) { break; }
1486
1487 ++(m_num_mg_levels[amrlev]);
1488
1489 m_geom[amrlev].emplace_back(cdom, rb, coord, is_per);
1490
1491 m_grids[amrlev].push_back(a_grids[amrlev]);
1492 AMREX_ASSERT(m_grids[amrlev].back().coarsenable(rr));
1493 m_grids[amrlev].back().coarsen(rr);
1494
1495 m_dmap[amrlev].push_back(a_dmap[amrlev]);
1496
1497 rr *= mg_coarsen_ratio_v;
1498 }
1499
1500#if (AMREX_SPACEDIM > 1)
1501 if (hasHiddenDimension()) {
1502 m_amr_ref_ratio[amrlev-1] = rr[(info.hidden_direction+1) % AMREX_SPACEDIM];
1503 } else
1504#endif
1505 {
1506 m_amr_ref_ratio[amrlev-1] = rr[0];
1507 }
1508 }
1509
1510 // coarsest amr level
1511 m_num_mg_levels[0] = 1;
1512 m_geom[0].push_back(a_geom[0]);
1513 m_grids[0].push_back(a_grids[0]);
1514 m_dmap[0].push_back(a_dmap[0]);
1515 if (!a_factory.empty()) {
1516 m_factory[0].emplace_back(a_factory[0]->clone());
1517 } else {
1518 m_factory[0].push_back(std::make_unique<DefaultFabFactory<FAB>>());
1519 }
1520
1521 m_domain_covered.resize(m_num_amr_levels, false);
1522 auto npts0 = m_grids[0][0].numPts();
1523 m_domain_covered[0] = (npts0 == compactify(m_geom[0][0].Domain()).numPts());
1524 for (int amrlev = 1; amrlev < m_num_amr_levels; ++amrlev)
1525 {
1526 if (!m_domain_covered[amrlev-1]) { break; }
1527 m_domain_covered[amrlev] = (m_grids[amrlev][0].numPts() ==
1528 compactify(m_geom[amrlev][0].Domain()).numPts());
1529 }
1530
1531 if (m_mg_deferred) {
1532 // MG levels > 0 of AMR level 0 are built by prepareMGHierarchy.
1533 m_bottom_comm = m_default_comm;
1534 m_do_agglomeration = false;
1535 m_do_consolidation = false;
1536 } else {
1537 defineCoarseMGLevels();
1538 }
1539
1540 for (int amrlev = 1; amrlev < m_num_amr_levels; ++amrlev)
1541 {
1542 for (int mglev = 1; mglev < m_num_mg_levels[amrlev]; ++mglev)
1543 {
1544 m_factory[amrlev].emplace_back(makeFactory(amrlev,mglev));
1545 }
1546 }
1547
1548 for (int amrlev = 1; amrlev < m_num_amr_levels; ++amrlev)
1549 {
1550 AMREX_ASSERT_WITH_MESSAGE(m_grids[amrlev][0].coarsenable(AMRRefRatioVect(amrlev-1)),
1551 "MLLinOp: grids not coarsenable between AMR levels");
1552 }
1553}
1554
1555template <typename MF>
1556void
1557MLLinOpT<MF>::defineCoarseMGLevels ()
1558{
1559 BL_PROFILE("MLLinOp::defineCoarseMGLevels()");
1560
1561 AMREX_ASSERT(m_grids[0].size() == 1 && mg_coarsen_ratio_vec.empty());
1562
1563 // Copies, because m_geom[0], m_grids[0] and m_dmap[0] grow below.
1564 Geometry const geom0 = m_geom[0][0];
1565 BoxArray const ba0 = m_grids[0][0];
1566 DistributionMapping const dm0 = m_dmap[0][0];
1567
1568 const RealBox& rb = geom0.ProbDomain();
1569 const int coord = geom0.Coord();
1570 const Array<int,AMREX_SPACEDIM>& is_per = geom0.isPeriodic();
1571 auto const npts0 = ba0.numPts();
1572
1573 IntVect mg_coarsen_ratio_v(mg_coarsen_ratio);
1574 IntVect mg_box_min_width_v(mg_box_min_width);
1575 IntVect mg_domain_min_width_v(mg_domain_min_width);
1576 if (hasHiddenDimension()) {
1577 mg_coarsen_ratio_v[info.hidden_direction] = 1;
1578 mg_box_min_width_v[info.hidden_direction] = 0;
1579 mg_domain_min_width_v[info.hidden_direction] = 0;
1580 }
1581
1582 Box aggbox;
1583 bool aggable = false;
1584
1585 if (ba0.size() > 1 && info.do_agglomeration)
1586 {
1587 if (m_domain_covered[0])
1588 {
1589 aggbox = geom0.Domain();
1590 if (hasHiddenDimension()) {
1591 aggbox.makeSlab(hiddenDirection(), ba0[0].smallEnd(hiddenDirection()));
1592 }
1593 aggable = true;
1594 }
1595 else
1596 {
1597 aggbox = ba0.minimalBox();
1598 aggable = (aggbox.numPts() == npts0);
1599 }
1600 }
1601
1602 bool agged = false;
1603 bool coned = false;
1604 int agg_lev = 0, con_lev = 0;
1605
1606 AMREX_ALWAYS_ASSERT( ! (info.do_semicoarsening && info.hasHiddenDimension()
1607 && (info.semicoarsening_direction == -1 ||
1608 info.semicoarsening_direction == info.hidden_direction))
1609 && info.semicoarsening_direction >= -1
1610 && info.semicoarsening_direction < AMREX_SPACEDIM );
1611
1612 // Directions to coarsen for stretched cells: those shorter than 1.5
1613 // times the shortest. A fixed semicoarsening direction takes precedence.
1614 bool const aniso_coarsening = supportsAnisotropicCoarsening() && !hasHiddenDimension()
1615 && !(info.do_semicoarsening && info.semicoarsening_direction != -1);
1616 auto const dx0 = anisotropicCoarseningCellSize(geom0);
1617 auto base_ratio = [&] (IntVect const& accum) -> IntVect
1618 {
1619 IntVect rr = mg_coarsen_ratio_v;
1620 if (aniso_coarsening) {
1621 Real dxmin = std::numeric_limits<Real>::max();
1622 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1623 dxmin = std::min(dxmin, dx0[idim]*Real(accum[idim]));
1624 }
1625 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1626 if (dx0[idim]*Real(accum[idim]) >= Real(1.5)*dxmin) { rr[idim] = 1; }
1627 }
1628 }
1629 return rr;
1630 };
1631
1632 if (info.do_agglomeration && aggable)
1633 {
1634 Box dbx = geom0.Domain();
1635 Box bbx = aggbox;
1636 Real const nbxs = static_cast<Real>(ba0.size());
1637 Long const threshold_npts = AMREX_D_TERM(Long(info.agg_grid_size),
1638 *info.agg_grid_size,
1639 *info.agg_grid_size);
1640 Vector<Box> domainboxes{dbx};
1641 Vector<Box> boundboxes{bbx};
1642 Vector<int> agg_flag{false};
1643 Vector<IntVect> accum_coarsen_ratio{IntVect(1)};
1644 int numsclevs = 0;
1645
1646 for (int lev = 0; lev < info.max_coarsening_level; ++lev)
1647 {
1648 IntVect const rr_base = base_ratio(accum_coarsen_ratio.back());
1649 IntVect rr_level = rr_base;
1650 bool const do_semicoarsening_level = info.do_semicoarsening
1651 && numsclevs < info.max_semicoarsening_level;
1652 if (do_semicoarsening_level
1653 && info.semicoarsening_direction != -1)
1654 {
1655 rr_level[info.semicoarsening_direction] = 1;
1656 }
1657 IntVect is_coarsenable;
1658 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1659 IntVect rr_dir(1);
1660 rr_dir[idim] = rr_level[idim];
1661 // With odd ratios, the first ratio must also fit the original boxes.
1662 bool const fit_ba0 = mg_odd_coarsening && lev == 0;
1663 is_coarsenable[idim] = dbx.coarsenable(rr_dir, mg_domain_min_width_v)
1664 && bbx.coarsenable(rr_dir, mg_box_min_width_v)
1665 && (!fit_ba0 || ba0.coarsenable(rr_dir, mg_box_min_width_v));
1666 for (int r : {3, 5}) {
1667 if (is_coarsenable[idim] || !mg_odd_coarsening || rr_level[idim] != 2) {
1668 break;
1669 }
1670 rr_dir[idim] = r;
1671 if (dbx.coarsenable(rr_dir, mg_domain_min_width_v)
1672 && bbx.coarsenable(rr_dir, mg_box_min_width_v)
1673 && (!fit_ba0 || ba0.coarsenable(rr_dir, mg_box_min_width_v)))
1674 {
1675 is_coarsenable[idim] = true;
1676 rr_level[idim] = r;
1677 }
1678 }
1679 if (!is_coarsenable[idim] && do_semicoarsening_level
1680 && info.semicoarsening_direction == -1)
1681 {
1682 is_coarsenable[idim] = true;
1683 rr_level[idim] = 1;
1684 }
1685 }
1686 if (mg_independent_coarsening) {
1687 // A direction that cannot be coarsened gets ratio 1, and one whose
1688 // cells are 1.5 times longer than the shortest coarsenable waits.
1689 Real hmin = std::numeric_limits<Real>::max();
1690 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1691 if (is_coarsenable[idim] && rr_level[idim] > 1) {
1692 hmin = std::min(hmin, dx0[idim]*Real(accum_coarsen_ratio.back()[idim]));
1693 }
1694 }
1695 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1696 if (!is_coarsenable[idim] || dx0[idim]*Real(accum_coarsen_ratio.back()[idim]) >= Real(1.5)*hmin) {
1697 is_coarsenable[idim] = true;
1698 rr_level[idim] = 1;
1699 }
1700 }
1701 }
1702 if (is_coarsenable != IntVect(1) || rr_level == IntVect(1)) {
1703 break;
1704 }
1705 if (do_semicoarsening_level && info.semicoarsening_direction == -1) {
1706 // make sure there is at most one direction that is not coarsened
1707 int n_ones = AMREX_D_TERM( static_cast<int>(rr_level[0] == 1),
1708 + static_cast<int>(rr_level[1] == 1),
1709 + static_cast<int>(rr_level[2] == 1));
1710 if (n_ones > 1 && !aniso_coarsening) { break; }
1711 }
1712 bool semi_level = false; // odd ratios do not count
1713 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1714 semi_level = semi_level || (rr_level[idim] == 1 && rr_base[idim] != 1);
1715 }
1716 if (semi_level) {
1717 ++numsclevs;
1718 }
1719
1720 accum_coarsen_ratio.push_back(accum_coarsen_ratio.back()*rr_level);
1721 domainboxes.push_back(dbx.coarsen(rr_level));
1722 boundboxes.push_back(bbx.coarsen(rr_level));
1723 bool to_agg = (bbx.d_numPts() / nbxs)
1724 < Real(0.999)*static_cast<Real>(threshold_npts);
1725 agg_flag.push_back(to_agg);
1726 }
1727
1728 for (int lev = 1, nlevs = static_cast<int>(domainboxes.size()); lev < nlevs; ++lev) {
1729 if (!agged && !agg_flag[lev] &&
1730 ba0.coarsenable(accum_coarsen_ratio[lev], mg_box_min_width_v))
1731 {
1732 m_grids[0].push_back(amrex::coarsen(ba0, accum_coarsen_ratio[lev]));
1733 m_dmap[0].push_back(dm0);
1734 } else {
1735 IntVect cr = domainboxes[lev-1].length() / domainboxes[lev].length();
1736 if (!agged && lev > 1 && !m_grids[0].back().coarsenable(cr)) {
1737 // The boxes of level lev-1 cannot be coarsened further,
1738 // so agglomerate from that level instead.
1739 m_grids[0].pop_back();
1740 m_dmap[0].pop_back();
1741 m_geom[0].pop_back();
1742 --lev;
1743 cr = domainboxes[lev-1].length() / domainboxes[lev].length();
1744 }
1745 if (!m_grids[0].back().coarsenable(cr)) {
1746 break; // average_down would fail if fine boxarray is not coarsenable.
1747 }
1748 m_grids[0].emplace_back(boundboxes[lev]);
1749 Box const cell_box = amrex::enclosedCells(boundboxes[lev]);
1750 if (cell_box.numPts() > threshold_npts) {
1751 IntVect max_grid_size(info.agg_grid_size);
1752 if (info.do_semicoarsening && info.max_semicoarsening_level >= lev
1753 && info.semicoarsening_direction != -1)
1754 {
1755 IntVect blen = cell_box.size();
1756 AMREX_D_TERM(int mgs_0 = (max_grid_size[0]+blen[0]-1) / blen[0];,
1757 int mgs_1 = (max_grid_size[1]+blen[1]-1) / blen[1];,
1758 int mgs_2 = (max_grid_size[2]+blen[2]-1) / blen[2]);
1759 max_grid_size[info.semicoarsening_direction]
1760 *= AMREX_D_TERM(mgs_0, *mgs_1, *mgs_2);
1761 }
1762 if (mg_agg_no_split_direction >= 0 &&
1763 mg_agg_no_split_direction < AMREX_SPACEDIM)
1764 {
1765 int const d = mg_agg_no_split_direction;
1766 max_grid_size[d] = std::max(max_grid_size[d], cell_box.length(d));
1767 }
1768 // Chop in units of the next coarsening ratio, so that
1769 // the boxes can be coarsened.
1770 IntVect const rn = (lev+1 < nlevs)
1771 ? domainboxes[lev].length() / domainboxes[lev+1].length() : IntVect(1);
1772 BoxArray& cba = m_grids[0].back();
1773 cba.coarsen(rn);
1774 cba.maxSize((max_grid_size+rn-1)/rn);
1775 cba.refine(rn);
1776 }
1777 m_dmap[0].push_back(DistributionMapping());
1778 if (!agged) {
1779 agged = true;
1780 agg_lev = lev;
1781 }
1782 }
1783 m_geom[0].emplace_back(domainboxes[lev],rb,coord,is_per);
1784 }
1785 }
1786 else
1787 {
1788 Long consolidation_threshold = 0;
1789 Real avg_npts = 0.0;
1790 if (info.do_consolidation) {
1791 avg_npts = static_cast<Real>(ba0.d_numPts()) / static_cast<Real>(ParallelContext::NProcsSub());
1792 consolidation_threshold = AMREX_D_TERM(Long(info.con_grid_size),
1793 *info.con_grid_size,
1794 *info.con_grid_size);
1795 }
1796
1797 Box const& dom0 = geom0.Domain();
1798 IntVect rr_vec(1);
1799 int numsclevs = 0;
1800 for (int lev = 0; lev < info.max_coarsening_level; ++lev)
1801 {
1802 IntVect const rr_base = base_ratio(rr_vec);
1803 IntVect rr_level = rr_base;
1804 bool do_semicoarsening_level = info.do_semicoarsening
1805 && numsclevs < info.max_semicoarsening_level;
1806 if (do_semicoarsening_level
1807 && info.semicoarsening_direction != -1)
1808 {
1809 rr_level[info.semicoarsening_direction] = 1;
1810 }
1811 IntVect is_coarsenable;
1812 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1813 IntVect rr_dir(1);
1814 rr_dir[idim] = rr_vec[idim] * rr_level[idim];
1815 is_coarsenable[idim] = dom0.coarsenable(rr_dir, mg_domain_min_width_v)
1816 && ba0.coarsenable(rr_dir, mg_box_min_width_v);
1817 for (int r : {3, 5}) {
1818 if (is_coarsenable[idim] || !mg_odd_coarsening || rr_level[idim] != 2) {
1819 break;
1820 }
1821 rr_dir[idim] = rr_vec[idim] * r;
1822 if (dom0.coarsenable(rr_dir, mg_domain_min_width_v)
1823 && ba0.coarsenable(rr_dir, mg_box_min_width_v))
1824 {
1825 is_coarsenable[idim] = true;
1826 rr_level[idim] = r;
1827 }
1828 }
1829 if (!is_coarsenable[idim] && do_semicoarsening_level
1830 && info.semicoarsening_direction == -1)
1831 {
1832 is_coarsenable[idim] = true;
1833 rr_level[idim] = 1;
1834 }
1835 }
1836 if (mg_independent_coarsening) {
1837 // A direction that cannot be coarsened gets ratio 1, and one whose
1838 // cells are 1.5 times longer than the shortest coarsenable waits.
1839 Real hmin = std::numeric_limits<Real>::max();
1840 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1841 if (is_coarsenable[idim] && rr_level[idim] > 1) {
1842 hmin = std::min(hmin, dx0[idim]*Real(rr_vec[idim]));
1843 }
1844 }
1845 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1846 if (!is_coarsenable[idim] || dx0[idim]*Real(rr_vec[idim]) >= Real(1.5)*hmin) {
1847 is_coarsenable[idim] = true;
1848 rr_level[idim] = 1;
1849 }
1850 }
1851 }
1852 if (is_coarsenable != IntVect(1) || rr_level == IntVect(1)) {
1853 break;
1854 }
1855 if (do_semicoarsening_level && info.semicoarsening_direction == -1) {
1856 // make sure there is at most one direction that is not coarsened
1857 int n_ones = AMREX_D_TERM( static_cast<int>(rr_level[0] == 1),
1858 + static_cast<int>(rr_level[1] == 1),
1859 + static_cast<int>(rr_level[2] == 1));
1860 if (n_ones > 1 && !aniso_coarsening) { break; }
1861 }
1862 bool semi_level = false; // odd ratios do not count
1863 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1864 semi_level = semi_level || (rr_level[idim] == 1 && rr_base[idim] != 1);
1865 }
1866 if (semi_level) {
1867 ++numsclevs;
1868 }
1869 rr_vec *= rr_level;
1870
1871 m_geom[0].emplace_back(amrex::coarsen(dom0, rr_vec), rb, coord, is_per);
1872 m_grids[0].push_back(amrex::coarsen(ba0, rr_vec));
1873
1874 if (info.do_consolidation)
1875 {
1876 if (avg_npts/static_cast<Real>(AMREX_D_TERM(rr_vec[0], *rr_vec[1], *rr_vec[2]))
1877 < Real(0.999)*static_cast<Real>(consolidation_threshold))
1878 {
1879 coned = true;
1880 con_lev = m_dmap[0].size();
1881 m_dmap[0].push_back(DistributionMapping());
1882 }
1883 else
1884 {
1885 m_dmap[0].push_back(m_dmap[0].back());
1886 }
1887 }
1888 else
1889 {
1890 m_dmap[0].push_back(dm0);
1891 }
1892 }
1893 }
1894
1895 m_num_mg_levels[0] = m_grids[0].size();
1896
1897 for (int mglev = 0; mglev < m_num_mg_levels[0] - 1; mglev++){
1898 const Box& fine_domain = m_geom[0][mglev].Domain();
1899 const Box& crse_domain = m_geom[0][mglev+1].Domain();
1900 mg_coarsen_ratio_vec.push_back(fine_domain.length()/crse_domain.length());
1901 }
1902
1903 for (int amrlev = 0; amrlev < m_num_amr_levels; ++amrlev) {
1904 if (AMRRefRatio(amrlev) == 4 && mg_coarsen_ratio_vec.empty()) {
1905 mg_coarsen_ratio_vec.push_back(IntVect(2));
1906 }
1907 }
1908
1909 if (agged)
1910 {
1911 makeAgglomeratedDMap(m_grids[0], m_dmap[0]);
1912 }
1913 else if (coned)
1914 {
1915 makeConsolidatedDMap(m_grids[0], m_dmap[0], info.con_ratio, info.con_strategy);
1916 }
1917
1918 if (agged || coned)
1919 {
1920 m_bottom_comm = makeSubCommunicator(m_dmap[0].back());
1921 }
1922 else
1923 {
1924 m_bottom_comm = m_default_comm;
1925 }
1926
1927 m_do_agglomeration = agged;
1928 m_do_consolidation = coned;
1929
1930 if (verbose > 1) {
1931 if (agged) {
1932 Print() << "MLLinOp::defineGrids(): agglomerated AMR level 0 starting at MG level "
1933 << agg_lev << " of " << m_num_mg_levels[0] << "\n";
1934 } else if (coned) {
1935 Print() << "MLLinOp::defineGrids(): consolidated AMR level 0 starting at MG level "
1936 << con_lev << " of " << m_num_mg_levels[0]
1937 << " (ratio = " << info.con_ratio << ")" << "\n";
1938 } else {
1939 Print() << "MLLinOp::defineGrids(): no agglomeration or consolidation of AMR level 0\n";
1940 }
1941 }
1942
1943 for (int mglev = 1; mglev < m_num_mg_levels[0]; ++mglev)
1944 {
1945 m_factory[0].emplace_back(makeFactory(0,mglev));
1946 }
1947}
1948
1949template <typename MF>
1950void
1960
1961template <typename MF>
1962void
1963MLLinOpT<MF>::defineBC ()
1964{
1965 m_needs_coarse_data_for_bc = !m_domain_covered[0];
1966
1967 levelbc_raii.resize(m_num_amr_levels);
1968 robin_a_raii.resize(m_num_amr_levels);
1969 robin_b_raii.resize(m_num_amr_levels);
1970 robin_f_raii.resize(m_num_amr_levels);
1971}
1972
1973template <typename MF>
1974void
1976 const Array<BCType,AMREX_SPACEDIM>& a_hibc) noexcept
1977{
1978 const int ncomp = getNComp();
1980 Vector<Array<BCType,AMREX_SPACEDIM> >(ncomp,a_hibc));
1981}
1982
1983template <typename MF>
1984void
1986 const Vector<Array<BCType,AMREX_SPACEDIM> >& a_hibc)
1987{
1988 const int ncomp = getNComp();
1989 AMREX_ASSERT_WITH_MESSAGE(ncomp == a_lobc.size() && ncomp == a_hibc.size(),
1990 "MLLinOp::setDomainBC: wrong size");
1991 m_lobc = a_lobc;
1992 m_hibc = a_hibc;
1995 for (int icomp = 0; icomp < ncomp; ++icomp) {
1996 for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
1997 if (m_geom[0][0].isPeriodic(idim)) {
1998 AMREX_ALWAYS_ASSERT(m_lobc[icomp][idim] == BCType::Periodic &&
1999 m_hibc[icomp][idim] == BCType::Periodic);
2000 } else {
2001 AMREX_ALWAYS_ASSERT(m_lobc[icomp][idim] != BCType::Periodic &&
2002 m_hibc[icomp][idim] != BCType::Periodic);
2003 }
2004
2005 if (m_lobc[icomp][idim] == LinOpBCType::inhomogNeumann ||
2006 m_lobc[icomp][idim] == LinOpBCType::Robin)
2007 {
2008 m_lobc[icomp][idim] = LinOpBCType::Neumann;
2009 }
2010
2011 if (m_hibc[icomp][idim] == LinOpBCType::inhomogNeumann ||
2012 m_hibc[icomp][idim] == LinOpBCType::Robin)
2013 {
2014 m_hibc[icomp][idim] = LinOpBCType::Neumann;
2015 }
2016 }
2017 }
2018
2019 if (hasHiddenDimension()) {
2020 const int hd = hiddenDirection();
2021 for (int n = 0; n < ncomp; ++n) {
2024 }
2025 }
2026
2028 amrex::Abort("Inhomogeneous Neumann BC not supported");
2029 }
2030 if (hasRobinBC() && !supportRobinBC()) {
2031 amrex::Abort("Robin BC not supported");
2032 }
2033
2034 if (m_sp_linop) { m_sp_linop->setDomainBC(a_lobc, a_hibc); }
2035}
2036
2037template <typename MF>
2038bool
2039MLLinOpT<MF>::hasBC (BCType bct) const noexcept
2040{
2041 int ncomp = m_lobc_orig.size();
2042 for (int n = 0; n < ncomp; ++n) {
2043 for (int idim = 0; idim <AMREX_SPACEDIM; ++idim) {
2044 if (m_lobc_orig[n][idim] == bct || m_hibc_orig[n][idim] == bct) {
2045 return true;
2046 }
2047 }
2048 }
2049 return false;
2050}
2051
2052template <typename MF>
2053bool
2055{
2056 return hasBC(BCType::inhomogNeumann);
2057}
2058
2059template <typename MF>
2060bool
2062{
2063 return hasBC(BCType::Robin);
2064}
2065
2066template <typename MF>
2067Box
2068MLLinOpT<MF>::compactify (Box const& b) const noexcept
2069{
2070#if (AMREX_SPACEDIM == 3)
2071 if (info.hasHiddenDimension()) {
2072 const auto& lo = b.smallEnd();
2073 const auto& hi = b.bigEnd();
2074 if (info.hidden_direction == 0) {
2075 return Box(IntVect(lo[1],lo[2],0), IntVect(hi[1],hi[2],0), b.ixType());
2076 } else if (info.hidden_direction == 1) {
2077 return Box(IntVect(lo[0],lo[2],0), IntVect(hi[0],hi[2],0), b.ixType());
2078 } else {
2079 return Box(IntVect(lo[0],lo[1],0), IntVect(hi[0],hi[1],0), b.ixType());
2080 }
2081 } else
2082#endif
2083 {
2084 return b;
2085 }
2086}
2087
2088template <typename MF>
2089void
2090MLLinOpT<MF>::makeAgglomeratedDMap (const Vector<BoxArray>& ba,
2092{
2093 BL_PROFILE("MLLinOp::makeAgglomeratedDMap");
2094
2095 BL_ASSERT(!dm[0].empty());
2096 for (int i = 1, N=static_cast<int>(ba.size()); i < N; ++i)
2097 {
2098 if (dm[i].empty())
2099 {
2100 const std::vector< std::vector<int> >& sfc = DistributionMapping::makeSFC(ba[i]);
2101
2102 const int nprocs = ParallelContext::NProcsSub();
2103 AMREX_ASSERT(std::ssize(sfc) == nprocs);
2104
2105 Vector<int> pmap(ba[i].size());
2106 for (int iproc = 0; iproc < nprocs; ++iproc) {
2107 int grank = ParallelContext::local_to_global_rank(iproc);
2108 for (int ibox : sfc[iproc]) {
2109 pmap[ibox] = grank;
2110 }
2111 }
2112 dm[i].define(std::move(pmap));
2113 }
2114 }
2115}
2116
2117template <typename MF>
2118void
2119MLLinOpT<MF>::makeConsolidatedDMap (const Vector<BoxArray>& ba,
2121 int ratio, int strategy)
2122{
2123 BL_PROFILE("MLLinOp::makeConsolidatedDMap()");
2124
2125 int factor = 1;
2126 BL_ASSERT(!dm[0].empty());
2127 for (int i = 1, N=static_cast<int>(ba.size()); i < N; ++i)
2128 {
2129 if (dm[i].empty())
2130 {
2131 factor *= ratio;
2132
2133 const int nprocs = ParallelContext::NProcsSub();
2134 const auto& pmap_fine = dm[i-1].ProcessorMap();
2135 Vector<int> pmap(pmap_fine.size());
2136 ParallelContext::global_to_local_rank(pmap.data(), pmap_fine.data(), static_cast<int>(pmap.size()));
2137 if (strategy == 1) {
2138 for (auto& x: pmap) {
2139 x /= ratio;
2140 }
2141 } else if (strategy == 2) {
2142 int nprocs_con = static_cast<int>(std::ceil(static_cast<Real>(nprocs)
2143 / static_cast<Real>(factor)));
2144 for (auto& x: pmap) {
2145 auto d = std::div(x,nprocs_con);
2146 x = d.rem;
2147 }
2148 } else if (strategy == 3) {
2149 if (factor == ratio) {
2150 const std::vector< std::vector<int> >& sfc = DistributionMapping::makeSFC(ba[i]);
2151 for (int iproc = 0; iproc < nprocs; ++iproc) {
2152 for (int ibox : sfc[iproc]) {
2153 pmap[ibox] = iproc;
2154 }
2155 }
2156 }
2157 for (auto& x: pmap) {
2158 x /= ratio;
2159 }
2160 }
2161
2163 dm[i].define(std::move(pmap));
2164 } else {
2165 Vector<int> pmap_g(pmap.size());
2166 ParallelContext::local_to_global_rank(pmap_g.data(), pmap.data(), static_cast<int>(pmap.size()));
2167 dm[i].define(std::move(pmap_g));
2168 }
2169 }
2170 }
2171}
2172
2173template <typename MF>
2175MLLinOpT<MF>::makeSubCommunicator (const DistributionMapping& dm)
2176{
2177 BL_PROFILE("MLLinOp::makeSubCommunicator()");
2178
2179#ifdef BL_USE_MPI
2180
2181 Vector<int> newgrp_ranks = dm.ProcessorMap();
2182 std::ranges::sort(newgrp_ranks);
2183 auto last = std::unique(newgrp_ranks.begin(), newgrp_ranks.end());
2184 newgrp_ranks.erase(last, newgrp_ranks.end());
2185
2186 MPI_Comm newcomm;
2187 MPI_Group defgrp, newgrp;
2188 MPI_Comm_group(m_default_comm, &defgrp);
2190 MPI_Group_incl(defgrp, static_cast<int>(newgrp_ranks.size()), newgrp_ranks.data(), &newgrp);
2191 } else {
2192 Vector<int> local_newgrp_ranks(newgrp_ranks.size());
2193 ParallelContext::global_to_local_rank(local_newgrp_ranks.data(),
2194 newgrp_ranks.data(), static_cast<int>(newgrp_ranks.size()));
2195 MPI_Group_incl(defgrp, static_cast<int>(local_newgrp_ranks.size()), local_newgrp_ranks.data(), &newgrp);
2196 }
2197
2198 MPI_Comm_create(m_default_comm, newgrp, &newcomm);
2199
2200 m_raii_comm = std::make_unique<CommContainer>(newcomm);
2201
2202 MPI_Group_free(&defgrp);
2203 MPI_Group_free(&newgrp);
2204
2205 return newcomm;
2206#else
2208 return m_default_comm;
2209#endif
2210}
2211
2212template <typename MF>
2213void
2215 const Array<Real,AMREX_SPACEDIM>& hi_bcloc) noexcept
2216{
2217 m_domain_bloc_lo = lo_bcloc;
2218 m_domain_bloc_hi = hi_bcloc;
2219 if (m_sp_linop) {
2220 auto lo = lo_bcloc;
2221 auto hi = hi_bcloc;
2222 for (auto& x : lo) { x *= m_sp_length_scale; }
2223 for (auto& x : hi) { x *= m_sp_length_scale; }
2224 m_sp_linop->setDomainBCLoc(lo, hi);
2225 }
2226}
2227
2228template <typename MF>
2229void
2230MLLinOpT<MF>::setCoarseFineBC (const MF* crse, int crse_ratio,
2231 LinOpBCType bc_type) noexcept
2232{
2233 setCoarseFineBC(crse, IntVect(crse_ratio), bc_type);
2234}
2235
2236template <typename MF>
2237void
2238MLLinOpT<MF>::setCoarseFineBC (const MF* crse, IntVect const& crse_ratio,
2239 LinOpBCType bc_type) noexcept
2240{
2241 m_coarse_data_for_bc = crse;
2242 m_coarse_data_crse_ratio = crse_ratio;
2243 m_coarse_fine_bc_type = bc_type;
2244 if (m_sp_linop) { // the correction equation has homogeneous coarse/fine BC
2245 m_sp_linop->setCoarseFineBC(static_cast<fMultiFab const*>(nullptr), crse_ratio, bc_type);
2246 }
2247}
2248
2249template <typename MF>
2250template <typename AMF>
2251requires (!std::same_as<MF,AMF>)
2252void
2253MLLinOpT<MF>::setCoarseFineBC (const AMF* crse, int crse_ratio,
2254 LinOpBCType bc_type) noexcept
2255{
2256 setCoarseFineBC(crse, IntVect(crse_ratio), bc_type);
2257}
2258
2259template <typename MF>
2260template <typename AMF>
2261requires (!std::same_as<MF,AMF>)
2262void
2263MLLinOpT<MF>::setCoarseFineBC (const AMF* crse, IntVect const& crse_ratio,
2264 LinOpBCType bc_type) noexcept
2265{
2266 if (crse) {
2267 m_coarse_data_for_bc_raii = MF(crse->boxArray(), crse->DistributionMap(),
2268 crse->nComp(), crse->nGrowVect());
2269 m_coarse_data_for_bc_raii.LocalCopy(*crse, 0, 0, crse->nComp(),
2270 crse->nGrowVect());
2272 } else {
2273 m_coarse_data_for_bc = nullptr;
2274 }
2275 m_coarse_data_crse_ratio = crse_ratio;
2276 m_coarse_fine_bc_type = bc_type;
2277 if (m_sp_linop) {
2278 m_sp_linop->setCoarseFineBC(static_cast<fMultiFab const*>(nullptr), crse_ratio, bc_type);
2279 }
2280}
2281
2282template <typename MF>
2283void
2285{
2286 mf.clear();
2287 mf.resize(m_num_amr_levels);
2288 for (int alev = 0; alev < m_num_amr_levels; ++alev) {
2289 mf[alev].resize(m_num_mg_levels[alev]);
2290 for (int mlev = 0; mlev < m_num_mg_levels[alev]; ++mlev) {
2291 mf[alev][mlev] = make(alev, mlev, ng);
2292 }
2293 }
2294}
2295
2296template <typename MF>
2297MF
2298MLLinOpT<MF>::make (int amrlev, int mglev, IntVect const& ng) const
2299{
2300 return make(amrlev, mglev, ng, MFInfo());
2301}
2302
2303template <typename MF>
2304MF
2305MLLinOpT<MF>::make (int amrlev, int mglev, IntVect const& ng, MFInfo const& mf_info) const
2306{
2307 if constexpr (IsMultiFabLike_v<MF>) {
2308 return MF(amrex::convert(m_grids[amrlev][mglev], m_ixtype),
2309 m_dmap[amrlev][mglev], getNComp(), ng, mf_info,
2310 *m_factory[amrlev][mglev]);
2311 } else {
2312 amrex::ignore_unused(amrlev, mglev, ng);
2313 amrex::Abort("MLLinOpT::make: how did we get here?");
2314 return {};
2315 }
2316}
2317
2318template <typename MF>
2319MF
2320MLLinOpT<MF>::makeAlias (MF const& mf) const
2321{
2322 if constexpr (IsMultiFabLike_v<MF>) {
2323 return MF(mf, amrex::make_alias, 0, mf.nComp());
2324 } else {
2326 amrex::Abort("MLLinOpT::makeAlias: how did we get here?");
2327 return {};
2328 }
2329}
2330
2331template <typename MF>
2332MF
2333MLLinOpT<MF>::makeCoarseMG (int amrlev, int mglev, IntVect const& ng) const
2334{
2335 return makeCoarseMG(amrlev, mglev, ng, MFInfo());
2336}
2337
2338template <typename MF>
2339MF
2340MLLinOpT<MF>::makeCoarseMG (int amrlev, int mglev, IntVect const& ng,
2341 MFInfo const& mf_info) const
2342{
2343 if constexpr (IsMultiFabLike_v<MF>) {
2344 BoxArray cba = m_grids[amrlev][mglev];
2345 IntVect ratio = (amrlev > 0) ? IntVect(2) : mg_coarsen_ratio_vec[mglev];
2346 if (hasHiddenDimension()) { ratio[hiddenDirection()] = 1; }
2347 cba.coarsen(ratio);
2348 cba.convert(m_ixtype);
2349 return MF(cba, m_dmap[amrlev][mglev], getNComp(), ng, mf_info);
2350 } else {
2351 amrex::ignore_unused(amrlev, mglev, ng);
2352 amrex::Abort("MLLinOpT::makeCoarseMG: how did we get here?");
2353 return {};
2354 }
2355}
2356
2357template <typename MF>
2358MF
2359MLLinOpT<MF>::makeCoarseAmr (int famrlev, IntVect const& ng) const
2360{
2361 return makeCoarseAmr(famrlev, ng, MFInfo());
2362}
2363
2364template <typename MF>
2365MF
2366MLLinOpT<MF>::makeCoarseAmr (int famrlev, IntVect const& ng, MFInfo const& mf_info) const
2367{
2368 if constexpr (IsMultiFabLike_v<MF>) {
2369 BoxArray cba = m_grids[famrlev][0];
2370 IntVect ratio(AMRRefRatioVect(famrlev-1));
2371 cba.coarsen(ratio);
2372 cba.convert(m_ixtype);
2373 return MF(cba, m_dmap[famrlev][0], getNComp(), ng, mf_info);
2374 } else {
2375 amrex::ignore_unused(famrlev, ng);
2376 amrex::Abort("MLLinOpT::makeCoarseAmr: how did we get here?");
2377 return {};
2378 }
2379}
2380
2381template <typename MF>
2382void
2384{
2385 if (new_size <= 0 || new_size >= m_num_mg_levels[0]) { return; }
2386
2387 m_num_mg_levels[0] = new_size;
2388
2389 m_geom[0].resize(new_size);
2390 m_grids[0].resize(new_size);
2391 m_dmap[0].resize(new_size);
2392 m_factory[0].resize(new_size);
2393
2395 m_bottom_comm = makeSubCommunicator(m_dmap[0].back());
2396 }
2397}
2398
2399template <typename MF>
2400void
2401MLLinOpT<MF>::avgDownResMG (int clev, MF& cres, MF const& fres) const
2402{
2403 amrex::ignore_unused(clev, cres, fres);
2404 if constexpr (amrex::IsFabArray<MF>::value) {
2405 const int ncomp = this->getNComp();
2406#ifdef AMREX_USE_EB
2407 if (!fres.isAllRegular()) {
2408 if constexpr (std::is_same<MF,MultiFab>()) {
2409 amrex::EB_average_down(fres, cres, 0, ncomp,
2410 mg_coarsen_ratio_vec[clev-1]);
2411 } else {
2412 amrex::Abort("EB_average_down only works with MultiFab");
2413 }
2414 } else
2415#endif
2416 {
2417 amrex::average_down(fres, cres, 0, ncomp, mg_coarsen_ratio_vec[clev-1]);
2418 }
2419 } else {
2420 amrex::Abort("For non-FabArray, MLLinOpT<MF>::avgDownResMG should be overridden.");
2421 }
2422}
2423
2424template <typename MF>
2425bool
2426MLLinOpT<MF>::isMFIterSafe (int amrlev, int mglev1, int mglev2) const
2427{
2428 return m_dmap[amrlev][mglev1] == m_dmap[amrlev][mglev2]
2429 && BoxArray::SameRefs(m_grids[amrlev][mglev1], m_grids[amrlev][mglev2]);
2430}
2431
2432template <typename MF>
2433template <MultiFabLike AMF>
2434requires (!std::same_as<MF,AMF>)
2435void
2436MLLinOpT<MF>::setLevelBC (int amrlev, const AMF* levelbcdata,
2437 const AMF* robinbc_a, const AMF* robinbc_b,
2438 const AMF* robinbc_f)
2439{
2440 const int ncomp = this->getNComp();
2441 if (levelbcdata) {
2442 levelbc_raii[amrlev] = std::make_unique<MF>(levelbcdata->boxArray(),
2443 levelbcdata->DistributionMap(),
2444 ncomp, levelbcdata->nGrowVect());
2445 levelbc_raii[amrlev]->LocalCopy(*levelbcdata, 0, 0, ncomp,
2446 levelbcdata->nGrowVect());
2447 } else {
2448 levelbc_raii[amrlev].reset();
2449 }
2450
2451 if (robinbc_a) {
2452 robin_a_raii[amrlev] = std::make_unique<MF>(robinbc_a->boxArray(),
2453 robinbc_a->DistributionMap(),
2454 ncomp, robinbc_a->nGrowVect());
2455 robin_a_raii[amrlev]->LocalCopy(*robinbc_a, 0, 0, ncomp,
2456 robinbc_a->nGrowVect());
2457 } else {
2458 robin_a_raii[amrlev].reset();
2459 }
2460
2461 if (robinbc_b) {
2462 robin_b_raii[amrlev] = std::make_unique<MF>(robinbc_b->boxArray(),
2463 robinbc_b->DistributionMap(),
2464 ncomp, robinbc_b->nGrowVect());
2465 robin_b_raii[amrlev]->LocalCopy(*robinbc_b, 0, 0, ncomp,
2466 robinbc_b->nGrowVect());
2467 } else {
2468 robin_b_raii[amrlev].reset();
2469 }
2470
2471 if (robinbc_f) {
2472 robin_f_raii[amrlev] = std::make_unique<MF>(robinbc_f->boxArray(),
2473 robinbc_f->DistributionMap(),
2474 ncomp, robinbc_f->nGrowVect());
2475 robin_f_raii[amrlev]->LocalCopy(*robinbc_f, 0, 0, ncomp,
2476 robinbc_f->nGrowVect());
2477 } else {
2478 robin_f_raii[amrlev].reset();
2479 }
2480
2481 this->setLevelBC(amrlev, levelbc_raii[amrlev].get(), robin_a_raii[amrlev].get(),
2482 robin_b_raii[amrlev].get(), robin_f_raii[amrlev].get());
2483}
2484
2485template <typename MF>
2486auto
2488{
2490 return xdoty(0,0,*x[0],*y[0],false);
2491}
2492
2493template <typename MF>
2494auto
2496{
2498 auto r = xdoty(0,0,*x[0],*x[0],false);
2499 return std::sqrt(r);
2500}
2501
2502extern template class MLLinOpT<MultiFab>;
2503#ifdef AMREX_MLMG_HAS_FLOAT
2504extern template class MLLinOpT<fMultiFab>;
2505#endif
2506
2509
2510}
2511
2512#endif
Type-erased container that supports move-only types.
#define BL_PROFILE(a)
Definition AMReX_BLProfiler.H:593
#define AMREX_ALWAYS_ASSERT_WITH_MESSAGE(EX, MSG)
Definition AMReX_BLassert.H:49
#define BL_ASSERT(EX)
Definition AMReX_BLassert.H:39
#define AMREX_ASSERT_WITH_MESSAGE(EX, MSG)
Definition AMReX_BLassert.H:37
#define AMREX_ASSERT(EX)
Definition AMReX_BLassert.H:38
#define AMREX_ALWAYS_ASSERT(EX)
Definition AMReX_BLassert.H:50
Infrastructure for storing per-face boundary data in FabSets.
Type trait that exposes the FAB and value types of MultiFab-like containers.
#define AMREX_D_TERM(a, b, c)
Definition AMReX_SPACE.H:172
#define AMREX_D_PICK(a, b, c)
Definition AMReX_SPACE.H:173
#define AMREX_D_DECL(a, b, c)
Definition AMReX_SPACE.H:171
Reference-counted collection of Boxes.
Definition AMReX_BoxArray.H:681
BoxArray & refine(int refinement_ratio)
Refine each Box in the BoxArray by refinement_ratio.
Definition AMReX_BoxArray.cpp:606
static bool SameRefs(const BoxArray &lhs, const BoxArray &rhs)
whether two BoxArrays share the same data
Definition AMReX_BoxArray.H:1252
BoxArray & coarsen(int refinement_ratio)
Coarsen each Box in the BoxArray by refinement_ratio.
Definition AMReX_BoxArray.cpp:685
BoxArray & convert(IndexType typ)
Set the IndexType of the BoxArray.
Definition AMReX_BoxArray.cpp:829
BoxArray & maxSize(int block_size)
Split any Box whose side length exceeds block_size.
Definition AMReX_BoxArray.cpp:553
GpuArray< Real, 3 > CellSizeArray() const noexcept
Returns the cell sizes as a GpuArray for use on host or device.
Definition AMReX_CoordSys.H:85
Default FabFactory that calls new / delete on the FAB type directly.
Definition AMReX_FabFactory.H:124
Calculates the distribution of FABs to MPI processes.
Definition AMReX_DistributionMapping.H:55
static DistributionMapping makeSFC(const MultiFab &weight, bool sort=true)
Build an SFC map weighted by the sum of component 0 over each valid box of weight; sort enables load-...
Definition AMReX_DistributionMapping.cpp:1778
Definition AMReX_EBFabFactory.H:32
Abstract factory interface for creating, aliasing, and destroying FAB objects.
Definition AMReX_FabFactory.H:73
Rectangular problem domain geometry.
Definition AMReX_Geometry.H:87
Interface
HYPRE interface modes supported.
Definition AMReX_Hypre.H:70
Definition AMReX_MLLinOp.H:156
virtual void copyNSolveSolution(MF &dst, MF const &src) const
Copy an NSolve solution from src to dst.
Definition AMReX_MLLinOp.H:888
const MultiFab * m_coarse_data_for_bc
Definition AMReX_MLLinOp.H:1039
bool mg_odd_coarsening
Definition AMReX_MLLinOp.H:978
virtual void postSolve(Vector< MF * > const &sol) const
Optional hook invoked after the main solve completes.
Definition AMReX_MLLinOp.H:897
Vector< Vector< std::unique_ptr< FabFactory< FAB > > > > m_factory
Definition AMReX_MLLinOp.H:1010
virtual bool scaleRHS(int amrlev, MF *rhs) const
Optionally scale the RHS to fix solvability.
Definition AMReX_MLLinOp.H:658
bool m_mg_deferred
Definition AMReX_MLLinOp.H:989
virtual void avgDownResMG(int clev, MF &cres, MF const &fres) const
Average residuals from fine to coarse MG levels (FMG helper).
Definition AMReX_MLLinOp.H:2401
int NAMRLevels() const noexcept
Return the number of AMR levels.
Definition AMReX_MLLinOp.H:951
friend class HypreMLNodeLap
Definition AMReX_MLLinOp.H:165
bool m_do_consolidation
Definition AMReX_MLLinOp.H:1001
bool isCellCentered() const noexcept
Definition AMReX_MLLinOp.H:1248
IntVect m_ixtype
Definition AMReX_MLLinOp.H:998
void setVerbose(int v) noexcept
Set verbosity.
Definition AMReX_MLLinOp.H:324
bool isMFIterSafe(int amrlev, int mglev1, int mglev2) const
Check whether mixing MFIter loops for different MG levels is safe.
Definition AMReX_MLLinOp.H:2426
RealVect m_coarse_bc_loc
Definition AMReX_MLLinOp.H:1038
virtual bool needsUpdate() const
Does it need update if it's reused?
Definition AMReX_MLLinOp.H:390
virtual void interpolation(int amrlev, int fmglev, MF &fine, const MF &crse) const =0
Add interpolated coarse MG level data to fine MG level data.
virtual void setLevelBC(int, const MF *, const MF *=nullptr, const MF *=nullptr, const MF *=nullptr)=0
Set boundary conditions for given level. For cell-centered solves only.
virtual MF make(int amrlev, int mglev, IntVect const &ng) const
Definition AMReX_MLLinOp.H:2298
virtual void applyOverset(int amrlev, MF &rhs) const
Overset-only hook for zeroing regions covered by masks.
Definition AMReX_MLLinOp.H:647
FabFactory< FAB > const * Factory(int amr_lev, int mglev=0) const noexcept
Definition AMReX_MLLinOp.H:1209
LinOpEnumType::StateMode StateMode
Definition AMReX_MLLinOp.H:173
int spMetricExponent() const noexcept
Definition AMReX_MLLinOp.H:1091
void setDomainBC(const Vector< Array< BCType, 3 > > &lobc, const Vector< Array< BCType, 3 > > &hibc)
Boundary of the whole domain.
Definition AMReX_MLLinOp.H:1985
Array< Real, 3 > m_domain_bloc_hi
Definition AMReX_MLLinOp.H:1033
T get_d0(T const &dx, T const &dy, T const &) const noexcept
Definition AMReX_MLLinOp.H:1312
MPI_Comm BottomCommunicator() const noexcept
Definition AMReX_MLLinOp.H:1236
void setEnforceSingularSolvable(bool o) noexcept
Control whether the solver should try to make singular problems solvable.
Definition AMReX_MLLinOp.H:353
MPI_Comm Communicator() const noexcept
Definition AMReX_MLLinOp.H:1237
friend class GMRESMLMGT
Definition AMReX_MLLinOp.H:164
void setPrintIndentation(std::string s)
Prefix printed messages (e.g., to indent per level).
Definition AMReX_MLLinOp.H:334
int mg_domain_min_width
Definition AMReX_MLLinOp.H:976
void setMaxOrder(int o) noexcept
Set order of interpolation at coarse/fine boundary.
Definition AMReX_MLLinOp.H:341
virtual void compGrad(int amrlev, const Array< MF *, 3 > &grad, MF &sol, Location loc) const
Compute gradients of the solution.
Definition AMReX_MLLinOp.H:593
virtual void interpAssign(int amrlev, int fmglev, MF &fine, MF &crse) const
Overwrite fine MG level data with interpolated coarse data.
Definition AMReX_MLLinOp.H:423
virtual std::string name() const
Definition AMReX_MLLinOp.H:202
GpuArray< BCType, 3 > LoBC(int icomp=0) const noexcept
Definition AMReX_MLLinOp.H:1213
virtual void getEBFluxes(const Vector< MF * > &a_flux, const Vector< MF * > &a_sol) const
Extract embedded-boundary fluxes.
Definition AMReX_MLLinOp.H:795
bool doAgglomeration() const noexcept
Definition AMReX_MLLinOp.H:1244
virtual void spCopySettings()
Definition AMReX_MLLinOp.H:1165
virtual bool supportCustomBottomSolver() const
Does this operator provide its own bottom solver (BottomSolver::custom)?
Definition AMReX_MLLinOp.H:364
virtual MF makeCoarseAmr(int famrlev, IntVect const &ng, MFInfo const &mf_info) const
As above, with caller-selected allocation metadata for temporary storage.
Definition AMReX_MLLinOp.H:2366
MultiFab m_coarse_data_for_bc_raii
Definition AMReX_MLLinOp.H:1040
Vector< Geometry > spGeom(const Vector< Geometry > &a_geom)
Definition AMReX_MLLinOp.H:1102
MLLinOpT< MF > & operator=(const MLLinOpT< MF > &)=delete
int mg_box_min_width
Definition AMReX_MLLinOp.H:975
std::unique_ptr< CommContainer > m_raii_comm
Definition AMReX_MLLinOp.H:1030
bool m_do_semicoarsening
Definition AMReX_MLLinOp.H:1003
bool hasRobinBC() const noexcept
virtual std::unique_ptr< MLLinOpT< MF > > makeNLinOp(int grid_size) const
Create the NSolve counterpart of this operator with the requested grid size.
Definition AMReX_MLLinOp.H:756
friend class MLPoissonT
Definition AMReX_MLLinOp.H:162
Vector< Array< BCType, 3 > > m_hibc
Definition AMReX_MLLinOp.H:966
virtual void resizeMultiGrid(int new_size)
Definition AMReX_MLLinOp.H:2383
Vector< Vector< BoxArray > > m_grids
Definition AMReX_MLLinOp.H:1008
virtual MF makeCoarseAmr(int famrlev, IntVect const &ng) const
Allocate an MF on the next coarser AMR level (famrlev-1) with grow cells ng.
Definition AMReX_MLLinOp.H:2359
bool m_do_agglomeration
Definition AMReX_MLLinOp.H:1000
virtual MF makeAlias(MF const &mf) const
Definition AMReX_MLLinOp.H:2320
virtual bool supportsMixedPrecision() const
Definition AMReX_MLLinOp.H:877
int m_sp_linop_count
Definition AMReX_MLLinOp.H:1056
Array4< T > compactify(Array4< T > const &a) const noexcept
Definition AMReX_MLLinOp.H:1298
static constexpr int mg_coarsen_ratio
Definition AMReX_MLLinOp.H:974
virtual void solutionResidual(int amrlev, MF &resid, MF &x, const MF &b, const MF *crse_bcdata=nullptr)=0
Compute residual for solution.
int getMaxOrder() const noexcept
Get order of interpolation at coarse/fine boundary.
Definition AMReX_MLLinOp.H:346
virtual int getNComp() const
Return number of components.
Definition AMReX_MLLinOp.H:385
void setCoarseFineBCLocation(const RealVect &cloc) noexcept
Definition AMReX_MLLinOp.H:1239
Vector< int > m_amr_ref_ratio
Definition AMReX_MLLinOp.H:993
MPI_Comm m_default_comm
Definition AMReX_MLLinOp.H:1013
virtual void unapplyMetricTerm(int amrlev, int mglev, MF &rhs) const
Remove metric scaling previously applied via applyMetricTerm().
Definition AMReX_MLLinOp.H:617
virtual void setDirichletNodesToZero(int amrlev, int mglev, MF &mf) const
Optional hook for masking out Dirichlet nodes or cells prior to GMRES solves; the default is a no-op ...
Definition AMReX_MLLinOp.H:709
bool isBottomActive() const noexcept
Definition AMReX_MLLinOp.H:1234
virtual void applyInhomogNeumannTerm(int amrlev, MF &rhs) const
Add extra terms introduced when treating inhomogeneous Neumann BC as homogeneous.
Definition AMReX_MLLinOp.H:637
virtual BottomSolver getDefaultBottomSolver() const
Definition AMReX_MLLinOp.H:361
virtual void prepareForFluxes(int amrlev, const MF *crse_bcdata=nullptr)
Ensure BC caches are populated before flux extraction.
Definition AMReX_MLLinOp.H:532
typename FabDataType< MF >::fab_type FAB
Definition AMReX_MLLinOp.H:168
virtual RT normInf(int amrlev, MF const &mf, bool local) const =0
Infinity norm helper used by residual reductions.
Vector< int > m_num_mg_levels
Definition AMReX_MLLinOp.H:995
bool hasBC(BCType bct) const noexcept
Definition AMReX_MLLinOp.H:2039
Vector< Vector< DistributionMapping > > m_dmap
Definition AMReX_MLLinOp.H:1009
int verbose
Definition AMReX_MLLinOp.H:983
virtual MF make(int amrlev, int mglev, IntVect const &ng, MFInfo const &mf_info) const
As above, with caller-selected allocation metadata for temporary storage.
Definition AMReX_MLLinOp.H:2305
IntVect m_coarse_data_crse_ratio
Definition AMReX_MLLinOp.H:1037
LinOpBCType BCType
Definition AMReX_MLLinOp.H:171
virtual void correctionResidual(int amrlev, int mglev, MF &resid, MF &x, const MF &b, BCMode bc_mode, const MF *crse_bcdata=nullptr)=0
Compute residual for the residual-correction form, resid = b - L(x).
virtual void customBottomSolve(MLMGT< MF > *mlmg, MF &x, const MF &b, RT eps_rel, RT eps_abs, int maxiter)
Bottom solve provided by the operator itself.
Definition AMReX_MLLinOp.H:377
const Vector< int > & AMRRefRatio() const noexcept
Return AMR refinement ratios.
Definition AMReX_MLLinOp.H:1197
MLLinOpT(MLLinOpT< MF > &&)=delete
Vector< Array< BCType, 3 > > m_hibc_orig
Definition AMReX_MLLinOp.H:970
RT m_sp_scale
Definition AMReX_MLLinOp.H:1064
virtual void unimposeNeumannBC(int amrlev, MF &rhs) const
Undo Neumann contributions stored on the RHS.
Definition AMReX_MLLinOp.H:627
void setCoarseFineBC(const MF *crse, int crse_ratio, LinOpBCType bc_type=LinOpBCType::Dirichlet) noexcept
Set coarse/fine boundary conditions. For cell-centered solves only.
Definition AMReX_MLLinOp.H:2230
virtual void apply(int amrlev, int mglev, MF &out, MF &in, BCMode bc_mode, StateMode s_mode, const MLMGBndryT< MF > *bndry=nullptr) const =0
Apply the linear operator, out = L(in).
int mg_agg_no_split_direction
Definition AMReX_MLLinOp.H:977
friend class MLCGSolverT
Definition AMReX_MLLinOp.H:161
std::string print_ident
Definition AMReX_MLLinOp.H:984
virtual void interpCoarseFineSolution(int famrlev, MF &fine_sol, const MF &crse_sol) const
Before a composite solve, set the solution at the nodes that fine AMR level famrlev takes from the co...
Definition AMReX_MLLinOp.H:455
bool needsCoarseDataForBC() const noexcept
Needs coarse data for bc?
Definition AMReX_MLLinOp.H:249
static RT spScaleFor(RT x) noexcept
The power of two p with p*x in [0.5,1), or 1 if x is zero or not finite.
Definition AMReX_MLLinOp.H:1068
typename FabDataType< MF >::value_type RT
Definition AMReX_MLLinOp.H:169
virtual void update()
Update for reuse.
Definition AMReX_MLLinOp.H:392
Vector< Array< BCType, 3 > > m_lobc_orig
Definition AMReX_MLLinOp.H:969
bool m_precond_mode
Definition AMReX_MLLinOp.H:1042
virtual std::unique_ptr< FabFactory< FAB > > makeFactory(int, int) const
Definition AMReX_MLLinOp.H:1278
bool hasHiddenDimension() const noexcept
Definition AMReX_MLLinOp.H:1293
virtual bool isBottomSingular() const =0
Is the bottom of the multigrid hierarchy singular?
virtual void reflux(int crse_amrlev, MF &res, const MF &crse_sol, const MF &crse_rhs, MF &fine_res, MF &fine_sol, const MF &fine_rhs) const
Reflux at AMR coarse/fine boundary.
Definition AMReX_MLLinOp.H:561
virtual IntVect getNGrowVectRestriction() const
Definition AMReX_MLLinOp.H:1250
virtual std::unique_ptr< MLAlgMG > makeAlgMG(int mglev) const
Build the algebraic system of MG level mglev of AMR level 0 for the AlgMG solver. Operators that hypr...
Definition AMReX_MLLinOp.H:806
virtual bool supportsAnisotropicCoarsening() const
True if the operator supports MG levels coarsened in any subset of directions. Then MLMG coarsens str...
Definition AMReX_MLLinOp.H:823
virtual void compFlux(int amrlev, const Array< MF *, 3 > &fluxes, MF &sol, Location loc) const
Compute fluxes.
Definition AMReX_MLLinOp.H:578
virtual RT dotProductPrecond(Vector< MF const * > const &x, Vector< MF const * > const &y) const
Dot product over the composite AMR hierarchy, excluding cells covered by finer levels....
Definition AMReX_MLLinOp.H:2487
virtual MF makeCoarseMG(int amrlev, int mglev, IntVect const &ng) const
Allocate an MF on the next coarser MG level (mglev+1) with grow cells ng.
Definition AMReX_MLLinOp.H:2333
const Geometry & Geom(int amr_lev, int mglev=0) const noexcept
Geometry accessor for (amr_lev,mglev).
Definition AMReX_MLLinOp.H:962
virtual void endPrecondBC()
Called when the operator stops being used as a preconditioner.
Definition AMReX_MLLinOp.H:939
bool isMixedPrecision() const noexcept
True if this operator has a single precision copy for mixed precision.
Definition AMReX_MLLinOp.H:880
int hiddenDirection() const noexcept
Definition AMReX_MLLinOp.H:1294
void setDomainBCLoc(const Array< Real, 3 > &lo_bcloc, const Array< Real, 3 > &hi_bcloc) noexcept
Set location offsets for the physical domain boundaries.
Definition AMReX_MLLinOp.H:2214
Vector< Array< BCType, 3 > > m_lobc
Definition AMReX_MLLinOp.H:965
Vector< int > m_domain_covered
Definition AMReX_MLLinOp.H:1011
void prepareMGHierarchy()
Build the deferred MG levels of AMR level 0 once. See supportsAnisotropicCoarsening.
Definition AMReX_MLLinOp.H:1951
const MLLinOpT< MultiFab > * m_parent
Definition AMReX_MLLinOp.H:996
bool doSemicoarsening() const noexcept
Definition AMReX_MLLinOp.H:1246
virtual bool supportNSolve() const
Whether this operator supports NSolve.
Definition AMReX_MLLinOp.H:873
virtual bool supportRobinBC() const noexcept
Definition AMReX_MLLinOp.H:1228
virtual void normalize(int amrlev, int mglev, MF &mf) const
Divide mf by the diagonal component of the operator. Used by the bottom solvers.
Definition AMReX_MLLinOp.H:510
virtual void avgDownResAmr(int clev, MF &cres, MF const &fres) const
Definition AMReX_MLLinOp.H:917
Vector< Vector< Geometry > > m_geom
Definition AMReX_MLLinOp.H:1007
virtual RT norm2Precond(Vector< MF const * > const &x) const
L2 norm over the composite AMR hierarchy, excluding cells covered by finer levels....
Definition AMReX_MLLinOp.H:2495
MLLinOpT(const MLLinOpT< MF > &)=delete
friend class MLABecLaplacianT
Definition AMReX_MLLinOp.H:163
virtual void averageDownAndSync(Vector< MF > &sol) const =0
Average the solution hierarchy down (fine to coarse) and synchronize interfaces.
void setCoarseFineBC(const MF *crse, IntVect const &crse_ratio, LinOpBCType bc_type=LinOpBCType::Dirichlet) noexcept
Definition AMReX_MLLinOp.H:2238
LPInfo dpInfo(LPInfo const &a_info) const
Definition AMReX_MLLinOp.H:1128
MLLinOpT()=default
virtual void getFluxes(const Vector< MF * > &a_flux, const Vector< MF * > &a_sol) const
Extract fluxes when the operator stores them in single MultiFabs per level.
Definition AMReX_MLLinOp.H:782
Box compactify(Box const &b) const noexcept
Definition AMReX_MLLinOp.H:2068
bool m_needs_coarse_data_for_bc
Definition AMReX_MLLinOp.H:1035
virtual void fixSolvabilityByOffset(int amrlev, int mglev, MF &rhs, Vector< RT > const &offset) const
Subtract previously computed offsets from the RHS.
Definition AMReX_MLLinOp.H:685
GpuArray< BCType, 3 > HiBC(int icomp=0) const noexcept
Definition AMReX_MLLinOp.H:1218
Real m_sp_length_scale
Definition AMReX_MLLinOp.H:1065
int maxorder
Definition AMReX_MLLinOp.H:986
void define(const Vector< Geometry > &a_geom, const Vector< BoxArray > &a_grids, const Vector< DistributionMapping > &a_dmap, const LPInfo &a_info, const Vector< FabFactory< FAB > const * > &a_factory, bool eb_limit_coarsening=true)
Initialize the operator hierarchy on a set of AMR levels.
Definition AMReX_MLLinOp.H:1356
Vector< IntVect > mg_coarsen_ratio_vec
Definition AMReX_MLLinOp.H:1004
virtual MF makeCoarseMG(int amrlev, int mglev, IntVect const &ng, MFInfo const &mf_info) const
As above, with caller-selected allocation metadata for temporary storage.
Definition AMReX_MLLinOp.H:2340
LinOpEnumType::Location Location
Definition AMReX_MLLinOp.H:174
MF MFType
Definition AMReX_MLLinOp.H:167
virtual void preparePrecond()
Prepare auxiliary data used when the operator acts as a preconditioner.
Definition AMReX_MLLinOp.H:699
virtual ~MLLinOpT()=default
virtual void averageDownSolutionRHS(int camrlev, MF &crse_sol, MF &crse_rhs, const MF &fine_sol, const MF &fine_rhs)
Average-down data from fine AMR level to coarse AMR level.
Definition AMReX_MLLinOp.H:469
LPInfo info
Definition AMReX_MLLinOp.H:981
void makeSPLinOp(LPInfo const &a_info, F const &f)
Definition AMReX_MLLinOp.H:1145
friend class MLMGT
Definition AMReX_MLLinOp.H:160
int NMGLevels(int amrlev) const noexcept
Return the number of MG levels at given AMR level.
Definition AMReX_MLLinOp.H:959
LinOpEnumType::BCMode BCMode
Definition AMReX_MLLinOp.H:172
virtual Vector< RT > getSolvabilityOffset(int amrlev, int mglev, MF const &rhs) const
Compute offsets used to enforce solvability (per component).
Definition AMReX_MLLinOp.H:671
T get_d1(T const &, T const &dy, T const &dz) const noexcept
Definition AMReX_MLLinOp.H:1322
bool enforceSingularSolvable
Definition AMReX_MLLinOp.H:988
virtual RT xdoty(int amrlev, int mglev, const MF &x, const MF &y, bool local) const =0
Dot-product helper used by bottom solvers.
virtual void interpolationAmr(int famrlev, MF &fine, const MF &crse, IntVect const &nghost) const
Interpolation between AMR levels.
Definition AMReX_MLLinOp.H:437
bool doConsolidation() const noexcept
Definition AMReX_MLLinOp.H:1245
static constexpr bool mixed_precision_capable
Definition AMReX_MLLinOp.H:1047
virtual bool supportInhomogNeumannBC() const noexcept
Definition AMReX_MLLinOp.H:1229
void spForward(F const &f)
Definition AMReX_MLLinOp.H:1185
LinOpBCType m_coarse_fine_bc_type
Definition AMReX_MLLinOp.H:1036
Array< Real, 3 > m_domain_bloc_lo
Definition AMReX_MLLinOp.H:1032
std::unique_ptr< MLLinOpT< fMultiFab > > m_sp_linop
Definition AMReX_MLLinOp.H:1053
virtual bool supportsAlgMG() const
True if makeAlgMG is implemented for this operator.
Definition AMReX_MLLinOp.H:813
bool m_mg_built
Definition AMReX_MLLinOp.H:990
virtual void buildMGHierarchy()
Build the MG levels of AMR level 0 below the finest one.
Definition AMReX_MLLinOp.H:1288
virtual bool isSingular(int amrlev) const =0
Is it singular on AMR level amrlev?
int AMRRefRatio(int amr_lev) const noexcept
Return AMR refinement ratio at given AMR level.
Definition AMReX_MLLinOp.H:1200
MPI_Comm m_bottom_comm
Definition AMReX_MLLinOp.H:1014
virtual void restriction(int amrlev, int cmglev, MF &crse, MF &fine) const =0
Restriction onto coarse MG level.
friend class MLLinOpT
Definition AMReX_MLLinOp.H:159
virtual void getFluxes(const Vector< Array< MF *, 3 > > &a_flux, const Vector< MF * > &a_sol, Location a_loc) const
Extract per-direction fluxes for each AMR level.
Definition AMReX_MLLinOp.H:770
virtual void beginPrecondBC()
Called when the operator starts being used as a preconditioner.
Definition AMReX_MLLinOp.H:935
virtual void applyMetricTerm(int amrlev, int mglev, MF &rhs) const
Apply metric scaling to the RHS on (amrlev,mglev).
Definition AMReX_MLLinOp.H:607
bool mg_independent_coarsening
Definition AMReX_MLLinOp.H:979
bool getEnforceSingularSolvable() const noexcept
Definition AMReX_MLLinOp.H:359
virtual void prepareForSolve()=0
Finalize coefficients, masks, and BC data before iterative solves.
IntVect AMRRefRatioVect(int amr_lev) const noexcept
Return AMR refinement ratio as IntVect (1 in hidden direction).
Definition AMReX_MLLinOp.H:1203
virtual void smooth(int amrlev, int mglev, MF &sol, const MF &rhs, bool skip_fillboundary, int niter) const =0
Smooth.
static RT spDiagForScale(Vector< RT > const &diag) noexcept
Definition AMReX_MLLinOp.H:1077
virtual GpuArray< Real, 3 > anisotropicCoarseningCellSize(Geometry const &geom) const
Cell size used to pick the directions to coarsen when supportsAnisotropicCoarsening() is true....
Definition AMReX_MLLinOp.H:831
virtual void make(Vector< Vector< MF > > &mf, IntVect const &ng) const
Definition AMReX_MLLinOp.H:2284
bool hasInhomogNeumannBC() const noexcept
Definition AMReX_MLLinOp.H:2054
void setDomainBC(const Array< BCType, 3 > &lobc, const Array< BCType, 3 > &hibc) noexcept
Boundary of the whole domain.
Definition AMReX_MLLinOp.H:1975
virtual int getNGrow(int=0, int=0) const
Definition AMReX_MLLinOp.H:387
int m_num_amr_levels
Definition AMReX_MLLinOp.H:992
Boundary helper for MLMG that manages coarse/fine and physical BC metadata.
Definition AMReX_MLMGBndry.H:20
This class provides the user with a few print options.
Definition AMReX_Print.H:35
A Box with real dimensions.
Definition AMReX_RealBox.H:28
This class is a thin wrapper around std::vector. Unlike vector, Vector::operator[] provides bound che...
Definition AMReX_Vector.H:29
Long size() const noexcept
Definition AMReX_Vector.H:54
amrex_real Real
Floating Point Type for Fields.
Definition AMReX_REAL.H:80
amrex_long Long
Definition AMReX_INT.H:30
__host__ __device__ Dim3 length(Array4< T > const &a) noexcept
Return the spatial extents of an Array4 in Dim3 form.
Definition AMReX_Array4.H:1391
ArrayND< T, 4, true > Array4
Convenient alias for a 4D ArrayND with three spatial dimensions plus a component dimension.
Definition AMReX_Array4.H:1352
__host__ __device__ BoxND< dim > convert(const BoxND< dim > &b, const IntVectND< dim > &typ) noexcept
Return a copy of b converted to the nodal flags typ.
Definition AMReX_Box.H:1632
__host__ __device__ BoxND< dim > coarsen(const BoxND< dim > &b, int ref_ratio) noexcept
Return a copy of b coarsened by the isotropic ratio ref_ratio.
Definition AMReX_Box.H:1471
__host__ __device__ BoxND< dim > enclosedCells(const BoxND< dim > &b, int dir) noexcept
Return a BoxND with CELL based coordinates in direction dir that is enclosed by b.
Definition AMReX_Box.H:1666
std::array< T, N > Array
Definition AMReX_Array.H:31
MLLinOpT< MultiFab > MLLinOp
Definition AMReX_MLLinOp.H:2508
bool notInLaunchRegion() noexcept
Definition AMReX_GpuControl.H:89
void push(MPI_Comm c)
Definition AMReX_ParallelContext.H:105
MPI_Comm CommunicatorSub() noexcept
sub-communicator for current frame
Definition AMReX_ParallelContext.H:70
void pop()
Note that it's the user's responsibility to free the MPI_Comm.
Definition AMReX_ParallelContext.H:111
int local_to_global_rank(int rank) noexcept
translate between local rank and global rank
Definition AMReX_ParallelContext.H:98
int global_to_local_rank(int rank) noexcept
Definition AMReX_ParallelContext.H:101
int NProcsSub() noexcept
number of ranks in current frame
Definition AMReX_ParallelContext.H:74
MPI_Comm Communicator() noexcept
Definition AMReX_ParallelDescriptor.H:223
int MPI_Comm
Definition AMReX_ccse-mpi.H:51
static constexpr int MPI_COMM_NULL
Definition AMReX_ccse-mpi.H:59
int MPI_Group
Definition AMReX_ccse-mpi.H:52
__host__ __device__ T hmin(T const &v)
Definition AMReX_SIMD.H:168
Definition AMReX_Amr.cpp:50
@ make_alias
Definition AMReX_MakeType.H:7
__host__ __device__ void ignore_unused(const Ts &...)
No-op helper that marks variables as intentionally unused.
Definition AMReX.H:273
@ F
Definition AMReX_Order.H:7
void average_down(const MultiFab &S_fine, MultiFab &S_crse, const Geometry &fgeom, const Geometry &cgeom, int scomp, int ncomp, int rr)
Definition AMReX_MultiFabUtil.cpp:360
constexpr bool IsMultiFabLike_v
Definition AMReX_TypeTraits.H:44
@ bicgstab
Definition AMReX_AlgMG.H:200
BoxND< 3 > Box
Box is an alias for amrex::BoxND instantiated with AMREX_SPACEDIM.
Definition AMReX_BaseFwd.H:35
LinOpBCType
Definition AMReX_LO_BCTYPES.H:27
@ Robin
Definition AMReX_LO_BCTYPES.H:36
@ Neumann
Definition AMReX_LO_BCTYPES.H:30
@ Dirichlet
Definition AMReX_LO_BCTYPES.H:29
@ inhomogNeumann
Definition AMReX_LO_BCTYPES.H:35
void EB_average_down(const MultiFab &S_fine, MultiFab &S_crse, const MultiFab &vol_fine, const MultiFab &vfrac_fine, int scomp, int ncomp, const IntVect &ratio)
Volume-weighted average-down from fine to coarse using EB volume fractions.
Definition AMReX_EBMultiFabUtil.cpp:336
@ y
Definition AMReX_Orientation.H:14
@ x
Definition AMReX_Orientation.H:14
BottomSolver
Definition AMReX_MLLinOp.H:43
@ algmg
Definition AMReX_MLLinOp.H:44
@ bicgcg
Definition AMReX_MLLinOp.H:44
@ petsc
Definition AMReX_MLLinOp.H:44
@ cg
Definition AMReX_MLLinOp.H:44
@ Default
Definition AMReX_MLLinOp.H:44
@ custom
Definition AMReX_MLLinOp.H:44
@ cgbicg
Definition AMReX_MLLinOp.H:44
@ hypre
Definition AMReX_MLLinOp.H:44
@ smoother
Definition AMReX_MLLinOp.H:44
@ bicgstab
Definition AMReX_MLLinOp.H:44
FabArray< BaseFab< float > > fMultiFab
Definition AMReX_MultiFab.H:19
std::unique_ptr< Hypre > makeHypre(const BoxArray &grids, const DistributionMapping &dmap, const Geometry &geom, MPI_Comm comm_, Hypre::Interface interface, const iMultiFab *overset_mask)
Factory that instantiates the requested HYPRE interface.
Definition AMReX_Hypre.cpp:12
IntVectND< 3 > IntVect
IntVect is an alias for amrex::IntVectND instantiated with AMREX_SPACEDIM.
Definition AMReX_BaseFwd.H:38
void Warning(const std::string &msg)
Print a warning message to the diagnostic stream and keep running.
Definition AMReX.cpp:245
void Abort(const std::string &msg)
Print a fatal-error message to stderr and abort execution.
Definition AMReX.cpp:239
RealVectND< 3 > RealVect
Definition AMReX_ParmParse.H:40
__host__ __device__ constexpr int get(IntVectND< dim > const &iv) noexcept
Get the Idx-th element of IntVectND<dim>.
Definition AMReX_IntVect.H:1367
Type trait specialized for MultiFab-like types and their containers.
Definition AMReX_FabDataType.H:16
Fixed-size array that can be used on GPU.
Definition AMReX_Array.H:52
Definition AMReX_TypeTraits.H:27
Configuration knobs for multilevel linear operators (grid agglomeration, metrics, etc....
Definition AMReX_MLLinOp.H:54
LPInfo & setConsolidationRatio(int x) noexcept
Set the refinement ratio x between consolidated levels.
Definition AMReX_MLLinOp.H:81
int con_strategy
Definition AMReX_MLLinOp.H:61
bool do_semicoarsening
Definition AMReX_MLLinOp.H:57
bool has_metric_term
Definition AMReX_MLLinOp.H:62
LPInfo & setConsolidationGridSize(int x) noexcept
Override the consolidation grid cutoff x (cells per MPI task) used to trigger grouping.
Definition AMReX_MLLinOp.H:79
int max_semicoarsening_level
Definition AMReX_MLLinOp.H:64
bool hasHiddenDimension() const noexcept
True if a hidden dimension was configured via setHiddenDirection().
Definition AMReX_MLLinOp.H:102
int con_ratio
Definition AMReX_MLLinOp.H:60
bool do_consolidation
Definition AMReX_MLLinOp.H:56
int con_grid_size
Definition AMReX_MLLinOp.H:59
LPInfo & setSemicoarsening(bool x) noexcept
Toggle plane-wise semicoarsening instead of full coarsening (x = true selects semicoarsening).
Definition AMReX_MLLinOp.H:75
LPInfo & setHiddenDirection(int n) noexcept
Specify a dimension n that should be treated as “hidden” (e.g., for thin domains).
Definition AMReX_MLLinOp.H:93
LPInfo & setConsolidation(bool x) noexcept
Enable or disable consolidation (MPI rank grouping) on coarse levels (x toggles the feature).
Definition AMReX_MLLinOp.H:73
LPInfo & setSemicoarseningDirection(int n) noexcept
Lock the direction n used for semicoarsening (-1 restores the default heuristic).
Definition AMReX_MLLinOp.H:91
LPInfo & setMaxSemicoarseningLevel(int n) noexcept
Cap the number of semicoarsening steps (when enabled) via n.
Definition AMReX_MLLinOp.H:89
bool do_agglomeration
Definition AMReX_MLLinOp.H:55
LPInfo & setMetricTerm(bool x) noexcept
Indicate whether metric terms are present so downstream code can skip metric work when absent.
Definition AMReX_MLLinOp.H:85
bool deterministic
Enable deterministic mode for GPU operations.
Definition AMReX_MLLinOp.H:67
static constexpr int getDefaultConsolidationGridSize()
Definition AMReX_MLLinOp.H:114
LPInfo & setConsolidationStrategy(int x) noexcept
Select the heuristic x used when forming consolidated grids.
Definition AMReX_MLLinOp.H:83
int max_coarsening_level
Definition AMReX_MLLinOp.H:63
int agg_grid_size
Definition AMReX_MLLinOp.H:58
static constexpr int getDefaultAgglomerationGridSize()
Definition AMReX_MLLinOp.H:106
int hidden_direction
Definition AMReX_MLLinOp.H:66
LPInfo & setAgglomerationGridSize(int x) noexcept
Override the target grid size x used when agglomerating patches.
Definition AMReX_MLLinOp.H:77
LPInfo & setMixedPrecision(bool x) noexcept
Definition AMReX_MLLinOp.H:99
LPInfo & setMaxCoarseningLevel(int n) noexcept
Cap how many coarsening steps (standard or semi-) MLMG may perform by setting n.
Definition AMReX_MLLinOp.H:87
LPInfo & setDeterministic(bool x) noexcept
Definition AMReX_MLLinOp.H:96
LPInfo & setAgglomeration(bool x) noexcept
Enable or disable grid agglomeration on the coarsest MLMG levels (x = true enables it).
Definition AMReX_MLLinOp.H:71
bool mixed_precision
Run the multigrid cycles in single precision.
Definition AMReX_MLLinOp.H:68
int semicoarsening_direction
Definition AMReX_MLLinOp.H:65
Definition AMReX_MLLinOp.H:124
StateMode
Definition AMReX_MLLinOp.H:126
@ Solution
Definition AMReX_MLLinOp.H:126
@ Correction
Definition AMReX_MLLinOp.H:126
BCMode
Definition AMReX_MLLinOp.H:125
@ Homogeneous
Definition AMReX_MLLinOp.H:125
@ Inhomogeneous
Definition AMReX_MLLinOp.H:125
Location
Definition AMReX_MLLinOp.H:127
@ CellCentroid
Definition AMReX_MLLinOp.H:127
@ FaceCentroid
Definition AMReX_MLLinOp.H:127
@ FaceCenter
Definition AMReX_MLLinOp.H:127
@ CellCenter
Definition AMReX_MLLinOp.H:127
FabArray memory allocation information.
Definition AMReX_FabArray.H:73