#include <ERF_SpongeStruct.H>

Collaboration diagram for SpongeChoice:

[legend]

Public Member Functions
void	init_params (std::string pp_prefix)

void	display ()

Public Attributes
bool	use_xlo_sponge_damping = false

bool	use_xhi_sponge_damping = false

bool	use_ylo_sponge_damping = false

bool	use_yhi_sponge_damping = false

bool	use_zlo_sponge_damping = false

bool	use_zhi_sponge_damping = false

amrex::Real	sponge_strength = 0.0

amrex::Real	xlo_sponge_end

amrex::Real	xhi_sponge_start

amrex::Real	ylo_sponge_end

amrex::Real	yhi_sponge_start

amrex::Real	zlo_sponge_end

amrex::Real	zhi_sponge_start

amrex::Real	sponge_density = -one

amrex::Real	sponge_rhotheta = -one

amrex::Real	sponge_rhomoist = -one

amrex::Real	sponge_x_velocity

amrex::Real	sponge_y_velocity

amrex::Real	sponge_z_velocity

Static Public Attributes
static SpongeType	sponge_type = SpongeType::Standard

Detailed Description

Container holding the sponge-related choices

Member Function Documentation

◆ display()

void SpongeChoice::display ( )

inline

     {
         amrex::Print() << "Sponge choices: " << std::endl;
     }

Referenced by SolverChoice::display().

Here is the caller graph for this function:

◆ init_params()

void SpongeChoice::init_params ( std::string pp_prefix )

inline

     {
         amrex::ParmParse pp(pp_prefix);
  
         // The default type is SpongeType::Standard
         // Here we can overwrite the default with None or Input_Sponge
         pp.query_enum_case_insensitive("sponge_type",sponge_type);
  
         if (sponge_type == SpongeType::None) return;
  
         pp.query("sponge_strength" , sponge_strength);
  
         // If sponge_strength == 0 then we set sponge_type to None
         if (std::abs(sponge_strength) == zero)
         {
             sponge_type = SpongeType::None;
         }
         else
         {
             pp.query("use_xlo_sponge_damping", use_xlo_sponge_damping);
             pp.query("use_xhi_sponge_damping", use_xhi_sponge_damping);
             pp.query("use_ylo_sponge_damping", use_ylo_sponge_damping);
             pp.query("use_yhi_sponge_damping", use_yhi_sponge_damping);
             pp.query("use_zlo_sponge_damping", use_zlo_sponge_damping);
             pp.query("use_zhi_sponge_damping", use_zhi_sponge_damping);
  
             if (use_xlo_sponge_damping) {
                 pp.get("xlo_sponge_end"  , xlo_sponge_end);
             }
             if (use_xhi_sponge_damping) {
                 pp.get("xhi_sponge_start"  , xhi_sponge_start);
             }
             if (use_ylo_sponge_damping) {
                 pp.get("ylo_sponge_end"  , ylo_sponge_end);
             }
             if (use_yhi_sponge_damping) {
                 pp.get("yhi_sponge_start"  , yhi_sponge_start);
             }
             if (use_zlo_sponge_damping) {
                 pp.get("zlo_sponge_end"  , zlo_sponge_end);
             }
             if (use_zhi_sponge_damping) {
                 pp.get("zhi_sponge_start"  , zhi_sponge_start);
             }
  
             pp.query("sponge_density"    , sponge_density);
             pp.query("sponge_rhotheta"   , sponge_rhotheta);
             pp.query("sponge_rhomoist"   , sponge_rhomoist);
             pp.query("sponge_x_velocity" , sponge_x_velocity);
             pp.query("sponge_y_velocity" , sponge_y_velocity);
             pp.query("sponge_z_velocity" , sponge_z_velocity);
         }
     }