Default2DOutputPlugin.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
//
// Copyright 2026 Caleb Buahin
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

 
#pragma once
 
#ifdef OPENSWMM_HAS_2D
 
#include "../../../../include/openswmm/plugin_sdk/IOutputPlugin.hpp"
 
#include <string>
#include <vector>
#include <hdf5.h>
 
namespace openswmm::twoD {
 
struct MeshData;          // forward declaration
struct SolverOptions2D;   // 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);

    void setMeshCoordinateScale(double metres_per_model_unit);

    std::string configureOutput(const SolverOptions2D& opts, double report_step_sec);

    unsigned reportVariables() const noexcept { return report_vars_; }
 
private:
    // ---- results-file size controls (configureOutput) ----
    hid_t    storage_type_ = H5T_NATIVE_DOUBLE;  
    int      compression_  = 4;                  
    unsigned report_vars_  = 0x7FFu;             
    std::vector<std::string> species_filter_;    
    std::vector<int>         species_rows_;      
    double   report_2d_step_days_ = 0.0;         
    double   next_due_days_       = -1.0;        
    bool     want(unsigned bit) const noexcept { return (report_vars_ & bit) != 0; }
    void writeSpeciesRows(const double* all, hsize_t n_species_in);
 
    std::string  h5_path_;
    PluginState  state_ = PluginState::UNLOADED;
    std::string  last_error_;
 
    std::string  model_crs_;                
    double       metres_per_model_unit_ = 1.0;  
 
    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_infil_rate_      = H5I_INVALID_HID;
    hid_t ds_face_infil_cum_       = H5I_INVALID_HID;
    hid_t ds_face_rain_cum_        = H5I_INVALID_HID;
    hid_t   ds_face_species_conc_  = H5I_INVALID_HID;
    hsize_t n_species_             = 0;
    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;
    hid_t ds_node_depth_           = 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 edge_stride_ = 3;  
    hsize_t n_steps_  = 0;  
 
    // Helpers
    void writeMeshTopology(const SimulationContext& ctx);
    void writeCrsVariable();
    hid_t createUnlimitedDataset(const char* name, int rank,
                                  const hsize_t* dims,
                                  const hsize_t* chunk_dims,
                                  hid_t type = -1);
    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