ERF_ShocTypes.H File Reference

#include "ERF_DataStruct.H"
#include <AMReX_FArrayBox.H>
#include <AMReX_Geometry.H>
#include <AMReX_GpuQualifiers.H>
#include <AMReX_ParmParse.H>
#include <AMReX_Vector.H>
#include <algorithm>
#include <cctype>
#include <string>

Include dependency graph for ERF_ShocTypes.H:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ShocRuntimeOptions
struct	ShocColumnLayout
struct	ShocColumnData

Enumerations
enum class	ShocTransportMode { StateUpdate , HostDiffusion }
enum class	ShocMomentumTransport { None , StateUpdate , HostDiffusion }

Functions
const char *	shoc_transport_mode_name (ShocTransportMode mode)
const char *	shoc_momentum_transport_name (ShocMomentumTransport mode)
bool	shoc_uses_state_update (ShocTransportMode mode)
bool	shoc_uses_host_diffusion (ShocTransportMode mode)
bool	shoc_uses_momentum_state_update (ShocMomentumTransport mode)
bool	shoc_uses_momentum_host_diffusion (ShocMomentumTransport mode)
bool	shoc_disables_momentum_transport (ShocMomentumTransport mode)
std::string	shoc_lower_copy (std::string value)
bool	parse_shoc_transport_mode_string (std::string value, ShocTransportMode &mode, std::string &error_message)
bool	parse_shoc_momentum_transport_string (std::string value, ShocMomentumTransport &mode, std::string &error_message)
bool	validate_shoc_runtime_options_message (const ShocRuntimeOptions &opts, std::string &error_message)
void	read_shoc_runtime_options (ShocRuntimeOptions &opts)
void	validate_shoc_runtime_options (const ShocRuntimeOptions &opts)
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	shoc_valid_comp (int comp, int ncomp)
template<typename T >
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE T	shoc_clamp (T value, T lo, T hi)

Enumeration Type Documentation

ShocMomentumTransport

enum ShocMomentumTransport

strong

Enumerator
None
StateUpdate
HostDiffusion

{
    None,
    StateUpdate,
    HostDiffusion
};

ShocTransportMode

enum ShocTransportMode

strong

Enumerator
StateUpdate
HostDiffusion

{
    StateUpdate,
    HostDiffusion
};

Function Documentation

parse_shoc_momentum_transport_string()

bool parse_shoc_momentum_transport_string ( std::string  value, ShocMomentumTransport &  mode, std::string &  error_message  )

inline

{
    value = shoc_lower_copy(value);
    if (value == "none") {
        mode = ShocMomentumTransport::None;
        return true;
    }
    if (value == "state_update") {
        mode = ShocMomentumTransport::StateUpdate;
        return true;
    }
    if (value == "host_diffusion") {
        mode = ShocMomentumTransport::HostDiffusion;
        return true;
    }
 
    error_message = "erf.shoc.momentum_transport must be 'none', 'state_update', or 'host_diffusion'";
    return false;
}

Referenced by read_shoc_runtime_options().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_shoc_transport_mode_string()

bool parse_shoc_transport_mode_string ( std::string  value, ShocTransportMode &  mode, std::string &  error_message  )

inline

{
    value = shoc_lower_copy(value);
    if (value == "state_update") {
        mode = ShocTransportMode::StateUpdate;
        return true;
    }
    if (value == "host_diffusion") {
        mode = ShocTransportMode::HostDiffusion;
        return true;
    }
    if (value == "tendencies") {
        error_message =
            "erf.shoc.transport_mode = tendencies has been removed for native SHOC. Use erf.shoc.transport_mode = state_update. Native SHOC now applies its coupled column increment before the dycore to avoid splitting theta and momentum from moisture.";
        return false;
    }
 
    error_message = "erf.shoc.transport_mode must be 'state_update' or 'host_diffusion'";
    return false;
}

Referenced by read_shoc_runtime_options().

Here is the call graph for this function:

Here is the caller graph for this function:

read_shoc_runtime_options()

void read_shoc_runtime_options ( ShocRuntimeOptions &  opts )

inline

{
    amrex::ParmParse pp("erf.shoc");
 
    pp.query("lambda_low", opts.lambda_low);
    pp.query("lambda_high", opts.lambda_high);
    pp.query("lambda_slope", opts.lambda_slope);
    pp.query("lambda_thresh", opts.lambda_thresh);
    pp.query("thl2tune", opts.thl2tune);
    pp.query("qw2tune", opts.qw2tune);
    pp.query("qwthl2tune", opts.qwthl2tune);
    pp.query("w2tune", opts.w2tune);
    pp.query("length_fac", opts.length_fac);
    pp.query("c_diag_3rd_mom", opts.c_diag_3rd_mom);
    pp.query("coeff_kh", opts.coeff_kh);
    pp.query("coeff_km", opts.coeff_km);
    pp.query("top_taper_depth", opts.top_taper_depth);
    pp.query("top_taper_min_factor", opts.top_taper_min_factor);
    pp.query("shoc_1p5tke", opts.shoc_1p5tke);
    pp.query("extra_shoc_diags", opts.extra_shoc_diags);
    pp.query("apply_tms", opts.apply_tms);
    pp.query("check_flux_state", opts.check_flux_state);
    pp.query("column_conservation_check", opts.column_conservation_check);
    pp.query("debug_summary", opts.debug_summary);
    pp.query("allow_tendency_microphysics_overlap", opts.allow_tendency_microphysics_overlap);
    pp.query("signed_tke_production", opts.signed_tke_production);
    pp.query("debug_bad_column", opts.debug_bad_column);
    pp.query("debug_bad_column_abort", opts.debug_bad_column_abort);
    pp.query("debug_bad_column_max_reports", opts.debug_bad_column_max_reports);
    pp.query("debug_bad_column_theta_tend_threshold", opts.debug_bad_column_theta_tend_threshold);
    pp.query("debug_bad_column_q_tend_threshold", opts.debug_bad_column_q_tend_threshold);
    pp.query("debug_bad_column_brunt_threshold", opts.debug_bad_column_brunt_threshold);
    pp.query("debug_bad_column_min_dz", opts.debug_bad_column_min_dz);
    pp.query("debug_bad_column_scalar_moment_threshold", opts.debug_bad_column_scalar_moment_threshold);
    pp.query("debug_disable_pdf_cloud_increment", opts.debug_disable_pdf_cloud_increment);
    pp.query("debug_disable_theta_state_update", opts.debug_disable_theta_state_update);
    pp.query("debug_disable_moisture_state_update", opts.debug_disable_moisture_state_update);
    pp.query("debug_disable_tke_state_update", opts.debug_disable_tke_state_update);
 
    std::string transport_mode = shoc_transport_mode_name(opts.transport_mode);
    if (pp.query("transport_mode", transport_mode)) {
        std::string error_message;
        if (!parse_shoc_transport_mode_string(transport_mode, opts.transport_mode, error_message)) {
            amrex::Abort(error_message.c_str());
        }
    }
 
    std::string momentum_transport = shoc_momentum_transport_name(opts.momentum_transport);
    if (pp.query("momentum_transport", momentum_transport)) {
        std::string error_message;
        if (!parse_shoc_momentum_transport_string(momentum_transport,
                                                  opts.momentum_transport,
                                                  error_message)) {
            amrex::Abort(error_message.c_str());
        }
    }
}

Referenced by ShocDriver::ShocDriver().

Here is the call graph for this function:

Here is the caller graph for this function:

shoc_clamp()

template<typename T >

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE T shoc_clamp	(	T	value,
		T	lo,
		T	hi
	)

{
    return amrex::max(lo, amrex::min(value, hi));
}

Referenced by ShocImplicit::advance_implicit_state(), ShocTKE::diagnose_tke_and_diffusivities(), ShocImplicit::finalize_from_pdf(), and shoc::reconstruct_pdf_state().

Here is the caller graph for this function:

shoc_disables_momentum_transport()

bool shoc_disables_momentum_transport ( ShocMomentumTransport  mode )

inline

{
    return mode == ShocMomentumTransport::None;
}

Referenced by ShocDriver::disables_momentum_transport().

Here is the caller graph for this function:

shoc_lower_copy()

std::string shoc_lower_copy ( std::string  value )

inline

{
    std::transform(value.begin(), value.end(), value.begin(),
                   [] (unsigned char c) { return static_cast<char>(std::tolower(c)); });
    return value;
}

Referenced by parse_shoc_momentum_transport_string(), and parse_shoc_transport_mode_string().

Here is the caller graph for this function:

shoc_momentum_transport_name()

const char* shoc_momentum_transport_name ( ShocMomentumTransport  mode )

inline

{
    switch (mode) {
    case ShocMomentumTransport::None:         return "none";
    case ShocMomentumTransport::StateUpdate:   return "state_update";
    case ShocMomentumTransport::HostDiffusion: return "host_diffusion";
    }
    return "unknown";
}

Referenced by ShocDriver::print_debug_summary(), and read_shoc_runtime_options().

Here is the caller graph for this function:

shoc_transport_mode_name()

const char* shoc_transport_mode_name ( ShocTransportMode  mode )

inline

{
    switch (mode) {
    case ShocTransportMode::StateUpdate:   return "state_update";
    case ShocTransportMode::HostDiffusion:return "host_diffusion";
    }
    return "unknown";
}

Referenced by ShocDriver::print_debug_summary(), and read_shoc_runtime_options().

Here is the caller graph for this function:

shoc_uses_host_diffusion()

bool shoc_uses_host_diffusion ( ShocTransportMode  mode )

inline

{
    return mode == ShocTransportMode::HostDiffusion;
}

Referenced by shoc_driver_host_diffusion_moisture_supported(), ShocDriver::uses_host_diffusion(), and validate_shoc_runtime_options_message().

Here is the caller graph for this function:

shoc_uses_momentum_host_diffusion()

bool shoc_uses_momentum_host_diffusion ( ShocMomentumTransport  mode )

inline

{
    return mode == ShocMomentumTransport::HostDiffusion;
}

Referenced by ShocDriver::uses_momentum_host_diffusion(), and validate_shoc_runtime_options_message().

Here is the caller graph for this function:

shoc_uses_momentum_state_update()

bool shoc_uses_momentum_state_update ( ShocMomentumTransport  mode )

inline

{
    return mode == ShocMomentumTransport::StateUpdate;
}

Referenced by ShocDriver::uses_momentum_state_update().

Here is the caller graph for this function:

shoc_uses_state_update()

bool shoc_uses_state_update ( ShocTransportMode  mode )

inline

{
    return mode == ShocTransportMode::StateUpdate;
}

Referenced by shoc_driver_state_update_layout_supported(), and ShocDriver::uses_state_update().

Here is the caller graph for this function:

shoc_valid_comp()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool shoc_valid_comp	(	int	comp,
		int	ncomp
	)

{
    return comp >= 0 && comp < ncomp;
}

Referenced by shoc_layout_requires_number_closure().

Here is the caller graph for this function:

validate_shoc_runtime_options()

void validate_shoc_runtime_options ( const ShocRuntimeOptions &  opts )

inline

{
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.lambda_low > 0.0, "erf.shoc.lambda_low must be positive");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.lambda_high >= opts.lambda_low,
                                     "erf.shoc.lambda_high must be >= lambda_low");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.length_fac > 0.0, "erf.shoc.length_fac must be positive");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.coeff_kh >= 0.0, "erf.shoc.coeff_kh must be non-negative");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.coeff_km >= 0.0, "erf.shoc.coeff_km must be non-negative");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.top_taper_depth >= 0.0,
                                     "erf.shoc.top_taper_depth must be non-negative");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.top_taper_min_factor >= 0.0 &&
                                     opts.top_taper_min_factor <= 1.0,
                                     "erf.shoc.top_taper_min_factor must be in [0, 1]");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.debug_bad_column_max_reports > 0,
                                     "erf.shoc.debug_bad_column_max_reports must be positive");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.debug_bad_column_theta_tend_threshold > 0.0,
                                     "erf.shoc.debug_bad_column_theta_tend_threshold must be positive");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.debug_bad_column_q_tend_threshold > 0.0,
                                     "erf.shoc.debug_bad_column_q_tend_threshold must be positive");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.debug_bad_column_brunt_threshold > 0.0,
                                     "erf.shoc.debug_bad_column_brunt_threshold must be positive");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.debug_bad_column_min_dz > 0.0,
                                     "erf.shoc.debug_bad_column_min_dz must be positive");
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(opts.debug_bad_column_scalar_moment_threshold > 0.0,
                                     "erf.shoc.debug_bad_column_scalar_moment_threshold must be positive");
    std::string error_message;
    AMREX_ALWAYS_ASSERT_WITH_MESSAGE(validate_shoc_runtime_options_message(opts, error_message),
                                     error_message.c_str());
}

Referenced by ShocDriver::ShocDriver().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_shoc_runtime_options_message()

bool validate_shoc_runtime_options_message ( const ShocRuntimeOptions &  opts, std::string &  error_message  )

inline

{
    if (shoc_uses_host_diffusion(opts.transport_mode) &&
        !shoc_uses_momentum_host_diffusion(opts.momentum_transport)) {
        error_message =
            "erf.shoc.transport_mode = host_diffusion requires erf.shoc.momentum_transport = host_diffusion";
        return false;
    }
    return true;
}

Referenced by validate_shoc_runtime_options().

Here is the call graph for this function:

Here is the caller graph for this function: