Template for implementing new file readers in MOAB This class is a template for writing new file readers in MOAB. This shows how to efficiently create vertices and elements using the ReadUtilIface class, and to translate indices in connectivity lists into vertex handles created during the read. More...

#include <ReadTemplate.hpp>

Inheritance diagram for moab::ReadTemplate:

Collaboration diagram for moab::ReadTemplate:

Public Member Functions
ErrorCode	load_file (const char file_name, const EntityHandle file_set, const FileOptions &opts, const SubsetList subset_list=0, const Tag file_id_tag=0)
	Load mesh from a file. More...

ErrorCode	read_tag_values (const char file_name, const char tag_name, const FileOptions &opts, std::vector< int > &tag_values_out, const SubsetList *subset_list=0)
	Read tag values from a file. More...

	ReadTemplate (Interface *impl=NULL)
	Constructor. More...

virtual	~ReadTemplate ()
	Destructor. More...

Public Member Functions inherited from moab::ReaderIface
virtual	~ReaderIface ()

Static Public Member Functions
static ReaderIface *	factory (Interface *)
	factory method More...

Private Member Functions
ErrorCode	read_vertices (int num_verts, EntityHandle &start_vertex, Range &read_ents)
	Read vertex data and create vertices in MOAB database. More...

ErrorCode	read_elements (int num_elems, EntityHandle start_vertex, EntityHandle &start_elem, Range &read_ents)
	Read element data and create elements in MOAB database. More...

ErrorCode	create_sets (int num_sets, EntityHandle start_vertex, int num_verts, EntityHandle start_elem, int num_elems, Range &read_ents)
	Read entity set data and create/populate sets in MOAB database. More...

ErrorCode	process_options (const FileOptions &opts)
	Process options passed into the reader. More...

Private Attributes
ReadUtilIface *	readMeshIface

Interface *	mbImpl
	interface instance More...

const char *	fileName

Detailed Description

Template for implementing new file readers in MOAB This class is a template for writing new file readers in MOAB. This shows how to efficiently create vertices and elements using the ReadUtilIface class, and to translate indices in connectivity lists into vertex handles created during the read.

After writing the new reader class, you should also modify src/ReaderWriterSet.cpp, to register the new reader along with the file extensions that it reads. This will turn on automatic creating of this reader based on file extension, which is done in Core::serial_load_file.

Definition at line 23 of file ReadTemplate.hpp.

Constructor & Destructor Documentation

◆ ReadTemplate()

ReadTemplate::ReadTemplate ( Interface * impl = NULL )

Constructor.

Definition at line 24 of file ReadTemplate.cpp.

                                             : mbImpl( impl ), fileName( NULL )
 {
     mbImpl->query_interface( readMeshIface );
 }

References mbImpl, moab::Interface::query_interface(), and readMeshIface.

Referenced by factory().

◆ ~ReadTemplate()

ReadTemplate::~ReadTemplate ( )

virtual

Destructor.

Definition at line 29 of file ReadTemplate.cpp.

 {
     if( readMeshIface )
     {
         mbImpl->release_interface( readMeshIface );
         readMeshIface = 0;
     }
 }

References mbImpl, readMeshIface, and moab::Interface::release_interface().

Member Function Documentation

◆ create_sets()

ErrorCode ReadTemplate::create_sets	(	int	num_sets,
		EntityHandle	start_vertex,
		int	num_verts,
		EntityHandle	start_elem,
		int	num_elems,
		Range &	read_ents
	)

private

Read entity set data and create/populate sets in MOAB database.

Read/create sets.

Parameters

num_sets	Number of sets to be read
start_vertex	Starting vertex handle
num_verts	Total number of vertices read from file
start_elem	Starting element handle
num_elems	Total number of elements read from file
read_ents	Range storing all entities read from this file

Definition at line 208 of file ReadTemplate.cpp.

 {
     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;
 }

References moab::Interface::add_entities(), moab::Interface::create_meshset(), ErrorCode, fileName, moab::Range::insert(), MB_CHK_SET_ERR, MB_SUCCESS, mbImpl, and MESHSET_SET.

Referenced by load_file().

◆ factory()

ReaderIface * ReadTemplate::factory ( Interface * iface )

static

factory method

Definition at line 19 of file ReadTemplate.cpp.

 {
     return new ReadTemplate( iface );
 }

References iface, and ReadTemplate().

Referenced by moab::ReaderWriterSet::ReaderWriterSet().

◆ load_file()

ErrorCode ReadTemplate::load_file	(	const char *	file_name,
		const EntityHandle *	file_set,
		const FileOptions &	opts,
		const SubsetList *	subset_list = `0`,
		const Tag *	file_id_tag = `0`
	)

virtual

Load mesh from a file.

Method all readers must provide to import a mesh.

Parameters

file_name	The file to read.
file_set	Optional pointer to entity set representing file. If this is not NULL, reader may optionally tag the pointed-to set with format-specific meta-data.
subset_list	An optional struct pointer specifying the tags identifying entity sets to be read.
file_id_tag	If specified, reader should store for each entity it reads, a unique integer ID for this tag.

Author: Jason Kraftcheck

Implements moab::ReaderIface.

Definition at line 47 of file ReadTemplate.cpp.

 {
     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;
 }

References moab::Interface::add_entities(), create_sets(), ErrorCode, fileName, MB_CHK_SET_ERR, MB_FILE_DOES_NOT_EXIST, MB_SET_ERR, MB_SUCCESS, mbImpl, process_options(), read_elements(), and read_vertices().

◆ process_options()

ErrorCode ReadTemplate::process_options ( const FileOptions & opts )

private

Process options passed into the reader.

Parameters

opts	Options passed into this read

Definition at line 236 of file ReadTemplate.cpp.

 {
     // Mark all options seen, to avoid compile warning on unused variable
     opts.mark_all_seen();
     return MB_SUCCESS;
 }

References moab::FileOptions::mark_all_seen(), and MB_SUCCESS.

Referenced by load_file().

◆ read_elements()

ErrorCode ReadTemplate::read_elements	(	int	num_elems,
		EntityHandle	start_vertex,
		EntityHandle &	start_elem,
		Range &	read_ents
	)

private

Read element data and create elements in MOAB database.

Read/create elements.

Parameters

num_elems	Number of elements to be read
start_vertex	Starting vertex handle; used to offset connectivity indices
start_elem	Starting element handle; may be used later to offset set entities
read_ents	Range storing all entities read from this file

Definition at line 157 of file ReadTemplate.cpp.

 {
     // 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;
 }

References ErrorCode, fileName, moab::ReadUtilIface::get_element_connect(), moab::Range::insert(), MB_CHK_SET_ERR, MB_SUCCESS, MBHEX, moab::Range::rbegin(), readMeshIface, and moab::ReadUtilIface::update_adjacencies().

Referenced by load_file().

◆ read_tag_values()

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 = `0`
	)

virtual

Read tag values from a file.

Read the list if all integer tag values from the file for a tag that is a single integer value per entity.

Parameters

file_name	The file to read.
tag_name	The tag for which to read values
tag_values_out	Output: The list of tag values.
subset_list	An array of tag name and value sets specifying the subset of the file to read. If multiple tags are specified, the sets that match all tags (intersection) should be read.
subset_list_length	The length of the 'subset_list' array.

Implements moab::ReaderIface.

Definition at line 38 of file ReadTemplate.cpp.

 {
     return MB_NOT_IMPLEMENTED;
 }

References MB_NOT_IMPLEMENTED.

◆ read_vertices()

ErrorCode ReadTemplate::read_vertices	(	int	num_verts,
		EntityHandle &	start_vertex,
		Range &	read_ents
	)

private

Read vertex data and create vertices in MOAB database.

Parameters

num_verts	Number of vertices to be read
start_vertex	Starting vertex handle; used later to offset connectivity indices
read_ents	Range storing all entities read from this file

Definition at line 133 of file ReadTemplate.cpp.

 {
     // 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;
 }

References ErrorCode, fileName, moab::ReadUtilIface::get_node_coords(), moab::Range::insert(), MB_CHK_SET_ERR, and readMeshIface.

Referenced by load_file().

Member Data Documentation

◆ fileName

const char* moab::ReadTemplate::fileName

private

Definition at line 89 of file ReadTemplate.hpp.

Referenced by create_sets(), load_file(), read_elements(), and read_vertices().

◆ mbImpl

Interface* moab::ReadTemplate::mbImpl

private

interface instance

Definition at line 87 of file ReadTemplate.hpp.

Referenced by create_sets(), load_file(), ReadTemplate(), and ~ReadTemplate().

◆ readMeshIface

ReadUtilIface* moab::ReadTemplate::readMeshIface

private

Definition at line 84 of file ReadTemplate.hpp.

Referenced by read_elements(), read_vertices(), ReadTemplate(), and ~ReadTemplate().

The documentation for this class was generated from the following files:

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ReadTemplate()

◆ ~ReadTemplate()

Member Function Documentation

◆ create_sets()

◆ factory()

◆ load_file()

◆ process_options()

◆ read_elements()

◆ read_tag_values()

◆ read_vertices()

Member Data Documentation

◆ fileName

◆ mbImpl

◆ readMeshIface