PartitionMesh.cpp File Reference

#include <tclap/CmdLine.h>
#include "BaseLib/CPUTime.h"
#include "BaseLib/FileTools.h"
#include "BaseLib/Logging.h"
#include "BaseLib/MPI.h"
#include "BaseLib/RunTime.h"
#include "BaseLib/TCLAPArguments.h"
#include "InfoLib/GitInfo.h"
#include "MeshLib/IO/readMeshFromFile.h"
#include "Metis.h"
#include "NodeWiseMeshPartitioner.h"

Include dependency graph for PartitionMesh.cpp:

Go to the source code of this file.

Functions
void	addGlobalIDsToMesh (MeshLib::Properties &mesh_properties, MeshLib::MeshItemType const mesh_item_type, std::size_t const number_of_items)
void	addGlobalIDsToMesh (MeshLib::Mesh &mesh)
int	main (int argc, char *argv[])

Function Documentation

addGlobalIDsToMesh() [1/2]

void addGlobalIDsToMesh

(

MeshLib::Mesh &

mesh

)

Definition at line 38 of file PartitionMesh.cpp.

{
    auto& mesh_properties = mesh.getProperties();
 
    addGlobalIDsToMesh(mesh_properties, MeshLib::MeshItemType::Node,
                       mesh.getNumberOfNodes());
    INFO("Property {} is added to mesh {}",
         MeshLib::globalIDString(MeshLib::MeshItemType::Node), mesh.getName());
 
    addGlobalIDsToMesh(mesh_properties, MeshLib::MeshItemType::Cell,
                       mesh.getNumberOfElements());
    INFO("Property {} is added to mesh {}",
         MeshLib::globalIDString(MeshLib::MeshItemType::Cell), mesh.getName());
}

References addGlobalIDsToMesh(), MeshLib::Cell, MeshLib::Mesh::getName(), MeshLib::Mesh::getNumberOfElements(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), MeshLib::globalIDString(), INFO(), and MeshLib::Node.

addGlobalIDsToMesh() [2/2]

void addGlobalIDsToMesh	(	MeshLib::Properties &	mesh_properties,
		MeshLib::MeshItemType const	mesh_item_type,
		std::size_t const	number_of_items )

Definition at line 19 of file PartitionMesh.cpp.

{
    if (!mesh_properties.existsPropertyVector<std::size_t>(
            MeshLib::globalIDString(mesh_item_type), mesh_item_type, 1))
    {
        auto* global_ids = mesh_properties.createNewPropertyVector<std::size_t>(
            MeshLib::globalIDString(mesh_item_type), mesh_item_type,
            number_of_items, 1);
        if (!global_ids)
        {
            OGS_FATAL("Could not create PropertyVector '{}'.",
                      MeshLib::globalIDString(mesh_item_type));
        }
        global_ids->assign(ranges::views::iota(0u, number_of_items));
    }
}

References MeshLib::PropertyVector< PROP_VAL_TYPE >::assign(), MeshLib::Properties::createNewPropertyVector(), MeshLib::Properties::existsPropertyVector(), MeshLib::globalIDString(), and OGS_FATAL.

Referenced by addGlobalIDsToMesh(), and main().

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 53 of file PartitionMesh.cpp.

{
    TCLAP::CmdLine cmd(
        "Partition a mesh for parallel computing."
        "The tasks of this tool are in twofold:\n"
        "1. Convert mesh file to the input file of the partitioning tool,\n"
        "2. Partition a mesh using the partitioning tool,\n"
        "\tcreate the mesh data of each partition,\n"
        "\trenumber the node indices of each partition,\n"
        "\tand output the results for parallel computing.\n"
        "Note: If this tool is installed as a system command,\n"
        "\tthe command must be run with its full path.\n\n"
        "OpenGeoSys-6 software, version " +
            GitInfoLib::GitInfo::ogs_version +
            ".\n"
            "Copyright (c) 2012-2026, OpenGeoSys Community "
            "(http://www.opengeosys.org)",
        ' ', GitInfoLib::GitInfo::ogs_version);
    TCLAP::ValueArg<std::string> mesh_input(
        "i", "mesh-input-file",
        "Input (.vtu). The name of the file containing the input mesh", true,
        "", "INPUT_FILE");
    cmd.add(mesh_input);
 
    TCLAP::ValueArg<std::string> metis_mesh_input(
        "x", "metis-mesh-input-file",
        "Input (.mesh). Base name (without .mesh extension) of the file "
        "containing the metis input mesh",
        false, "", "BASE_FILENAME_INPUT");
    cmd.add(metis_mesh_input);
 
    TCLAP::ValueArg<std::string> output_directory_arg(
        "o", "output", "Output. Directory name for the output files", false, "",
        "OUTPUT_PATH");
    cmd.add(output_directory_arg);
 
    TCLAP::ValueArg<int> nparts("n", "np",
                                "the number of partitions, "
                                "(min = 0)",
                                false, 2, "N_PARTS");
    cmd.add(nparts);
 
    TCLAP::SwitchArg ogs2metis_flag(
        "s", "ogs2metis",
        "Indicator to convert the ogs mesh file to METIS input file", cmd,
        false);
 
    TCLAP::SwitchArg exe_metis_flag(
        "m", "exe_metis", "Call mpmetis inside the programme via system().",
        false);
    cmd.add(exe_metis_flag);
 
    auto log_level_arg = BaseLib::makeLogLevelArg();
    cmd.add(log_level_arg);
 
    // All the remaining arguments are used as file names for boundary/subdomain
    // meshes.
    TCLAP::UnlabeledMultiArg<std::string> other_meshes_filenames_arg(
        "other_meshes_filenames", "mesh file names.", false, "file");
    cmd.add(other_meshes_filenames_arg);
 
    cmd.parse(argc, argv);
 
    BaseLib::MPI::Setup mpi_setup(argc, argv);
    BaseLib::initOGSLogger(log_level_arg.getValue());
 
    const auto output_directory = output_directory_arg.getValue();
    BaseLib::createOutputDirectory(output_directory);
 
    BaseLib::RunTime run_timer;
    run_timer.start();
    BaseLib::CPUTime CPU_timer;
    CPU_timer.start();
 
    const std::string input_file_name_wo_extension =
        BaseLib::dropFileExtension(mesh_input.getValue());
    std::unique_ptr<MeshLib::Mesh> mesh_ptr(
        MeshLib::IO::readMeshFromFile(input_file_name_wo_extension + ".vtu"));
    INFO("Mesh '{:s}' read: {:d} nodes, {:d} elements.",
         mesh_ptr->getName(),
         mesh_ptr->getNumberOfNodes(),
         mesh_ptr->getNumberOfElements());
 
    addGlobalIDsToMesh(*mesh_ptr);
 
    std::string const output_file_name_wo_extension = BaseLib::joinPaths(
        output_directory,
        BaseLib::extractBaseNameWithoutExtension(mesh_input.getValue()));
 
    if (ogs2metis_flag.getValue())
    {
        INFO("Write the mesh into METIS input file.");
        ApplicationUtils::writeMETIS(mesh_ptr->getElements(),
                                     output_file_name_wo_extension + ".mesh");
        INFO("Total runtime: {:g} s.", run_timer.elapsed());
        INFO("Total CPU time: {:g} s.", CPU_timer.elapsed());
 
        return EXIT_SUCCESS;
    }
 
    ApplicationUtils::NodeWiseMeshPartitioner mesh_partitioner(
        nparts.getValue(), std::move(mesh_ptr));
 
    const int num_partitions = nparts.getValue();
 
    if (num_partitions < 1)
    {
        OGS_FATAL("Number of partitions must be positive.");
    }
 
    if (num_partitions == 1)
    {
        OGS_FATAL(
            "Partitioning the mesh into one domain is unnecessary because OGS "
            "reads vtu mesh data directly when called with 'mpirun bin/ogs "
            "-np=1'.");
    }
 
    auto metis_mesh = output_file_name_wo_extension;
    if (metis_mesh_input.getValue() != "")
    {
        metis_mesh = metis_mesh_input.getValue();
    }
 
    // Execute mpmetis via system(...)
    if (exe_metis_flag.getValue())
    {
        INFO("METIS is running ...");
        const std::string exe_name = argv[0];
        const std::string exe_path = BaseLib::extractPath(exe_name);
        INFO("Path to mpmetis is: \n\t{:s}", exe_path);
 
        const std::string mpmetis_com =
            BaseLib::joinPaths(exe_path, "mpmetis") + " -gtype=nodal " + "\"" +
            metis_mesh + ".mesh" + "\" " + std::to_string(nparts.getValue());
 
        INFO("Running: {:s}", mpmetis_com);
        const int status = system(mpmetis_com.c_str());
        if (status != 0)
        {
            INFO("Failed in system calling.");
            INFO("Return value of system call {:d} ", status);
            return EXIT_FAILURE;
        }
    }
    mesh_partitioner.resetPartitionIdsForNodes(
        readMetisData(metis_mesh, num_partitions,
                      mesh_partitioner.mesh().getNumberOfNodes()));
 
    // Remove metis partitioning files only if metis was run internally.
    if (exe_metis_flag.getValue())
    {
        removeMetisPartitioningFiles(metis_mesh, num_partitions);
    }
 
    INFO("Partitioning the mesh in the node wise way ...");
    mesh_partitioner.partitionByMETIS();
 
    INFO("Partitioning other meshes according to the main mesh partitions.");
    for (auto const& filename : other_meshes_filenames_arg.getValue())
    {
        std::unique_ptr<MeshLib::Mesh> mesh(
            MeshLib::IO::readMeshFromFile(filename));
        INFO("Mesh '{:s}' from file '{:s}' read: {:d} nodes, {:d} elements.",
             mesh->getName(), filename, mesh->getNumberOfNodes(),
             mesh->getNumberOfElements());
 
        addGlobalIDsToMesh(*mesh);
 
        std::string const other_mesh_output_file_name_wo_extension =
            BaseLib::joinPaths(
                output_directory,
                BaseLib::extractBaseNameWithoutExtension(filename));
        auto partitions = mesh_partitioner.partitionOtherMesh(*mesh);
 
        auto partitioned_properties = partitionProperties(mesh, partitions);
        mesh_partitioner.renumberBulkIdsProperty(partitions,
                                                 partitioned_properties);
 
        mesh_partitioner.writeOtherMesh(
            other_mesh_output_file_name_wo_extension, partitions,
            partitioned_properties);
    }
 
    BaseLib::RunTime io_run_timer;
    io_run_timer.start();
    mesh_partitioner.write(output_file_name_wo_extension);
    INFO("Writing the partitions data into binary files took {:g} s",
         io_run_timer.elapsed());
 
    INFO("Total runtime: {:g} s.", run_timer.elapsed());
    INFO("Total CPU time: {:g} s.", CPU_timer.elapsed());
 
    return EXIT_SUCCESS;
}

References addGlobalIDsToMesh(), BaseLib::createOutputDirectory(), BaseLib::dropFileExtension(), BaseLib::CPUTime::elapsed(), BaseLib::RunTime::elapsed(), BaseLib::extractBaseNameWithoutExtension(), BaseLib::extractPath(), MeshLib::Mesh::getNumberOfNodes(), INFO(), BaseLib::initOGSLogger(), BaseLib::joinPaths(), BaseLib::makeLogLevelArg(), ApplicationUtils::NodeWiseMeshPartitioner::mesh(), OGS_FATAL, GitInfoLib::GitInfo::ogs_version, ApplicationUtils::NodeWiseMeshPartitioner::partitionByMETIS(), ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh(), ApplicationUtils::partitionProperties(), MeshLib::IO::readMeshFromFile(), ApplicationUtils::readMetisData(), ApplicationUtils::removeMetisPartitioningFiles(), ApplicationUtils::NodeWiseMeshPartitioner::renumberBulkIdsProperty(), ApplicationUtils::NodeWiseMeshPartitioner::resetPartitionIdsForNodes(), BaseLib::CPUTime::start(), BaseLib::RunTime::start(), ApplicationUtils::NodeWiseMeshPartitioner::write(), ApplicationUtils::writeMETIS(), and ApplicationUtils::NodeWiseMeshPartitioner::writeOtherMesh().