raingageassignment.h

Go to the documentation of this file.

 
#ifndef OPENSWMMVIS_ASSIGNMENT_RAINGAGEASSIGNMENT_H
#define OPENSWMMVIS_ASSIGNMENT_RAINGAGEASSIGNMENT_H
 
#include "core/gageblend.h"
 
#include <QMap>
#include <QPointF>
#include <QSet>
#include <QString>
#include <QStringList>
#include <QVector>
 
#include <atomic>
 
class MapCanvas;
class QUndoCommand;
class SWMMModelLayer;
 
namespace openswmmvis::assignment::raingage
{
 
enum class Method { Nearest, Interpolated };
 
struct Options {
    Method method = Method::Nearest;
    bool laplace = false;      
    double tolerance = 0.01;   
    bool subcatchments = true; 
    bool rdii = false;         
    bool selectedOnly = false; 
    QStringList selectedSubcatchments;
    QStringList selectedNodes; 
};
 
struct GageSite {
    int index = -1; 
    QString name;
    QPointF pos; 
};
 
struct SubcatchInput {
    QString name;
    QString oldGage;
    QVector<QPointF> ring; 
};
 
struct RdiiInput {
    QString node;
    QString group;
    double area = 0.0;
    QPointF pos;
    bool inScope = true; 
};
 
struct UhGroup {
    struct Row {
        int month = -1, response = 0;
        double r = 0, t = 0, k = 0, dmax = 0, drecov = 0, dinit = 0;
    };
    struct Decay {
        int response = 0;
        double kDep = 0, k0 = 0, kT = 0, tRef = 0, thetaRec = 0, tFreeze = 0;
        int snowOn = 0;
        double snowT = 0, snowDdf = 0;
    };
    QString gage;
    QVector<Row> rows;
    QVector<Decay> decay;
};
 
struct Input {
    Options options;
    QVector<GageSite> gages;
    QStringList unlocated;  
    QStringList coincident; 
    QVector<SubcatchInput> subcatchments;
    QVector<RdiiInput> rdii;
    QMap<QString, UhGroup> groups;          
    QVector<GageBlend::SourceGage> sources; 
    double scfMin = 1.0, scfMax = 1.0;
    QMap<QString, QStringList> existingClaims;
    QSet<QString> gageNames; 
    QString error;           
};
 
struct RowPlan {
    enum class Kind { Subcatchment, Rdii };
    Kind kind = Kind::Subcatchment;
    QString object; 
    QString oldGage;
    QString newGage;
    QString oldGroup; 
    QString newGroup; 
    QString detail;
    bool changed = false;
};
 
struct GeneratedGage {
    QString gageName;
    QString seriesName;
    QString key; 
    QVector<GageBlend::SeriesPoint> points;
    qint64 intervalSec = 0;
    double snowFactor = 1.0;
    double relError = 0.0;
    QStringList members; 
    bool isNew = false;
    bool isUpdate = false;
};
 
struct NewGroup {
    QString name;
    QString source;
    QString gage;
};
 
struct Plan {
    QVector<RowPlan> rows;
    QVector<GeneratedGage> generated;
    QStringList staleGages;            
    QMap<QString, QString> groupGages; 
    QVector<NewGroup> newGroups;
    QStringList warnings;
    QString error;  
    QPointF parkAt; 
    int scanned = 0;
    int skipped = 0;
    int changed = 0;
    int splitGroups = 0;
};
 
struct Progress {
    std::atomic<int> done{0};
    std::atomic<int> total{0};
    std::atomic<bool> cancel{false};
};
 
[[nodiscard]] QVector<GageSite> eligibleGages(SWMMModelLayer *layer, QStringList *unlocated,
                                              QStringList *coincident);
 
[[nodiscard]] Input gatherInput(SWMMModelLayer *layer, const Options &options);
 
[[nodiscard]] Plan computePlan(const Input &input, Progress *progress = nullptr);
 
[[nodiscard]] QUndoCommand *makeApplyCommand(SWMMModelLayer *layer, MapCanvas *canvas,
                                             const Plan &plan, const QString &text);
 
} // namespace openswmmvis::assignment::raingage
 
#endif // OPENSWMMVIS_ASSIGNMENT_RAINGAGEASSIGNMENT_H