moab::ReadTetGen Class Reference

#include <ReadTetGen.hpp>

Inheritance diagram for moab::ReadTetGen:

Collaboration diagram for moab::ReadTetGen:

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 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...
	ReadTetGen (Interface *impl=NULL)
	Constructor. More...
virtual	~ReadTetGen ()
	Destructor. More...
Public Member Functions inherited from moab::ReaderIface
virtual	~ReaderIface ()

Static Public Member Functions
static ReaderIface *	factory (Interface *)

Private Member Functions
ErrorCode	open_file (const std::string &input_file_name, const std::string &input_name_base, const std::string &input_name_suffix, const char *file_type_suffix, const char *file_name_option, const FileOptions &opts, std::ifstream &file_stream, bool file_required=false)
	Try to open one of several input files. More...
ErrorCode	read_line (std::istream &file, std::string &line, int &lineno)
	Read a line from a file. More...
ErrorCode	read_line (std::istream &file, double *values_out, int num_values, int &lineno)
	Read a line of double values from a file. More...
ErrorCode	parse_attr_list (const std::string &option_str, std::vector< Tag > &tag_list, std::vector< int > &index_list, const char *group_designator=0)
	Parse option string specifying mapping from attributes to tags. More...
ErrorCode	read_node_file (std::istream &file, const Tag *attr_tag_list, const int *attr_tag_index, int attr_tag_list_len, std::vector< EntityHandle > &nodes)
ErrorCode	read_elem_file (EntityType type, std::istream &file, const std::vector< EntityHandle > &nodes, Range &elems)

Private Attributes
Interface *	mbIface
ReadUtilIface *	readTool

Detailed Description

Definition at line 36 of file ReadTetGen.hpp.

Constructor & Destructor Documentation

ReadTetGen()

moab::ReadTetGen::ReadTetGen

(

Interface *

impl = NULL

)

Constructor.

Definition at line 21 of file ReadTetGen.cpp.

 : mbIface( moab ), readTool( 0 )
{
 moab->query_interface( readTool );
}

References readTool.

Referenced by factory().

~ReadTetGen()

moab::ReadTetGen::~ReadTetGen ( )

virtual

Destructor.

Definition at line 26 of file ReadTetGen.cpp.

{
 if( mbIface && readTool ) mbIface->release_interface( readTool );
}

References mbIface, readTool, and moab::Interface::release_interface().

Member Function Documentation

factory()

ReaderIface * moab::ReadTetGen::factory ( Interface *  moab )

static

Definition at line 16 of file ReadTetGen.cpp.

{
 return new ReadTetGen( moab );
}

References ReadTetGen().

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

load_file()

ErrorCode moab::ReadTetGen::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 a file

Implements moab::ReaderIface.

Definition at line 75 of file ReadTetGen.cpp.

{
 std::ifstream node_file, ele_file, face_file, edge_file;
 ErrorCode rval;
 
 if( subset_list )
 {
 MB_SET_ERR( MB_UNSUPPORTED_OPERATION, "Reading subset of files not supported for TetGen" );
 }
 
 std::string suffix, base, filename( file_name_c );
 size_t dot_idx = filename.find_last_of( '.' );
 if( dot_idx == std::string::npos )
 {
 base = filename;
 }
 else
 {
 suffix = filename.substr( dot_idx + 1 );
 for( size_t i = 0; i < suffix.length(); ++i )
 suffix[i] = (char)tolower( suffix[i] );
 if( suffix == "node" || suffix == "ele" || suffix == "face" || suffix == "edge" )
 {
 base = filename.substr( 0, dot_idx );
 }
 else
 {
 base = filename;
 suffix.clear();
 }
 }
 
 rval = open_file( filename, base, suffix, "node", "NODE_FILE", opts, node_file, true );
 if( MB_SUCCESS != rval ) return rval;
 rval = open_file( filename, base, suffix, "ele", "ELE_FILE", opts, ele_file );
 if( MB_SUCCESS != rval ) return rval;
 rval = open_file( filename, base, suffix, "face", "FACE_FILE", opts, face_file );
 if( MB_SUCCESS != rval ) return rval;
 rval = open_file( filename, base, suffix, "edge", "EDGE_FILE", opts, edge_file );
 if( MB_SUCCESS != rval ) return rval;
 
 std::vector< Tag > attr_tags[4];
 std::vector< int > attr_idx[4];
 const char* option_names[4] = { "NODE_ATTR_LIST", "EDGE_ATTR_LIST", "TRI_ATTR_LIST", "TET_ATTR_LIST" };
 const char* group_names[4] = { 0, "CURVE_ID", "SURFACE_ID", "VOLUME_ID" };
 for( int i = 0; i < 4; ++i )
 {
 std::string opt_str;
 rval = opts.get_str_option( option_names[i], opt_str );
 if( MB_SUCCESS != rval ) continue;
 rval = parse_attr_list( opt_str, attr_tags[i], attr_idx[i], group_names[i] );
 if( MB_SUCCESS != rval )
 {
 MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, option_names[i] << ": invalid option value" );
 }
 }
 
 Range tets, tris, edges;
 std::vector< EntityHandle > nodes;
 rval = read_node_file( node_file, &attr_tags[0][0], &attr_idx[0][0], attr_tags[0].size(), nodes );
 if( MB_SUCCESS == rval && ele_file.is_open() ) rval = read_elem_file( MBTET, ele_file, nodes, tets );
 if( MB_SUCCESS == rval && face_file.is_open() ) rval = read_elem_file( MBTRI, face_file, nodes, tris );
 if( MB_SUCCESS == rval && edge_file.is_open() ) rval = read_elem_file( MBEDGE, edge_file, nodes, edges );
 
 if( file_id_tag && MB_SUCCESS == rval ) rval = readTool->assign_ids( *file_id_tag, &nodes[0], nodes.size() );
 if( file_id_tag && MB_SUCCESS == rval ) rval = readTool->assign_ids( *file_id_tag, edges );
 if( file_id_tag && MB_SUCCESS == rval ) rval = readTool->assign_ids( *file_id_tag, tris );
 if( file_id_tag && MB_SUCCESS == rval ) rval = readTool->assign_ids( *file_id_tag, tets );
 
 return rval;
}

References moab::ReadUtilIface::assign_ids(), ErrorCode, moab::FileOptions::get_str_option(), MB_SET_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MB_UNSUPPORTED_OPERATION, MBEDGE, MBTET, MBTRI, open_file(), parse_attr_list(), read_elem_file(), read_node_file(), readTool, and size.

open_file()

ErrorCode moab::ReadTetGen::open_file ( const std::string &  input_file_name, const std::string &  input_name_base, const std::string &  input_name_suffix, const char *  file_type_suffix, const char *  file_name_option, const FileOptions &  opts, std::ifstream &  file_stream, bool  file_required = false  )

private

Try to open one of several input files.

Parameters

input_file_name	The file name as passed in by the application
input_name_base	If the input file name ends with a known suffix, the portition of the input file without the suffix. Otherwise equal to input_file_name.
input_file_suffix	If the input file name ends with a known suffix, the suffix. Otherwise empty.
file_type_suffix	The suffix for the file type that is to be opened.
file_name_option	The FileOptions option name specifying the file name to open.
opts	Input options list.
file_stream	The stream to open for the file.

Definition at line 31 of file ReadTetGen.cpp.

{
 std::string real_file_name;
 ErrorCode rval = opts.get_option( opt_name, real_file_name );
 if( MB_ENTITY_NOT_FOUND == rval || real_file_name.empty() )
 {
 if( MB_SUCCESS == rval ) file_required = true;
 if( suffix == exp_suffix )
 {
 real_file_name = filename;
 }
 else
 {
 real_file_name = basename;
 real_file_name += ".";
 real_file_name += exp_suffix;
 }
 }
 
 if( !real_file_name.empty() ) file_stream.open( real_file_name.c_str(), std::ios::in );
 if( file_required && !file_stream.is_open() )
 {
 MB_SET_ERR( MB_FILE_DOES_NOT_EXIST, real_file_name << ": cannot read file" );
 }
 
 return MB_SUCCESS;
}

References ErrorCode, moab::FileOptions::get_option(), MB_ENTITY_NOT_FOUND, MB_FILE_DOES_NOT_EXIST, MB_SET_ERR, and MB_SUCCESS.

Referenced by load_file().

parse_attr_list()

ErrorCode moab::ReadTetGen::parse_attr_list ( const std::string &  option_str, std::vector< Tag > &  tag_list, std::vector< int > &  index_list, const char *  group_designator = 0  )

private

Parse option string specifying mapping from attributes to tags.

Given a file option string describing the mapping from tetgen attributes to MOAB tags, parse it and populate the passed vectors.

Parameters

option_str	Input: The option string to parse.
tag_list	Output: A list tag handles, one for each attribute. Tag handle value will be zero if the attribute is to be interpreted as a group id.
index_list	Output: Which array index to store the attribute value at for a multi-valued tag. Zero for single- valued tags. -1 if the corresponding attribute value is to be interpreted as a group ID.
group_designator	Input: special tag name used to designate an attribute as the group (surface or volume) ID.

Definition at line 151 of file ReadTetGen.cpp.

{
 std::vector< std::string > name_list;
 size_t prev_pos = 0;
 while( prev_pos != std::string::npos )
 {
 size_t pos = option_str.find_first_of( ',', prev_pos );
 name_list.push_back( option_str.substr( prev_pos, pos ) );
 prev_pos = pos + 1;
 }
 
 index_list.resize( name_list.size() );
 std::map< std::string, int > name_count;
 for( size_t i = 0; i < name_list.size(); ++i )
 index_list[i] = name_count[name_list[i]]++;
 
 for( size_t i = 0; i < name_list.size(); ++i )
 {
 if( group_designator && name_list[i] == group_designator )
 {
 tag_list[i] = 0;
 index_list[i] = -1;
 }
 else if( name_list.empty() )
 {
 tag_list[i] = 0;
 index_list[i] = 0;
 }
 else
 {
 ErrorCode rval = mbIface->tag_get_handle( name_list[i].c_str(), name_count[name_list[i]], MB_TYPE_DOUBLE,
 tag_list[i], MB_TAG_DENSE | MB_TAG_CREAT );
 if( MB_SUCCESS != rval ) return rval;
 }
 }
 
 return MB_SUCCESS;
}

References ErrorCode, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_DOUBLE, mbIface, and moab::Interface::tag_get_handle().

Referenced by load_file().

read_elem_file()

ErrorCode moab::ReadTetGen::read_elem_file ( EntityType  type, std::istream &  file, const std::vector< EntityHandle > &  nodes, Range &  elems  )

private

Definition at line 345 of file ReadTetGen.cpp.

{
 int lineno = 0;
 ErrorCode rval;
 
 int node_per_elem, have_group_id, dim;
 double header_vals[3];
 switch( type )
 {
 case MBTET:
 rval = read_line( file, header_vals, 3, lineno );
 node_per_elem = (int)header_vals[1];
 have_group_id = (int)header_vals[2];
 dim = 3;
 break;
 case MBTRI:
 rval = read_line( file, header_vals, 2, lineno );
 node_per_elem = 3;
 have_group_id = (int)header_vals[1];
 dim = 2;
 break;
 case MBEDGE:
 rval = read_line( file, header_vals, 1, lineno );
 node_per_elem = 2;
 have_group_id = 0;
 dim = 1;
 break;
 default:
 rval = MB_FAILURE;
 break;
 }
 if( MB_SUCCESS != rval ) return rval;
 const int num_elem = (int)header_vals[0];
 if( num_elem < 1 || node_per_elem < 2 || have_group_id < 0 || have_group_id > 1 )
 {
 MB_SET_ERR( MB_FAILURE, "Invalid header line for element data" );
 }
 
 // Create group map
 std::map< double, EntityHandle > groups;
 Tag dim_tag, id_tag;
 id_tag = mbIface->globalId_tag();
 
 const int negone = -1;
 rval = mbIface->tag_get_handle( GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, dim_tag, MB_TAG_SPARSE | MB_TAG_CREAT,
 &negone );
 if( MB_SUCCESS != rval ) return rval;
 
 // Allocate elements
 EntityHandle start_handle, *conn_array;
 rval = readTool->get_element_connect( num_elem, node_per_elem, type, 1, start_handle, conn_array );
 if( MB_SUCCESS != rval ) return rval;
 elems.insert( start_handle, start_handle + num_elem - 1 );
 
 // Read data line for each node
 std::vector< double > data( 1 + node_per_elem + have_group_id );
 std::vector< int > ids( num_elem );
 for( int i = 0; i < num_elem; ++i )
 {
 rval = read_line( file, &data[0], data.size(), lineno );
 if( MB_SUCCESS != rval ) return rval;
 
 // Get ID
 ids[i] = (int)data[0];
 
 // Get connectivity
 for( int j = 0; j < node_per_elem; ++j )
 conn_array[node_per_elem * i + j] = nodes[(int)data[j + 1]];
 
 // Grouping
 if( have_group_id && 0.0 != data[node_per_elem + 1] )
 {
 double id = data[node_per_elem + 1];
 EntityHandle grp = groups[id];
 if( 0 == grp )
 {
 rval = mbIface->create_meshset( MESHSET_SET, grp );
 if( MB_SUCCESS != rval ) return rval;
 elems.insert( grp );
 rval = mbIface->tag_set_data( dim_tag, &grp, 1, &dim );
 if( MB_SUCCESS != rval ) return rval;
 int iid = (int)id;
 rval = mbIface->tag_set_data( id_tag, &grp, 1, &iid );
 if( MB_SUCCESS != rval ) return rval;
 groups[id] = grp;
 }
 EntityHandle handle = start_handle + i;
 rval = mbIface->add_entities( grp, &handle, 1 );
 if( MB_SUCCESS != rval ) return rval;
 }
 }
 
 // Store id data
 Range elems2;
 elems2.insert( start_handle, start_handle + num_elem - 1 );
 rval = mbIface->tag_set_data( id_tag, elems2, &ids[0] );
 if( MB_SUCCESS != rval ) return rval;
 
 return MB_SUCCESS;
}

References moab::Interface::add_entities(), moab::Interface::create_meshset(), dim, ErrorCode, GEOM_DIMENSION_TAG_NAME, moab::ReadUtilIface::get_element_connect(), moab::Interface::globalId_tag(), moab::Range::insert(), MB_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_INTEGER, MBEDGE, mbIface, MBTET, MBTRI, MESHSET_SET, read_line(), readTool, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by load_file().

read_line() [1/2]

ErrorCode moab::ReadTetGen::read_line ( std::istream &  file, double *  values_out, int  num_values, int &  lineno  )

private

Read a line of double values from a file.

Definition at line 217 of file ReadTetGen.cpp.

{
 // Get a line of text
 std::string line;
 ErrorCode rval = read_line( file, line, lineno );
 if( MB_SUCCESS != rval ) return rval;
 
 // Tokenize line as doubles
 std::stringstream str( line );
 for( int i = 0; i < num_values; ++i )
 {
 double v;
 if( !( str >> v ) )
 {
 MB_SET_ERR( MB_FAILURE, "Error reading node data at line " << lineno );
 }
 values_out[i] = v;
 }
 
 // Check that we're at the end of the line
 int junk;
 if( ( str >> junk ) || !str.eof() )
 {
 MB_SET_ERR( MB_FAILURE, "Unexpected trailing data for line " << lineno << " of node data" );
 }
 
 return MB_SUCCESS;
}

References ErrorCode, MB_SET_ERR, MB_SUCCESS, and read_line().

read_line() [2/2]

ErrorCode moab::ReadTetGen::read_line ( std::istream &  file, std::string &  line, int &  lineno  )

private

Read a line from a file.

Read the next non-empty line. Strips comments.

Parameters

file	The stream to read from
line	Output: the line read from the stream
lineno	Incremented for each real line read from the stream (including disgarded empty and comment lines.)

Definition at line 193 of file ReadTetGen.cpp.

{
 // Loop until we find a non-empty line
 do
 {
 // Read a line
 line.clear();
 if( !getline( file, line ) ) return MB_FILE_WRITE_ERROR;
 ++lineno;
 // Strip comments from line
 size_t pos = line.find_first_of( '#' );
 if( pos != std::string::npos ) line = line.substr( 0, pos );
 // Strip leading whitespace from line
 for( pos = 0; pos < line.length() && isspace( line[pos] ); ++pos )
 ;
 if( pos == line.length() )
 line.clear();
 else if( pos != 0 )
 line = line.substr( pos );
 } while( line.empty() );
 
 return MB_SUCCESS;
}

References MB_FILE_WRITE_ERROR, and MB_SUCCESS.

Referenced by read_elem_file(), read_line(), and read_node_file().

read_node_file()

ErrorCode moab::ReadTetGen::read_node_file ( std::istream &  file, const Tag *  attr_tag_list, const int *  attr_tag_index, int  attr_tag_list_len, std::vector< EntityHandle > &  nodes  )

private

Definition at line 246 of file ReadTetGen.cpp.

{
 int lineno = 0;
 ErrorCode rval;
 
 double header_vals[4];
 rval = read_line( file, header_vals, 4, lineno );
 if( MB_SUCCESS != rval ) return rval;
 
 const int num_vtx = (int)header_vals[0];
 const int dim = (int)header_vals[1];
 const int num_attr = (int)header_vals[2];
 const int bdry_flag = (int)header_vals[3];
 if( num_vtx < 1 || dim < 2 || dim > 3 || num_attr < 0 || bdry_flag < 0 || bdry_flag > 1 )
 {
 MB_SET_ERR( MB_FAILURE, "Invalid header line for node data" );
 }
 if( attr_tag_list_len > num_attr ) attr_tag_list_len = num_attr;
 
 // Allocate space for tag data
 std::map< Tag, int > tag_size;
 std::map< Tag, std::vector< double > > tag_data;
 for( int i = 0; i < attr_tag_list_len; ++i )
 {
 if( !attr_tag_list[i] || attr_tag_index[i] < 0 ) continue;
 std::vector< double >& data = tag_data[attr_tag_list[i]];
 // Increase tag size by one value per vertex for each time
 // we encounter it in the list.
 data.resize( data.size() + num_vtx );
 ++tag_size[attr_tag_list[i]];
 }
 std::vector< double* > attr_data( attr_tag_list_len );
 std::vector< int > attr_size( attr_tag_list_len );
 for( int i = 0; i < attr_tag_list_len; ++i )
 {
 if( !attr_tag_list[i] || attr_tag_index[i] < 0 )
 {
 attr_data[i] = 0;
 attr_size[i] = 0;
 }
 else
 {
 attr_data[i] = &( tag_data[attr_tag_list[i]] )[0];
 attr_size[i] = tag_size[attr_tag_list[i]];
 }
 }
 
 // Allocate vertices
 std::vector< double* > coords;
 EntityHandle start_handle;
 rval = readTool->get_node_coords( dim, num_vtx, 1, start_handle, coords );
 if( MB_SUCCESS != rval ) return rval;
 
 // Read data line for each node
 nodes.reserve( num_vtx );
 std::vector< double > data( 1 + dim + num_attr + bdry_flag );
 std::vector< int > ids( num_vtx );
 for( int i = 0; i < num_vtx; ++i )
 {
 rval = read_line( file, &data[0], data.size(), lineno );
 if( MB_SUCCESS != rval ) return rval;
 
 // Get ID
 ids[i] = (int)data[0];
 if( ids[i] >= (int)nodes.size() ) nodes.resize( ids[i] + 1 );
 nodes[ids[i]] = start_handle + i;
 
 // Get coordinates
 // Cppcheck warning (false positive): variable coords is assigned a value that is never used
 for( int j = 0; j < dim; ++j )
 coords[j][i] = data[j + 1];
 
 // Get attribute data
 for( int j = 0; j < attr_tag_list_len; ++j )
 if( attr_data[j] ) attr_data[j][i * attr_size[j] + attr_tag_index[j]] = data[j + 1 + dim];
 
 // Discard boundary bit
 }
 
 // Store tag data
 Range node_range;
 node_range.insert( start_handle, start_handle + num_vtx - 1 );
 for( std::map< Tag, std::vector< double > >::iterator i = tag_data.begin(); i != tag_data.end(); ++i )
 {
 rval = mbIface->tag_set_data( i->first, node_range, &i->second[0] );
 if( MB_SUCCESS != rval ) return rval;
 }
 Tag idtag = mbIface->globalId_tag();
 
 rval = mbIface->tag_set_data( idtag, node_range, &ids[0] );
 if( MB_SUCCESS != rval ) return rval;
 
 return MB_SUCCESS;
}

References dim, ErrorCode, moab::ReadUtilIface::get_node_coords(), moab::Interface::globalId_tag(), moab::Range::insert(), MB_SET_ERR, MB_SUCCESS, mbIface, read_line(), readTool, and moab::Interface::tag_set_data().

Referenced by load_file().

read_tag_values()

ErrorCode moab::ReadTetGen::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 66 of file ReadTetGen.cpp.

{
 return MB_NOT_IMPLEMENTED;
}

References MB_NOT_IMPLEMENTED.

Member Data Documentation

mbIface

Interface* moab::ReadTetGen::mbIface

private

Definition at line 62 of file ReadTetGen.hpp.

Referenced by parse_attr_list(), read_elem_file(), read_node_file(), and ~ReadTetGen().

readTool

ReadUtilIface* moab::ReadTetGen::readTool

private

Definition at line 63 of file ReadTetGen.hpp.

Referenced by load_file(), read_elem_file(), read_node_file(), ReadTetGen(), and ~ReadTetGen().

---

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

• ReadTetGen.hpp
• ReadTetGen.cpp