moab::WriteNCDF Class Reference

Output Exodus File for VERDE. More...

#include <WriteNCDF.hpp>

Inheritance diagram for moab::WriteNCDF:

Collaboration diagram for moab::WriteNCDF:

Classes
struct	ExodusMeshInfo
	contains the general information about a mesh More...

Public Member Functions
	WriteNCDF (Interface *impl)
	Constructor. More...
virtual	~WriteNCDF ()
	Destructor. More...
ErrorCode	write_file (const char *exodus_file_name, const bool overwrite, const FileOptions &opts, const EntityHandle *output_list, const int num_sets, const std::vector< std::string > &qa_records, const Tag *=NULL, int=0, int user_dimension=3)
	writes out an ExoII file More...
Public Member Functions inherited from moab::WriterIface
virtual	~WriterIface ()

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

Protected Member Functions
ErrorCode	open_file (const char *file_name)
	number of dimensions in this exo file More...

Private Member Functions
ErrorCode	gather_mesh_information (ExodusMeshInfo &mesh_info, std::vector< MaterialSetData > &block_info, std::vector< NeumannSetData > &sideset_info, std::vector< DirichletSetData > &nodeset_info, std::vector< EntityHandle > &blocks, std::vector< EntityHandle > &sidesets, std::vector< EntityHandle > &nodesets)
ErrorCode	write_header (ExodusMeshInfo &mesh_info, std::vector< MaterialSetData > &block_info, std::vector< NeumannSetData > &sideset_info, std::vector< DirichletSetData > &nodeset_info, const char *filename)
ErrorCode	initialize_exodus_file (ExodusMeshInfo &mesh_info, std::vector< MaterialSetData > &block_data, std::vector< NeumannSetData > &sideset_data, std::vector< DirichletSetData > &nodeset_data, const char *title_string, bool write_maps=true, bool write_sideset_distribution_factors=true)
ErrorCode	write_qa_string (const char *string, int record_number, int record_position)
ErrorCode	write_qa_records (std::vector< std::string > &qa_record_list)
ErrorCode	write_nodes (int num_nodes, Range &nodes, int dimension)
ErrorCode	write_poly_faces (ExodusMeshInfo &mesh_info)
ErrorCode	write_elementblocks (ExodusMeshInfo &mesh_info, std::vector< MaterialSetData > &block_data)
ErrorCode	write_exodus_integer_variable (const char *variable_name, int *variable_array, int start_position, int number_values)
ErrorCode	write_global_node_order_map (int num_nodes, Range &nodes)
ErrorCode	write_global_element_order_map (int num_elements)
ErrorCode	write_element_order_map (int num_elements)
ErrorCode	write_BCs (std::vector< NeumannSetData > &sidesets, std::vector< DirichletSetData > &nodesets)
ErrorCode	find_side_element_type (const int element_id, ExoIIElementType &type)
void	reset_block (std::vector< MaterialSetData > &block_info)
	free up allocated Ranges More...
ErrorCode	get_sideset_elems (EntityHandle sideset, int current_sense, Range &forward_elems, Range &reverse_elems)
	recursive function; given a meshset handle, get the entities and put them on the right list, then call recursively for any contained meshsets, first checking for sense reversals More...
ErrorCode	get_valid_sides (Range &elems, ExodusMeshInfo &mesh_info, const int sense, NeumannSetData &sideset_data)

Static Private Member Functions
static void	time_and_date (char *time_string, char *date_string)
	get the time and date in strings More...

Private Attributes
Interface *	mdbImpl
	interface instance More...
WriteUtilIface *	mWriteIface
std::string	exodusFile
	file name More...
int	ncFile
EntityHandle	mCurrentMeshHandle
	Meshset Handle for the mesh that is currently being read. More...
Tag	mMaterialSetTag
	Cached tags for reading. Note that all these tags are defined when the core is initialized. More...
Tag	mDirichletSetTag
Tag	mNeumannSetTag
Tag	mHasMidNodesTag
Tag	mGeomDimensionTag
Tag	mDistFactorTag
Tag	mGlobalIdTag
Tag	mQaRecordTag
Tag	mEntityMark
int	repeat_face_blocks

Detailed Description

Output Exodus File for VERDE.

Definition at line 85 of file WriteNCDF.hpp.

Constructor & Destructor Documentation

WriteNCDF()

moab::WriteNCDF::WriteNCDF

(

Interface *

impl

)

Constructor.

Get and cache predefined tag handles

Definition at line 100 of file WriteNCDF.cpp.

 : mdbImpl( impl ), ncFile( 0 ), mCurrentMeshHandle( 0 ), mGeomDimensionTag( 0 ), repeat_face_blocks( 0 )
{
 assert( impl != NULL );
 
 impl->query_interface( mWriteIface );
 
 // Initialize in case tag_get_handle fails below
 //! Get and cache predefined tag handles
 int negone = -1;
 impl->tag_get_handle( MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, mMaterialSetTag, MB_TAG_SPARSE | MB_TAG_CREAT,
 &negone );
 
 impl->tag_get_handle( DIRICHLET_SET_TAG_NAME, 1, MB_TYPE_INTEGER, mDirichletSetTag, MB_TAG_SPARSE | MB_TAG_CREAT,
 &negone );
 
 impl->tag_get_handle( NEUMANN_SET_TAG_NAME, 1, MB_TYPE_INTEGER, mNeumannSetTag, MB_TAG_SPARSE | MB_TAG_CREAT,
 &negone );
 
 mGlobalIdTag = impl->globalId_tag();
 
 int dum_val_array[] = { -1, -1, -1, -1 };
 impl->tag_get_handle( HAS_MID_NODES_TAG_NAME, 4, MB_TYPE_INTEGER, mHasMidNodesTag, MB_TAG_SPARSE | MB_TAG_CREAT,
 dum_val_array );
 
 impl->tag_get_handle( "distFactor", 0, MB_TYPE_DOUBLE, mDistFactorTag,
 MB_TAG_SPARSE | MB_TAG_VARLEN | MB_TAG_CREAT );
 
 impl->tag_get_handle( "qaRecord", 0, MB_TYPE_OPAQUE, mQaRecordTag, MB_TAG_SPARSE | MB_TAG_VARLEN | MB_TAG_CREAT );
 
 impl->tag_get_handle( "WriteNCDF element mark", 1, MB_TYPE_BIT, mEntityMark, MB_TAG_CREAT );
}

References DIRICHLET_SET_TAG_NAME, moab::Interface::globalId_tag(), HAS_MID_NODES_TAG_NAME, MATERIAL_SET_TAG_NAME, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TAG_VARLEN, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, mDirichletSetTag, mDistFactorTag, mEntityMark, mGlobalIdTag, mHasMidNodesTag, mMaterialSetTag, mNeumannSetTag, mQaRecordTag, mWriteIface, NEUMANN_SET_TAG_NAME, moab::Interface::query_interface(), and moab::Interface::tag_get_handle().

Referenced by factory().

~WriteNCDF()

moab::WriteNCDF::~WriteNCDF ( )

virtual

Destructor.

Definition at line 133 of file WriteNCDF.cpp.

{
 mdbImpl->release_interface( mWriteIface );
 
 mdbImpl->tag_delete( mEntityMark );
 
 if( 0 != ncFile ) ncFile = 0;
}

References mdbImpl, mEntityMark, mWriteIface, ncFile, moab::Interface::release_interface(), and moab::Interface::tag_delete().

Member Function Documentation

factory()

WriterIface * moab::WriteNCDF::factory ( Interface *  iface )

static

Definition at line 95 of file WriteNCDF.cpp.

{
 return new WriteNCDF( iface );
}

References iface, and WriteNCDF().

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

find_side_element_type()

ErrorCode moab::WriteNCDF::find_side_element_type ( const int  element_id, ExoIIElementType &  type  )

private

gather_mesh_information()

ErrorCode moab::WriteNCDF::gather_mesh_information ( ExodusMeshInfo &  mesh_info, std::vector< MaterialSetData > &  block_info, std::vector< NeumannSetData > &  sideset_info, std::vector< DirichletSetData > &  nodeset_info, std::vector< EntityHandle > &  blocks, std::vector< EntityHandle > &  sidesets, std::vector< EntityHandle > &  nodesets  )

private

Definition at line 364 of file WriteNCDF.cpp.

{
 ErrorCode rval;
 std::vector< EntityHandle >::iterator vector_iter, end_vector_iter;
 
 mesh_info.num_nodes = 0;
 mesh_info.num_elements = 0;
 mesh_info.num_elementblocks = 0;
 mesh_info.num_polyhedra_blocks = 0;
 
 int id = 0;
 
 vector_iter = blocks.begin();
 end_vector_iter = blocks.end();
 
 std::vector< EntityHandle > parent_meshsets;
 
 // Clean out the bits for the element mark
 rval = mdbImpl->tag_delete( mEntityMark );
 if( MB_SUCCESS != rval ) return rval;
 rval = mdbImpl->tag_get_handle( "WriteNCDF element mark", 1, MB_TYPE_BIT, mEntityMark, MB_TAG_CREAT );
 if( MB_SUCCESS != rval ) return rval;
 
 int highest_dimension_of_element_blocks = 0;
 
 for( vector_iter = blocks.begin(); vector_iter != blocks.end(); ++vector_iter )
 {
 MaterialSetData block_data;
 
 // For the purpose of qa records, get the parents of these blocks
 if( mdbImpl->get_parent_meshsets( *vector_iter, parent_meshsets ) != MB_SUCCESS ) return MB_FAILURE;
 
 // Get all Entity Handles in the mesh set
 Range dummy_range;
 rval = mdbImpl->get_entities_by_handle( *vector_iter, dummy_range, true );
 if( MB_SUCCESS != rval ) return rval;
 
 // Skip empty blocks
 if( dummy_range.empty() ) continue;
 
 // Get the block's id
 if( mdbImpl->tag_get_data( mMaterialSetTag, &( *vector_iter ), 1, &id ) != MB_SUCCESS )
 {
 MB_SET_ERR( MB_FAILURE, "Couldn't get block id from a tag for an element block" );
 }
 
 block_data.id = id;
 block_data.number_attributes = 0;
 
 // Wait a minute, we are doing some filtering here that doesn't make sense at this level CJS
 
 // Find the dimension of the last entity in this range
 int this_dim = CN::Dimension( TYPE_FROM_HANDLE( dummy_range.back() ) );
 if( this_dim > 3 )
 {
 MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, "Block " << id << " contains entity sets" );
 }
 block_data.elements = dummy_range.subset_by_dimension( this_dim );
 
 // End of -- wait a minute, we are doing some filtering here that doesn't make sense at this
 // level CJS
 
 // Get the entity type for this block, verifying that it's the same for all elements
 EntityType entity_type = TYPE_FROM_HANDLE( block_data.elements.front() );
 if( !block_data.elements.all_of_type( entity_type ) )
 {
 MB_SET_ERR( MB_FAILURE, "Entities in block " << id << " not of common type" );
 }
 
 int dimension = -1;
 if( entity_type == MBQUAD || entity_type == MBTRI )
 dimension = 2; // Output shells by default
 else if( entity_type == MBEDGE )
 dimension = 1;
 else
 dimension = CN::Dimension( entity_type );
 
 if( dimension > highest_dimension_of_element_blocks ) highest_dimension_of_element_blocks = dimension;
 
 std::vector< EntityHandle > tmp_conn;
 rval = mdbImpl->get_connectivity( &( block_data.elements.front() ), 1, tmp_conn );
 if( MB_SUCCESS != rval ) return rval;
 block_data.element_type = ExoIIUtil::get_element_type_from_num_verts( tmp_conn.size(), entity_type, dimension );
 
 if( block_data.element_type == EXOII_MAX_ELEM_TYPE )
 {
 MB_SET_ERR( MB_FAILURE, "Element type in block " << id << " didn't get set correctly" );
 }
 
 if( block_data.element_type == EXOII_POLYGON )
 {
 // get all poly connectivity
 int numconn = 0;
 for( Range::iterator eit = block_data.elements.begin(); eit != block_data.elements.end(); eit++ )
 {
 EntityHandle polg = *eit;
 int nnodes = 0;
 const EntityHandle* conn = NULL;
 rval = mdbImpl->get_connectivity( polg, conn, nnodes );MB_CHK_ERR( rval );
 numconn += nnodes;
 }
 block_data.number_nodes_per_element = numconn;
 }
 else
 block_data.number_nodes_per_element = ExoIIUtil::VerticesPerElement[block_data.element_type];
 
 // Number of nodes for this block
 block_data.number_elements = block_data.elements.size();
 
 // Total number of elements
 mesh_info.num_elements += block_data.number_elements;
 
 // Get the nodes for the elements
 rval = mWriteIface->gather_nodes_from_elements( block_data.elements, mEntityMark, mesh_info.nodes );
 if( MB_SUCCESS != rval ) return rval;
 
 // if polyhedra block
 if( EXOII_POLYHEDRON == block_data.element_type )
 {
 rval = mdbImpl->get_connectivity( block_data.elements, mesh_info.polyhedronFaces );MB_CHK_ERR( rval );
 mesh_info.num_polyhedra_blocks++;
 }
 
 if( !sidesets.empty() )
 {
 // If there are sidesets, keep track of which elements are being written out
 for( Range::iterator iter = block_data.elements.begin(); iter != block_data.elements.end(); ++iter )
 {
 unsigned char bit = 0x1;
 rval = mdbImpl->tag_set_data( mEntityMark, &( *iter ), 1, &bit );
 if( MB_SUCCESS != rval ) return rval;
 }
 }
 
 block_info.push_back( block_data );
 
 const void* data = NULL;
 int size = 0;
 if( MB_SUCCESS == mdbImpl->tag_get_by_ptr( mQaRecordTag, &( *vector_iter ), 1, &data, &size ) && NULL != data )
 {
 // There are qa records on this block - copy over to mesh qa records
 const char* qa_rec = static_cast< const char* >( data );
 int start = 0;
 int count = 0;
 for( int i = 0; i < size; i++ )
 {
 if( qa_rec[i] == '\0' )
 {
 std::string qa_string( &qa_rec[start], i - start );
 mesh_info.qaRecords.push_back( qa_string );
 start = i + 1;
 count++;
 }
 }
 
 // Constrained to multiples of 4 qa records
 if( count > 0 ) assert( count % 4 == 0 );
 }
 }
 
 mesh_info.num_elementblocks = block_info.size();
 
 for( std::vector< MaterialSetData >::iterator blit = block_info.begin(); blit != block_info.end(); blit++ )
 {
 MaterialSetData& block = *blit;
 if( block.element_type != EXOII_POLYHEDRON )
 {
 mesh_info.polyhedronFaces = subtract( mesh_info.polyhedronFaces, block.elements );
 }
 }
 
 // If user hasn't entered dimension, we figure it out
 if( mesh_info.num_dim == 0 )
 {
 // Never want 1 or zero dimensions
 if( highest_dimension_of_element_blocks < 2 )
 mesh_info.num_dim = 3;
 else
 mesh_info.num_dim = highest_dimension_of_element_blocks;
 }
 
 Range::iterator range_iter, end_range_iter;
 range_iter = mesh_info.nodes.begin();
 end_range_iter = mesh_info.nodes.end();
 
 mesh_info.num_nodes = mesh_info.nodes.size();
 
 //------nodesets--------
 
 vector_iter = nodesets.begin();
 end_vector_iter = nodesets.end();
 
 for( ; vector_iter != end_vector_iter; ++vector_iter )
 {
 DirichletSetData nodeset_data;
 nodeset_data.id = 0;
 nodeset_data.number_nodes = 0;
 
 // Get the nodeset's id
 if( mdbImpl->tag_get_data( mDirichletSetTag, &( *vector_iter ), 1, &id ) != MB_SUCCESS )
 {
 MB_SET_ERR( MB_FAILURE, "Couldn't get id tag for nodeset " << id );
 }
 
 nodeset_data.id = id;
 
 std::vector< EntityHandle > node_vector;
 // Get the nodes of the nodeset that are in mesh_info.nodes
 if( mdbImpl->get_entities_by_handle( *vector_iter, node_vector, true ) != MB_SUCCESS )
 {
 MB_SET_ERR( MB_FAILURE, "Couldn't get nodes in nodeset " << id );
 }
 
 // Get the tag for distribution factors
 const double* dist_factor_vector;
 int dist_factor_size;
 const void* ptr = 0;
 
 int has_dist_factors = 0;
 if( mdbImpl->tag_get_by_ptr( mDistFactorTag, &( *vector_iter ), 1, &ptr, &dist_factor_size ) == MB_SUCCESS &&
 dist_factor_size )
 has_dist_factors = 1;
 dist_factor_size /= sizeof( double );
 dist_factor_vector = reinterpret_cast< const double* >( ptr );
 std::vector< EntityHandle >::iterator iter, end_iter;
 iter = node_vector.begin();
 end_iter = node_vector.end();
 
 int j = 0;
 unsigned char node_marked = 0;
 ErrorCode result;
 for( ; iter != end_iter; ++iter )
 {
 if( TYPE_FROM_HANDLE( *iter ) != MBVERTEX ) continue;
 result = mdbImpl->tag_get_data( mEntityMark, &( *iter ), 1, &node_marked );MB_CHK_SET_ERR( result, "Couldn't get mark data" );
 
 if( 0x1 == node_marked )
 {
 nodeset_data.nodes.push_back( *iter );
 if( 0 != has_dist_factors )
 nodeset_data.node_dist_factors.push_back( dist_factor_vector[j] );
 else
 nodeset_data.node_dist_factors.push_back( 1.0 );
 }
 j++;
 }
 
 nodeset_data.number_nodes = nodeset_data.nodes.size();
 nodeset_info.push_back( nodeset_data );
 }
 
 //------sidesets--------
 vector_iter = sidesets.begin();
 end_vector_iter = sidesets.end();
 
 for( ; vector_iter != end_vector_iter; ++vector_iter )
 {
 NeumannSetData sideset_data;
 
 // Get the sideset's id
 if( mdbImpl->tag_get_data( mNeumannSetTag, &( *vector_iter ), 1, &id ) != MB_SUCCESS ) return MB_FAILURE;
 
 sideset_data.id = id;
 sideset_data.mesh_set_handle = *vector_iter;
 
 // Get the sides in two lists, one forward the other reverse; starts with forward sense
 // by convention
 Range forward_elems, reverse_elems;
 if( get_sideset_elems( *vector_iter, 0, forward_elems, reverse_elems ) == MB_FAILURE ) return MB_FAILURE;
 
 ErrorCode result = get_valid_sides( forward_elems, mesh_info, 1, sideset_data );MB_CHK_SET_ERR( result, "Couldn't get valid sides data" );
 result = get_valid_sides( reverse_elems, mesh_info, -1, sideset_data );MB_CHK_SET_ERR( result, "Couldn't get valid sides data" );
 
 sideset_data.number_elements = sideset_data.elements.size();
 sideset_info.push_back( sideset_data );
 }
 
 return MB_SUCCESS;
}

References moab::Range::all_of_type(), moab::Range::back(), moab::Range::begin(), moab::CN::Dimension(), moab::MaterialSetData::element_type, moab::MaterialSetData::elements, moab::NeumannSetData::elements, moab::Range::empty(), moab::Range::end(), ErrorCode, moab::EXOII_MAX_ELEM_TYPE, moab::EXOII_POLYGON, moab::EXOII_POLYHEDRON, moab::Range::front(), moab::WriteUtilIface::gather_nodes_from_elements(), moab::Interface::get_connectivity(), moab::ExoIIUtil::get_element_type_from_num_verts(), moab::Interface::get_entities_by_handle(), moab::Interface::get_parent_meshsets(), get_sideset_elems(), get_valid_sides(), moab::MaterialSetData::id, moab::DirichletSetData::id, moab::NeumannSetData::id, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TYPE_BIT, MB_TYPE_OUT_OF_RANGE, MBEDGE, MBQUAD, MBTRI, MBVERTEX, mdbImpl, mDirichletSetTag, mDistFactorTag, mEntityMark, moab::NeumannSetData::mesh_set_handle, mMaterialSetTag, mNeumannSetTag, mQaRecordTag, mWriteIface, moab::DirichletSetData::node_dist_factors, moab::DirichletSetData::nodes, moab::WriteNCDF::ExodusMeshInfo::nodes, moab::WriteNCDF::ExodusMeshInfo::num_dim, moab::WriteNCDF::ExodusMeshInfo::num_elementblocks, moab::WriteNCDF::ExodusMeshInfo::num_elements, moab::WriteNCDF::ExodusMeshInfo::num_nodes, moab::WriteNCDF::ExodusMeshInfo::num_polyhedra_blocks, moab::MaterialSetData::number_attributes, moab::MaterialSetData::number_elements, moab::NeumannSetData::number_elements, moab::DirichletSetData::number_nodes, moab::MaterialSetData::number_nodes_per_element, moab::WriteNCDF::ExodusMeshInfo::polyhedronFaces, moab::WriteNCDF::ExodusMeshInfo::qaRecords, size, moab::Range::size(), moab::Range::subset_by_dimension(), moab::subtract(), moab::Interface::tag_delete(), moab::Interface::tag_get_by_ptr(), moab::Interface::tag_get_data(), moab::Interface::tag_get_handle(), moab::Interface::tag_set_data(), moab::TYPE_FROM_HANDLE(), and moab::ExoIIUtil::VerticesPerElement.

Referenced by write_file().

get_sideset_elems()

ErrorCode moab::WriteNCDF::get_sideset_elems ( EntityHandle  sideset, int  current_sense, Range &  forward_elems, Range &  reverse_elems  )

private

recursive function; given a meshset handle, get the entities and put them on the right list, then call recursively for any contained meshsets, first checking for sense reversals

Definition at line 2285 of file WriteNCDF.cpp.

{
 Range ss_elems, ss_meshsets;
 
 // Get the sense tag; don't need to check return, might be an error if the tag
 // hasn't been created yet
 Tag sense_tag = 0;
 mdbImpl->tag_get_handle( "SENSE", 1, MB_TYPE_INTEGER, sense_tag );
 
 // Get the entities in this set
 ErrorCode result = mdbImpl->get_entities_by_handle( sideset, ss_elems, true );
 if( MB_FAILURE == result ) return result;
 
 // Now remove the meshsets into the ss_meshsets; first find the first meshset,
 Range::iterator range_iter = ss_elems.begin();
 while( TYPE_FROM_HANDLE( *range_iter ) != MBENTITYSET && range_iter != ss_elems.end() )
 ++range_iter;
 
 // Then, if there are some, copy them into ss_meshsets and erase from ss_elems
 if( range_iter != ss_elems.end() )
 {
 std::copy( range_iter, ss_elems.end(), range_inserter( ss_meshsets ) );
 ss_elems.erase( range_iter, ss_elems.end() );
 }
 
 // OK, for the elements, check the sense of this set and copy into the right range
 // (if the sense is 0, copy into both ranges)
 
 // Need to step forward on list until we reach the right dimension
 Range::iterator dum_it = ss_elems.end();
 --dum_it;
 int target_dim = CN::Dimension( TYPE_FROM_HANDLE( *dum_it ) );
 dum_it = ss_elems.begin();
 while( target_dim != CN::Dimension( TYPE_FROM_HANDLE( *dum_it ) ) && dum_it != ss_elems.end() )
 ++dum_it;
 
 if( current_sense == 1 || current_sense == 0 ) std::copy( dum_it, ss_elems.end(), range_inserter( forward_elems ) );
 if( current_sense == -1 || current_sense == 0 )
 std::copy( dum_it, ss_elems.end(), range_inserter( reverse_elems ) );
 
 // Now loop over the contained meshsets, getting the sense of those and calling this
 // function recursively
 for( range_iter = ss_meshsets.begin(); range_iter != ss_meshsets.end(); ++range_iter )
 {
 // First get the sense; if it's not there, by convention it's forward
 int this_sense;
 if( 0 == sense_tag || MB_FAILURE == mdbImpl->tag_get_data( sense_tag, &( *range_iter ), 1, &this_sense ) )
 this_sense = 1;
 
 // Now get all the entities on this meshset, with the proper (possibly reversed) sense
 get_sideset_elems( *range_iter, this_sense * current_sense, forward_elems, reverse_elems );
 }
 
 return result;
}

References moab::Range::begin(), moab::CN::Dimension(), moab::Range::end(), moab::Range::erase(), ErrorCode, moab::Interface::get_entities_by_handle(), MB_TYPE_INTEGER, MBENTITYSET, mdbImpl, moab::Interface::tag_get_data(), moab::Interface::tag_get_handle(), and moab::TYPE_FROM_HANDLE().

Referenced by gather_mesh_information().

get_valid_sides()

ErrorCode moab::WriteNCDF::get_valid_sides ( Range &  elems, ExodusMeshInfo &  mesh_info, const int  sense, NeumannSetData &  sideset_data  )

private

Definition at line 650 of file WriteNCDF.cpp.

{
 // This is where we see if underlying element of side set element is included in output
 
 // Get the sideset-based info for distribution factors
 const double* dist_factor_vector = 0;
 int dist_factor_size = 0;
 
 // Initialize dist_fac_iter to get rid of compiler warning
 const double* dist_fac_iter = 0;
 const void* ptr = 0;
 bool has_dist_factors = false;
 if( mdbImpl->tag_get_by_ptr( mDistFactorTag, &( sideset_data.mesh_set_handle ), 1, &ptr, &dist_factor_size ) ==
 MB_SUCCESS &&
 dist_factor_size )
 {
 has_dist_factors = true;
 dist_factor_vector = reinterpret_cast< const double* >( ptr );
 dist_fac_iter = dist_factor_vector;
 dist_factor_size /= sizeof( double );
 }
 
 unsigned char element_marked = 0;
 ErrorCode result;
 for( Range::iterator iter = elems.begin(); iter != elems.end(); ++iter )
 {
 // Should insert here if "side" is a quad/tri on a quad/tri mesh
 result = mdbImpl->tag_get_data( mEntityMark, &( *iter ), 1, &element_marked );MB_CHK_SET_ERR( result, "Couldn't get mark data" );
 
 if( 0x1 == element_marked )
 {
 sideset_data.elements.push_back( *iter );
 
 // TJT TODO: the sense should really be # edges + 1or2
 sideset_data.side_numbers.push_back( ( sense == 1 ? 1 : 2 ) );
 }
 else
 { // Then "side" is probably a quad/tri on a hex/tet mesh
 std::vector< EntityHandle > parents;
 int dimension = CN::Dimension( TYPE_FROM_HANDLE( *iter ) );
 
 // Get the adjacent parent element of "side"
 if( mdbImpl->get_adjacencies( &( *iter ), 1, dimension + 1, false, parents ) != MB_SUCCESS )
 {
#if 0
 // This is not treated as an error, print warning messages for
 // debugging only
 fprintf(stderr, "[Warning]: Couldn't get adjacencies for sideset.\n");
#endif
 }
 
 if( !parents.empty() )
 {
 // Make sure the adjacent parent element will be output
 for( unsigned int k = 0; k < parents.size(); k++ )
 {
 result = mdbImpl->tag_get_data( mEntityMark, &( parents[k] ), 1, &element_marked );MB_CHK_SET_ERR( result, "Couldn't get mark data" );
 
 int side_no, this_sense, this_offset;
 if( 0x1 == element_marked &&
 mdbImpl->side_number( parents[k], *iter, side_no, this_sense, this_offset ) == MB_SUCCESS &&
 this_sense == sense )
 {
 sideset_data.elements.push_back( parents[k] );
 sideset_data.side_numbers.push_back( side_no + 1 );
 break;
 }
 }
 }
 else
 {
#if 0
 // This is not treated as an error, print warning messages for
 // debugging only
 fprintf(stderr, "[Warning]: No parent element exists for element in sideset %i\n", sideset_data.id);
#endif
 }
 }
 
 if( sideset_data.elements.size() != 0 )
 {
 // Distribution factors
 int num_nodes = CN::VerticesPerEntity( TYPE_FROM_HANDLE( *iter ) );
 // put some dummy dist factors for polygons; why do we need them?
 if( TYPE_FROM_HANDLE( *iter ) == MBPOLYGON ) num_nodes = 1; // dummy
 if( has_dist_factors )
 {
 std::copy( dist_fac_iter, dist_fac_iter + num_nodes,
 std::back_inserter( sideset_data.ss_dist_factors ) );
 dist_fac_iter += num_nodes;
 }
 else
 {
 for( int j = 0; j < num_nodes; j++ )
 sideset_data.ss_dist_factors.push_back( 1.0 );
 }
 }
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::CN::Dimension(), moab::NeumannSetData::elements, moab::Range::end(), ErrorCode, moab::Interface::get_adjacencies(), moab::NeumannSetData::id, MB_CHK_SET_ERR, MB_SUCCESS, MBPOLYGON, mdbImpl, mDistFactorTag, mEntityMark, moab::NeumannSetData::mesh_set_handle, moab::Interface::side_number(), moab::NeumannSetData::side_numbers, moab::NeumannSetData::ss_dist_factors, moab::Interface::tag_get_by_ptr(), moab::Interface::tag_get_data(), moab::TYPE_FROM_HANDLE(), and moab::CN::VerticesPerEntity().

Referenced by gather_mesh_information().

initialize_exodus_file()

ErrorCode moab::WriteNCDF::initialize_exodus_file ( ExodusMeshInfo &  mesh_info, std::vector< MaterialSetData > &  block_data, std::vector< NeumannSetData > &  sideset_data, std::vector< DirichletSetData > &  nodeset_data, const char *  title_string, bool  write_maps = true, bool  write_sideset_distribution_factors = true  )

private

Definition at line 1569 of file WriteNCDF.cpp.

{
 // This routine takes the place of the exodusii routine ex_put_init,
 // and additionally pre-defines variables such as qa, element blocks,
 // sidesets and nodesets in a single pass.
 //
 // This is necessary because of the way exodusII works. Each time the
 // netcdf routine endef is called to take the file out of define mode,
 // the entire file is copied before the new information is added.
 //
 // With very large files, this is simply not workable. This routine takes
 // the definition portions of all applicable exodus routines and puts them
 // in a single definition, preventing repeated copying of the file.
 //
 // Most of the code is copied directly from the applicable exodus routine,
 // and thus this routine may not seem very consistent in usage or variable
 // naming, etc.
 
 // Perform the initializations
 
 int element_block_index;
 
 // Inquire on defined string dimension and general dimension for qa
 
 int dim_str, dim_four, dim_line, dim_time;
 if( nc_def_dim( ncFile, "len_string", ExoIIInterface::MAX_STR_LENGTH, &dim_str ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to get string length in file" );
 }
 
 if( nc_def_dim( ncFile, "len_line", ExoIIInterface::MAX_STR_LENGTH, &dim_line ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to get line length in file" );
 }
 
 if( nc_def_dim( ncFile, "four", 4, &dim_four ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to locate four in file" );
 }
 
 if( nc_def_dim( ncFile, "time_step", 1, &dim_time ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to locate time step in file" );
 }
 // some whole_time dummy :(
 int dtime;
 if( NC_NOERR != nc_def_var( ncFile, "time_whole", NC_DOUBLE, 1, &dim_time, &dtime ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define time whole array" );
 }
 
 /* Put file into define mode */
 
 // It is possible that an NT filename using backslashes is in the title string
 // this can give fits to unix codes where the backslash is assumed to be an escape
 // sequence. For the exodus file, just flip the backslash to a slash to prevent
 // this problem
 
 // Get a working copy of the title_string;
 
 char working_title[80];
 strncpy( working_title, title_string, 79 );
 
 int length = strlen( working_title );
 for( int pos = 0; pos < length; pos++ )
 {
 if( working_title[pos] == '\\' ) working_title[pos] = '/';
 }
 
 if( NC_NOERR != nc_put_att_text( ncFile, NC_GLOBAL, "title", length, working_title ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define title attribute" );
 }
 
 // Add other attributes while we're at it
 float dum_vers = 6.28F;
 if( NC_NOERR != nc_put_att_float( ncFile, NC_GLOBAL, "api_version", NC_FLOAT, 1, &dum_vers ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define api_version attribute" );
 }
 dum_vers = 6.28F;
 if( NC_NOERR != nc_put_att_float( ncFile, NC_GLOBAL, "version", NC_FLOAT, 1, &dum_vers ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define version attribute" );
 }
 int dum_siz = sizeof( double );
 if( NC_NOERR != nc_put_att_int( ncFile, NC_GLOBAL, "floating_point_word_size", NC_INT, 1, &dum_siz ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define floating pt word size attribute" );
 }
 
 // Set up number of dimensions
 
 int num_el_blk, num_elem, num_nodes, num_dim, num_fa_blk, num_faces;
 if( nc_def_dim( ncFile, "num_dim", (size_t)mesh_info.num_dim, &num_dim ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of dimensions" );
 }
 
 if( nc_def_dim( ncFile, "num_nodes", mesh_info.num_nodes, &num_nodes ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of nodes" );
 }
 
 int num_nod_per_fa; // it is needed for polyhedron only; need to compute it (connectivity of
 // faces of polyhedra)
 if( mesh_info.polyhedronFaces.size() > 0 )
 if( nc_def_dim( ncFile, "num_faces", (int)mesh_info.polyhedronFaces.size(), &num_faces ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of nodes" );
 }
 
 if( nc_def_dim( ncFile, "num_elem", mesh_info.num_elements, &num_elem ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of elements" );
 }
 
 if( nc_def_dim( ncFile, "num_el_blk", mesh_info.num_elementblocks, &num_el_blk ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of element blocks" );
 }
 
 /* ...and some variables */
 
 /* Element block id status array */
 int idstat = -1;
 if( NC_NOERR != nc_def_var( ncFile, "eb_status", NC_LONG, 1, &num_el_blk, &idstat ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define element block status array" );
 }
 
 /* Element block id array */
 
 int idarr = -1;
 if( NC_NOERR != nc_def_var( ncFile, "eb_prop1", NC_LONG, 1, &num_el_blk, &idarr ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define element block id array" );
 }
 
 /* store property name as attribute of property array variable */
 if( NC_NOERR != nc_put_att_text( ncFile, idarr, "name", strlen( "ID" ), "ID" ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store element block property name ID" );
 }
 
 // count how many are polyhedron blocks
 int num_fa_blocks = 0, num_polyh_blocks = 0;
 for( unsigned int i = 0; i < block_data.size(); i++ )
 {
 MaterialSetData& block = block_data[i];
 if( EXOII_POLYHEDRON == block.element_type )
 {
 num_fa_blocks++;
 num_polyh_blocks++;
 }
 }
 if( 0 == this->repeat_face_blocks && num_fa_blocks > 1 ) num_fa_blocks = 1;
 char wname[80];
 
 if( num_fa_blocks > 0 )
 {
 /* face block id status array */
 if( nc_def_dim( ncFile, "num_fa_blk", num_fa_blocks, &num_fa_blk ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of face blocks" );
 }
 
 int idstatf = -1;
 if( NC_NOERR != nc_def_var( ncFile, "fa_status", NC_LONG, 1, &num_fa_blk, &idstatf ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define face block status array" );
 }
 
 /* Element block id array */
 
 int idarrf = -1;
 if( NC_NOERR != nc_def_var( ncFile, "fa_prop1", NC_LONG, 1, &num_fa_blk, &idarrf ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define face block id array" );
 }
 
 /* store property name as attribute of property array variable */
 if( NC_NOERR != nc_put_att_text( ncFile, idarrf, "name", strlen( "ID" ), "ID" ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store face block property name ID" );
 }
 // determine the number of num_nod_per_face
 /*
 num_fa_in_blk1 = 15 ;
 num_nod_per_fa1 = 58 ;
 
 int fbconn1(num_nod_per_fa1) ;
 fbconn1:elem_type = "nsided" ;
 int fbepecnt1(num_fa_in_blk1) ;
 fbepecnt1:entity_type1 = "NODE" ;
 fbepecnt1:entity_type2 = "FACE" ;
 */
 
 int num_nodes_per_face = 0;
 
 int dims[1]; // maybe 1 is enough here
 for( Range::iterator eit = mesh_info.polyhedronFaces.begin(); eit != mesh_info.polyhedronFaces.end(); eit++ )
 {
 EntityHandle polyg = *eit;
 int nnodes = 0;
 const EntityHandle* conn = NULL;
 ErrorCode rval = mdbImpl->get_connectivity( polyg, conn, nnodes );MB_CHK_ERR( rval );
 num_nodes_per_face += nnodes;
 }
 
 // duplicate if needed; default is not duplicate
 for( int j = 1; j <= num_fa_blocks; j++ )
 {
 INS_ID( wname, "num_nod_per_fa%d", j );
 if( nc_def_dim( ncFile, wname, (size_t)num_nodes_per_face, &num_nod_per_fa ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of nodes for face block " );
 }
 dims[0] = num_nod_per_fa;
 INS_ID( wname, "fbconn%d", j ); // first one, or more
 int fbconn;
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, dims, &fbconn ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create connectivity array for face block " << 1 );
 }
 std::string element_type_string( "nsided" );
 if( NC_NOERR != nc_put_att_text( ncFile, fbconn, "elem_type", element_type_string.length(),
 element_type_string.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store element type nsided " );
 }
 
 INS_ID( wname, "num_fa_in_blk%d", j ); // first one, or more
 int num_fa_in_blk;
 if( nc_def_dim( ncFile, wname, (size_t)mesh_info.polyhedronFaces.size(), &num_fa_in_blk ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of nodes for face block " );
 }
 
 // fbepecnt
 INS_ID( wname, "fbepecnt%d", j ); // first one, or more
 int fbepecnt;
 dims[0] = num_fa_in_blk;
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, dims, &fbepecnt ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create fbepecnt array for block " << 1 );
 }
 std::string enttype1( "NODE" );
 if( NC_NOERR != nc_put_att_text( ncFile, fbepecnt, "entity_type1", enttype1.length(), enttype1.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store entity type 1 " );
 }
 std::string enttype2( "FACE" );
 if( NC_NOERR != nc_put_att_text( ncFile, fbepecnt, "entity_type2", enttype2.length(), enttype2.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store entity type 2 " );
 }
 }
 }
 
 // Define element blocks
 
 for( unsigned int i = 0; i < block_data.size(); i++ )
 {
 MaterialSetData& block = block_data[i];
 
 element_block_index = i + 1;
 int num_el_in_blk = -1, num_att_in_blk = -1;
 int blk_attrib, connect;
 
 /* Define number of elements in this block */
 
 INS_ID( wname, "num_el_in_blk%d", element_block_index );
 if( nc_def_dim( ncFile, wname, (size_t)block.number_elements, &num_el_in_blk ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of elements/block for block " << i + 1 );
 }
 
 /* Define number of nodes per element for this block */
 INS_ID( wname, "num_nod_per_el%d", element_block_index );
 int num_nod_per_el = -1;
 if( EXOII_POLYHEDRON != block.element_type )
 if( nc_def_dim( ncFile, wname, (size_t)block.number_nodes_per_element, &num_nod_per_el ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of nodes/element for block " << block.id );
 }
 
 /* Define element attribute array for this block */
 int dims[3];
 if( block.number_attributes > 0 )
 {
 INS_ID( wname, "num_att_in_blk%d", element_block_index );
 if( nc_def_dim( ncFile, wname, (size_t)block.number_attributes, &num_att_in_blk ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of attributes in block " << block.id );
 }
 
 INS_ID( wname, "attrib%d", element_block_index );
 dims[0] = num_el_in_blk;
 dims[1] = num_att_in_blk;
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_DOUBLE, 2, dims, &blk_attrib ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define attributes for element block " << block.id );
 }
 }
 
 /* Define element connectivity array for this block */
 
 if( EXOII_POLYGON != block.element_type && EXOII_POLYHEDRON != block.element_type )
 {
 INS_ID( wname, "connect%d", element_block_index );
 dims[0] = num_el_in_blk;
 dims[1] = num_nod_per_el;
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 2, dims, &connect ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create connectivity array for block " << i + 1 );
 }
 
 /* Store element type as attribute of connectivity variable */
 
 std::string element_type_string( ExoIIUtil::ElementTypeNames[block.element_type] );
 if( NC_NOERR != nc_put_att_text( ncFile, connect, "elem_type", element_type_string.length(),
 element_type_string.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store element type name " << (int)block.element_type );
 }
 }
 else if( EXOII_POLYGON == block.element_type )
 {
 INS_ID( wname, "connect%d", element_block_index );
 // need to define num_nod_per_el as total number of nodes
 // ebepecnt1 as number of nodes per polygon
 /*
 * int connect1(num_nod_per_el1) ;
 connect1:elem_type = "nsided" ;
 int ebepecnt1(num_el_in_blk1) ;
 ebepecnt1:entity_type1 = "NODE" ;
 ebepecnt1:entity_type2 = "ELEM" ;*/
 dims[0] = num_nod_per_el;
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, dims, &connect ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create connectivity array for block " << i + 1 );
 }
 std::string element_type_string( "nsided" );
 if( NC_NOERR != nc_put_att_text( ncFile, connect, "elem_type", element_type_string.length(),
 element_type_string.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store element type name " << (int)block.element_type );
 }
 INS_ID( wname, "ebepecnt%d", element_block_index );
 int ebepecnt;
 dims[0] = num_el_in_blk;
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, dims, &ebepecnt ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create ebepecnt array for block " << i + 1 );
 }
 std::string etype1( "NODE" );
 if( NC_NOERR != nc_put_att_text( ncFile, ebepecnt, "entity_type1", etype1.length(), etype1.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store entity type1 " << (int)block.element_type );
 }
 std::string etype2( "ELEM" );
 if( NC_NOERR != nc_put_att_text( ncFile, ebepecnt, "entity_type2", etype2.length(), etype2.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store entity type2 " << (int)block.element_type );
 }
 }
 else if( EXOII_POLYHEDRON == block.element_type )
 {
 // INS_ID(wname, "connect%d", element_block_index);
 /*
 testn face example: 3 polyh, 15 total faces, 2 shared; 15+2 = 17
 num_elem = 3 ;
 num_face = 15 ; // not needed?
 num_el_blk = 1 ;
 
 num_el_in_blk1 = 3 ;
 num_fac_per_el1 = 17 ;
 
 * num faces will be total face conn
 * num_faces_in_block will be number of faces (non repeated)
 * num_nodes_per_face will have total face connectivity
 */
 int num_faces2 = 0;
 
 for( Range::iterator eit = block.elements.begin(); eit != block.elements.end(); eit++ )
 {
 EntityHandle polyh = *eit;
 int nfaces = 0;
 const EntityHandle* conn = NULL;
 ErrorCode rval = mdbImpl->get_connectivity( polyh, conn, nfaces );MB_CHK_ERR( rval );
 num_faces2 += nfaces;
 }
 
 int num_fac_per_el;
 
 INS_ID( wname, "num_fac_per_el%d", element_block_index );
 if( nc_def_dim( ncFile, wname, (size_t)num_faces2, &num_fac_per_el ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of faces per block " << block.id );
 }
 
 /*
 int facconn1(num_fac_per_el1) ;
 facconn1:elem_type = "NFACED" ;
 int ebepecnt1(num_el_in_blk1) ;
 ebepecnt1:entity_type1 = "FACE" ;
 ebepecnt1:entity_type2 = "ELEM" ;
 */
 
 // facconn
 INS_ID( wname, "facconn%d", element_block_index );
 int facconn;
 dims[0] = num_fac_per_el;
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, dims, &facconn ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create facconn array for block " << i + 1 );
 }
 std::string etype( "NFACED" );
 if( NC_NOERR != nc_put_att_text( ncFile, facconn, "elem_type", etype.length(), etype.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store elem type " << (int)block.element_type );
 }
 
 // ebepecnt
 INS_ID( wname, "ebepecnt%d", element_block_index );
 int ebepecnt;
 dims[0] = num_el_in_blk;
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, dims, &ebepecnt ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create ebepecnt array for block " << i + 1 );
 }
 std::string etype1( "FACE" );
 if( NC_NOERR != nc_put_att_text( ncFile, ebepecnt, "entity_type1", etype1.length(), etype1.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store entity type1 " << (int)block.element_type );
 }
 std::string etype2( "ELEM" );
 if( NC_NOERR != nc_put_att_text( ncFile, ebepecnt, "entity_type2", etype2.length(), etype2.c_str() ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store entity type2 " << (int)block.element_type );
 }
 
 block.number_nodes_per_element = num_faces2; // connectivity for all polyhedra in block
 }
 }
 
 /* Node set id array: */
 
 int non_empty_nss = 0;
 // Need to go through nodesets to compute # nodesets, some might be empty
 std::vector< DirichletSetData >::iterator ns_it;
 for( ns_it = nodeset_data.begin(); ns_it != nodeset_data.end(); ++ns_it )
 {
 if( 0 != ( *ns_it ).number_nodes ) non_empty_nss++;
 }
 
 int num_ns = -1;
 int ns_idstat = -1, ns_idarr = -1;
 if( non_empty_nss > 0 )
 {
 if( nc_def_dim( ncFile, "num_node_sets", (size_t)( non_empty_nss ), &num_ns ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of node sets" );
 }
 
 /* Node set id status array: */
 
 if( NC_NOERR != nc_def_var( ncFile, "ns_status", NC_LONG, 1, &num_ns, &ns_idstat ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create node sets status array" );
 }
 
 /* Node set id array: */
 if( NC_NOERR != nc_def_var( ncFile, "ns_prop1", NC_LONG, 1, &num_ns, &ns_idarr ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create node sets property array" );
 }
 
 /* Store property name as attribute of property array variable */
 if( NC_NOERR != nc_put_att_text( ncFile, NC_GLOBAL, "name", strlen( "ID" ), "ID" ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store node set property name ID" );
 }
 
 // Now, define the arrays needed for each node set
 
 int index = 0;
 
 for( unsigned i = 0; i < nodeset_data.size(); i++ )
 {
 DirichletSetData node_set = nodeset_data[i];
 
 if( 0 == node_set.number_nodes )
 {
 MB_SET_ERR_CONT( "WriteNCDF: empty nodeset " << node_set.id );
 continue;
 }
 index++;
 
 int num_nod_ns = -1;
 INS_ID( wname, "num_nod_ns%d", index );
 if( nc_def_dim( ncFile, wname, (size_t)node_set.number_nodes, &num_nod_ns ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of nodes for set " << node_set.id );
 }
 
 /* Create variable array in which to store the node set node list */
 int node_ns = -1;
 INS_ID( wname, "node_ns%d", index );
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, &num_nod_ns, &node_ns ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create node set " << node_set.id << " node list" );
 }
 
 // Create distribution factor array
 int fact_ns = -1;
 INS_ID( wname, "dist_fact_ns%d", index );
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_DOUBLE, 1, &num_nod_ns, &fact_ns ) )
 {
 MB_SET_ERR( MB_FAILURE,
 "WriteNCDF: failed to create node set " << node_set.id << " distribution factor list" );
 }
 }
 }
 
 /* Side set id array: */
 
 long non_empty_ss = 0;
 // Need to go through nodesets to compute # nodesets, some might be empty
 std::vector< NeumannSetData >::iterator ss_it;
 for( ss_it = sideset_data.begin(); ss_it != sideset_data.end(); ++ss_it )
 {
 if( 0 != ( *ss_it ).number_elements ) non_empty_ss++;
 }
 
 if( non_empty_ss > 0 )
 {
 int num_ss = -1;
 if( nc_def_dim( ncFile, "num_side_sets", non_empty_ss, &num_ss ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of side sets" );
 }
 
 /* Side set id status array: */
 int ss_idstat = -1, ss_idarr = -1;
 if( NC_NOERR != nc_def_var( ncFile, "ss_status", NC_LONG, 1, &num_ss, &ss_idstat ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define side set status" );
 }
 
 /* Side set id array: */
 if( NC_NOERR != nc_def_var( ncFile, "ss_prop1", NC_LONG, 1, &num_ss, &ss_idarr ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define side set property" );
 }
 
 /* Store property name as attribute of property array variable */
 if( NC_NOERR != nc_put_att_text( ncFile, ss_idarr, "name", strlen( "ID" ), "ID" ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to store side set property name ID" );
 }
 
 // Now, define the arrays needed for each side set
 
 int index = 0;
 for( unsigned int i = 0; i < sideset_data.size(); i++ )
 {
 NeumannSetData side_set = sideset_data[i];
 
 // Don't define an empty set
 if( 0 == side_set.number_elements ) continue;
 
 index++;
 
 int num_side_ss = -1;
 int elem_ss = -1, side_ss = -1;
 INS_ID( wname, "num_side_ss%d", index );
 if( nc_def_dim( ncFile, wname, (size_t)side_set.number_elements, &num_side_ss ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of sides in side set " << side_set.id );
 }
 
 INS_ID( wname, "elem_ss%d", index );
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, &num_side_ss, &elem_ss ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create element list for side set "
 << side_set.id ); /* Exit define mode and return */
 }
 INS_ID( wname, "side_ss%d", index );
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, &num_side_ss, &side_ss ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create side list for side set "
 << side_set.id ); /* Exit define mode and return */
 }
 
 // sideset distribution factors
 int num_df_ss = -1;
 INS_ID( wname, "num_df_ss%d", index );
 if( nc_def_dim( ncFile, wname, (size_t)side_set.ss_dist_factors.size(), &num_df_ss ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define number of dist factors in side set "
 << side_set.id ); /* Exit define mode and return */
 }
 
 /* Create variable array in which to store the side set distribution factors */
 
 int fact_ss = -1;
 INS_ID( wname, "dist_fact_ss%d", index );
 if( NC_NOERR != nc_def_var( ncFile, wname, NC_LONG, 1, &num_df_ss, &fact_ss ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create dist factors list for side set "
 << side_set.id ); /* Exit define mode and return */
 }
 }
 }
 
 /* Node coordinate arrays: */
 
 int coord, name_coord, dims[3];
 dims[0] = num_dim;
 dims[1] = num_nodes;
 if( NC_NOERR != nc_def_var( ncFile, "coord", NC_DOUBLE, 2, dims, &coord ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define node coordinate array" );
 }
 
 /* Coordinate names array */
 
 dims[0] = num_dim;
 dims[1] = dim_str;
 if( NC_NOERR != nc_def_var( ncFile, "coor_names", NC_CHAR, 2, dims, &name_coord ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define coordinate name array" );
 }
 
 // Define genesis maps if required
 
 if( write_maps )
 {
 // Element map
 int elem_map = -1, elem_map2 = -1, node_map = -1;
 if( NC_NOERR != nc_def_var( ncFile, "elem_map", NC_LONG, 1, &num_elem, &elem_map ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create element map array" ); /* Exit define mode and return */
 }
 
 // Create the element number map
 if( NC_NOERR != nc_def_var( ncFile, "elem_num_map", NC_LONG, 1, &num_elem, &elem_map2 ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create element numbering map" ); /* Exit define mode
 and return */
 }
 
 // Create node number map
 if( NC_NOERR != nc_def_var( ncFile, "node_num_map", NC_LONG, 1, &num_nodes, &node_map ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to create node numbering map array" ); /* Exit define mode and
 return */
 }
 }
 
 // Define qa records to be used
 
 int num_qa_rec = mesh_info.qaRecords.size() / 4;
 int num_qa = -1;
 
 if( nc_def_dim( ncFile, "num_qa_rec", (long)num_qa_rec, &num_qa ) != NC_NOERR )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define qa record array size" );
 }
 
 // Define qa array
 int qa_title;
 dims[0] = num_qa;
 dims[1] = dim_four;
 dims[2] = dim_str;
 if( NC_NOERR != nc_def_var( ncFile, "qa_records", NC_CHAR, 3, dims, &qa_title ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to define qa record array" );
 }
 
 // Take it out of define mode
 if( NC_NOERR != nc_enddef( ncFile ) )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: Trouble leaving define mode" );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::MaterialSetData::element_type, moab::MaterialSetData::elements, moab::ExoIIUtil::ElementTypeNames, moab::Range::end(), ErrorCode, moab::EXOII_POLYGON, moab::EXOII_POLYHEDRON, moab::Interface::get_connectivity(), moab::MaterialSetData::id, moab::DirichletSetData::id, moab::NeumannSetData::id, INS_ID, length(), moab::ExoIIInterface::MAX_STR_LENGTH, MB_CHK_ERR, MB_SET_ERR, MB_SET_ERR_CONT, MB_SUCCESS, mdbImpl, ncFile, moab::WriteNCDF::ExodusMeshInfo::num_dim, moab::WriteNCDF::ExodusMeshInfo::num_elementblocks, moab::WriteNCDF::ExodusMeshInfo::num_elements, moab::WriteNCDF::ExodusMeshInfo::num_nodes, moab::MaterialSetData::number_attributes, moab::MaterialSetData::number_elements, moab::NeumannSetData::number_elements, moab::DirichletSetData::number_nodes, moab::MaterialSetData::number_nodes_per_element, moab::WriteNCDF::ExodusMeshInfo::polyhedronFaces, moab::WriteNCDF::ExodusMeshInfo::qaRecords, repeat_face_blocks, moab::Range::size(), and moab::NeumannSetData::ss_dist_factors.

Referenced by write_header().

open_file()

ErrorCode moab::WriteNCDF::open_file ( const char *  file_name )

protected

number of dimensions in this exo file

open an ExoII file for writing

Definition at line 2266 of file WriteNCDF.cpp.

{
 // Not a valid filename
 if( strlen( (const char*)filename ) == 0 )
 {
 MB_SET_ERR( MB_FAILURE, "Output Exodus filename not specified" );
 }
 
 int fail = nc_create( filename, NC_CLOBBER, &ncFile );
 
 // File couldn't be opened
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Cannot open " << filename );
 }
 
 return MB_SUCCESS;
}

References moab::fail(), MB_SET_ERR, MB_SUCCESS, and ncFile.

reset_block()

void moab::WriteNCDF::reset_block ( std::vector< MaterialSetData > &  block_info )

private

free up allocated Ranges

Definition at line 142 of file WriteNCDF.cpp.

{
 std::vector< MaterialSetData >::iterator iter;
 
 for( iter = block_info.begin(); iter != block_info.end(); ++iter )
 {
 iter->elements.clear();
 }
}

Referenced by write_file().

time_and_date()

void moab::WriteNCDF::time_and_date ( char *  time_string, char *  date_string  )

staticprivate

get the time and date in strings

Definition at line 152 of file WriteNCDF.cpp.

{
 struct tm* local_time;
 time_t calendar_time;
 
 calendar_time = time( NULL );
 local_time = localtime( &calendar_time );
 
 assert( NULL != time_string && NULL != date_string );
 
 strftime( time_string, TIME_STR_LEN, "%H:%M:%S", local_time );
 strftime( date_string, TIME_STR_LEN, "%m/%d/%Y", local_time );
 
 // Terminate with NULL character
 time_string[10] = '\0';
 date_string[10] = '\0';
}

References moab::TIME_STR_LEN.

Referenced by write_file(), and write_header().

write_BCs()

ErrorCode moab::WriteNCDF::write_BCs ( std::vector< NeumannSetData > &  sidesets, std::vector< DirichletSetData > &  nodesets  )

private

Definition at line 1363 of file WriteNCDF.cpp.

{
 unsigned int i, j;
 int id;
 int ns_index = -1;
 
 for( std::vector< DirichletSetData >::iterator ns_it = nodesets.begin(); ns_it != nodesets.end(); ++ns_it )
 {
 // Get number of nodes in set
 int number_nodes = ( *ns_it ).number_nodes;
 if( 0 == number_nodes ) continue;
 
 // If we're here, we have a non-empty nodeset; increment the index
 ns_index++;
 
 // Get the node set id
 id = ( *ns_it ).id;
 
 // Build new array to old exodus ids
 int* exodus_id_array = new int[number_nodes];
 double* dist_factor_array = new double[number_nodes];
 
 std::vector< EntityHandle >::iterator begin_iter, end_iter;
 std::vector< double >::iterator other_iter;
 begin_iter = ( *ns_it ).nodes.begin();
 end_iter = ( *ns_it ).nodes.end();
 other_iter = ( *ns_it ).node_dist_factors.begin();
 
 j = 0;
 int exodus_id;
 ErrorCode result;
 // Fill up node array and dist. factor array at the same time
 for( ; begin_iter != end_iter; ++begin_iter )
 {
 result = mdbImpl->tag_get_data( mGlobalIdTag, &( *begin_iter ), 1, &exodus_id );MB_CHK_SET_ERR( result, "Problem getting id tag data" );
 
 exodus_id_array[j] = exodus_id;
 dist_factor_array[j] = *( other_iter );
 ++other_iter;
 j++;
 }
 
 // Write out the id for the nodeset
 
 int num_values = 1;
 
 result = write_exodus_integer_variable( "ns_prop1", &id, ns_index, num_values );MB_CHK_SET_ERR_RET_VAL( result, "Problem writing node set id " << id, MB_FAILURE );
 
 // Write out the nodeset status
 
 int status = 1;
 if( !number_nodes ) status = 0;
 
 result = write_exodus_integer_variable( "ns_status", &status, ns_index, num_values );MB_CHK_SET_ERR_RET_VAL( result, "Problem writing node set status", MB_FAILURE );
 
 // Write it out
 char wname[80];
 int nc_var = -1;
 std::vector< int > dims;
 INS_ID( wname, "node_ns%d", ns_index + 1 );
 GET_VAR( wname, nc_var, dims );
 if( -1 == nc_var )
 {
 MB_SET_ERR( MB_FAILURE, "Failed to get node_ns variable" );
 }
 
 size_t start = 0, count = number_nodes;
 int fail = nc_put_vara_int( ncFile, nc_var, &start, &count, exodus_id_array );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Failed writing exodus id array" );
 }
 
 // Write out nodeset distribution factors
 INS_ID( wname, "dist_fact_ns%d", ns_index + 1 );
 nc_var = -1;
 GET_VAR( wname, nc_var, dims );
 if( -1 == nc_var )
 {
 MB_SET_ERR( MB_FAILURE, "Failed to get dist_fact variable" );
 }
 fail = nc_put_vara_double( ncFile, nc_var, &start, &count, dist_factor_array );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Failed writing dist factor array" );
 }
 
 delete[] dist_factor_array;
 delete[] exodus_id_array;
 }
 
 // Now do sidesets
 int ss_index = 0; // Index of sideset - not the same as 'i' because
 // only writing non-empty side sets
 for( i = 0; i < sidesets.size(); i++ )
 {
 NeumannSetData sideset_data = sidesets[i];
 
 // Get the side set id
 int side_set_id = sideset_data.id;
 
 // Get number of elements in set
 int number_elements = sideset_data.number_elements;
 if( 0 == number_elements ) continue;
 
 // Build new array to old exodus ids
 int* output_element_ids = new int[number_elements];
 int* output_element_side_numbers = new int[number_elements];
 
 std::vector< EntityHandle >::iterator begin_iter, end_iter;
 begin_iter = sideset_data.elements.begin();
 end_iter = sideset_data.elements.end();
 std::vector< int >::iterator side_iter = sideset_data.side_numbers.begin();
 
 // Get the tag handle
 j = 0;
 int exodus_id;
 
 // For each "side"
 for( ; begin_iter != end_iter; ++begin_iter, ++side_iter )
 {
 ErrorCode result = mdbImpl->tag_get_data( mGlobalIdTag, &( *begin_iter ), 1, &exodus_id );MB_CHK_SET_ERR( result, "Problem getting exodus id for sideset element "
 << (long unsigned int)ID_FROM_HANDLE( *begin_iter ) );
 
 output_element_ids[j] = exodus_id;
 output_element_side_numbers[j++] = *side_iter;
 }
 
 if( 0 != number_elements )
 {
 // Write out the id for the nodeset
 
 int num_values = 1;
 
 // ss_prop1[ss_index] = side_set_id
 ErrorCode result = write_exodus_integer_variable( "ss_prop1", &side_set_id, ss_index, num_values );MB_CHK_SET_ERR_RET_VAL( result, "Problem writing node set id " << id, MB_FAILURE );
 
 // FIXME : Something seems wrong here. The we are within a block
 // started with if (0 != number_elements), so this condition is always
 // false. This code seems to indicate that we want to write all
 // sidesets, not just empty ones. But the code both here and in
 // initialize_exodus_file() skip empty side sets.
 // - j.k. 2007-03-09
 int status = 1;
 if( 0 == number_elements ) status = 0;
 
 // ss_status[ss_index] = status
 result = write_exodus_integer_variable( "ss_status", &status, ss_index, num_values );MB_CHK_SET_ERR_RET_VAL( result, "Problem writing side set status", MB_FAILURE );
 
 // Increment ss_index now because we want a) we need to
 // increment it somewhere within the if (0 != number_elements)
 // block and b) the above calls need a zero-based index
 // while the following use a one-based index.
 ++ss_index;
 
 char wname[80];
 int nc_var;
 std::vector< int > dims;
 INS_ID( wname, "elem_ss%d", ss_index );
 GET_VAR( wname, nc_var, dims );
 if( -1 == nc_var )
 {
 MB_SET_ERR( MB_FAILURE, "Failed to get elem_ss variable" );
 }
 size_t start = 0, count = number_elements;
 int fail = nc_put_vara_int( ncFile, nc_var, &start, &count, output_element_ids );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Failed writing sideset element array" );
 }
 
 INS_ID( wname, "side_ss%d", ss_index );
 nc_var = -1;
 GET_VAR( wname, nc_var, dims );
 if( -1 == nc_var )
 {
 MB_SET_ERR( MB_FAILURE, "Failed to get side_ss variable" );
 }
 fail = nc_put_vara_int( ncFile, nc_var, &start, &count, output_element_side_numbers );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Failed writing sideset side array" );
 }
 
 INS_ID( wname, "dist_fact_ss%d", ss_index );
 nc_var = -1;
 GET_VAR( wname, nc_var, dims );
 if( -1 == nc_var )
 {
 MB_SET_ERR( MB_FAILURE, "Failed to get sideset dist factors variable" );
 }
 count = sideset_data.ss_dist_factors.size();
 fail = nc_put_vara_double( ncFile, nc_var, &start, &count, &( sideset_data.ss_dist_factors[0] ) );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Failed writing sideset dist factors array" );
 }
 }
 
 delete[] output_element_ids;
 delete[] output_element_side_numbers;
 }
 
 return MB_SUCCESS;
}

References moab::NeumannSetData::elements, ErrorCode, moab::fail(), GET_VAR, moab::NeumannSetData::id, moab::ID_FROM_HANDLE(), INS_ID, MB_CHK_SET_ERR, MB_CHK_SET_ERR_RET_VAL, MB_SET_ERR, MB_SUCCESS, mdbImpl, mGlobalIdTag, ncFile, moab::NeumannSetData::number_elements, moab::NeumannSetData::side_numbers, moab::NeumannSetData::ss_dist_factors, moab::Interface::tag_get_data(), and write_exodus_integer_variable().

Referenced by write_file().

write_element_order_map()

ErrorCode moab::WriteNCDF::write_element_order_map ( int  num_elements )

private

Definition at line 1289 of file WriteNCDF.cpp.

{
 // Note: this routine bypasses the standard exodusII interface for efficiency!
 
 // Element order map
 int* map = new int[num_elements];
 
 // For now, output a dummy map!
 
 for( int i = 0; i < num_elements; i++ )
 {
 map[i] = i + 1;
 }
 
 // Output array and cleanup
 
 int error = write_exodus_integer_variable( "elem_map", map, 0, num_elements );
 
 if( map ) delete[] map;
 
 if( error < 0 )
 {
 MB_SET_ERR( MB_FAILURE, "Failed writing element map" );
 }
 
 return MB_SUCCESS;
}

References moab::error(), MB_SET_ERR, MB_SUCCESS, and write_exodus_integer_variable().

Referenced by write_file().

write_elementblocks()

ErrorCode moab::WriteNCDF::write_elementblocks ( ExodusMeshInfo &  mesh_info, std::vector< MaterialSetData > &  block_data  )

private

Definition at line 1035 of file WriteNCDF.cpp.

{
 unsigned int i;
 int block_index = 0; // Index into block list, may != 1 if there are inactive blocks
 int exodus_id = 1;
 
 for( i = 0; i < block_data.size(); i++ )
 {
 MaterialSetData& block = block_data[i];
 
 unsigned int num_nodes_per_elem = block.number_nodes_per_element;
 
 // Write out the id for the block
 
 int id = block.id;
 int num_values = 1;
 
 if( write_exodus_integer_variable( "eb_prop1", &id, block_index, num_values ) != MB_SUCCESS )
 {
 MB_SET_ERR_CONT( "Problem writing element block id " << id );
 }
 
 // Write out the block status
 
 int status = 1;
 if( 0 == block.number_elements )
 {
 MB_SET_ERR( MB_FAILURE, "No elements in block " << id );
 }
 
 if( write_exodus_integer_variable( "eb_status", &status, block_index, num_values ) != MB_SUCCESS )
 {
 MB_SET_ERR( MB_FAILURE, "Problem writing element block status" );
 }
 
 //
 // Map the connectivity to the new nodes
 const unsigned int num_elem = block.number_elements;
 unsigned int num_nodes = num_nodes_per_elem * num_elem;
 if( EXOII_POLYGON == block.element_type || EXOII_POLYHEDRON == block.element_type )
 {
 num_nodes = num_nodes_per_elem;
 }
 int* connectivity = new int[num_nodes];
 
 ErrorCode result = MB_SUCCESS;
 if( block.element_type != EXOII_POLYHEDRON )
 mWriteIface->get_element_connect( num_elem, num_nodes_per_elem, mGlobalIdTag, block.elements, mGlobalIdTag,
 exodus_id, connectivity );
 if( result != MB_SUCCESS )
 {
 delete[] connectivity;
 MB_SET_ERR( result, "Couldn't get element array to write from" );
 }
 
 // If necessary, convert from EXODUS to CN node order
 const EntityType elem_type = ExoIIUtil::ExoIIElementMBEntity[block.element_type];
 assert( block.elements.all_of_type( elem_type ) );
 const int* reorder = 0;
 if( block.element_type != EXOII_POLYHEDRON && block.element_type != EXOII_POLYGON )
 reorder = exodus_elem_order_map[elem_type][block.number_nodes_per_element];
 if( reorder )
 WriteUtilIface::reorder( reorder, connectivity, block.number_elements, block.number_nodes_per_element );
 
 char wname[80];
 int nc_var = -1;
 std::vector< int > dims;
 if( block.element_type != EXOII_POLYHEDRON )
 {
 exodus_id += num_elem;
 INS_ID( wname, "connect%u", i + 1 );
 
 GET_VAR( wname, nc_var, dims );
 if( -1 == nc_var )
 {
 delete[] connectivity;
 MB_SET_ERR( MB_FAILURE, "Couldn't get connectivity variable" );
 }
 }
 
 if( EXOII_POLYGON == block.element_type )
 {
 size_t start[1] = { 0 }, count[1] = { num_nodes_per_elem };
 int fail = nc_put_vara_int( ncFile, nc_var, start, count, connectivity );
 if( NC_NOERR != fail )
 {
 delete[] connectivity;
 MB_SET_ERR( MB_FAILURE, "Couldn't write connectivity variable" );
 }
 // now put also number ebepecnt1
 INS_ID( wname, "ebepecnt%u", i + 1 );
 GET_VAR( wname, nc_var, dims );
 count[0] = block.number_elements;
 start[0] = 0;
 // reuse connectivity array, to not allocate another one
 int j = 0;
 for( Range::iterator eit = block.elements.begin(); eit != block.elements.end(); j++, eit++ )
 {
 EntityHandle polg = *eit;
 int nnodes = 0;
 const EntityHandle* conn = NULL;
 ErrorCode rval = mdbImpl->get_connectivity( polg, conn, nnodes );MB_CHK_ERR( rval );
 connectivity[j] = nnodes;
 }
 fail = nc_put_vara_int( ncFile, nc_var, start, count, connectivity );
 if( NC_NOERR != fail )
 {
 delete[] connectivity;
 MB_SET_ERR( MB_FAILURE, "Couldn't write ebepecnt variable" );
 }
 }
 else if( block.element_type != EXOII_POLYHEDRON )
 {
 size_t start[2] = { 0, 0 }, count[2] = { num_elem, num_nodes_per_elem };
 int fail = nc_put_vara_int( ncFile, nc_var, start, count, connectivity );
 if( NC_NOERR != fail )
 {
 delete[] connectivity;
 MB_SET_ERR( MB_FAILURE, "Couldn't write connectivity variable" );
 }
 }
 else // if (block.element_type == EXOII_POLYHEDRON)
 {
 /* write a lot of stuff // faconn
 num_fa_in_blk1 = 15 ;
 num_nod_per_fa1 = 58 ;
 num_el_in_blk1 = 3 ;
 num_fac_per_el1 = 17 ;
 int fbconn1(num_nod_per_fa1) ;
 fbconn1:elem_type = "nsided" ;
 int fbepecnt1(num_fa_in_blk1) ;
 fbepecnt1:entity_type1 = "NODE" ;
 fbepecnt1:entity_type2 = "FACE" ;
 int facconn1(num_fac_per_el1) ;
 facconn1:elem_type = "NFACED" ;
 int ebepecnt1(num_el_in_blk1) ;
 ebepecnt1:entity_type1 = "FACE" ;
 ebepecnt1:entity_type2 = "ELEM" ;
 
 */
 Range& block_faces = mesh_info.polyhedronFaces;
 // ErrorCode rval = mdbImpl->get_connectivity(block.elements, block_faces);
 // MB_CHK_ERR(rval);
 
 // reuse now connectivity for facconn1
 INS_ID( wname, "facconn%u", i + 1 );
 GET_VAR( wname, nc_var, dims ); // fbconn# variable, 1 dimensional
 
 std::vector< int > ebepe( block.elements.size() ); // ebepecnt1
 int ixcon = 0, j = 0;
 size_t start[1] = { 0 }, count[1] = { 0 };
 
 for( Range::iterator eit = block.elements.begin(); eit != block.elements.end(); eit++ )
 {
 EntityHandle polyh = *eit;
 int nfaces = 0;
 const EntityHandle* conn = NULL;
 ErrorCode rval = mdbImpl->get_connectivity( polyh, conn, nfaces );MB_CHK_ERR( rval );
 for( int k = 0; k < nfaces; k++ )
 {
 int index = block_faces.index( conn[k] );
 if( index == -1 ) MB_SET_ERR( MB_FAILURE, "Couldn't find face in polyhedron" );
 connectivity[ixcon++] = index + 1;
 }
 ebepe[j++] = nfaces;
 // num_faces+=nfaces;
 }
 count[0] = ixcon; // facconn1
 int fail = nc_put_vara_int( ncFile, nc_var, start, count, connectivity );
 if( NC_NOERR != fail )
 {
 delete[] connectivity;
 MB_SET_ERR( MB_FAILURE, "Couldn't write fbconn variable" );
 }
 
 INS_ID( wname, "ebepecnt%u", i + 1 );
 GET_VAR( wname, nc_var, dims ); // ebepecnt# variable, 1 dimensional
 count[0] = block.elements.size();
 
 fail = nc_put_vara_int( ncFile, nc_var, start, count, &ebepe[0] );
 if( NC_NOERR != fail )
 {
 delete[] connectivity;
 MB_SET_ERR( MB_FAILURE, "Couldn't write fbepecnt variable" );
 }
 }
 block_index++;
 delete[] connectivity;
 }
 
 return MB_SUCCESS;
}

References moab::Range::all_of_type(), moab::Range::begin(), moab::MaterialSetData::element_type, moab::MaterialSetData::elements, moab::Range::end(), ErrorCode, exodus_elem_order_map, moab::EXOII_POLYGON, moab::EXOII_POLYHEDRON, moab::ExoIIUtil::ExoIIElementMBEntity, moab::fail(), moab::Interface::get_connectivity(), moab::WriteUtilIface::get_element_connect(), GET_VAR, moab::MaterialSetData::id, moab::Range::index(), INS_ID, MB_CHK_ERR, MB_SET_ERR, MB_SET_ERR_CONT, MB_SUCCESS, mdbImpl, mGlobalIdTag, mWriteIface, ncFile, moab::MaterialSetData::number_elements, moab::MaterialSetData::number_nodes_per_element, moab::WriteNCDF::ExodusMeshInfo::polyhedronFaces, moab::WriteUtilIface::reorder(), moab::Range::size(), and write_exodus_integer_variable().

Referenced by write_file().

write_exodus_integer_variable()

ErrorCode moab::WriteNCDF::write_exodus_integer_variable ( const char *  variable_name, int *  variable_array, int  start_position, int  number_values  )

private

Definition at line 1317 of file WriteNCDF.cpp.

{
 // Note: this routine bypasses the standard exodusII interface for efficiency!
 
 // Write directly to netcdf interface for efficiency
 
 // Get the variable id of the element map
 int nc_var = -1;
 std::vector< int > dims;
 GET_VAR( variable_name, nc_var, dims );
 if( -1 == nc_var )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF: failed to locate variable " << variable_name << " in file" );
 }
 // This contortion is necessary because netCDF is expecting nclongs;
 // fortunately it's necessary only when ints and nclongs aren't the same size
 
 size_t start[1], count[1];
 start[0] = start_position;
 count[0] = number_values;
 
 int fail = NC_NOERR;
 if( sizeof( int ) == sizeof( long ) )
 {
 fail = nc_put_vara_int( ncFile, nc_var, start, count, variable_array );
 }
 else
 {
 long* lptr = new long[number_values];
 for( int jj = 0; jj < number_values; jj++ )
 lptr[jj] = variable_array[jj];
 fail = nc_put_vara_long( ncFile, nc_var, start, count, lptr );
 delete[] lptr;
 }
 
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Failed to store variable " << variable_name );
 }
 
 return MB_SUCCESS;
}

References moab::fail(), GET_VAR, MB_SET_ERR, MB_SUCCESS, and ncFile.

Referenced by write_BCs(), write_element_order_map(), write_elementblocks(), write_global_element_order_map(), write_global_node_order_map(), and write_poly_faces().

write_file()

ErrorCode moab::WriteNCDF::write_file ( const char *  exodus_file_name, const bool  overwrite, const FileOptions &  opts, const EntityHandle *  output_list, const int  num_sets, const std::vector< std::string > &  qa_records, const Tag *  = NULL, int  = 0, int  user_dimension = 3  )

virtual

writes out an ExoII file

Implements moab::WriterIface.

Definition at line 170 of file WriteNCDF.cpp.

{
 assert( 0 != mMaterialSetTag && 0 != mNeumannSetTag && 0 != mDirichletSetTag );
 
 if( user_dimension == 0 ) mdbImpl->get_dimension( user_dimension );
 
 if( opts.get_null_option( "REPEAT_FACE_BLOCKS" ) == MB_SUCCESS ) repeat_face_blocks = 1;
 
 std::vector< EntityHandle > blocks, nodesets, sidesets, entities;
 
 // Separate into blocks, nodesets, sidesets
 
 if( num_sets == 0 )
 {
 // Default to all defined block, nodeset and sideset-type sets
 Range this_range;
 mdbImpl->get_entities_by_type_and_tag( 0, MBENTITYSET, &mMaterialSetTag, NULL, 1, this_range );
 std::copy( this_range.begin(), this_range.end(), std::back_inserter( blocks ) );
 this_range.clear();
 mdbImpl->get_entities_by_type_and_tag( 0, MBENTITYSET, &mDirichletSetTag, NULL, 1, this_range );
 std::copy( this_range.begin(), this_range.end(), std::back_inserter( nodesets ) );
 this_range.clear();
 mdbImpl->get_entities_by_type_and_tag( 0, MBENTITYSET, &mNeumannSetTag, NULL, 1, this_range );
 std::copy( this_range.begin(), this_range.end(), std::back_inserter( sidesets ) );
 
 // If there is nothing to write, write everything as one block.
 if( blocks.empty() && nodesets.empty() && sidesets.empty() )
 {
 this_range.clear();
 for( int d = user_dimension; d > 0 && this_range.empty(); --d )
 mdbImpl->get_entities_by_dimension( 0, d, this_range, false );
 if( this_range.empty() ) return MB_FILE_WRITE_ERROR;
 
 EntityHandle block_handle;
 int block_id = 1;
 mdbImpl->create_meshset( MESHSET_SET, block_handle );
 mdbImpl->tag_set_data( mMaterialSetTag, &block_handle, 1, &block_id );
 mdbImpl->add_entities( block_handle, this_range );
 blocks.push_back( block_handle );
 }
 }
 else
 {
 int dummy;
 for( const EntityHandle* iter = ent_handles; iter < ent_handles + num_sets; ++iter )
 {
 if( MB_SUCCESS == mdbImpl->tag_get_data( mMaterialSetTag, &( *iter ), 1, &dummy ) && -1 != dummy )
 blocks.push_back( *iter );
 else if( MB_SUCCESS == mdbImpl->tag_get_data( mDirichletSetTag, &( *iter ), 1, &dummy ) && -1 != dummy )
 nodesets.push_back( *iter );
 else if( MB_SUCCESS == mdbImpl->tag_get_data( mNeumannSetTag, &( *iter ), 1, &dummy ) && -1 != dummy )
 sidesets.push_back( *iter );
 }
 }
 
 // If there is nothing to write just return.
 if( blocks.empty() && nodesets.empty() && sidesets.empty() ) return MB_FILE_WRITE_ERROR;
 
 // Try to get mesh information
 ExodusMeshInfo mesh_info;
 
 std::vector< MaterialSetData > block_info;
 std::vector< NeumannSetData > sideset_info;
 std::vector< DirichletSetData > nodeset_info;
 
 mesh_info.num_dim = user_dimension;
 
 if( qa_records.empty() )
 {
 // qa records are empty - initialize some MB-standard ones
 mesh_info.qaRecords.push_back( "MB" );
 mesh_info.qaRecords.push_back( "0.99" );
 char string1[80], string2[80];
 time_and_date( string2, string1 );
 mesh_info.qaRecords.push_back( string2 );
 mesh_info.qaRecords.push_back( string1 );
 }
 else
 {
 // Constrained to multiples of 4 qa records
 assert( qa_records.size() % 4 == 0 );
 
 std::copy( qa_records.begin(), qa_records.end(), std::back_inserter( mesh_info.qaRecords ) );
 }
 
 block_info.clear();
 if( gather_mesh_information( mesh_info, block_info, sideset_info, nodeset_info, blocks, sidesets, nodesets ) !=
 MB_SUCCESS )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 
 // Try to open the file after gather mesh info succeeds
 int fail = nc_create( exodus_file_name, overwrite ? NC_CLOBBER : NC_NOCLOBBER, &ncFile );
 if( NC_NOERR != fail )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 
 if( write_header( mesh_info, block_info, sideset_info, nodeset_info, exodus_file_name ) != MB_SUCCESS )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 
 {
 // write dummy time_whole
 double timev = 0.0; // dummy, to make paraview happy
 size_t start = 0, count = 1;
 int nc_var;
 std::vector< int > dims;
 GET_VAR( "time_whole", nc_var, dims );
 fail = nc_put_vara_double( ncFile, nc_var, &start, &count, &timev );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Failed writing dist factor array" );
 }
 }
 
 if( write_nodes( mesh_info.num_nodes, mesh_info.nodes, mesh_info.num_dim ) != MB_SUCCESS )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 
 if( !mesh_info.polyhedronFaces.empty() )
 {
 if( write_poly_faces( mesh_info ) != MB_SUCCESS )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 }
 
 if( write_elementblocks( mesh_info, block_info ) )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 
 // Write the three maps
 if( write_global_node_order_map( mesh_info.num_nodes, mesh_info.nodes ) != MB_SUCCESS )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 
 if( write_global_element_order_map( mesh_info.num_elements ) != MB_SUCCESS )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 
 if( write_element_order_map( mesh_info.num_elements ) != MB_SUCCESS )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 
 /*
 if (write_elementmap(mesh_info) != MB_SUCCESS)
 return MB_FAILURE;
 */
 
 if( write_BCs( sideset_info, nodeset_info ) != MB_SUCCESS )
 {
 reset_block( block_info );
 return MB_FAILURE;
 }
 
 if( write_qa_records( mesh_info.qaRecords ) != MB_SUCCESS ) return MB_FAILURE;
 
 // Copy the qa records into the argument
 // mesh_info.qaRecords.swap(qa_records);
 // Close the file
 fail = nc_close( ncFile );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Trouble closing file" );
 }
 
 return MB_SUCCESS;
}

References moab::Interface::add_entities(), moab::Range::begin(), moab::Range::clear(), moab::Interface::create_meshset(), moab::Range::empty(), moab::Range::end(), entities, moab::fail(), gather_mesh_information(), moab::Interface::get_dimension(), moab::Interface::get_entities_by_dimension(), moab::Interface::get_entities_by_type_and_tag(), moab::FileOptions::get_null_option(), GET_VAR, MB_FILE_WRITE_ERROR, MB_SET_ERR, MB_SUCCESS, MBENTITYSET, mdbImpl, mDirichletSetTag, MESHSET_SET, mMaterialSetTag, mNeumannSetTag, ncFile, moab::WriteNCDF::ExodusMeshInfo::nodes, moab::WriteNCDF::ExodusMeshInfo::num_dim, moab::WriteNCDF::ExodusMeshInfo::num_elements, moab::WriteNCDF::ExodusMeshInfo::num_nodes, moab::WriteNCDF::ExodusMeshInfo::polyhedronFaces, moab::WriteNCDF::ExodusMeshInfo::qaRecords, repeat_face_blocks, reset_block(), moab::Interface::tag_get_data(), moab::Interface::tag_set_data(), time_and_date(), write_BCs(), write_element_order_map(), write_elementblocks(), write_global_element_order_map(), write_global_node_order_map(), write_header(), write_nodes(), write_poly_faces(), and write_qa_records().

write_global_element_order_map()

ErrorCode moab::WriteNCDF::write_global_element_order_map ( int  num_elements )

private

Definition at line 1263 of file WriteNCDF.cpp.

{
 // Allocate map array
 int* map = new int[num_elements];
 
 // Many Sandia codes assume this map is unique, and CUBIT does not currently
 // have unique ids for all elements. Therefore, to make sure nothing crashes,
 // insert a dummy map...
 
 for( int i = 0; i < num_elements; i++ )
 map[i] = i + 1;
 
 // Output array and cleanup
 
 int error = write_exodus_integer_variable( "elem_num_map", map, 0, num_elements );
 
 if( map ) delete[] map;
 
 if( error < 0 )
 {
 MB_SET_ERR( MB_FAILURE, "Failed writing global element order map" );
 }
 
 return MB_SUCCESS;
}

References moab::error(), MB_SET_ERR, MB_SUCCESS, and write_exodus_integer_variable().

Referenced by write_file().

write_global_node_order_map()

ErrorCode moab::WriteNCDF::write_global_node_order_map ( int  num_nodes, Range &  nodes  )

private

Definition at line 1228 of file WriteNCDF.cpp.

{
 // Note: this routine bypasses the standard exodusII interface for efficiency!
 
 // Node order map
 int* map = new int[num_nodes];
 
 // For now, output a dummy map!
 
 Range::iterator range_iter, end_iter;
 range_iter = nodes.begin();
 end_iter = nodes.end();
 
 int i = 0;
 
 for( ; range_iter != end_iter; ++range_iter )
 {
 // TODO -- do we really want to cast this to an int?
 map[i++] = (int)ID_FROM_HANDLE( *range_iter );
 }
 
 // Output array and cleanup
 
 int error = write_exodus_integer_variable( "node_num_map", map, 0, num_nodes );
 
 if( map ) delete[] map;
 
 if( error < 0 )
 {
 MB_SET_ERR( MB_FAILURE, "Failed writing global node order map" );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::end(), moab::error(), moab::ID_FROM_HANDLE(), MB_SET_ERR, MB_SUCCESS, and write_exodus_integer_variable().

Referenced by write_file().

write_header()

ErrorCode moab::WriteNCDF::write_header ( ExodusMeshInfo &  mesh_info, std::vector< MaterialSetData > &  block_info, std::vector< NeumannSetData > &  sideset_info, std::vector< DirichletSetData > &  nodeset_info, const char *  filename  )

private

Definition at line 1004 of file WriteNCDF.cpp.

{
 // Get the date and time
 char time[TIME_STR_LEN];
 char date[TIME_STR_LEN];
 time_and_date( time, date );
 
 std::string title_string = "MOAB";
 title_string.append( "(" );
 title_string.append( filename );
 title_string.append( "): " );
 title_string.append( date );
 title_string.append( ": " );
 title_string.append( "time " );
 
 if( title_string.length() > ExoIIInterface::MAX_LINE_LENGTH )
 title_string.resize( ExoIIInterface::MAX_LINE_LENGTH );
 
 // Initialize the exodus file
 
 int result = initialize_exodus_file( mesh_info, block_info, sideset_info, nodeset_info, title_string.c_str() );
 
 if( result == MB_FAILURE ) return MB_FAILURE;
 
 return MB_SUCCESS;
}

References initialize_exodus_file(), moab::ExoIIInterface::MAX_LINE_LENGTH, MB_SUCCESS, time_and_date(), and moab::TIME_STR_LEN.

Referenced by write_file().

write_nodes()

ErrorCode moab::WriteNCDF::write_nodes ( int  num_nodes, Range &  nodes, int  dimension  )

private

Definition at line 799 of file WriteNCDF.cpp.

{
 // Write coordinates names
 int nc_var = -1;
 std::vector< int > dims;
 GET_VAR( "coor_names", nc_var, dims );
 if( -1 == nc_var )
 {
 MB_SET_ERR( MB_FAILURE, "Trouble getting coordinate name variable" );
 }
 
 size_t start[2] = { 0, 0 }, count[2] = { 1, ExoIIInterface::MAX_STR_LENGTH };
 char dum_str[ExoIIInterface::MAX_STR_LENGTH];
 strcpy( dum_str, "x" );
 int fail = nc_put_vara_text( ncFile, nc_var, start, count, dum_str );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Trouble adding x coordinate name; netcdf message: " << nc_strerror( fail ) );
 }
 
 start[0] = 1;
 strcpy( dum_str, "y" );
 fail = nc_put_vara_text( ncFile, nc_var, start, count, dum_str );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Trouble adding y coordinate name; netcdf message: " << nc_strerror( fail ) );
 }
 
 start[0] = 2;
 strcpy( dum_str, "z" );
 fail = nc_put_vara_text( ncFile, nc_var, start, count, dum_str );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Trouble adding z coordinate name; netcdf message: " << nc_strerror( fail ) );
 }
 
 // See if should transform coordinates
 ErrorCode result;
 Tag trans_tag;
 result = mdbImpl->tag_get_handle( MESH_TRANSFORM_TAG_NAME, 16, MB_TYPE_DOUBLE, trans_tag );
 bool transform_needed = true;
 if( result == MB_TAG_NOT_FOUND ) transform_needed = false;
 
 int num_coords_to_fill = transform_needed ? 3 : dimension;
 
 std::vector< double* > coord_arrays( 3 );
 coord_arrays[0] = new double[num_nodes];
 coord_arrays[1] = new double[num_nodes];
 coord_arrays[2] = NULL;
 
 if( num_coords_to_fill == 3 ) coord_arrays[2] = new double[num_nodes];
 
 result = mWriteIface->get_node_coords( dimension, num_nodes, nodes, mGlobalIdTag, 1, coord_arrays );
 if( result != MB_SUCCESS )
 {
 delete[] coord_arrays[0];
 delete[] coord_arrays[1];
 if( coord_arrays[2] ) delete[] coord_arrays[2];
 return result;
 }
 
 if( transform_needed )
 {
 double trans_matrix[16];
 const EntityHandle mesh = 0;
 result = mdbImpl->tag_get_data( trans_tag, &mesh, 0, trans_matrix );MB_CHK_SET_ERR( result, "Couldn't get transform data" );
 
 for( int i = 0; i < num_nodes; i++ )
 {
 double vec1[3];
 double vec2[3];
 
 vec2[0] = coord_arrays[0][i];
 vec2[1] = coord_arrays[1][i];
 vec2[2] = coord_arrays[2][i];
 
 for( int row = 0; row < 3; row++ )
 {
 vec1[row] = 0.0;
 for( int col = 0; col < 3; col++ )
 vec1[row] += ( trans_matrix[( row * 4 ) + col] * vec2[col] );
 }
 
 coord_arrays[0][i] = vec1[0];
 coord_arrays[1][i] = vec1[1];
 coord_arrays[2][i] = vec1[2];
 }
 }
 
 // Write the nodes
 nc_var = -1;
 GET_VAR( "coord", nc_var, dims );
 if( -1 == nc_var )
 {
 MB_SET_ERR( MB_FAILURE, "Trouble getting coordinate variable" );
 }
 start[0] = 0;
 count[1] = num_nodes;
 fail = nc_put_vara_double( ncFile, nc_var, start, count, &( coord_arrays[0][0] ) );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Trouble writing x coordinate" );
 }
 
 start[0] = 1;
 fail = nc_put_vara_double( ncFile, nc_var, start, count, &( coord_arrays[1][0] ) );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Trouble writing y coordinate" );
 }
 
 start[0] = 2;
 fail = nc_put_vara_double( ncFile, nc_var, start, count, &( coord_arrays[2][0] ) );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Trouble writing z coordinate" );
 }
 
 delete[] coord_arrays[0];
 delete[] coord_arrays[1];
 if( coord_arrays[2] ) delete[] coord_arrays[2];
 
 return MB_SUCCESS;
}

References ErrorCode, moab::fail(), moab::WriteUtilIface::get_node_coords(), GET_VAR, moab::ExoIIInterface::MAX_STR_LENGTH, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_NOT_FOUND, MB_TYPE_DOUBLE, mdbImpl, MESH_TRANSFORM_TAG_NAME, mGlobalIdTag, mWriteIface, ncFile, moab::Interface::tag_get_data(), and moab::Interface::tag_get_handle().

Referenced by write_file().

write_poly_faces()

ErrorCode moab::WriteNCDF::write_poly_faces ( ExodusMeshInfo &  mesh_info )

private

Definition at line 924 of file WriteNCDF.cpp.

{
 // write all polygons that are not in another element block;
 // usually they are nowhere else, but be sure, write in this block only ones that are not in the
 // other blocks
 Range pfaces = mesh_info.polyhedronFaces;
 
 /*
 * int fbconn1(num_nod_per_fa1) ;
 fbconn1:elem_type = "nsided" ;
 int fbepecnt1(num_fa_in_blk1) ;
 fbepecnt1:entity_type1 = "NODE" ;
 fbepecnt1:entity_type2 = "FACE" ;
 */
 if( pfaces.empty() ) return MB_SUCCESS;
 char wname[80];
 int nc_var = -1;
 std::vector< int > dims;
 
 // write one for each element block, to make paraview and visit happy
 int num_faces_in_block = (int)pfaces.size();
 for( unsigned int bl = 0; bl < mesh_info.num_polyhedra_blocks; bl++ )
 {
 INS_ID( wname, "fbconn%u", bl + 1 ); // it is the first block
 GET_VAR( wname, nc_var, dims ); // fbconn# variable, 1 dimensional
 
 INS_ID( wname, "num_nod_per_fa%u", bl + 1 );
 int ncdim, num_nod_per_face;
 GET_DIM( ncdim, wname, num_nod_per_face );
 int* connectivity = new int[num_nod_per_face];
 int ixcon = 0, j = 0;
 std::vector< int > fbepe( num_faces_in_block ); // fbepecnt1
 for( Range::iterator eit = pfaces.begin(); eit != pfaces.end(); eit++ )
 {
 EntityHandle polyg = *eit;
 int nnodes = 0;
 const EntityHandle* conn = NULL;
 ErrorCode rval = mdbImpl->get_connectivity( polyg, conn, nnodes );MB_CHK_ERR( rval );
 for( int k = 0; k < nnodes; k++ )
 connectivity[ixcon++] = conn[k];
 fbepe[j++] = nnodes;
 }
 size_t start[1] = { 0 }, count[1] = { 0 };
 count[0] = ixcon;
 int fail = nc_put_vara_int( ncFile, nc_var, start, count, connectivity );
 if( NC_NOERR != fail )
 {
 delete[] connectivity;
 MB_SET_ERR( MB_FAILURE, "Couldn't write fbconn variable" );
 }
 
 INS_ID( wname, "fbepecnt%u", bl + 1 );
 GET_VAR( wname, nc_var, dims ); // fbconn# variable, 1 dimensional
 count[0] = num_faces_in_block;
 
 fail = nc_put_vara_int( ncFile, nc_var, start, count, &fbepe[0] );
 if( NC_NOERR != fail )
 {
 delete[] connectivity;
 MB_SET_ERR( MB_FAILURE, "Couldn't write fbepecnt variable" );
 }
 
 int id = bl + 1;
 if( write_exodus_integer_variable( "fa_prop1", &id, bl, 1 ) != MB_SUCCESS )
 {
 MB_SET_ERR_CONT( "Problem writing element block id " << id );
 }
 
 int status = 1;
 if( write_exodus_integer_variable( "fa_status", &status, bl, 1 ) != MB_SUCCESS )
 {
 MB_SET_ERR( MB_FAILURE, "Problem writing face block status" );
 }
 
 delete[] connectivity;
 if( 0 == repeat_face_blocks ) break; // do not repeat face blocks
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::Range::empty(), moab::Range::end(), ErrorCode, moab::fail(), moab::Interface::get_connectivity(), GET_DIM, GET_VAR, INS_ID, MB_CHK_ERR, MB_SET_ERR, MB_SET_ERR_CONT, MB_SUCCESS, mdbImpl, ncFile, moab::WriteNCDF::ExodusMeshInfo::num_polyhedra_blocks, moab::WriteNCDF::ExodusMeshInfo::polyhedronFaces, repeat_face_blocks, moab::Range::size(), and write_exodus_integer_variable().

Referenced by write_file().

write_qa_records()

ErrorCode moab::WriteNCDF::write_qa_records ( std::vector< std::string > &  qa_record_list )

private

Definition at line 755 of file WriteNCDF.cpp.

{
 int i = 0;
 
 for( std::vector< std::string >::iterator string_it = qa_record_list.begin(); string_it != qa_record_list.end(); )
 {
 for( int j = 0; j < 4; j++ )
 write_qa_string( ( *string_it++ ).c_str(), i, j );
 i++;
 }
 
 return MB_SUCCESS;
}

References MB_SUCCESS, and write_qa_string().

Referenced by write_file().

write_qa_string()

ErrorCode moab::WriteNCDF::write_qa_string ( const char *  string, int  record_number, int  record_position  )

private

Definition at line 769 of file WriteNCDF.cpp.

{
 // Get the variable id in the exodus file
 
 std::vector< int > dims;
 int temp_var = -1;
 GET_VAR( "qa_records", temp_var, dims );
 if( -1 == temp_var )
 {
 MB_SET_ERR( MB_FAILURE, "WriteNCDF:: Problem getting qa record variable" );
 }
 size_t count[3], start[3];
 
 // Write out the record
 start[0] = record_number;
 start[1] = record_position;
 start[2] = 0;
 
 count[0] = 1;
 count[1] = 1;
 count[2] = (long)strlen( string ) + 1;
 int fail = nc_put_vara_text( ncFile, temp_var, start, count, string );
 if( NC_NOERR != fail )
 {
 MB_SET_ERR( MB_FAILURE, "Failed to position qa string variable" );
 }
 
 return MB_SUCCESS;
}

References moab::fail(), GET_VAR, MB_SET_ERR, MB_SUCCESS, and ncFile.

Referenced by write_qa_records().

Member Data Documentation

exodusFile

std::string moab::WriteNCDF::exodusFile

private

file name

Definition at line 135 of file WriteNCDF.hpp.

mCurrentMeshHandle

EntityHandle moab::WriteNCDF::mCurrentMeshHandle

private

Meshset Handle for the mesh that is currently being read.

Definition at line 139 of file WriteNCDF.hpp.

mdbImpl

Interface* moab::WriteNCDF::mdbImpl

private

interface instance

Definition at line 131 of file WriteNCDF.hpp.

Referenced by gather_mesh_information(), get_sideset_elems(), get_valid_sides(), initialize_exodus_file(), write_BCs(), write_elementblocks(), write_file(), write_nodes(), write_poly_faces(), and ~WriteNCDF().

mDirichletSetTag

Tag moab::WriteNCDF::mDirichletSetTag

private

Definition at line 144 of file WriteNCDF.hpp.

Referenced by gather_mesh_information(), write_file(), and WriteNCDF().

mDistFactorTag

Tag moab::WriteNCDF::mDistFactorTag

private

Definition at line 148 of file WriteNCDF.hpp.

Referenced by gather_mesh_information(), get_valid_sides(), and WriteNCDF().

mEntityMark

Tag moab::WriteNCDF::mEntityMark

private

Definition at line 152 of file WriteNCDF.hpp.

Referenced by gather_mesh_information(), get_valid_sides(), WriteNCDF(), and ~WriteNCDF().

mGeomDimensionTag

Tag moab::WriteNCDF::mGeomDimensionTag

private

Definition at line 147 of file WriteNCDF.hpp.

mGlobalIdTag

Tag moab::WriteNCDF::mGlobalIdTag

private

Definition at line 149 of file WriteNCDF.hpp.

Referenced by write_BCs(), write_elementblocks(), write_nodes(), and WriteNCDF().

mHasMidNodesTag

Tag moab::WriteNCDF::mHasMidNodesTag

private

Definition at line 146 of file WriteNCDF.hpp.

Referenced by WriteNCDF().

mMaterialSetTag

Tag moab::WriteNCDF::mMaterialSetTag

private

Cached tags for reading. Note that all these tags are defined when the core is initialized.

Definition at line 143 of file WriteNCDF.hpp.

Referenced by gather_mesh_information(), write_file(), and WriteNCDF().

mNeumannSetTag

Tag moab::WriteNCDF::mNeumannSetTag

private

Definition at line 145 of file WriteNCDF.hpp.

Referenced by gather_mesh_information(), write_file(), and WriteNCDF().

mQaRecordTag

Tag moab::WriteNCDF::mQaRecordTag

private

Definition at line 150 of file WriteNCDF.hpp.

Referenced by gather_mesh_information(), and WriteNCDF().

mWriteIface

WriteUtilIface* moab::WriteNCDF::mWriteIface

private

Definition at line 132 of file WriteNCDF.hpp.

Referenced by gather_mesh_information(), write_elementblocks(), write_nodes(), WriteNCDF(), and ~WriteNCDF().

ncFile

int moab::WriteNCDF::ncFile

private

Definition at line 136 of file WriteNCDF.hpp.

Referenced by initialize_exodus_file(), open_file(), write_BCs(), write_elementblocks(), write_exodus_integer_variable(), write_file(), write_nodes(), write_poly_faces(), write_qa_string(), and ~WriteNCDF().

repeat_face_blocks

int moab::WriteNCDF::repeat_face_blocks

private

Definition at line 154 of file WriteNCDF.hpp.

Referenced by initialize_exodus_file(), write_file(), and write_poly_faces().

---

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

• WriteNCDF.hpp
• WriteNCDF.cpp