plotfile2d Namespace Reference

Classes
struct	DiagnosticDescriptor
struct	SampledBracket
struct	SampledWindSources
struct	SelectedSurfacePrecipAccumulationComponents
struct	SampledFieldDescriptor
struct	SampledFieldSelection
struct	SampledVerticalCoordinateMetadata
struct	SampledLevelMetadata
struct	Plotfile2DOutputDescriptor
struct	SampledLevelDefinition
struct	PlotVariableSelection
struct	WaterPathDescriptor
struct	SelectedWaterPathComponents

Enumerations
enum class	DiagnosticID {   ZSurf , LandMask , MapFac , LatM ,   LonM , UStar , WStar , TStar ,   QStar , Olen , Pblh , TSurf ,   QSurf , Z0 , OLR , SensFlux ,   LatenFlux , SurfPres , PrecipTotalAccum , PrecipRainAccum ,   PrecipSnowAccum , PrecipGraupelAccum , PrecipHailAccum , PrecipFrozenAccum ,   IntegratedQv , IntegratedQc , IntegratedQi , IntegratedQr ,   IntegratedQs , IntegratedQg , SurfaceDiagnosticSource , SensibleHeatFlux ,   LatentHeatFlux , ShocUStar , ShocOlen , ShocWthvSfc ,   LandSurfaceTsfC , LandSurfaceEmissivity , LandSurfaceAlbDirVis , LandSurfaceAlbDirNir ,   LandSurfaceAlbDifVis , LandSurfaceAlbDifNir , LandSurfaceCosZenith , LandSurfaceSwFluxDn ,   LandSurfaceSwFluxDnDirVis , LandSurfaceSwFluxDnDirNir , LandSurfaceSwFluxDnDifVis , LandSurfaceSwFluxDnDifNir ,   LandSurfaceLwFluxDn , LandSurfaceGrdflx , LandSurfaceFira , LandSurfaceSav ,   LandSurfaceSag , LandSurfaceAlbedo , LandSurfaceSfcrunoff , LandSurfaceUdrunoff ,   NoahmpTemperature2mVegetated , NoahmpTemperature2mBare , NoahmpWaterVaporMixingRatio2mVegetated , NoahmpWaterVaporMixingRatio2mBare ,   NoahmpVegetationFraction , Temperature2m , WaterVaporMixingRatio2m , NearSurfaceDiagnosticSource ,   DynamicSoilBase }
enum class	DiagnosticCategory {   Geometry , SurfaceLayer , Radiation , SurfaceFlux ,   PBL , SurfaceState , Precipitation , ColumnIntegral ,   LandSurface , SampledLevel }
enum class	MissingPolicy { AlwaysAvailable , FillZeroWhenUnavailable , FillMinus999WhenUnavailable }
enum class	SampledFieldID {   Rho , Theta , Temp , Pressure ,   HeightMSL , HeightAGL , Qv , Qc ,   Qi , Qr , Qs , Qg ,   UEast , VNorth , W , WindSpeed ,   WindDir }
enum class	SampledCoordinate { ModelIndex , HeightMSL , HeightAGL , Pressure }
enum class	SampledInterpolation { None , Linear }

Functions
const amrex::Vector< DiagnosticDescriptor > &	diagnostic_catalog ()
amrex::Vector< std::string >	diagnostic_names ()
const DiagnosticDescriptor *	find_diagnostic (const std::string &name)
amrex::Vector< std::string >	dynamic_soil_diagnostic_names (int nsoil)
amrex::Vector< std::string >	dynamic_soil_diagnostic_names (const amrex::Vector< std::string > &active_lsm_names)
const DiagnosticDescriptor *	find_dynamic_soil_diagnostic (const std::string &name)
bool	is_dynamic_soil_diagnostic_name (const std::string &name)
void	fill_component_with_value (MultiFab &dst, int dst_comp, Real value)
void	fill_component_from_klevel (MultiFab &dst, int dst_comp, const MultiFab &src, int src_k, int src_comp)
void	fill_component_from_klevel_or_value (MultiFab &dst, int dst_comp, const MultiFab *src, int src_k, Real missing_value, int src_comp)
void	fill_land_surface_component_from_klevel_or_missing (MultiFab &dst, int dst_comp, const MultiFab *src, int src_k, Real missing_value)
void	fill_sensible_heat_flux_from_klevel_or_missing (MultiFab &dst, int dst_comp, const MultiFab *src, int src_k, Real missing_value)
void	fill_latent_heat_flux_from_klevel_or_missing (MultiFab &dst, int dst_comp, const MultiFab *src, int src_k, Real missing_value)
void	fill_component_with_value (amrex::MultiFab &dst, int dst_comp, amrex::Real value)
void	fill_component_from_klevel (amrex::MultiFab &dst, int dst_comp, const amrex::MultiFab &src, int src_k, int src_comp=0)
void	fill_component_from_klevel_or_value (amrex::MultiFab &dst, int dst_comp, const amrex::MultiFab *src, int src_k, amrex::Real missing_value, int src_comp=0)
void	fill_land_surface_component_from_klevel_or_missing (amrex::MultiFab &dst, int dst_comp, const amrex::MultiFab *src, int src_k, amrex::Real missing_value)
void	fill_sensible_heat_flux_from_klevel_or_missing (amrex::MultiFab &dst, int dst_comp, const amrex::MultiFab *src, int src_k, amrex::Real missing_value)
void	fill_latent_heat_flux_from_klevel_or_missing (amrex::MultiFab &dst, int dst_comp, const amrex::MultiFab *src, int src_k, amrex::Real missing_value)
void	fill_sampled_level_component (MultiFab &dst, int dst_comp, const Plotfile2DOutputDescriptor &descriptor, const MultiFab &cons, const MultiFab *z_phys_cc, const MultiFab &z_phys_nd, bool have_z_phys_cc, const MoistureComponentIndices &moisture_indices, int klo, int khi, const SampledWindSources &wind_sources)
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	sampled_target_is_bracketed (amrex::Real target, amrex::Real c0, amrex::Real c1) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real	linear_interpolate (amrex::Real lo_value, amrex::Real hi_value, amrex::Real lo_coord, amrex::Real hi_coord, amrex::Real target) noexcept
void	fill_sampled_level_component (amrex::MultiFab &dst, int dst_comp, const Plotfile2DOutputDescriptor &descriptor, const amrex::MultiFab &cons, const amrex::MultiFab *z_phys_cc, const amrex::MultiFab &z_phys_nd, bool have_z_phys_cc, const MoistureComponentIndices &moisture_indices, int klo, int khi, const SampledWindSources &wind_sources={})
const char *	diagnostic_category_to_string (DiagnosticCategory category) noexcept
const char *	missing_policy_to_string (MissingPolicy policy) noexcept
std::string	missing_value_json (MissingPolicy policy)
std::string	escape_json_string (const std::string &value)
std::string	metadata_json_filename (const std::string &plotfilename)
std::string	format_2d_metadata_json (const amrex::Vector< std::string > &varnames)
std::string	format_2d_metadata_json (const amrex::Vector< Plotfile2DOutputDescriptor > &descriptors)
void	write_2d_metadata_json (const std::string &plotfilename, const amrex::Vector< std::string > &varnames)
void	write_2d_metadata_json (const std::string &plotfilename, const amrex::Vector< Plotfile2DOutputDescriptor > &descriptors)
bool	is_precipitation_accumulation (DiagnosticID id) noexcept
bool	is_precipitation_accumulation_name (const std::string &name)
bool	precipitation_diagnostic_available (DiagnosticID id, const MoistureComponentIndices &moisture_indices) noexcept
SelectedSurfacePrecipAccumulationComponents	selected_precipitation_accumulation_components (const amrex::Vector< std::string > &plot_var_names, const SurfacePrecipAccumulationSources &sources)
void	fill_precipitation_accumulations (MultiFab &dst, const SurfacePrecipAccumulationSources &sources, const SelectedSurfacePrecipAccumulationComponents &selected, const int klo)
void	fill_precipitation_accumulations (amrex::MultiFab &dst, const SurfacePrecipAccumulationSources &sources, const SelectedSurfacePrecipAccumulationComponents &selected, const int klo)
const amrex::Vector< SampledFieldDescriptor > &	sampled_field_catalog ()
const SampledFieldDescriptor *	find_sampled_field (const std::string &name)
amrex::Vector< std::string >	available_sampled_field_names (const SolverChoice &solver_choice)
SampledFieldSelection	select_requested_sampled_fields (const amrex::Vector< std::string > &requested, const SolverChoice &solver_choice)
std::string	sampled_field_id_to_string (SampledFieldID field_id)
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	sampled_field_is_wind (SampledFieldID field_id) noexcept
AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool	sampled_field_is_scalar_state (SampledFieldID field_id) noexcept
AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real	sampled_field_value (SampledFieldID field_id, const amrex::Array4< const amrex::Real > &cons_arr, const amrex::Array4< const amrex::Real > &z_phys_cc_arr, const amrex::Array4< const amrex::Real > &z_phys_nd_arr, bool have_z_phys_cc, int i, int j, int k, const MoistureComponentIndices &moisture_indices) noexcept
const char *	sampled_field_name (SampledFieldID field_id) noexcept
const char *	sampled_coordinate_to_string (SampledCoordinate coordinate) noexcept
const char *	sampled_coordinate_tag (SampledCoordinate coordinate) noexcept
const char *	sampled_coordinate_default_units (SampledCoordinate coordinate) noexcept
const char *	sampled_coordinate_default_interpolation (SampledCoordinate coordinate) noexcept
const char *	sampled_interpolation_to_string (SampledInterpolation interpolation) noexcept
SampledCoordinate	sampled_coordinate_from_string (const std::string &value)
SampledInterpolation	sampled_interpolation_from_string (const std::string &value)
std::string	validate_sampled_coordinate_string (const std::string &level_set_name, const std::string &value)
std::string	sampled_level_error_prefix (const std::string &level_set_name, const std::string &parameter_name)
std::string	sampled_level_value_tag (amrex::Real value, const std::string &units)
std::string	sampled_output_name (const std::string &field_name, SampledCoordinate coordinate, amrex::Real value, const std::string &units)
std::string	validate_sampled_level_definition (const SampledLevelDefinition &level_set)
SampledLevelDefinition	parse_sampled_level_definition (const std::string &level_set_name, const std::string &pp_prefix)
amrex::Vector< std::string >	parse_requested_sampled_level_sets (const std::string &pp_prefix, int which)
amrex::Vector< Plotfile2DOutputDescriptor >	build_sampled_level_output_descriptors_from_definitions (const amrex::Vector< SampledLevelDefinition > &level_sets, const amrex::Vector< std::string > &static_plot_vars, const SolverChoice &solver_choice)
amrex::Vector< Plotfile2DOutputDescriptor >	build_sampled_level_output_descriptors (const std::string &pp_prefix, int which, const amrex::Vector< std::string > &static_plot_vars, const SolverChoice &solver_choice)
PlotVariableSelection	select_requested_plot_variables (const amrex::Vector< std::string > &requested, const amrex::Vector< std::string > &available)
std::string	format_unavailable_2d_plot_var_warning (const std::string &parameter_name, const std::string &unavailable_name, const amrex::Vector< std::string > &available_names)
std::string	format_plot2d_parameter_name (const std::string &pp_prefix, const std::string &parameter_name)
std::string	format_2d_component_count_error (int lev, int filled, int expected)
std::string	format_invalid_2d_stream_error (int which)
AMREX_FORCE_INLINE bool	use_native_shoc_consumed_flux_source (bool native_shoc_owns_scalar_fluxes, bool native_shoc_has_consumed_flux_diagnostics, bool host_flux_field_available) noexcept
bool	is_condensed_water_path (DiagnosticID id) noexcept
amrex::Vector< WaterPathDescriptor >	active_condensed_water_path_descriptors (const SolverChoice &solver_choice)
bool	is_condensed_water_path_name (const std::string &name)
bool	is_noahmp_active (const SolverChoice &solver_choice) noexcept
bool	is_land_surface_provider_field (DiagnosticID id) noexcept
bool	active_lsm_contains (const amrex::Vector< std::string > &active_lsm_names, const char *name)
amrex::Vector< std::string >	available_diagnostic_names (const SolverChoice &solver_choice)
amrex::Vector< std::string >	available_diagnostic_names (const SolverChoice &solver_choice, bool has_surface_layer)
amrex::Vector< std::string >	available_diagnostic_names (const SolverChoice &solver_choice, bool has_surface_layer, const amrex::Vector< std::string > &active_lsm_names)
SelectedWaterPathComponents	selected_condensed_water_path_components (const amrex::Vector< std::string > &plot_var_names, const SolverChoice &solver_choice)
void	fill_condensed_water_paths (MultiFab &dst, const MultiFab &cons, const SelectedWaterPathComponents &selected, const Geometry &geom, const MultiFab &detJ)
void	fill_condensed_water_paths (amrex::MultiFab &dst, const amrex::MultiFab &cons, const SelectedWaterPathComponents &selected, const amrex::Geometry &geom, const amrex::MultiFab &detJ)

Variables
static constexpr int	MaxSurfacePrecipAccumulationComponents = 6
static constexpr int	MaxCondensedWaterPathComponents = 5

Enumeration Type Documentation

DiagnosticCategory

enum plotfile2d::DiagnosticCategory

strong

Enumerator
Geometry
SurfaceLayer
Radiation
SurfaceFlux
PBL
SurfaceState
Precipitation
ColumnIntegral
LandSurface
SampledLevel

{
    Geometry,
    SurfaceLayer,
    Radiation,
    SurfaceFlux,
    PBL,
    SurfaceState,
    Precipitation,
    ColumnIntegral,
    LandSurface,
    SampledLevel
};

DiagnosticID

enum plotfile2d::DiagnosticID

strong

Enumerator
ZSurf
LandMask
MapFac
LatM
LonM
UStar
WStar
TStar
QStar
Olen
Pblh
TSurf
QSurf
Z0
OLR
SensFlux
LatenFlux
SurfPres
PrecipTotalAccum
PrecipRainAccum
PrecipSnowAccum
PrecipGraupelAccum
PrecipHailAccum
PrecipFrozenAccum
IntegratedQv
IntegratedQc
IntegratedQi
IntegratedQr
IntegratedQs
IntegratedQg
SurfaceDiagnosticSource
SensibleHeatFlux
LatentHeatFlux
ShocUStar
ShocOlen
ShocWthvSfc
LandSurfaceTsfC
LandSurfaceEmissivity
LandSurfaceAlbDirVis
LandSurfaceAlbDirNir
LandSurfaceAlbDifVis
LandSurfaceAlbDifNir
LandSurfaceCosZenith
LandSurfaceSwFluxDn
LandSurfaceSwFluxDnDirVis
LandSurfaceSwFluxDnDirNir
LandSurfaceSwFluxDnDifVis
LandSurfaceSwFluxDnDifNir
LandSurfaceLwFluxDn
LandSurfaceGrdflx
LandSurfaceFira
LandSurfaceSav
LandSurfaceSag
LandSurfaceAlbedo
LandSurfaceSfcrunoff
LandSurfaceUdrunoff
NoahmpTemperature2mVegetated
NoahmpTemperature2mBare
NoahmpWaterVaporMixingRatio2mVegetated
NoahmpWaterVaporMixingRatio2mBare
NoahmpVegetationFraction
Temperature2m
WaterVaporMixingRatio2m
NearSurfaceDiagnosticSource
DynamicSoilBase

{
    ZSurf,
    LandMask,
    MapFac,
    LatM,
    LonM,
    UStar,
    WStar,
    TStar,
    QStar,
    Olen,
    Pblh,
    TSurf,
    QSurf,
    Z0,
    OLR,
    SensFlux,
    LatenFlux,
    SurfPres,
    PrecipTotalAccum,
    PrecipRainAccum,
    PrecipSnowAccum,
    PrecipGraupelAccum,
    PrecipHailAccum,
    PrecipFrozenAccum,
    IntegratedQv,
    IntegratedQc,
    IntegratedQi,
    IntegratedQr,
    IntegratedQs,
    IntegratedQg,
    SurfaceDiagnosticSource,
    SensibleHeatFlux,
    LatentHeatFlux,
    ShocUStar,
    ShocOlen,
    ShocWthvSfc,
    LandSurfaceTsfC,
    LandSurfaceEmissivity,
    LandSurfaceAlbDirVis,
    LandSurfaceAlbDirNir,
    LandSurfaceAlbDifVis,
    LandSurfaceAlbDifNir,
    LandSurfaceCosZenith,
    LandSurfaceSwFluxDn,
    LandSurfaceSwFluxDnDirVis,
    LandSurfaceSwFluxDnDirNir,
    LandSurfaceSwFluxDnDifVis,
    LandSurfaceSwFluxDnDifNir,
    LandSurfaceLwFluxDn,
    LandSurfaceGrdflx,
    LandSurfaceFira,
    LandSurfaceSav,
    LandSurfaceSag,
    LandSurfaceAlbedo,
    LandSurfaceSfcrunoff,
    LandSurfaceUdrunoff,
    NoahmpTemperature2mVegetated,
    NoahmpTemperature2mBare,
    NoahmpWaterVaporMixingRatio2mVegetated,
    NoahmpWaterVaporMixingRatio2mBare,
    NoahmpVegetationFraction,
    Temperature2m,
    WaterVaporMixingRatio2m,
    NearSurfaceDiagnosticSource,
    DynamicSoilBase
};

MissingPolicy

enum plotfile2d::MissingPolicy

strong

Enumerator
AlwaysAvailable
FillZeroWhenUnavailable
FillMinus999WhenUnavailable

{
    AlwaysAvailable,
    FillZeroWhenUnavailable,
    FillMinus999WhenUnavailable
};

SampledCoordinate

enum plotfile2d::SampledCoordinate

strong

Enumerator
ModelIndex
HeightMSL
HeightAGL
Pressure

{
    ModelIndex,
    HeightMSL,
    HeightAGL,
    Pressure
};

SampledFieldID

enum plotfile2d::SampledFieldID

strong

Enumerator
Rho
Theta
Temp
Pressure
HeightMSL
HeightAGL
Qv
Qc
Qi
Qr
Qs
Qg
UEast
VNorth
W
WindSpeed
WindDir

{
    Rho,
    Theta,
    Temp,
    Pressure,
    HeightMSL,
    HeightAGL,
    Qv,
    Qc,
    Qi,
    Qr,
    Qs,
    Qg,
    UEast,
    VNorth,
    W,
    WindSpeed,
    WindDir
};

SampledInterpolation

enum plotfile2d::SampledInterpolation

strong

Enumerator
None
Linear

{
    None,
    Linear
};

Function Documentation

active_condensed_water_path_descriptors()

amrex::Vector< WaterPathDescriptor > plotfile2d::active_condensed_water_path_descriptors

(

const SolverChoice &

solver_choice

)

{
    amrex::Vector<WaterPathDescriptor> descriptors;
    descriptors.reserve(MaxCondensedWaterPathComponents);
 
    for (const auto& spec : condensed_specs) {
        const int source_component = source_component_for(spec.id, solver_choice.moisture_indices);
        if (source_component >= 0) {
            descriptors.push_back({spec.id, spec.name, source_component});
        }
    }
 
    return descriptors;
}

active_lsm_contains()

bool plotfile2d::active_lsm_contains	(	const amrex::Vector< std::string > &	active_lsm_names,
		const char *	name
	)

{
    return std::find(active_lsm_names.begin(), active_lsm_names.end(), name) !=
           active_lsm_names.end();
}

Referenced by available_diagnostic_names().

Here is the caller graph for this function:

available_diagnostic_names() [1/3]

amrex::Vector< std::string > plotfile2d::available_diagnostic_names

(

const SolverChoice &

solver_choice

)

{
    return available_diagnostic_names(solver_choice, true);
}

Referenced by ERF::setPlotVariables2D().

Here is the call graph for this function:

Here is the caller graph for this function:

available_diagnostic_names() [2/3]

amrex::Vector< std::string > plotfile2d::available_diagnostic_names	(	const SolverChoice &	solver_choice,
		bool	has_surface_layer
	)

{
    return available_diagnostic_names(solver_choice, has_surface_layer,
                                      amrex::Vector<std::string>{});
}

Here is the call graph for this function:

available_diagnostic_names() [3/3]

amrex::Vector< std::string > plotfile2d::available_diagnostic_names	(	const SolverChoice &	solver_choice,
		bool	has_surface_layer,
		const amrex::Vector< std::string > &	active_lsm_names
	)

{
    amrex::Vector<std::string> names;
    names.reserve(diagnostic_catalog().size());
    const bool has_noahmp = is_noahmp_active(solver_choice);
    const bool has_moisture = solver_choice.moisture_type != MoistureType::None;
 
    for (const auto& descriptor : diagnostic_catalog()) {
        if (is_land_surface_provider_field(descriptor.id) &&
            ((!active_lsm_names.empty() &&
              !active_lsm_contains(active_lsm_names, descriptor.name)) ||
             (active_lsm_names.empty() && !has_noahmp))) {
            continue;
        }
        if (descriptor.id == DiagnosticID::Temperature2m && !(has_noahmp || has_surface_layer)) {
            continue;
        }
        if ((descriptor.id == DiagnosticID::WaterVaporMixingRatio2m ||
             descriptor.id == DiagnosticID::NearSurfaceDiagnosticSource) &&
            !(has_moisture && (has_noahmp || has_surface_layer))) {
            if (descriptor.id == DiagnosticID::NearSurfaceDiagnosticSource &&
                (has_noahmp || has_surface_layer)) {
                names.push_back(descriptor.name);
            }
            continue;
        }
        if (is_condensed_water_path(descriptor.id)) {
            if (source_component_for(descriptor.id, solver_choice.moisture_indices) >= 0) {
                names.push_back(descriptor.name);
            }
            continue;
        }
 
        if (is_precipitation_accumulation(descriptor.id)) {
            if (precipitation_diagnostic_available(descriptor.id, solver_choice.moisture_indices)) {
                names.push_back(descriptor.name);
            }
            continue;
        }
 
        names.push_back(descriptor.name);
    }
 
    if (has_noahmp || !active_lsm_names.empty()) {
        amrex::ParmParse pp("erf");
        int nsoil = 4;
        const auto soil_names = active_lsm_names.empty()
            ? (pp.query("lsm_nsoil", nsoil), dynamic_soil_diagnostic_names(nsoil))
            : dynamic_soil_diagnostic_names(active_lsm_names);
        names.insert(names.end(), soil_names.begin(), soil_names.end());
    }
 
    return names;
}

Referenced by available_diagnostic_names().

Here is the call graph for this function:

Here is the caller graph for this function:

available_sampled_field_names()

amrex::Vector< std::string > plotfile2d::available_sampled_field_names

(

const SolverChoice &

solver_choice

)

{
    amrex::Vector<std::string> names;
    names.reserve(sampled_field_catalog().size());
 
    for (const auto& descriptor : sampled_field_catalog()) {
        if (field_is_available(descriptor.id, solver_choice)) {
            names.push_back(descriptor.name);
        }
    }
 
    return names;
}

Here is the call graph for this function:

build_sampled_level_output_descriptors()

amrex::Vector< Plotfile2DOutputDescriptor > plotfile2d::build_sampled_level_output_descriptors	(	const std::string &	pp_prefix,
		int	which,
		const amrex::Vector< std::string > &	static_plot_vars,
		const SolverChoice &	solver_choice
	)

{
    amrex::Vector<SampledLevelDefinition> level_sets;
    for (const auto& level_set_name : parse_requested_sampled_level_sets(pp_prefix, which)) {
        level_sets.push_back(parse_sampled_level_definition(level_set_name, pp_prefix));
    }
 
    return build_sampled_level_output_descriptors_from_definitions(level_sets,
                                                                   static_plot_vars,
                                                                   solver_choice);
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

build_sampled_level_output_descriptors_from_definitions()

amrex::Vector< Plotfile2DOutputDescriptor > plotfile2d::build_sampled_level_output_descriptors_from_definitions	(	const amrex::Vector< SampledLevelDefinition > &	level_sets,
		const amrex::Vector< std::string > &	static_plot_vars,
		const SolverChoice &	solver_choice
	)

{
    amrex::Vector<Plotfile2DOutputDescriptor> descriptors;
    descriptors.reserve(static_plot_vars.size());
 
    std::unordered_set<std::string> output_names;
 
    for (const auto& name : static_plot_vars) {
        const auto* static_descriptor = find_diagnostic(name);
        if (static_descriptor == nullptr) {
            static_descriptor = find_dynamic_soil_diagnostic(name);
        }
        if (static_descriptor == nullptr) {
            amrex::Abort("Unknown built-in 2D plotfile diagnostic '" + name + "'");
        }
 
        Plotfile2DOutputDescriptor descriptor;
        descriptor.name = static_descriptor->name;
        descriptor.long_name = static_descriptor->long_name;
        descriptor.units = static_descriptor->units;
        descriptor.category = static_descriptor->category;
        descriptor.missing_policy = static_descriptor->missing_policy;
        descriptor.missing_value =
            (descriptor.missing_policy == MissingPolicy::FillZeroWhenUnavailable) ? amrex::Real(0.0)
                                                                                  : amrex::Real(-999.0);
        descriptor.static_diagnostic = static_descriptor;
 
        if (!output_names.insert(descriptor.name).second) {
            amrex::Abort(build_duplicate_output_error(descriptor.name));
        }
 
        descriptors.push_back(std::move(descriptor));
    }
 
    for (const auto& level_set : level_sets) {
        const auto field_selection = select_requested_sampled_fields(level_set.fields, solver_choice);
        if (!field_selection.unavailable.empty()) {
            if (amrex::ParallelDescriptor::IOProcessor()) {
                for (const auto& field_name : field_selection.unavailable) {
                    amrex::Warning(sampled_level_error_prefix(level_set.name, "fields") +
                                   "skipping unavailable field '" + field_name + "'");
                }
            }
        }
 
        if (field_selection.accepted.empty()) {
            amrex::Abort(sampled_level_error_prefix(level_set.name, "fields") +
                         "all requested fields unavailable");
        }
 
        const std::string coordinate_units = level_set.units.empty()
            ? sampled_coordinate_default_units(level_set.coordinate)
            : level_set.units;
        const std::string interpolation_name = sampled_interpolation_to_string(level_set.interpolation);
        const std::string canonical_units =
            (level_set.coordinate == SampledCoordinate::Pressure && coordinate_units == "hPa") ? "Pa"
                                                                                               : coordinate_units;
 
        for (const auto& value : level_set.values) {
            amrex::Real canonical_value = value;
            if (level_set.coordinate == SampledCoordinate::Pressure &&
                coordinate_units == "hPa") {
                canonical_value = value * amrex::Real(100.0);
            }
 
            for (const auto& field : field_selection.accepted) {
                Plotfile2DOutputDescriptor descriptor;
                descriptor.name = sampled_output_name(field.name, level_set.coordinate, value, coordinate_units);
                descriptor.long_name = std::string(field.long_name) + " sampled on " +
                                       sampled_coordinate_to_string(level_set.coordinate) + " levels";
                descriptor.units = field.units;
                descriptor.category = DiagnosticCategory::SampledLevel;
                descriptor.missing_policy = MissingPolicy::FillMinus999WhenUnavailable;
                descriptor.missing_value = level_set.missing_value;
                descriptor.sampled_level = SampledLevelMetadata{
                    level_set.name,
                    field.name,
                    SampledVerticalCoordinateMetadata{
                        sampled_coordinate_to_string(level_set.coordinate),
                        value,
                        coordinate_units,
                        canonical_value,
                        canonical_units,
                        interpolation_name
                    }
                };
 
                if (!output_names.insert(descriptor.name).second) {
                    amrex::Abort(build_duplicate_output_error(descriptor.name));
                }
 
                descriptors.push_back(std::move(descriptor));
            }
        }
    }
 
    return descriptors;
}

Referenced by build_sampled_level_output_descriptors().

Here is the call graph for this function:

Here is the caller graph for this function:

diagnostic_catalog()

const amrex::Vector< DiagnosticDescriptor > & plotfile2d::diagnostic_catalog

(

)

{
    return catalog_storage();
}

Referenced by available_diagnostic_names(), diagnostic_names(), and find_diagnostic().

Here is the caller graph for this function:

diagnostic_category_to_string()

const char * plotfile2d::diagnostic_category_to_string ( DiagnosticCategory  category )

noexcept

{
    switch (category) {
    case DiagnosticCategory::Geometry:        return "Geometry";
    case DiagnosticCategory::SurfaceLayer:     return "SurfaceLayer";
    case DiagnosticCategory::Radiation:        return "Radiation";
    case DiagnosticCategory::SurfaceFlux:      return "SurfaceFlux";
    case DiagnosticCategory::PBL:              return "PBL";
    case DiagnosticCategory::SurfaceState:     return "SurfaceState";
    case DiagnosticCategory::Precipitation:    return "Precipitation";
    case DiagnosticCategory::ColumnIntegral:   return "ColumnIntegral";
    case DiagnosticCategory::LandSurface:      return "LandSurface";
    case DiagnosticCategory::SampledLevel:     return "SampledLevel";
    }
 
    amrex::Abort("Unhandled DiagnosticCategory in 2D metadata writer");
    return "";
}

diagnostic_names()

amrex::Vector< std::string > plotfile2d::diagnostic_names

(

)

{
    amrex::Vector<std::string> names;
    names.reserve(diagnostic_catalog().size());
 
    for (const auto& descriptor : diagnostic_catalog()) {
        names.push_back(descriptor.name);
    }
 
    return names;
}

Here is the call graph for this function:

dynamic_soil_diagnostic_names() [1/2]

amrex::Vector< std::string > plotfile2d::dynamic_soil_diagnostic_names

(

const amrex::Vector< std::string > &

active_lsm_names

)

{
    amrex::Vector<std::string> names;
    for (const auto& name : active_lsm_names) {
        if (is_dynamic_soil_diagnostic_name(name)) {
            ensure_dynamic_soil_descriptor(name);
            names.push_back(name);
        }
    }
    return names;
}

Here is the call graph for this function:

dynamic_soil_diagnostic_names() [2/2]

amrex::Vector< std::string > plotfile2d::dynamic_soil_diagnostic_names

(

int

nsoil

)

{
    amrex::Vector<std::string> names;
    if (nsoil < 1) {
        return names;
    }
    names.reserve(3*nsoil);
    for (const char* group : {"smois", "sh2o", "tslb"}) {
        for (int layer = 1; layer <= nsoil; ++layer) {
            const std::string name = std::string(group) + "_" + std::to_string(layer);
            ensure_dynamic_soil_descriptor(name);
            names.push_back(name);
        }
    }
    return names;
}

Referenced by available_diagnostic_names().

Here is the caller graph for this function:

escape_json_string()

std::string plotfile2d::escape_json_string

(

const std::string &

value

)

{
    std::string escaped;
    escaped.reserve(value.size() + 8);
 
    for (unsigned char c : value) {
        switch (c) {
        case '\"': escaped += "\\\""; break;
        case '\\': escaped += "\\\\"; break;
        case '\n': escaped += "\\n"; break;
        case '\t': escaped += "\\t"; break;
        case '\r': escaped += "\\r"; break;
        default:
            if (c < 0x20) {
                append_escaped_codepoint(escaped, c);
            } else {
                escaped.push_back(static_cast<char>(c));
            }
            break;
        }
    }
 
    return escaped;
}

fill_component_from_klevel() [1/2]

void plotfile2d::fill_component_from_klevel	(	amrex::MultiFab &	dst,
		int	dst_comp,
		const amrex::MultiFab &	src,
		int	src_k,
		int	src_comp = 0
	)

fill_component_from_klevel() [2/2]

void plotfile2d::fill_component_from_klevel	(	MultiFab &	dst,
		int	dst_comp,
		const MultiFab &	src,
		int	src_k,
		int	src_comp
	)

{
    // Iterate over dst because it defines the 2D output component layout. The
    // source must be box-compatible with dst on the horizontal tile covered by
    // each MFIter.
#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& src_arr = src.const_array(mfi);
 
        ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            dst_arr(i, j, k, dst_comp) = src_arr(i, j, src_k, src_comp);
        });
    }
}

Referenced by fill_component_from_klevel_or_value().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_component_from_klevel_or_value() [1/2]

void plotfile2d::fill_component_from_klevel_or_value	(	amrex::MultiFab &	dst,
		int	dst_comp,
		const amrex::MultiFab *	src,
		int	src_k,
		amrex::Real	missing_value,
		int	src_comp = 0
	)

fill_component_from_klevel_or_value() [2/2]

void plotfile2d::fill_component_from_klevel_or_value	(	MultiFab &	dst,
		int	dst_comp,
		const MultiFab *	src,
		int	src_k,
		Real	missing_value,
		int	src_comp
	)

{
    if (src) {
        fill_component_from_klevel(dst, dst_comp, *src, src_k, src_comp);
    } else {
        fill_component_with_value(dst, dst_comp, missing_value);
    }
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_component_with_value() [1/2]

void plotfile2d::fill_component_with_value	(	amrex::MultiFab &	dst,
		int	dst_comp,
		amrex::Real	value
	)

fill_component_with_value() [2/2]

void plotfile2d::fill_component_with_value	(	MultiFab &	dst,
		int	dst_comp,
		Real	value
	)

{
    dst.setVal(value, dst_comp, 1, 0);
}

Referenced by fill_component_from_klevel_or_value(), fill_land_surface_component_from_klevel_or_missing(), fill_latent_heat_flux_from_klevel_or_missing(), fill_sampled_level_component(), and fill_sensible_heat_flux_from_klevel_or_missing().

Here is the caller graph for this function:

fill_condensed_water_paths() [1/2]

void plotfile2d::fill_condensed_water_paths	(	amrex::MultiFab &	dst,
		const amrex::MultiFab &	cons,
		const SelectedWaterPathComponents &	selected,
		const amrex::Geometry &	geom,
		const amrex::MultiFab &	detJ
	)

fill_condensed_water_paths() [2/2]

void plotfile2d::fill_condensed_water_paths	(	MultiFab &	dst,
		const MultiFab &	cons,
		const SelectedWaterPathComponents &	selected,
		const Geometry &	geom,
		const MultiFab &	detJ
	)

{
    if (selected.n == 0) {
        return;
    }
 
    // Validate selected components on the host before device kernels use them.
    AMREX_ALWAYS_ASSERT(selected.n >= 0);
    AMREX_ALWAYS_ASSERT(selected.n <= MaxCondensedWaterPathComponents);
    for (int n = 0; n < selected.n; ++n) {
        AMREX_ALWAYS_ASSERT(selected.dst_comp[n] >= 0);
        AMREX_ALWAYS_ASSERT(selected.dst_comp[n] < dst.nComp());
        AMREX_ALWAYS_ASSERT(selected.src_comp[n] >= 0);
        AMREX_ALWAYS_ASSERT(selected.src_comp[n] < cons.nComp());
    }
 
    for (int n = 0; n < selected.n; ++n) {
        dst.setVal(0., selected.dst_comp[n], 1, 0);
    }
 
    const auto& dx = geom.CellSizeArray();
 
#ifdef _OPENMP
#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
#endif
    for (MFIter mfi(cons, TilingIfNotGPU()); mfi.isValid(); ++mfi)
    {
        const Box& bx = mfi.tilebox();
        const auto dst_arr = dst.array(mfi);
        const auto src_arr = cons.const_array(mfi);
 
        if (SolverChoice::mesh_type == MeshType::ConstantDz) {
            ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
                for (int n = 0; n < selected.n; ++n) {
                    amrex::HostDevice::Atomic::Add(
                        &dst_arr(i, j, 0, selected.dst_comp[n]),
                        src_arr(i, j, k, selected.src_comp[n]));
                }
            });
        } else {
            const auto& detJ_arr = detJ.const_array(mfi);
            ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
                const amrex::Real metric = detJ_arr(i, j, k);
                for (int n = 0; n < selected.n; ++n) {
                    amrex::HostDevice::Atomic::Add(
                        &dst_arr(i, j, 0, selected.dst_comp[n]),
                        src_arr(i, j, k, selected.src_comp[n]) * metric);
                }
            });
        }
    }
 
    for (int n = 0; n < selected.n; ++n) {
        dst.mult(dx[2], selected.dst_comp[n], 1, 0);
    }
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_land_surface_component_from_klevel_or_missing() [1/2]

void plotfile2d::fill_land_surface_component_from_klevel_or_missing	(	amrex::MultiFab &	dst,
		int	dst_comp,
		const amrex::MultiFab *	src,
		int	src_k,
		amrex::Real	missing_value
	)

fill_land_surface_component_from_klevel_or_missing() [2/2]

void plotfile2d::fill_land_surface_component_from_klevel_or_missing	(	MultiFab &	dst,
		int	dst_comp,
		const MultiFab *	src,
		int	src_k,
		Real	missing_value
	)

{
    if (!src) {
        fill_component_with_value(dst, dst_comp, missing_value);
        return;
    }
 
#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& src_arr = src->const_array(mfi);
        ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            const Real value = src_arr(i, j, src_k, 0);
            dst_arr(i, j, k, dst_comp) = is_valid_land_surface_value(value)
                ? value : missing_value;
        });
    }
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_latent_heat_flux_from_klevel_or_missing() [1/2]

void plotfile2d::fill_latent_heat_flux_from_klevel_or_missing	(	amrex::MultiFab &	dst,
		int	dst_comp,
		const amrex::MultiFab *	src,
		int	src_k,
		amrex::Real	missing_value
	)

fill_latent_heat_flux_from_klevel_or_missing() [2/2]

void plotfile2d::fill_latent_heat_flux_from_klevel_or_missing	(	MultiFab &	dst,
		int	dst_comp,
		const MultiFab *	src,
		int	src_k,
		Real	missing_value
	)

{
    if (!src) {
        fill_component_with_value(dst, dst_comp, missing_value);
        return;
    }
 
#ifdef _OPENMP
#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
#endif
    for (MFIter mfi(dst, TilingIfNotGPU()); mfi.isValid(); ++mfi)
    {
        // Keep unit conversion in the surface-flux diagnostic helper so this
        // mechanical layer does not duplicate physical constants or units.
        const Box& bx = mfi.tilebox();
        const auto& dst_arr = dst.array(mfi);
        const auto& src_arr = src->const_array(mfi);
 
        ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            dst_arr(i, j, k, dst_comp) =
                surface_flux_diagnostics::latent_heat_flux_wm2_from_rhoqv_flux(
                    src_arr(i, j, src_k, 0));
        });
    }
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_precipitation_accumulations() [1/2]

void plotfile2d::fill_precipitation_accumulations	(	amrex::MultiFab &	dst,
		const SurfacePrecipAccumulationSources &	sources,
		const SelectedSurfacePrecipAccumulationComponents &	selected,
		const int	klo
	)

fill_precipitation_accumulations() [2/2]

void plotfile2d::fill_precipitation_accumulations	(	MultiFab &	dst,
		const SurfacePrecipAccumulationSources &	sources,
		const SelectedSurfacePrecipAccumulationComponents &	selected,
		const int	klo
	)

{
    if (selected.n == 0) {
        return;
    }
 
    AMREX_ALWAYS_ASSERT(selected.n >= 0);
    AMREX_ALWAYS_ASSERT(selected.n <= MaxSurfacePrecipAccumulationComponents);
 
    for (int n = 0; n < selected.n; ++n) {
        AMREX_ALWAYS_ASSERT(selected.dst_comp[n] >= 0);
        AMREX_ALWAYS_ASSERT(selected.dst_comp[n] < dst.nComp());
        dst.setVal(0.0, selected.dst_comp[n], 1, 0);
    }
 
    if (!surface_precip_has_any_source(sources)) {
        return;
    }
 
    // Normalize scheme-native precipitation accumulators to kg/m^2 at the
    // output boundary, then build the derived total and frozen fields from the
    // normalized species values.
    const SurfacePrecipAccumulationSource* anchor = first_available_source(sources);
    AMREX_ALWAYS_ASSERT(anchor != nullptr);
    const MultiFab& anchor_mf = *anchor->accum;
    const bool has_total_source = surface_precip_has_source(sources.total);
    const bool has_rain_source = surface_precip_has_source(sources.rain);
    const bool has_snow_source = surface_precip_has_source(sources.snow);
    const bool has_graupel_source = surface_precip_has_source(sources.graupel);
    const bool has_hail_source = surface_precip_has_source(sources.hail);
    const amrex::Real total_factor = sources.total.native_to_kg_m2;
    const amrex::Real rain_factor = sources.rain.native_to_kg_m2;
    const amrex::Real snow_factor = sources.snow.native_to_kg_m2;
    const amrex::Real graupel_factor = sources.graupel.native_to_kg_m2;
    const amrex::Real hail_factor = sources.hail.native_to_kg_m2;
 
    for (MFIter mfi(anchor_mf, TilingIfNotGPU()); mfi.isValid(); ++mfi)
    {
        const Box& bx = mfi.tilebox();
        const auto dst_arr = dst.array(mfi);
        const auto total_arr = has_total_source ? sources.total.accum->const_array(mfi) : Array4<const Real>{};
        const auto rain_arr = has_rain_source ? sources.rain.accum->const_array(mfi) : Array4<const Real>{};
        const auto snow_arr = has_snow_source ? sources.snow.accum->const_array(mfi) : Array4<const Real>{};
        const auto graupel_arr = has_graupel_source ? sources.graupel.accum->const_array(mfi) : Array4<const Real>{};
        const auto hail_arr = has_hail_source ? sources.hail.accum->const_array(mfi) : Array4<const Real>{};
 
        ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept
        {
            if (k != klo) {
                return;
            }
 
            const amrex::Real total_source =
                has_total_source ? total_arr(i, j, k, 0) * total_factor : amrex::Real(0.0);
            const amrex::Real rain_source =
                has_rain_source ? rain_arr(i, j, k, 0) * rain_factor : amrex::Real(0.0);
            const amrex::Real snow =
                has_snow_source ? snow_arr(i, j, k, 0) * snow_factor : amrex::Real(0.0);
            const amrex::Real graupel =
                has_graupel_source ? graupel_arr(i, j, k, 0) * graupel_factor : amrex::Real(0.0);
            const amrex::Real hail =
                has_hail_source ? hail_arr(i, j, k, 0) * hail_factor : amrex::Real(0.0);
            const amrex::Real frozen = snow + graupel + hail;
            const amrex::Real total = has_total_source ? total_source : rain_source + frozen;
            // Total-plus-frozen-subset schemes derive rain as total - frozen.
            // Clamp to zero to avoid negative output from roundoff or small
            // scheme inconsistencies.
            const amrex::Real rain = has_rain_source ? rain_source
                                                     : amrex::max(amrex::Real(0.0), total - frozen);
 
            for (int n = 0; n < selected.n; ++n) {
                switch (selected.id[n]) {
                case DiagnosticID::PrecipTotalAccum:
                    dst_arr(i, j, 0, selected.dst_comp[n]) = total;
                    break;
                case DiagnosticID::PrecipRainAccum:
                    dst_arr(i, j, 0, selected.dst_comp[n]) = rain;
                    break;
                case DiagnosticID::PrecipSnowAccum:
                    dst_arr(i, j, 0, selected.dst_comp[n]) = snow;
                    break;
                case DiagnosticID::PrecipGraupelAccum:
                    dst_arr(i, j, 0, selected.dst_comp[n]) = graupel;
                    break;
                case DiagnosticID::PrecipHailAccum:
                    dst_arr(i, j, 0, selected.dst_comp[n]) = hail;
                    break;
                case DiagnosticID::PrecipFrozenAccum:
                    dst_arr(i, j, 0, selected.dst_comp[n]) = frozen;
                    break;
                default:
                    break;
                }
            }
        });
    }
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_sampled_level_component() [1/2]

void plotfile2d::fill_sampled_level_component	(	amrex::MultiFab &	dst,
		int	dst_comp,
		const Plotfile2DOutputDescriptor &	descriptor,
		const amrex::MultiFab &	cons,
		const amrex::MultiFab *	z_phys_cc,
		const amrex::MultiFab &	z_phys_nd,
		bool	have_z_phys_cc,
		const MoistureComponentIndices &	moisture_indices,
		int	klo,
		int	khi,
		const SampledWindSources &	wind_sources = {}
	)

fill_sampled_level_component() [2/2]

void plotfile2d::fill_sampled_level_component	(	MultiFab &	dst,
		int	dst_comp,
		const Plotfile2DOutputDescriptor &	descriptor,
		const MultiFab &	cons,
		const MultiFab *	z_phys_cc,
		const MultiFab &	z_phys_nd,
		bool	have_z_phys_cc,
		const MoistureComponentIndices &	moisture_indices,
		int	klo,
		int	khi,
		const SampledWindSources &	wind_sources
	)

{
    const auto* sampled = descriptor.sampled_level ? &*descriptor.sampled_level : nullptr;
    if (sampled == nullptr) {
        fill_component_with_value(dst, dst_comp, descriptor.missing_value);
        return;
    }
 
    const auto* field_descriptor = find_sampled_field(sampled->source_field);
    if (field_descriptor == nullptr) {
        Abort("Unknown sampled-level source field '" + sampled->source_field + "'");
    }
 
    const auto coordinate = sampled_coordinate_from_string(sampled->vertical_coordinate.type);
    const auto field_id = field_descriptor->id;
    const Real target = sampled->vertical_coordinate.canonical_value;
    const int target_k = static_cast<int>(std::nearbyint(target));
    const Real missing_value = descriptor.missing_value;
    const bool is_wind_field = sampled_field_is_wind(field_id);
    const bool have_rotation = (wind_sources.cos_alpha != nullptr) || (wind_sources.sin_alpha != nullptr);
 
    if (is_wind_field) {
        if (wind_sources.xvel == nullptr || wind_sources.yvel == nullptr || wind_sources.zvel == nullptr) {
            Abort("Sampled-level wind field '" + sampled->source_field + "' requires xvel, yvel, and zvel sources");
        }
        if ((wind_sources.cos_alpha == nullptr) != (wind_sources.sin_alpha == nullptr)) {
            Abort("Sampled-level wind field '" + sampled->source_field + "' requires both cos_alpha and sin_alpha when rotation is supplied");
        }
    }
 
#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& cons_arr = cons.const_array(mfi);
        const auto& z_phys_nd_arr = z_phys_nd.const_array(mfi);
        const auto& z_phys_cc_arr = have_z_phys_cc && z_phys_cc != nullptr
            ? z_phys_cc->const_array(mfi)
            : cons.const_array(mfi);
        const auto& xvel_arr = is_wind_field ? wind_sources.xvel->const_array(mfi) : cons.const_array(mfi);
        const auto& yvel_arr = is_wind_field ? wind_sources.yvel->const_array(mfi) : cons.const_array(mfi);
        const auto& zvel_arr = is_wind_field ? wind_sources.zvel->const_array(mfi) : cons.const_array(mfi);
        const auto& cos_alpha_arr = have_rotation ? wind_sources.cos_alpha->const_array(mfi) : cons.const_array(mfi);
        const auto& sin_alpha_arr = have_rotation ? wind_sources.sin_alpha->const_array(mfi) : cons.const_array(mfi);
 
        ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            if (coordinate == SampledCoordinate::ModelIndex) {
                if (target_k < klo || target_k > khi) {
                    dst_arr(i, j, k, dst_comp) = missing_value;
                    return;
                }
 
                if (is_wind_field) {
                    const SampledEarthWind wind = earth_wind_at_cell_center(
                        i, j, target_k, xvel_arr, yvel_arr, zvel_arr, cos_alpha_arr, sin_alpha_arr,
                        have_rotation);
                    dst_arr(i, j, k, dst_comp) = wind_field_from_earth_wind(field_id, wind, missing_value);
                } else {
                    dst_arr(i, j, k, dst_comp) =
                        sampled_field_value(field_id, cons_arr, z_phys_cc_arr, z_phys_nd_arr,
                                            have_z_phys_cc, i, j, target_k, moisture_indices);
                }
                return;
            }
 
            const auto bracket = find_sampled_bracket(coordinate, target, klo, khi, i, j,
                                                      cons_arr, z_phys_cc_arr, z_phys_nd_arr,
                                                      have_z_phys_cc, moisture_indices);
            if (!bracket.found) {
                dst_arr(i, j, k, dst_comp) = missing_value;
                return;
            }
 
            const Real coord_lo =
                sampled_field_value((coordinate == SampledCoordinate::HeightMSL)
                                        ? SampledFieldID::HeightMSL
                                        : (coordinate == SampledCoordinate::HeightAGL)
                                            ? SampledFieldID::HeightAGL
                                            : SampledFieldID::Pressure,
                                    cons_arr, z_phys_cc_arr, z_phys_nd_arr,
                                    have_z_phys_cc, i, j, bracket.klo, moisture_indices);
            const Real coord_hi =
                sampled_field_value((coordinate == SampledCoordinate::HeightMSL)
                                        ? SampledFieldID::HeightMSL
                                        : (coordinate == SampledCoordinate::HeightAGL)
                                            ? SampledFieldID::HeightAGL
                                            : SampledFieldID::Pressure,
                                    cons_arr, z_phys_cc_arr, z_phys_nd_arr,
                                    have_z_phys_cc, i, j, bracket.khi, moisture_indices);
            if (is_wind_field) {
                const SampledEarthWind wind_lo = earth_wind_at_cell_center(
                    i, j, bracket.klo, xvel_arr, yvel_arr, zvel_arr, cos_alpha_arr, sin_alpha_arr,
                    have_rotation);
                if (bracket.klo == bracket.khi) {
                    dst_arr(i, j, k, dst_comp) = wind_field_from_earth_wind(field_id, wind_lo, missing_value);
                    return;
                }
 
                const SampledEarthWind wind_hi = earth_wind_at_cell_center(
                    i, j, bracket.khi, xvel_arr, yvel_arr, zvel_arr, cos_alpha_arr, sin_alpha_arr,
                    have_rotation);
                SampledEarthWind wind_interp;
                wind_interp.u_east = linear_interpolate(wind_lo.u_east, wind_hi.u_east, coord_lo, coord_hi, target);
                wind_interp.v_north = linear_interpolate(wind_lo.v_north, wind_hi.v_north, coord_lo, coord_hi, target);
                wind_interp.w = linear_interpolate(wind_lo.w, wind_hi.w, coord_lo, coord_hi, target);
                dst_arr(i, j, k, dst_comp) = wind_field_from_earth_wind(field_id, wind_interp, missing_value);
            } else {
                const Real field_lo =
                    sampled_field_value(field_id, cons_arr, z_phys_cc_arr, z_phys_nd_arr,
                                        have_z_phys_cc, i, j, bracket.klo, moisture_indices);
                if (bracket.klo == bracket.khi) {
                    dst_arr(i, j, k, dst_comp) = field_lo;
                    return;
                }
 
                const Real field_hi =
                    sampled_field_value(field_id, cons_arr, z_phys_cc_arr, z_phys_nd_arr,
                                        have_z_phys_cc, i, j, bracket.khi, moisture_indices);
                dst_arr(i, j, k, dst_comp) =
                    linear_interpolate(field_lo, field_hi, coord_lo, coord_hi, target);
            }
        });
    }
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

fill_sensible_heat_flux_from_klevel_or_missing() [1/2]

void plotfile2d::fill_sensible_heat_flux_from_klevel_or_missing	(	amrex::MultiFab &	dst,
		int	dst_comp,
		const amrex::MultiFab *	src,
		int	src_k,
		amrex::Real	missing_value
	)

fill_sensible_heat_flux_from_klevel_or_missing() [2/2]

void plotfile2d::fill_sensible_heat_flux_from_klevel_or_missing	(	MultiFab &	dst,
		int	dst_comp,
		const MultiFab *	src,
		int	src_k,
		Real	missing_value
	)

{
    if (!src) {
        fill_component_with_value(dst, dst_comp, missing_value);
        return;
    }
 
#ifdef _OPENMP
#pragma omp parallel if (amrex::Gpu::notInLaunchRegion())
#endif
    for (MFIter mfi(dst, TilingIfNotGPU()); mfi.isValid(); ++mfi)
    {
        // Keep unit conversion in the surface-flux diagnostic helper so this
        // mechanical layer does not duplicate physical constants or units.
        const Box& bx = mfi.tilebox();
        const auto& dst_arr = dst.array(mfi);
        const auto& src_arr = src->const_array(mfi);
 
        ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) noexcept {
            dst_arr(i, j, k, dst_comp) =
                surface_flux_diagnostics::sensible_heat_flux_wm2_from_rhotheta_flux(
                    src_arr(i, j, src_k, 0));
        });
    }
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

find_diagnostic()

const DiagnosticDescriptor * plotfile2d::find_diagnostic

(

const std::string &

name

)

{
    for (const auto& descriptor : diagnostic_catalog()) {
        if (name == descriptor.name) {
            return &descriptor;
        }
    }
 
    return nullptr;
}

Referenced by build_sampled_level_output_descriptors_from_definitions(), format_2d_metadata_json(), is_condensed_water_path_name(), is_precipitation_accumulation_name(), selected_condensed_water_path_components(), selected_precipitation_accumulation_components(), and ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

find_dynamic_soil_diagnostic()

const DiagnosticDescriptor * plotfile2d::find_dynamic_soil_diagnostic

(

const std::string &

name

)

{
    if (!is_dynamic_soil_diagnostic_name(name)) {
        return nullptr;
    }
    return ensure_dynamic_soil_descriptor(name);
}

Referenced by build_sampled_level_output_descriptors_from_definitions(), format_2d_metadata_json(), and ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

find_sampled_field()

const SampledFieldDescriptor * plotfile2d::find_sampled_field

(

const std::string &

name

)

{
    for (const auto& descriptor : sampled_field_catalog()) {
        if (name == descriptor.name) {
            return &descriptor;
        }
    }
 
    return nullptr;
}

Referenced by fill_sampled_level_component(), and select_requested_sampled_fields().

Here is the call graph for this function:

Here is the caller graph for this function:

format_2d_component_count_error()

std::string plotfile2d::format_2d_component_count_error	(	int	lev,
		int	filled,
		int	expected
	)

{
    std::ostringstream os;
    os << "Write2DPlotFile internal error at level " << lev
       << ": filled " << filled
       << " components but expected " << expected
       << ". The 2D plot variable list and fill blocks are inconsistent.";
    return os.str();
}

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

format_2d_metadata_json() [1/2]

std::string plotfile2d::format_2d_metadata_json

(

const amrex::Vector< Plotfile2DOutputDescriptor > &

descriptors

)

{
    // Native AMReX 2D plotfiles get a metadata sidecar for the selected
    // output variables only. The writer formats catalog metadata and sampled-
    // level metadata; it does not compute diagnostics or encode runtime
    // source selection.
    std::ostringstream os;
    os << "{\n";
    os << "  \"format_version\": 2,\n";
    os << "  \"kind\": \"ERF 2D plotfile metadata\",\n";
    os << "  \"n_variables\": " << static_cast<int>(descriptors.size()) << ",\n";
    os << "  \"variables\": [\n";
 
    for (int i = 0; i < static_cast<int>(descriptors.size()); ++i) {
        append_variable_record(os, descriptors[i], i, i == static_cast<int>(descriptors.size()) - 1);
    }
 
    os << "  ]\n";
    os << "}\n";
    return os.str();
}

format_2d_metadata_json() [2/2]

std::string plotfile2d::format_2d_metadata_json

(

const amrex::Vector< std::string > &

varnames

)

{
    amrex::Vector<Plotfile2DOutputDescriptor> descriptors;
    descriptors.reserve(varnames.size());
 
    for (const auto& name : varnames) {
        const auto* static_descriptor = find_diagnostic(name);
        if (static_descriptor == nullptr) {
            static_descriptor = find_dynamic_soil_diagnostic(name);
        }
        if (static_descriptor == nullptr) {
            amrex::Abort("2D metadata requested for unknown diagnostic '" + name + "'");
        }
 
        Plotfile2DOutputDescriptor descriptor;
        descriptor.name = static_descriptor->name;
        descriptor.long_name = static_descriptor->long_name;
        descriptor.units = static_descriptor->units;
        descriptor.category = static_descriptor->category;
        descriptor.missing_policy = static_descriptor->missing_policy;
        descriptor.missing_value =
            (descriptor.missing_policy == MissingPolicy::FillZeroWhenUnavailable) ? amrex::Real(0.0)
                                                                                  : amrex::Real(-999.0);
        descriptor.static_diagnostic = static_descriptor;
        descriptors.push_back(std::move(descriptor));
    }
 
    return format_2d_metadata_json(descriptors);
}

Referenced by write_2d_metadata_json().

Here is the call graph for this function:

Here is the caller graph for this function:

format_invalid_2d_stream_error()

std::string plotfile2d::format_invalid_2d_stream_error

(

int

which

)

{
    std::ostringstream os;
    os << "Write2DPlotFile received invalid stream index " << which
       << "; expected 1 or 2.";
    return os.str();
}

format_plot2d_parameter_name()

std::string plotfile2d::format_plot2d_parameter_name	(	const std::string &	pp_prefix,
		const std::string &	parameter_name
	)

{
    if (pp_prefix.empty()) {
        return parameter_name;
    }
 
    return pp_prefix + "." + parameter_name;
}

Referenced by ERF::setPlotVariables2D().

Here is the caller graph for this function:

format_unavailable_2d_plot_var_warning()

std::string plotfile2d::format_unavailable_2d_plot_var_warning	(	const std::string &	parameter_name,
		const std::string &	unavailable_name,
		const amrex::Vector< std::string > &	available_names
	)

{
    std::ostringstream os;
    os << "WARNING: Requested 2D plot variable '" << unavailable_name
       << "' from '" << parameter_name
       << "' is not available and will be skipped. Available built-in 2D plot variables are: "
       << join_names(available_names) << ".";
    return os.str();
}

is_condensed_water_path()

bool plotfile2d::is_condensed_water_path ( DiagnosticID  id )

noexcept

{
    switch (id) {
    case DiagnosticID::IntegratedQc:
    case DiagnosticID::IntegratedQi:
    case DiagnosticID::IntegratedQr:
    case DiagnosticID::IntegratedQs:
    case DiagnosticID::IntegratedQg:
        return true;
    default:
        return false;
    }
}

Referenced by available_diagnostic_names(), is_condensed_water_path_name(), and selected_condensed_water_path_components().

Here is the caller graph for this function:

is_condensed_water_path_name()

bool plotfile2d::is_condensed_water_path_name

(

const std::string &

name

)

{
    const auto* descriptor = find_diagnostic(name);
    return descriptor && is_condensed_water_path(descriptor->id);
}

Here is the call graph for this function:

is_dynamic_soil_diagnostic_name()

bool plotfile2d::is_dynamic_soil_diagnostic_name

(

const std::string &

name

)

{
    const auto underscore = name.find('_');
    if (underscore == std::string::npos) {
        return false;
    }
    const std::string group = name.substr(0, underscore);
    if (group != "smois" && group != "sh2o" && group != "tslb") {
        return false;
    }
    try {
        std::size_t parsed = 0;
        const int layer = std::stoi(name.substr(underscore + 1), &parsed);
        return parsed == name.size() - underscore - 1 && layer > 0;
    } catch (...) {
        return false;
    }
}

Referenced by dynamic_soil_diagnostic_names(), and find_dynamic_soil_diagnostic().

Here is the caller graph for this function:

is_land_surface_provider_field()

bool plotfile2d::is_land_surface_provider_field ( DiagnosticID  id )

noexcept

{
    switch (id) {
    case DiagnosticID::LandSurfaceTsfC:
    case DiagnosticID::LandSurfaceEmissivity:
    case DiagnosticID::LandSurfaceAlbDirVis:
    case DiagnosticID::LandSurfaceAlbDirNir:
    case DiagnosticID::LandSurfaceAlbDifVis:
    case DiagnosticID::LandSurfaceAlbDifNir:
    case DiagnosticID::LandSurfaceCosZenith:
    case DiagnosticID::LandSurfaceSwFluxDn:
    case DiagnosticID::LandSurfaceSwFluxDnDirVis:
    case DiagnosticID::LandSurfaceSwFluxDnDirNir:
    case DiagnosticID::LandSurfaceSwFluxDnDifVis:
    case DiagnosticID::LandSurfaceSwFluxDnDifNir:
    case DiagnosticID::LandSurfaceLwFluxDn:
    case DiagnosticID::LandSurfaceGrdflx:
    case DiagnosticID::LandSurfaceFira:
    case DiagnosticID::LandSurfaceSav:
    case DiagnosticID::LandSurfaceSag:
    case DiagnosticID::LandSurfaceAlbedo:
    case DiagnosticID::LandSurfaceSfcrunoff:
    case DiagnosticID::LandSurfaceUdrunoff:
    case DiagnosticID::NoahmpTemperature2mVegetated:
    case DiagnosticID::NoahmpTemperature2mBare:
    case DiagnosticID::NoahmpWaterVaporMixingRatio2mVegetated:
    case DiagnosticID::NoahmpWaterVaporMixingRatio2mBare:
    case DiagnosticID::NoahmpVegetationFraction:
        return true;
    default:
        return false;
    }
}

Referenced by available_diagnostic_names().

Here is the caller graph for this function:

is_noahmp_active()

bool plotfile2d::is_noahmp_active ( const SolverChoice &  solver_choice )

noexcept

{
#ifdef ERF_USE_NOAHMP
    return solver_choice.lsm_type == LandSurfaceType::NOAHMP;
#else
    amrex::ignore_unused(solver_choice);
    return false;
#endif
}

Referenced by available_diagnostic_names().

Here is the caller graph for this function:

is_precipitation_accumulation()

bool plotfile2d::is_precipitation_accumulation ( DiagnosticID  id )

noexcept

{
    switch (id) {
    case DiagnosticID::PrecipTotalAccum:
    case DiagnosticID::PrecipRainAccum:
    case DiagnosticID::PrecipSnowAccum:
    case DiagnosticID::PrecipGraupelAccum:
    case DiagnosticID::PrecipHailAccum:
    case DiagnosticID::PrecipFrozenAccum:
        return true;
    default:
        return false;
    }
}

Referenced by available_diagnostic_names(), is_precipitation_accumulation_name(), and selected_precipitation_accumulation_components().

Here is the caller graph for this function:

is_precipitation_accumulation_name()

bool plotfile2d::is_precipitation_accumulation_name

(

const std::string &

name

)

{
    const auto* descriptor = find_diagnostic(name);
    return descriptor && is_precipitation_accumulation(descriptor->id);
}

Here is the call graph for this function:

linear_interpolate()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE amrex::Real plotfile2d::linear_interpolate ( amrex::Real  lo_value, amrex::Real  hi_value, amrex::Real  lo_coord, amrex::Real  hi_coord, amrex::Real  target  )

noexcept

{
    if (hi_coord == lo_coord) {
        return lo_value;
    }
 
    const amrex::Real weight = (target - lo_coord) / (hi_coord - lo_coord);
    return lo_value + weight * (hi_value - lo_value);
}

Referenced by fill_sampled_level_component().

Here is the caller graph for this function:

metadata_json_filename()

std::string plotfile2d::metadata_json_filename

(

const std::string &

plotfilename

)

{
    return plotfilename + "/2DMetadata.json";
}

Referenced by write_2d_metadata_json().

Here is the caller graph for this function:

missing_policy_to_string()

const char * plotfile2d::missing_policy_to_string ( MissingPolicy  policy )

noexcept

{
    switch (policy) {
    case MissingPolicy::AlwaysAvailable:            return "AlwaysAvailable";
    case MissingPolicy::FillZeroWhenUnavailable:     return "FillZeroWhenUnavailable";
    case MissingPolicy::FillMinus999WhenUnavailable: return "FillMinus999WhenUnavailable";
    }
 
    amrex::Abort("Unhandled MissingPolicy in 2D metadata writer");
    return "";
}

missing_value_json()

std::string plotfile2d::missing_value_json

(

MissingPolicy

policy

)

{
    switch (policy) {
    case MissingPolicy::AlwaysAvailable:            return "null";
    case MissingPolicy::FillZeroWhenUnavailable:     return "0";
    case MissingPolicy::FillMinus999WhenUnavailable: return "-999";
    }
 
    amrex::Abort("Unhandled MissingPolicy in 2D metadata writer");
    return {};
}

parse_requested_sampled_level_sets()

amrex::Vector< std::string > plotfile2d::parse_requested_sampled_level_sets	(	const std::string &	pp_prefix,
		int	which
	)

{
    amrex::Vector<std::string> names;
    amrex::ParmParse pp(pp_prefix);
 
    const std::string param_name = "plot2d_level_sets_" + std::to_string(which);
    if (!pp.contains(param_name.c_str())) {
        return names;
    }
 
    const int n_sets = pp.countval(param_name.c_str());
    names.resize(n_sets);
    pp.getarr(param_name.c_str(), names, 0, n_sets);
    return names;
}

Referenced by build_sampled_level_output_descriptors().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_sampled_level_definition()

SampledLevelDefinition plotfile2d::parse_sampled_level_definition	(	const std::string &	level_set_name,
		const std::string &	pp_prefix
	)

{
    SampledLevelDefinition level_set;
    level_set.name = level_set_name;
 
    amrex::ParmParse pp(pp_prefix);
    const std::string base = "plot2d.level_set." + level_set_name + ".";
 
    std::string coordinate_value;
    if (!pp.query((base + "coordinate").c_str(), coordinate_value)) {
        amrex::Abort(build_missing_field_error(level_set_name, "coordinate"));
    }
    const std::string coordinate_error =
        validate_sampled_coordinate_string(level_set_name, coordinate_value);
    if (!coordinate_error.empty()) {
        amrex::Abort(coordinate_error);
    }
    level_set.coordinate = sampled_coordinate_from_string(coordinate_value);
 
    if (pp.query((base + "units").c_str(), level_set.units) == 0) {
        level_set.units = sampled_coordinate_default_units(level_set.coordinate);
    }
 
    std::string interpolation_value;
    if (pp.query((base + "interpolation").c_str(), interpolation_value) == 0) {
        level_set.interpolation =
            sampled_interpolation_from_string(sampled_coordinate_default_interpolation(level_set.coordinate));
    } else {
        level_set.interpolation = sampled_interpolation_from_string(interpolation_value);
    }
 
    if (pp.query((base + "missing_value").c_str(), level_set.missing_value) == 0) {
        level_set.missing_value = amrex::Real(-999.0);
    }
 
    int n_values = pp.countval((base + "values").c_str());
    if (n_values <= 0) {
        amrex::Abort(build_missing_field_error(level_set_name, "values"));
    }
    level_set.values.resize(n_values);
    pp.getarr((base + "values").c_str(), level_set.values, 0, n_values);
 
    int n_fields = pp.countval((base + "fields").c_str());
    if (n_fields <= 0) {
        amrex::Abort(build_missing_field_error(level_set_name, "fields"));
    }
    level_set.fields.resize(n_fields);
    pp.getarr((base + "fields").c_str(), level_set.fields, 0, n_fields);
 
    const std::string error = validate_sampled_level_definition(level_set);
    if (!error.empty()) {
        amrex::Abort(error);
    }
 
    return level_set;
}

Referenced by build_sampled_level_output_descriptors().

Here is the call graph for this function:

Here is the caller graph for this function:

precipitation_diagnostic_available()

bool plotfile2d::precipitation_diagnostic_available ( DiagnosticID  id, const MoistureComponentIndices &  moisture_indices  )

noexcept

{
    const bool has_any_precip = has_any_precip_component(moisture_indices);
 
    switch (id) {
    case DiagnosticID::PrecipTotalAccum:
    case DiagnosticID::PrecipFrozenAccum:
        return has_any_precip;
    case DiagnosticID::PrecipRainAccum:
        return has_rain_component(moisture_indices);
    case DiagnosticID::PrecipSnowAccum:
        return has_snow_component(moisture_indices);
    case DiagnosticID::PrecipGraupelAccum:
        return has_graupel_component(moisture_indices);
    case DiagnosticID::PrecipHailAccum:
        return false;
    default:
        return false;
    }
}

Referenced by available_diagnostic_names().

Here is the caller graph for this function:

sampled_coordinate_default_interpolation()

const char * plotfile2d::sampled_coordinate_default_interpolation ( SampledCoordinate  coordinate )

noexcept

{
    return coordinate_interpolation_default(coordinate);
}

Referenced by parse_sampled_level_definition(), and validate_sampled_level_definition().

Here is the caller graph for this function:

sampled_coordinate_default_units()

const char * plotfile2d::sampled_coordinate_default_units ( SampledCoordinate  coordinate )

noexcept

{
    return coordinate_units_default(coordinate);
}

Referenced by build_sampled_level_output_descriptors_from_definitions(), parse_sampled_level_definition(), and validate_sampled_level_definition().

Here is the caller graph for this function:

sampled_coordinate_from_string()

SampledCoordinate plotfile2d::sampled_coordinate_from_string

(

const std::string &

value

)

{
    if (string_iequals(value, "model_index")) {
        return SampledCoordinate::ModelIndex;
    }
    if (string_iequals(value, "height_msl")) {
        return SampledCoordinate::HeightMSL;
    }
    if (string_iequals(value, "height_agl")) {
        return SampledCoordinate::HeightAGL;
    }
    if (string_iequals(value, "pressure")) {
        return SampledCoordinate::Pressure;
    }
 
    amrex::Abort("Unknown sampled-level coordinate '" + value + "'");
    return SampledCoordinate::ModelIndex;
}

Referenced by fill_sampled_level_component(), and parse_sampled_level_definition().

Here is the caller graph for this function:

sampled_coordinate_tag()

const char * plotfile2d::sampled_coordinate_tag ( SampledCoordinate  coordinate )

noexcept

{
    switch (coordinate) {
    case SampledCoordinate::ModelIndex: return "k";
    case SampledCoordinate::HeightMSL:   return "z_msl";
    case SampledCoordinate::HeightAGL:   return "z_agl";
    case SampledCoordinate::Pressure:    return "p";
    }
    return "unknown";
}

Referenced by sampled_output_name().

Here is the caller graph for this function:

sampled_coordinate_to_string()

const char * plotfile2d::sampled_coordinate_to_string ( SampledCoordinate  coordinate )

noexcept

{
    switch (coordinate) {
    case SampledCoordinate::ModelIndex: return "model_index";
    case SampledCoordinate::HeightMSL:   return "height_msl";
    case SampledCoordinate::HeightAGL:   return "height_agl";
    case SampledCoordinate::Pressure:    return "pressure";
    }
    return "unknown";
}

Referenced by build_sampled_level_output_descriptors_from_definitions(), and validate_sampled_level_definition().

Here is the caller graph for this function:

sampled_field_catalog()

const amrex::Vector< SampledFieldDescriptor > & plotfile2d::sampled_field_catalog

(

)

{
    return field_catalog_storage();
}

Referenced by available_sampled_field_names(), and find_sampled_field().

Here is the caller graph for this function:

sampled_field_id_to_string()

std::string plotfile2d::sampled_field_id_to_string

(

SampledFieldID

field_id

)

{
    return sampled_field_name(field_id);
}

Here is the call graph for this function:

sampled_field_is_scalar_state()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool plotfile2d::sampled_field_is_scalar_state ( SampledFieldID  field_id )

noexcept

{
    return !sampled_field_is_wind(field_id);
}

Here is the call graph for this function:

sampled_field_is_wind()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool plotfile2d::sampled_field_is_wind ( SampledFieldID  field_id )

noexcept

{
    switch (field_id) {
    case SampledFieldID::UEast:
    case SampledFieldID::VNorth:
    case SampledFieldID::W:
    case SampledFieldID::WindSpeed:
    case SampledFieldID::WindDir:
        return true;
    default:
        return false;
    }
}

Referenced by fill_sampled_level_component(), and sampled_field_is_scalar_state().

Here is the caller graph for this function:

sampled_field_name()

const char* plotfile2d::sampled_field_name ( SampledFieldID  field_id )

inlinenoexcept

{
    switch (field_id) {
    case SampledFieldID::Rho:       return "rho";
    case SampledFieldID::Theta:     return "theta";
    case SampledFieldID::Temp:      return "temp";
    case SampledFieldID::Pressure:  return "pressure";
    case SampledFieldID::HeightMSL: return "height_msl";
    case SampledFieldID::HeightAGL: return "height_agl";
    case SampledFieldID::Qv:        return "qv";
    case SampledFieldID::Qc:        return "qc";
    case SampledFieldID::Qi:        return "qi";
    case SampledFieldID::Qr:        return "qr";
    case SampledFieldID::Qs:        return "qs";
    case SampledFieldID::Qg:        return "qg";
    case SampledFieldID::UEast:     return "u_east";
    case SampledFieldID::VNorth:    return "v_north";
    case SampledFieldID::W:         return "w";
    case SampledFieldID::WindSpeed: return "wind_speed";
    case SampledFieldID::WindDir:    return "wind_dir";
    }
 
    return "unknown";
}

Referenced by sampled_field_id_to_string().

Here is the caller graph for this function:

sampled_field_value()

AMREX_GPU_DEVICE AMREX_FORCE_INLINE amrex::Real plotfile2d::sampled_field_value ( SampledFieldID  field_id, const amrex::Array4< const amrex::Real > &  cons_arr, const amrex::Array4< const amrex::Real > &  z_phys_cc_arr, const amrex::Array4< const amrex::Real > &  z_phys_nd_arr, bool  have_z_phys_cc, int  i, int  j, int  k, const MoistureComponentIndices &  moisture_indices  )

noexcept

{
    const amrex::Real rho = cons_arr(i, j, k, Rho_comp);
    const bool has_moisture = (moisture_indices.qv >= 0);
    // Microphysical fields are sampled as mixing ratios. The conserved state
    // stores rho*q, so field evaluation divides by rho before interpolation.
    const amrex::Real qv_for_eos = has_moisture
        ? cons_arr(i, j, k, moisture_indices.qv) / rho
        : amrex::Real(0.0);
 
    switch (field_id) {
    case SampledFieldID::Rho:
        return rho;
    case SampledFieldID::Theta:
        return cons_arr(i, j, k, RhoTheta_comp) / rho;
    case SampledFieldID::Temp:
        return getTgivenRandRTh(rho, cons_arr(i, j, k, RhoTheta_comp), qv_for_eos);
    case SampledFieldID::Pressure:
        return getPgivenRTh(cons_arr(i, j, k, RhoTheta_comp), qv_for_eos);
    case SampledFieldID::HeightMSL:
        if (have_z_phys_cc) {
            return z_phys_cc_arr(i, j, k);
        }
        return Compute_Z_AtCellCenter(i, j, k, z_phys_nd_arr);
    case SampledFieldID::HeightAGL:
        return Compute_Zrel_AtCellCenter(i, j, k, z_phys_nd_arr);
    case SampledFieldID::Qv:
        return has_moisture ? cons_arr(i, j, k, moisture_indices.qv) / rho : amrex::Real(0.0);
    case SampledFieldID::Qc:
        return (moisture_indices.qc >= 0) ? cons_arr(i, j, k, moisture_indices.qc) / rho : amrex::Real(0.0);
    case SampledFieldID::Qi:
        return (moisture_indices.qi >= 0) ? cons_arr(i, j, k, moisture_indices.qi) / rho : amrex::Real(0.0);
    case SampledFieldID::Qr:
        return (moisture_indices.qr >= 0) ? cons_arr(i, j, k, moisture_indices.qr) / rho : amrex::Real(0.0);
    case SampledFieldID::Qs:
        return (moisture_indices.qs >= 0) ? cons_arr(i, j, k, moisture_indices.qs) / rho : amrex::Real(0.0);
    case SampledFieldID::Qg:
        return (moisture_indices.qg >= 0) ? cons_arr(i, j, k, moisture_indices.qg) / rho : amrex::Real(0.0);
    case SampledFieldID::UEast:
    case SampledFieldID::VNorth:
    case SampledFieldID::W:
    case SampledFieldID::WindSpeed:
    case SampledFieldID::WindDir:
        return amrex::Real(0.0);
    }
 
    return amrex::Real(0.0);
}

Referenced by fill_sampled_level_component().

Here is the call graph for this function:

Here is the caller graph for this function:

sampled_interpolation_from_string()

SampledInterpolation plotfile2d::sampled_interpolation_from_string

(

const std::string &

value

)

{
    if (string_iequals(value, "none")) {
        return SampledInterpolation::None;
    }
    if (string_iequals(value, "linear")) {
        return SampledInterpolation::Linear;
    }
 
    amrex::Abort("Unknown sampled-level interpolation '" + value + "'");
    return SampledInterpolation::None;
}

Referenced by parse_sampled_level_definition().

Here is the caller graph for this function:

sampled_interpolation_to_string()

const char * plotfile2d::sampled_interpolation_to_string ( SampledInterpolation  interpolation )

noexcept

{
    switch (interpolation) {
    case SampledInterpolation::None:   return "none";
    case SampledInterpolation::Linear: return "linear";
    }
    return "unknown";
}

Referenced by build_sampled_level_output_descriptors_from_definitions().

Here is the caller graph for this function:

sampled_level_error_prefix()

std::string plotfile2d::sampled_level_error_prefix	(	const std::string &	level_set_name,
		const std::string &	parameter_name
	)

{
    std::ostringstream os;
    os << "Sampled-level definition '" << level_set_name << "' parameter '"
       << parameter_name << "': ";
    return os.str();
}

Referenced by build_sampled_level_output_descriptors_from_definitions(), validate_sampled_coordinate_string(), and validate_sampled_level_definition().

Here is the caller graph for this function:

sampled_level_value_tag()

std::string plotfile2d::sampled_level_value_tag	(	amrex::Real	value,
		const std::string &	units
	)

{
    std::string tag = format_numeric_tag(value);
    if (!units.empty() && units != "1") {
        tag += units;
    }
    return tag;
}

Referenced by sampled_output_name().

Here is the caller graph for this function:

sampled_output_name()

std::string plotfile2d::sampled_output_name	(	const std::string &	field_name,
		SampledCoordinate	coordinate,
		amrex::Real	value,
		const std::string &	units
	)

{
    std::ostringstream os;
    os << field_name << "_" << sampled_coordinate_tag(coordinate) << "_"
       << sampled_level_value_tag(value, units);
    return os.str();
}

Referenced by build_sampled_level_output_descriptors_from_definitions().

Here is the call graph for this function:

Here is the caller graph for this function:

sampled_target_is_bracketed()

AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE bool plotfile2d::sampled_target_is_bracketed ( amrex::Real  target, amrex::Real  c0, amrex::Real  c1  )

noexcept

{
    return (c0 <= target && target <= c1) ||
           (c1 <= target && target <= c0);
}

select_requested_plot_variables()

PlotVariableSelection plotfile2d::select_requested_plot_variables	(	const amrex::Vector< std::string > &	requested,
		const amrex::Vector< std::string > &	available
	)

{
    PlotVariableSelection selection;
 
    std::unordered_set<std::string> requested_set(requested.begin(), requested.end());
    std::unordered_set<std::string> available_set(available.begin(), available.end());
    std::unordered_set<std::string> seen_unavailable;
 
    // Preserve the canonical built-in ordering so component indices remain
    // stable even when the user lists variables in a different order.
    for (const auto& name : available) {
        if (requested_set.count(name) != 0) {
            selection.accepted.push_back(name);
        }
    }
 
    // Report each missing name once, in the order it was requested. The caller
    // uses these names to emit warnings without duplicating messages for repeats.
    for (const auto& name : requested) {
        if (available_set.count(name) == 0) {
            if (seen_unavailable.insert(name).second) {
                selection.unavailable.push_back(name);
            }
        }
    }
 
    return selection;
}

Referenced by ERF::setPlotVariables2D().

Here is the caller graph for this function:

select_requested_sampled_fields()

SampledFieldSelection plotfile2d::select_requested_sampled_fields	(	const amrex::Vector< std::string > &	requested,
		const SolverChoice &	solver_choice
	)

{
    SampledFieldSelection selection;
 
    std::unordered_set<std::string> seen;
 
    for (const auto& name : requested) {
        const auto* descriptor = find_sampled_field(name);
        if (descriptor == nullptr) {
            selection.unavailable.push_back(name);
            continue;
        }
 
        if (!field_is_available(descriptor->id, solver_choice)) {
            selection.unavailable.push_back(name);
            continue;
        }
 
        if (seen.insert(name).second) {
            selection.accepted.push_back(*descriptor);
        }
    }
 
    return selection;
}

Referenced by build_sampled_level_output_descriptors_from_definitions().

Here is the call graph for this function:

Here is the caller graph for this function:

selected_condensed_water_path_components()

SelectedWaterPathComponents plotfile2d::selected_condensed_water_path_components	(	const amrex::Vector< std::string > &	plot_var_names,
		const SolverChoice &	solver_choice
	)

{
    SelectedWaterPathComponents selected;
 
    for (int dst_comp = 0; dst_comp < static_cast<int>(plot_var_names.size()); ++dst_comp) {
        const auto* descriptor = find_diagnostic(plot_var_names[dst_comp]);
        if (!descriptor || !is_condensed_water_path(descriptor->id)) {
            continue;
        }
 
        const int src_comp = source_component_for(descriptor->id, solver_choice.moisture_indices);
        if (src_comp < 0) {
            continue;
        }
 
        selected.dst_comp[selected.n] = dst_comp;
        selected.src_comp[selected.n] = src_comp;
        ++selected.n;
    }
 
    return selected;
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

selected_precipitation_accumulation_components()

SelectedSurfacePrecipAccumulationComponents plotfile2d::selected_precipitation_accumulation_components	(	const amrex::Vector< std::string > &	plot_var_names,
		const SurfacePrecipAccumulationSources &	sources
	)

{
    SelectedSurfacePrecipAccumulationComponents selected;
 
    for (int dst_comp = 0; dst_comp < static_cast<int>(plot_var_names.size()); ++dst_comp) {
        const auto* descriptor = find_diagnostic(plot_var_names[dst_comp]);
        if (!descriptor || !is_precipitation_accumulation(descriptor->id)) {
            continue;
        }
 
        const bool has_total = surface_precip_has_total_source(sources);
        const bool has_rain = surface_precip_has_source(sources.rain);
 
        const bool source_available =
            (descriptor->id == DiagnosticID::PrecipTotalAccum)
                ? surface_precip_has_any_source(sources)
                : (descriptor->id == DiagnosticID::PrecipRainAccum)
                    ? (has_rain || has_total)
                    : (descriptor->id == DiagnosticID::PrecipSnowAccum)
                        ? surface_precip_has_source(sources.snow)
                        : (descriptor->id == DiagnosticID::PrecipGraupelAccum)
                            ? surface_precip_has_source(sources.graupel)
                            : (descriptor->id == DiagnosticID::PrecipHailAccum)
                                ? surface_precip_has_source(sources.hail)
                                : (descriptor->id == DiagnosticID::PrecipFrozenAccum)
                                    ? surface_precip_has_any_frozen_source(sources)
                                    : false;
 
        if (!source_available) {
            continue;
        }
 
        selected.dst_comp[selected.n] = dst_comp;
        selected.id[selected.n] = descriptor->id;
        ++selected.n;
    }
 
    return selected;
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

use_native_shoc_consumed_flux_source()

AMREX_FORCE_INLINE bool plotfile2d::use_native_shoc_consumed_flux_source ( bool  native_shoc_owns_scalar_fluxes, bool  native_shoc_has_consumed_flux_diagnostics, bool  host_flux_field_available  )

noexcept

{
    return native_shoc_owns_scalar_fluxes &&
           native_shoc_has_consumed_flux_diagnostics &&
           host_flux_field_available;
}

Referenced by ERF::Write2DPlotFile().

Here is the caller graph for this function:

validate_sampled_coordinate_string()

std::string plotfile2d::validate_sampled_coordinate_string	(	const std::string &	level_set_name,
		const std::string &	value
	)

{
    if (string_iequals(value, "isentropic")) {
        return sampled_level_error_prefix(level_set_name, "coordinate") +
               "isentropic output needs a crossing policy";
    }
 
    if (string_iequals(value, "model_index") ||
        string_iequals(value, "height_msl") ||
        string_iequals(value, "height_agl") ||
        string_iequals(value, "pressure")) {
        return {};
    }
 
    return "Unknown sampled-level coordinate '" + value + "'";
}

Referenced by parse_sampled_level_definition().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_sampled_level_definition()

std::string plotfile2d::validate_sampled_level_definition

(

const SampledLevelDefinition &

level_set

)

{
    if (level_set.name.empty()) {
        return "Sampled-level definition name is empty";
    }
 
    if (level_set.fields.empty()) {
        return sampled_level_error_prefix(level_set.name, "fields") + "missing fields";
    }
 
    if (level_set.values.empty()) {
        return sampled_level_error_prefix(level_set.name, "values") + "missing values";
    }
 
    const char* default_units = sampled_coordinate_default_units(level_set.coordinate);
    if (level_set.units.empty() || level_set.units == default_units) {
        // valid
    } else if (level_set.coordinate == SampledCoordinate::Pressure &&
               (level_set.units == "Pa" || level_set.units == "hPa")) {
        // valid
    } else {
        return sampled_level_error_prefix(level_set.name, "units") +
               "unsupported units '" + level_set.units + "'";
    }
 
    const char* default_interp = sampled_coordinate_default_interpolation(level_set.coordinate);
    if (level_set.interpolation == SampledInterpolation::None) {
        if (std::string(default_interp) != "none") {
            return sampled_level_error_prefix(level_set.name, "interpolation") +
                   "unsupported interpolation 'none' for coordinate '" +
                   sampled_coordinate_to_string(level_set.coordinate) + "'";
        }
    } else if (level_set.interpolation == SampledInterpolation::Linear) {
        if (std::string(default_interp) == "none" && level_set.coordinate == SampledCoordinate::ModelIndex) {
            return sampled_level_error_prefix(level_set.name, "interpolation") +
                   "unsupported interpolation 'linear' for coordinate 'model_index'";
        }
    }
 
    if (level_set.coordinate == SampledCoordinate::ModelIndex) {
        for (const auto value : level_set.values) {
            const auto rounded = std::nearbyint(value);
            if (std::abs(value - rounded) > amrex::Real(1.0e-12)) {
                return sampled_level_error_prefix(level_set.name, "values") +
                       "non-integer model_index value '" + std::to_string(value) + "'";
            }
        }
    }
 
    std::unordered_set<std::string> unique_fields(level_set.fields.begin(), level_set.fields.end());
    const auto n_unique_fields    = static_cast<int>(unique_fields.size());
    const auto n_requested_fields = static_cast<int>(level_set.fields.size());
    if (n_unique_fields != n_requested_fields) {
        return sampled_level_error_prefix(level_set.name, "fields") +
               build_duplicate_output_error(level_set.name);
    }
 
    return {};
}

Referenced by parse_sampled_level_definition().

Here is the call graph for this function:

Here is the caller graph for this function:

write_2d_metadata_json() [1/2]

void plotfile2d::write_2d_metadata_json	(	const std::string &	plotfilename,
		const amrex::Vector< Plotfile2DOutputDescriptor > &	descriptors
	)

{
    if (!amrex::ParallelDescriptor::IOProcessor()) {
        return;
    }
 
    const std::string filename = metadata_json_filename(plotfilename);
    std::ofstream outfile(filename, std::ios::out | std::ios::trunc);
    if (!outfile.good()) {
        amrex::FileOpenFailed(filename);
    }
 
    outfile << format_2d_metadata_json(descriptors);
    if (!outfile.good()) {
        amrex::FileOpenFailed(filename);
    }
}

Here is the call graph for this function:

write_2d_metadata_json() [2/2]

void plotfile2d::write_2d_metadata_json	(	const std::string &	plotfilename,
		const amrex::Vector< std::string > &	varnames
	)

{
    // Native AMReX 2D plotfiles write this sidecar next to the plotfile
    // directory on the I/O processor only.
    if (!amrex::ParallelDescriptor::IOProcessor()) {
        return;
    }
 
    const std::string filename = metadata_json_filename(plotfilename);
    std::ofstream outfile(filename, std::ios::out | std::ios::trunc);
    if (!outfile.good()) {
        amrex::FileOpenFailed(filename);
    }
 
    outfile << format_2d_metadata_json(varnames);
    if (!outfile.good()) {
        amrex::FileOpenFailed(filename);
    }
}

Referenced by ERF::Write2DPlotFile().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

MaxCondensedWaterPathComponents

constexpr int plotfile2d::MaxCondensedWaterPathComponents = 5

staticconstexpr

Referenced by active_condensed_water_path_descriptors(), and fill_condensed_water_paths().

MaxSurfacePrecipAccumulationComponents

constexpr int plotfile2d::MaxSurfacePrecipAccumulationComponents = 6

staticconstexpr

Referenced by fill_precipitation_accumulations().