Default2DOutputPlugin.hpp

Go to the documentation of this file.

 
#pragma once
 
#ifdef OPENSWMM_HAS_2D
 
#include "../../../../include/openswmm/plugin_sdk/IOutputPlugin.hpp"
 
#include <string>
#include <hdf5.h>
 
namespace openswmm::twoD {
 
struct MeshData;  // forward declaration

class Default2DOutputPlugin final : public IOutputPlugin {
public:
    explicit Default2DOutputPlugin(std::string h5_path);
    ~Default2DOutputPlugin() override;
 
    // Non-copyable
    Default2DOutputPlugin(const Default2DOutputPlugin&) = delete;
    Default2DOutputPlugin& operator=(const Default2DOutputPlugin&) = delete;
 
    // -----------------------------------------------------------------------
    // IOutputPlugin interface
    // -----------------------------------------------------------------------
 
    PluginState state() const noexcept override { return state_; }
 
    int initialize(const std::vector<std::string>& init_args,
                   const IPluginComponentInfo* info) override;
 
    int validate(const SimulationContext& ctx) override;
 
    int prepare(const SimulationContext& ctx) override;
 
    int update(const SimulationSnapshot& snapshot) override;
 
    int finalize(const SimulationContext& ctx) override;
 
    const char* last_error_message() const noexcept override {
        return last_error_.c_str();
    }

    void prepareMeshAndDatasets(const MeshData& mesh);
 
private:
    std::string  h5_path_;
    PluginState  state_ = PluginState::UNLOADED;
    std::string  last_error_;
 
    hid_t file_id_   = H5I_INVALID_HID;  
 
    // Dataset handles for time-varying fields (unlimited time dimension)
    hid_t ds_time_                 = H5I_INVALID_HID;
    hid_t ds_face_depth_           = H5I_INVALID_HID;
    hid_t ds_face_head_            = H5I_INVALID_HID;
    hid_t ds_face_grad_hx_         = H5I_INVALID_HID;
    hid_t ds_face_grad_hy_         = H5I_INVALID_HID;
    hid_t ds_face_grad_hx_lim_     = H5I_INVALID_HID;
    hid_t ds_face_grad_hy_lim_     = H5I_INVALID_HID;
    hid_t ds_face_rainfall_        = H5I_INVALID_HID;
    hid_t ds_face_coupling_flux_   = H5I_INVALID_HID;
    hid_t ds_face_net_source_      = H5I_INVALID_HID;
    hid_t ds_face_vx_              = H5I_INVALID_HID;
    hid_t ds_face_vy_              = H5I_INVALID_HID;
    hid_t ds_face_continuity_err_  = H5I_INVALID_HID;
    hid_t ds_edge_flux_            = H5I_INVALID_HID;
    hid_t ds_node_head_            = H5I_INVALID_HID;
 
    // Cumulative envelopes — fixed [nFace], overwritten in place each update()
    hid_t ds_face_max_depth_          = H5I_INVALID_HID;
    hid_t ds_face_max_velocity_       = H5I_INVALID_HID;
    hid_t ds_face_max_continuity_err_ = H5I_INVALID_HID;
 
    hsize_t n_faces_  = 0;
    hsize_t n_nodes_  = 0;
    hsize_t n_steps_  = 0;  
 
    // Helpers
    void writeMeshTopology(const SimulationContext& ctx);
    hid_t createUnlimitedDataset(const char* name, int rank,
                                  const hsize_t* dims,
                                  const hsize_t* chunk_dims);
    void writeStringAttr(hid_t loc, const char* name, const char* value);
    void writeDoubleAttr(hid_t loc, const char* name, double value);
    void extendAndWrite2D(hid_t ds, const double* data, hsize_t n_cols);
    void extendAndWrite3D(hid_t ds, const double* data, hsize_t dim1, hsize_t dim2);
    hid_t createFaceEnvelopeDataset(const char* name, const char* long_name,
                                    const char* units);
    void writeFaceEnvelope(hid_t ds, const double* data);
};
 
} // namespace openswmm::twoD
 
#endif // OPENSWMM_HAS_2D