eb_ Class Reference

Owns and exposes cell-centered and face-centered EB factories. More...

#include <ERF_EB.H>

Collaboration diagram for eb_:

Public Types
using	CutCellList = amrex::Gpu::DeviceVector< amrex::Dim3 >

Public Member Functions
	~eb_ ()
	Destroy the EB factory manager. More...
	eb_ (amrex::Geometry const &a_geom, amrex::FArrayBox const &terrain_fab, amrex::Gpu::DeviceVector< amrex::Real > &a_dz_stretched, bool is_anelastic)
	Construct an EB description from terrain data. More...
	eb_ ()
	Construct an empty EB factory manager. More...
void	define (int level, amrex::Geometry const &a_geom, amrex::EB2::Level const *a_eb_level, bool is_anelastic)
	Define the EB level metadata used by this factory manager. More...
void	make_all_factories (int level, amrex::Geometry const &a_geom, amrex::BoxArray const &ba, amrex::DistributionMapping const &dm, amrex::EB2::Level const &a_eb_level)
	Build cell-centered and staggered EB factories for the level. More...
void	make_cc_factory (int level, amrex::Geometry const &a_geom, amrex::BoxArray const &ba, amrex::DistributionMapping const &dm, amrex::EB2::Level const &a_eb_level)
	Build only the cell-centered EB factory for the level. More...
int	nghost_basic () const
	Number of ghost cells needed for basic EB flags. More...
int	nghost_volume () const
	Number of ghost cells needed for EB volume data. More...
int	nghost_full () const
	Number of ghost cells needed for full EB geometric data. More...
CutCellList const &	get_u_cut_cells (int grid_index) const noexcept
	Return cut x-faces owned by a grid, cached when the EB factories are built. More...
CutCellList const &	get_v_cut_cells (int grid_index) const noexcept
	Return cut y-faces owned by a grid, cached when the EB factories are built. More...
CutCellList const &	get_w_cut_cells (int grid_index) const noexcept
	Return cut z-faces owned by a grid, cached when the EB factories are built. More...
const std::unique_ptr< amrex::EBFArrayBoxFactory > &	get_const_factory () const noexcept
	Return the cell-centered EB factory. More...
void	set_connection_flags (amrex::EBFArrayBoxFactory *factory)
	Disconnect covered neighbors in an EB factory's cell flags. More...
void	mask_fc_from_cc (amrex::EBFArrayBoxFactory *fc_factory, const amrex::EBFArrayBoxFactory *cc_factory, int idim)
	Enforce FC-CC consistency by marking FC faces as covered when both CC neighbors are covered. More...
amrex::EBFArrayBoxFactory const *	get_u_const_factory () const noexcept
	Return the native AMReX x-face EB factory. More...
amrex::EBFArrayBoxFactory const *	get_v_const_factory () const noexcept
	Return the native AMReX y-face EB factory. More...
amrex::EBFArrayBoxFactory const *	get_w_const_factory () const noexcept
	Return the native AMReX z-face EB factory. More...

Private Member Functions
void	build_cut_cell_lists (amrex::FabArray< amrex::EBCellFlagFab > const &flags, amrex::Vector< CutCellList > &cut_cells)
void	make_terrain (amrex::Geometry const &a_geom)
	Build terrain EB geometry for the supplied Geometry. More...
template<class F >
void	build_level (amrex::Geometry const &a_geom, amrex::EB2::GeometryShop< F > a_gshop)
	Construct EB levels from an AMReX GeometryShop. More...
amrex::FabArray< amrex::EBCellFlagFab > &	getNonConstEBCellFlags (const amrex::EBFArrayBoxFactory &ebfact)
	Return mutable EB cell flags from an AMReX factory. More...
amrex::MultiFab &	getNonConstVolFrac (const amrex::EBFArrayBoxFactory &ebfact)
	Return mutable volume fractions from an AMReX factory. More...
amrex::MultiCutFab &	getNonConstCentroid (const amrex::EBFArrayBoxFactory &ebfact)
	Return mutable cell centroids from an AMReX factory. More...
amrex::Array< amrex::MultiCutFab *, AMREX_SPACEDIM >	getNonConstAreaFrac (const amrex::EBFArrayBoxFactory &ebfact)
	Return mutable area-fraction arrays from an AMReX factory. More...
amrex::Array< amrex::MultiCutFab *, AMREX_SPACEDIM >	getNonConstFaceCent (const amrex::EBFArrayBoxFactory &ebfact)
	Return mutable face-centroid arrays from an AMReX factory. 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 = nullptr
eb_aux_	m_u_factory
eb_aux_	m_v_factory
eb_aux_	m_w_factory
std::unique_ptr< amrex::EBFArrayBoxFactory >	m_u_factory_fc = nullptr
std::unique_ptr< amrex::EBFArrayBoxFactory >	m_v_factory_fc = nullptr
std::unique_ptr< amrex::EBFArrayBoxFactory >	m_w_factory_fc = nullptr
amrex::Vector< CutCellList >	m_u_cut_cells
amrex::Vector< CutCellList >	m_v_cut_cells
amrex::Vector< CutCellList >	m_w_cut_cells

Detailed Description

Owns and exposes cell-centered and face-centered EB factories.

The class builds AMReX EB factories for cell-centered state data and, depending on USE_FC_FACTORY, either native AMReX or ERF auxiliary factories for staggered velocity components.

Member Typedef Documentation

CutCellList

using eb_::CutCellList = amrex::Gpu::DeviceVector<amrex::Dim3>

Constructor & Destructor Documentation

~eb_()

eb_::~eb_

(

)

Destroy the EB factory manager.

{
    // 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
	)

Construct an EB description from terrain data.

Parameters

a_geom	Geometry used to place the terrain EB.
terrain_fab	Terrain height data.
a_dz_stretched	Device vector containing stretched vertical spacing.
is_anelastic	Whether the owning level is using anelastic dynamics.

eb_() [2/2]

eb_::eb_

(

)

Construct an empty EB factory manager.

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

Member Function Documentation

build_cut_cell_lists()

void eb_::build_cut_cell_lists ( amrex::FabArray< amrex::EBCellFlagFab > const &  flags, amrex::Vector< CutCellList > &  cut_cells  )

private

{
    BL_PROFILE("eb_::build_cut_cell_lists()");
 
    cut_cells.clear();
    cut_cells.resize(flags.boxArray().size());
 
#ifdef AMREX_USE_GPU
    for (MFIter mfi(flags, false); mfi.isValid(); ++mfi) {
        Box const& bx = mfi.validbox();
        if (flags[mfi].getType(bx) != FabType::singlevalued) {
            continue;
        }
 
        Array4<EBCellFlag const> const& flag = flags.const_array(mfi);
        Long const num_candidates = bx.numPts();
        CutCellList grid_cut_cells(num_candidates);
        Dim3* const grid_cut_cells_ptr = grid_cut_cells.data();
 
        int const num_cut_cells = fill_cut_cell_list(bx, flag, grid_cut_cells_ptr);
 
        grid_cut_cells.resize(num_cut_cells);
        grid_cut_cells.shrink_to_fit();
        cut_cells[mfi.index()] = std::move(grid_cut_cells);
    }
#else
    amrex::ignore_unused(flags);
#endif
}

Referenced by make_all_factories().

Here is the caller graph for this function:

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 an AMReX GeometryShop.

Template Parameters

F	Implicit-function type stored by the GeometryShop.

Parameters

a_geom	Geometry used to build the EB index space.
a_gshop	GeometryShop describing the implicit EB.

    {
      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
	)

Define the EB level metadata used by this factory manager.

Parameters

level	AMR level index.
a_geom	Geometry for the level.
a_eb_level	AMReX EB level owned by the global EB index space.
is_anelastic	Whether the owning level is using anelastic dynamics.

get_const_factory()

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

inlinenoexcept

Return the cell-centered EB factory.

{ return m_factory; }

Referenced by compute_gradp_xy(), compute_gradp_z(), ComputeTurbulentViscosityLES_EB(), erf_make_tau_terms(), erf_slow_rhs_post(), erf_slow_rhs_pre(), ERF::estTimeStep(), and make_buoyancy().

Here is the caller graph for this function:

get_u_const_factory()

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

inlinenoexcept

Return the native AMReX x-face EB factory.

{ return m_u_factory_fc.get(); }

Referenced by AdvectionSrcForMom_EB(), compute_gradp_xy(), ComputeStrain_EB(), ComputeTurbulentViscosityLES_EB(), DiffusionSrcForMom_EB(), and make_mom_sources().

Here is the caller graph for this function:

get_u_cut_cells()

CutCellList const& eb_::get_u_cut_cells ( int  grid_index ) const

inlinenoexcept

Return cut x-faces owned by a grid, cached when the EB factories are built.

    {
        return m_u_cut_cells[grid_index];
    }

Referenced by DiffusionSrcForMom_EB().

Here is the caller graph for this function:

get_v_const_factory()

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

inlinenoexcept

Return the native AMReX y-face EB factory.

{ return m_v_factory_fc.get(); }

Referenced by AdvectionSrcForMom_EB(), compute_gradp_xy(), ComputeStrain_EB(), ComputeTurbulentViscosityLES_EB(), DiffusionSrcForMom_EB(), and make_mom_sources().

Here is the caller graph for this function:

get_v_cut_cells()

CutCellList const& eb_::get_v_cut_cells ( int  grid_index ) const

inlinenoexcept

Return cut y-faces owned by a grid, cached when the EB factories are built.

    {
        return m_v_cut_cells[grid_index];
    }

Referenced by DiffusionSrcForMom_EB().

Here is the caller graph for this function:

get_w_const_factory()

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

inlinenoexcept

Return the native AMReX z-face EB factory.

{ return m_w_factory_fc.get(); }

Referenced by AdvectionSrcForMom_EB(), compute_gradp_z(), ComputeStrain_EB(), ComputeTurbulentViscosityLES_EB(), DiffusionSrcForMom_EB(), and make_mom_sources().

Here is the caller graph for this function:

get_w_cut_cells()

CutCellList const& eb_::get_w_cut_cells ( int  grid_index ) const

inlinenoexcept

Return cut z-faces owned by a grid, cached when the EB factories are built.

    {
        return m_w_cut_cells[grid_index];
    }

Referenced by DiffusionSrcForMom_EB().

Here is the caller graph for this function:

getNonConstAreaFrac()

amrex::Array<amrex::MultiCutFab*, AMREX_SPACEDIM> eb_::getNonConstAreaFrac ( const amrex::EBFArrayBoxFactory &  ebfact )

inlineprivate

Return mutable area-fraction arrays from an AMReX factory.

    {
      auto afrac_const = ebfact.getAreaFrac();
      amrex::Array<amrex::MultiCutFab*, AMREX_SPACEDIM> afrac;
      for (int dir = 0; dir < AMREX_SPACEDIM; ++dir) {
          afrac[dir] = const_cast<amrex::MultiCutFab*>(afrac_const[dir]);
      }
      return afrac;
    }

getNonConstCentroid()

amrex::MultiCutFab& eb_::getNonConstCentroid ( const amrex::EBFArrayBoxFactory &  ebfact )

inlineprivate

Return mutable cell centroids from an AMReX factory.

    {
      const amrex::MultiCutFab& vcent_const = ebfact.getCentroid();
      return const_cast<amrex::MultiCutFab&>(vcent_const);
    }

getNonConstEBCellFlags()

amrex::FabArray<amrex::EBCellFlagFab>& eb_::getNonConstEBCellFlags ( const amrex::EBFArrayBoxFactory &  ebfact )

inlineprivate

Return mutable EB cell flags from an AMReX factory.

    {
      const amrex::FabArray<amrex::EBCellFlagFab>& flags_const = ebfact.getMultiEBCellFlagFab();
      return const_cast<amrex::FabArray<amrex::EBCellFlagFab>&>(flags_const);
    }

Referenced by mask_fc_from_cc(), and set_connection_flags().

Here is the caller graph for this function:

getNonConstFaceCent()

amrex::Array<amrex::MultiCutFab*, AMREX_SPACEDIM> eb_::getNonConstFaceCent ( const amrex::EBFArrayBoxFactory &  ebfact )

inlineprivate

Return mutable face-centroid arrays from an AMReX factory.

    {
      auto fcent_const = ebfact.getFaceCent();
      amrex::Array<amrex::MultiCutFab*, AMREX_SPACEDIM> fcent;
      for (int dir = 0; dir < AMREX_SPACEDIM; ++dir) {
          fcent[dir] = const_cast<amrex::MultiCutFab*>(fcent_const[dir]);
      }
      return fcent;
    }

getNonConstVolFrac()

amrex::MultiFab& eb_::getNonConstVolFrac ( const amrex::EBFArrayBoxFactory &  ebfact )

inlineprivate

Return mutable volume fractions from an AMReX factory.

    {
      const amrex::MultiFab& vfrac_const = ebfact.getVolFrac();
      return const_cast<amrex::MultiFab&>(vfrac_const);
    }

Referenced by mask_fc_from_cc().

Here is the caller graph for this function:

make_all_factories()

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

Build cell-centered and staggered EB factories for the level.

Parameters

level	AMR level index.
a_geom	Geometry for the level.
ba	BoxArray over which factories are defined.
dm	DistributionMapping for the BoxArray.
a_eb_level	AMReX EB level used to populate factory data.

{
#if USE_FC_FACTORY
    for (int idim = 0; idim < AMREX_SPACEDIM; ++idim) {
        if (!a_eb_level.hasFCData(idim)) {
            Abort("ERF: native face-centered EB data are unavailable at level " +
                  std::to_string(level) + ", direction " + std::to_string(idim) +
                  ". EB2::BuildFC() must successfully build data before factory construction.");
        }
    }
#endif
 
    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);
 
    // Correct cell connectivity
    eb_::set_connection_flags(m_factory.get());
 
#if USE_FC_FACTORY
    // Native AMReX FC factories (EB2::BuildFC called in initializeEB).
    { int const idim(0);
        Print() << "making EB staggered u-factory\n";
        m_u_factory_fc = std::make_unique<EBFArrayBoxFactory>(
            a_eb_level, a_geom, ba, dm,
            Vector<int>{nghost_basic(), nghost_volume(), nghost_full()},
            m_support_level, idim);
        eb_::mask_fc_from_cc(m_u_factory_fc.get(), m_factory.get(), idim);
        eb_::set_connection_flags(m_u_factory_fc.get());
    }
 
    { int const idim(1);
        Print() << "making EB staggered v-factory\n";
        m_v_factory_fc = std::make_unique<EBFArrayBoxFactory>(
            a_eb_level, a_geom, ba, dm,
            Vector<int>{nghost_basic(), nghost_volume(), nghost_full()},
            m_support_level, idim);
        eb_::mask_fc_from_cc(m_v_factory_fc.get(), m_factory.get(), idim);
        eb_::set_connection_flags(m_v_factory_fc.get());
    }
 
    { int const idim(2);
        Print() << "making EB staggered w-factory\n";
        m_w_factory_fc = std::make_unique<EBFArrayBoxFactory>(
            a_eb_level, a_geom, ba, dm,
            Vector<int>{nghost_basic(), nghost_volume(), nghost_full()},
            m_support_level, idim);
        eb_::mask_fc_from_cc(m_w_factory_fc.get(), m_factory.get(), idim);
        eb_::set_connection_flags(m_w_factory_fc.get());
    }
#else
    // Original: eb_aux_ factories
    { int const idim(0);
        Print() << "making EB staggered u-factory\n";
        m_u_factory.define(level, 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.define(level, 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.define(level, idim, a_geom, ba, dm,
            Vector<int>{nghost_basic(), nghost_volume(), nghost_full()},
            m_factory.get());
    }
#endif
 
#if USE_FC_FACTORY
    build_cut_cell_lists(m_u_factory_fc->getMultiEBCellFlagFab(), m_u_cut_cells);
    build_cut_cell_lists(m_v_factory_fc->getMultiEBCellFlagFab(), m_v_cut_cells);
    build_cut_cell_lists(m_w_factory_fc->getMultiEBCellFlagFab(), m_w_cut_cells);
#else
    build_cut_cell_lists(m_u_factory.getMultiEBCellFlagFab(), m_u_cut_cells);
    build_cut_cell_lists(m_v_factory.getMultiEBCellFlagFab(), m_v_cut_cells);
    build_cut_cell_lists(m_w_factory.getMultiEBCellFlagFab(), m_w_cut_cells);
#endif
    Print() << "\nDone making EB factory at level = " << level << ".\n\n";
}

Here is the call graph for this function:

make_cc_factory()

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

Build only the cell-centered EB factory for the level.

Parameters

level	AMR level index.
a_geom	Geometry for the level.
ba	BoxArray over which the factory is defined.
dm	DistributionMapping for the BoxArray.
a_eb_level	AMReX EB level used to populate factory data.

{
    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);
 
    // Correct cell connectivity
    eb_::set_connection_flags(m_factory.get());
 
    m_u_cut_cells.clear();
    m_v_cut_cells.clear();
    m_w_cut_cells.clear();
 
    Print() << "\nDone making EB factory at level " << level << ".\n\n";
}

Here is the call graph for this function:

make_terrain()

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

private

Build terrain EB geometry for the supplied Geometry.

Parameters

a_geom

Geometry used to define the EB index space.

mask_fc_from_cc()

void eb_::mask_fc_from_cc	(	amrex::EBFArrayBoxFactory *	fc_factory,
		const amrex::EBFArrayBoxFactory *	cc_factory,
		int	idim
	)

Enforce FC-CC consistency by marking FC faces as covered when both CC neighbors are covered.

Mask FC faces as covered when both neighboring CC cells are covered.

Parameters

fc_factory	Face-centered factory to modify (non-const)
cc_factory	Cell-centered factory to read neighbor states (const)
idim	Direction of face centering (0=x, 1=y, 2=z)

For each face in the FC factory, if BOTH neighboring cell-centered cells are marked as covered, this function sets the FC face's volume fraction to zero and marks it as covered. This maintains consistency between CC and FC EB representations.

{
 
    FabArray<EBCellFlagFab>& fc_cellflag = getNonConstEBCellFlags(*fc_factory);
    MultiFab& fc_volfrac = getNonConstVolFrac(*fc_factory);
    const FabArray<EBCellFlagFab>& cc_cellflag = cc_factory->getMultiEBCellFlagFab();
 
    for (MFIter mfi(fc_cellflag, false); mfi.isValid(); ++mfi) {
        const Box face_box = mfi.nodaltilebox(idim);
        const Box gbx = amrex::grow(face_box, fc_cellflag.nGrow()-1);
 
        Array4<EBCellFlag> const& fc_flag = fc_cellflag.array(mfi);
        Array4<Real> const& fc_vfrac = fc_volfrac.array(mfi);
        Array4<EBCellFlag const> const& cc_flag = cc_cellflag.const_array(mfi);
 
        if (idim == 0) {
            ParallelFor(gbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
                if (cc_flag(i-1,j,k).isCovered() && cc_flag(i,j,k).isCovered()) {
                    fc_vfrac(i,j,k) = Real(0.0);
                    fc_flag(i,j,k).setCovered();
                }
            });
        } else if (idim == 1) {
            ParallelFor(gbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
                if (cc_flag(i,j-1,k).isCovered() && cc_flag(i,j,k).isCovered()) {
                    fc_vfrac(i,j,k) = Real(0.0);
                    fc_flag(i,j,k).setCovered();
                }
            });
        } else if (idim == 2) {
            ParallelFor(gbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept {
                if (cc_flag(i,j,k-1).isCovered() && cc_flag(i,j,k).isCovered()) {
                    fc_vfrac(i,j,k) = Real(0.0);
                    fc_flag(i,j,k).setCovered();
                }
            });
        }
    }
}

Referenced by make_all_factories().

Here is the call graph for this function:

Here is the caller graph for this function:

nghost_basic()

int eb_::nghost_basic ( ) const

inline

Number of ghost cells needed for basic EB flags.

{ return 5; } // nghost_eb_basic ()

Referenced by make_all_factories(), and make_cc_factory().

Here is the caller graph for this function:

nghost_full()

int eb_::nghost_full ( ) const

inline

Number of ghost cells needed for full EB geometric data.

{ return 4; } // nghost_eb_full ()

Referenced by make_all_factories(), and make_cc_factory().

Here is the caller graph for this function:

nghost_volume()

int eb_::nghost_volume ( ) const

inline

Number of ghost cells needed for EB volume data.

{ return 5; } // nghost_eb_volume ()

Referenced by make_all_factories(), and make_cc_factory().

Here is the caller graph for this function:

set_connection_flags()

void eb_::set_connection_flags

(

amrex::EBFArrayBoxFactory *

factory

)

Disconnect covered neighbors in an EB factory's cell flags.

Reset cell flags to disconnect cells with zero volume fraction.

Parameters

factory

Factory whose non-const flag data are updated.

The factory EBCellFlagFab data are updated through a non-const reference.

{
    // Get non-const reference to EBCellFlagFab FabArray
    FabArray<EBCellFlagFab>& cellflag = getNonConstEBCellFlags(*factory);
 
    const MultiFab& volfrac = factory->getVolFrac();
 
    for (MFIter mfi(cellflag, false); mfi.isValid(); ++mfi) {
        const Box& bx = mfi.validbox();
        const Box gbx = amrex::grow(bx, cellflag.nGrow()-1); // Leave one cell layer
 
        Array4<EBCellFlag> const& flag = cellflag.array(mfi);
        Array4<Real const> const& vfrac = volfrac.const_array(mfi);
 
        ParallelFor(gbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
        {
            for(int kk(-1); kk<=1; kk++) {
            for(int jj(-1); jj<=1; jj++) {
            for(int ii(-1); ii<=1; ii++)
            {
                if (vfrac(i+ii,j+jj,k+kk) == zero) {
                    flag(i,j,k).setDisconnected(ii,jj,kk);
                }
            }}}
        });
 
        ParallelFor(gbx, [=] AMREX_GPU_DEVICE (int i, int j, int k) noexcept
        {
            if (vfrac(i,j,k)==zero) {
                flag(i,j,k).setCovered();
            }
        });
 
    }
}

Referenced by make_all_factories(), and make_cc_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 = nullptr

private

Referenced by get_const_factory(), make_all_factories(), and make_cc_factory().

m_has_eb

int eb_::m_has_eb

private

m_support_level

amrex::EBSupport eb_::m_support_level

private

Referenced by make_all_factories(), and make_cc_factory().

m_type

std::string eb_::m_type

private

m_u_cut_cells

amrex::Vector<CutCellList> eb_::m_u_cut_cells

private

Referenced by get_u_cut_cells(), make_all_factories(), and make_cc_factory().

m_u_factory

eb_aux_ eb_::m_u_factory

private

Referenced by make_all_factories().

m_u_factory_fc

std::unique_ptr<amrex::EBFArrayBoxFactory> eb_::m_u_factory_fc = nullptr

private

Referenced by get_u_const_factory(), and make_all_factories().

m_v_cut_cells

amrex::Vector<CutCellList> eb_::m_v_cut_cells

private

Referenced by get_v_cut_cells(), make_all_factories(), and make_cc_factory().

m_v_factory

eb_aux_ eb_::m_v_factory

private

Referenced by make_all_factories().

m_v_factory_fc

std::unique_ptr<amrex::EBFArrayBoxFactory> eb_::m_v_factory_fc = nullptr

private

Referenced by get_v_const_factory(), and make_all_factories().

m_w_cut_cells

amrex::Vector<CutCellList> eb_::m_w_cut_cells

private

Referenced by get_w_cut_cells(), make_all_factories(), and make_cc_factory().

m_w_factory

eb_aux_ eb_::m_w_factory

private

Referenced by make_all_factories().

m_w_factory_fc

std::unique_ptr<amrex::EBFArrayBoxFactory> eb_::m_w_factory_fc = nullptr

private

Referenced by get_w_const_factory(), and make_all_factories().

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