mesh_connectivity.hpp

Go to the documentation of this file.

#pragma once
 
#include <fstream>
#include <span>
#include <unordered_map>
#include <vector>
 
#include <yaml-cpp/yaml.h>
 
namespace kynema::model {
 
class MeshConnectivity {
public:
    MeshConnectivity() = default;
 
    void AddBeamElementConnectivity(size_t elem_id, std::span<const size_t> node_ids) {
        beams_[elem_id].assign(std::begin(node_ids), std::end(node_ids));
    }
 
    void AddMassElementConnectivity(size_t elem_id, size_t node_id) {
        masses_[elem_id] = std::vector<size_t>{node_id};
    }
 
    void AddSpringElementConnectivity(size_t elem_id, const std::array<size_t, 2>& node_ids) {
        springs_[elem_id] = std::vector<size_t>{node_ids[0], node_ids[1]};
    }
 
    void AddConstraintConnectivity(size_t constraint_id, std::span<const size_t> node_ids) {
        constraints_[constraint_id].assign(std::begin(node_ids), std::end(node_ids));
    }
 
    [[nodiscard]] const std::vector<size_t>& GetBeamElementConnectivity(size_t elem_id) const {
        return beams_.at(elem_id);
    }
 
    [[nodiscard]] const std::vector<size_t>& GetMassElementConnectivity(size_t elem_id) const {
        return masses_.at(elem_id);
    }
 
    [[nodiscard]] const std::vector<size_t>& GetSpringElementConnectivity(size_t elem_id) const {
        return springs_.at(elem_id);
    }
 
    [[nodiscard]] const std::vector<size_t>& GetConstraintConnectivity(size_t constraint_id) const {
        return constraints_.at(constraint_id);
    }
 
    void ExportToYAML(std::ostream& file) const {
        YAML::Node root;
 
        ExportElementTypeToYAML(root, "beams", beams_);
        ExportElementTypeToYAML(root, "masses", masses_);
        ExportElementTypeToYAML(root, "springs", springs_);
        ExportElementTypeToYAML(root, "constraints", constraints_);
 
        file << root;
    }
 
    void ExportToYAML(const std::string& filename) const {
        std::ofstream file(filename);
        ExportToYAML(file);
    }
 
    void ImportFromYAML(const YAML::Node& root) {
        masses_.clear();
        springs_.clear();
        beams_.clear();
        constraints_.clear();
 
        // Import masses
        if (root["masses"]) {
            for (const auto& entry : root["masses"]) {
                const size_t id = std::stoul(entry.first.as<std::string>());
                masses_[id] = entry.second.as<std::vector<size_t>>();
            }
        }
 
        // Import springs
        if (root["springs"]) {
            for (const auto& entry : root["springs"]) {
                const size_t id = std::stoul(entry.first.as<std::string>());
                springs_[id] = entry.second.as<std::vector<size_t>>();
            }
        }
 
        // Import beams
        if (root["beams"]) {
            for (const auto& entry : root["beams"]) {
                const size_t id = std::stoul(entry.first.as<std::string>());
                beams_[id] = entry.second.as<std::vector<size_t>>();
            }
        }
 
        // Import constraints
        if (root["constraints"]) {
            for (const auto& entry : root["constraints"]) {
                const size_t id = std::stoul(entry.first.as<std::string>());
                constraints_[id] = entry.second.as<std::vector<size_t>>();
            }
        }
    }
 
    void ImportFromYAML(const std::string& filename) { ImportFromYAML(YAML::LoadFile(filename)); }
 
private:
    std::unordered_map<size_t, std::vector<size_t>> beams_;
    std::unordered_map<size_t, std::vector<size_t>> masses_;
    std::unordered_map<size_t, std::vector<size_t>> springs_;
    std::unordered_map<size_t, std::vector<size_t>> constraints_;
 
    template <typename MapType>
    static void ExportElementTypeToYAML(
        YAML::Node& root, const std::string& element_type, const MapType& map
    ) {
        if (map.empty()) {
            return;
        }
 
        YAML::Node element_node;
 
        // Get all keys from the map and sort them to maintain consistent order
        std::vector<size_t> keys;
        keys.reserve(map.size());
        for (const auto& [id, _] : map) {
            keys.push_back(id);
        }
        std::sort(keys.begin(), keys.end());
 
        // Add each element in sorted order of id
        for (const auto& id : keys) {
            YAML::Node array_node;
            std::for_each(map.at(id).begin(), map.at(id).end(), [&array_node](const auto& node_id) {
                array_node.push_back(node_id);
            });
 
            array_node.SetStyle(YAML::EmitterStyle::Flow);
            element_node[std::to_string(id)] = array_node;
        }
 
        root[element_type] = element_node;
    }
};
 
}  // namespace kynema::model