irunlayer.h

Go to the documentation of this file.

 
#ifndef OPENSWMMVIS_PLOT_IRUNLAYER_H
#define OPENSWMMVIS_PLOT_IRUNLAYER_H
 
#include "plot/plotattribute.h"
#include "plot/resultdescriptor.h"
 
#include <QDateTime>
#include <QString>
#include <QStringList>
 
#include <vector>
 
namespace openswmmvis::plot {
 
struct ObjectRef {
    enum class Kind {
        Unknown    = 0,
        Node       = 1,    
        Link       = 2,    
        Subcatch   = 3,    
        Mesh2DCell = 4,    
        Observed   = 5,    
        System     = 6,    
        Mesh2DEdge = 7,    
        Mesh2DVertex = 8,  
    };
 
    Kind     kind      = Kind::Unknown;
    QString  name;          
    int      triIdx    = -1;   
    int      edgeLocal = -1;   
 
    constexpr ObjectRef() = default;
    ObjectRef(Kind k, QString n) : kind(k), name(std::move(n)) {}
    static ObjectRef forNode(QString n)       { return ObjectRef(Kind::Node, std::move(n)); }
    static ObjectRef forLink(QString n)       { return ObjectRef(Kind::Link, std::move(n)); }
    static ObjectRef forSubcatch(QString n)   { return ObjectRef(Kind::Subcatch, std::move(n)); }
    static ObjectRef forMesh2DCell(int idx)   { ObjectRef r; r.kind = Kind::Mesh2DCell; r.triIdx = idx; return r; }
    static ObjectRef forMesh2DEdge(int tri, int edge)
    { ObjectRef r; r.kind = Kind::Mesh2DEdge; r.triIdx = tri; r.edgeLocal = edge; return r; }
    static ObjectRef forMesh2DVertex(int idx)
    { ObjectRef r; r.kind = Kind::Mesh2DVertex; r.triIdx = idx; return r; }
    static ObjectRef forObserved(QString lbl) { return ObjectRef(Kind::Observed, std::move(lbl)); }
    static ObjectRef forSystem()              { ObjectRef r; r.kind = Kind::System; return r; }
 
    bool isValid() const noexcept
    {
        switch (kind) {
        case Kind::Mesh2DCell:   return triIdx >= 0;
        case Kind::Mesh2DVertex: return triIdx >= 0;
        case Kind::Mesh2DEdge:   return triIdx >= 0 && edgeLocal >= 0 && edgeLocal <= 2;
        case Kind::System:       return true;   // name is unused
        case Kind::Unknown:      return false;
        default:                 return !name.isEmpty();
        }
    }
 
    bool operator==(const ObjectRef& other) const noexcept
    {
        return kind == other.kind && name == other.name
            && triIdx == other.triIdx && edgeLocal == other.edgeLocal;
    }
    bool operator!=(const ObjectRef& other) const noexcept { return !(*this == other); }
};
 
inline const QVector<PlotAttribute> &attributesForKind(ObjectRef::Kind k)
{
    switch (k) {
    case ObjectRef::Kind::Node:         return nodePlotAttributes();
    case ObjectRef::Kind::Link:         return linkPlotAttributes();
    case ObjectRef::Kind::Subcatch:     return subcatchPlotAttributes();
    case ObjectRef::Kind::System:       return systemPlotAttributes();
    case ObjectRef::Kind::Mesh2DCell:   return mesh2DCellPlotAttributes();
    case ObjectRef::Kind::Mesh2DEdge:   return mesh2DEdgePlotAttributes();
    case ObjectRef::Kind::Mesh2DVertex: return mesh2DVertexPlotAttributes();
    default: {
        static const QVector<PlotAttribute> kEmpty;
        return kEmpty;
    }
    }
}
 
inline QVector<ResultDescriptor> resultDescriptorsForKind(
    ObjectRef::Kind kind, const QStringList &speciesNames)
{
    QVector<ResultDescriptor> out;
    const QVector<PlotAttribute> &fixed = attributesForKind(kind);
    out.reserve(fixed.size() + speciesNames.size());
    for (const PlotAttribute a : fixed)
        out.append(ResultDescriptor::forAttribute(a));
 
    // Species columns exist for the element kinds the .out carries them
    // on (node/link/subcatch — Y2a's rule); System series and mesh kinds
    // have none. Order is the run's .out order — the engine's order — so
    // two pickers over the same run agree.
    const bool speciesKind = kind == ObjectRef::Kind::Node ||
                             kind == ObjectRef::Kind::Link ||
                             kind == ObjectRef::Kind::Subcatch;
    if (speciesKind)
        for (const QString &sp : speciesNames)
            if (!sp.isEmpty())
                out.append(ResultDescriptor::forSpecies(sp));
    return out;
}
 
struct SeriesData {
    std::vector<double> timesJulian;   
    std::vector<double> values;        
    bool                ok = false;    
    QString             errorMessage;  
 
    int                 firstPeriod = 0;
    int                 periodCount = 0;
};
 
class IRunLayer {
public:
    virtual ~IRunLayer() = default;
 
    virtual QString scenarioName() const = 0;
 
    virtual UnitSystem unitSystem() const = 0;
 
    virtual double startDateJulian() const = 0;
 
    virtual int periodCount() const = 0;
 
    virtual int reportStepSeconds() const = 0;
 
    virtual void getSeriesAt(const ObjectRef& ref,
                             PlotAttribute attr,
                             SeriesData& out) const = 0;
 
    virtual bool supportsAttribute(PlotAttribute /*attr*/) const { return true; }
 
    virtual void getSeriesAt(const ObjectRef& ref,
                             const ResultDescriptor& descriptor,
                             SeriesData& out) const
    {
        if (descriptor.isSpecies()) {
            out.ok = false;
            out.errorMessage =
                QStringLiteral("Source '%1' carries no species results")
                    .arg(scenarioName());
            return;
        }
        getSeriesAt(ref, descriptor.attr, out);
    }
 
    virtual QVector<ResultDescriptor> resultDescriptorsForKind(
        ObjectRef::Kind kind) const
    { return plot::resultDescriptorsForKind(kind, QStringList()); }
 
    virtual QString persistenceKey() const { return scenarioName(); }
};
 
} // namespace openswmmvis::plot
 
#endif // OPENSWMMVIS_PLOT_IRUNLAYER_H