CellUtils.h

Go to the documentation of this file.

 
#pragma once
#include "CLIUtils.h"
#include <bitset>
#include <sstream>
#include <string>
#include <unordered_map>
#include <vector>
 
enum class BoundaryCondition { OUTFLOW, REFLECTIVE, PERIODIC };
enum class CellType { INNER, BORDER, HALO };
enum class HaloLocation { NORTH, SOUTH, WEST, EAST, ABOVE, BELOW };
enum class BorderLocation { NORTH = 0, SOUTH = 1, WEST = 2, EAST = 3, ABOVE = 4, BELOW = 5 };
 
namespace CellUtils {
static inline const std::unordered_map<std::string, BoundaryCondition> conditionTable = {
    {"outflow", BoundaryCondition::OUTFLOW},
    {"reflective", BoundaryCondition::REFLECTIVE},
    {"periodic", BoundaryCondition::PERIODIC}};
 
static inline const std::unordered_map<std::string, CellType> typeTable = {
    {"inner", CellType::INNER}, {"border", CellType::BORDER}, {"halo", CellType::HALO}};
 
static inline const std::unordered_map<std::string, HaloLocation> haloTable = {
    {"north", HaloLocation::NORTH}, {"south", HaloLocation::SOUTH}, {"east", HaloLocation::EAST},
    {"west", HaloLocation::WEST},   {"above", HaloLocation::ABOVE}, {"below", HaloLocation::BELOW},
};
 
static inline const std::unordered_map<BoundaryCondition, std::string> conditionStringTable = []() {
    std::unordered_map<BoundaryCondition, std::string> reverseMap;
    for (const auto &pair : conditionTable)
        reverseMap[pair.second] = pair.first;
    return reverseMap;
}();
 
static inline const std::unordered_map<CellType, std::string> typeStringTable = []() {
    std::unordered_map<CellType, std::string> reverseMap;
    for (const auto &pair : typeTable)
        reverseMap[pair.second] = pair.first;
    return reverseMap;
}();
 
static inline const std::unordered_map<HaloLocation, std::string> haloStringTable = []() {
    std::unordered_map<HaloLocation, std::string> reverseMap;
    for (const auto &pair : haloTable)
        reverseMap[pair.second] = pair.first;
    return reverseMap;
}();
 
static inline std::string fromBoundaryCondition(BoundaryCondition type) { return conditionStringTable.at(type); }
 
static inline BoundaryCondition toBoundaryCondition(const std::string &type) {
    auto it = conditionTable.find(type);
    if (it != conditionTable.end())
        return it->second;
    else
        CLIUtils::error("Invalid output type", type);
    return BoundaryCondition::OUTFLOW; // shouldn't reach this; included to silence warning
}
 
static inline std::string fromType(CellType type) { return typeStringTable.at(type); }
 
static inline CellType toType(const std::string &type) {
    auto it = typeTable.find(type);
    if (it != typeTable.end())
        return it->second;
    else
        CLIUtils::error("Invalid output type", type);
    return CellType::INNER; // shouldn't reach this; included to silence warning
}
 
static inline std::string fromHalo(HaloLocation type) { return haloStringTable.at(type); }
 
static inline std::string fromHaloVec(const std::vector<HaloLocation> &vec) {
    std::stringstream ss;
    for (auto v : vec) {
        switch (v) {
        case HaloLocation::NORTH:
            ss << "N";
            break;
        case HaloLocation::SOUTH:
            ss << "S";
            break;
        case HaloLocation::EAST:
            ss << "E";
            break;
        case HaloLocation::WEST:
            ss << "W";
            break;
        case HaloLocation::ABOVE:
            ss << "A";
            break;
        case HaloLocation::BELOW:
            ss << "B";
            break;
        default:
            SPDLOG_WARN("This shouldn't happen! (haloVec)");
            break;
        }
    }
    return ss.str();
}
 
static inline std::string fromBoundaryConditionArray(const std::array<BoundaryCondition, 6> &arr) {
    std::stringstream ss;
    for (auto c : arr) {
        switch (c) {
        case BoundaryCondition::OUTFLOW:
            ss << "o";
            break;
        case BoundaryCondition::REFLECTIVE:
            ss << "r";
            break;
        case BoundaryCondition::PERIODIC:
            ss << "p";
            break;
        default:
            SPDLOG_WARN("This shouldn't happen! (fromBoundaryConditionArray)");
            break;
        }
    }
    return ss.str();
}
 
static inline HaloLocation toHalo(const std::string &type) {
    auto it = haloTable.find(type);
    if (it != haloTable.end())
        return it->second;
    else
        CLIUtils::error("Invalid output type", type);
    return HaloLocation::NORTH; // shouldn't reach this; included to silence warning
}
 
static inline std::array<BoundaryCondition, 6> stringToBoundaryConditions(const std::string &str) {
    if (str.size() != 6)
        CLIUtils::error("Invalid boundary condition string length!");
    std::array<BoundaryCondition, 6> arr;
    size_t index = 0;
    for (auto &c : str) {
        switch (c) {
        case 'o':
            arr[index++] = BoundaryCondition::OUTFLOW;
            break;
        case 'r':
            arr[index++] = BoundaryCondition::REFLECTIVE;
            break;
        case 'p':
            arr[index++] = BoundaryCondition::PERIODIC;
            break;
        default:
            CLIUtils::error("Invalid boundary condition character (must be one of: o, r)!");
        }
    }
    return arr;
}
 
} // namespace CellUtils