ReadWriteTest.cpp File Reference

#include "moab/Core.hpp"
#include <iostream>
#include <chrono>
#include <string>
#include <memory>
#include <cstdlib>

Include dependency graph for ReadWriteTest.cpp:

Go to the source code of this file.

Classes
struct	anonymous_namespace{ReadWriteTest.cpp}::Config

Namespaces
	anonymous_namespace{ReadWriteTest.cpp}

Functions
void	anonymous_namespace{ReadWriteTest.cpp}::print_usage (const char *program_name)
Config	anonymous_namespace{ReadWriteTest.cpp}::parse_arguments (int argc, char **argv)
void	anonymous_namespace{ReadWriteTest.cpp}::print_config (const Config &config, int rank, int nprocs)
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Examples

ReadWriteTest.cpp.

Definition at line 141 of file ReadWriteTest.cpp.

{
    // Initialize MPI
    int mpi_initialized = 0;
    MPI_Initialized( &mpi_initialized );
    if( !mpi_initialized )
    {
        MPI_Init( &argc, &argv );
    }
 
    int rank   = 0;
    int nprocs = 1;
    MPI_Comm_rank( MPI_COMM_WORLD, &rank );
    MPI_Comm_size( MPI_COMM_WORLD, &nprocs );
 
    try
    {
        // Parse command line arguments
        Config config = parse_arguments( argc, argv );
        if( rank == 0 )
        {
            print_config( config, rank, nprocs );
        }
 
        // Create MOAB instance with smart pointer for automatic cleanup
        auto moab = std::make_unique< Core >();
        if( !moab )
        {
            std::cerr << "Error: Failed to create MOAB instance" << std::endl;
            MPI_Abort( MPI_COMM_WORLD, 1 );
        }
 
        // Create parallel communication interface
        auto pcomm = std::make_unique< ParallelComm >( moab.get(), MPI_COMM_WORLD );
 
        // Create a mesh set to store the loaded mesh
        EntityHandle mesh_set;
        MB_CHK_ERR( moab->create_meshset( moab::MESHSET_SET, mesh_set ) );
 
        // Time the read operation
        auto read_start = std::chrono::high_resolution_clock::now();
 
        if( rank == 0 )
        {
            std::cout << "Reading mesh file..." << std::endl;
        }
 
        // Read the mesh file
        MB_CHK_SET_ERR( moab->load_file( config.input_file.c_str(), &mesh_set, config.read_opts.c_str() ),
                        "Failed to read input file: " << config.input_file );
 
        auto read_end                                = std::chrono::high_resolution_clock::now();
        std::chrono::duration< double > read_elapsed = read_end - read_start;
 
        if( rank == 0 )
        {
            std::cout << "Read completed in " << read_elapsed.count() << " seconds" << std::endl;
            std::cout << "Writing mesh file..." << std::endl;
        }
 
        // Time the write operation
        auto write_start = std::chrono::high_resolution_clock::now();
 
        // Write the mesh file
        MB_CHK_SET_ERR( moab->write_file( config.output_file.c_str(), nullptr, config.write_opts.c_str(), &mesh_set,
                                          1 ),
                        "Failed to write output file: " << config.output_file );
 
        auto write_end                                = std::chrono::high_resolution_clock::now();
        std::chrono::duration< double > write_elapsed = write_end - write_start;
 
        if( rank == 0 )
        {
            std::cout << "Write completed in " << write_elapsed.count() << " seconds" << std::endl;
            std::cout << "\n=== Test completed successfully ===" << std::endl;
        }
 
        // Clean up
        pcomm.reset();
        moab.reset();
 
        // Only finalize MPI if we initialized it
        if( !mpi_initialized )
        {
            MPI_Finalize();
        }
 
        return 0;
    }
    catch( const std::exception& e )
    {
        std::cerr << "Error on rank " << rank << ": " << e.what() << std::endl;
        MPI_Abort( MPI_COMM_WORLD, 1 );
        return 1;
    }
    catch( ... )
    {
        std::cerr << "Unknown error occurred on rank " << rank << std::endl;
        MPI_Abort( MPI_COMM_WORLD, 1 );
        return 1;
    }
}

References MB_CHK_ERR, MB_CHK_SET_ERR, MESHSET_SET, anonymous_namespace{ReadWriteTest.cpp}::parse_arguments(), and anonymous_namespace{ReadWriteTest.cpp}::print_config().