anonymous_namespace{postLIE.cpp} Namespace Reference

Functions
void	postVTU (std::string const &int_vtu_filename, std::string const &out_vtu_filename)
void	postPVD (std::string const &in_pvd_filename, std::string const &out_pvd_filename, bool const allow_overwrite)

Function Documentation

postPVD()

void anonymous_namespace{postLIE.cpp}::postPVD	(	std::string const &	in_pvd_filename,
		std::string const &	out_pvd_filename,
		bool const	allow_overwrite )

Definition at line 71 of file postLIE.cpp.

{
    auto const in_pvd_file_dir = BaseLib::extractPath(in_pvd_filename);
    auto const out_pvd_file_dir = BaseLib::extractPath(out_pvd_filename);
    INFO("start reading the PVD file {:s}", in_pvd_filename);
    boost::property_tree::ptree pt;
    read_xml(in_pvd_filename, pt,
             boost::property_tree::xml_parser::trim_whitespace);
 
    for (auto& dataset : pt.get_child("VTKFile.Collection"))
    {
        if (dataset.first != "DataSet")
        {
            continue;
        }
 
        // get VTU file name
        auto const org_vtu_filename =
            dataset.second.get<std::string>("<xmlattr>.file");
        auto const org_vtu_filebasename =
            BaseLib::extractBaseName(org_vtu_filename);
        auto org_vtu_dir = BaseLib::extractPath(org_vtu_filename);
        if (org_vtu_dir.empty())
        {
            org_vtu_dir = in_pvd_file_dir;
        }
        auto const org_vtu_filepath =
            BaseLib::joinPaths(org_vtu_dir, org_vtu_filebasename);
        INFO("processing {:s}...", org_vtu_filepath);
 
        // post-process the VTU and save into the new file
        auto const dest_vtu_filename = "post_" + org_vtu_filebasename;
        auto const dest_vtu_filepath =
            BaseLib::joinPaths(out_pvd_file_dir, dest_vtu_filename);
        if (!allow_overwrite && BaseLib::IsFileExisting(dest_vtu_filepath))
        {
            INFO("The destination file already exists. Skip overwriting it.");
        }
        else
        {
            postVTU(org_vtu_filepath, dest_vtu_filepath);
        }
 
        // create a new VTU file and update XML
        dataset.second.put("<xmlattr>.file", dest_vtu_filename);
    }
 
    // save into the new PVD file
    INFO("save into the new PVD file {:s}", out_pvd_filename);
    boost::property_tree::xml_writer_settings<std::string> settings('\t', 1);
    write_xml(out_pvd_filename, pt, std::locale(), settings);
}

References BaseLib::extractBaseName(), BaseLib::extractPath(), INFO(), BaseLib::IsFileExisting(), BaseLib::joinPaths(), and postVTU().

Referenced by main().

postVTU()

void anonymous_namespace{postLIE.cpp}::postVTU	(	std::string const &	int_vtu_filename,
		std::string const &	out_vtu_filename )

Definition at line 33 of file postLIE.cpp.

{
    // read VTU with simulation results
    std::unique_ptr<MeshLib::Mesh const> mesh(
        MeshLib::IO::readMeshFromFile(int_vtu_filename));
    if (mesh->hasNonlinearElement())
    {
        mesh = MeshToolsLib::convertToLinearMesh(*mesh, mesh->getName());
    }
 
    // post-process
    std::vector<MeshLib::Element*> vec_matrix_elements;
    std::vector<int> vec_fracture_mat_IDs;
    std::vector<std::vector<MeshLib::Element*>> vec_fracture_elements;
    std::vector<std::vector<MeshLib::Element*>> vec_fracture_matrix_elements;
    std::vector<std::vector<MeshLib::Node*>> vec_fracture_nodes;
    std::vector<std::pair<std::size_t, std::vector<int>>>
        vec_branch_nodeID_matIDs;
    std::vector<std::pair<std::size_t, std::vector<int>>>
        vec_junction_nodeID_matIDs;
    ProcessLib::LIE::getFractureMatrixDataInMesh(
        *mesh, vec_matrix_elements, vec_fracture_mat_IDs, vec_fracture_elements,
        vec_fracture_matrix_elements, vec_fracture_nodes,
        vec_branch_nodeID_matIDs, vec_junction_nodeID_matIDs);
 
    ProcessLib::LIE::PostProcessTool post(*mesh,
                                          vec_fracture_mat_IDs,
                                          vec_fracture_nodes,
                                          vec_fracture_matrix_elements,
                                          vec_branch_nodeID_matIDs,
                                          vec_junction_nodeID_matIDs);
 
    // create a new VTU file
    INFO("create {:s}", out_vtu_filename);
    MeshLib::IO::writeMeshToFile(post.getOutputMesh(), out_vtu_filename);
}

References MeshToolsLib::convertToLinearMesh(), ProcessLib::LIE::getFractureMatrixDataInMesh(), ProcessLib::LIE::PostProcessTool::getOutputMesh(), INFO(), MeshLib::IO::readMeshFromFile(), and MeshLib::IO::writeMeshToFile().

Referenced by main(), and postPVD().