partcheck.cpp

Go to the documentation of this file.

#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include "moab/ParallelComm.hpp"
#include "moab/Skinner.hpp"
#include "moab/CN.hpp"

#include <iostream>
#include <sstream>
#include <limits>
#include <string>
#include <ctime>

#include "moab_mpi.h"

const char PARTTAG[]           = "PARALLEL_PARTITION";
const char READ_DEL_OPT[]      = "READ_DELETE";
const char BCAST_DEL_OPT[]     = "BCAST_DELETE";
const char READ_PART_OPT[]     = "READ_PART";
const char* const DEFAULT_MODE = READ_PART_OPT;

const char USAGE[] = " [-v <n>] [-R] [-p <parttag>[=val]] [-D|-B|-P] <input_file>";

static void usage( const char* argv0 )
{
    std::cerr << "Usage: " << argv0 << USAGE << std::endl << "       " << argv0 << " -h" << std::endl;
    exit( 1 );
}

static const char* defstr( const char* mode )
{
    static const char s[] = " (default)";
    int len               = ( mode == DEFAULT_MODE ) ? 0 : sizeof( s ) - 1;
    return s + len;
}

static void help( const char* argv0 )
{
    std::cout << "Usage: " << argv0 << USAGE << std::endl
              << "  -v  : debug output level (DEBUG_IO option)" << std::endl
              << "  -R  : do not resolve shared entities" << std::endl
              << "  -p  : partition tag, with optional '=' value" << std::endl
              << "          (default = \"" << PARTTAG << "\")" << std::endl
              << "  -D  : read mode as \"" << READ_DEL_OPT << "\"" << defstr( READ_DEL_OPT ) << std::endl
              << "  -B  : read mode as \"" << BCAST_DEL_OPT << "\"" << defstr( READ_DEL_OPT ) << std::endl
              << "  -P  : read mode as \"" << READ_PART_OPT << "\"" << defstr( READ_PART_OPT ) << std::endl;
    exit( 0 );
}

using namespace moab;

int check_parallel_read( Interface& mb, ParallelComm* pcomm, bool shared_ents );

int main( int argc, char* argv[] )
{
    const char* read_mode_opt  = DEFAULT_MODE;
    const char* part_tag_opt   = PARTTAG;
    bool resolve_shared        = true;
    const char* input_file     = 0;
    const char* debug_flag_str = 0;
    bool no_more_flags         = false;

    MPI_Init( &argc, &argv );

    // process command line arguments

    for( int i = 1; i < argc; ++i )
    {
        if( !no_more_flags && argv[i][0] == '-' )
        {
            const char* opts = argv[i] + 1;
            for( int j = 0; opts[j]; ++j )
            {
                switch( opts[j] )
                {
                    case '-':
                        no_more_flags = true;
                        break;
                    case 'v':
                        if( ++i == argc ) usage( argv[0] );
                        debug_flag_str = argv[i];
                        break;
                    case 'R':
                        resolve_shared = false;
                        break;
                    case 'p':
                        if( ++i == argc ) usage( argv[0] );
                        part_tag_opt = argv[i];
                        break;
                    case 'D':
                        read_mode_opt = READ_DEL_OPT;
                        break;
                    case 'B':
                        read_mode_opt = BCAST_DEL_OPT;
                        break;
                    case 'P':
                        read_mode_opt = READ_PART_OPT;
                        break;
                    case 'h':
                        help( argv[0] );
                        break;
                    default:
                        usage( argv[0] );
                }
            }
        }
        else if( !input_file )
        {
            input_file = argv[i];
        }
        else
        {
            usage( argv[0] );
        }
    }

    if( !input_file )
    {
        std::cerr << argv[0] << ": no input file specified" << std::endl;
        usage( argv[0] );
    }

    // build options string

    std::ostringstream opts;
    opts << "PARALLEL=" << read_mode_opt;

    std::string part_opt( part_tag_opt );
    size_t p = part_opt.find_last_of( '=' );
    if( p == std::string::npos ) { opts << ";PARTITION=" << part_opt; }
    else
    {
        char* endptr = 0;
        long n       = strtol( part_opt.c_str() + p + 1, &endptr, 0 );
        if( *endptr || p == part_opt.size() - 1 )
        {
            std::cerr << "Warning: partition tag option contains an '=' followed "
                         "         by a non-integer value.  Assuming tag name is "
                         "         \""
                      << part_opt << "\"" << std::endl;
            opts << ";PARTITION=" << part_opt;
        }
        else
        {
            opts << ";PARTITION=" << part_opt.substr( 0, p );
            opts << ";PARTITION_VAL=" << n;
        }
    }

    if( resolve_shared ) { opts << ";PARALLEL_RESOLVE_SHARED_ENTS"; }

    if( debug_flag_str )
    {
        char* endptr = 0;
        long n       = strtol( debug_flag_str, &endptr, 0 );
        if( *endptr || n < 0 || !*debug_flag_str ) usage( argv[0] );
        opts << ";DEBUG_IO=" << n;
    }

    Core moab;
    Interface& mb       = moab;
    ParallelComm* pcomm = new ParallelComm( &mb, MPI_COMM_WORLD );
    if( pcomm->rank() == 0 )
        std::cout << "Loading file: \"" << input_file << "\" with options \"" << opts.str() << '"' << std::endl;
    opts << ";PARALLEL_COMM=" << pcomm->get_id();

    clock_t init_time = clock();
    ErrorCode rval    = mb.load_file( input_file, 0, opts.str().c_str() );
    if( MB_SUCCESS != rval )
    {
        std::cerr << input_file << " : file read failed (" << mb.get_error_string( rval ) << ")" << std::endl;
        return 1;
    }

    clock_t t = clock();
    double sec;
    if( t < init_time )
        sec =
            ( std::numeric_limits< clock_t >::max() - init_time ) / (double)CLOCKS_PER_SEC + t / (double)CLOCKS_PER_SEC;
    else
        sec = ( t - init_time ) / (double)CLOCKS_PER_SEC;
    double allsec;
    MPI_Reduce( &sec, &allsec, 1, MPI_DOUBLE, MPI_MAX, 0, pcomm->comm() );
    if( pcomm->rank() == 0 ) { std::cout << "Read completed in " << allsec << " seconds" << std::endl; }

    int result = check_parallel_read( mb, pcomm, resolve_shared );

    if( MB_SUCCESS != pcomm->check_all_shared_handles( false ) ) ++result;

    MPI_Finalize();
    return result;
}

int check_parallel_read( Interface& mb, ParallelComm* pcomm, bool /*shared_ents*/ )
{
    int error_count = 0;

    const Range& parts = pcomm->partition_sets();
    if( parts.empty() ) std::cout << "No parts for process " << pcomm->rank() << std::endl;

    // get all entities from parts
    Range part_ents;
    for( Range::iterator i = parts.begin(); i != parts.end(); ++i )
        mb.get_entities_by_handle( *i, part_ents );

    int dim = 3;
    if( part_ents.empty() )
        std::cout << "No partitioned entities for process " << pcomm->rank() << std::endl;
    else
    {
        dim = CN::Dimension( mb.type_from_handle( part_ents.back() ) );
        if( !part_ents.all_of_dimension( dim ) )
            std::cout << "Partitioned ents of mixed dimension for process " << pcomm->rank() << std::endl;
    }

    Range all_ents;
    mb.get_entities_by_dimension( 0, dim, all_ents );
    if( !subtract( all_ents, part_ents ).empty() )
    {
        std::cerr << "Process " << pcomm->rank() << " has entities of dimension " << dim
                  << " that are not contained in any part" << std::endl;
        ++error_count;
    }

    if( dim == 0 )
    {
        std::cout << "Skipping further tests because mesh is vertex-partitioned" << std::endl;
        return error_count;
    }

    Range part_verts;
    mb.get_connectivity( part_ents, part_verts );
    Range all_verts;
    mb.get_entities_by_dimension( 0, 0, all_verts );
    if( !subtract( all_verts, part_verts ).empty() )
    {
        std::cerr << "Process " << pcomm->rank() << " has vertices "
                  << " that are not contained in any partitioned element" << std::endl;
        ++error_count;
    }

    // if (!shared_ents) {
    //  std::cout << "Skipping further tests because shared entities were not resolved" <<
    //  std::endl; return error_count;
    //}

    return error_count;
}