inpmeshwriter.h

Go to the documentation of this file.

 
#ifndef OPENSWMMVIS_MESH_INPMESHWRITER_H
#define OPENSWMMVIS_MESH_INPMESHWRITER_H
 
#include "meshresult.h"
#include "meshedgebc.h"
 
#include <QHash>
#include <QString>
#include <QVector>
 
namespace mesh {
 
struct CouplingMap
{
    QHash<int, QString> vertexToNode;
    QHash<int, QString> triangleToNode;
    QHash<int, double>  triangleMannings;
};
 
enum class MeshOutputMode {
    External,   
    Inline      
};
 
class InpMeshWriter
{
public:
    struct UnitInfo
    {
        QString linearUnitName;     
        QString sourceCrsTag;       
 
        // User-declared (out-of-line) default ctor: makes UnitInfo a
        // non-aggregate so the `const UnitInfo & = {}` default arguments
        // below invoke this constructor instead of aggregate-initialising
        // with the in-class member initializer — which clang rejects as
        // "needed within definition of enclosing class outside of member
        // functions" when the type is nested in InpMeshWriter.
        UnitInfo();
    };
 
    [[nodiscard]] static QString buildSectionText(const MeshResult &mesh,
                                                  const CouplingMap &coupling,
                                                  double defaultMannings = 0.035,
                                                  const UnitInfo &units = {});
 
    [[nodiscard]] static QString buildBCSectionText(const QVector<MeshEdgeBC> &bcs);
 
    [[nodiscard]] static QString buildConveyanceSectionText(
        const MeshResult &mesh, const QVector<MeshEdgeBC> &bcs);
 
    [[nodiscard]] static bool writeExternal(const QString &inpPath,
                                             const QString &meshFilePath,
                                             const MeshResult &mesh,
                                             const CouplingMap &coupling,
                                             double defaultMannings = 0.035,
                                             QString *errorOut = nullptr,
                                             const UnitInfo &units = {});
 
    [[nodiscard]] static bool writeExternal(const QString &inpPath,
                                             const QString &meshFilePath,
                                             const MeshResult &mesh,
                                             const CouplingMap &coupling,
                                             const QVector<MeshEdgeBC> &bcs,
                                             double defaultMannings,
                                             QString *errorOut = nullptr,
                                             const UnitInfo &units = {});
 
    [[nodiscard]] static bool writeInline(const QString &inpPath,
                                           const MeshResult &mesh,
                                           const CouplingMap &coupling,
                                           double defaultMannings = 0.035,
                                           QString *errorOut = nullptr,
                                           const UnitInfo &units = {});
 
    [[nodiscard]] static bool writeInline(const QString &inpPath,
                                           const MeshResult &mesh,
                                           const CouplingMap &coupling,
                                           const QVector<MeshEdgeBC> &bcs,
                                           double defaultMannings,
                                           QString *errorOut = nullptr,
                                           const UnitInfo &units = {});
 
    [[nodiscard]] static bool writeMeshFileRef(const QString &inpPath,
                                               const QString &meshFilePath,
                                               QString *errorOut = nullptr);
 
    [[nodiscard]] static bool patchBCSections(const QString &filePath,
                                              const MeshResult &mesh,
                                              const QVector<MeshEdgeBC> &bcs,
                                              QString *errorOut = nullptr);
 
    [[nodiscard]] static bool patchAttributeSections(const QString &filePath,
                                                     const MeshResult &mesh,
                                                     QString *errorOut = nullptr,
                                                     double defaultMannings = 0.035);
 
    [[nodiscard]] static bool clearMeshFileRef(const QString &inpPath,
                                               QString *errorOut = nullptr);
 
    [[nodiscard]] static bool write(MeshOutputMode mode,
                                     const QString &inpPath,
                                     const QString &meshFilePath,
                                     const MeshResult &mesh,
                                     const CouplingMap &coupling,
                                     double defaultMannings = 0.035,
                                     QString *errorOut = nullptr,
                                     const UnitInfo &units = {});
};
 
} // namespace mesh
 
#endif // OPENSWMMVIS_MESH_INPMESHWRITER_H