StorageGeometry.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2026 Caleb Buahin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#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.141592654;

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