output.hpp

#ifndef NGEN_REALIZATION_CONFIG_OUTPUT_H
#define NGEN_REALIZATION_CONFIG_OUTPUT_H
 
#include <string>
#include <stdexcept>
 
#include <boost/property_tree/ptree.hpp>
#include <boost/optional.hpp>
 
namespace realization {
  namespace config {
 
    static const std::string OUTPUT_CONFIG_KEY = "output";
 
    static const std::string LEGACY_OUTPUT_ROOT_KEY        = "output_root";
    static const std::string LEGACY_DISABLE_CATCHMENT_KEY  = "disable_catchment_output";
    static const std::string LEGACY_PER_FORMULATION_KEY    = "per_formulation_nexus_files";
 
    enum class OutputFormat { csv, netcdf };
 
    enum class OutputGrouping { per_feature, per_formulation };
 
    inline OutputFormat parse_output_format(const std::string& s)
    {
        if (s == "csv")    return OutputFormat::csv;
        if (s == "netcdf") return OutputFormat::netcdf;
        throw std::runtime_error("Invalid output format '" + s + "'; expected 'csv' or 'netcdf'.");
    }
 
    inline OutputGrouping parse_output_grouping(const std::string& s)
    {
        if (s == "per_feature")     return OutputGrouping::per_feature;
        if (s == "per_formulation") return OutputGrouping::per_formulation;
        throw std::runtime_error("Invalid output grouping '" + s + "'; expected 'per_feature' or 'per_formulation'.");
    }
 
    struct OutputDomain {
        bool enable = true;
        OutputFormat format = OutputFormat::csv;
        OutputGrouping grouping = OutputGrouping::per_feature;
        bool rank_subdir = false;
 
        OutputDomain() = default;
 
        explicit OutputDomain(const boost::property_tree::ptree& tree) {
            enable = tree.get<bool>("enable", true);
            rank_subdir = tree.get<bool>("rank_subdir", false);
            if (auto f = tree.get_optional<std::string>("format"))   format   = parse_output_format(*f);
            if (auto g = tree.get_optional<std::string>("grouping")) grouping = parse_output_grouping(*g);
        }
    };
 
    inline std::string rank_output_root(const std::string& base_root, const OutputDomain& domain,
                                        int mpi_rank, int mpi_num_procs)
    {
        const bool needs_rank_subdir = domain.rank_subdir
                                       || domain.grouping == OutputGrouping::per_formulation;
        if (mpi_num_procs > 1 && needs_rank_subdir) {
            return base_root + "rank_" + std::to_string(mpi_rank) + "/";
        }
        return base_root;
    }
 
    struct Output {
        static constexpr int DEFAULT_PRECISION = 9;
 
        std::string root;
        OutputDomain catchment;
        OutputDomain nexus;
        int precision = DEFAULT_PRECISION;
        bool from_legacy_keys = false;
 
        Output() = default;
 
        static Output parse_block(const boost::property_tree::ptree& output_tree)
        {
            Output out;
            out.root = output_tree.get<std::string>("root", "");
            out.precision = output_tree.get<int>("precision", DEFAULT_PRECISION);
            if (auto c = output_tree.get_child_optional("catchment")) out.catchment = OutputDomain(*c);
            if (auto n = output_tree.get_child_optional("nexus"))     out.nexus     = OutputDomain(*n);
            return out;
        }
 
        static Output parse_legacy(const boost::property_tree::ptree& realization_tree)
        {
            Output out;
            const auto root        = realization_tree.get_optional<std::string>(LEGACY_OUTPUT_ROOT_KEY);
            const auto disable_cat = realization_tree.get_optional<bool>(LEGACY_DISABLE_CATCHMENT_KEY);
            const auto per_form    = realization_tree.get_child_optional(LEGACY_PER_FORMULATION_KEY);
 
            if (root)        out.root = *root;
            if (disable_cat) out.catchment.enable = !(*disable_cat);
            if (per_form && per_form->get_value<bool>(false)) out.nexus.format = OutputFormat::netcdf;
 
            out.from_legacy_keys = static_cast<bool>(root) || static_cast<bool>(disable_cat) || static_cast<bool>(per_form);
            return out;
        }
 
        static Output from_realization(const boost::property_tree::ptree& realization_tree)
        {
            auto block = realization_tree.get_child_optional(OUTPUT_CONFIG_KEY);
            Output out = block ? parse_block(*block) : parse_legacy(realization_tree);
            out.root = normalize_root(out.root);
            return out;
        }
 
    private:
        static std::string normalize_root(const std::string& configured_root)
        {
            if (configured_root.empty()) {
                return "./";
            }
            return configured_root.back() == '/' ? configured_root : configured_root + "/";
        }
    };
 
  }//end namespace config
}//end namespace realization
#endif //NGEN_REALIZATION_CONFIG_OUTPUT_H