erf_interval_means Namespace Reference

Namespaces
	detail

Classes
struct	LevelMetadata
struct	Metadata

Functions
bool	parse_metadata (std::istream &input, Metadata &result, std::string &error)
std::string	validate_metadata (const Metadata &metadata, int expected_levels, int expected_components, const amrex::Vector< amrex::BoxArray > &expected_boxes)
int	global_reset_done (const Metadata &metadata)
int	legacy_reset_done (bool time_reset_mode, double checkpoint_time, double reset_time)
bool	initialization_accumulates_state (bool restarting) noexcept
bool	initialization_clears_interval (bool restarting, bool compute_mean_vars, const std::string &reset_mode) noexcept

Function Documentation

global_reset_done()

int erf_interval_means::global_reset_done ( const Metadata &  metadata )

inline

{
    for (const auto& record : metadata.level) {
        if (record.reset_done != 0) return 1;
    }
    return 0;
}

Referenced by ERF::ReadCheckpointFile().

Here is the caller graph for this function:

initialization_accumulates_state()

bool erf_interval_means::initialization_accumulates_state ( bool  restarting )

inlinenoexcept

{
    return !restarting;
}

Referenced by ERF::InitData_post().

Here is the caller graph for this function:

initialization_clears_interval()

bool erf_interval_means::initialization_clears_interval ( bool  restarting, bool  compute_mean_vars, const std::string &  reset_mode  )

inlinenoexcept

{
    return !restarting && compute_mean_vars && reset_mode == "plotfile";
}

Referenced by ERF::InitData_post().

Here is the caller graph for this function:

legacy_reset_done()

int erf_interval_means::legacy_reset_done ( bool  time_reset_mode, double  checkpoint_time, double  reset_time  )

inline

{
    return time_reset_mode && checkpoint_time >= reset_time ? 1 : 0;
}

Referenced by ERF::ReadCheckpointFile().

Here is the caller graph for this function:

parse_metadata()

bool erf_interval_means::parse_metadata ( std::istream &  input, Metadata &  result, std::string &  error  )

inline

{
    std::string title;
    if (!std::getline(input, title) || title != "ERF interval means checkpoint v1") {
        error = "expected ERF interval means checkpoint v1 title";
        return false;
    }
    if (!(input >> result.levels >> result.components) || result.levels < 0 ||
        result.components < 0) {
        error = "missing or invalid interval-mean level/component counts";
        return false;
    }
 
    result.level.clear();
    result.level.resize(result.levels);
    for (int lev = 0; lev < result.levels; ++lev) {
        auto& record = result.level[lev];
        if (!(input >> record.level >> record.accumulation_count >> record.reset_done) ||
            record.level != lev || !std::isfinite(record.accumulation_count) ||
            record.accumulation_count < 0.0 ||
            (record.reset_done != 0 && record.reset_done != 1)) {
            error = "invalid interval-mean level record " + std::to_string(lev);
            return false;
        }
 
        if (!detail::read_box_array(input, record.boxes)) {
            error = "truncated interval-mean BoxArray record for level " +
                    std::to_string(lev);
            return false;
        }
        std::string box_remainder;
        if (!std::getline(input, box_remainder)) {
            error = "truncated interval-mean BoxArray line for level " +
                    std::to_string(lev);
            return false;
        }
 
        long long map_size = -1;
        if (!(input >> map_size) || map_size < 0 ||
            map_size != static_cast<long long>(record.boxes.size())) {
            error = "invalid interval-mean processor-map size for level " +
                    std::to_string(lev);
            return false;
        }
        // The map records the writer's ranks, which need not exist in the
        // restarted run, so only reject entries that cannot be a rank at all.
        record.processor_map.resize(static_cast<std::size_t>(map_size));
        for (long long ibox = 0; ibox < map_size; ++ibox) {
            int& rank = record.processor_map[static_cast<std::size_t>(ibox)];
            if (!(input >> rank)) {
                error = "truncated interval-mean processor map for level " +
                        std::to_string(lev);
                return false;
            }
            if (rank < 0) {
                error = "invalid interval-mean processor-map rank " +
                        std::to_string(rank) + " for level " + std::to_string(lev);
                return false;
            }
        }
    }
    return true;
}

Referenced by ERF::ReadCheckpointFile().

Here is the call graph for this function:

Here is the caller graph for this function:

validate_metadata()

std::string erf_interval_means::validate_metadata ( const Metadata &  metadata, int  expected_levels, int  expected_components, const amrex::Vector< amrex::BoxArray > &  expected_boxes  )

inline

{
    if (metadata.levels != expected_levels || metadata.components != expected_components) {
        return "expected " + std::to_string(expected_levels) + " levels and " +
               std::to_string(expected_components) + " components";
    }
    if (static_cast<int>(expected_boxes.size()) < expected_levels ||
        static_cast<int>(metadata.level.size()) != expected_levels) {
        return "interval-mean metadata level count does not match the restart";
    }
    for (int lev = 0; lev < expected_levels; ++lev) {
        if (!(metadata.level[lev].boxes == expected_boxes[lev])) {
            return "interval-mean checkpoint BoxArray does not match level " +
                   std::to_string(lev);
        }
    }
    return {};
}

Referenced by ERF::ReadCheckpointFile().

Here is the caller graph for this function: