AMReX_MLLinOp_temp.H

Go to the documentation of this file.

#ifndef AMREX_MLLINOP_TEMP_H_
#define AMREX_MLLINOP_TEMP_H_
 
 
#include <AMReX_MLLinOp.H>
 
namespace amrex_temp
{
 
class MLLinOpTemp
    : public amrex::MLLinOp
{
public:
 
    using Container = amrex::Array<amrex::MultiFab,3>;
 
    MLLinOpTemp () {}
 
    virtual ~MLLinOpTemp () {}
 
    MLLinOpTemp (const MLLinOpTemp&) = delete;
    MLLinOpTemp (MLLinOpTemp&&) = delete;
    MLLinOpTemp& operator= (const MLLinOpTemp&) = delete;
    MLLinOpTemp& operator= (MLLinOpTemp&&) = delete;
 
    MLLinOpTemp (const amrex::Vector<amrex::Geometry>& a_geom,
                 const amrex::Vector<amrex::BoxArray>& a_grids,
                 const amrex::Vector<amrex::DistributionMapping>& a_dmap,
                 const amrex::LPInfo& a_info = amrex::LPInfo(),
                 const amrex::Vector<amrex::FabFactory<amrex::FArrayBox> const*>& a_factory = {})
    {
        define(a_geom, a_grids, a_dmap, a_info, a_factory);
    }
 
    void define (const amrex::Vector<amrex::Geometry>& a_geom,
                 const amrex::Vector<amrex::BoxArray>& a_grids,
                 const amrex::Vector<amrex::DistributionMapping>& a_dmap,
                 const amrex::LPInfo& a_info = amrex::LPInfo(),
                 const amrex::Vector<amrex::FabFactory<amrex::FArrayBox> const*>& a_factory = {})
    {
        amrex::MLLinOp::define(a_geom, a_grids, a_dmap, a_info, a_factory);
    }
 
    virtual amrex::BottomSolver getDefaultBottomSolver () const override {
        return amrex::BottomSolver::smoother;
    }
 
    virtual amrex::Any AnyMake (int amrlev, int mglev, amrex::IntVect const& ng) const override
    {
        auto const& ba = m_grids[amrlev][mglev];
        auto const& dm = m_dmap [amrlev][mglev];
        auto const& fc = *m_factory[amrlev][mglev];
        return amrex::Any(Container{amrex::MultiFab(amrex::convert(ba,amrex::IntVect(0,1,1)),
                                                    dm, 1, ng, amrex::MFInfo(), fc),
                                    amrex::MultiFab(amrex::convert(ba,amrex::IntVect(1,0,1)),
                                                    dm, 1, ng, amrex::MFInfo(), fc),
                                    amrex::MultiFab(amrex::convert(ba,amrex::IntVect(1,1,0)),
                                                    dm, 1, ng, amrex::MFInfo(), fc)});
    }
 
    virtual amrex::Any AnyMakeCoarseMG (int amrlev, int mglev, amrex::IntVect const& ng) const override
    {
        auto ratio = (amrlev > 0) ? amrex::IntVect(2) : this->mg_coarsen_ratio_vec[mglev];
        auto const& ba = amrex::coarsen(m_grids[amrlev][mglev], ratio);
        auto const& dm = m_dmap[amrlev][mglev];
        return amrex::Any(Container{amrex::MultiFab(amrex::convert(ba,amrex::IntVect(0,1,1)),
                                                    dm, 1, ng),
                                    amrex::MultiFab(amrex::convert(ba,amrex::IntVect(1,0,1)),
                                                    dm, 1, ng),
                                    amrex::MultiFab(amrex::convert(ba,amrex::IntVect(1,1,0)),
                                                    dm, 1, ng)});
    }
 
    virtual amrex::Any AnyMakeCoarseAmr (int famrlev, amrex::IntVect const& ng) const override
    {
        amrex::IntVect ratio(this->AMRRefRatio(famrlev-1));
        auto const& ba = amrex::coarsen(m_grids[famrlev][0], ratio);
        auto const& dm = m_dmap[famrlev][0];
        return amrex::Any(Container{amrex::MultiFab(amrex::convert(ba,amrex::IntVect(0,1,1)),
                                                    dm, 1, ng),
                                    amrex::MultiFab(amrex::convert(ba,amrex::IntVect(1,0,1)),
                                                    dm, 1, ng),
                                    amrex::MultiFab(amrex::convert(ba,amrex::IntVect(1,1,0)),
                                                    dm, 1, ng)});
    }
 
    virtual amrex::Any AnyMakeAlias (amrex::Any const& a) const override
    {
        auto const& rhs = a.get<Container>();
        return amrex::Any(Container{amrex::MultiFab(rhs[0], amrex::make_alias, 0, 1),
                                    amrex::MultiFab(rhs[1], amrex::make_alias, 0, 1),
                                    amrex::MultiFab(rhs[2], amrex::make_alias, 0, 1)});
    }
 
    virtual amrex::IntVect AnyGrowVect (amrex::Any const& a) const override
    {
        auto const& mfs = a.get<Container>();
        return mfs[0].nGrowVect();
    }
 
    virtual void AnyCopy (amrex::Any& dst, amrex::Any const& src, amrex::IntVect const& ng) const override
    {
        auto& dmf = dst.get<Container>();
        auto const& smf = src.get<Container>();
        for (int idim=0; idim < 3; ++idim) {
            amrex::MultiFab::Copy(dmf[idim], smf[idim], 0, 0, 1, ng);
        }
    }
 
    virtual void AnyAdd (amrex::Any& dst, amrex::Any const& src, amrex::IntVect const& ng) const override
    {
        auto& dmf = dst.get<Container>();
        auto const& smf = src.get<Container>();
        for (int idim=0; idim < 3; ++idim) {
            amrex::MultiFab::Add(dmf[idim], smf[idim], 0, 0, 1, ng);
        }
    }
 
    virtual void AnySetToZero (amrex::Any& a) const override
    {
        auto& mfs = a.get<Container>();
        for (int idim=0; idim < 3; ++idim) {
            mfs[idim].setVal(amrex::Real(0.0));
        }
    }
 
    virtual void AnySetBndryToZero (amrex::Any& a) const override
    {
        auto& mfs = a.get<Container>();
        for (int idim=0; idim < 3; ++idim) {
            mfs[idim].setBndry(amrex::Real(0.0), 0, 1);
        }
    }
 
#ifdef AMREX_USE_EB
    virtual void AnySetCoveredToZero (amrex::Any& a) const override
    {
        auto& mfs = a.get<Container>();
        for (int idim=0; idim < 3; ++idim) {
            amrex::EB_set_covered(mfs[idim], 0, 1, 0, amrex::Real(0.0));
        }
    }
#endif
 
    virtual void AnyParallelCopy (amrex::Any& dst, amrex::Any const& src,
                                  amrex::IntVect const& src_nghost, amrex::IntVect const& dst_nghost,
                                  amrex::Periodicity const& period = amrex::Periodicity::NonPeriodic()) const override
    {
        auto& dmf = dst.get<Container>();
        auto const& smf = src.get<Container>();
        for (int idim=0; idim < 3; ++idim) {
            dmf[idim].ParallelCopy_nowait(smf[idim], 0, 0, 1, src_nghost, dst_nghost, period);
        }
        for (int idim=0; idim < 3; ++idim) {
            dmf[idim].ParallelCopy_finish();
        }
    }
 
    virtual amrex::Real AnyNormInf (amrex::Any& a) const override
    {
        auto& mfs = a.get<Container>();
        amrex::Real r = amrex::Real(0.0);
        for (int idim=0; idim < 3; ++idim) {
            auto tmp = mfs[idim].norminf(0, 0, true);
            r = std::max(r, tmp);
        }
        amrex::ParallelAllReduce::Max(r, amrex::ParallelContext::CommunicatorSub());
        return r;
    }
 
    virtual amrex::Real AnyNormInfMask (int amrlev, amrex::Any const& a, bool local) const override
    {
        amrex::ignore_unused(amrlev, a, local);
        amrex::Abort("TODO: AnyNormInfMask");
        // This is only needed for multi-level composite solve
        return amrex::Real(0.0);
    }
 
    virtual void AnySolutionResidual (int amrlev, amrex::Any& resid, amrex::Any& x, amrex::Any const& b,
                                      amrex::Any const* crse_bcdata = nullptr) override
    {
        amrex::ignore_unused(amrlev, resid, x, b, crse_bcdata);
        amrex::Abort("TODO: AnySolutionResidual");
    }
 
    virtual void AnyCorrectionResidual (int amrlev, int mglev, amrex::Any& resid, amrex::Any& x,
                                        const amrex::Any& b, MLLinOp::BCMode bc_mode,
                                        const amrex::Any* crse_bcdata=nullptr) override
    {
        amrex::ignore_unused(amrlev, mglev, resid, x, b, bc_mode, crse_bcdata);
        amrex::Abort("TODO: AnyCorrectionResidual");
    }
 
    virtual void AnyReflux (int crse_amrlev,
                            amrex::Any& res, const amrex::Any& crse_sol, const amrex::Any& crse_rhs,
                            amrex::Any& fine_res, amrex::Any& fine_sol, const amrex::Any& fine_rhs) override
    {
        amrex::ignore_unused(crse_amrlev, res, crse_sol, crse_rhs, fine_res, fine_sol, fine_rhs);
        amrex::Abort("TODO: AnyReflux");
        // This is only needed for multi-level composite solve
    }
 
    virtual void AnyAvgDownResAmr (int clev, amrex::Any& cres, amrex::Any const& fres) const override
    {
        amrex::ignore_unused(clev, cres, fres);
        amrex::Abort("TODO: AnyAvgDownResAmr");
        // This is only needed for mulit-level composite solve.
        // And maybe there is nothing neeed to be done here, like in the nodal projection solver.
    }
 
    virtual void AnyAvgDownResMG (int clev, amrex::Any& cres, amrex::Any const& fres) const override
    {
        amrex::ignore_unused(clev, cres, fres);
        amrex::Abort("TODO: AnyAvgDownResMG"); // Not needed for V-cycle.
    }
 
    virtual void AnySmooth (int amrlev, int mglev, amrex::Any& sol, const amrex::Any& rhs,
                            bool skip_fillboundary=false) const override
    {
        amrex::ignore_unused(amrlev, mglev, sol, rhs, skip_fillboundary);
        amrex::Abort("TODO: AnySmooth");
    }
 
    virtual void AnyRestriction (int amrlev, int cmglev, amrex::Any& crse, amrex::Any& fine) const override
    {
        amrex::ignore_unused(amrlev, cmglev, crse, fine);
        amrex::Abort("TODO: AnyRestriction");
    }
 
    virtual void AnyInterpolationMG (int amrlev, int fmglev, amrex::Any& fine, const amrex::Any& crse) const override
    {
        amrex::ignore_unused(amrlev, fmglev, fine, crse);
        amrex::Abort("TODO: AnyInterpolationMG");
    }
 
    virtual void AnyInterpAssignMG (int amrlev, int fmglev, amrex::Any& fine, amrex::Any& crse) const override
    {
        amrex::ignore_unused(amrlev, fmglev, fine, crse);
        amrex::Abort("TODO: AnyInterpAssignMG"); // not needed for V-cycle.
    }
 
    virtual void AnyInterpolationAmr (int famrlev, amrex::Any& fine, const amrex::Any& crse,
                                      amrex::IntVect const& /*nghost*/) const override
    {
        amrex::ignore_unused(famrlev, fine, crse);
        // This is only needed for multi-level composite solve
        amrex::Abort("TODO: AnyInterpolationAmr");
    }
 
    virtual void AnyAverageDownSolutionRHS (int camrlev, amrex::Any& crse_sol, amrex::Any& crse_rhs,
                                            const amrex::Any& fine_sol, const amrex::Any& fine_rhs) override
    {
        amrex::ignore_unused(camrlev, crse_sol, crse_rhs, fine_sol, fine_rhs);
        // This is only needed for multi-level composite solve
        amrex::Abort("AnyAverageDownSolutionRHS");
    }
 
    virtual void AnyAverageDownAndSync (amrex::Vector<amrex::Any>& sol) const override
    {
        amrex::ignore_unused(sol);
        // Even for single level, we shoudl synchronize the data on level 0.
        amrex::Abort("TODO: AnyAverageDownAndSync");
    }
 
    virtual void prepareForSolve () override
    {
        amrex::Abort("TODO: prepareForSolve");
    }
};
 
}
 
 
#endif