TableData.hpp

Go to the documentation of this file.

 
#ifndef OPENSWMM_ENGINE_TABLE_DATA_HPP
#define OPENSWMM_ENGINE_TABLE_DATA_HPP
 
#include <string>
#include <vector>
#include <cstdint>
#include <cassert>
#include <algorithm>
 
namespace openswmm {
 
// ============================================================================
// Table types (matching legacy SWMM enums.h)
// ============================================================================
 
enum class TableType : int {
    TIMESERIES    = 0,  
    CURVE_STORAGE = 1,  
    CURVE_DIVERSION = 2, 
    CURVE_RATING  = 3,  
    CURVE_SHAPE   = 4,  
    CURVE_CONTROL = 5,  
    CURVE_TIDAL   = 6,  
    CURVE_PUMP1   = 7,  
    CURVE_PUMP2   = 8,  
    CURVE_PUMP3   = 9,  
    CURVE_PUMP4   = 10  
};
 
// ============================================================================
// TableCursor
// ============================================================================
 
struct TableCursor {
    int index     =  0;  
    int direction = +1;  
 
    void reset() noexcept { index = 0; direction = +1; }
};
 
// ============================================================================
// Table
// ============================================================================
 
struct Table {
    std::string         id;      
    TableType           type;    
    std::vector<double> x;       
    std::vector<double> y;       
    TableCursor         cursor;  
 
    std::size_t size() const noexcept { return x.size(); }
 
    bool empty() const noexcept { return x.empty(); }
};
 
// ============================================================================
// Cursor-optimized lookup
// ============================================================================
 
inline double table_lookup_cursor(Table& tbl, double x_query) noexcept {
    const int n = static_cast<int>(tbl.x.size());
    if (n == 0) return 0.0;
    if (n == 1) return tbl.y[0];
 
    // Clamp below first entry
    if (x_query <= tbl.x[0]) {
        tbl.cursor.index     = 0;
        tbl.cursor.direction = +1;
        return tbl.y[0];
    }
 
    // Clamp above last entry
    if (x_query >= tbl.x[n - 1]) {
        tbl.cursor.index     = n - 1;
        tbl.cursor.direction = -1;
        return tbl.y[n - 1];
    }
 
    // Start from cursor position and seek in the most likely direction
    int idx = std::clamp(tbl.cursor.index, 0, n - 2);
 
    // Forward seek
    while (idx < n - 1 && tbl.x[idx + 1] < x_query) {
        ++idx;
        tbl.cursor.direction = +1;
    }
 
    // Backward seek
    while (idx > 0 && tbl.x[idx] > x_query) {
        --idx;
        tbl.cursor.direction = -1;
    }
 
    tbl.cursor.index = idx;
 
    // Linear interpolation between x[idx] and x[idx+1]
    const double dx = tbl.x[idx + 1] - tbl.x[idx];
    if (dx <= 0.0) return tbl.y[idx];  // guard against duplicate x values
    const double t = (x_query - tbl.x[idx]) / dx;
    return tbl.y[idx] + t * (tbl.y[idx + 1] - tbl.y[idx]);
}
 
inline double table_step_cursor(Table& tbl, double x_query) noexcept {
    const int n = static_cast<int>(tbl.x.size());
    if (n == 0) return 0.0;
    if (n == 1) return tbl.y[0];
 
    // Before first entry → 0 (no rain before first recorded value)
    if (x_query < tbl.x[0]) {
        tbl.cursor.index     = 0;
        tbl.cursor.direction = +1;
        return 0.0;
    }
 
    // At or past last entry → return last value.
    // The caller (Gage.cpp) handles the rain interval cutoff and returns 0
    // after entry_time + rainInterval. This allows the last entry's value to
    // be used for its full recording interval before going to zero.
    if (x_query >= tbl.x[n - 1]) {
        tbl.cursor.index     = n - 1;
        tbl.cursor.direction = -1;
        return tbl.y[n - 1];
    }
 
    // Seek to the interval containing x_query: x[idx] <= x_query < x[idx+1]
    int idx = std::clamp(tbl.cursor.index, 0, n - 2);
 
    while (idx < n - 1 && tbl.x[idx + 1] <= x_query) {
        ++idx;
        tbl.cursor.direction = +1;
    }
    while (idx > 0 && tbl.x[idx] > x_query) {
        --idx;
        tbl.cursor.direction = -1;
    }
 
    tbl.cursor.index = idx;
    return tbl.y[idx];
}
 
// ============================================================================
// TableData — SoA collection of all tables
// ============================================================================
 
struct TableData {
    std::vector<Table> tables;  
 
    std::size_t count() const noexcept { return tables.size(); }
 
    Table&       operator[](int idx)       { return tables[static_cast<std::size_t>(idx)]; }
    const Table& operator[](int idx) const { return tables[static_cast<std::size_t>(idx)]; }
 
    int add(const std::string& id, TableType type) {
        tables.push_back({id, type, {}, {}, {}});
        return static_cast<int>(tables.size()) - 1;
    }
 
    void reset_cursors() noexcept {
        for (auto& t : tables) t.cursor.reset();
    }
};
 
} /* namespace openswmm */
 
#endif /* OPENSWMM_ENGINE_TABLE_DATA_HPP */