erf_wall_scalar_bc Namespace Reference

Classes
struct	ParsedWallScalarBC
struct	ParsedWallFaceScalars
struct	WallFaceParseResult

Enumerations
enum class	WallScalarBCIntent : unsigned char { Unspecified , DirichletConserved , DirichletPrimitive , Neumann }
enum class	SolidWallKind : unsigned char { NoSlip , Slip }

Functions
ParsedWallScalarBC	resolve_wall_scalar_value (bool value_specified, amrex::Real primitive_value, bool density_specified_on_same_face, amrex::Real density_value)
ParsedWallScalarBC	resolve_wall_scalar_gradient (bool gradient_specified, amrex::Real gradient)
bool	wall_scalar_value_gradient_conflict (bool value_specified, bool gradient_specified)
std::string	wall_scalar_value_gradient_error (const std::string &face, const std::string &variable)
std::string	anelastic_wall_density_error (const std::string &face, bool density_specified, bool density_gradient_specified)
std::string	no_slip_density_gradient_error (const std::string &face)
WallFaceParseResult	parse_wall_face_scalars (amrex::ParmParse &pp, const std::string &face, SolidWallKind wall_kind, bool anelastic)

Enumeration Type Documentation

SolidWallKind

enum erf_wall_scalar_bc::SolidWallKind : unsigned char

strong

Enumerator
NoSlip
Slip

                         : unsigned char {
    NoSlip,
    Slip
};

WallScalarBCIntent

enum erf_wall_scalar_bc::WallScalarBCIntent : unsigned char

strong

Enumerator
Unspecified
DirichletConserved
DirichletPrimitive
Neumann

                              : unsigned char {
    Unspecified,
    DirichletConserved,
    DirichletPrimitive,
    Neumann
};

Function Documentation

anelastic_wall_density_error()

std::string erf_wall_scalar_bc::anelastic_wall_density_error ( const std::string &  face, bool  density_specified, bool  density_gradient_specified  )

inline

Build the anelastic-mode density error message for a wall face.

Parameters

[in]	face	face name used in the input keys
[in]	density_specified	whether density was specified
[in]	density_gradient_specified	whether density_grad was specified

{
    if (!density_specified && !density_gradient_specified) {
        return {};
    }
 
    std::string message = face + ": density and density_grad must be omitted "
        "on solid walls in anelastic mode (density is fixed by the base state)";
    if (density_specified && density_gradient_specified) {
        message += "; both keywords were supplied";
    } else if (density_specified) {
        message += "; " + face + ".density was supplied";
    } else {
        message += "; " + face + ".density_grad was supplied";
    }
    return message;
}

Referenced by parse_wall_face_scalars().

Here is the caller graph for this function:

no_slip_density_gradient_error()

std::string erf_wall_scalar_bc::no_slip_density_gradient_error ( const std::string &  face )

inline

Build the unsupported no-slip density-gradient error message.

Parameters

[in]

face

face name used in the input keys

{
    return face + ".density_grad is not supported for NoSlipWall; use "
        + face + ".density for a fixed compressible wall density or omit "
        "wall density in anelastic mode";
}

Referenced by parse_wall_face_scalars().

Here is the caller graph for this function:

parse_wall_face_scalars()

WallFaceParseResult erf_wall_scalar_bc::parse_wall_face_scalars ( amrex::ParmParse &  pp, const std::string &  face, SolidWallKind  wall_kind, bool  anelastic  )

inline

Parse scalar wall boundary-condition inputs for one face.

Parameters

[in]	pp	ParmParse object scoped to the wall face
[in]	face	face name used in errors
[in]	wall_kind	no-slip or slip wall type
[in]	anelastic	whether anelastic mode is active

{
    // The value-carrying keys are probed with negative sentinels and their presence is
    // read off the resulting value, not off the queryAdd return value.  queryAdd inserts
    // the default into the (process-global) ParmParse table on a miss, so its return
    // value means "did this key exist before this call" -- true for every call after the
    // first.  ERF::init_bcs() runs twice on restart, and ERF_InitBCs.cpp parses the same
    // density/qv keys under the same face prefix, so a return-value test reports
    // "user specified" with a value of zero on the second pass.  That is what produced
    // the spurious NoSlipWall density_grad abort in #3922.
    //
    // density_grad and theta_grad deliberately keep plain query(): every real value is a
    // legal gradient, including zero and negatives, so no sentinel can encode "unset".
    amrex::Real density = amrex::Real(-1.0);
    pp.queryAdd("density", density);
    const bool density_specified = (density > amrex::Real(0.0));
    if (!density_specified) { density = amrex::Real(0.0); }
 
    amrex::Real density_grad = amrex::Real(0.0);
    const bool density_gradient_specified = pp.query("density_grad", density_grad);
 
    amrex::Real theta = amrex::Real(-1.0);
    pp.queryAdd("theta", theta);
    const bool theta_specified = (theta > amrex::Real(0.0));
    if (!theta_specified) { theta = amrex::Real(0.0); }
 
    amrex::Real theta_grad = amrex::Real(0.0);
    const bool theta_gradient_specified = pp.query("theta_grad", theta_grad);
 
    amrex::Real qv = amrex::Real(-1.0);
    if (wall_kind == SolidWallKind::NoSlip) { pp.queryAdd("qv", qv); }
    const bool qv_specified = (wall_kind == SolidWallKind::NoSlip) &&
                              (qv >= amrex::Real(0.0));
    if (!qv_specified) { qv = amrex::Real(0.0); }
 
    WallFaceParseResult result;
    if (anelastic && (density_specified || density_gradient_specified)) {
        result.error = anelastic_wall_density_error(
            face, density_specified, density_gradient_specified);
        return result;
    }
 
    if (wall_kind == SolidWallKind::NoSlip && density_gradient_specified) {
        result.error = no_slip_density_gradient_error(face);
        return result;
    }
 
    if (wall_kind == SolidWallKind::Slip &&
        wall_scalar_value_gradient_conflict(density_specified,
                                            density_gradient_specified)) {
        result.error = wall_scalar_value_gradient_error(face, "density");
        return result;
    }
 
    if (wall_scalar_value_gradient_conflict(theta_specified,
                                            theta_gradient_specified)) {
        result.error = wall_scalar_value_gradient_error(face, "theta");
        return result;
    }
 
    if (density_specified) {
        result.scalars.density = {
            WallScalarBCIntent::DirichletConserved, density};
    }
    result.scalars.theta = resolve_wall_scalar_value(
        theta_specified, theta, density_specified, density);
    if (theta_gradient_specified) {
        result.scalars.theta = resolve_wall_scalar_gradient(true, theta_grad);
    }
 
    if (wall_kind == SolidWallKind::Slip && density_gradient_specified) {
        result.scalars.density = resolve_wall_scalar_gradient(true, density_grad);
    }
 
    if (qv_specified) {
        result.scalars.qv = resolve_wall_scalar_value(
            true, qv, density_specified, density);
    }
 
    return result;
}

Referenced by ERF::init_phys_bcs().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_wall_scalar_gradient()

ParsedWallScalarBC erf_wall_scalar_bc::resolve_wall_scalar_gradient ( bool  gradient_specified, amrex::Real  gradient  )

inline

Resolve a wall scalar gradient into Neumann storage.

Parameters

[in]	gradient_specified	whether the scalar gradient was specified
[in]	gradient	gradient value from inputs

{
    if (!gradient_specified) {
        return {};
    }
    return {WallScalarBCIntent::Neumann, gradient};
}

Referenced by parse_wall_face_scalars().

Here is the caller graph for this function:

resolve_wall_scalar_value()

ParsedWallScalarBC erf_wall_scalar_bc::resolve_wall_scalar_value ( bool  value_specified, amrex::Real  primitive_value, bool  density_specified_on_same_face, amrex::Real  density_value  )

inline

Resolve a wall scalar value into primitive or conserved storage.

Parameters

[in]	value_specified	whether the scalar value was specified
[in]	primitive_value	primitive scalar value from inputs
[in]	density_specified_on_same_face	whether density was specified on the same face
[in]	density_value	density value used for conserved conversion

{
    if (!value_specified) {
        return {};
    }
 
    if (density_specified_on_same_face) {
        return {WallScalarBCIntent::DirichletConserved,
                density_value * primitive_value};
    }
 
    return {WallScalarBCIntent::DirichletPrimitive, primitive_value};
}

Referenced by parse_wall_face_scalars().

Here is the caller graph for this function:

wall_scalar_value_gradient_conflict()

bool erf_wall_scalar_bc::wall_scalar_value_gradient_conflict ( bool  value_specified, bool  gradient_specified  )

inline

Test whether value and gradient inputs conflict.

Parameters

[in]	value_specified	whether a scalar value was specified
[in]	gradient_specified	whether a scalar gradient was specified

{
    return value_specified && gradient_specified;
}

Referenced by parse_wall_face_scalars().

Here is the caller graph for this function:

wall_scalar_value_gradient_error()

std::string erf_wall_scalar_bc::wall_scalar_value_gradient_error ( const std::string &  face, const std::string &  variable  )

inline

Build the error message for mutually exclusive wall scalar inputs.

Parameters

[in]	face	face name used in the input keys
[in]	variable	variable name used in the input keys

{
    return face + "." + variable + " and " + face + "." + variable
        + "_grad are mutually exclusive";
}

Referenced by parse_wall_face_scalars().

Here is the caller graph for this function: