Report2DVars.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_2D_REPORT2D_VARS_HPP
#define OPENSWMM_ENGINE_2D_REPORT2D_VARS_HPP
 
#include "SolverOptions2D.hpp"
 
#include <cctype>
#include <cmath>
#include <cstdio>
#include <limits>
#include <string>
#include <vector>
 
namespace openswmm::twoD::report2d {

inline const std::vector<std::string>& tokens() {
    static const std::vector<std::string> kTokens = {
        "DEPTH",        "VELOCITY",    "EDGE_FLUX", "NODE_HEAD",  "SPECIES",   "RAINFALL",
        "INFILTRATION", "COUPLING",    "GRADIENTS", "CONTINUITY", "ENVELOPES",
        "BUILDUP",                     // S7
        "GROUNDWATER",  "GW_DETAILED", // G-O
        "HEAT", "TURBULENCE",
    };
    return kTokens;
}

inline bool iequalsTok(const std::string& a, const char* b) {
    std::size_t i = 0;
    for (; i < a.size() && b[i]; ++i)
        if (std::toupper(static_cast<unsigned char>(a[i])) !=
            std::toupper(static_cast<unsigned char>(b[i])))
            return false;
    return i == a.size() && b[i] == '\0';
}

inline std::vector<std::string> splitList(const std::string& text) {
    std::vector<std::string> toks;
    std::string cur;
    for (char c : text) {
        if (c == ',' || c == ' ' || c == '\t' || c == '\r' || c == '\n') {
            if (!cur.empty()) {
                toks.push_back(cur);
                cur.clear();
            }
        } else {
            cur += c;
        }
    }
    if (!cur.empty())
        toks.push_back(cur);
    return toks;
}

inline std::string parseMask(const std::string& text, unsigned& mask) {
    mask = 0;
    const auto toks = splitList(text);
    if (toks.empty())
        return "REPORT_2D_VARIABLES needs DEFAULT|MINIMAL|ALL or a token list";
    const auto& names = tokens();
    for (const auto& t : toks) {
        if (iequalsTok(t, "DEFAULT")) {
            mask |= DEFAULT_MASK;
            continue;
        }
        if (iequalsTok(t, "MINIMAL")) {
            mask |= MINIMAL_MASK;
            continue;
        }
        if (iequalsTok(t, "ALL")) {
            mask |= ALL_MASK;
            continue;
        }
        if (iequalsTok(t, "NONE")) {
            continue;
        }
        bool found = false;
        for (std::size_t i = 0; i < names.size(); ++i) {
            if (iequalsTok(t, names[i].c_str())) {
                mask |= (1u << i);
                found = true;
                break;
            }
        }
        if (!found) {
            std::string all;
            for (const auto& n : names) {
                if (!all.empty())
                    all += "|";
                all += n;
            }
            return "Unknown REPORT_2D_VARIABLES token '" + t +
                   "' (expected DEFAULT|MINIMAL|ALL|NONE or " + all + ")";
        }
    }
    mask |= DEPTH;
    return {};
}

inline std::string formatMask(unsigned mask) {
    mask &= ALL_MASK;
    if (mask == DEFAULT_MASK)
        return "DEFAULT";
    if (mask == MINIMAL_MASK)
        return "MINIMAL";
    if (mask == ALL_MASK)
        return "ALL";
    const auto& names = tokens();
    std::string out;
    for (std::size_t i = 0; i < names.size(); ++i) {
        if (mask & (1u << i)) {
            if (!out.empty())
                out += ' ';
            out += names[i];
        }
    }
    return out.empty() ? std::string("DEPTH") : out;
}

inline std::string formatSpecies(const std::vector<std::string>& species) {
    if (species.empty())
        return "ALL";
    std::string out;
    for (const auto& n : species) {
        if (!out.empty())
            out += ' ';
        out += n;
    }
    return out;
}

inline std::vector<std::string> parseSpecies(const std::string& text) {
    auto v = splitList(text);
    if (v.size() == 1 && iequalsTok(v[0], "ALL"))
        v.clear();
    return v;
}

inline std::string formatStep(double seconds) {
    char buf[64];
    if (!(seconds > 0))
        return "00:00:00";
    // Fractional report/infiltration cadences must survive API and INP
    // roundtrips. These 2D keys accept bare numeric seconds directly.
    if (std::floor(seconds) != seconds ||
        seconds >= static_cast<double>(std::numeric_limits<long>::max())) {
        std::snprintf(buf, sizeof(buf), "%.17g", seconds);
        return buf;
    }
    const long total = seconds > 0.0 ? static_cast<long>(seconds) : 0L;
    std::snprintf(buf, sizeof(buf), "%02ld:%02ld:%02ld", total / 3600, (total % 3600) / 60,
                  total % 60);
    return buf;
}
 
} // namespace openswmm::twoD::report2d
 
#endif // OPENSWMM_ENGINE_2D_REPORT2D_VARS_HPP