StorageGeometry.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_DATA_STORAGEGEOMETRY_HPP
#define OPENSWMM_ENGINE_DATA_STORAGEGEOMETRY_HPP
 
#include "NodeData.hpp"
 
#include <cmath>
#include <string>
#include <string_view>
 
namespace openswmm {

inline constexpr double kStoragePi = 3.141592653589793;

inline constexpr bool storage_shape_is_geometric(StorageShape s) noexcept {
    return s == StorageShape::CYLINDRICAL || s == StorageShape::CONICAL ||
           s == StorageShape::PARABOLOID  || s == StorageShape::PYRAMIDAL;
}

inline bool storage_shape_params_valid(StorageShape s,
                                       double p1, double p2, double p3) noexcept {
    if (!storage_shape_is_geometric(s)) return true;
    if (p1 <= 0.0 || p2 <= 0.0 || p3 < 0.0) return false;
    if (s == StorageShape::PARABOLOID && p3 == 0.0) return false;
    return true;
}

inline bool storage_shape_coeffs(StorageShape s, double p1, double p2, double p3,
                                 double& a, double& b, double& c) noexcept {
    if (!storage_shape_is_geometric(s)) return false;
    if (!storage_shape_params_valid(s, p1, p2, p3)) return false;
 
    const double A = p1 / 2.0;   // base/top semi-axis length
    const double B = p2 / 2.0;   // base/top semi-axis width
    const double Z = p3;         // side slope (run/rise), or height for PARABOLOID
 
    switch (s) {
        case StorageShape::CYLINDRICAL:
            a = 0.0;
            b = 0.0;
            c = kStoragePi * A * B;
            return true;
        case StorageShape::CONICAL:
            a = 2.0 * kStoragePi * B * Z;
            b = kStoragePi * B / A * Z * Z;
            c = kStoragePi * A * B;
            return true;
        case StorageShape::PARABOLOID:
            a = kStoragePi * A * B / Z;   // Z != 0 guaranteed by params_valid
            b = 0.0;
            c = 0.0;
            return true;
        case StorageShape::PYRAMIDAL:
            a = 2.0 * (p1 + p2) * Z;      // 2(L + W)Z — full base dims, not semi-axes
            b = 4.0 * Z * Z;
            c = p1 * p2;                  // L·W
            return true;
        default:
            return false;
    }
}

inline const char* storage_shape_keyword(StorageShape s) noexcept {
    switch (s) {
        case StorageShape::TABULAR:     return "TABULAR";
        case StorageShape::FUNCTIONAL:  return "FUNCTIONAL";
        case StorageShape::CYLINDRICAL: return "CYLINDRICAL";
        case StorageShape::CONICAL:     return "CONICAL";
        case StorageShape::PARABOLOID:  return "PARABOLIC";
        case StorageShape::PYRAMIDAL:   return "PYRAMIDAL";
    }
    return "FUNCTIONAL";
}

inline bool storage_shape_from_keyword(std::string_view kw, StorageShape& out) noexcept {
    if (kw == "TABULAR")     { out = StorageShape::TABULAR;     return true; }
    if (kw == "FUNCTIONAL")  { out = StorageShape::FUNCTIONAL;  return true; }
    if (kw == "CYLINDRICAL") { out = StorageShape::CYLINDRICAL; return true; }
    if (kw == "CONICAL")     { out = StorageShape::CONICAL;     return true; }
    if (kw == "PARABOLIC" || kw == "PARABOLOID")
                             { out = StorageShape::PARABOLOID;  return true; }
    if (kw == "PYRAMIDAL")   { out = StorageShape::PYRAMIDAL;   return true; }
    return false;
}

inline constexpr bool storage_shape_is_valid_code(int v) noexcept {
    return v >= static_cast<int>(StorageShape::TABULAR) &&
           v <= static_cast<int>(StorageShape::PYRAMIDAL);
}
 
}  // namespace openswmm
 
#endif  // OPENSWMM_ENGINE_DATA_STORAGEGEOMETRY_HPP