AMReX EB implicit-function sign convention: >0 is body, 0 is boundary, <0 is fluid. More...

#include <ERF_EBIFTerrain.H>

Inheritance diagram for TerrainIF:

Collaboration diagram for TerrainIF:

[legend]

Public Member Functions
	TerrainIF (amrex::FArrayBox const &a_z_terrain, amrex::Geometry const &a_geom, amrex::Gpu::DeviceVector< amrex::Real > &a_dz_stretched)
	Construct a terrain implicit function from height and geometry data. More...

AMREX_GPU_HOST_DEVICE amrex::Real	operator() (AMREX_D_DECL(amrex::Real x, amrex::Real y, amrex::Real z)) const noexcept
	Evaluate the signed implicit-function value at physical coordinates. More...

AMREX_GPU_HOST_DEVICE amrex::Real	operator() (const amrex::RealArray &p) const noexcept
	Evaluate the signed implicit-function value at a point array. More...

Protected Attributes
amrex::Array4< amrex::Real const >	terr_arr
	Terrain height array sampled on the horizontal mesh. More...

amrex::Real const *	dz_s
	Device pointer to stretched vertical cell sizes. More...

amrex::Real	dx
	Uniform computational grid spacing in each direction. More...

amrex::Real	dy
	Uniform computational grid spacing in y. More...

amrex::Real	dz
	Uniform computational grid spacing in z. More...

amrex::Real	prob_lo_x
	Low problem bounds used for interpolation. More...

amrex::Real	prob_lo_y
	Low problem bound in y. More...

amrex::Real	prob_lo_z
	Low problem bound in z. More...

amrex::Real	prob_hi_x
	High problem bounds used for interpolation. More...

amrex::Real	prob_hi_y
	High problem bound in y. More...

int	i_hi
	Highest terrain-array index in the x and y directions. More...

int	j_hi
	Highest terrain-array index in y. More...

int	k_hi
	Number of vertical cells (one past the highest valid dz_s index). More...

Detailed Description

AMReX EB implicit-function sign convention: >0 is body, 0 is boundary, <0 is fluid.

Terrain implicit function backed by gridded terrain heights.

The operator interpolates terrain height in x-y, maps the query z coordinate through stretched vertical spacing, and returns the AMReX EB signed value.

Constructor & Destructor Documentation

◆ TerrainIF()

TerrainIF::TerrainIF	(	amrex::FArrayBox const &	a_z_terrain,
		amrex::Geometry const &	a_geom,
		amrex::Gpu::DeviceVector< amrex::Real > &	a_dz_stretched
	)

inline

Construct a terrain implicit function from height and geometry data.

Parameters

a_z_terrain	Terrain elevation values on the horizontal mesh.
a_geom	Geometry used for grid spacing and problem bounds.
a_dz_stretched	Device vector of stretched vertical cell sizes.

         : terr_arr(a_z_terrain.const_array()),
           dz_s(a_dz_stretched.data()),
           dx(a_geom.CellSize(0)),
           dy(a_geom.CellSize(1)),
           dz(a_geom.CellSize(2)),
           prob_lo_x(a_geom.ProbLo(0)),
           prob_lo_y(a_geom.ProbLo(1)),
           prob_lo_z(a_geom.ProbLo(2)),
           prob_hi_x(a_geom.ProbHi(0)),
           prob_hi_y(a_geom.ProbHi(1)),
           i_hi(static_cast<int>(std::round((a_geom.ProbHi(0)-a_geom.ProbLo(0))/a_geom.CellSize(0)))),
           j_hi(static_cast<int>(std::round((a_geom.ProbHi(1)-a_geom.ProbLo(1))/a_geom.CellSize(1)))),
           k_hi(static_cast<int>(std::round((a_geom.ProbHi(2)-a_geom.ProbLo(2))/a_geom.CellSize(2))))
         {}

Member Function Documentation

◆ operator()() [1/2]

AMREX_GPU_HOST_DEVICE amrex::Real TerrainIF::operator() ( AMREX_D_DECL(amrex::Real x, amrex::Real y, amrex::Real z) ) const

inlinenoexcept

Evaluate the signed implicit-function value at physical coordinates.

The coordinates are passed through AMREX_D_DECL for spatial-dimension portability.

Returns: Positive inside terrain, zero at the terrain surface, negative in fluid.

     {
         int i1{};
         int j1{};
         int i2{};
         int j2{};
  
         amrex::Real x1{};
         amrex::Real x2{};
         amrex::Real y1{};
         amrex::Real y2{};
         amrex::Real w1{};
         amrex::Real w2{};
         amrex::Real terr_z{amrex::Real(0.0)};
  
         // z_stretched
         const int k1 = amrex::Clamp(static_cast<int>(std::floor((z-prob_lo_z) / dz)), 0, k_hi - 1);
         const amrex::Real z1 = prob_lo_z + k1*dz;
         const amrex::Real remainder_z = (z - z1)/dz;
         amrex::Real z_stretched = prob_lo_z;
         for (int kk = 0; kk < k1; ++kk) {
             z_stretched += dz_s[kk];
         }
         z_stretched += remainder_z * dz_s[k1];
  
         // Interpolation (nine subregions of x-y plane)
         if        (x <= prob_lo_x && y <= prob_lo_y) {
             terr_z = terr_arr(0   ,0   ,0);
         } else if (x >= prob_hi_x && y <= prob_lo_y) {
             terr_z = terr_arr(i_hi,0   ,0);
         } else if (x >= prob_hi_x && y >= prob_hi_y) {
             terr_z = terr_arr(i_hi,j_hi,0);
         } else if (x <= prob_lo_x && y >= prob_hi_y) {
             terr_z = terr_arr(0   ,j_hi,0);
         } else if (x > prob_lo_x && x < prob_hi_x && (y <= prob_lo_y || y >= prob_hi_y) ) {
             i1 = static_cast<int>(std::floor((x-prob_lo_x) / dx));
             i2 = i1+1;
             x1 = prob_lo_x + i1*dx;
             x2 = x1 + dx;
             w1 = (x2-x)/dx;
             w2 = (x-x1)/dx;
             if        (y <= prob_lo_y){
                 terr_z = w1*terr_arr(i1,0   ,0) + w2*terr_arr(i2,0   ,0);
             } else if (y >= prob_hi_y) {
                 terr_z = w1*terr_arr(i1,j_hi,0) + w2*terr_arr(i2,j_hi,0);
             }
         } else if (y > prob_lo_y && y < prob_hi_y && (x <= prob_lo_x || x >= prob_hi_x) ) {
             j1 = static_cast<int>(std::floor((y-prob_lo_y) / dy));
             j2 = j1+1;
             y1 = prob_lo_y + j1*dy;
             y2 = y1 + dy;
             w1 = (y2-y)/dy;
             w2 = (y-y1)/dy;
             if        (x <= prob_lo_x){
                 terr_z = w1*terr_arr(0   ,j1,0) + w2*terr_arr(0   ,j2,0);
             } else if (x >= prob_hi_x) {
                 terr_z = w1*terr_arr(i_hi,j1,0) + w2*terr_arr(i_hi,j2,0);
             }
         } else {
             // Do bilinear interpolation of the terrain surface
             i1 = static_cast<int>(std::floor((x-prob_lo_x) / dx));
             i2 = i1+1;
             j1 = static_cast<int>(std::floor((y-prob_lo_y) / dy));
             j2 = j1+1;
             x1 = prob_lo_x + i1*dx;
             x2 = x1 + dx;
             y1 = prob_lo_y + j1*dy;
             y2 = y1 + dy;
  
             const amrex::Real denom = dx*dy;
             const amrex::Real w11 = (x2-x)*(y2-y)/denom;
             const amrex::Real w12 = (x2-x)*(y-y1)/denom;
             const amrex::Real w21 = (x-x1)*(y2-y)/denom;
             const amrex::Real w22 = (x-x1)*(y-y1)/denom;
             terr_z = w11*terr_arr(i1,j1,0) + w12*terr_arr(i1,j2,0) + w21*terr_arr(i2,j1,0) + w22*terr_arr(i2,j2,0);
         }
         return -(z_stretched - terr_z);
     }

Referenced by operator()().

Here is the caller graph for this function:

◆ operator()() [2/2]

AMREX_GPU_HOST_DEVICE amrex::Real TerrainIF::operator() ( const amrex::RealArray & p ) const

inlinenoexcept

Evaluate the signed implicit-function value at a point array.

Parameters

p	Physical coordinate array.

Returns: Positive inside terrain, zero at the terrain surface, negative in fluid.

     {
         return this->operator() (AMREX_D_DECL(p[0], p[1], p[2]));
     }

Here is the call graph for this function:

Member Data Documentation

◆ dx

amrex::Real TerrainIF::dx

protected

Uniform computational grid spacing in each direction.

Referenced by operator()().

◆ dy

TerrainIF::dy

protected

Uniform computational grid spacing in y.

Referenced by operator()().

◆ dz

TerrainIF::dz

protected

Uniform computational grid spacing in z.

Referenced by operator()().

◆ dz_s

amrex::Real const* TerrainIF::dz_s

protected

Device pointer to stretched vertical cell sizes.

Referenced by operator()().

◆ i_hi

int TerrainIF::i_hi

protected

Highest terrain-array index in the x and y directions.

Referenced by operator()().

◆ j_hi

TerrainIF::j_hi

protected

Highest terrain-array index in y.

Referenced by operator()().

◆ k_hi

int TerrainIF::k_hi

protected

Number of vertical cells (one past the highest valid dz_s index).

Referenced by operator()().

◆ prob_hi_x

amrex::Real TerrainIF::prob_hi_x

protected

High problem bounds used for interpolation.

Referenced by operator()().

◆ prob_hi_y

TerrainIF::prob_hi_y

protected

High problem bound in y.

Referenced by operator()().

◆ prob_lo_x

amrex::Real TerrainIF::prob_lo_x

protected

Low problem bounds used for interpolation.

Referenced by operator()().

◆ prob_lo_y

TerrainIF::prob_lo_y

protected

Low problem bound in y.

Referenced by operator()().

◆ prob_lo_z

TerrainIF::prob_lo_z

protected

Low problem bound in z.

Referenced by operator()().

◆ terr_arr

amrex::Array4<amrex::Real const> TerrainIF::terr_arr

protected

Terrain height array sampled on the horizontal mesh.

Referenced by operator()().

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

Source/EB/ERF_EBIFTerrain.H

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ TerrainIF()

Member Function Documentation

◆ operator()() [1/2]

◆ operator()() [2/2]

Member Data Documentation

◆ dx

◆ dy

◆ dz

◆ dz_s

◆ i_hi

◆ j_hi

◆ k_hi

◆ prob_hi_x

◆ prob_hi_y

◆ prob_lo_x

◆ prob_lo_y

◆ prob_lo_z

◆ terr_arr