Mesh Oriented datABase  (version 5.5.1)
An array-based unstructured mesh library
moab::ReadTemplate Class Reference

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 ReaderIfacefactory (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

ReadUtilIfacereadMeshIface
 
InterfacembImpl
 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.

24  : mbImpl( impl ), fileName( NULL )
25 {
27 }

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

Referenced by factory().

◆ ~ReadTemplate()

ReadTemplate::~ReadTemplate ( )
virtual

Destructor.

Definition at line 29 of file ReadTemplate.cpp.

30 {
31  if( readMeshIface )
32  {
34  readMeshIface = 0;
35  }
36 }

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_setsNumber of sets to be read
start_vertexStarting vertex handle
num_vertsTotal number of vertices read from file
start_elemStarting element handle
num_elemsTotal number of elements read from file
read_entsRange storing all entities read from this file

Definition at line 208 of file ReadTemplate.cpp.

214 {
215  ErrorCode result = MB_SUCCESS;
216  EntityHandle this_set;
217 
218  for( int i = 0; i < num_sets; i++ )
219  {
220  // Create set
221  result = mbImpl->create_meshset( MESHSET_SET, this_set );MB_CHK_SET_ERR( result, fileName << ": Trouble creating set" );
222 
223  Range set_ents;
224  // Read/compute what's in this set; REMEMBER TO CONVERT THESE TO MOAB HANDLES
225 
226  // Add them to the set
227  result = mbImpl->add_entities( this_set, set_ents );MB_CHK_SET_ERR( result, fileName << ": Trouble putting entities in set" );
228 
229  // Add the new set to read_ents
230  read_ents.insert( this_set );
231  }
232 
233  return MB_SUCCESS;
234 }

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.

20 {
21  return new ReadTemplate( iface );
22 }

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_nameThe file to read.
file_setOptional 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_listAn optional struct pointer specifying the tags identifying entity sets to be read.
file_id_tagIf 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.

52 {
53  if( subset_list )
54  {
55  // See src/moab/ReaderIface.hpp, definition of SubsetList struct; this basically specifies
56  // an integer tag and tag values for sets to read on this proc, or a part number and total #
57  // parts for reading a trivial partition of entities
58  }
59 
60  // Save filename to member variable so we don't need to pass as an argument
61  // to called functions
62  fileName = filename;
63 
64  // Process options; see src/FileOptions.hpp for API for FileOptions class, and
65  // doc/metadata_info.doc for a description of various options used by some of the readers in
66  // MOAB
67  ErrorCode result = process_options( opts );MB_CHK_SET_ERR( result, fileName << ": problem reading options" );
68 
69  // Open file; filePtr is member of ReadTemplate, change to whatever mechanism is used to
70  // identify file
71  FILE* filePtr = fopen( fileName, "r" );
72  if( !filePtr )
73  {
74  MB_SET_ERR( MB_FILE_DOES_NOT_EXIST, fileName << ": fopen returned error" );
75  }
76 
77  // Read number of verts, elements, sets
78  long num_verts = 0, num_elems = 0, num_sets = 0;
79 
80  // read_ents keeps a running set of entities read from this file, including vertices, elements,
81  // and sets; these will get added to file_set (if input) at the end of the read
82  Range read_ents;
83 
84  // start_vertex is passed back so we know how to convert indices from the file into vertex
85  // handles; most of the time this is done by adding start_vertex to the (0-based) index; if the
86  // index is 1-based, you also need to subtract one; see read_elements for details
87  EntityHandle start_vertex;
88  result = read_vertices( num_verts, start_vertex, read_ents );
89  if( MB_SUCCESS != result )
90  {
91  fclose( filePtr );
92  return result;
93  }
94 
95  // Create/read elements; this template assumes that all elements are the same type, so can be
96  // read in a single call to read_elements, and kept track of with a single start_elem handle. If
97  // there are more entity types, might have to keep these start handles in an array/vector.
98  // start_elem is only really needed if you're reading sets later, and need to convert some
99  // file-based index to an entity handle
100  EntityHandle start_elem;
101  result = read_elements( num_elems, start_vertex, start_elem, read_ents );
102  if( MB_SUCCESS != result )
103  {
104  fclose( filePtr );
105  return result;
106  }
107 
108  // Read/create entity sets; typically these sets have some tag identifying what they're for, see
109  // doc/metadata_info.doc for examples of different kinds of sets and how they're marked
110  result = create_sets( num_sets, start_vertex, num_verts, start_elem, num_elems, read_ents );
111  if( MB_SUCCESS != result )
112  {
113  fclose( filePtr );
114  return result;
115  }
116 
117  // Finally, add all read_ents into the file set, if one was input
118  if( file_set && *file_set )
119  {
120  result = mbImpl->add_entities( *file_set, read_ents );
121  if( MB_SUCCESS != result )
122  {
123  fclose( filePtr );
124  return result;
125  }
126  }
127 
128  fclose( filePtr );
129 
130  return result;
131 }

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
optsOptions passed into this read

Definition at line 236 of file ReadTemplate.cpp.

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

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_elemsNumber of elements to be read
start_vertexStarting vertex handle; used to offset connectivity indices
start_elemStarting element handle; may be used later to offset set entities
read_entsRange storing all entities read from this file

Definition at line 157 of file ReadTemplate.cpp.

161 {
162  // Get the entity type being read
163  EntityType ent_type = MBHEX;
164 
165  // Get the number of vertices per entity
166  int verts_per_elem = 8;
167 
168  // Create the element sequence; passes back a pointer to the internal storage for connectivity
169  // and the starting entity handle
170  EntityHandle* conn_array;
171  ErrorCode result =
172  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" );
173 
174  // Read connectivity into conn_array directly
175  for( long i = 0; i < num_elems; i++ )
176  {
177  // Read connectivity
178  }
179 
180  // Convert file-based connectivity indices to vertex handles in-place; be careful, if indices
181  // are smaller than handles, need to do from the end of the list so we don't overwrite data
182  //
183  // Here, we assume indices are smaller than handles, just for demonstration; create an
184  // integer-type pointer to connectivity initialized to same start of connectivity array
185  int* ind_array = reinterpret_cast< int* >( conn_array );
186  // OFFSET is value of first vertex index in file; most files are 1-based, but some might be
187  // 0-based
188  int OFFSET = 1;
189  for( long i = num_elems * verts_per_elem - 1; i >= 0; i-- )
190  {
191  conn_array[i] = ind_array[i] + start_vertex + OFFSET;
192 
193  // This assert assumes last handle in read_ents is highest vertex handle in this file
194  assert( conn_array[i] >= start_vertex && conn_array[i] <= *read_ents.rbegin() );
195  }
196 
197  // Notify MOAB of the new elements
198  result = readMeshIface->update_adjacencies( start_elem, num_elems, verts_per_elem, conn_array );
199  if( MB_SUCCESS != result ) return result;
200 
201  // Add elements to read_ents
202  if( num_elems ) read_ents.insert( start_elem, start_elem + num_elems - 1 );
203 
204  return MB_SUCCESS;
205 }

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_nameThe file to read.
tag_nameThe tag for which to read values
tag_values_outOutput: The list of tag values.
subset_listAn 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_lengthThe length of the 'subset_list' array.

Implements moab::ReaderIface.

Definition at line 38 of file ReadTemplate.cpp.

43 {
44  return MB_NOT_IMPLEMENTED;
45 }

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_vertsNumber of vertices to be read
start_vertexStarting vertex handle; used later to offset connectivity indices
read_entsRange storing all entities read from this file

Definition at line 133 of file ReadTemplate.cpp.

134 {
135  // Allocate nodes; these are allocated in one shot, get contiguous handles starting with
136  // start_handle, and the reader is passed back double*'s pointing to MOAB's native storage for
137  // vertex coordinates for those verts
138  std::vector< double* > coord_arrays;
139  ErrorCode result = readMeshIface->get_node_coords( 3, num_verts, 1, start_vertex, coord_arrays );MB_CHK_SET_ERR( result, fileName << ": Trouble reading vertices" );
140 
141  // Fill in vertex coordinate arrays
142  double *x = coord_arrays[0], *y = coord_arrays[1], *z = coord_arrays[2];
143  for( long i = 0; i < num_verts; ++i )
144  {
145  // Read x/y/z; do something with them for now to avoid warning
146  if( x || y || z )
147  {
148  }
149  }
150 
151  if( num_verts ) read_ents.insert( start_vertex, start_vertex + num_verts - 1 );
152 
153  return result;
154 }

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: