AdvChoice Struct Reference

#include <ERF_AdvStruct.H>

Collaboration diagram for AdvChoice:

Public Member Functions
void	init_params (std::string pp_prefix)
	Read advection options from the input parameter database. More...
void	display (std::string &pp_prefix)
	Print the configured advection choices. More...
std::string	adv_type_convert_int_to_string (AdvType adv_int)
	Convert an advection type enum to the corresponding input string. More...
AdvType	adv_type_convert_string_to_advtype (std::string adv_string)
	Convert an input advection string to the corresponding enum value. More...
void	validate_weno_momentum_compatibility (bool use_embedded_boundary)
	Check whether the selected momentum WENO schemes are compatible with embedded boundaries. More...

Public Attributes
bool	use_efficient_advection = false
	Whether to use the efficient advection implementation. More...
AdvType	dycore_horiz_adv_type = AdvType::Upwind_3rd
	Horizontal advection scheme for dynamical-core variables. More...
AdvType	dycore_vert_adv_type = AdvType::Upwind_3rd
	Vertical advection scheme for dynamical-core variables. More...
AdvType	dryscal_horiz_adv_type = AdvType::Upwind_3rd
	Horizontal advection scheme for dry scalar variables. More...
AdvType	dryscal_vert_adv_type = AdvType::Upwind_3rd
	Vertical advection scheme for dry scalar variables. More...
AdvType	moistscal_horiz_adv_type = AdvType::Weno_3
	Horizontal advection scheme for moist scalar variables. More...
AdvType	moistscal_vert_adv_type = AdvType::Weno_3
	Vertical advection scheme for moist scalar variables. More...
amrex::Real	dycore_horiz_upw_frac = one
	Upwind blending fraction for horizontal dynamical-core advection. More...
amrex::Real	dycore_vert_upw_frac = one
	Upwind blending fraction for vertical dynamical-core advection. More...
amrex::Real	dryscal_horiz_upw_frac = one
	Upwind blending fraction for horizontal dry scalar advection. More...
amrex::Real	dryscal_vert_upw_frac = one
	Upwind blending fraction for vertical dry scalar advection. More...
amrex::Real	moistscal_horiz_upw_frac = one
	Upwind blending fraction for horizontal moist scalar advection. More...
amrex::Real	moistscal_vert_upw_frac = one
	Upwind blending fraction for vertical moist scalar advection. More...
amrex::Vector< amrex::IntVect >	zero_xflux
	Thin immersed-body x-face indices where fluxes are forced to zero. More...
amrex::Vector< amrex::IntVect >	zero_yflux
	Thin immersed-body y-face indices where fluxes are forced to zero. More...
amrex::Vector< amrex::IntVect >	zero_zflux
	Thin immersed-body z-face indices where fluxes are forced to zero. More...
bool	have_zero_flux_faces = false
	Whether any zero-flux thin immersed-body faces were specified. More...

Detailed Description

Container holding the advection-related choices

Member Function Documentation

adv_type_convert_int_to_string()

std::string AdvChoice::adv_type_convert_int_to_string ( AdvType  adv_int )

inline

Convert an advection type enum to the corresponding input string.

Parameters

adv_int

Advection type enum value.

Returns

String representation of the advection type.

    {
        if (adv_int == AdvType::Centered_2nd) {
            return "Centered_2nd";
        } else if (adv_int == AdvType::Upwind_3rd) {
            return "Upwind_3rd";
        } else if (adv_int == AdvType::Upwind_3rd_SL) {
            return "Upwind_3rd_SL";
        } else if (adv_int == AdvType::Centered_4th) {
            return "Centered_4th";
        } else if (adv_int == AdvType::Upwind_5th) {
            return "Upwind_5th";
        } else if (adv_int == AdvType::Centered_6th) {
            return "Centered_6th";
        } else if (adv_int == AdvType::Weno_3) {
            return "WENO3";
        } else if (adv_int == AdvType::Weno_3Z) {
            return "WENOZ3";
        } else if (adv_int == AdvType::Weno_5) {
            return "WENO5";
        } else if (adv_int == AdvType::Weno_5Z) {
            return "WENOZ5";
        } else if (adv_int == AdvType::Weno_3MZQ) {
            return "WENOMZQ3";
        } else if (adv_int == AdvType::Weno_7) {
            return "WENO7";
        } else if (adv_int == AdvType::Weno_7Z) {
            return "WENOZ7";
        } else {
            return "Unknown";
        }
    }

Referenced by display().

Here is the caller graph for this function:

adv_type_convert_string_to_advtype()

AdvType AdvChoice::adv_type_convert_string_to_advtype ( std::string  adv_string )

inline

Convert an input advection string to the corresponding enum value.

Parameters

adv_string

User-facing advection type string.

Returns

Matching advection type, or AdvType::Unknown if no match is found.

    {
        if (adv_string == "Centered_2nd") {
            return AdvType::Centered_2nd;
        } else if ((adv_string == "Upwind_3rd") || (adv_string == "Blended_3rd4th")) {
            return AdvType::Upwind_3rd;
        } else if (adv_string == "Upwind_3rd_SL") {
            return AdvType::Upwind_3rd_SL;
        } else if (adv_string == "Centered_4th") {
            return AdvType::Centered_4th;
        } else if (adv_string == "Upwind_5th" || (adv_string == "Blended_5th6th")) {
            return AdvType::Upwind_5th;
        } else if (adv_string == "Centered_6th") {
            return AdvType::Centered_6th;
        } else if (adv_string == "WENO3") {
            return AdvType::Weno_3;
        } else if (adv_string == "WENOZ3") {
            return AdvType::Weno_3Z;
        } else if (adv_string == "WENO5") {
            return AdvType::Weno_5;
        } else if (adv_string == "WENOZ5") {
            return AdvType::Weno_5Z;
        } else if (adv_string == "WENOMZQ3") {
            return AdvType::Weno_3MZQ;
        } else if (adv_string == "WENO7") {
            return AdvType::Weno_7;
        } else if (adv_string == "WENOZ7") {
            return AdvType::Weno_7Z;
        } else {
            return AdvType::Unknown;
        }
    }

Referenced by init_params().

Here is the caller graph for this function:

display()

void AdvChoice::display ( std::string &  pp_prefix )

inline

Print the configured advection choices.

Parameters

pp_prefix

ParmParse prefix used to recover input strings for display.

    {
        amrex::Print() << "Advection Choices: " << std::endl;
 
        // We read these again here just as a convenience to avoid passing them
        amrex::ParmParse pp(pp_prefix);
        std::string dycore_horiz_adv_string    = "" ; std::string dycore_vert_adv_string   = "";
        std::string dryscal_horiz_adv_string   = "" ; std::string dryscal_vert_adv_string  = "";
        pp.queryAdd("dycore_horiz_adv_type"   , dycore_horiz_adv_string);
        pp.queryAdd("dycore_vert_adv_type"    , dycore_vert_adv_string);
        pp.queryAdd("dryscal_horiz_adv_type"  , dryscal_horiz_adv_string);
        pp.queryAdd("dryscal_vert_adv_type"   , dryscal_vert_adv_string);
        std::string moistscal_horiz_adv_string = ""; std::string moistscal_vert_adv_string = "";
        pp.queryAdd("moistscal_horiz_adv_type", moistscal_horiz_adv_string);
        pp.queryAdd("moistscal_vert_adv_type" , moistscal_vert_adv_string);
 
        if (dycore_horiz_adv_string != "") {
            amrex::Print() << "    dycore_horiz_adv_type   : " << dycore_horiz_adv_string;
        } else {
            amrex::Print() << "    dycore_horiz_adv_type   : " << adv_type_convert_int_to_string(dycore_horiz_adv_type);
        }
        if ( (dycore_horiz_adv_string == "Blended_3rd4th") ||
             (dycore_horiz_adv_string == "Blended_5th6th") ) {
            amrex::Print() << " with " << 100*dycore_horiz_upw_frac << "% upwinding";
        }
        amrex::Print() << std::endl;
 
        if (dycore_vert_adv_string != "") {
            amrex::Print() << "    dycore_vert_adv_type    : " << dycore_vert_adv_string;
        } else {
            amrex::Print() << "    dycore_vert_adv_type    : " << adv_type_convert_int_to_string(dycore_vert_adv_type);
        }
        if ( (dycore_vert_adv_string == "Blended_3rd4th") ||
             (dycore_vert_adv_string == "Blended_5th6th") ) {
            amrex::Print() << " with " << 100*dycore_vert_upw_frac << "% upwinding";
        }
        amrex::Print() << std::endl;
 
        if (dryscal_horiz_adv_string != "") {
            amrex::Print() << "   dryscal_horiz_adv_type   : " << dryscal_horiz_adv_string;
        } else {
            amrex::Print() << "   dryscal_horiz_adv_type   : " << adv_type_convert_int_to_string(dryscal_horiz_adv_type);
        }
        if ( (dryscal_horiz_adv_string == "Blended_3rd4th") ||
             (dryscal_horiz_adv_string == "Blended_5th6th") ) {
            amrex::Print() << " with " << 100*dryscal_horiz_upw_frac << "% upwinding";
        }
        amrex::Print() << std::endl;
 
        if (dryscal_vert_adv_string != "") {
            amrex::Print() << "   dryscal_vert_adv_type    : " << dryscal_vert_adv_string;
        } else {
            amrex::Print() << "   dryscal_vert_adv_type    : " << adv_type_convert_int_to_string(dryscal_vert_adv_type);
        }
        if ( (dryscal_vert_adv_string == "Blended_3rd4th") ||
             (dryscal_vert_adv_string == "Blended_5th6th") ) {
            amrex::Print() << " with " << 100*dryscal_vert_upw_frac << "% upwinding";
        }
        amrex::Print() << std::endl;
 
        if (moistscal_horiz_adv_string != "") {
            amrex::Print() << " moistscal_horiz_adv_type   : " << moistscal_horiz_adv_string;
        } else {
            amrex::Print() << " moistscal_horiz_adv_type   : " << adv_type_convert_int_to_string(moistscal_horiz_adv_type);
        }
        if ( (moistscal_horiz_adv_string == "Blended_3rd4th") ||
             (moistscal_horiz_adv_string == "Blended_5th6th") ) {
            amrex::Print() << " with " << 100*moistscal_horiz_upw_frac << "% upwinding";
        }
        amrex::Print() << std::endl;
 
        if (moistscal_vert_adv_string != "") {
            amrex::Print() << " moistscal_vert_adv_type    : " << moistscal_vert_adv_string;
        } else {
            amrex::Print() << " moistscal_vert_adv_type    : " << adv_type_convert_int_to_string(moistscal_vert_adv_type);
        }
        if ( (moistscal_vert_adv_string == "Blended_3rd4th") ||
             (moistscal_vert_adv_string == "Blended_5th6th") ) {
            amrex::Print() << " with " << 100*moistscal_vert_upw_frac << "% upwinding";
        }
        amrex::Print() << std::endl;
    }

Referenced by SolverChoice::display().

Here is the call graph for this function:

Here is the caller graph for this function:

init_params()

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

inline

Read advection options from the input parameter database.

Parameters

pp_prefix

ParmParse prefix for the ERF input namespace.

    {
        amrex::ParmParse pp(pp_prefix);
 
        // Order and type of spatial discretizations used in advection
        pp.queryAdd("use_efficient_advection", use_efficient_advection);
        std::string dycore_horiz_adv_string    = "" ; std::string dycore_vert_adv_string   = "";
        std::string dryscal_horiz_adv_string   = "" ; std::string dryscal_vert_adv_string  = "";
        pp.queryAdd("dycore_horiz_adv_type"   , dycore_horiz_adv_string);
        pp.queryAdd("dycore_vert_adv_type"    , dycore_vert_adv_string);
        pp.queryAdd("dryscal_horiz_adv_type"  , dryscal_horiz_adv_string);
        pp.queryAdd("dryscal_vert_adv_type"   , dryscal_vert_adv_string);
 
        std::string moistscal_horiz_adv_string = ""; std::string moistscal_vert_adv_string = "";
        pp.queryAdd("moistscal_horiz_adv_type", moistscal_horiz_adv_string);
        pp.queryAdd("moistscal_vert_adv_type" , moistscal_vert_adv_string);
 
        if (use_efficient_advection){
           amrex::Print() << "Using efficient advection scheme" << std::endl;
        }
 
        if ( (dycore_horiz_adv_string == "Blended_3rd4th") ||
             (dycore_horiz_adv_string == "Blended_5th6th") )
        {
            pp.queryAdd("dycore_horiz_upw_frac" , dycore_horiz_upw_frac);
            AMREX_ASSERT_WITH_MESSAGE((dycore_horiz_upw_frac >= zero) && (dycore_horiz_upw_frac <= one),
                                      "The dycore horizontal upwinding fraction must be between 0 and 1");
        }
 
        if ( (dycore_vert_adv_string == "Blended_3rd4th") ||
             (dycore_vert_adv_string == "Blended_5th6th") )
        {
            pp.queryAdd("dycore_vert_upw_frac" , dycore_vert_upw_frac);
            AMREX_ASSERT_WITH_MESSAGE((dycore_vert_upw_frac >= zero) && (dycore_vert_upw_frac <= one),
                                      "The dycore vertical upwinding fraction must be between 0 and 1");
        }
 
        if ( (dryscal_horiz_adv_string == "Blended_3rd4th") ||
             (dryscal_horiz_adv_string == "Blended_5th6th") )
        {
            pp.queryAdd("dryscal_horiz_upw_frac" , dryscal_horiz_upw_frac);
            AMREX_ASSERT_WITH_MESSAGE((dryscal_horiz_upw_frac >= zero) && (dryscal_horiz_upw_frac <= one),
                                      "The dry scalar horizontal upwinding fraction must be between 0 and 1");
        }
 
        if ( (dryscal_vert_adv_string == "Blended_3rd4th") ||
             (dryscal_vert_adv_string == "Blended_5th6th") )
        {
            pp.queryAdd("dryscal_vert_upw_frac" , dryscal_vert_upw_frac);
            AMREX_ASSERT_WITH_MESSAGE((dryscal_vert_upw_frac >= zero) && (dryscal_vert_upw_frac <= one),
                                      "The dry scalar vertical upwinding fraction must be between 0 and 1");
        }
 
        if ( (moistscal_horiz_adv_string == "Blended_3rd4th") ||
             (moistscal_horiz_adv_string == "Blended_5th6th") )
        {
            pp.queryAdd("moistscal_horiz_upw_frac" , moistscal_horiz_upw_frac);
            AMREX_ASSERT_WITH_MESSAGE((moistscal_horiz_upw_frac >= zero) && (moistscal_horiz_upw_frac <= one),
                                      "The moist scalar horizontal upwinding fraction must be between 0 and 1");
        }
 
        if ( (moistscal_vert_adv_string == "Blended_3rd4th") ||
             (moistscal_vert_adv_string == "Blended_5th6th") )
        {
            pp.queryAdd("moistscal_vert_upw_frac" , moistscal_vert_upw_frac);
            AMREX_ASSERT_WITH_MESSAGE((moistscal_vert_upw_frac >= zero) && (moistscal_vert_upw_frac <= one),
                                      "The moist scalar vertical upwinding fraction must be between 0 and 1");
        }
 
        if (dycore_horiz_adv_string != "") {
            if ( (dycore_horiz_adv_string == "Centered_2nd") ||
                 (dycore_horiz_adv_string == "Upwind_3rd"  ) ||
                 (dycore_horiz_adv_string == "Blended_3rd4th") ||
                 (dycore_horiz_adv_string == "Centered_4th") ||
                 (dycore_horiz_adv_string == "Upwind_5th"  ) ||
                (dycore_horiz_adv_string == "Blended_5th6th") ||
                (dycore_horiz_adv_string == "Centered_6th") ||
                (dycore_horiz_adv_string == "WENO3"       ) ||
                (dycore_horiz_adv_string == "WENOZ3"      ) ||
                (dycore_horiz_adv_string == "WENOMZQ3"    ) ||
                (dycore_horiz_adv_string == "WENO5"       ) ||
                (dycore_horiz_adv_string == "WENOZ5"      ) ||
                (dycore_horiz_adv_string == "WENO7"       ) ||
                (dycore_horiz_adv_string == "WENOZ7"      ))
           {
               dycore_horiz_adv_type = adv_type_convert_string_to_advtype(dycore_horiz_adv_string);
           } else {
               amrex::Error("Don't know this dycore_horiz_adv_string");
           }
        }
 
        if (dycore_vert_adv_string != "") {
            if ( (dycore_vert_adv_string == "Centered_2nd") ||
                 (dycore_vert_adv_string == "Upwind_3rd"  ) ||
                 (dycore_vert_adv_string == "Blended_3rd4th") ||
                 (dycore_vert_adv_string == "Centered_4th") ||
                 (dycore_vert_adv_string == "Upwind_5th"  ) ||
                 (dycore_vert_adv_string == "Blended_5th6th") ||
                 (dycore_vert_adv_string == "Centered_6th") ||
                 (dycore_vert_adv_string == "WENO3"       ) ||
                 (dycore_vert_adv_string == "WENOZ3"      ) ||
                 (dycore_vert_adv_string == "WENOMZQ3"    ) ||
                 (dycore_vert_adv_string == "WENO5"       ) ||
                 (dycore_vert_adv_string == "WENOZ5"      ) ||
                 (dycore_vert_adv_string == "WENO7"       ) ||
                 (dycore_vert_adv_string == "WENOZ7"      ))
            {
                dycore_vert_adv_type = adv_type_convert_string_to_advtype(dycore_vert_adv_string);
            } else {
                amrex::Error("Don't know this dycore_vert_adv_string");
            }
        }
 
        if (dryscal_horiz_adv_string != "") {
            if ( (dryscal_horiz_adv_string == "Centered_2nd") ||
                 (dryscal_horiz_adv_string == "Upwind_3rd"  ) ||
                 (dryscal_horiz_adv_string == "Upwind_3rd_SL") ||
                 (dryscal_horiz_adv_string == "Blended_3rd4th") ||
                 (dryscal_horiz_adv_string == "Centered_4th") ||
                 (dryscal_horiz_adv_string == "Upwind_5th"  ) ||
                 (dryscal_horiz_adv_string == "Blended_5th6th") ||
                 (dryscal_horiz_adv_string == "Centered_6th") ||
                 (dryscal_horiz_adv_string == "WENO3"       ) ||
                 (dryscal_horiz_adv_string == "WENOZ3"      ) ||
                 (dryscal_horiz_adv_string == "WENOMZQ3"    ) ||
                 (dryscal_horiz_adv_string == "WENO5"       ) ||
                 (dryscal_horiz_adv_string == "WENOZ5"      ) ||
                 (dryscal_horiz_adv_string == "WENO7"       ) ||
                 (dryscal_horiz_adv_string == "WENOZ7"      ) )
            {
                dryscal_horiz_adv_type = adv_type_convert_string_to_advtype(dryscal_horiz_adv_string);
            } else {
                amrex::Error("Don't know this dryscal_horiz_adv_string");
            }
        }
 
        if (dryscal_vert_adv_string != "") {
            if ( (dryscal_vert_adv_string == "Centered_2nd") ||
                 (dryscal_vert_adv_string == "Upwind_3rd"  ) ||
                 (dryscal_vert_adv_string == "Upwind_3rd_SL") ||
                 (dryscal_vert_adv_string == "Blended_3rd4th") ||
                 (dryscal_vert_adv_string == "Centered_4th") ||
                 (dryscal_vert_adv_string == "Upwind_5th"  ) ||
                 (dryscal_vert_adv_string == "Blended_5th6th") ||
                 (dryscal_vert_adv_string == "Centered_6th") ||
                 (dryscal_vert_adv_string == "WENO3"       ) ||
                 (dryscal_vert_adv_string == "WENOZ3"      ) ||
                 (dryscal_vert_adv_string == "WENOMZQ3"    ) ||
                 (dryscal_vert_adv_string == "WENO5"       ) ||
                 (dryscal_vert_adv_string == "WENOZ5"      ) ||
                 (dryscal_vert_adv_string == "WENO7"       ) ||
                 (dryscal_vert_adv_string == "WENOZ7"      ))
            {
                dryscal_vert_adv_type = adv_type_convert_string_to_advtype(dryscal_vert_adv_string);
            } else {
                amrex::Error("Don't know this dryscal_vert_adv_string");
            }
        }
 
        if (moistscal_horiz_adv_string != "") {
            if ( (moistscal_horiz_adv_string == "Centered_2nd") ||
                 (moistscal_horiz_adv_string == "Upwind_3rd"  ) ||
                 (moistscal_horiz_adv_string == "Upwind_3rd_SL"  ) ||
                 (moistscal_horiz_adv_string == "Blended_3rd4th") ||
                 (moistscal_horiz_adv_string == "Centered_4th") ||
                 (moistscal_horiz_adv_string == "Upwind_5th"  ) ||
                 (moistscal_horiz_adv_string == "Blended_5th6th") ||
                 (moistscal_horiz_adv_string == "Centered_6th") ||
                 (moistscal_horiz_adv_string == "WENO3"       ) ||
                 (moistscal_horiz_adv_string == "WENOZ3"      ) ||
                 (moistscal_horiz_adv_string == "WENOMZQ3"    ) ||
                 (moistscal_horiz_adv_string == "WENO5"       ) ||
                 (moistscal_horiz_adv_string == "WENOZ5"      ) ||
                 (moistscal_horiz_adv_string == "WENO7"       ) ||
                 (moistscal_horiz_adv_string == "WENOZ7"      ))
            {
                moistscal_horiz_adv_type = adv_type_convert_string_to_advtype(moistscal_horiz_adv_string);
            } else {
                amrex::Error("Don't know this moistscal_horiz_adv_string");
            }
        }
 
        if (moistscal_vert_adv_string != "") {
            if ( (moistscal_vert_adv_string == "Centered_2nd") ||
                 (moistscal_vert_adv_string == "Upwind_3rd"  ) ||
                 (moistscal_vert_adv_string == "Upwind_3rd_SL"  ) ||
                 (moistscal_vert_adv_string == "Blended_3rd4th") ||
                 (moistscal_vert_adv_string == "Centered_4th") ||
                 (moistscal_vert_adv_string == "Upwind_5th"  ) ||
                 (moistscal_vert_adv_string == "Blended_5th6th") ||
                 (moistscal_vert_adv_string == "Centered_6th") ||
                 (moistscal_vert_adv_string == "WENO3"       ) ||
                 (moistscal_vert_adv_string == "WENOZ3"      ) ||
                 (moistscal_vert_adv_string == "WENOMZQ3"    ) ||
                 (moistscal_vert_adv_string == "WENO5"       ) ||
                 (moistscal_vert_adv_string == "WENOZ5"      ) ||
                 (moistscal_vert_adv_string == "WENO7"       ) ||
                 (moistscal_vert_adv_string == "WENOZ7"      ))
            {
                moistscal_vert_adv_type = adv_type_convert_string_to_advtype(moistscal_vert_adv_string);
            } else {
                amrex::Error("Don't know this moistscal_vert_adv_string");
            }
        }
 
        // We can can't use weno with Embedded Boundaries (for now)
        std::string terrain_type;
        pp.queryAdd("terrain_type", terrain_type);
        validate_weno_momentum_compatibility(terrain_type == "EB");
 
        pp.queryarr("zero_xflux_faces", zero_xflux);
        pp.queryarr("zero_yflux_faces", zero_yflux);
        pp.queryarr("zero_zflux_faces", zero_zflux);
        have_zero_flux_faces = ((zero_xflux.size() > 0) || (zero_yflux.size() > 0) || (zero_zflux.size() > 0));
    }

Referenced by SolverChoice::init_params().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_weno_momentum_compatibility()

void AdvChoice::validate_weno_momentum_compatibility ( bool  use_embedded_boundary )

inline

Check whether the selected momentum WENO schemes are compatible with embedded boundaries.

Parameters

use_embedded_boundary

Whether the run uses embedded-boundary terrain.

    {
        // Check if any WENO momentum advection is being used
        bool using_weno_momentum =
            (dycore_horiz_adv_type == AdvType::Weno_3) ||
            (dycore_horiz_adv_type == AdvType::Weno_3Z) ||
            (dycore_horiz_adv_type == AdvType::Weno_3MZQ) ||
            (dycore_horiz_adv_type == AdvType::Weno_5) ||
            (dycore_horiz_adv_type == AdvType::Weno_5Z) ||
            (dycore_horiz_adv_type == AdvType::Weno_7) ||
            (dycore_horiz_adv_type == AdvType::Weno_7Z) ||
            (dycore_vert_adv_type == AdvType::Weno_3) ||
            (dycore_vert_adv_type == AdvType::Weno_3Z) ||
            (dycore_vert_adv_type == AdvType::Weno_3MZQ) ||
            (dycore_vert_adv_type == AdvType::Weno_5) ||
            (dycore_vert_adv_type == AdvType::Weno_5Z) ||
            (dycore_vert_adv_type == AdvType::Weno_7) ||
            (dycore_vert_adv_type == AdvType::Weno_7Z);
 
        // Check embedded boundary incompatibility
        amrex::ignore_unused(use_embedded_boundary, using_weno_momentum);
        AMREX_ASSERT_WITH_MESSAGE(!using_weno_momentum || !use_embedded_boundary,
            "WENO momentum advection schemes are not yet implemented for embedded boundaries. "
            "Please use traditional momentum advection schemes when using embedded boundaries:\n"
            "  - Centered_2nd\n"
            "  - Upwind_3rd\n"
            "  - Centered_4th\n"
            "  - Upwind_5th\n"
            "  - Centered_6th");
    }

Referenced by init_params().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

dryscal_horiz_adv_type

AdvChoice::dryscal_horiz_adv_type = AdvType::Upwind_3rd

Horizontal advection scheme for dry scalar variables.

Referenced by erf_auxiliary::AuxiliaryInertTracer::advance_stage(), ERF::ComputeGhostCells(), display(), and init_params().

dryscal_horiz_upw_frac

AdvChoice::dryscal_horiz_upw_frac = one

Upwind blending fraction for horizontal dry scalar advection.

Referenced by erf_auxiliary::AuxiliaryInertTracer::advance_stage(), display(), and init_params().

dryscal_vert_adv_type

AdvChoice::dryscal_vert_adv_type = AdvType::Upwind_3rd

Vertical advection scheme for dry scalar variables.

Referenced by erf_auxiliary::AuxiliaryInertTracer::advance_stage(), ERF::ComputeGhostCells(), display(), and init_params().

dryscal_vert_upw_frac

AdvChoice::dryscal_vert_upw_frac = one

Upwind blending fraction for vertical dry scalar advection.

Referenced by erf_auxiliary::AuxiliaryInertTracer::advance_stage(), display(), and init_params().

dycore_horiz_adv_type

AdvChoice::dycore_horiz_adv_type = AdvType::Upwind_3rd

Horizontal advection scheme for dynamical-core variables.

Referenced by ERF::ComputeGhostCells(), display(), erf_slow_rhs_pre(), init_params(), and validate_weno_momentum_compatibility().

dycore_horiz_upw_frac

AdvChoice::dycore_horiz_upw_frac = one

Upwind blending fraction for horizontal dynamical-core advection.

Referenced by display(), erf_slow_rhs_pre(), and init_params().

dycore_vert_adv_type

AdvChoice::dycore_vert_adv_type = AdvType::Upwind_3rd

Vertical advection scheme for dynamical-core variables.

Referenced by ERF::ComputeGhostCells(), display(), erf_slow_rhs_pre(), init_params(), and validate_weno_momentum_compatibility().

dycore_vert_upw_frac

AdvChoice::dycore_vert_upw_frac = one

Upwind blending fraction for vertical dynamical-core advection.

Referenced by display(), erf_slow_rhs_pre(), and init_params().

have_zero_flux_faces

AdvChoice::have_zero_flux_faces = false

Whether any zero-flux thin immersed-body faces were specified.

Referenced by init_params().

moistscal_horiz_adv_type

AdvChoice::moistscal_horiz_adv_type = AdvType::Weno_3

Horizontal advection scheme for moist scalar variables.

Referenced by ERF::ComputeGhostCells(), display(), and init_params().

moistscal_horiz_upw_frac

AdvChoice::moistscal_horiz_upw_frac = one

Upwind blending fraction for horizontal moist scalar advection.

Referenced by display(), and init_params().

moistscal_vert_adv_type

AdvChoice::moistscal_vert_adv_type = AdvType::Weno_3

Vertical advection scheme for moist scalar variables.

Referenced by ERF::ComputeGhostCells(), display(), and init_params().

moistscal_vert_upw_frac

AdvChoice::moistscal_vert_upw_frac = one

Upwind blending fraction for vertical moist scalar advection.

Referenced by display(), and init_params().

use_efficient_advection

AdvChoice::use_efficient_advection = false

Whether to use the efficient advection implementation.

Referenced by init_params().

zero_xflux

AdvChoice::zero_xflux

Thin immersed-body x-face indices where fluxes are forced to zero.

Referenced by init_params().

zero_yflux

AdvChoice::zero_yflux

Thin immersed-body y-face indices where fluxes are forced to zero.

Referenced by init_params().

zero_zflux

AdvChoice::zero_zflux

Thin immersed-body z-face indices where fluxes are forced to zero.

Referenced by init_params().

---

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

• Source/DataStructs/ERF_AdvStruct.H