io.hpp

Go to the documentation of this file.

#ifndef GET_FILE_OPTIONS_H
#define GET_FILE_OPTIONS_H

#include "moab/Core.hpp"

#include <iostream>

namespace moab
{
namespace point_locator
{
    namespace io
    {

        template < typename String        = std::string,
                   typename String_vector = std::vector< std::string >,
                   typename Char_vector   = std::vector< const char* > >
        class File_options
        {
          public:
            File_options()
                : meshFiles(), interpTag(), gNormTag(), ssNormTag(), readOpts(), outFile(), writeOpts(), dbgFile(),
                  ssTagNames(), ssTagValues(), help( true )
            {
            }
            String_vector meshFiles;
            String interpTag;
            String gNormTag;
            String ssNormTag;
            String readOpts;
            String outFile;
            String writeOpts;
            String dbgFile;
            Char_vector ssTagNames;
            Char_vector ssTagValues;
            bool help;
        };

        // Check first character for a '-'.
        // Return true if one is found.  False otherwise.
        bool check_for_flag( const char* str )
        {
            if( str[0] == '-' )
                return true;
            else
                return false;
        }

        // New get_file_options() function with added possibilities for mbcoupler_test.
        ErrorCode get_file_options( int argc,
                                    char** argv,
                                    std::vector< std::string >& meshFiles,
                                    std::string& interpTag,
                                    std::string& gNormTag,
                                    std::string& ssNormTag,
                                    std::vector< const char* >& ssTagNames,
                                    std::vector< const char* >& ssTagValues,
                                    std::string& readOpts,
                                    std::string& outFile,
                                    std::string& writeOpts,
                                    std::string& dbgFile,
                                    bool& help )
        {
            // Initialize some of the outputs to null values indicating not present
            // in the argument list.
            gNormTag                   = "";
            ssNormTag                  = "";
            readOpts                   = "PARALLEL=READ_PART;PARTITION=PARALLEL_PARTITION;PARTITION_DISTRIBUTE;"
                                         "PARALLEL_RESOLVE_SHARED_ENTS;PARALLEL_GHOSTS=3.0.1;CPUTIME";
            outFile                    = "";
            writeOpts                  = "PARALLEL=WRITE_PART;CPUTIME";
            dbgFile                    = "";
            std::string defaultDbgFile = argv[0];  // The executable name will be the default debug output file.

            // These will indicate if we've gotten our required parameters at the end of parsing.
            bool haveMeshes    = false;
            bool haveInterpTag = false;

            // Loop over the values in argv pulling out an parsing each one
            int npos = 1;

            if( argc > 1 && argv[1] == std::string( "-h" ) )
            {
                help = true;
                return MB_SUCCESS;
            }

            while( npos < argc )
            {
                if( argv[npos] == std::string( "-meshes" ) )
                {
                    // Parse out the mesh filenames
                    npos++;
                    int numFiles = 2;
                    meshFiles.resize( numFiles );
                    for( int i = 0; i < numFiles; i++ )
                    {
                        if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
                            meshFiles[i] = argv[npos++];
                        else
                        {
                            std::cerr << "    ERROR - missing correct number of mesh filenames" << std::endl;
                            return MB_FAILURE;
                        }
                    }

                    haveMeshes = true;
                }
                else if( argv[npos] == std::string( "-itag" ) )
                {
                    // Parse out the interpolation tag
                    npos++;
                    if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
                        interpTag = argv[npos++];
                    else
                    {
                        std::cerr << "    ERROR - missing <interp_tag>" << std::endl;
                        return MB_FAILURE;
                    }

                    haveInterpTag = true;
                }
                else if( argv[npos] == std::string( "-gnorm" ) )
                {
                    // Parse out the global normalization tag
                    npos++;
                    if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
                        gNormTag = argv[npos++];
                    else
                    {
                        std::cerr << "    ERROR - missing <gnorm_tag>" << std::endl;
                        return MB_FAILURE;
                    }
                }
                else if( argv[npos] == std::string( "-ssnorm" ) )
                {
                    // Parse out the subset normalization tag and selection criteria
                    npos++;
                    if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
                        ssNormTag = argv[npos++];
                    else
                    {
                        std::cerr << "    ERROR - missing <ssnorm_tag>" << std::endl;
                        return MB_FAILURE;
                    }

                    if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
                    {
                        char* opts         = argv[npos++];
                        char sep1[1]       = { ';' };
                        char sep2[1]       = { '=' };
                        bool end_vals_seen = false;
                        std::vector< char* > tmpTagOpts;

                        // first get the options
                        for( char* i = strtok( opts, sep1 ); i; i = strtok( 0, sep1 ) )
                        {
                            tmpTagOpts.push_back( i );
                        }

                        // parse out the name and val or just name.
                        for( unsigned int j = 0; j < tmpTagOpts.size(); j++ )
                        {
                            char* e = strtok( tmpTagOpts[j], sep2 );
                            ssTagNames.push_back( e );
                            e = strtok( 0, sep2 );
                            if( e != NULL )
                            {
                                // We have a value
                                if( end_vals_seen )
                                {
                                    // ERROR we should not have a value after none are seen
                                    std::cerr << "    ERROR - new value seen after end of values "
                                                 "in <ssnorm_selection>"
                                              << std::endl;
                                    return MB_FAILURE;
                                }
                                // Otherwise get the value string from e and convert it to an int
                                int* valp = new int;
                                *valp     = atoi( e );
                                ssTagValues.push_back( (const char*)valp );
                            }
                            else
                            {
                                // Otherwise there is no '=' so push a null on the list
                                end_vals_seen = true;
                                ssTagValues.push_back( (const char*)0 );
                            }
                        }
                    }
                    else
                    {
                        std::cerr << "    ERROR - missing <ssnorm_selection>" << std::endl;
                        return MB_FAILURE;
                    }
                }
                else if( argv[npos] == std::string( "-ropts" ) )
                {
                    // Parse out the mesh file read options
                    npos++;
                    if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
                        readOpts = argv[npos++];
                    else
                    {
                        std::cerr << "    ERROR - missing <roptions>" << std::endl;
                        return MB_FAILURE;
                    }
                }
                else if( argv[npos] == std::string( "-outfile" ) )
                {
                    // Parse out the output file name
                    npos++;
                    if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
                        outFile = argv[npos++];
                    else
                    {
                        std::cerr << "    ERROR - missing <out_file>" << std::endl;
                        return MB_FAILURE;
                    }
                }
                else if( argv[npos] == std::string( "-wopts" ) )
                {
                    // Parse out the output file write options
                    npos++;
                    if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
                        writeOpts = argv[npos++];
                    else
                    {
                        std::cerr << "    ERROR - missing <woptions>" << std::endl;
                        return MB_FAILURE;
                    }
                }
                else if( argv[npos] == std::string( "-dbgout" ) )
                {
                    // Parse out the debug output file name.
                    // If no name then use the default.
                    npos++;
                    if( ( npos < argc ) && ( !check_for_flag( argv[npos] ) ) )
                        dbgFile = argv[npos++];
                    else
                        dbgFile = defaultDbgFile;
                }
                else
                {
                    // Unrecognized parameter.  Skip it and move along.
                    std::cerr << "    ERROR - Unrecognized parameter:" << argv[npos] << std::endl;
                    std::cerr << "            Skipping..." << std::endl;
                    npos++;
                }
            }

            if( !haveMeshes )
            {
                meshFiles.resize( 2 );
                meshFiles[0] = std::string( TestDir + "/64bricks_1khex.h5m" );
                meshFiles[1] = std::string( TestDir + "/64bricks_12ktet.h5m" );
                std::cout << "Mesh files not entered; using default files " << meshFiles[0] << " and " << meshFiles[1]
                          << std::endl;
            }

            if( !haveInterpTag )
            {
                interpTag = "vertex_field";
                std::cout << "Interpolation field name not given, using default of " << interpTag << std::endl;
            }

#ifdef MOAB_HAVE_HDF5
            if( 1 == argc )
            {
                std::cout << "No arguments given; using output file dum.h5m." << std::endl;
                outFile = "dum.h5m";
            }
#endif

            return MB_SUCCESS;
        }

        // "generic" get_file_options
        template < typename Options >
        ErrorCode get_file_options( int argc, char** argv, Options& o )
        {
            return get_file_options( argc, argv, o.meshFiles, o.interpTag, o.gNormTag, o.ssNormTag, o.ssTagNames,
                                     o.ssTagValues, o.readOpts, o.outFile, o.writeOpts, o.dbgFile, o.help );
        }

    }  // namespace io
}  // namespace point_locator
}  // namespace moab

#endif  // GET_FILE_OPTIONS_H