eb_ Class Reference

#include <ERF_EB.H>

Collaboration diagram for eb_:

Classes
class	EBToPVD

Public Member Functions
	~eb_ ()
	eb_ (amrex::Geometry const &a_geom, amrex::FArrayBox const &terrain_fab, amrex::Gpu::DeviceVector< amrex::Real > &a_dz_stretched, bool is_anelastic)
	eb_ ()
void	define (int level, amrex::Geometry const &a_geom, amrex::EB2::Level const *a_eb_level, bool is_anelastic)
void	make_factory (int level, amrex::Geometry const &a_geom, amrex::BoxArray const &ba, amrex::DistributionMapping const &dm, amrex::EB2::Level const &a_eb_level)
int	nghost_basic () const
int	nghost_volume () const
int	nghost_full () const
const std::unique_ptr< amrex::EBFArrayBoxFactory > &	get_const_factory () const noexcept
void	WriteEBSurface (const amrex::BoxArray &ba, const amrex::DistributionMapping &dmap, const amrex::Geometry &geom, const amrex::EBFArrayBoxFactory *ebf, const int level)
eb_aux_ const *	get_u_const_factory () const noexcept
eb_aux_ const *	get_v_const_factory () const noexcept
eb_aux_ const *	get_w_const_factory () const noexcept

Private Member Functions
void	make_box (amrex::Geometry const &a_geom)
void	make_terrain (amrex::Geometry const &a_geom)
template<class F >
void	build_level (amrex::Geometry const &a_geom, amrex::EB2::GeometryShop< F > a_gshop)
	Construct EB levels from Geometry shop. More...

Private Attributes
int	m_has_eb
std::string	m_type
amrex::EBSupport	m_support_level
int	m_write_eb_surface
amrex::FabArray< amrex::EBCellFlagFab > *	m_cellflags = nullptr
amrex::EB2::Level const *	m_eb_level
	EB level constructed from building GeometryShop. More...
std::unique_ptr< amrex::EBFArrayBoxFactory >	m_factory
eb_aux_	m_u_factory
eb_aux_	m_v_factory
eb_aux_	m_w_factory

Constructor & Destructor Documentation

~eb_()

eb_::~eb_

(

)

{
  // if (m_factory) { m_factory.reset(nullptr); }
}

eb_() [1/2]

eb_::eb_	(	amrex::Geometry const &	a_geom,
		amrex::FArrayBox const &	terrain_fab,
		amrex::Gpu::DeviceVector< amrex::Real > &	a_dz_stretched,
		bool	is_anelastic
	)

eb_() [2/2]

eb_::eb_

(

)

    : m_has_eb(0),
      m_support_level(EBSupport::full),
      m_write_eb_surface(0)
{ }

Member Function Documentation

build_level()

template<class F >

void eb_::build_level ( amrex::Geometry const &  a_geom, amrex::EB2::GeometryShop< F >  a_gshop  )

inlineprivate

Construct EB levels from Geometry shop.

    {
      int const req_lev(0);
      int const max_lev(2);
 
      amrex::EB2::Build(a_gshop, a_geom, req_lev, max_lev);
      const amrex::EB2::IndexSpace& ebis = amrex::EB2::IndexSpace::top();
      m_eb_level = &(ebis.getLevel(a_geom));
    }

define()

void eb_::define	(	int	level,
		amrex::Geometry const &	a_geom,
		amrex::EB2::Level const *	a_eb_level,
		bool	is_anelastic
	)

get_const_factory()

const std::unique_ptr<amrex::EBFArrayBoxFactory>& eb_::get_const_factory ( ) const

inlinenoexcept

{ return m_factory; }

Referenced by ERF::estTimeStep().

Here is the caller graph for this function:

get_u_const_factory()

eb_aux_ const* eb_::get_u_const_factory ( ) const

inlinenoexcept

{ return &m_u_factory; }

get_v_const_factory()

eb_aux_ const* eb_::get_v_const_factory ( ) const

inlinenoexcept

{ return &m_v_factory; }

get_w_const_factory()

eb_aux_ const* eb_::get_w_const_factory ( ) const

inlinenoexcept

{ return &m_w_factory; }

make_box()

void eb_::make_box ( amrex::Geometry const &  a_geom )

private

{
  ParmParse pp_box("eb.box");
 
  bool inside = true;
 
  Vector<Real> boxLo(AMREX_SPACEDIM), boxHi(AMREX_SPACEDIM);
 
  Real const* dx = a_geom.CellSize();
 
  if ( !almostEqual(dx[0],dx[1]) || !almostEqual(dx[1],dx[2])) {
    amrex::Error(" EB Error: Mesh spacing must be uniform!.\n");
  }
 
  Real offset = 0.01*dx[0];
 
  for (int i = 0; i < AMREX_SPACEDIM; i++) {
      boxLo[i] = a_geom.ProbLo(i);
      boxHi[i] = a_geom.ProbHi(i);
  }
 
  pp_box.queryarr("lo", boxLo,  0, AMREX_SPACEDIM);
  pp_box.queryarr("hi", boxHi,  0, AMREX_SPACEDIM);
 
  pp_box.query("internal_flow", inside);
  pp_box.query("offset", offset);
 
  Real xlo = boxLo[0] + offset;
  Real xhi = boxHi[0] - offset;
 
  // This ensures that the walls won't even touch the ghost cells. By
  // putting them one domain width away
  if (a_geom.isPeriodic(0))
  {
      xlo = 2.0*a_geom.ProbLo(0) - a_geom.ProbHi(0);
      xhi = 2.0*a_geom.ProbHi(0) - a_geom.ProbLo(0);
  }
 
 
  Real ylo = boxLo[1] + offset;
  Real yhi = boxHi[1] - offset;
 
  // This ensures that the walls won't even touch the ghost cells. By
  // putting them one domain width away
  if (a_geom.isPeriodic(1))
  {
      ylo = 2.0*a_geom.ProbLo(1) - a_geom.ProbHi(1);
      yhi = 2.0*a_geom.ProbHi(1) - a_geom.ProbLo(1);
  }
 
  Real zlo = boxLo[2] + offset;
  Real zhi = boxHi[2] - offset;
 
  // This ensures that the walls won't even touch the ghost cells. By
  // putting them one domain width away
  if (a_geom.isPeriodic(2))
  {
      zlo = 2.0*a_geom.ProbLo(2) - a_geom.ProbHi(2);
      zhi = 2.0*a_geom.ProbHi(2) - a_geom.ProbLo(2);
  }
 
  Array<Real,3>  point_lox{ xlo, 0.0, 0.0};
  Array<Real,3> normal_lox{-1.0, 0.0, 0.0};
  Array<Real,3>  point_hix{ xhi, 0.0, 0.0};
  Array<Real,3> normal_hix{ 1.0, 0.0, 0.0};
 
  Array<Real,3>  point_loy{0.0, ylo, 0.0};
  Array<Real,3> normal_loy{0.0,-1.0, 0.0};
  Array<Real,3>  point_hiy{0.0, yhi, 0.0};
  Array<Real,3> normal_hiy{0.0, 1.0, 0.0};
 
  Array<Real,3>  point_loz{0.0, 0.0, zlo};
  Array<Real,3> normal_loz{0.0, 0.0,-1.0};
  Array<Real,3>  point_hiz{0.0, 0.0, zhi};
  Array<Real,3> normal_hiz{0.0, 0.0, 1.0};
 
  EB2::PlaneIF plane_lox(point_lox,normal_lox);
  EB2::PlaneIF plane_hix(point_hix,normal_hix);
 
  EB2::PlaneIF plane_loy(point_loy,normal_loy);
  EB2::PlaneIF plane_hiy(point_hiy,normal_hiy);
 
  EB2::PlaneIF plane_loz(point_loz,normal_loz);
  EB2::PlaneIF plane_hiz(point_hiz,normal_hiz);
 
  auto box = EB2::makeUnion(plane_lox, plane_hix, plane_loy,
                            plane_hiy, plane_loz, plane_hiz );
 
 
  if( inside ) {
 
    auto gshop = EB2::makeShop(box);
    build_level(a_geom, gshop);
 
  } else {
 
    auto xob = EB2::makeComplement(box);
    auto gshop = EB2::makeShop(xob);
 
    build_level(a_geom, gshop);
  }
 
}

Here is the call graph for this function:

make_factory()

void eb_::make_factory	(	int	level,
		amrex::Geometry const &	a_geom,
		amrex::BoxArray const &	ba,
		amrex::DistributionMapping const &	dm,
		amrex::EB2::Level const &	a_eb_level
	)

{
 
  Print() << "making EB factory\n";
  m_factory = std::make_unique<EBFArrayBoxFactory>(a_eb_level, a_geom, ba, dm,
    Vector<int>{nghost_basic(), nghost_volume(), nghost_full()}, m_support_level);
 
  eb_::WriteEBSurface(ba, dm, a_geom, m_factory.get(), level);
 
  { int const idim(0);
 
    Print() << "making EB staggered u-factory\n";
    //m_u_factory.set_verbose();
    m_u_factory.define(idim, a_geom, ba, dm,
      Vector<int>{nghost_basic(), nghost_volume(), nghost_full()},
      m_factory.get());
  }
 
  { int const idim(1);
    Print() << "making EB staggered v-factory\n";
    //m_v_factory.set_verbose();
    m_v_factory.define(idim, a_geom, ba, dm,
      Vector<int>{nghost_basic(), nghost_volume(), nghost_full()},
      m_factory.get());
  }
 
  { int const idim(2);
    Print() << "making EB staggered w-factory\n";
    //m_w_factory.set_verbose();
    m_w_factory.define(idim, a_geom, ba, dm,
      Vector<int>{nghost_basic(), nghost_volume(), nghost_full()},
      m_factory.get());
  }
 
  Print() << "\nDone making EB factory.\n\n";
}

Here is the call graph for this function:

make_terrain()

void eb_::make_terrain ( amrex::Geometry const &  a_geom )

private

nghost_basic()

int eb_::nghost_basic ( ) const

inline

{ return 5; } // nghost_eb_basic ()

Referenced by make_factory().

Here is the caller graph for this function:

nghost_full()

int eb_::nghost_full ( ) const

inline

{ return 4; } // nghost_eb_full ()

Referenced by make_factory().

Here is the caller graph for this function:

nghost_volume()

int eb_::nghost_volume ( ) const

inline

{ return 5; } // nghost_eb_volume ()

Referenced by make_factory().

Here is the caller graph for this function:

WriteEBSurface()

void eb_::WriteEBSurface	(	const amrex::BoxArray &	ba,
		const amrex::DistributionMapping &	dmap,
		const amrex::Geometry &	geom,
		const amrex::EBFArrayBoxFactory *	ebf,
		const int	level
	)

{
 
    EBToPVD eb_to_pvd;
 
    const Real* dx           = geom.CellSize();
    const Real* problo       = geom.ProbLo();
 
    MultiFab mf_ba(ba, dmap, 1, 0, MFInfo(), *ebf);
 
    for (MFIter mfi(mf_ba); mfi.isValid(); ++mfi) {
 
        const auto & sfab    = static_cast<EBFArrayBox const &>(mf_ba[mfi]);
        const auto & my_flag = sfab.getEBCellFlagFab();
        const auto * my_flag_ptr = &my_flag;
 
        const Box & bx = mfi.validbox();
 
        if (my_flag.getType(bx) == FabType::covered ||
            my_flag.getType(bx) == FabType::regular) { continue; }
 
        std::array<const CutFab *, AMREX_SPACEDIM> areafrac;
        const CutFab * bndrycent;
 
        for (int d = 0; d < AMREX_SPACEDIM; ++d) {
            areafrac[d]  =   &(*ebf->getAreaFrac()[d])[mfi];
        }
        bndrycent = &(ebf->getBndryCent()[mfi]);
 
#ifdef AMREX_USE_GPU
        std::unique_ptr<EBCellFlagFab> host_flag;
        if (my_flag.arena()->isManaged() || my_flag.arena()->isDevice()) {
            host_flag = std::make_unique<EBCellFlagFab>(my_flag.box(), my_flag.nComp(),
                                                  The_Pinned_Arena());
            Gpu::dtoh_memcpy_async(host_flag->dataPtr(), my_flag.dataPtr(),
                                   host_flag->nBytes());
            Gpu::streamSynchronize();
            my_flag_ptr = host_flag.get();
        }
 
        std::array<std::unique_ptr<CutFab>, AMREX_SPACEDIM> areafrac_h;
        for (int d = 0; d < AMREX_SPACEDIM; ++d) {
            if (areafrac[d]->arena()->isManaged() || areafrac[d]->arena()->isDevice()) {
                areafrac_h[d] = std::make_unique<CutFab>(areafrac[d]->box(), areafrac[d]->nComp(),
                                                           The_Pinned_Arena());
                Gpu::dtoh_memcpy_async(areafrac_h[d]->dataPtr(), areafrac[d]->dataPtr(),
                                       areafrac[d]->size()*sizeof(Real));
                Gpu::streamSynchronize();
                areafrac[d] = areafrac_h[d].get();
            }
        }
 
        std::unique_ptr<CutFab> bndrycent_h;
        if (bndrycent->arena()->isManaged() || bndrycent->arena()->isDevice()) {
            bndrycent_h = std::make_unique<CutFab>(bndrycent->box(), bndrycent->nComp(),
                                                        The_Pinned_Arena());
            Gpu::dtoh_memcpy_async(bndrycent_h->dataPtr(), bndrycent->dataPtr(),
                                   bndrycent->size()*sizeof(Real));
            Gpu::streamSynchronize();
            bndrycent = bndrycent_h.get();
        }
#endif
 
        eb_to_pvd.EBToPolygon(
                problo, dx,
                bx, my_flag_ptr->const_array(),
                bndrycent->const_array(),
                areafrac[0]->const_array(),
                areafrac[1]->const_array(),
                areafrac[2]->const_array());
    }
 
    int cpu = ParallelDescriptor::MyProc();
    int nProcs = ParallelDescriptor::NProcs();
 
    eb_to_pvd.WriteEBVTP(cpu, level);
 
    if(ParallelDescriptor::IOProcessor()) {
        EBToPVD::WritePVTP(nProcs);
    }
 
    for (MFIter mfi(mf_ba); mfi.isValid(); ++mfi) {
 
        const auto & sfab    = static_cast<EBFArrayBox const &>(mf_ba[mfi]);
        const auto & my_flag = sfab.getEBCellFlagFab();
        const auto * my_flag_ptr = &my_flag;
 
        const Box & bx = mfi.validbox();
 
        if (my_flag.getType(bx) == FabType::covered ||
            my_flag.getType(bx) == FabType::regular) { continue; }
 
#ifdef AMREX_USE_GPU
        std::unique_ptr<EBCellFlagFab> host_flag;
        if (my_flag.arena()->isManaged() || my_flag.arena()->isDevice()) {
            host_flag = std::make_unique<EBCellFlagFab>(my_flag.box(), my_flag.nComp(),
                                                  The_Pinned_Arena());
            Gpu::dtoh_memcpy_async(host_flag->dataPtr(), my_flag.dataPtr(),
                                   host_flag->nBytes());
            Gpu::streamSynchronize();
            my_flag_ptr = host_flag.get();
        }
#endif
 
        eb_to_pvd.EBGridCoverage(cpu, problo, dx, bx, my_flag_ptr->const_array());
    }
}

Referenced by make_factory().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_cellflags

amrex::FabArray<amrex::EBCellFlagFab>* eb_::m_cellflags = nullptr

private

m_eb_level

amrex::EB2::Level const* eb_::m_eb_level

private

EB level constructed from building GeometryShop.

Referenced by build_level().

m_factory

std::unique_ptr<amrex::EBFArrayBoxFactory> eb_::m_factory

private

Referenced by get_const_factory(), and make_factory().

m_has_eb

int eb_::m_has_eb

private

m_support_level

amrex::EBSupport eb_::m_support_level

private

Referenced by make_factory().

m_type

std::string eb_::m_type

private

m_u_factory

eb_aux_ eb_::m_u_factory

private

Referenced by get_u_const_factory(), and make_factory().

m_v_factory

eb_aux_ eb_::m_v_factory

private

Referenced by get_v_const_factory(), and make_factory().

m_w_factory

eb_aux_ eb_::m_w_factory

private

Referenced by get_w_const_factory(), and make_factory().

m_write_eb_surface

int eb_::m_write_eb_surface

private

---

The documentation for this class was generated from the following files:

• Source/EB/ERF_EB.H
• Source/EB/ERF_EB.cpp
• Source/EB/ERF_EBBox.cpp