ReadTemplate.cpp

Go to the documentation of this file.

/**
 * \class ReadTemplate
 * \brief Template for writing a new reader in MOAB
 *
 */
 
#include "ReadTemplate.hpp"
#include "moab/Interface.hpp"
#include "moab/ReadUtilIface.hpp"
#include "moab/Range.hpp"
#include "moab/FileOptions.hpp"
 
#include <cstdio>
#include <cassert>
 
namespace moab
{
 
ReaderIface* ReadTemplate::factory( Interface* iface )
{
    return new ReadTemplate( iface );
}
 
ReadTemplate::ReadTemplate( Interface* impl ) : mbImpl( impl ), fileName( NULL )
{
    mbImpl->query_interface( readMeshIface );
}
 
ReadTemplate::~ReadTemplate()
{
    if( readMeshIface )
    {
        mbImpl->release_interface( readMeshIface );
        readMeshIface = 0;
    }
}
 
ErrorCode ReadTemplate::read_tag_values( const char* /* file_name */,
                                         const char* /* tag_name */,
                                         const FileOptions& /* opts */,
                                         std::vector< int >& /* tag_values_out */,
                                         const SubsetList* /* subset_list */ )
{
    return MB_NOT_IMPLEMENTED;
}
 
ErrorCode ReadTemplate::load_file( const char* filename,
                                   const EntityHandle* file_set,
                                   const FileOptions& opts,
                                   const ReaderIface::SubsetList* subset_list,
                                   const Tag* /*file_id_tag*/ )
{
    if( subset_list )
    {
        // See src/moab/ReaderIface.hpp, definition of SubsetList struct; this basically specifies
        // an integer tag and tag values for sets to read on this proc, or a part number and total #
        // parts for reading a trivial partition of entities
    }
 
    // Save filename to member variable so we don't need to pass as an argument
    // to called functions
    fileName = filename;
 
    // Process options; see src/FileOptions.hpp for API for FileOptions class, and
    // doc/metadata_info.doc for a description of various options used by some of the readers in
    // MOAB
    ErrorCode result = process_options( opts );
    MB_CHK_SET_ERR( result, fileName << ": problem reading options" );
 
    // Open file; filePtr is member of ReadTemplate, change to whatever mechanism is used to
    // identify file
    FILE* filePtr = fopen( fileName, "r" );
    if( !filePtr )
    {
        MB_SET_ERR( MB_FILE_DOES_NOT_EXIST, fileName << ": fopen returned error" );
    }
 
    // Read number of verts, elements, sets
    long num_verts = 0, num_elems = 0, num_sets = 0;
 
    // read_ents keeps a running set of entities read from this file, including vertices, elements,
    // and sets; these will get added to file_set (if input) at the end of the read
    Range read_ents;
 
    // start_vertex is passed back so we know how to convert indices from the file into vertex
    // handles; most of the time this is done by adding start_vertex to the (0-based) index; if the
    // index is 1-based, you also need to subtract one; see read_elements for details
    EntityHandle start_vertex;
    result = read_vertices( num_verts, start_vertex, read_ents );
    if( MB_SUCCESS != result )
    {
        fclose( filePtr );
        return result;
    }
 
    // Create/read elements; this template assumes that all elements are the same type, so can be
    // read in a single call to read_elements, and kept track of with a single start_elem handle. If
    // there are more entity types, might have to keep these start handles in an array/vector.
    // start_elem is only really needed if you're reading sets later, and need to convert some
    // file-based index to an entity handle
    EntityHandle start_elem;
    result = read_elements( num_elems, start_vertex, start_elem, read_ents );
    if( MB_SUCCESS != result )
    {
        fclose( filePtr );
        return result;
    }
 
    // Read/create entity sets; typically these sets have some tag identifying what they're for, see
    // doc/metadata_info.doc for examples of different kinds of sets and how they're marked
    result = create_sets( num_sets, start_vertex, num_verts, start_elem, num_elems, read_ents );
    if( MB_SUCCESS != result )
    {
        fclose( filePtr );
        return result;
    }
 
    // Finally, add all read_ents into the file set, if one was input
    if( file_set && *file_set )
    {
        result = mbImpl->add_entities( *file_set, read_ents );
        if( MB_SUCCESS != result )
        {
            fclose( filePtr );
            return result;
        }
    }
 
    fclose( filePtr );
 
    return result;
}
 
ErrorCode ReadTemplate::read_vertices( int num_verts, EntityHandle& start_vertex, Range& read_ents )
{
    // Allocate nodes; these are allocated in one shot, get contiguous handles starting with
    // start_handle, and the reader is passed back double*'s pointing to MOAB's native storage for
    // vertex coordinates for those verts
    std::vector< double* > coord_arrays;
    ErrorCode result = readMeshIface->get_node_coords( 3, num_verts, 1, start_vertex, coord_arrays );
    MB_CHK_SET_ERR( result, fileName << ": Trouble reading vertices" );
 
    // Fill in vertex coordinate arrays
    double *x = coord_arrays[0], *y = coord_arrays[1], *z = coord_arrays[2];
    for( long i = 0; i < num_verts; ++i )
    {
        // Read x/y/z; do something with them for now to avoid warning
        if( x || y || z )
        {
        }
    }
 
    if( num_verts ) read_ents.insert( start_vertex, start_vertex + num_verts - 1 );
 
    return result;
}
 
//! Read/create elements
ErrorCode ReadTemplate::read_elements( int num_elems,
                                       EntityHandle start_vertex,
                                       EntityHandle& start_elem,
                                       Range& read_ents )
{
    // Get the entity type being read
    EntityType ent_type = MBHEX;
 
    // Get the number of vertices per entity
    int verts_per_elem = 8;
 
    // Create the element sequence; passes back a pointer to the internal storage for connectivity
    // and the starting entity handle
    EntityHandle* conn_array;
    ErrorCode result =
        readMeshIface->get_element_connect( num_elems, verts_per_elem, ent_type, 1, start_elem, conn_array );
    MB_CHK_SET_ERR( result, fileName << ": Trouble reading elements" );
 
    // Read connectivity into conn_array directly
    for( long i = 0; i < num_elems; i++ )
    {
        // Read connectivity
    }
 
    // Convert file-based connectivity indices to vertex handles in-place; be careful, if indices
    // are smaller than handles, need to do from the end of the list so we don't overwrite data
    //
    // Here, we assume indices are smaller than handles, just for demonstration; create an
    // integer-type pointer to connectivity initialized to same start of connectivity array
    int* ind_array = reinterpret_cast< int* >( conn_array );
    // OFFSET is value of first vertex index in file; most files are 1-based, but some might be
    // 0-based
    int OFFSET = 1;
    for( long i = num_elems * verts_per_elem - 1; i >= 0; i-- )
    {
        conn_array[i] = ind_array[i] + start_vertex + OFFSET;
 
        // This assert assumes last handle in read_ents is highest vertex handle in this file
        assert( conn_array[i] >= start_vertex && conn_array[i] <= *read_ents.rbegin() );
    }
 
    // Notify MOAB of the new elements
    result = readMeshIface->update_adjacencies( start_elem, num_elems, verts_per_elem, conn_array );
    if( MB_SUCCESS != result ) return result;
 
    // Add elements to read_ents
    if( num_elems ) read_ents.insert( start_elem, start_elem + num_elems - 1 );
 
    return MB_SUCCESS;
}
 
//! Read/create sets
ErrorCode ReadTemplate::create_sets( int num_sets,
                                     EntityHandle /*start_vertex*/,
                                     int /*num_verts*/,
                                     EntityHandle /*start_elem*/,
                                     int /*num_elems*/,
                                     Range& read_ents )
{
    ErrorCode result = MB_SUCCESS;
    EntityHandle this_set;
 
    for( int i = 0; i < num_sets; i++ )
    {
        // Create set
        result = mbImpl->create_meshset( MESHSET_SET, this_set );
        MB_CHK_SET_ERR( result, fileName << ": Trouble creating set" );
 
        Range set_ents;
        // Read/compute what's in this set; REMEMBER TO CONVERT THESE TO MOAB HANDLES
 
        // Add them to the set
        result = mbImpl->add_entities( this_set, set_ents );
        MB_CHK_SET_ERR( result, fileName << ": Trouble putting entities in set" );
 
        // Add the new set to read_ents
        read_ents.insert( this_set );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadTemplate::process_options( const FileOptions& opts )
{
    // Mark all options seen, to avoid compile warning on unused variable
    opts.mark_all_seen();
    return MB_SUCCESS;
}
 
}  // namespace moab