io.hpp

Go to the documentation of this file.

 
#pragma once 
 
#include <fstream>
#include <sstream>
#include <iostream>
#include <stdlib.h>
#include <string>
#include <vector>
#include <stdexcept>
#include <sys/stat.h>
 
#include "mesh/Mesh.hpp"
#include "model/Record.hpp"
#include "model/Model.hpp"
#include "mesh/Vertex.hpp"
#include "Parameters.hpp"
#include "linalg/Linear_algebra.hpp"
#include "Dynamics.hpp"
 
std::string pop_space(std::string rawString);
 
std::string trim_trailing_semicolon(std::string rawString);
 
bool import_kv_string(std::string variableNameStr, std::string variableValueStr, Param& param);
 
bool import_param_file(Param& param, std::string filepath);
 
template <typename T>
std::vector<std::vector<T>> read_data_from_csv(const std::string& filepath, char separator = ',') {
    // Open and read CSV file
    std::ifstream csvFile(filepath);
    if (!csvFile.is_open()) {
        // Handle error: Unable to open CSV file
        throw std::invalid_argument("Unable to open CSV file.");
    }
 
    // Data structure to store data
    std::vector<std::vector<T>> data;
 
    // Read each line from the CSV file
    std::string line;
    while (std::getline(csvFile, line)) {
        std::vector<T> row;
        std::istringstream iss(line);
        std::string value;
 
        // Parse the line using the specified separator
        while (std::getline(iss, value, separator)) {
            try {
                T typedValue = static_cast<T>(std::stod(value));
                row.push_back(typedValue);
            } catch (const std::invalid_argument& e) {
                // Handle error: Unable to convert to the specified data type
                csvFile.close(); // Close CSV file before throwing exception
                throw std::invalid_argument("Unable to convert data to the specified data type.");
            }
        }
 
        // Add the row to the data vector
        data.push_back(row);
    }
 
    // Close the CSV file
    csvFile.close();
 
    return data;
}
 
bool import_mesh_from_vertices_faces(Mesh& mesh, std::string verticesFilepath, std::string facesFilepath);
 
std::vector<Matrix> import_scaffolding_mesh(std::string filepath);
 
void write_vertex_data_to_csv(const Mesh &mesh, const int iteration)
__attribute__((deprecated("Use Mesh::write_vertex_data_to_csv instead.")));
 
void write_energy_force_data_to_csv(const Model &model);
 
bool write_model_restart_checkpoint(const Model &model,
                                    const std::string &filepath,
                                    const int nextIteration);
 
bool load_model_restart_checkpoint(Model &model, const std::string &filepath);
 
void write_element_face_energy_to_csv(const Model &model);
 
void write_final_vertex_data_to_csv(const Mesh &mesh);
 
void dynamics_create_trajectory_files(DynamicMesh &mesh, const std::string &filename);
 
void output_trajectory_files(Mesh &mesh, const std::string &input_filename);
 
void dynamics_output_trajectory_files(DynamicMesh &mesh, const std::string &filename);