plotfile2d Namespace Reference

Classes
struct	DiagnosticDescriptor
struct	PlotVariableSelection

Enumerations
enum class	DiagnosticID {   ZSurf , LandMask , MapFac , LatM ,   LonM , UStar , WStar , TStar ,   QStar , Olen , Pblh , TSurf ,   QSurf , Z0 , OLR , SensFlux ,   LatenFlux , SurfPres , IntegratedQv , SurfaceDiagnosticSource ,   SensibleHeatFlux , LatentHeatFlux , ShocUStar , ShocOlen ,   ShocWthvSfc }
enum class	DiagnosticCategory {   Geometry , SurfaceLayer , Radiation , SurfaceFlux ,   PBL , SurfaceState , ColumnIntegral }
enum class	MissingPolicy { AlwaysAvailable , FillZeroWhenUnavailable , FillMinus999WhenUnavailable }

Functions
const amrex::Vector< DiagnosticDescriptor > &	diagnostic_catalog ()
amrex::Vector< std::string >	diagnostic_names ()
const DiagnosticDescriptor *	find_diagnostic (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_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_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)
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)
void	write_2d_metadata_json (const std::string &plotfilename, const amrex::Vector< std::string > &varnames)
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

Enumeration Type Documentation

DiagnosticCategory

enum plotfile2d::DiagnosticCategory

strong

Enumerator
Geometry
SurfaceLayer
Radiation
SurfaceFlux
PBL
SurfaceState
ColumnIntegral

{
    Geometry,
    SurfaceLayer,
    Radiation,
    SurfaceFlux,
    PBL,
    SurfaceState,
    ColumnIntegral
};

DiagnosticID

enum plotfile2d::DiagnosticID

strong

Enumerator
ZSurf
LandMask
MapFac
LatM
LonM
UStar
WStar
TStar
QStar
Olen
Pblh
TSurf
QSurf
Z0
OLR
SensFlux
LatenFlux
SurfPres
IntegratedQv
SurfaceDiagnosticSource
SensibleHeatFlux
LatentHeatFlux
ShocUStar
ShocOlen
ShocWthvSfc

{
    ZSurf,
    LandMask,
    MapFac,
    LatM,
    LonM,
    UStar,
    WStar,
    TStar,
    QStar,
    Olen,
    Pblh,
    TSurf,
    QSurf,
    Z0,
    OLR,
    SensFlux,
    LatenFlux,
    SurfPres,
    IntegratedQv,
    SurfaceDiagnosticSource,
    SensibleHeatFlux,
    LatentHeatFlux,
    ShocUStar,
    ShocOlen,
    ShocWthvSfc
};

MissingPolicy

enum plotfile2d::MissingPolicy

strong

Enumerator
AlwaysAvailable
FillZeroWhenUnavailable
FillMinus999WhenUnavailable

{
    AlwaysAvailable,
    FillZeroWhenUnavailable,
    FillMinus999WhenUnavailable
};

Function Documentation

diagnostic_catalog()

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

(

)

{
    return catalog_storage();
}

Referenced by 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::ColumnIntegral:   return "ColumnIntegral";
    }
 
    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;
}

Referenced by ERF::setPlotVariables2D().

Here is the call graph for this function:

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_latent_heat_flux_from_klevel_or_missing(), and fill_sensible_heat_flux_from_klevel_or_missing().

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_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 format_2d_metadata_json().

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()

std::string plotfile2d::format_2d_metadata_json

(

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

varnames

)

{
    // Native AMReX 2D plotfiles get a metadata sidecar for the selected
    // output variables only. The writer formats catalog metadata; it does not
    // compute diagnostics or encode runtime source selection.
    std::ostringstream os;
    os << "{\n";
    os << "  \"format_version\": 1,\n";
    os << "  \"kind\": \"ERF 2D plotfile metadata\",\n";
    os << "  \"n_variables\": " << static_cast<int>(varnames.size()) << ",\n";
    os << "  \"variables\": [\n";
 
    for (int i = 0; i < static_cast<int>(varnames.size()); ++i) {
        const auto* descriptor = find_diagnostic(varnames[i]);
        if (descriptor == nullptr) {
            amrex::Abort("2D metadata requested for unknown diagnostic '" + varnames[i] + "'");
        }
 
        append_variable_record(os, *descriptor, i, i == static_cast<int>(varnames.size()) - 1);
    }
 
    os << "  ]\n";
    os << "}\n";
    return os.str();
}

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();
}

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 {};
}

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:

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:

write_2d_metadata_json()

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: