near_surface_diagnostics Namespace Reference

Classes
struct	NativeBundle
struct	NativeAggregate
struct	MostState
struct	MostProfile
struct	Sources
struct	WindSources

Functions
void	fill (MultiFab &dst, int temperature_comp, int mixing_ratio_comp, int source_comp, const Sources &sources, Real missing_value)
void	fill_wind_10m (MultiFab &dst, int u_comp, int v_comp, int u_east_comp, int v_north_comp, const WindSources &sources, Real missing_value)
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	valid_real (amrex::Real value) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	valid_noahmp_component (amrex::Real value) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	native_bundle_temperature_is_valid (const NativeBundle &bundle) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	native_bundle_mixing_ratio_is_valid (const NativeBundle &bundle) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	native_bundle_vegetation_fraction_is_valid (const NativeBundle &bundle) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	native_bundle_is_valid (const NativeBundle &bundle) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	native_vegetated_tile_is_used (amrex::Real vegetation_fraction) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	native_bare_tile_is_used (amrex::Real vegetation_fraction) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE NativeAggregate	aggregate_native_bundle (const NativeBundle &bundle) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	most_profile_zeta_max () noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	evaluate_most_factor (const MostState &state, amrex::Real height, amrex::Real &factor) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	evaluate_most_momentum_factor (amrex::Real roughness_height, amrex::Real obukhov_length, amrex::Real height, amrex::Real &factor) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	evaluate_most_profile (const MostState &state, amrex::Real height, MostProfile &profile) noexcept
void	fill (amrex::MultiFab &dst, int temperature_comp, int mixing_ratio_comp, int source_comp, const Sources &sources, amrex::Real missing_value=amrex::Real(-999.0))
void	fill_wind_10m (amrex::MultiFab &dst, int u_comp, int v_comp, int u_east_comp, int v_north_comp, const WindSources &sources, amrex::Real missing_value=amrex::Real(-999.0))

Variables
constexpr amrex::Real	wind_height = amrex::Real(10.0)

Function Documentation

aggregate_native_bundle()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE NativeAggregate near_surface_diagnostics::aggregate_native_bundle ( const NativeBundle &  bundle )

noexcept

{
    const amrex::Real f = bundle.vegetation_fraction;
    // At the endpoints take the one tile in use, so that an unused tile's
    // placeholder (which may be a sentinel) cannot leak in through 0 * value.
    if (!native_vegetated_tile_is_used(f)) {
        return {bundle.temperature_bare, bundle.mixing_ratio_bare};
    }
    if (!native_bare_tile_is_used(f)) {
        return {bundle.temperature_vegetated, bundle.mixing_ratio_vegetated};
    }
    return {
        f * bundle.temperature_vegetated + (amrex::Real(1.0)-f) * bundle.temperature_bare,
        f * bundle.mixing_ratio_vegetated + (amrex::Real(1.0)-f) * bundle.mixing_ratio_bare
    };
}

Referenced by fill().

Here is the call graph for this function:

Here is the caller graph for this function:

evaluate_most_factor()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::evaluate_most_factor ( const MostState &  state, amrex::Real  height, amrex::Real &  factor  )

noexcept

{
    if (!valid_real(state.roughness_height) ||
        !valid_real(state.obukhov_length) ||
        state.roughness_height <= amrex::Real(0.0) ||
        height <= state.roughness_height ||
        state.obukhov_length == amrex::Real(0.0)) {
        return false;
    }
    const similarity_funs sfuns{};
    const amrex::Real zeta = amrex::min(height / state.obukhov_length,
                                        most_profile_zeta_max());
    factor = std::log(height / state.roughness_height) - sfuns.calc_psi_h(zeta);
    return valid_real(factor);
}

Referenced by evaluate_most_profile(), and fill().

Here is the call graph for this function:

Here is the caller graph for this function:

evaluate_most_momentum_factor()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::evaluate_most_momentum_factor ( amrex::Real  roughness_height, amrex::Real  obukhov_length, amrex::Real  height, amrex::Real &  factor  )

noexcept

{
    if (!valid_real(roughness_height) || !valid_real(obukhov_length) ||
        roughness_height <= amrex::Real(0.0) ||
        height <= roughness_height ||
        obukhov_length == amrex::Real(0.0)) {
        return false;
    }
    const similarity_funs sfuns{};
    const amrex::Real zeta = amrex::min(height / obukhov_length,
                                        most_profile_zeta_max());
    factor = std::log(height / roughness_height) - sfuns.calc_psi_m(zeta);
    return valid_real(factor);
}

Referenced by fill_wind_10m().

Here is the call graph for this function:

Here is the caller graph for this function:

evaluate_most_profile()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::evaluate_most_profile ( const MostState &  state, amrex::Real  height, MostProfile &  profile  )

noexcept

{
    if (!valid_real(state.theta_surface) || !valid_real(state.theta_star) ||
        !valid_real(state.mixing_ratio_surface) || !valid_real(state.mixing_ratio_star)) {
        return false;
    }
 
    amrex::Real profile_factor = amrex::Real(0.0);
    if (!evaluate_most_factor(state, height, profile_factor)) {
        return false;
    }
 
    profile.potential_temperature = state.theta_surface +
        state.theta_star / KAPPA * profile_factor;
    profile.mixing_ratio = state.mixing_ratio_surface +
        state.mixing_ratio_star / KAPPA * profile_factor;
    return valid_real(profile.potential_temperature) &&
           valid_real(profile.mixing_ratio) &&
           profile.potential_temperature > amrex::Real(0.0) &&
           profile.mixing_ratio >= amrex::Real(0.0);
}

Here is the call graph for this function:

fill() [1/2]

void near_surface_diagnostics::fill	(	amrex::MultiFab &	dst,
		int	temperature_comp,
		int	mixing_ratio_comp,
		int	source_comp,
		const Sources &	sources,
		amrex::Real	missing_value = amrex::Real(-999.0)
	)

fill() [2/2]

void near_surface_diagnostics::fill	(	MultiFab &	dst,
		int	temperature_comp,
		int	mixing_ratio_comp,
		int	source_comp,
		const Sources &	sources,
		Real	missing_value
	)

{
#ifdef _OPENMP
#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
#endif
    for (MFIter mfi(dst, TilingIfNotGPU()); mfi.isValid(); ++mfi) {
        const Box& bx = mfi.tilebox();
        const auto dst_arr = dst.array(mfi);
 
        const auto tv = array_or_empty(sources.native_temperature_vegetated, mfi);
        const auto tb = array_or_empty(sources.native_temperature_bare, mfi);
        const auto qv = array_or_empty(sources.native_mixing_ratio_vegetated, mfi);
        const auto qb = array_or_empty(sources.native_mixing_ratio_bare, mfi);
        const auto fv = array_or_empty(sources.native_vegetation_fraction, mfi);
        const auto ts = array_or_empty(sources.theta_surface, mfi);
        const auto tstar = array_or_empty(sources.theta_star, mfi);
        const auto qs = array_or_empty(sources.mixing_ratio_surface, mfi);
        const auto qstar = array_or_empty(sources.mixing_ratio_star, mfi);
        const auto z0 = array_or_empty(sources.roughness_height, mfi);
        const auto olen = array_or_empty(sources.obukhov_length, mfi);
        const auto source_mask = array_or_empty(sources.source_mask, mfi);
        const auto lmask = int_array_or_empty(sources.land_mask, mfi);
        const auto cons = array_or_empty(sources.cons, mfi);
        const auto znd = array_or_empty(sources.z_phys_nd, mfi);
 
        const bool request_temperature = temperature_comp >= 0;
        const bool request_mixing_ratio = mixing_ratio_comp >= 0;
        const bool request_source = source_comp >= 0;
        // Provenance follows the temperature path only for a source-only
        // request. When paired with humidity, it describes the humidity
        // source without adding an unrequested temperature prerequisite.
        const bool source_only = request_source && !request_temperature &&
                                 !request_mixing_ratio;
        const bool need_temperature = request_temperature || source_only;
        const bool need_mixing_ratio = request_mixing_ratio;
        const bool have_native_temperature = sources.native_temperature_vegetated &&
                                              sources.native_temperature_bare &&
                                              sources.native_vegetation_fraction;
        const bool have_native_mixing_ratio = sources.native_mixing_ratio_vegetated &&
                                               sources.native_mixing_ratio_bare &&
                                               sources.native_vegetation_fraction;
        const bool have_most_temperature = sources.theta_surface && sources.theta_star &&
                                           sources.roughness_height && sources.obukhov_length;
        const bool have_most_mixing_ratio = sources.mixing_ratio_surface &&
                                            sources.mixing_ratio_star &&
                                            sources.roughness_height && sources.obukhov_length;
        const bool have_atmosphere = sources.cons != nullptr;
        const bool have_source_mask = sources.source_mask != nullptr;
        const bool have_land_mask = sources.land_mask != nullptr;
        const int klo = sources.klo;
        const Real dz = sources.dz;
        const bool moist = sources.moist;
        const bool has_lsm = sources.has_lsm;
 
        ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            Real temperature = missing_value;
            Real mixing_ratio = missing_value;
            Real source_value = surface_diagnostics::to_plot_value(
                surface_diagnostics::SurfaceDiagnosticSource::Missing);
 
            const NativeBundle native_bundle{
                have_native_temperature ? tv(i,j,0) : missing_value,
                have_native_temperature ? tb(i,j,0) : missing_value,
                have_native_mixing_ratio ? qv(i,j,0) : missing_value,
                have_native_mixing_ratio ? qb(i,j,0) : missing_value,
                (have_native_temperature || have_native_mixing_ratio) ? fv(i,j,0) : missing_value
            };
            const bool native_temperature_valid = have_native_temperature &&
                native_bundle_temperature_is_valid(native_bundle);
            const bool native_mixing_ratio_valid = moist && have_native_mixing_ratio &&
                native_bundle_mixing_ratio_is_valid(native_bundle);
            const bool native_selected = (!need_temperature || native_temperature_valid) &&
                                         (!need_mixing_ratio || native_mixing_ratio_valid);
 
            bool selected = false;
            if (native_selected && (need_temperature || need_mixing_ratio)) {
                const NativeAggregate aggregate = aggregate_native_bundle(native_bundle);
                if (need_temperature) {
                    temperature = aggregate.temperature;
                }
                if (need_mixing_ratio) {
                    mixing_ratio = aggregate.mixing_ratio;
                }
                source_value = surface_diagnostics::to_plot_value(
                    surface_diagnostics::SurfaceDiagnosticSource::LSMLand);
                selected = true;
            }
 
            if (!selected && (need_temperature || need_mixing_ratio)) {
                const MostState state{
                    have_most_temperature ? ts(i,j,0) : missing_value,
                    have_most_temperature ? tstar(i,j,0) : missing_value,
                    have_most_mixing_ratio ? qs(i,j,0) : missing_value,
                    have_most_mixing_ratio ? qstar(i,j,0) : missing_value,
                    (have_most_temperature || have_most_mixing_ratio) ? z0(i,j,0) : missing_value,
                    (have_most_temperature || have_most_mixing_ratio) ? olen(i,j,0) : missing_value
                };
                Real factor = zero;
                const bool common_most_valid = evaluate_most_factor(state, Real(2.0), factor);
                bool most_temperature_valid = false;
                bool most_mixing_ratio_valid = false;
                Real theta_2m = missing_value;
                Real q_2m = missing_value;
                if (common_most_valid && need_temperature && have_most_temperature) {
                    theta_2m = state.theta_surface + state.theta_star / KAPPA * factor;
                    if (valid_real(theta_2m) && theta_2m > zero && have_atmosphere) {
                        const Real rho = cons(i,j,klo,Rho_comp);
                        const Real rhotheta = cons(i,j,klo,RhoTheta_comp);
                        const Real q_cell = moist ? cons(i,j,klo,RhoQ1_comp) / rho : zero;
                        if (valid_real(rho) && rho > zero && valid_real(rhotheta) &&
                            valid_real(q_cell) && q_cell >= zero) {
                            const Real p_cc = getPgivenRTh(rhotheta, q_cell);
                            const Real z_cc_agl = znd ? Compute_Zrel_AtCellCenter(i,j,klo,znd)
                                                       : Real(0.5) * dz;
                            const Real p_2m = p_cc + rho * CONST_GRAV *
                                              (z_cc_agl - Real(2.0));
                            const Real t_2m = (valid_real(p_2m) && p_2m > zero)
                                ? getTgivenPandTh(p_2m, theta_2m, R_d/Cp_d)
                                : missing_value;
                            most_temperature_valid = valid_real(t_2m) && t_2m > zero;
                            if (most_temperature_valid) { temperature = t_2m; }
                        }
                    }
                }
                if (common_most_valid && need_mixing_ratio && moist &&
                    have_most_mixing_ratio && valid_real(state.mixing_ratio_surface) &&
                    valid_real(state.mixing_ratio_star)) {
                    q_2m = state.mixing_ratio_surface + state.mixing_ratio_star / KAPPA * factor;
                    most_mixing_ratio_valid = valid_real(q_2m) && q_2m >= zero;
                    if (most_mixing_ratio_valid) {
                        mixing_ratio = q_2m;
                    }
                }
                const bool most_selected = (!need_temperature || most_temperature_valid) &&
                                           (!need_mixing_ratio || most_mixing_ratio_valid);
                // Do not expose a valid scalar from an incomplete MOST bundle
                // when both requested fields must come from one source.
                if (!most_selected) {
                    temperature = missing_value;
                    mixing_ratio = missing_value;
                }
                if (most_selected) {
                    if (have_source_mask && source_value_is_valid(source_mask(i,j,0))) {
                        source_value = source_mask(i,j,0);
                        if (static_cast<int>(source_value) ==
                            surface_diagnostics::to_int(surface_diagnostics::SurfaceDiagnosticSource::LSMLand)) {
                            source_value = surface_diagnostics::to_plot_value(
                                surface_diagnostics::SurfaceDiagnosticSource::SurfaceLayerFallback);
                        }
                    } else if (have_land_mask && lmask(i,j,0) == 0) {
                        source_value = surface_diagnostics::to_plot_value(
                            surface_diagnostics::SurfaceDiagnosticSource::SurfaceLayerSea);
                    } else {
                        source_value = surface_diagnostics::to_plot_value(
                            has_lsm ? surface_diagnostics::SurfaceDiagnosticSource::SurfaceLayerFallback
                                    : surface_diagnostics::SurfaceDiagnosticSource::SurfaceLayerLand);
                    }
                    selected = true;
                }
            }
 
            if (temperature_comp >= 0) {
                dst_arr(i,j,k,temperature_comp) = temperature;
            }
            if (mixing_ratio_comp >= 0) {
                dst_arr(i,j,k,mixing_ratio_comp) = (selected && moist)
                    ? mixing_ratio : missing_value;
            }
            if (source_comp >= 0) {
                dst_arr(i,j,k,source_comp) = source_value;
            }
        });
    }
}

Referenced by erf_auxiliary::CompletedStepFluxLedger::begin_stage(), IBFaceSet::build(), erf_auxiliary::CompletedStepFluxLedger::discard_step(), ERF::FillPlot2DVars(), SLM::init_from_inputs(), PlaneAverage::operator()(), obs_nudging::parse_station_series(), and WidenForPBLH().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_wind_10m() [1/2]

void near_surface_diagnostics::fill_wind_10m	(	amrex::MultiFab &	dst,
		int	u_comp,
		int	v_comp,
		int	u_east_comp,
		int	v_north_comp,
		const WindSources &	sources,
		amrex::Real	missing_value = amrex::Real(-999.0)
	)

fill_wind_10m() [2/2]

void near_surface_diagnostics::fill_wind_10m	(	MultiFab &	dst,
		int	u_comp,
		int	v_comp,
		int	u_east_comp,
		int	v_north_comp,
		const WindSources &	sources,
		Real	missing_value
	)

{
    if (u_comp < 0 && v_comp < 0 && u_east_comp < 0 && v_north_comp < 0) { return; }
 
    const bool have_surface_layer = sources.u_star && sources.roughness_height &&
                                    sources.obukhov_length && sources.xvel && sources.yvel;
    const bool have_rotation = sources.cos_alpha && sources.sin_alpha;
    const int klo = sources.klo;
 
#ifdef _OPENMP
#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
#endif
    for (MFIter mfi(dst, TilingIfNotGPU()); mfi.isValid(); ++mfi) {
        const Box& bx = mfi.tilebox();
        const auto dst_arr = dst.array(mfi);
 
        const auto ustar = array_or_empty(sources.u_star, mfi);
        const auto z0 = array_or_empty(sources.roughness_height, mfi);
        const auto olen = array_or_empty(sources.obukhov_length, mfi);
        const auto u = array_or_empty(sources.xvel, mfi);
        const auto v = array_or_empty(sources.yvel, mfi);
        const auto cosa = array_or_empty(sources.cos_alpha, mfi);
        const auto sina = array_or_empty(sources.sin_alpha, mfi);
 
        ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            Real u10 = missing_value;
            Real v10 = missing_value;
            Real factor = zero;
            if (have_surface_layer &&
                valid_real(ustar(i,j,0)) && ustar(i,j,0) >= zero &&
                evaluate_most_momentum_factor(z0(i,j,0), olen(i,j,0), wind_height, factor)) {
                const Real speed = ustar(i,j,0) / KAPPA * factor;
                // The direction of the wind at the centre of the first cell
                const Real u_cc = myhalf * (u(i,j,klo) + u(i+1,j,klo));
                const Real v_cc = myhalf * (v(i,j,klo) + v(i,j+1,klo));
                const Real speed_cc = std::sqrt(u_cc*u_cc + v_cc*v_cc);
                if (valid_real(speed) && speed >= zero && valid_real(speed_cc)) {
                    u10 = (speed_cc > zero) ? speed * u_cc / speed_cc : zero;
                    v10 = (speed_cc > zero) ? speed * v_cc / speed_cc : zero;
                }
            }
 
            if (u_comp >= 0) { dst_arr(i,j,k,u_comp) = u10; }
            if (v_comp >= 0) { dst_arr(i,j,k,v_comp) = v10; }
            if (u_east_comp >= 0 || v_north_comp >= 0) {
                Real u_east = u10;
                Real v_north = v10;
                // Without a grid orientation the grid is taken to be aligned with east
                if (u10 != missing_value && have_rotation) {
                    erf_earth_wind::grid_to_earth(u10, v10, cosa(i,j,0), sina(i,j,0), u_east, v_north);
                }
                if (u_east_comp  >= 0) { dst_arr(i,j,k,u_east_comp)  = u_east; }
                if (v_north_comp >= 0) { dst_arr(i,j,k,v_north_comp) = v_north; }
            }
        });
    }
}

Referenced by ERF::FillPlot2DVars().

Here is the call graph for this function:

Here is the caller graph for this function:

most_profile_zeta_max()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real near_surface_diagnostics::most_profile_zeta_max ( )

noexcept

{ return amrex::Real(1.0); }

Referenced by evaluate_most_factor(), and evaluate_most_momentum_factor().

Here is the caller graph for this function:

native_bare_tile_is_used()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::native_bare_tile_is_used ( amrex::Real  vegetation_fraction )

noexcept

{
    return vegetation_fraction < amrex::Real(1.0);
}

Referenced by aggregate_native_bundle(), native_bundle_mixing_ratio_is_valid(), and native_bundle_temperature_is_valid().

Here is the caller graph for this function:

native_bundle_is_valid()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::native_bundle_is_valid ( const NativeBundle &  bundle )

noexcept

{
    return native_bundle_temperature_is_valid(bundle) &&
           native_bundle_mixing_ratio_is_valid(bundle) &&
           native_bundle_vegetation_fraction_is_valid(bundle);
}

Here is the call graph for this function:

native_bundle_mixing_ratio_is_valid()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::native_bundle_mixing_ratio_is_valid ( const NativeBundle &  bundle )

noexcept

{
    if (!native_bundle_vegetation_fraction_is_valid(bundle)) { return false; }
    const amrex::Real f = bundle.vegetation_fraction;
    const bool vegetated_ok = !native_vegetated_tile_is_used(f) ||
        (valid_noahmp_component(bundle.mixing_ratio_vegetated) &&
         bundle.mixing_ratio_vegetated >= amrex::Real(0.0));
    const bool bare_ok = !native_bare_tile_is_used(f) ||
        (valid_noahmp_component(bundle.mixing_ratio_bare) &&
         bundle.mixing_ratio_bare >= amrex::Real(0.0));
    return vegetated_ok && bare_ok;
}

Referenced by fill(), and native_bundle_is_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

native_bundle_temperature_is_valid()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::native_bundle_temperature_is_valid ( const NativeBundle &  bundle )

noexcept

{
    if (!native_bundle_vegetation_fraction_is_valid(bundle)) { return false; }
    const amrex::Real f = bundle.vegetation_fraction;
    const bool vegetated_ok = !native_vegetated_tile_is_used(f) ||
        (valid_noahmp_component(bundle.temperature_vegetated) &&
         bundle.temperature_vegetated > amrex::Real(0.0));
    const bool bare_ok = !native_bare_tile_is_used(f) ||
        (valid_noahmp_component(bundle.temperature_bare) &&
         bundle.temperature_bare > amrex::Real(0.0));
    return vegetated_ok && bare_ok;
}

Referenced by fill(), and native_bundle_is_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

native_bundle_vegetation_fraction_is_valid()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::native_bundle_vegetation_fraction_is_valid ( const NativeBundle &  bundle )

noexcept

{
    return valid_noahmp_component(bundle.vegetation_fraction) &&
           bundle.vegetation_fraction >= amrex::Real(0.0) &&
           bundle.vegetation_fraction <= amrex::Real(1.0);
}

Referenced by native_bundle_is_valid(), native_bundle_mixing_ratio_is_valid(), and native_bundle_temperature_is_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

native_vegetated_tile_is_used()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::native_vegetated_tile_is_used ( amrex::Real  vegetation_fraction )

noexcept

{
    return vegetation_fraction > amrex::Real(0.0);
}

Referenced by aggregate_native_bundle(), native_bundle_mixing_ratio_is_valid(), and native_bundle_temperature_is_valid().

Here is the caller graph for this function:

valid_noahmp_component()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::valid_noahmp_component ( amrex::Real  value )

noexcept

{
    return valid_real(value) && value > amrex::Real(-9990.0) &&
           value < amrex::Real(0.5) * lsm_undefined;
}

Referenced by native_bundle_mixing_ratio_is_valid(), native_bundle_temperature_is_valid(), and native_bundle_vegetation_fraction_is_valid().

Here is the call graph for this function:

Here is the caller graph for this function:

valid_real()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool near_surface_diagnostics::valid_real ( amrex::Real  value )

noexcept

{
    return amrex::Math::isfinite(value);
}

Referenced by evaluate_most_factor(), evaluate_most_momentum_factor(), evaluate_most_profile(), fill(), fill_wind_10m(), and valid_noahmp_component().

Here is the caller graph for this function:

Variable Documentation

wind_height

constexpr amrex::Real near_surface_diagnostics::wind_height = amrex::Real(10.0)

constexpr

Referenced by fill_wind_10m().