erf_checkpoint_surface_temperature Namespace Reference

Enumerations
enum class	ContractReadStatus { Valid , Malformed , UnknownVersion }
enum class	LegacyInitType { WRFInput , Metgrid , Unknown }
enum class	LegacySurfaceTemperatureCompatibility { Compatible , UnsafeMetgrid , UnknownProvenance }

Functions
void	write_contract_version (std::ostream &output)
int	first_legacy_surface_temperature_level (const std::string &checkpointname, const int finest_level)
LegacyInitType	parse_legacy_init_type_value (std::string value)
ContractReadStatus	read_contract_version (std::istream &input, int &version)
LegacyInitType	parse_legacy_init_type_from_job_info (std::istream &input)
LegacySurfaceTemperatureCompatibility	classify_legacy_surface_temperature_checkpoint (const bool marker_present, const bool has_surface_arrays, const LegacyInitType legacy_init_type)

Variables
constexpr int	contract_version = 1

Enumeration Type Documentation

ContractReadStatus

enum erf_checkpoint_surface_temperature::ContractReadStatus

strong

Enumerator
Valid
Malformed
UnknownVersion

                              {
    Valid,
    Malformed,
    UnknownVersion
};

LegacyInitType

enum erf_checkpoint_surface_temperature::LegacyInitType

strong

Enumerator
WRFInput
Metgrid
Unknown

                          {
    WRFInput,
    Metgrid,
    Unknown
};

LegacySurfaceTemperatureCompatibility

enum erf_checkpoint_surface_temperature::LegacySurfaceTemperatureCompatibility

strong

Enumerator
Compatible
UnsafeMetgrid
UnknownProvenance

                                                 {
    Compatible,
    UnsafeMetgrid,
    UnknownProvenance
};

Function Documentation

classify_legacy_surface_temperature_checkpoint()

LegacySurfaceTemperatureCompatibility erf_checkpoint_surface_temperature::classify_legacy_surface_temperature_checkpoint ( const bool  marker_present, const bool  has_surface_arrays, const LegacyInitType  legacy_init_type  )

inline

{
    if (marker_present || !has_surface_arrays) {
        return LegacySurfaceTemperatureCompatibility::Compatible;
    }
    if (legacy_init_type == LegacyInitType::WRFInput) {
        return LegacySurfaceTemperatureCompatibility::Compatible;
    }
    if (legacy_init_type == LegacyInitType::Metgrid) {
        return LegacySurfaceTemperatureCompatibility::UnsafeMetgrid;
    }
    return LegacySurfaceTemperatureCompatibility::UnknownProvenance;
}

first_legacy_surface_temperature_level()

int erf_checkpoint_surface_temperature::first_legacy_surface_temperature_level ( const std::string &  checkpointname, const int  finest_level  )

inline

Return the first AMR level containing a legacy SST or TSK surface array.

The arrays are identified by their AMReX header files. A return value of -1 means that neither legacy array is present on any level.

{
    for (int lev = 0; lev <= finest_level; ++lev) {
        const bool has_sst = amrex::FileExists(
            amrex::MultiFabFileFullPrefix(lev, checkpointname, "Level_", "SST_0_H"));
        const bool has_tsk = amrex::FileExists(
            amrex::MultiFabFileFullPrefix(lev, checkpointname, "Level_", "TSK_0_H"));
        if (has_sst || has_tsk) {
            return lev;
        }
    }
    return -1;
}

parse_legacy_init_type_from_job_info()

LegacyInitType erf_checkpoint_surface_temperature::parse_legacy_init_type_from_job_info ( std::istream &  input )

inline

Legacy Metgrid SST/TSK arrays are absolute temperature, whereas current Metgrid initialization stores the SurfaceLayer representation (theta). Without the marker there is no pressure in a checkpoint with which to reinterpret those legacy arrays safely.

{
    constexpr const char* key = "erf.init_type";
    constexpr std::size_t key_length = 13;
    LegacyInitType result = LegacyInitType::Unknown;
    std::string line;
 
    while (std::getline(input, line)) {
        std::size_t pos = 0;
        while (pos < line.size() &&
               std::isspace(static_cast<unsigned char>(line[pos]))) {
            ++pos;
        }
        if (line.compare(pos, key_length, key) != 0) {
            continue;
        }
        pos += key_length;
        if (pos < line.size() && !std::isspace(static_cast<unsigned char>(line[pos])) &&
            line[pos] != '=') {
            continue;
        }
        while (pos < line.size() &&
               std::isspace(static_cast<unsigned char>(line[pos]))) {
            ++pos;
        }
        if (pos == line.size() || line[pos] != '=') {
            result = LegacyInitType::Unknown;
            continue;
        }
        ++pos;
        while (pos < line.size() &&
               std::isspace(static_cast<unsigned char>(line[pos]))) {
            ++pos;
        }
 
        std::string value;
        bool malformed = (pos == line.size());
        if (!malformed && line[pos] == '"') {
            ++pos;
            const std::size_t end_quote = line.find('"', pos);
            if (end_quote == std::string::npos) {
                malformed = true;
            } else {
                value = line.substr(pos, end_quote - pos);
                pos = end_quote + 1;
            }
        } else if (!malformed) {
            const std::size_t value_begin = pos;
            while (pos < line.size() &&
                   !std::isspace(static_cast<unsigned char>(line[pos]))) {
                ++pos;
            }
            value = line.substr(value_begin, pos - value_begin);
        }
 
        while (pos < line.size() &&
               std::isspace(static_cast<unsigned char>(line[pos]))) {
            ++pos;
        }
        if (malformed || pos != line.size()) {
            result = LegacyInitType::Unknown;
            continue;
        }
 
        result = parse_legacy_init_type_value(value);
    }
 
    return result;
}

Here is the call graph for this function:

parse_legacy_init_type_value()

LegacyInitType erf_checkpoint_surface_temperature::parse_legacy_init_type_value ( std::string  value )

inline

{
    for (char& character : value) {
        character = static_cast<char>(std::tolower(static_cast<unsigned char>(character)));
    }
    if (value == "wrfinput") {
        return LegacyInitType::WRFInput;
    }
    if (value == "metgrid") {
        return LegacyInitType::Metgrid;
    }
    return LegacyInitType::Unknown;
}

Referenced by parse_legacy_init_type_from_job_info().

Here is the caller graph for this function:

read_contract_version()

ContractReadStatus erf_checkpoint_surface_temperature::read_contract_version ( std::istream &  input, int &  version  )

inline

Parse the integer surface-temperature contract marker from a checkpoint.

{
    if (!(input >> version)) {
        return ContractReadStatus::Malformed;
    }
 
    std::string extra;
    if (input >> extra) {
        return ContractReadStatus::Malformed;
    }
 
    return (version == contract_version) ? ContractReadStatus::Valid
                                         : ContractReadStatus::UnknownVersion;
}

write_contract_version()

void erf_checkpoint_surface_temperature::write_contract_version ( std::ostream &  output )

inline

{
    output << contract_version << "\n";
}

Variable Documentation

contract_version

constexpr int erf_checkpoint_surface_temperature::contract_version = 1

constexpr

Referenced by read_contract_version(), and write_contract_version().