eb_ Class Reference

#include <ERF_EB.H>

Collaboration diagram for eb_:

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)
void	make_factory (amrex::Geometry const &a_geom, amrex::DistributionMapping const &a_dmap, amrex::BoxArray const &a_grids)
int	nghost_basic () const
int	nghost_volume () const
int	nghost_full () const
amrex::EBFArrayBoxFactory const *	get_const_factory () noexcept
amrex::EB2::Level const *	get_level () 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::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_()

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

    : m_has_eb(0),
      m_support_level(EBSupport::full),
      m_write_eb_surface(0)
{
    m_type = "terrain";
 
    int max_coarsening_level;
    if (is_anelastic) {
        max_coarsening_level = 100;
    } else {
        max_coarsening_level = 0;
    }
 
    int max_level_here = 0;
 
    if (m_type == "terrain")
    {
        Print() << "\nBuilding EB geometry based on terrain.\n";
 
        TerrainIF ebterrain(terrain_fab, a_geom, a_dz_stretched);
 
        auto gshop = EB2::makeShop(ebterrain);
 
        EB2::Build(gshop, a_geom, max_level_here, max_level_here+max_coarsening_level);
 
        m_has_eb = 1;
 
    } else if (m_type == "box") {
 
        Print() << "\nBuilding box geometry.\n";
        make_box(a_geom);
        m_has_eb = 1;
 
    } else {
 
        EB2::AllRegularIF regular;
        auto gshop = EB2::makeShop(regular);
        build_level(a_geom, gshop);
    }
}

Here is the call graph for this function:

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));
    }

Referenced by eb_().

Here is the caller graph for this function:

get_const_factory()

amrex::EBFArrayBoxFactory const* eb_::get_const_factory ( )

inlinenoexcept

    { return m_factory.get(); }

get_level()

amrex::EB2::Level const* eb_::get_level ( ) const

inlinenoexcept

    { return m_eb_level; }

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);
  }
 
}

Referenced by eb_().

Here is the call graph for this function:

Here is the caller graph for this function:

make_factory()

void eb_::make_factory	(	amrex::Geometry const &	a_geom,
		amrex::DistributionMapping const &	a_dmap,
		amrex::BoxArray const &	a_grids
	)

{
  Print() << "making EB factory\n";
  m_factory = std::make_unique<EBFArrayBoxFactory>(*m_eb_level, a_geom, a_grids, a_dmap,
    Vector<int>{nghost_basic(), nghost_volume(), nghost_full()}, m_support_level);
 
  if (m_write_eb_surface) {
    WriteEBSurface(a_grids, a_dmap, a_geom, m_factory.get());
  }
 
  { int const idim(0);
 
    Print() << "making EB staggered u-factory\n";
    //m_u_factory.set_verbose();
    m_u_factory.define(idim, a_geom, a_grids, a_dmap,
      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, a_grids, a_dmap,
      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, a_grids, a_dmap,
      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 2; }

Referenced by make_factory().

Here is the caller graph for this function:

nghost_full()

int eb_::nghost_full ( ) const

inline

{ return 2; }

Referenced by make_factory().

Here is the caller graph for this function:

nghost_volume()

int eb_::nghost_volume ( ) const

inline

{ return 2; }

Referenced by make_factory().

Here is the caller graph for this function:

Member Data Documentation

m_eb_level

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

private

EB level constructed from building GeometryShop.

Referenced by build_level(), get_level(), and make_factory().

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

Referenced by eb_().

m_support_level

amrex::EBSupport eb_::m_support_level

private

Referenced by make_factory().

m_type

std::string eb_::m_type

private

Referenced by eb_().

m_u_factory

eb_aux_ eb_::m_u_factory

private

Referenced by make_factory().

m_v_factory

eb_aux_ eb_::m_v_factory

private

Referenced by make_factory().

m_w_factory

eb_aux_ eb_::m_w_factory

private

Referenced by make_factory().

m_write_eb_surface

int eb_::m_write_eb_surface

private

Referenced by make_factory().

---

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