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

#include <WriteUtil.hpp>

+ Inheritance diagram for moab::WriteUtil:
+ Collaboration diagram for moab::WriteUtil:

Public Member Functions

 WriteUtil (Core *mdb)
 Constructor takes Core pointer. More...
 
 ~WriteUtil ()
 Destructor. More...
 
virtual ErrorCode check_doesnt_exist (const char *file_name)
 Check if the specified file already exists. Returns MB_SUCCESS if file does not exist, MB_ALREADY_ALLOCATED if file does exist, or MB_FAILURE for some other error condition. More...
 
virtual ErrorCode gather_entities (Range &all_ents, const EntityHandle *ent_sets=NULL, const int num_sets=0)
 Gather all entities in the mesh, or in the sets specified. More...
 
ErrorCode get_node_coords (const int num_arrays, const int num_nodes, const Range &entities, Tag node_id_tag, const int start_node_id, std::vector< double * > &arrays)
 Gets arrays for coordinate data from the MB. More...
 
ErrorCode get_node_coords (const int which_array, Range::const_iterator begin, const Range::const_iterator &end, const size_t output_size, double *const output_array)
 
ErrorCode get_element_connect (const int num_elements, const int verts_per_element, Tag node_id_tag, const Range &entities, Tag element_id_tag, int start_element_id, int *array, bool add_sizes=false)
 
ErrorCode get_element_connect (Range::const_iterator begin, const Range::const_iterator &end, const int vertices_per_elem, Tag node_id_tag, const size_t array_size, int *const element_array, bool add_sizes=false)
 
virtual ErrorCode get_element_connect (Range::const_iterator begin, const Range::const_iterator &end, const int vertices_per_elem, const size_t array_size, EntityHandle *const element_array)
 
virtual ErrorCode get_poly_connect_size (Range::const_iterator begin, const Range::const_iterator &end, int &connectivity_size)
 
virtual ErrorCode get_poly_connect (Range::const_iterator &iter, const Range::const_iterator &end, const Tag node_id_tag, size_t &handle_array_len, int *const handle_array, size_t &index_array_len, int *const index_array, int &index_offset)
 
ErrorCode gather_nodes_from_elements (const Range &elements, const Tag node_bit_mark_tag, Range &nodes)
 Get a set of nodes that represent a set of elements. More...
 
ErrorCode assign_ids (Range &elements, Tag id_tag, const int start_id)
 Assign ids to input elements starting with start_id, written to id_tag if zero, assigns to GLOBAL_ID_TAG_NAME. More...
 
ErrorCode get_adjacencies (EntityHandle entity, Tag id_tag, std::vector< int > &adj)
 
ErrorCode get_adjacencies (EntityHandle entity, const EntityHandle *&adj_array, int &num_adj)
 
virtual ErrorCode get_tag_list (std::vector< Tag > &result_list, const Tag *user_tag_list=0, int user_tag_list_length=0, bool include_variable_length_tags=true)
 Get list of tags to write. More...
 
virtual ErrorCode get_entity_list_pointers (Range::const_iterator query_begin, Range::const_iterator query_end, EntityHandle const **output_pointer_array, EntityListType relation=CONTENTS, int *lengths=0, unsigned char *flags=0)
 
virtual ErrorCode get_entity_list_pointers (EntityHandle const *entities, int num_entities, EntityHandle const **output_pointer_array, EntityListType relation=CONTENTS, int *lengths=0, unsigned char *flags=0)
 
- Public Member Functions inherited from moab::WriteUtilIface
 WriteUtilIface ()
 Constructor. More...
 
virtual ~WriteUtilIface ()
 Destructor. More...
 

Private Attributes

CoremMB
 Pointer to the Core. More...
 

Additional Inherited Members

- Public Types inherited from moab::WriteUtilIface
enum  EntityListType { CONTENTS = 0 , CHILDREN = 1 , PARENTS = 2 , TOPOLOGICAL = 1 }
 
- Static Public Member Functions inherited from moab::WriteUtilIface
template<typename T >
static void reorder (const int *order, T *conn, int num_elem, int node_per_elem)
 Re-order outgoing element connectivity. More...
 

Detailed Description

Definition at line 30 of file WriteUtil.hpp.

Constructor & Destructor Documentation

◆ WriteUtil()

moab::WriteUtil::WriteUtil ( Core mdb)

Constructor takes Core pointer.

Definition at line 46 of file WriteUtil.cpp.

46 : WriteUtilIface(), mMB( mdb ) {}

◆ ~WriteUtil()

moab::WriteUtil::~WriteUtil ( )
inline

Destructor.

Definition at line 41 of file WriteUtil.hpp.

41 {}

Member Function Documentation

◆ assign_ids()

ErrorCode moab::WriteUtil::assign_ids ( Range elements,
Tag  id_tag,
const int  start_id 
)
virtual

Assign ids to input elements starting with start_id, written to id_tag if zero, assigns to GLOBAL_ID_TAG_NAME.

Implements moab::WriteUtilIface.

Definition at line 654 of file WriteUtil.cpp.

655 {
656  ErrorCode result;
657  if( 0 == id_tag )
658  {
659  // Get the global id tag
660  id_tag = mMB->globalId_tag();
661  }
662 
663  // Now assign the ids
664  int i;
665  Range::iterator rit;
666  ErrorCode tmp_result;
667  result = MB_SUCCESS;
668  for( i = start_id, rit = elements.begin(); rit != elements.end(); ++rit, i++ )
669  {
670  tmp_result = mMB->tag_set_data( id_tag, &( *rit ), 1, &i );
671  if( MB_SUCCESS != tmp_result ) result = tmp_result;
672  }
673 
674  return result;
675 }

References moab::Range::begin(), moab::Range::end(), ErrorCode, moab::Core::globalId_tag(), MB_SUCCESS, mMB, and moab::Core::tag_set_data().

◆ check_doesnt_exist()

ErrorCode moab::WriteUtil::check_doesnt_exist ( const char *  file_name)
virtual

Check if the specified file already exists. Returns MB_SUCCESS if file does not exist, MB_ALREADY_ALLOCATED if file does exist, or MB_FAILURE for some other error condition.

Implements moab::WriteUtilIface.

Definition at line 51 of file WriteUtil.cpp.

52 {
53  struct stat s;
54  if( 0 == stat( file_name, &s ) )
55  {
56  MB_SET_ERR( MB_ALREADY_ALLOCATED, file_name << ": file already exists" );
57  }
58  else if( errno == ENOENT )
59  return MB_SUCCESS;
60  else
61  return MB_FAILURE;
62 }

References MB_ALREADY_ALLOCATED, MB_SET_ERR, and MB_SUCCESS.

◆ gather_entities()

ErrorCode moab::WriteUtil::gather_entities ( Range all_ents,
const EntityHandle ent_sets = NULL,
const int  num_sets = 0 
)
virtual

Gather all entities in the mesh, or in the sets specified.

Parameters
all_entsrange in which entities are returned
ent_setsentity sets whose contents are to be gathered
num_setsnumber of sets in list

Implements moab::WriteUtilIface.

Definition at line 65 of file WriteUtil.cpp.

72 {
73  ErrorCode rval = MB_SUCCESS;
74  if( !ent_sets || num_sets == 0 )
75  {
76  rval = mMB->get_entities_by_handle( 0, all_ents );
77  }
78  else
79  {
80  for( int i = 0; i < num_sets; i++ )
81  {
82  ErrorCode tmp_rval = mMB->get_entities_by_handle( ent_sets[i], all_ents );
83  if( MB_SUCCESS != tmp_rval ) rval = tmp_rval;
84  }
85  }
86 
87  return rval;
88 }

References ErrorCode, moab::Core::get_entities_by_handle(), MB_SUCCESS, and mMB.

◆ gather_nodes_from_elements()

ErrorCode moab::WriteUtil::gather_nodes_from_elements ( const Range elements,
const Tag  node_bit_mark_tag,
Range nodes 
)
virtual

Get a set of nodes that represent a set of elements.

Implements moab::WriteUtilIface.

Definition at line 515 of file WriteUtil.cpp.

516 {
517  bool printed_warning = false;
518 
519  if( elements.empty() ) return MB_SUCCESS;
520 
521  if( TYPE_FROM_HANDLE( elements.front() ) <= MBVERTEX || TYPE_FROM_HANDLE( elements.back() ) >= MBENTITYSET )
522  return MB_TYPE_OUT_OF_RANGE;
523 
524  // See if we need to use our own marking tag
525  Tag exporting_nodes_tag = 0;
526  if( node_bit_mark_tag )
527  exporting_nodes_tag = node_bit_mark_tag;
528  else
529  {
530  mMB->tag_get_handle( "__MBWriteUtil::exporting_nodes", 1, MB_TYPE_BIT, exporting_nodes_tag, MB_TAG_CREAT );
531  }
532 
533  // The x,y,z tag handles we need
534  EntityHandle lower_bound = ~0, upper_bound = 0;
535 
536  std::vector< EntityHandle > tmp_conn;
537 
538  RangeSeqIntersectIter iter( mMB->sequence_manager() );
539  for( ErrorCode rval = iter.init( elements.begin(), elements.end() ); MB_FAILURE != rval; rval = iter.step() )
540  {
541  if( MB_ENTITY_NOT_FOUND == rval )
542  {
543  if( !printed_warning )
544  {
545  std::cerr << "Warning: ignoring invalid element handle(s) in gather_nodes_from_elements" << std::endl;
546  printed_warning = true;
547  }
548  continue;
549  }
550 
551  ElementSequence* seq = static_cast< ElementSequence* >( iter.get_sequence() );
552 
553  // Get the connectivity array
554  const EntityHandle* conn_array = seq->get_connectivity_array();
555 
556  // If unstructured mesh
557  if( conn_array && mMB->type_from_handle( iter.get_start_handle() ) != MBPOLYHEDRON )
558  {
559  assert( iter.get_start_handle() >= seq->start_handle() );
560  assert( iter.get_end_handle() <= seq->end_handle() );
561  const EntityHandle offset = iter.get_start_handle() - seq->start_handle();
562  const EntityHandle num_elem = iter.get_end_handle() - iter.get_start_handle() + 1;
563 
564  conn_array += offset * seq->nodes_per_element();
565  const EntityHandle num_node = num_elem * seq->nodes_per_element();
566 
567  // For each node
568  for( EntityHandle j = 0; j < num_node; j++ )
569  {
570  EntityHandle node = conn_array[j];
571  if( node < lower_bound ) lower_bound = node;
572  if( node > upper_bound ) upper_bound = node;
573  unsigned char bit = 0x1;
574  rval = mMB->tag_set_data( exporting_nodes_tag, &node, 1, &bit );
575  assert( MB_SUCCESS == rval );
576  if( MB_SUCCESS != rval ) return rval;
577  }
578  }
579  // Polyhedra
580  else if( conn_array && mMB->type_from_handle( iter.get_start_handle() ) == MBPOLYHEDRON )
581  {
582  assert( iter.get_start_handle() >= seq->start_handle() );
583  assert( iter.get_end_handle() <= seq->end_handle() );
584  const EntityHandle offset = iter.get_start_handle() - seq->start_handle();
585  const EntityHandle num_elem = iter.get_end_handle() - iter.get_start_handle() + 1;
586 
587  conn_array += offset * seq->nodes_per_element();
588  int num_face = num_elem * seq->nodes_per_element();
589 
590  // For each node
591  for( int j = 0; j < num_face; j++ )
592  {
593  const EntityHandle* face_conn = NULL;
594  int face_num_conn = 0;
595  rval = mMB->get_connectivity( conn_array[j], face_conn, face_num_conn, false );
596  if( MB_SUCCESS != rval ) return rval;
597  for( int k = 0; k < face_num_conn; k++ )
598  {
599  EntityHandle node = face_conn[k];
600  if( node < lower_bound ) lower_bound = node;
601  if( node > upper_bound ) upper_bound = node;
602  unsigned char bit = 0x1;
603  rval = mMB->tag_set_data( exporting_nodes_tag, &node, 1, &bit );
604  assert( MB_SUCCESS == rval );
605  if( MB_SUCCESS != rval ) return rval;
606  }
607  }
608  }
609  // Structured mesh
610  else
611  {
612  EntityHandle end_h = iter.get_end_handle() + 1;
613  for( EntityHandle h = iter.get_start_handle(); h < end_h; ++h )
614  {
615  tmp_conn.clear();
616  rval = seq->get_connectivity( h, tmp_conn, false );
617  if( MB_SUCCESS != rval )
618  {
619  if( node_bit_mark_tag == 0 ) mMB->tag_delete( exporting_nodes_tag );
620  return rval;
621  }
622 
623  // For each node
624  for( size_t j = 0; j < tmp_conn.size(); j++ )
625  {
626  EntityHandle node = tmp_conn[j];
627  if( node < lower_bound ) lower_bound = node;
628  if( node > upper_bound ) upper_bound = node;
629  unsigned char bit = 0x1;
630  mMB->tag_set_data( exporting_nodes_tag, &node, 1, &bit );
631  }
632  }
633  }
634  }
635 
636  // We can get a REALLY long loop if lower_bound is zero
637  assert( lower_bound != 0 );
638  // Gather up all the nodes
639  for( ; upper_bound >= lower_bound; --upper_bound )
640  {
641  unsigned char node_marked = 0;
642  mMB->tag_get_data( exporting_nodes_tag, &upper_bound, 1, &node_marked );
643  if( node_marked == 0x1 ) nodes.insert( upper_bound );
644  }
645 
646  // Clean up our own marking tag
647  if( node_bit_mark_tag == 0 ) mMB->tag_delete( exporting_nodes_tag );
648 
649  return MB_SUCCESS;
650 }

References moab::Range::back(), moab::Range::begin(), moab::Range::empty(), moab::Range::end(), moab::EntitySequence::end_handle(), ErrorCode, moab::Range::front(), moab::Core::get_connectivity(), moab::ElementSequence::get_connectivity(), moab::ElementSequence::get_connectivity_array(), moab::RangeSeqIntersectIter::get_end_handle(), moab::RangeSeqIntersectIter::get_sequence(), moab::RangeSeqIntersectIter::get_start_handle(), moab::RangeSeqIntersectIter::init(), moab::Range::insert(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TAG_CREAT, MB_TYPE_BIT, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, MBPOLYHEDRON, MBVERTEX, mMB, moab::ElementSequence::nodes_per_element(), moab::Core::sequence_manager(), moab::EntitySequence::start_handle(), moab::RangeSeqIntersectIter::step(), moab::Core::tag_delete(), moab::Core::tag_get_data(), moab::Core::tag_get_handle(), moab::Core::tag_set_data(), moab::Core::type_from_handle(), and moab::TYPE_FROM_HANDLE().

◆ get_adjacencies() [1/2]

ErrorCode moab::WriteUtil::get_adjacencies ( EntityHandle  entity,
const EntityHandle *&  adj_array,
int &  num_adj 
)
virtual

Implements moab::WriteUtilIface.

Definition at line 709 of file WriteUtil.cpp.

710 {
711  return mMB->a_entity_factory()->get_adjacencies( entity, adj_array, num_adj );
712 }

References moab::Core::a_entity_factory(), moab::AEntityFactory::get_adjacencies(), and mMB.

◆ get_adjacencies() [2/2]

ErrorCode moab::WriteUtil::get_adjacencies ( EntityHandle  entity,
Tag  id_tag,
std::vector< int > &  adj 
)
virtual

Get explicit adjacencies

Get explicit adjacences stored in database. Does not create any explicit adjacencies or search for implicit ones.

Parameters
entityThe entity to retrieve adjacencies for.
id_tagThe global ID tag
adjThe output list of global IDs of adjacent entities.

Implements moab::WriteUtilIface.

Definition at line 677 of file WriteUtil.cpp.

678 {
679  ErrorCode rval;
680  const EntityHandle* adj_array;
681  int num_adj, id;
682 
683  // Get handles of adjacent entities
684  rval = mMB->a_entity_factory()->get_adjacencies( entity, adj_array, num_adj );
685  if( MB_SUCCESS != rval )
686  {
687  adj.clear();
688  return rval;
689  }
690 
691  // Append IDs of adjacent entities -- skip meshsets
692  adj.resize( num_adj ); // Pre-allocate space
693  adj.clear(); // Clear used space
694 
695  const EntityHandle* const end = adj_array + num_adj;
696  for( const EntityHandle* iter = adj_array; iter != end; ++iter )
697  {
698  if( TYPE_FROM_HANDLE( *iter ) != MBENTITYSET )
699  {
700  rval = mMB->tag_get_data( id_tag, iter, 1, &id );
701  if( MB_SUCCESS != rval ) return rval;
702  adj.push_back( id );
703  }
704  }
705 
706  return MB_SUCCESS;
707 }

References moab::Core::a_entity_factory(), ErrorCode, moab::AEntityFactory::get_adjacencies(), MB_SUCCESS, MBENTITYSET, mMB, moab::Core::tag_get_data(), and moab::TYPE_FROM_HANDLE().

◆ get_element_connect() [1/3]

ErrorCode moab::WriteUtil::get_element_connect ( const int  num_elements,
const int  verts_per_element,
Tag  node_id_tag,
const Range entities,
Tag  element_id_tag,
int  start_element_id,
int *  array,
bool  add_sizes = false 
)
virtual

Get connectivity for elements

Get the connectivity list for a range of elements.

Parameters
num_elementsNumber of elements for which connectivity is needed
vertices_per_elemNumber of vertices to retrieve for each element.
node_id_tagA tag with integer values.
entitiesEntities being queried
element_id_tagIf non-zero, elements are tagged with an id starting at start_element_id
start_element_idStarting id value for element_id_tag
add_sizesIf true, writes size of connect array before connectivity in array

Implements moab::WriteUtilIface.

Definition at line 215 of file WriteUtil.cpp.

223 {
224  // Check the data we got
225  if( num_elements < 1 ) return MB_FAILURE;
226  if( verts_per_element < 1 ) return MB_FAILURE;
227  if( elements.empty() ) return MB_FAILURE;
228  if( !element_array ) return MB_FAILURE;
229 
230  Range::const_iterator range_iter = elements.begin();
231  Range::const_iterator range_iter_end = elements.end();
232 
233  TypeSequenceManager::iterator seq_iter, seq_iter_end;
234  EntityType current_type = TYPE_FROM_HANDLE( *range_iter );
235 
236  seq_iter = mMB->sequence_manager()->entity_map( current_type ).begin();
237  seq_iter_end = mMB->sequence_manager()->entity_map( current_type ).end();
238 
239  // Let's find the entity sequence which holds the first entity
240  TypeSequenceManager::iterator seq_iter_lookahead = seq_iter;
241  ++seq_iter_lookahead;
242  for( ; seq_iter_lookahead != seq_iter_end && ( *seq_iter_lookahead )->start_handle() < *range_iter; )
243  {
244  ++seq_iter;
245  ++seq_iter_lookahead;
246  }
247 
248  // A look ahead iterator
249  Range::const_iterator range_iter_lookahead = range_iter;
250 
251  // Our main loop
252  for( ; range_iter != range_iter_end && seq_iter != seq_iter_end; /* ++ is handled in loop*/ )
253  {
254  // Find a range that fits in the current entity sequence
255  for( ; range_iter_lookahead != range_iter_end && *range_iter_lookahead <= ( *seq_iter )->end_handle();
256  ++range_iter_lookahead )
257  {
258  }
259 
260  if( current_type != TYPE_FROM_HANDLE( *range_iter ) )
261  {
262  current_type = TYPE_FROM_HANDLE( *range_iter );
263  seq_iter = mMB->sequence_manager()->entity_map( current_type ).begin();
264  seq_iter_end = mMB->sequence_manager()->entity_map( current_type ).end();
265 
266  // Let's find the entity sequence which holds the first entity of this type
267  TypeSequenceManager::const_iterator seq_iter_lookahead2 = seq_iter;
268  ++seq_iter_lookahead2;
269  for( ; seq_iter_lookahead2 != seq_iter_end && ( *seq_iter_lookahead2 )->start_handle() < *range_iter; )
270  {
271  ++seq_iter;
272  ++seq_iter_lookahead2;
273  }
274  }
275 
276  int i = static_cast< ElementSequence* >( *seq_iter )->nodes_per_element();
277 
278  // Get the connectivity array
279  EntityHandle* conn_array = static_cast< ElementSequence* >( *seq_iter )->get_connectivity_array();
280 
281  EntityHandle start_handle = ( *seq_iter )->start_handle();
282 
283  for( Range::const_iterator tmp_iter = range_iter; tmp_iter != range_iter_lookahead; ++tmp_iter )
284  {
285  // Set the element id tag
286  mMB->tag_set_data( element_id_tag, &*tmp_iter, 1, &start_element_id );
287  ++start_element_id;
288 
289  if( add_sizes ) *element_array++ = i;
290 
291  // For each node
292  for( int j = 0; j < i; j++ )
293  {
294  EntityHandle node = *( conn_array + j + i * ( *tmp_iter - start_handle ) );
295  mMB->tag_get_data( node_id_tag, &node, 1, element_array );
296  element_array++;
297  }
298  }
299 
300  // Go to the next entity sequence
301  ++seq_iter;
302  // Start with the next entities
303  range_iter = range_iter_lookahead;
304  }
305 
306  return MB_SUCCESS;
307 }

References moab::Range::begin(), moab::TypeSequenceManager::begin(), moab::Range::empty(), moab::Range::end(), moab::TypeSequenceManager::end(), moab::SequenceManager::entity_map(), moab::ElementSequence::get_connectivity_array(), MB_SUCCESS, mMB, moab::ElementSequence::nodes_per_element(), moab::Core::sequence_manager(), moab::Core::tag_get_data(), moab::Core::tag_set_data(), and moab::TYPE_FROM_HANDLE().

◆ get_element_connect() [2/3]

ErrorCode moab::WriteUtil::get_element_connect ( Range::const_iterator  begin,
const Range::const_iterator end,
const int  vertices_per_elem,
const size_t  array_size,
EntityHandle *const  element_array 
)
virtual

Get connectivity for elements

Get the connectivity list for a range of elements.

Failure cases:

  • Passed range is empty (begin == end).
  • vertices_per_elem is less than one
  • element_array is null.
  • The range contains invalid handles (non-existent entities, not an element, etc.)
  • Insufficient space in passed array.
Parameters
beginThe first element handle
endOne past the last element handle
vertices_per_elemNumber of vertices to retrieve for each element. If the element has more vertices, the element connectivity will be truncated. If vertices_per_elem is greater than the number of nodes for an element, the data will be padded with zeros.
array_sizeThe length of element_array
element_arrayThe memory location at which to store the connectivity list.
Author
Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 407 of file WriteUtil.cpp.

412 {
413  // Check the data we got
414  if( iter == end ) return MB_FAILURE;
415  if( vertices_per_elem < 1 ) return MB_FAILURE;
416  if( !element_array || elem_array_size < (unsigned)vertices_per_elem ) return MB_FAILURE;
417 
418  // Sequence iterators
419  TypeSequenceManager::const_iterator seq_iter, seq_end;
420 
421  // Loop over range, getting coordinate value
422  EntityType current_type = MBMAXTYPE;
423  EntityHandle* output_iter = element_array;
424  EntityHandle* const output_end = element_array + elem_array_size;
425  while( iter != end )
426  {
427  // Make sure we have the right sequence list (and get the sequence
428  // list for the first iteration.)
429  EntityType type = TYPE_FROM_HANDLE( *iter );
430  if( type != current_type )
431  {
432  if( type >= MBENTITYSET || type < MBEDGE ) return MB_FAILURE;
433  seq_iter = mMB->sequence_manager()->entity_map( type ).begin();
434  seq_end = mMB->sequence_manager()->entity_map( type ).end();
435  current_type = type;
436  }
437 
438  // Find the sequence containing the current handle
439  while( seq_iter != seq_end && ( *seq_iter )->end_handle() < *iter )
440  ++seq_iter;
441  if( seq_iter == seq_end || *iter < ( *seq_iter )->start_handle() ) return MB_FAILURE;
442 
443  // Get the connectivity array
444  EntityHandle* conn_array = NULL;
445  int conn_size = static_cast< ElementSequence* >( *seq_iter )->nodes_per_element();
446  if( conn_size != vertices_per_elem ) return MB_FAILURE;
447  conn_array = static_cast< ElementSequence* >( *seq_iter )->get_connectivity_array();
448 
449  // Determine how much of the sequence we want.
450  Range::pair_iterator pair( iter );
451  Range::const_iterator prev( end );
452  --prev;
453  EntityHandle range_end = pair->second;
454  EntityHandle sequence_end = ( *seq_iter )->end_handle();
455  EntityHandle end_handle = range_end > sequence_end ? sequence_end : range_end;
456  if( end_handle > *prev ) end_handle = *prev;
457  EntityHandle count = end_handle - *iter + 1;
458 
459  // Get offset in sequence to start at
460  assert( *iter >= ( *seq_iter )->start_handle() );
461  EntityHandle offset = *iter - ( *seq_iter )->start_handle();
462 
463  // Make sure sufficient space in output array
464  if( output_iter + ( count * conn_size ) > output_end ) return MB_FAILURE;
465 
466  if( conn_array == NULL )
467  { // If it is structured mesh
468  ErrorCode rval;
469  int temp_buff_size = conn_size * sizeof( EntityHandle );
470  for( unsigned i = 0; i < count; i++ )
471  { // Copy connectivity element by element
472  std::vector< EntityHandle > connect;
473  rval = static_cast< ElementSequence* >( *seq_iter )->get_connectivity( *iter, connect );
474  if( MB_SUCCESS != rval )
475  {
476  return rval;
477  }
478  memcpy( output_iter, &connect[0], temp_buff_size );
479  output_iter += conn_size;
480  ++iter;
481  }
482  }
483  else
484  {
485  // Copy connectivity into output array
486  conn_array += ( conn_size * offset );
487  memcpy( output_iter, conn_array, count * conn_size * sizeof( EntityHandle ) );
488  output_iter += count * conn_size;
489  iter += count;
490  }
491  }
492 
493  return MB_SUCCESS;
494 }

References moab::TypeSequenceManager::begin(), moab::TypeSequenceManager::end(), moab::SequenceManager::entity_map(), ErrorCode, moab::ElementSequence::get_connectivity(), moab::ElementSequence::get_connectivity_array(), MB_SUCCESS, MBEDGE, MBENTITYSET, MBMAXTYPE, mMB, moab::ElementSequence::nodes_per_element(), moab::Core::sequence_manager(), and moab::TYPE_FROM_HANDLE().

◆ get_element_connect() [3/3]

ErrorCode moab::WriteUtil::get_element_connect ( Range::const_iterator  begin,
const Range::const_iterator end,
const int  vertices_per_elem,
Tag  node_id_tag,
const size_t  array_size,
int *const  element_array,
bool  add_sizes = false 
)
virtual

Get connectivity for elements

Get the connectivity list for a range of elements.

Failure cases:

  • Passed range is empty (begin == end).
  • vertices_per_elem is less than one
  • element_array is null.
  • The range contains invalid handles (non-existent entities, not an element, etc.)
  • Retrieving ID tag for an entity failed.
  • Insufficient space in passed array.
Parameters
beginThe first element handle
endOne past the last element handle
vertices_per_elemNumber of vertices to retrieve for each element. If the element has more vertices, the element connectivity will be truncated. If vertices_per_elem is greater than the number of nodes for an element, the data will be padded with zeros.
node_id_tagA tag with integer values.
array_sizeThe length of element_array
element_arrayThe memory location at which to store the connectivity list.
add_sizesIf true, writes size of connect array before connectivity in array
Author
Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 309 of file WriteUtil.cpp.

316 {
317  // Check the data we got
318  if( iter == end ) return MB_FAILURE;
319  if( vertices_per_elem < 1 ) return MB_FAILURE;
320  if( !element_array || elem_array_size < (unsigned)vertices_per_elem ) return MB_FAILURE;
321 
322  // Sequence iterators
323  TypeSequenceManager::const_iterator seq_iter, seq_end;
324 
325  // loop over range, getting coordinate value
326  EntityType current_type = MBMAXTYPE;
327  int* output_iter = element_array;
328  int* const output_end = element_array + elem_array_size;
329  while( iter != end )
330  {
331  // Make sure we have the right sequence list (and get the sequence
332  // list for the first iteration.)
333  EntityType type = TYPE_FROM_HANDLE( *iter );
334  if( type != current_type )
335  {
336  if( type >= MBENTITYSET || type < MBEDGE ) return MB_FAILURE;
337  seq_iter = mMB->sequence_manager()->entity_map( type ).begin();
338  seq_end = mMB->sequence_manager()->entity_map( type ).end();
339  current_type = type;
340  }
341 
342  // Find the sequence containing the current handle
343  while( seq_iter != seq_end && ( *seq_iter )->end_handle() < *iter )
344  ++seq_iter;
345  if( seq_iter == seq_end || *iter < ( *seq_iter )->start_handle() ) return MB_FAILURE;
346 
347  // Get the connectivity array
348  EntityHandle* conn_array = NULL;
349  int conn_size = static_cast< ElementSequence* >( *seq_iter )->nodes_per_element();
350  conn_array = static_cast< ElementSequence* >( *seq_iter )->get_connectivity_array();
351 
352  // Determine how much of the sequence we want.
353  Range::pair_iterator pair( iter );
354  Range::const_iterator prev( end );
355  --prev;
356  EntityHandle range_end = pair->second;
357  EntityHandle sequence_end = ( *seq_iter )->end_handle();
358  EntityHandle end_handle = range_end > sequence_end ? sequence_end : range_end;
359  if( end_handle > *prev ) end_handle = *prev;
360  EntityHandle count = end_handle - *iter + 1;
361 
362  // Get offset in sequence to start at
363  assert( *iter >= ( *seq_iter )->start_handle() );
364  EntityHandle offset = *iter - ( *seq_iter )->start_handle();
365 
366  // Make sure sufficient space in output array
367  if( ( !add_sizes && output_iter + ( count * conn_size ) > output_end ) ||
368  ( add_sizes && output_iter + ( count * ( conn_size + 1 ) ) > output_end ) )
369  return MB_FAILURE;
370 
371  // If the nodes per element match, do in one call
372  conn_array += ( conn_size * offset );
373  if( vertices_per_elem == conn_size && !add_sizes )
374  {
375  ErrorCode rval = mMB->tag_get_data( node_id_tag, conn_array, count * conn_size, output_iter );
376  if( MB_SUCCESS != rval ) return rval;
377 
378  output_iter += count * conn_size;
379  }
380  // Otherwise need to do one at a time
381  else
382  {
383  int min = vertices_per_elem > conn_size ? conn_size : vertices_per_elem;
384  for( EntityHandle i = 0; i < count; ++i )
385  {
386  *output_iter++ = min;
387  ErrorCode rval = mMB->tag_get_data( node_id_tag, conn_array, min, output_iter );
388  if( MB_SUCCESS != rval ) return rval;
389 
390  output_iter += min;
391  conn_array += conn_size;
392 
393  if( vertices_per_elem > conn_size )
394  { // Need to pad
395  memset( output_iter, 0, sizeof( int ) * ( vertices_per_elem - conn_size ) );
396  output_iter += ( vertices_per_elem - conn_size );
397  }
398  }
399  }
400 
401  iter += count;
402  }
403 
404  return MB_SUCCESS;
405 }

References moab::TypeSequenceManager::begin(), moab::TypeSequenceManager::end(), moab::SequenceManager::entity_map(), ErrorCode, moab::ElementSequence::get_connectivity_array(), MB_SUCCESS, MBEDGE, MBENTITYSET, MBMAXTYPE, mMB, moab::ElementSequence::nodes_per_element(), moab::Core::sequence_manager(), moab::Core::tag_get_data(), and moab::TYPE_FROM_HANDLE().

◆ get_entity_list_pointers() [1/2]

ErrorCode moab::WriteUtil::get_entity_list_pointers ( EntityHandle const *  entities,
int  num_entities,
EntityHandle const **  output_pointer_array,
EntityListType  relation = CONTENTS,
int *  lengths = 0,
unsigned char *  flags = 0 
)
virtual

Implements moab::WriteUtilIface.

Definition at line 860 of file WriteUtil.cpp.

866 {
867  SequenceManager* sm = mMB->sequence_manager();
868  const EntitySequence* tmp_seq;
869  ErrorCode rval = MB_SUCCESS;
870  for( int i = 0; i < num_entities; i++ )
871  {
872  rval = sm->find( entities[i], tmp_seq );
873  if( MB_SUCCESS != rval ) return rval;
874 
875  EntityType type = TYPE_FROM_HANDLE( entities[i] );
876 
877  if( MBENTITYSET == type )
878  {
879  const MeshSetSequence* seq = reinterpret_cast< const MeshSetSequence* >( tmp_seq );
880  const MeshSet* set;
881  int len = 0;
882  size_t clen;
883  set = seq->get_set( entities[i] );
884  switch( relation )
885  {
886  case CONTENTS:
887  *pointers = set->get_contents( clen );
888  len = clen;
889  break;
890  case CHILDREN:
891  *pointers = set->get_children( len );
892  break;
893  case PARENTS:
894  *pointers = set->get_parents( len );
895  break;
896  }
897  if( lengths )
898  {
899  *lengths = len;
900  ++lengths;
901  }
902  if( flags )
903  {
904  *flags = (unsigned char)set->flags();
905  ++flags;
906  }
907  ++pointers;
908  }
909  else if( MBVERTEX != type )
910  {
911  const bool topological = ( relation == TOPOLOGICAL );
912  int len;
913  const ElementSequence* seq = reinterpret_cast< const ElementSequence* >( tmp_seq );
914  rval = seq->get_connectivity( entities[i], *pointers, len, topological );
915  if( MB_SUCCESS != rval ) return rval;
916  if( lengths )
917  {
918  *lengths = len;
919  ++lengths;
920  }
921  if( flags )
922  {
923  *flags = 0;
924  ++flags;
925  }
926  ++pointers;
927  }
928  else
929  {
930  return MB_TYPE_OUT_OF_RANGE;
931  }
932  }
933 
934  return MB_SUCCESS;
935 }

References moab::WriteUtilIface::CHILDREN, moab::WriteUtilIface::CONTENTS, entities, ErrorCode, moab::SequenceManager::find(), moab::MeshSet::flags(), moab::MeshSet::get_children(), moab::ElementSequence::get_connectivity(), moab::MeshSet::get_contents(), moab::MeshSet::get_parents(), moab::MeshSetSequence::get_set(), MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, MBVERTEX, mMB, moab::WriteUtilIface::PARENTS, moab::Core::sequence_manager(), moab::WriteUtilIface::TOPOLOGICAL, and moab::TYPE_FROM_HANDLE().

◆ get_entity_list_pointers() [2/2]

ErrorCode moab::WriteUtil::get_entity_list_pointers ( Range::const_iterator  query_begin,
Range::const_iterator  query_end,
EntityHandle const **  output_pointer_array,
EntityListType  relation = CONTENTS,
int *  lengths = 0,
unsigned char *  flags = 0 
)
virtual

Implements moab::WriteUtilIface.

Definition at line 776 of file WriteUtil.cpp.

782 {
783  RangeSeqIntersectIter iter( mMB->sequence_manager() );
784  ErrorCode rval = iter.init( begin, end );
785  while( MB_SUCCESS == rval )
786  {
787  EntityType type = TYPE_FROM_HANDLE( iter.get_start_handle() );
788 
789  if( MBENTITYSET == type )
790  {
791  const MeshSetSequence* seq = reinterpret_cast< MeshSetSequence* >( iter.get_sequence() );
792  const MeshSet* set;
793  int len = 0;
794  size_t clen;
795  for( EntityHandle h = iter.get_start_handle(); h <= iter.get_end_handle(); ++h )
796  {
797  set = seq->get_set( h );
798  switch( relation )
799  {
800  case CONTENTS:
801  *pointers = set->get_contents( clen );
802  len = clen;
803  break;
804  case CHILDREN:
805  *pointers = set->get_children( len );
806  break;
807  case PARENTS:
808  *pointers = set->get_parents( len );
809  break;
810  }
811  if( lengths )
812  {
813  *lengths = len;
814  ++lengths;
815  }
816  if( flags )
817  {
818  *flags = (unsigned char)set->flags();
819  ++flags;
820  }
821  ++pointers;
822  }
823  }
824 
825  else if( MBVERTEX != type )
826  {
827  const bool topological = ( relation == TOPOLOGICAL );
828  int len;
829  const ElementSequence* seq = reinterpret_cast< ElementSequence* >( iter.get_sequence() );
830  for( EntityHandle h = iter.get_start_handle(); h <= iter.get_end_handle(); ++h )
831  {
832  rval = seq->get_connectivity( h, *pointers, len, topological );
833  if( MB_SUCCESS != rval ) return rval;
834  if( lengths )
835  {
836  *lengths = len;
837  ++lengths;
838  }
839  if( flags )
840  {
841  *flags = 0;
842  ++flags;
843  }
844  ++pointers;
845  }
846  }
847  else
848  {
849  return MB_TYPE_OUT_OF_RANGE;
850  }
851 
852  rval = iter.step();
853  }
854  if( MB_FAILURE == rval )
855  return MB_SUCCESS; // At end of list
856  else
857  return rval;
858 }

References moab::WriteUtilIface::CHILDREN, moab::WriteUtilIface::CONTENTS, ErrorCode, moab::MeshSet::flags(), moab::MeshSet::get_children(), moab::ElementSequence::get_connectivity(), moab::MeshSet::get_contents(), moab::RangeSeqIntersectIter::get_end_handle(), moab::MeshSet::get_parents(), moab::RangeSeqIntersectIter::get_sequence(), moab::MeshSetSequence::get_set(), moab::RangeSeqIntersectIter::get_start_handle(), moab::RangeSeqIntersectIter::init(), MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, MBVERTEX, mMB, moab::WriteUtilIface::PARENTS, moab::Core::sequence_manager(), moab::RangeSeqIntersectIter::step(), moab::WriteUtilIface::TOPOLOGICAL, and moab::TYPE_FROM_HANDLE().

◆ get_node_coords() [1/2]

ErrorCode moab::WriteUtil::get_node_coords ( const int  num_arrays,
const int  num_nodes,
const Range entities,
Tag  node_id_tag,
const int  start_node_id,
std::vector< double * > &  arrays 
)
virtual

Gets arrays for coordinate data from the MB.

Implements moab::WriteUtilIface.

Definition at line 90 of file WriteUtil.cpp.

96 {
97  // Check the data coming into the function
98  // Dimension should be proper
99  if( num_arrays < 1 || num_arrays > 3 ) return MB_FAILURE;
100 
101  // There should be some entities
102  // if (entities.empty())
103  // return MB_FAILURE;
104  // The above necessitates annoying special cases for files
105  // w/out vertices (e.g. a kD-tree). Return NULL array
106  // pointers instead. - kraftcheck, 3-14-08
107  if( entities.empty() )
108  {
109  arrays.clear();
110  arrays.resize( num_arrays, NULL );
111  return MB_SUCCESS;
112  }
113 
114  // Memory should already be allocated for us
115  int tmp_num_arrays = 0;
116  for( unsigned int i = 0; i < 3; i++ )
117  if( i + 1 <= arrays.size() && NULL != arrays[i] ) tmp_num_arrays++;
118  if( 0 == tmp_num_arrays ) return MB_FAILURE;
119 
120  // Get coordinate data
121  ErrorCode result = mMB->get_coords( entities, num_arrays < 1 || arrays.size() < 1 ? NULL : arrays[0],
122  num_arrays < 2 || arrays.size() < 2 ? NULL : arrays[1],
123  num_arrays < 3 || arrays.size() < 3 ? NULL : arrays[2] );
124 
125  if( 0 == node_id_tag || MB_SUCCESS != result ) return result;
126 
127  // Now assign tags
128  std::vector< int > ids( num_nodes );
129  int node_id = start_node_id;
130  for( int i = 0; i < num_nodes; i++ )
131  ids[i] = node_id++;
132  result = mMB->tag_set_data( node_id_tag, entities, &ids[0] );
133 
134  return result;
135 }

References entities, ErrorCode, moab::Core::get_coords(), MB_SUCCESS, mMB, and moab::Core::tag_set_data().

◆ get_node_coords() [2/2]

ErrorCode moab::WriteUtil::get_node_coords ( const int  which_array,
Range::const_iterator  begin,
const Range::const_iterator end,
const size_t  output_size,
double *const  output_array 
)
virtual

Get an array of coordinate values for nodes

Given a range of node handles, retrieve a single or multiple coordinate value(s) for each.

Failure conditions:

  • invalid entity handles (not vertices, non-existent entity, etc.)
  • range is empty (iter == end)
  • output_array is null
  • insufficient space in output_array
Parameters
which_arrayThe coordinate to retrieve (0->X, 1->Y, 2->Z, -1->all)
beginThe first node handle.
endOne past the last node handle.
output_sizeThe size of output_array.
output_arrayThe memory in which to write the node coordinates.
Author
Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 137 of file WriteUtil.cpp.

142 {
143  // Check the data coming into the function
144  // Dimension should be proper
145  if( which_array < -1 || which_array > 2 ) return MB_FAILURE;
146 
147  // There should be some entities
148  if( iter == end ) return MB_FAILURE;
149 
150  // Memory should already be allocated for us
151  if( NULL == output_array || 0 == output_array_len ) return MB_FAILURE;
152 
153  // Sequence iterators
154  TypeSequenceManager::iterator seq_iter, seq_end;
155  seq_iter = mMB->sequence_manager()->entity_map( MBVERTEX ).begin();
156  seq_end = mMB->sequence_manager()->entity_map( MBVERTEX ).end();
157 
158  // Loop over range, getting coordinate value
159  double* output_iter = output_array;
160  double* const output_end = output_array + output_array_len;
161  while( iter != end )
162  {
163  // Find the sequence containing the current handle
164  while( seq_iter != seq_end && ( *seq_iter )->end_handle() < *iter )
165  ++seq_iter;
166  if( seq_iter == seq_end || *iter < ( *seq_iter )->start_handle() ) return MB_FAILURE;
167 
168  // Determine how much of the sequence we want.
169  Range::pair_iterator pair( iter );
170  Range::const_iterator prev( end );
171  --prev;
172  EntityHandle range_end = pair->second;
173  EntityHandle sequence_end = ( *seq_iter )->end_handle();
174  EntityHandle end_handle = range_end > sequence_end ? sequence_end : range_end;
175  if( end_handle > *prev ) end_handle = *prev;
176  EntityHandle count = end_handle - *iter + 1;
177 
178  // Get offset in sequence to start at
179  assert( *iter >= ( *seq_iter )->start_handle() );
180  EntityHandle offset = *iter - ( *seq_iter )->start_handle();
181 
182  // Get coordinate arrays from sequence
183  double* coord_array[3];
184  static_cast< VertexSequence* >( *seq_iter )
185  ->get_coordinate_arrays( coord_array[0], coord_array[1], coord_array[2] );
186 
187  // Copy data to output buffer
188  if( -1 != which_array )
189  {
190  if( output_iter + count > output_end ) return MB_FAILURE;
191  memcpy( output_iter, coord_array[which_array] + offset, count * sizeof( double ) );
192  output_iter += count;
193  }
194  else
195  {
196  if( output_iter + 3 * count > output_end ) return MB_FAILURE;
197  for( unsigned int i = 0; i < count; i++ )
198  {
199  *output_iter = coord_array[0][i + offset];
200  output_iter++;
201  *output_iter = coord_array[1][i + offset];
202  output_iter++;
203  *output_iter = coord_array[2][i + offset];
204  output_iter++;
205  }
206  }
207 
208  // Iterate
209  iter += count;
210  }
211 
212  return MB_SUCCESS;
213 }

References moab::TypeSequenceManager::begin(), moab::TypeSequenceManager::end(), moab::SequenceManager::entity_map(), moab::VertexSequence::get_coordinate_arrays(), MB_SUCCESS, MBVERTEX, mMB, and moab::Core::sequence_manager().

◆ get_poly_connect()

ErrorCode moab::WriteUtil::get_poly_connect ( Range::const_iterator iter,
const Range::const_iterator end,
const Tag  node_id_tag,
size_t &  handle_array_len,
int *const  handle_array,
size_t &  index_array_len,
int *const  index_array,
int &  index_offset 
)
virtual

Get poly (polygon or polyhedron) connectivity.

This function will add as many polys as possible to the passed arrays given the sizes of those arrays. It will then pass back position at which it stopped and the sizes of the data written to the arrays.

Parameters
iterAs input, the first element handle. As output, one past the last element handle for which data was written to the arrays.
endThe iterator at which to stop.
node_id_tagA tag with integer values.
element_array_lenAs input, length of element_array. As output, the number of entries written in that array.
element_arrayThe memory location at which to store the connectivity list.
index_array_lenAs input, the length of index_array. As output, the number of entries written in that array.
index_arrayThe memory location at which to store offsets.
index_offsetValue to offset (add to) index values. As output the input value plus the amount of data written to the element array. (The value you presumably want to pass to the next call.)
Author
Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 503 of file WriteUtil.cpp.

511 {
512  return MB_NOT_IMPLEMENTED;
513 }

References MB_NOT_IMPLEMENTED.

◆ get_poly_connect_size()

ErrorCode moab::WriteUtil::get_poly_connect_size ( Range::const_iterator  begin,
const Range::const_iterator end,
int &  connectivity_size 
)
virtual

Get poly (polygon or polyhedron) connectivity size

Parameters
beginFirst iterator in range of poly
endOne past last in range of poly.
connectivity_sizeThe length of the connectivity list For the specified range of polyhedra.
Author
Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 496 of file WriteUtil.cpp.

499 {
500  return MB_NOT_IMPLEMENTED;
501 }

References MB_NOT_IMPLEMENTED.

◆ get_tag_list()

ErrorCode moab::WriteUtil::get_tag_list ( std::vector< Tag > &  result_list,
const Tag user_tag_list = 0,
int  user_tag_list_length = 0,
bool  include_variable_length_tags = true 
)
virtual

Get list of tags to write.

Get the list of tags to write to the file, possibly using an optional user-specified tag list. This function consolidates some common code for file writers to use to figure out what tag data to write to the file. It provides the following features: o filter list based on user-specified array of tag handles o filter internal tags (those for which the name is prefixed with two underscore characters) o filter anonymous tags o optionally filter variable-length tags.

Author
Jason Kraftcheck
Parameters
result_listList of tag handles for which to write data
user_tag_listOptional array of tag handles passed by user to write to file.
include_variable_length_tagsIf false, return only fixed-length tags.

Implements moab::WriteUtilIface.

Definition at line 714 of file WriteUtil.cpp.

718 {
719  ErrorCode rval;
720 
721  if( user_tag_list )
722  {
723  result_list.clear();
724  result_list.reserve( user_tag_list_length );
725  for( int i = 0; i < user_tag_list_length; ++i )
726  {
727  std::string name;
728  rval = mMB->tag_get_name( user_tag_list[i], name );MB_CHK_SET_ERR( rval, "Error " << (int)rval << " getting name for tag (Invalid input tag handle?)" );
729 
730  if( name.empty() )
731  {
732  MB_SET_ERR( MB_TAG_NOT_FOUND, "Explicit request to save anonymous tag" );
733  }
734 
735  int size;
736  if( !include_variable_length_tags &&
737  MB_VARIABLE_DATA_LENGTH == mMB->tag_get_length( user_tag_list[i], size ) )
738  {
739  MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, "File format cannot store variable-length tag: \"" << name << "\"" );
740  }
741 
742  result_list.push_back( user_tag_list[i] );
743  }
744  }
745  else
746  {
747  std::vector< Tag > temp_list;
748  rval = mMB->tag_get_tags( temp_list );MB_CHK_SET_ERR( rval, "Interface::tag_get_tags failed" );
749 
750  result_list.clear();
751  result_list.reserve( temp_list.size() );
752 
753  std::vector< Tag >::iterator i;
754  for( i = temp_list.begin(); i != temp_list.end(); ++i )
755  {
756  std::string name;
757  rval = mMB->tag_get_name( *i, name );MB_CHK_SET_ERR( rval, "Error " << (int)rval << " getting name for tag (Stale tag handle?)" );
758 
759  // Skip anonymous tags
760  if( name.empty() ) continue;
761 
762  // Skip private/internal tags
763  if( name.size() >= 2 && name[0] == '_' && name[1] == '_' ) continue;
764 
765  // If requested, skip variable-length tags
766  int size;
767  if( !include_variable_length_tags && MB_VARIABLE_DATA_LENGTH == mMB->tag_get_length( *i, size ) ) continue;
768 
769  result_list.push_back( *i );
770  }
771  }
772 
773  return MB_SUCCESS;
774 }

References ErrorCode, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_NOT_FOUND, MB_TYPE_OUT_OF_RANGE, MB_VARIABLE_DATA_LENGTH, mMB, size, moab::Core::tag_get_length(), moab::Core::tag_get_name(), and moab::Core::tag_get_tags().

Member Data Documentation

◆ mMB


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