#include <ReadNASTRAN.hpp>

Inheritance diagram for moab::ReadNASTRAN:

Collaboration diagram for moab::ReadNASTRAN:

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

	ReadNASTRAN (Interface *impl=NULL)

virtual	~ReadNASTRAN ()

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

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

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

Private Types
enum	line_format { SMALL_FIELD , LARGE_FIELD , FREE_FIELD }

Private Member Functions
ErrorCode	determine_line_format (const std::string &line, line_format &format)

ErrorCode	tokenize_line (const std::string &line, const line_format format, std::vector< std::string > &tokens)

ErrorCode	determine_entity_type (const std::string &token, EntityType &type)

ErrorCode	get_real (const std::string &, double &real)

ErrorCode	read_node (const std::vector< std::string > &tokens, const bool debug, double *coord_arrays[3], int &node_id)

ErrorCode	read_element (const std::vector< std::string > &tokens, std::vector< Range > &materials, const EntityType element_type, const bool debug)

ErrorCode	create_materials (const std::vector< Range > &materials)

ErrorCode	assign_ids (const Tag *file_id_tag)

Private Attributes
ReadUtilIface *	readMeshIface

Interface *	MBI

RangeMap< int, EntityHandle >	nodeIdMap

RangeMap< int, EntityHandle >	elemIdMap

Detailed Description

Definition at line 49 of file ReadNASTRAN.hpp.

Member Enumeration Documentation

◆ line_format

enum moab::ReadNASTRAN::line_format

private

Enumerator
SMALL_FIELD
LARGE_FIELD
FREE_FIELD

Definition at line 83 of file ReadNASTRAN.hpp.

     {
         SMALL_FIELD,
         LARGE_FIELD,
         FREE_FIELD
     };

Constructor & Destructor Documentation

◆ ReadNASTRAN()

moab::ReadNASTRAN::ReadNASTRAN ( Interface * impl = NULL )

Definition at line 44 of file ReadNASTRAN.cpp.

                                           : MBI( impl )
 {
     assert( NULL != impl );
     MBI->query_interface( readMeshIface );
     assert( NULL != readMeshIface );
 }

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

Referenced by factory().

◆ ~ReadNASTRAN()

moab::ReadNASTRAN::~ReadNASTRAN ( )

virtual

Definition at line 52 of file ReadNASTRAN.cpp.

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

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

Member Function Documentation

◆ assign_ids()

ErrorCode moab::ReadNASTRAN::assign_ids ( const Tag * file_id_tag )

private

Definition at line 460 of file ReadNASTRAN.cpp.

 {
     // Create tag
     ErrorCode result;
     Tag id_tag = MBI->globalId_tag();
  
     RangeMap< int, EntityHandle >::iterator i;
     for( int t = 0; t < 2; ++t )
     {
         RangeMap< int, EntityHandle >& fileIdMap = t ? elemIdMap : nodeIdMap;
         for( i = fileIdMap.begin(); i != fileIdMap.end(); ++i )
         {
             Range range( i->value, i->value + i->count - 1 );
  
             result = readMeshIface->assign_ids( id_tag, range, i->begin );
             if( MB_SUCCESS != result ) return result;
  
             if( file_id_tag && *file_id_tag != id_tag )
             {
                 result = readMeshIface->assign_ids( *file_id_tag, range, i->begin );
                 if( MB_SUCCESS != result ) return result;
             }
         }
     }
  
     return MB_SUCCESS;
 }

References moab::ReadUtilIface::assign_ids(), moab::RangeMap< KeyType, ValType, NullVal >::begin(), elemIdMap, moab::RangeMap< KeyType, ValType, NullVal >::end(), ErrorCode, moab::Interface::globalId_tag(), MB_SUCCESS, MBI, nodeIdMap, and readMeshIface.

Referenced by load_file().

◆ create_materials()

ErrorCode moab::ReadNASTRAN::create_materials ( const std::vector< Range > & materials )

private

Definition at line 428 of file ReadNASTRAN.cpp.

 {
     ErrorCode result;
     Tag material_tag;
     int negone = -1;
     result = MBI->tag_get_handle( MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, material_tag, MB_TAG_SPARSE | MB_TAG_CREAT,
                                   &negone );
     if( MB_SUCCESS != result ) return result;
  
     for( size_t i = 0; i < materials.size(); ++i )
     {
         if( materials[i].empty() ) continue;
  
         // Merge with existing or create new?  Original code effectively
         // created new by only merging with existing in current file set,
         // so do the same here. - j.kraftcheck
  
         EntityHandle handle;
         result = MBI->create_meshset( MESHSET_SET, handle );
         if( MB_SUCCESS != result ) return result;
  
         result = MBI->add_entities( handle, materials[i] );
         if( MB_SUCCESS != result ) return result;
  
         int id = i;
         result = MBI->tag_set_data( material_tag, &handle, 1, &id );
         if( MB_SUCCESS != result ) return result;
     }
  
     return MB_SUCCESS;
 }

References moab::Interface::add_entities(), moab::Interface::create_meshset(), ErrorCode, MATERIAL_SET_TAG_NAME, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_INTEGER, MBI, MESHSET_SET, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by load_file().

◆ determine_entity_type()

ErrorCode moab::ReadNASTRAN::determine_entity_type	(	const std::string &	token,
		EntityType &	type
	)

private

Definition at line 252 of file ReadNASTRAN.cpp.

 {
     if( 0 == first_token.compare( "GRID    " ) )
         type = MBVERTEX;
     else if( 0 == first_token.compare( "CTETRA  " ) )
         type = MBTET;
     else if( 0 == first_token.compare( "CPENTA  " ) )
         type = MBPRISM;
     else if( 0 == first_token.compare( "CHEXA   " ) )
         type = MBHEX;
     else
         return MB_NOT_IMPLEMENTED;
  
     return MB_SUCCESS;
 }

References MB_NOT_IMPLEMENTED, MB_SUCCESS, MBHEX, MBPRISM, MBTET, and MBVERTEX.

Referenced by load_file().

◆ determine_line_format()

ErrorCode moab::ReadNASTRAN::determine_line_format	(	const std::string &	line,
		line_format &	format
	)

private

Definition at line 198 of file ReadNASTRAN.cpp.

 {
     std::string::size_type found_asterisk = line.find( "*" );
     if( std::string::npos != found_asterisk )
     {
         format = LARGE_FIELD;
         return MB_SUCCESS;
     }
     else
     {
         std::string::size_type found_comma = line.find( "," );
         if( std::string::npos != found_comma )
         {
             format = FREE_FIELD;
             return MB_SUCCESS;
         }
         else
         {
             format = SMALL_FIELD;
             return MB_SUCCESS;
         }
     }
 }

References FREE_FIELD, LARGE_FIELD, MB_SUCCESS, and SMALL_FIELD.

Referenced by load_file().

◆ factory()

ReaderIface * moab::ReadNASTRAN::factory ( Interface * iface )

static

Definition at line 38 of file ReadNASTRAN.cpp.

 {
     return new ReadNASTRAN( iface );
 }

References iface, and ReadNASTRAN().

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

◆ get_real()

ErrorCode moab::ReadNASTRAN::get_real	(	const std::string &	token,
		double &	real
	)

private

Definition at line 283 of file ReadNASTRAN.cpp.

 {
     std::string significand = token;
     std::string exponent    = "0";
  
     // Cut off the first digit because a "-" could be here indicating a negative
     // number. Instead we are looking for a negative exponent.
     std::string back_token = token.substr( 1 );
  
     // A minus that is not the first digit is always a negative exponent
     std::string::size_type found_minus = back_token.find( "-" );
     if( std::string::npos != found_minus )
     {
         // separate the significand from the exponent at the "-"
         exponent    = token.substr( found_minus + 1 );
         significand = token.substr( 0, found_minus + 1 );
  
         // If the significand has an "E", remove it
         if( std::string::npos != significand.find( "E" ) )
             // Assume the "E" is at the end of the significand.
             significand = significand.substr( 1, significand.size() - 2 );
  
         // If a minus does not exist past the 1st digit, but an "E" or "+" does, then
         // it is a positive exponent. First look for an "E",
     }
     else
     {
         std::string::size_type found_E = token.find( "E" );
         if( std::string::npos != found_E )
         {
             significand = token.substr( 0, found_E - 1 );
             exponent    = token.substr( found_E + 1 );
             // If there is a "+" on the exponent, cut it off
             std::size_t found_plus = exponent.find( "+" );
             if( std::string::npos != found_plus )
             {
                 exponent = exponent.substr( found_plus + 1 );
             }
         }
         else
         {
             // If there is a "+" on the exponent, cut it off
             std::size_t found_plus = token.find( "+" );
             if( std::string::npos != found_plus )
             {
                 significand = token.substr( 0, found_plus - 1 );
                 exponent    = token.substr( found_plus + 1 );
             }
         }
     }
  
     // Now assemble the real number
     double signi = atof( significand.c_str() );
     double expon = atof( exponent.c_str() );
  
     if( HUGE_VAL == signi || HUGE_VAL == expon ) return MB_FAILURE;
  
     real = signi * pow( 10, expon );
  
     return MB_SUCCESS;
 }

References MB_SUCCESS.

Referenced by read_node().

◆ load_file()

ErrorCode moab::ReadNASTRAN::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 71 of file ReadNASTRAN.cpp.

 {
     // At this time there is no support for reading a subset of the file
     if( subset_list )
     {
         MB_SET_ERR( MB_UNSUPPORTED_OPERATION, "Reading subset of files not supported for NASTRAN" );
     }
  
     nodeIdMap.clear();
     elemIdMap.clear();
  
     bool debug = false;
     if( debug ) std::cout << "begin ReadNASTRAN::load_file" << std::endl;
     ErrorCode result;
  
     // Count the entities of each type in the file. This is used to allocate the node array.
     int entity_count[MBMAXTYPE];
     for( int i = 0; i < MBMAXTYPE; i++ )
         entity_count[i] = 0;
  
     /* Determine the line_format of the first line. Assume that the entire file
        has the same format. */
     std::string line;
     std::ifstream file( filename );
     if( !getline( file, line ) ) return MB_FILE_DOES_NOT_EXIST;
     line_format format;
     result = determine_line_format( line, format );
     if( MB_SUCCESS != result ) return result;
  
     /* Count the number of each entity in the file. This allows one to allocate
        a sequential array of vertex handles. */
     while( !file.eof() )
     {
         // Cut the line into fields as determined by the line format.
         // Use a vector to allow for an unknown number of tokens (continue lines).
         // Continue lines are not implemented.
         std::vector< std::string > tokens;
         tokens.reserve( 10 );  // assume 10 fields to avoid extra vector resizing
         result = tokenize_line( line, format, tokens );
         if( MB_SUCCESS != result ) return result;
  
         // Process the tokens of the line. The first token describes the entity type.
         EntityType type;
         result = determine_entity_type( ( tokens.empty() ) ? "" : tokens.front(), type );
         if( MB_SUCCESS != result ) return result;
         entity_count[type]++;
         getline( file, line );
     }
  
     if( debug )
     {
         for( int i = 0; i < MBMAXTYPE; i++ )
         {
             std::cout << "entity_count[" << i << "]=" << entity_count[i] << std::endl;
         }
     }
  
     // Keep list of material sets
     std::vector< Range > materials;
  
     // Now that the number of vertices is known, create the vertices.
     EntityHandle start_vert = 0;
     std::vector< double* > coord_arrays( 3 );
     result = readMeshIface->get_node_coords( 3, entity_count[0], MB_START_ID, start_vert, coord_arrays );
     if( MB_SUCCESS != result ) return result;
     if( 0 == start_vert ) return MB_FAILURE;  // check for NULL
     int id, vert_index = 0;
     if( debug ) std::cout << "allocated coord arrays" << std::endl;
  
     // Read the file again to create the entities.
     file.clear();     // Clear eof state from object
     file.seekg( 0 );  // Rewind file
     while( !file.eof() )
     {
         getline( file, line );
  
         // Cut the line into fields as determined by the line format.
         // Use a vector to allow for an unknown number of tokens (continue lines).
         // Continue lines are not implemented.
         std::vector< std::string > tokens;
         tokens.reserve( 10 );  // assume 10 fields to avoid extra vector resizing
         result = tokenize_line( line, format, tokens );
         if( MB_SUCCESS != result ) return result;
  
         // Process the tokens of the line. The first token describes the entity type.
         EntityType type;
         result = determine_entity_type( tokens.front(), type );
         if( MB_SUCCESS != result ) return result;
  
         // Create the entity.
         if( MBVERTEX == type )
         {
             double* coords[3] = { coord_arrays[0] + vert_index, coord_arrays[1] + vert_index,
                                   coord_arrays[2] + vert_index };
             result            = read_node( tokens, debug, coords, id );
             if( MB_SUCCESS != result ) return result;
             if( !nodeIdMap.insert( id, start_vert + vert_index, 1 ).second ) return MB_FAILURE;  // Duplicate IDs!
             ++vert_index;
         }
         else
         {
             result = read_element( tokens, materials, type, debug );
             if( MB_SUCCESS != result ) return result;
         }
     }
  
     result = create_materials( materials );
     if( MB_SUCCESS != result ) return result;
  
     result = assign_ids( file_id_tag );
     if( MB_SUCCESS != result ) return result;
  
     file.close();
     nodeIdMap.clear();
     elemIdMap.clear();
     return MB_SUCCESS;
 }

References assign_ids(), moab::RangeMap< KeyType, ValType, NullVal >::clear(), create_materials(), moab::debug, determine_entity_type(), determine_line_format(), elemIdMap, ErrorCode, moab::ReadUtilIface::get_node_coords(), moab::RangeMap< KeyType, ValType, NullVal >::insert(), MB_FILE_DOES_NOT_EXIST, MB_SET_ERR, MB_START_ID, MB_SUCCESS, MB_UNSUPPORTED_OPERATION, MBMAXTYPE, MBVERTEX, nodeIdMap, read_element(), read_node(), readMeshIface, and tokenize_line().

◆ read_element()

ErrorCode moab::ReadNASTRAN::read_element	(	const std::vector< std::string > &	tokens,
		std::vector< Range > &	materials,
		const EntityType	element_type,
		const bool	debug
	)

private

Definition at line 379 of file ReadNASTRAN.cpp.

 {
     // Read the element's id (unique) and material set
     ErrorCode result;
     int id       = atoi( tokens[1].c_str() );
     int material = atoi( tokens[2].c_str() );
  
     // Resize materials list if necessary. This code is somewhat complicated
     // so as to avoid copying of Ranges
     if( material >= (int)materials.size() )
     {
         if( (int)materials.capacity() < material )
             materials.resize( material + 1 );
         else
         {
             std::vector< Range > new_mat( material + 1 );
             for( size_t i = 0; i < materials.size(); ++i )
                 new_mat[i].swap( materials[i] );
             materials.swap( new_mat );
         }
     }
  
     // The size of the connectivity array depends on the element type
     int n_conn = CN::VerticesPerEntity( element_type );
     EntityHandle conn_verts[27];
     assert( n_conn <= (int)( sizeof( conn_verts ) / sizeof( EntityHandle ) ) );
  
     // Read the connected node ids from the file
     for( int i = 0; i < n_conn; i++ )
     {
         int n         = atoi( tokens[3 + i].c_str() );
         conn_verts[i] = nodeIdMap.find( n );
         if( !conn_verts[i] )  // invalid vertex id
             return MB_FAILURE;
     }
  
     // Create the element and set the global id from the NASTRAN file
     EntityHandle element;
     result = MBI->create_element( element_type, conn_verts, n_conn, element );
     if( MB_SUCCESS != result ) return result;
     elemIdMap.insert( id, element, 1 );
  
     materials[material].insert( element );
     return MB_SUCCESS;
 }

References moab::Interface::create_element(), elemIdMap, ErrorCode, moab::RangeMap< KeyType, ValType, NullVal >::find(), moab::RangeMap< KeyType, ValType, NullVal >::insert(), MB_SUCCESS, MBI, nodeIdMap, and moab::CN::VerticesPerEntity().

Referenced by load_file().

◆ read_node()

ErrorCode moab::ReadNASTRAN::read_node	(	const std::vector< std::string > &	tokens,
		const bool	debug,
		double *	coord_arrays[3],
		int &	node_id
	)

private

Definition at line 347 of file ReadNASTRAN.cpp.

 {
     // Read the node's id (unique)
     ErrorCode result;
     id = atoi( tokens[1].c_str() );
  
     // Read the node's coordinate system number
     // "0" or blank refers to the basic coordinate system.
     int coord_system = atoi( tokens[2].c_str() );
     if( 0 != coord_system )
     {
         std::cerr << "ReadNASTRAN: alternative coordinate systems not implemented" << std::endl;
         return MB_NOT_IMPLEMENTED;
     }
  
     // Read the coordinates
     for( unsigned int i = 0; i < 3; i++ )
     {
         result = get_real( tokens[i + 3], *coords[i] );
         if( MB_SUCCESS != result ) return result;
         if( debug ) std::cout << "read_node: coords[" << i << "]=" << coords[i] << std::endl;
     }
  
     return MB_SUCCESS;
 }

References moab::debug, ErrorCode, get_real(), MB_NOT_IMPLEMENTED, and MB_SUCCESS.

Referenced by load_file().

◆ read_tag_values()

ErrorCode moab::ReadNASTRAN::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 61 of file ReadNASTRAN.cpp.

 {
     return MB_NOT_IMPLEMENTED;
 }

References MB_NOT_IMPLEMENTED.

◆ tokenize_line()

ErrorCode moab::ReadNASTRAN::tokenize_line	(	const std::string &	line,
		const line_format	format,
		std::vector< std::string > &	tokens
	)

private

Definition at line 223 of file ReadNASTRAN.cpp.

 {
     size_t line_size = line.size();
     switch( format )
     {
         case SMALL_FIELD: {
             // Expect 10 fields of 8 characters.
             // The sample file does not have all 10 fields in each line
             const int field_length = 8;
             unsigned int n_tokens  = line_size / field_length;
             for( unsigned int i = 0; i < n_tokens; i++ )
             {
                 tokens.push_back( line.substr( i * field_length, field_length ) );
             }
             break;
         }
         case LARGE_FIELD:
             return MB_NOT_IMPLEMENTED;
         case FREE_FIELD:
             return MB_NOT_IMPLEMENTED;
         default:
             return MB_FAILURE;
     }
  
     return MB_SUCCESS;
 }

References FREE_FIELD, LARGE_FIELD, MB_NOT_IMPLEMENTED, MB_SUCCESS, and SMALL_FIELD.

Referenced by load_file().

Member Data Documentation

◆ elemIdMap

RangeMap< int, EntityHandle > moab::ReadNASTRAN::elemIdMap

private

Definition at line 81 of file ReadNASTRAN.hpp.

Referenced by assign_ids(), load_file(), and read_element().

◆ MBI

Interface* moab::ReadNASTRAN::MBI

private

Definition at line 79 of file ReadNASTRAN.hpp.

Referenced by assign_ids(), create_materials(), read_element(), ReadNASTRAN(), and ~ReadNASTRAN().

◆ nodeIdMap

RangeMap< int, EntityHandle > moab::ReadNASTRAN::nodeIdMap

private

Definition at line 81 of file ReadNASTRAN.hpp.

Referenced by assign_ids(), load_file(), and read_element().

◆ readMeshIface

ReadUtilIface* moab::ReadNASTRAN::readMeshIface

private

Definition at line 76 of file ReadNASTRAN.hpp.

Referenced by assign_ids(), load_file(), ReadNASTRAN(), and ~ReadNASTRAN().

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

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ line_format

Constructor & Destructor Documentation

◆ ReadNASTRAN()

◆ ~ReadNASTRAN()

Member Function Documentation

◆ assign_ids()

◆ create_materials()

◆ determine_entity_type()

◆ determine_line_format()

◆ factory()

◆ get_real()

◆ load_file()

◆ read_element()

◆ read_node()

◆ read_tag_values()

◆ tokenize_line()

Member Data Documentation

◆ elemIdMap

◆ MBI

◆ nodeIdMap

◆ readMeshIface