#include <ReadRTT.hpp>

Inheritance diagram for moab::ReadRTT:

Collaboration diagram for moab::ReadRTT:

Classes
struct	boundary

struct	cell

struct	cell_def

struct	dimData

struct	facet

struct	headerData

struct	node

struct	side

struct	tet

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

	ReadRTT (Interface *impl=NULL)

virtual	~ReadRTT ()

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
typedef std::map< std::string, std::vector< std::string > >	rtt_flags

typedef std::map< std::string, std::vector< cell > >	rtt_flags_data

Private Member Functions
ErrorCode	generate_topology (std::vector< side > side_data, std::vector< cell > cell_data, std::vector< tet > tet_data, std::map< int, EntityHandle > &surface_map, std::map< int, EntityHandle > &volume_map)

void	generate_parent_child_links (int num_ents[4], std::vector< EntityHandle > entity_map[4], std::vector< side > side_data, std::vector< cell > cell_data)

void	set_surface_senses (int num_ents[4], std::vector< EntityHandle > entity_map[4], std::vector< side > side_data, std::vector< cell > cell_data)

ErrorCode	setup_group_data (std::vector< EntityHandle > entity_map[4], std::vector< tet > tet_data, std::map< int, EntityHandle > &volume_map)

EntityHandle	create_group (std::string group_name, int id)

ErrorCode	parse_dims (std::ifstream &input_file)

ErrorCode	read_cell_defs (std::ifstream &input_file)

ErrorCode	build_moab (std::vector< node > node_data, std::vector< facet > facet_data, std::vector< tet > tet_data, std::map< int, EntityHandle > surface_map, std::map< int, EntityHandle > volume_map)

ErrorCode	add_metadata (EntityHandle file_set)

ErrorCode	read_header (const char *filename)

ErrorCode	read_all_flags (const char *filename, std::vector< int > n_flags, std::string flag_id, rtt_flags &flags, std::map< std::string, int > &flag_idx)

ErrorCode	read_side_flags (const char *filename)

ErrorCode	side_process_faces (rtt_flags side_flags, std::vector< side > &side_data)

ErrorCode	read_cell_flags (const char *filename)

ErrorCode	cell_process_flag (rtt_flags cell_flags, std::string key)

ErrorCode	read_nodes (const char *filename, std::vector< node > &node_data)

ErrorCode	read_facets (const char *filename, std::vector< facet > &facet_data)

ErrorCode	read_tets (const char *filename, std::vector< tet > &tet_data)

ErrorCode	get_header_data (std::ifstream &input_file)

cell	get_cell_data (std::string celldata)

side	get_side_data (std::string sidedata)

node	get_node_data (std::string nodedata)

facet	get_facet_data (std::string facetdata)

tet	get_tet_data (std::string tetdata)

std::string	get_material_ref_flag ()
	Get the material ref flag object. More...

std::string	get_volume_ref_flag ()
	Get the volume ref flag object. More...

int	get_max_name_size (std::vector< cell > cell_data)
	Get the max name size object. More...

std::vector< std::string >	split_string (std::string string_to_split, char split_char)

boundary	split_name (std::string atilla_cellname)

int	count_sides (std::vector< side > side_data, std::vector< int > &surface_numbers)

void	create_facets (const std::vector< facet > &facet_data, const std::map< int, EntityHandle > &surface_map, Range &mb_coords, EntityHandle file_set)

ErrorCode	create_material_group (const std::string &material_name, int material_id, EntityHandle &handle)

Private Attributes
headerData	header_data

dimData	dim_data

rtt_flags_data	cell_flag_datas

std::map< std::string, std::map< int, int > >	cell_flag_indexes

std::map< std::string, int >	cell_flag_idx

rtt_flags_data	side_flag_datas

std::map< std::string, std::map< int, int > >	side_flag_indexes

std::map< std::string, int >	side_flag_idx

std::map< int, cell_def >	cell_def_data

std::vector< cell >	cell_data

std::map< int, int >	cell_data_idx

std::vector< side >	side_data

ReadUtilIface *	readMeshIface

Interface *	MBI

GeomTopoTool *	myGeomTool

Tag	geom_tag

Tag	id_tag

Tag	name_tag

Tag	category_tag

Tag	faceting_tol_tag

Detailed Description

Definition at line 112 of file ReadRTT.hpp.

Member Typedef Documentation

◆ rtt_flags

typedef std::map< std::string, std::vector< std::string > > moab::ReadRTT::rtt_flags

private

Definition at line 333 of file ReadRTT.hpp.

◆ rtt_flags_data

typedef std::map< std::string, std::vector< cell > > moab::ReadRTT::rtt_flags_data

private

Definition at line 334 of file ReadRTT.hpp.

Constructor & Destructor Documentation

◆ ReadRTT()

ReadRTT::ReadRTT ( Interface * impl = NULL )

Definition at line 56 of file ReadRTT.cpp.

     : MBI( impl ), geom_tag( 0 ), id_tag( 0 ), name_tag( 0 ), category_tag( 0 ), faceting_tol_tag( 0 )
 {
     assert( NULL != impl );
     myGeomTool = new GeomTopoTool( impl );
     MBI->query_interface( readMeshIface );
     assert( NULL != readMeshIface );
  
     // this section copied from ReadCGM initalisation
     int negone  = -1;
     double zero = 0.;
     ErrorCode rval;
     rval = MBI->tag_get_handle( GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, geom_tag, MB_TAG_SPARSE | MB_TAG_CREAT,
                                 &negone );
     MB_CHK_ERR_CONT( rval );
     id_tag = MBI->globalId_tag();
     rval = MBI->tag_get_handle( NAME_TAG_NAME, NAME_TAG_SIZE, MB_TYPE_OPAQUE, name_tag, MB_TAG_SPARSE | MB_TAG_CREAT );
     MB_CHK_ERR_CONT( rval );
     rval = MBI->tag_get_handle( CATEGORY_TAG_NAME, CATEGORY_TAG_SIZE, MB_TYPE_OPAQUE, category_tag,
                                 MB_TAG_SPARSE | MB_TAG_CREAT );
     MB_CHK_ERR_CONT( rval );
     rval =
         MBI->tag_get_handle( "FACETING_TOL", 1, MB_TYPE_DOUBLE, faceting_tol_tag, MB_TAG_SPARSE | MB_TAG_CREAT, &zero );
     MB_CHK_ERR_CONT( rval );
 }

References category_tag, CATEGORY_TAG_NAME, CATEGORY_TAG_SIZE, ErrorCode, faceting_tol_tag, GEOM_DIMENSION_TAG_NAME, geom_tag, moab::Interface::globalId_tag(), id_tag, MB_CHK_ERR_CONT, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_DOUBLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, MBI, myGeomTool, name_tag, NAME_TAG_NAME, NAME_TAG_SIZE, moab::Interface::query_interface(), readMeshIface, and moab::Interface::tag_get_handle().

Referenced by factory().

◆ ~ReadRTT()

ReadRTT::~ReadRTT ( )

virtual

Definition at line 83 of file ReadRTT.cpp.

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

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

Member Function Documentation

◆ add_metadata()

moab::ErrorCode ReadRTT::add_metadata ( EntityHandle file_set )

private

Add Metadata to the meshset, this includes the version number and contiguity value

Returns: moab::ErrorCode

Definition at line 366 of file ReadRTT.cpp.

 {
     moab::ErrorCode rval = MB_FAILURE;
  
     // Create CONTIGUITY tag and set its value
     Tag contiguity_tag;
     const char* contiguity_value = header_data.contiguity.c_str();
     rval = MBI->tag_get_handle( "CONTIGUITY", strlen( contiguity_value ) + 1, MB_TYPE_OPAQUE, contiguity_tag,
                                 MB_TAG_SPARSE | MB_TAG_CREAT );
     if( rval != MB_SUCCESS ) return rval;
     rval = MBI->tag_set_data( contiguity_tag, &file_set, 1, contiguity_value );
  
     return rval;
 }

References moab::ReadRTT::headerData::contiguity, ErrorCode, header_data, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_OPAQUE, MBI, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

◆ build_moab()

ErrorCode ReadRTT::build_moab	(	std::vector< node >	node_data,
		std::vector< facet >	facet_data,
		std::vector< tet >	tet_data,
		std::map< int, EntityHandle >	surface_map,
		std::map< int, EntityHandle >	volume_map
	)

private

Builds the full MOAB representation of the data, making vertices from coordinates, triangles from vertices and tets from the same vertices. Tags appropriate to each dataset collection are applied, triangles are tagged with the surface id and side id they belong to, as well as tagging the surface with the same data. Tets are similarly tagged only with the Material number

Parameters

node_data	the node data
facet_data,the	triangles in the problem
tet_data,the	tets in the problem
surface_map,the	map of surface meshset and id numbers

Returns: moab::ErrorCode

Definition at line 247 of file ReadRTT.cpp.

 {
     ErrorCode rval;
     EntityHandle file_set;
  
     rval = MBI->create_meshset( MESHSET_SET, file_set );
     if( MB_SUCCESS != rval ) return rval;
  
     // adding vertex set to the file set
     Range mb_coords;
     for( const auto& n : node_data )
     {
         double coords[3] = { n.x, n.y, n.z };
         EntityHandle v;
         rval = MBI->create_vertex( coords, v );MB_CHK_ERR( rval );
         mb_coords.insert( v );
     }
     rval = MBI->add_entities( file_set, mb_coords );MB_CHK_ERR( rval );
  
     // add facets to the file set
     create_facets( facet_data, surface_map, mb_coords, file_set );
  
     // material number tag
     Tag mat_num_tag;
     rval = MBI->tag_get_handle( "MATERIAL_NUMBER", 1, MB_TYPE_INTEGER, mat_num_tag, MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_ERR( rval );
  
     // adding material groups
     std::string mat_flag = get_material_ref_flag();
     std::string vol_flag = get_volume_ref_flag();
  
     // add tets to the file set
     Range mb_tets;
     for( const auto& t : tet_data )
     {
         EntityHandle tet_nodes[4] = { mb_coords[t.connectivity[0] - 1], mb_coords[t.connectivity[1] - 1],
                                       mb_coords[t.connectivity[2] - 1], mb_coords[t.connectivity[3] - 1] };
  
         EntityHandle tet_h;
         rval = MBI->create_element( MBTET, tet_nodes, 4, tet_h );MB_CHK_ERR( rval );
  
         int mat_no = t.flag_values[cell_flag_idx[mat_flag]];
         rval       = MBI->tag_set_data( mat_num_tag, &tet_h, 1, &mat_no );MB_CHK_ERR( rval );
  
         mb_tets.insert( tet_h );
     }
     rval = MBI->add_entities( file_set, mb_tets );MB_CHK_ERR( rval );
  
     return MB_SUCCESS;
 }

References moab::Interface::add_entities(), cell_flag_idx, moab::Interface::create_element(), create_facets(), moab::Interface::create_meshset(), moab::Interface::create_vertex(), ErrorCode, get_material_ref_flag(), get_volume_ref_flag(), moab::Range::insert(), MB_CHK_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_INTEGER, MBI, MBTET, MESHSET_SET, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by load_file().

◆ cell_process_flag()

ErrorCode ReadRTT::cell_process_flag	(	rtt_flags	cell_flags,
		std::string	key
	)

private

Process the standard flag from the cell_flags section

Parameters

cell_flags,a	vector containing all the read side_flag section
key,the	key to read
cell_data,a	vector containing all the read cell data

Returns: moab::ErrorCode

Definition at line 562 of file ReadRTT.cpp.

 {
     std::vector< cell > cell_data;
     // check if the key is in the cell_flags
     if( cell_flags.find( key ) != cell_flags.end() )
     {
         for( size_t i = 0; i < cell_flags[key].size(); i++ )
         {
             cell data = ReadRTT::get_cell_data( cell_flags[key][i] );
             cell_data.push_back( data );
         }
         if( cell_data.size() == 0 ) return MB_FAILURE;
     }
  
     // fill the corresponding index
     std::map< int, int > cell_data_idx;
     for( size_t i = 0; i < cell_data.size(); ++i )
     {
         cell tmp              = cell_data[i];
         cell_data_idx[tmp.id] = i;
     }
     if( cell_data.size() > 0 ) cell_flag_datas[key] = cell_data;
     cell_flag_indexes[key] = cell_data_idx;
  
     return MB_SUCCESS;
 }

References cell_data, cell_data_idx, cell_flag_datas, cell_flag_indexes, get_cell_data(), moab::ReadRTT::cell::id, and MB_SUCCESS.

Referenced by read_cell_flags().

◆ count_sides()

int moab::ReadRTT::count_sides	(	std::vector< side >	side_data,
		std::vector< int > &	surface_numbers
	)

private

Count the number of unique surface numbers in the dataset, also get list of surface numbers

Parameters

side_data,collection	of all the side data in the mesh
surface_numbers,collection	of surface numbers

returns the number of surface numbers

◆ create_facets()

void ReadRTT::create_facets	(	const std::vector< facet > &	facet_data,
		const std::map< int, EntityHandle > &	surface_map,
		Range &	mb_coords,
		EntityHandle	file_set
	)

private

Definition at line 327 of file ReadRTT.cpp.

 {
     ErrorCode rval;
     Tag side_id_tag, surface_number_tag;
     // Obtain or create tags for side IDs and surface numbers
     rval = MBI->tag_get_handle( "SIDEID_TAG", 1, MB_TYPE_INTEGER, side_id_tag, MB_TAG_SPARSE | MB_TAG_CREAT );
     rval =
         MBI->tag_get_handle( "SURFACE_NUMBER", 1, MB_TYPE_INTEGER, surface_number_tag, MB_TAG_SPARSE | MB_TAG_CREAT );
  
     EntityHandle triangle;
     Range mb_tris;  // For storing triangles
  
     for( const auto& tmp : facet_data )
     {
         EntityHandle tri_nodes[3] = { mb_coords[tmp.connectivity[0] - 1], mb_coords[tmp.connectivity[1] - 1],
                                       mb_coords[tmp.connectivity[2] - 1] };
         rval                      = MBI->create_element( MBTRI, tri_nodes, 3, triangle );
         // tag in side id on the triangle
         rval = MBI->tag_set_data( side_id_tag, &triangle, 1, &tmp.side_id );
         // tag the surface number on the triangle
         rval = MBI->tag_set_data( surface_number_tag, &triangle, 1, &tmp.surface_number );
         // insert vertices and triangles into the appropriate surface meshset
         EntityHandle meshset_handle = surface_map.at( tmp.surface_number );
         // also set surface tag
         rval = MBI->tag_set_data( side_id_tag, &meshset_handle, 1, &tmp.side_id );
         rval = MBI->tag_set_data( surface_number_tag, &meshset_handle, 1, &tmp.surface_number );
         // add vertices to the mesh
         rval = MBI->add_entities( meshset_handle, tri_nodes, 3 );
         // add triangles to the meshset
         rval = MBI->add_entities( meshset_handle, &triangle, 1 );
         // insert triangles into mb_tris
         mb_tris.insert( triangle );
     }
     rval = MBI->add_entities( file_set, mb_tris );
 }

References moab::Interface::add_entities(), moab::Interface::create_element(), ErrorCode, moab::Range::insert(), MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_INTEGER, MBI, MBTRI, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by build_moab().

◆ create_group()

EntityHandle ReadRTT::create_group	(	std::string	group_name,
		int	id
	)

private

create a group of a given name, mustkeep track of id

Parameters

group_name,name	of the group
id,integer	id number

returns the entity handle of the group

Definition at line 1365 of file ReadRTT.cpp.

 {
     ErrorCode rval;
     // category tags
     const char geom_categories[][CATEGORY_TAG_SIZE] = { "Vertex\0", "Curve\0", "Surface\0", "Volume\0", "Group\0" };
  
     EntityHandle handle;
     rval = MBI->create_meshset( MESHSET_SET, handle );
     if( MB_SUCCESS != rval ) return rval;
  
     rval = MBI->tag_set_data( name_tag, &handle, 1, group_name.c_str() );
     if( MB_SUCCESS != rval ) return MB_FAILURE;
  
     rval = MBI->tag_set_data( id_tag, &handle, 1, &id );
     if( MB_SUCCESS != rval ) return MB_FAILURE;
  
     rval = MBI->tag_set_data( category_tag, &handle, 1, &geom_categories[4] );
     if( MB_SUCCESS != rval ) return MB_FAILURE;
  
     return handle;
 }

References category_tag, CATEGORY_TAG_SIZE, moab::Interface::create_meshset(), ErrorCode, id_tag, MB_SUCCESS, MBI, MESHSET_SET, name_tag, and moab::Interface::tag_set_data().

Referenced by setup_group_data().

◆ create_material_group()

ErrorCode ReadRTT::create_material_group	(	const std::string &	material_name,
		int	material_id,
		EntityHandle &	handle
	)

private

Definition at line 302 of file ReadRTT.cpp.

 {
     ErrorCode rval = MBI->create_meshset( MESHSET_SET, handle );
     if( rval != MB_SUCCESS ) return rval;
  
     // NAME
     char name_val[NAME_TAG_SIZE] = { 0 };
     std::strncpy( name_val, material_name.c_str(), NAME_TAG_SIZE - 1 );
     rval = MBI->tag_set_data( name_tag, &handle, 1, name_val );MB_CHK_ERR( rval );
  
     // GLOBAL_ID
     rval = MBI->tag_set_data( id_tag, &handle, 1, &material_id );MB_CHK_ERR( rval );
  
     // CATEGORY
     char cat[CATEGORY_TAG_SIZE] = { 0 };
     std::strncpy( cat, "Group", CATEGORY_TAG_SIZE - 1 );
     rval = MBI->tag_set_data( category_tag, &handle, 1, cat );MB_CHK_ERR( rval );
  
     // GEOM_DIMENSION = 4
     int dim4 = 4;
     rval     = MBI->tag_set_data( geom_tag, &handle, 1, &dim4 );MB_CHK_ERR( rval );
  
     return MB_SUCCESS;
 }

References category_tag, CATEGORY_TAG_SIZE, moab::Interface::create_meshset(), ErrorCode, geom_tag, id_tag, MB_CHK_ERR, MB_SUCCESS, MBI, MESHSET_SET, name_tag, NAME_TAG_SIZE, and moab::Interface::tag_set_data().

Referenced by setup_group_data().

◆ factory()

ReaderIface * ReadRTT::factory ( Interface * iface )

static

Definition at line 50 of file ReadRTT.cpp.

 {
     return new ReadRTT( iface );
 }

References iface, and ReadRTT().

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

◆ generate_parent_child_links()

void ReadRTT::generate_parent_child_links	(	int	num_ents[4],
		std::vector< EntityHandle >	entity_map[4],
		std::vector< side >	side_data,
		std::vector< cell >	cell_data
	)

private

Generate parent child links to create DAGMC like structure of surface meshsets being children of parent cell meshsets. By looping over the surfaces (1->N), look in the description of the cells that are shared by that surface, and then make the surface the child of the parent volume. The appropriate sense data will be set later

Parameters

num_ents[4],array	containing the number of surfaces, cells, groups etc
entity_map[4],vector	of maps containing data by dimension
side_data,vector	of all the side data in the problem
cell_data,vector	of the cell data in the problem

Definition at line 1200 of file ReadRTT.cpp.

 {
     ErrorCode rval;  // return value
     // loop over the number of surfaces
     for( int i = 0; i < num_ents[2]; i++ )
     {
         // get the surface handle
         EntityHandle surf_handle = entity_map[2][i];
         // there are volumes that share this face
         for( unsigned int shared = 0; shared <= 1; shared++ )
         {
             std::string parent_name = side_data[i].names[shared];
             // find the @ sign
             unsigned pos = parent_name.find( "@" );
             parent_name  = parent_name.substr( 0, pos );
  
             // loop over tets looking for matching name
             for( int j = 0; j < num_ents[3]; j++ )
             {
                 // if match found
                 if( cell_data[j].name.compare( parent_name ) == 0 )
                 {
                     EntityHandle cell_handle = entity_map[3][j];
                     // parent
                     rval = MBI->add_parent_child( cell_handle, surf_handle );
                     if( rval != MB_SUCCESS )
                     {
                         std::cerr << "Failed to add parent child relationship" << std::endl;
                     }
                 }
             }
         }
     }
     return;
 }

References moab::Interface::add_parent_child(), cell_data, ErrorCode, MB_SUCCESS, MBI, and side_data.

Referenced by generate_topology().

◆ generate_topology()

ErrorCode ReadRTT::generate_topology	(	std::vector< side >	side_data,
		std::vector< cell >	cell_data,
		std::vector< tet >	tet_data,
		std::map< int, EntityHandle > &	surface_map,
		std::map< int, EntityHandle > &	volume_map
	)

private

generates the topology of the problem from the already read input data, loops over the 2 and 3 dimension macrodata that exist from the rtt file, sides = dagmc surfaces, cells = dagmc cells, creates a meshset for each surface and tags with the id number, and similarly makes a meshset for dagmc cells and tags with the id number. The surfaces are added to the s surface map, where the key is the surface ID number (1->N) and (cells and surfaces are added to an dimesional entity map stored in the class

Parameters

side_data,vector	of side data
cell_data,vector	of vector of cell data
tet_data,vector	of tet data
surface_map,reference	to the surface map of data
volume_map,reference	to the volume map of data

Definition at line 170 of file ReadRTT.cpp.

 {
  
     ErrorCode rval;
     std::vector< EntityHandle > entmap[4];
     int num_ents[4];  // number of entities in each dimension
  
     const char geom_categories[][CATEGORY_TAG_SIZE] = { "Vertex\0", "Curve\0", "Surface\0", "Volume\0", "Group\0" };
  
     std::vector< int > surface_numbers;  // the surface numbers in the problem
  
     // corresponds to number of cad like surfaces and cad like volumes
     num_ents[2] = side_data.size();
     num_ents[3] = cell_data.size();
  
     // loop over surfaces & volumes
     for( int dim = 2; dim <= 3; dim++ )
     {
         for( int i = 0; i != num_ents[dim]; i++ )
         {
             EntityHandle handle;
             // create a meshset for each entity surface/volume
             rval = MBI->create_meshset( dim == 1 ? MESHSET_ORDERED : MESHSET_SET, handle );
             // if failure
             if( rval != MB_SUCCESS ) return rval;
  
             // collect the entity handles into an
             entmap[dim].push_back( handle );
  
             // set the dimension tag
             rval = MBI->tag_set_data( geom_tag, &handle, 1, &dim );
             // if fail
             if( MB_SUCCESS != rval ) return rval;
             // if we are a surface
             if( dim == 2 )
             {
                 // tag the id onto the surface meshset
                 rval = MBI->tag_set_data( id_tag, &handle, 1, &side_data[i].id );
                 // inesert entity into the map
                 surface_map[side_data[i].id] = handle;
             }
             else
             {
                 // otherwise we set the volume tag data, loop is only 2 & 3 dim
                 rval                        = MBI->tag_set_data( id_tag, &handle, 1, &cell_data[i].id );
                 volume_map[cell_data[i].id] = handle;
             }
             // if fail
             if( MB_SUCCESS != rval ) return rval;
             // set the category tag
             rval = MBI->tag_set_data( category_tag, &handle, 1, &geom_categories[dim] );
             if( MB_SUCCESS != rval ) return rval;
         }
     }
  
     // generate parent child links
     // best to loop over the surfaces and assign them to volumes, we can then
     // assign facets to
     // to each surface
     generate_parent_child_links( num_ents, entmap, side_data, cell_data );
  
     // set the surface senses
     set_surface_senses( num_ents, entmap, side_data, cell_data );
  
     // set the group data
     rval = setup_group_data( entmap, tet_data, volume_map );
  
     return MB_SUCCESS;
 }

References category_tag, CATEGORY_TAG_SIZE, cell_data, moab::Interface::create_meshset(), dim, ErrorCode, generate_parent_child_links(), geom_tag, id_tag, MB_SUCCESS, MBI, MESHSET_SET, set_surface_senses(), setup_group_data(), side_data, and moab::Interface::tag_set_data().

Referenced by load_file().

◆ get_cell_data()

ReadRTT::cell ReadRTT::get_cell_data ( std::string celldata )

private

Reads a single atomic cell data string and populates a cell struct

Parameters

celldata,a string of read data and

Returns: cell, the propulated cell struct

Definition at line 978 of file ReadRTT.cpp.

 {
     cell new_cell;
     std::vector< std::string > tokens;
     tokens = ReadRTT::split_string( celldata, ' ' );
  
     // set the side id
     if( tokens.size() != 2 )
     {
         MB_SET_ERR_RET_VAL( "Error, too many tokens found from cell_data", new_cell );
     }
     // create the new side
     new_cell.id   = std::atoi( tokens[0].c_str() );
     new_cell.name = tokens[1];
  
     return new_cell;
 }

References moab::ReadRTT::cell::id, MB_SET_ERR_RET_VAL, moab::ReadRTT::cell::name, and split_string().

Referenced by cell_process_flag().

◆ get_facet_data()

ReadRTT::facet ReadRTT::get_facet_data ( std::string facetdata )

private

Reads a single atomic facet data string and populates a facet struct

Parameters

facetdata,a string of facet data and

Returns: facet, the propulated facet struct

Definition at line 1020 of file ReadRTT.cpp.

 {
     facet new_facet;
     std::vector< std::string > tokens;
     tokens = ReadRTT::split_string( facetdata, ' ' );
  
     // ensure we have the correct number of tokens
     int base_token_size = 0;
     int idx_offset      = 0;
     // branch on the rtt version number
     if( header_data.version == "v1.0.0" )
     {
         base_token_size = 4;
     }
     else if( header_data.version == "v1.0.1" )
     {
         base_token_size = 5;
         idx_offset      = 1;
     }
     else
     {
         MB_SET_ERR_RET_VAL( "Error, version number not understood", new_facet );
     }
  
     if( (int)tokens.size() != base_token_size + dim_data.nside_flag_types )
     {
         std::cout << facetdata << std::endl;
         std::cout << header_data.version << " " << (int)tokens.size() << " " << base_token_size << " "
                   << dim_data.nside_flag_types << std::endl;
         MB_SET_ERR_RET_VAL( "Error, too many tokens found from get_facet_data", new_facet );
         exit( 1 );
     }
  
     // set the side id
     new_facet.id              = std::atoi( tokens[0].c_str() );
     new_facet.connectivity[0] = std::atoi( tokens[idx_offset + 1].c_str() );
     new_facet.connectivity[1] = std::atoi( tokens[idx_offset + 2].c_str() );
     new_facet.connectivity[2] = std::atoi( tokens[idx_offset + 3].c_str() );
     new_facet.side_id         = std::atoi( tokens[idx_offset + 4].c_str() );
     new_facet.surface_number  = std::atoi( tokens[idx_offset + 5].c_str() );
  
     return new_facet;
 }

References moab::ReadRTT::facet::connectivity, dim_data, header_data, moab::ReadRTT::facet::id, MB_SET_ERR_RET_VAL, moab::ReadRTT::dimData::nside_flag_types, moab::ReadRTT::facet::side_id, split_string(), moab::ReadRTT::facet::surface_number, and moab::ReadRTT::headerData::version.

Referenced by read_facets().

◆ get_header_data()

ErrorCode ReadRTT::get_header_data ( std::ifstream & input_file )

private

Reads the header data into a class member structure

Parameters

input_file,an open filestream

Returns: void

Definition at line 699 of file ReadRTT.cpp.

 {
     std::string line;
     while( std::getline( input_file, line ) )
     {
  
         // tokenize the line
         std::istringstream iss( line );
         std::vector< std::string > split_string;
         do
         {
             std::string sub_string;
             iss >> sub_string;
             split_string.push_back( sub_string );
         } while( iss );
  
         // if we find version
         if( line.find( "version" ) != std::string::npos )
         {
             if( split_string[1].find( "v" ) != std::string::npos &&
                 split_string[0].find( "version" ) != std::string::npos )
             {
                 header_data.version = split_string[1];
             }
         }
         else if( line.find( "title" ) != std::string::npos )
         {
             header_data.title = split_string[1];
         }
         else if( line.find( "date" ) != std::string::npos )
         {
             header_data.date = split_string[1];
         }
         else if( line.find( "contiguity" ) != std::string::npos )
         {
             header_data.contiguity = split_string[1];
         }
         else if( line.find( "end_header" ) != std::string::npos )
         {
             return MB_SUCCESS;
         }
     }
     // otherwise we never found the end_header keyword
     return MB_FAILURE;
 }

References moab::ReadRTT::headerData::contiguity, moab::ReadRTT::headerData::date, header_data, input_file, MB_SUCCESS, split_string(), moab::ReadRTT::headerData::title, and moab::ReadRTT::headerData::version.

Referenced by read_header().

◆ get_material_ref_flag()

std::string ReadRTT::get_material_ref_flag ( )

private

Get the material ref flag object.

Returns: std::string

Definition at line 511 of file ReadRTT.cpp.

 {
     std::string material_ref_flag = "";  // set defaul to REGIONS
     if( cell_flag_datas.find( "MATERIAL" ) != cell_flag_datas.end() )
     {
         material_ref_flag = "MATERIAL";
     }
     return material_ref_flag;
 }

References cell_flag_datas.

Referenced by build_moab(), and setup_group_data().

◆ get_max_name_size()

int ReadRTT::get_max_name_size ( std::vector< cell > cell_data )

private

Get the max name size object.

Parameters

cell_data,vector of cell data

Returns: int, the max name size

Definition at line 1130 of file ReadRTT.cpp.

 {
     int max_size = 0;
     for( size_t i = 0; i < cell_data.size(); i++ )
     {
         if( (int)cell_data[i].name.length() > max_size ) max_size = cell_data[i].name.length();
     }
     return max_size;
 }

References cell_data.

◆ get_node_data()

ReadRTT::node ReadRTT::get_node_data ( std::string nodedata )

private

Reads a single atomic node data string and populates a node struct

Parameters

sidedata,a string of read data and

Returns: node, the propulated node struct

Definition at line 999 of file ReadRTT.cpp.

 {
     node new_node;
     std::vector< std::string > tokens;
     tokens = ReadRTT::split_string( nodedata, ' ' );
  
     // set the side id
     if( tokens.size() != 5 )
     {
         MB_SET_ERR_RET_VAL( "Error, too many tokens found from get_node_data", new_node );
     }
     new_node.id = std::atoi( tokens[0].c_str() );
     new_node.x  = std::atof( tokens[1].c_str() );
     new_node.y  = std::atof( tokens[2].c_str() );
     new_node.z  = std::atof( tokens[3].c_str() );
     return new_node;
 }

References moab::ReadRTT::node::id, MB_SET_ERR_RET_VAL, split_string(), moab::ReadRTT::node::x, moab::ReadRTT::node::y, and moab::ReadRTT::node::z.

Referenced by read_nodes().

◆ get_side_data()

ReadRTT::side ReadRTT::get_side_data ( std::string sidedata )

private

Reads a single atomic side data string and populates a side struct

Parameters

sidedata,a string of read data and

Returns: side, the propulated side struct

Definition at line 939 of file ReadRTT.cpp.

 {
     side new_side;
     std::vector< std::string > tokens;
     tokens = ReadRTT::split_string( sidedata, ' ' );
  
     // set the side id
     if( tokens.size() != 2 )
     {
         MB_SET_ERR_RET_VAL( "Error, too many tokens found from side_data", new_side );
     }
     // create the new side
     new_side.id = std::atoi( tokens[0].c_str() );
  
     std::vector< std::string > cell_names = ReadRTT::split_string( tokens[1], '/' );
     // get the boundary
     boundary new_bnd = ReadRTT::split_name( cell_names[0] );
     // set the surface sense and name
     new_side.senses[0] = new_bnd.sense;
     new_side.names[0]  = new_bnd.name;
     //
     if( cell_names.size() > 1 )
     {
         boundary bnd       = ReadRTT::split_name( cell_names[1] );
         new_side.senses[1] = bnd.sense;
         new_side.names[1]  = bnd.name;
     }
     else
     {
         new_side.senses[1] = 0;
         new_side.names[1]  = "\0";
     }
  
     return new_side;
 }

References moab::ReadRTT::side::id, MB_SET_ERR_RET_VAL, moab::ReadRTT::boundary::name, moab::ReadRTT::side::names, moab::ReadRTT::boundary::sense, moab::ReadRTT::side::senses, split_name(), and split_string().

Referenced by side_process_faces().

◆ get_tet_data()

ReadRTT::tet ReadRTT::get_tet_data ( std::string tetdata )

private

Reads a single atomic tet data string and populates a tet struct

Parameters

tetdata,a string of tet data and

Returns: tet, the propulated tet struct

Definition at line 1068 of file ReadRTT.cpp.

 {
     tet new_tet;
     std::vector< std::string > tokens;
     tokens = ReadRTT::split_string( tetdata, ' ' );
  
     // ensure we have the correct number of tokens
     int base_token_size = 0;
     int n_nodes         = 0;
     // branch on the rtt version number
     if( header_data.version == "v1.0.0" )
     {
         base_token_size = 1;
         // for old format we assume 4 nodes (Tet)
         n_nodes = 4;
     }
     else if( header_data.version == "v1.0.1" )
     {
         base_token_size = 2;
  
         // get the cell type
         new_tet.type_id = std::atoi( tokens[1].c_str() );
         // check that the cell type exists
         if( cell_def_data.find( new_tet.type_id ) == cell_def_data.end() )
         {
             std::cout << "Error: cell type " << new_tet.type_id << " not found in cell definitions." << std::endl;
             MB_SET_ERR_RET_VAL( "Error, cell type not found in cell definitions", new_tet );
         }
         n_nodes     = cell_def_data[new_tet.type_id].nnodes;
         int n_sides = cell_def_data[new_tet.type_id].nsides;
         if( n_nodes != 4 || n_sides != 4 )
         {
             std::cout << "Error: cell type " << new_tet.type_id << " does not have 4 nodes and 4 sides." << std::endl;
             MB_SET_ERR_RET_VAL( "Error, cell is not tetrahedricon", new_tet );
         }
     }
     else
     {
         MB_SET_ERR_RET_VAL( "Error, version number not understood", new_tet );
     }
     // set the side id
     new_tet.id = std::atoi( tokens[0].c_str() );
  
     if( (int)tokens.size() != base_token_size + n_nodes + dim_data.ncell_flag_types )
     {
         MB_SET_ERR_RET_VAL( "Error, unexpected number of tokens found from get_tet_data", new_tet );
     }
     for( int i = 0; i < n_nodes; i++ )
     {
         new_tet.connectivity[i] = std::atoi( tokens[i + base_token_size].c_str() );
     }
     for( int i = 0; i < dim_data.ncell_flag_types; i++ )
     {
         new_tet.flag_values.push_back( std::atoi( tokens[i + base_token_size + n_nodes].c_str() ) );
     }
  
     return new_tet;
 }

References cell_def_data, moab::ReadRTT::tet::connectivity, dim_data, moab::ReadRTT::tet::flag_values, header_data, moab::ReadRTT::tet::id, MB_SET_ERR_RET_VAL, moab::ReadRTT::dimData::ncell_flag_types, split_string(), moab::ReadRTT::tet::type_id, and moab::ReadRTT::headerData::version.

Referenced by read_tets().

◆ get_volume_ref_flag()

std::string ReadRTT::get_volume_ref_flag ( )

private

Get the volume ref flag object.

Returns: std::string

Definition at line 521 of file ReadRTT.cpp.

 {
     std::string part_ref_flag = "REGIONS";  // set defaul to REGIONS
     if( cell_flag_datas.find( "MCNP_PSEUDO-CELLS" ) != cell_flag_datas.end() )
     {
         part_ref_flag = "MCNP_PSEUDO-CELLS";
     }
     else if( cell_flag_datas.find( "ABAQUS_PARTS" ) != cell_flag_datas.end() )
     {
         part_ref_flag = "ABAQUS_PARTS";
     }
     return part_ref_flag;
 }

References cell_flag_datas.

Referenced by build_moab(), read_cell_flags(), and setup_group_data().

◆ load_file()

ErrorCode ReadRTT::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 104 of file ReadRTT.cpp.

 {
     ErrorCode rval;
  
     // at this time there is no support for reading a subset of the file
     if( subset_list )
     {
         std::cout << "Subset reading not supported for RTT meshes" << std::endl;
         return MB_UNSUPPORTED_OPERATION;
     }
  
     // test to see if file exists
     FILE* file = NULL;
     file       = fopen( filename, "r" );
     if( file == NULL ) return MB_FILE_DOES_NOT_EXIST;
     // otherwise close the file
     fclose( file );
  
     // read the header
     rval = ReadRTT::read_header( filename );
     if( rval != MB_SUCCESS ) return rval;
  
     // read the side_flag data
     rval = ReadRTT::read_side_flags( filename );
     if( rval != MB_SUCCESS ) return rval;
  
     // read the cell data
     rtt_flags cell_flags;
     rval = ReadRTT::read_cell_flags( filename );
     if( rval != MB_SUCCESS ) return rval;
  
     // read the node data
     std::vector< node > node_data;
     rval = ReadRTT::read_nodes( filename, node_data );
     if( rval != MB_SUCCESS ) return rval;
  
     // read the facet data
     std::vector< facet > facet_data;
     rval = ReadRTT::read_facets( filename, facet_data );
     if( rval != MB_SUCCESS ) return rval;
  
     // read the tetrahedra data
     std::vector< tet > tet_data;
     rval = ReadRTT::read_tets( filename, tet_data );
     if( rval != MB_SUCCESS ) return rval;
  
     // make the map of surface number in the rttmesh to the surface meshset
     std::map< int, EntityHandle > surface_map;  // corrsespondance of surface number to entity handle
     std::map< int, EntityHandle > volume_map;   // corrsespondance of volume number to entity handle
     rval = ReadRTT::generate_topology( side_data, cell_data, tet_data, surface_map, volume_map );
     if( rval != MB_SUCCESS ) return rval;
  
     // generate the rest of the database, triangles to surface meshsets etc
     rval = ReadRTT::build_moab( node_data, facet_data, tet_data, surface_map, volume_map );
     if( rval != MB_SUCCESS ) return rval;
  
     return MB_SUCCESS;
 }

References build_moab(), cell_data, ErrorCode, generate_topology(), MB_FILE_DOES_NOT_EXIST, MB_SUCCESS, MB_UNSUPPORTED_OPERATION, read_cell_flags(), read_facets(), read_header(), read_nodes(), read_side_flags(), read_tets(), and side_data.

◆ parse_dims()

ErrorCode ReadRTT::parse_dims ( std::ifstream & input_file )

private

parse the dimensions of the problem from the file header

Parameters

input_file,an open filestream

Definition at line 745 of file ReadRTT.cpp.

 {
     if( !input_file.good() || !input_file.is_open() )
     {
         std::cout << "Problems reading file" << std::endl;
         return MB_FAILURE;
     }
  
     std::string line;
     std::vector< std::string > tokens;
     while( std::getline( input_file, line ) )
     {
         if( line == "" ) continue;
         if( line.find( "end_dims" ) != std::string::npos ) break;
  
         tokens = ReadRTT::split_string( line, ' ' );
         if( tokens[0] == "coor_units" )
         {
             dim_data.coor_units = tokens[1];
         }
         else if( tokens[0] == "prob_time_units" )
         {
             dim_data.prob_time_units = tokens[1];
         }
         else if( tokens[0] == "ncell_defs" )
         {
             dim_data.ncell_defs = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nnodes_max" )
         {
             dim_data.nnodes_max = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nsides_max" )
         {
             dim_data.nsides_max = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nnodes_sides_max" )
         {
             dim_data.nnodes_sides_max = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "ndim" )
         {
             dim_data.ndim = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "n_dim_topo" )
         {
             dim_data.n_dim_topo = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nnodes" )
         {
             dim_data.nnodes = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nnode_flag_types" )
         {
             dim_data.nnode_flag_types = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nnode_flags" )
         {
             for( size_t i = 1; i < tokens.size(); i++ )
             {
                 dim_data.nnode_flags.push_back( std::atoi( tokens[i].c_str() ) );
             }
         }
         else if( tokens[0] == "nnode_data" )
         {
             dim_data.nnode_data = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nsides" )
         {
             dim_data.nsides = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nside_types" )
         {
             dim_data.nside_types = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "side_types" )
         {
             dim_data.side_types = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nside_flag_types" )
         {
             dim_data.nside_flag_types = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "nside_flags" )
         {
             for( size_t i = 1; i < tokens.size(); i++ )
             {
                 dim_data.nside_flags.push_back( std::atoi( tokens[i].c_str() ) );
             }
         }
         else if( tokens[0] == "nside_data" )
         {
             dim_data.nside_data = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "ncells" )
         {
             dim_data.ncells = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "ncell_types" )
         {
             dim_data.ncell_types = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "cell_types" )
         {
             dim_data.cell_types = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "ncell_flag_types" )
         {
             dim_data.ncell_flag_types = std::atoi( tokens[1].c_str() );
         }
         else if( tokens[0] == "ncell_flags" )
         {
             for( size_t i = 1; i < tokens.size(); i++ )
             {
                 dim_data.ncell_flags.push_back( std::atoi( tokens[i].c_str() ) );
             }
         }
         else if( tokens[0] == "ncell_data" )
         {
             dim_data.ncell_data = std::atoi( tokens[1].c_str() );
         }
     }
     // Check that the data is valid and has the expected number of entries
     dim_data.validate();
  
     return MB_SUCCESS;
 }

Referenced by read_header().

◆ read_all_flags()

ErrorCode ReadRTT::read_all_flags	(	const char *	filename,
		std::vector< int >	n_flags,
		std::string	flag_id,
		rtt_flags &	flags,
		std::map< std::string, int > &	flag_idx
	)

private

Reads the full set of data from the file

Parameters

filename,the	file to read all the data from
n_flags,a	vector containing the number of flags
flag_id,the	flag id to read
flags,a	map for all the flags from the XX_flags section
flag_idx,a	map for the index of the flags

Returns: moab::ErrorCode

Definition at line 420 of file ReadRTT.cpp.

 {
     std::string start_flag = flag_id + "_flags";
     std::string end_flag   = "end_" + start_flag + "\0";
     std::string line;                       // the current line being read
     std::ifstream input_file( filename );   // filestream for rttfile
     std::vector< std::string > flag_order;  // order of the flags
     // file ok?
     if( !input_file.good() )
     {
         std::cout << "Problems reading file = " << filename << std::endl;
         return MB_FAILURE;
     }
     // if it works
     if( input_file.is_open() )
     {
         while( std::getline( input_file, line ) )
         {
             if( line.compare( start_flag ) == 0 )
             {
                 while( std::getline( input_file, line ) )
                 {
                     // Read all the side block until we find the end
                     if( line.compare( end_flag ) == 0 ) break;
                     std::vector< std::string > token = ReadRTT::split_string( line, ' ' );
                     if( token.size() != 2 )
                     {
                         std::cout << "Error reading side flags" << std::endl;
                         return MB_FAILURE;
                     }
                     int flag_key    = std::stoi( token[0] ) - 1;
                     std::string key = token[1];
                     flag_order.push_back( key );
                     for( int i = 0; i < n_flags[flag_key]; i++ )
                     {
                         std::getline( input_file, line );
                         flags[key].push_back( line );
                     }
                 }
             }
         }
         input_file.close();
     }
     for( size_t i = 0; i < flag_order.size(); i++ )
     {
         std::string key = flag_order[i];
         // fill the index
         flag_idx[key] = i;
     }
     return MB_SUCCESS;
 }

References input_file, MB_SUCCESS, and split_string().

Referenced by read_cell_flags(), and read_side_flags().

◆ read_cell_defs()

ErrorCode ReadRTT::read_cell_defs ( std::ifstream & input_file )

private

parse the cell definition car

Parameters

input_file,an open filestream

Definition at line 876 of file ReadRTT.cpp.

 {
     if( !input_file.good() || !input_file.is_open() )
     {
         std::cout << "Problems reading file" << std::endl;
         return MB_FAILURE;
     }
  
     std::string line;
     std::vector< std::string > tokens;
     while( std::getline( input_file, line ) )
     {
         if( line == "" ) continue;
         if( line.find( "end_cell_defs" ) != std::string::npos ) break;
         cell_def new_cell_def;
         // Tokenize the line
         tokens            = ReadRTT::split_string( line, ' ' );
         new_cell_def.id   = std::atoi( tokens[0].c_str() );
         new_cell_def.name = tokens[1];
         // Getting the number of nodes and sides
         std::getline( input_file, line );
         // Tokenize the line
         tokens              = ReadRTT::split_string( line, ' ' );
         new_cell_def.nnodes = std::atoi( tokens[0].c_str() );
         new_cell_def.nsides = std::atoi( tokens[1].c_str() );
         // Side type index
         std::getline( input_file, line );
         // Tokenize the line
         tokens = ReadRTT::split_string( line, ' ' );
         for( int i = 0; i < new_cell_def.nsides; i++ )
         {
             int side_type = std::atoi( tokens[i].c_str() );
             // Ensure side types exists
             if( cell_def_data.find( side_type ) == cell_def_data.end() )
             {
                 std::cout << "Error: side type " << side_type << " not found in cell definitions." << std::endl;
                 return MB_FAILURE;
             }
             new_cell_def.side_type.push_back( side_type );
         }
         // Read the nodes per side
         for( int i = 0; i < new_cell_def.nsides; i++ )
         {
             std::vector< int > side_nodes;
             std::getline( input_file, line );
             // Tokenize the line
             tokens = ReadRTT::split_string( line, ' ' );
             for( int j = 0; j < new_cell_def.nnodes; j++ )
             {
                 side_nodes.push_back( std::atoi( tokens[i].c_str() ) );
             }
             new_cell_def.sides_nodes.push_back( side_nodes );
         }
  
         cell_def_data.insert( std::make_pair( new_cell_def.id, new_cell_def ) );
     }
  
     return MB_SUCCESS;
 }

References cell_def_data, moab::ReadRTT::cell_def::id, input_file, MB_SUCCESS, moab::ReadRTT::cell_def::name, moab::ReadRTT::cell_def::nnodes, moab::ReadRTT::cell_def::nsides, moab::ReadRTT::cell_def::side_type, moab::ReadRTT::cell_def::sides_nodes, and split_string().

Referenced by read_header().

◆ read_cell_flags()

ErrorCode ReadRTT::read_cell_flags ( const char * filename )

private

Reads the full set of cell data from the file

Parameters

filename,the file to read all the side data from

Returns: moab::ErrorCode

Definition at line 538 of file ReadRTT.cpp.

 {
     rtt_flags cell_flags;
     ErrorCode rval = MB_FAILURE;
     // read all the cell data
     rval = read_all_flags( filename, dim_data.ncell_flags, "cell", cell_flags, cell_flag_idx );
  
     for( auto it = cell_flags.begin(); it != cell_flags.end(); ++it )
     {
         std::string key = it->first;
         // fill the index
         rval = ReadRTT::cell_process_flag( cell_flags, key );
         if( rval != MB_SUCCESS ) return rval;
     }
  
     std::string part_flag_name = get_volume_ref_flag();
     cell_data                  = cell_flag_datas[part_flag_name];
     cell_data_idx              = cell_flag_indexes[part_flag_name];
     return rval;
 }

References cell_data, cell_data_idx, cell_flag_datas, cell_flag_idx, cell_flag_indexes, cell_process_flag(), dim_data, ErrorCode, get_volume_ref_flag(), MB_SUCCESS, moab::ReadRTT::dimData::ncell_flags, and read_all_flags().

Referenced by load_file().

◆ read_facets()

ErrorCode ReadRTT::read_facets	(	const char *	filename,
		std::vector< facet > &	facet_data
	)

private

Reads the full set of facet data from the file

Parameters

filename,the	file to read all the side data from
facet	data, a vector containing all the read facet data

Returns: moab::ErrorCode

Definition at line 628 of file ReadRTT.cpp.

 {
     std::string line;                      // the current line being read
     std::ifstream input_file( filename );  // filestream for rttfile
     // file ok?
     if( !input_file.good() )
     {
         std::cout << "Problems reading file = " << filename << std::endl;
         return MB_FAILURE;
     }
  
     // if it works
     if( input_file.is_open() )
     {
         while( std::getline( input_file, line ) )
         {
             if( line.compare( "sides\0" ) == 0 )
             {
                 // read lines until find end nodes
                 while( std::getline( input_file, line ) )
                 {
                     if( line.compare( "end_sides\0" ) == 0 ) break;
                     facet data = ReadRTT::get_facet_data( line );
                     facet_data.push_back( data );
                 }
             }
         }
         input_file.close();
     }
     if( facet_data.size() == 0 ) return MB_FAILURE;
     return MB_SUCCESS;
 }

References get_facet_data(), input_file, and MB_SUCCESS.

Referenced by load_file().

◆ read_header()

ErrorCode ReadRTT::read_header ( const char * filename )

private

reads the full set of header data

Parameters

filename,the file to read the data from

Returns: moab::Error code

Definition at line 384 of file ReadRTT.cpp.

 {
     std::ifstream input_file( filename );  // filename for rtt file
     // file ok?
     if( !input_file.good() )
     {
         std::cout << "Problems reading file = " << filename << std::endl;
         return MB_FAILURE;
     }
  
     // if it works
     std::string line;
     moab::ErrorCode rval = MB_FAILURE;
     if( input_file.is_open() )
     {
         while( std::getline( input_file, line ) )
         {
             if( line.compare( "header" ) == 0 )
             {
                 rval = get_header_data( input_file );
             }
             else if( line.compare( "dims" ) == 0 )
             {
                 rval = parse_dims( input_file );
             }
             else if( line.compare( "cell_defs" ) == 0 )
             {
                 rval = ReadRTT::read_cell_defs( input_file );
             }
         }
         input_file.close();
     }
     return rval;
 }

References ErrorCode, get_header_data(), input_file, parse_dims(), and read_cell_defs().

Referenced by load_file().

◆ read_nodes()

ErrorCode ReadRTT::read_nodes	(	const char *	filename,
		std::vector< node > &	node_data
	)

private

Reads the full set of node data from the file

Parameters

filename,the	file to read all the side data from
node	data, a vector containing all the read node data

Returns: moab::ErrorCode

Definition at line 592 of file ReadRTT.cpp.

 {
     std::string line;                      // the current line being read
     std::ifstream input_file( filename );  // filestream for rttfile
     // file ok?
     if( !input_file.good() )
     {
         std::cout << "Problems reading file = " << filename << std::endl;
         return MB_FAILURE;
     }
  
     // if it works
     if( input_file.is_open() )
     {
         while( std::getline( input_file, line ) )
         {
             if( line.compare( "nodes\0" ) == 0 )
             {
                 // read lines until find end nodes
                 while( std::getline( input_file, line ) )
                 {
                     if( line.compare( "end_nodes\0" ) == 0 ) break;
                     node data = ReadRTT::get_node_data( line );
                     node_data.push_back( data );
                 }
             }
         }
         input_file.close();
     }
     if( node_data.size() == 0 ) return MB_FAILURE;
     return MB_SUCCESS;
 }

References get_node_data(), input_file, and MB_SUCCESS.

Referenced by load_file().

◆ read_side_flags()

ErrorCode ReadRTT::read_side_flags ( const char * filename )

private

Reads the full set of side data from the file

Parameters

filename,the file to read all the side data from

Returns: moab::ErrorCode

Definition at line 479 of file ReadRTT.cpp.

 {
     rtt_flags side_flags;
  
     ErrorCode rval = MB_FAILURE;
     // read all the side data
     rval = read_all_flags( filename, dim_data.nside_flags, "side", side_flags, side_flag_idx );
  
     //process sides
     rval = ReadRTT::side_process_faces( side_flags, side_data );
     if( rval != MB_SUCCESS ) return rval;
  
     return rval;
 }

References dim_data, ErrorCode, MB_SUCCESS, moab::ReadRTT::dimData::nside_flags, read_all_flags(), side_data, side_flag_idx, and side_process_faces().

Referenced by load_file().

◆ read_tag_values()

ErrorCode ReadRTT::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 94 of file ReadRTT.cpp.

 {
     return MB_NOT_IMPLEMENTED;
 }

References MB_NOT_IMPLEMENTED.

◆ read_tets()

ErrorCode ReadRTT::read_tets	(	const char *	filename,
		std::vector< tet > &	tet_data
	)

private

Reads the full set of tet data from the file

Parameters

filename,the	file to read all the side data from
tet	data, a vector containing all the read tet data

Returns: moab::ErrorCode

Definition at line 664 of file ReadRTT.cpp.

 {
     std::string line;                      // the current line being read
     std::ifstream input_file( filename );  // filestream for rttfile
     // file ok?
     if( !input_file.good() )
     {
         std::cout << "Problems reading file = " << filename << std::endl;
         return MB_FAILURE;
     }
     // if it works
     if( input_file.is_open() )
     {
         while( std::getline( input_file, line ) )
         {
             if( line.compare( "cells\0" ) == 0 )
             {
                 // read lines until find end nodes
                 while( std::getline( input_file, line ) )
                 {
                     if( line.compare( "end_cells\0" ) == 0 ) break;
                     tet data = ReadRTT::get_tet_data( line );
                     tet_data.push_back( data );
                 }
             }
         }
         input_file.close();
     }
     if( tet_data.size() == 0 ) return MB_FAILURE;
     return MB_SUCCESS;
 }

References get_tet_data(), input_file, and MB_SUCCESS.

Referenced by load_file().

◆ set_surface_senses()

void ReadRTT::set_surface_senses	(	int	num_ents[4],
		std::vector< EntityHandle >	entity_map[4],
		std::vector< side >	side_data,
		std::vector< cell >	cell_data
	)

private

Sets the appropriate surface senses for each surface in the problem. By looping through all the surfaces, we determine from the side_data vector, the volume id's that are shared, then using 1 to mean +ve sense and -1 to mean -ve sense wrt the volume.

Parameters

num_ents[4],array	containing the number of surfaces, cells, groups etc
entity_map[4],vector	of maps containing data by dimension
side_data,vector	of all the side data in the problem
cell_data,vector	of the cell data in the problem

Definition at line 1242 of file ReadRTT.cpp.

 {
  
     ErrorCode rval;  // return value
     // loop over the number of surfaces
     for( int i = 0; i < num_ents[2]; i++ )
     {
         EntityHandle surf_handle = entity_map[2][i];
         // there are 2 volumes that share this face
         for( unsigned int shared = 0; shared <= 1; shared++ )
         {
             std::string parent_name = side_data[i].names[shared];
             unsigned pos            = parent_name.find( "@" );
             parent_name             = parent_name.substr( 0, pos );
             // loop over tets looking for matching name
             for( int j = 0; j < num_ents[3]; j++ )
             {
                 // if match found
                 if( cell_data[j].name.compare( parent_name ) == 0 )
                 {
                     EntityHandle cell_handle = entity_map[3][j];
                     // in rtt mesh +represents the inside and -represents outside
                     // in moab reverse is outside and forward is inside
                     if( side_data[i].senses[shared] == 1 )
                         rval = myGeomTool->set_sense( surf_handle, cell_handle, SENSE_FORWARD );
                     else if( side_data[i].senses[shared] == -1 )
                         rval = myGeomTool->set_sense( surf_handle, cell_handle, SENSE_REVERSE );
                     else
                         rval = myGeomTool->set_sense( surf_handle, 0, SENSE_REVERSE );
  
                     if( rval != MB_SUCCESS )
                     {
                         std::cerr << "Failed to set sense appropriately" << std::endl;
                     }
                 }
             }
         }
     }
     return;
 }

References cell_data, ErrorCode, MB_SUCCESS, myGeomTool, SENSE_REVERSE, moab::GeomTopoTool::set_sense(), and side_data.

Referenced by generate_topology().

◆ setup_group_data()

ErrorCode ReadRTT::setup_group_data	(	std::vector< EntityHandle >	entity_map[4],
		std::vector< tet >	tet_data,
		std::map< int, EntityHandle > &	volume_map
	)

private

creates the group data requried for dagmc, reflecting planes, material assignments etc

Parameters

entity_map,vector	of vector of entitiy handles for each dimension
tet_data,vector	of tet data

Returns: moab::ErrorCode

Definition at line 1289 of file ReadRTT.cpp.

 {
     ErrorCode rval;  // error codes
     EntityHandle handle;
     handle = create_group( "graveyard_comp", 1 );
  
     // add any volume to group graveyard, it is ignored by dag
     EntityHandle vol_handle = entity_map[3][0];
     rval                    = MBI->add_entities( handle, &vol_handle, 1 );
  
     if( get_material_ref_flag() == "MATERIAL" )
     {
         std::string mat_flag                 = get_material_ref_flag();
         std::string vol_flag                 = get_volume_ref_flag();
         const std::vector< cell >& mat_cells = cell_flag_datas[mat_flag];
         const std::map< int, int >& mat_idx  = cell_flag_indexes[mat_flag];
  
         std::map< int, int > volume2mat;           // region → material
         std::map< int, EntityHandle > mat_groups;  // material → group
  
         for( const auto& t : tet_data )
         {
             int mat_no = t.flag_values[cell_flag_idx[mat_flag]];
             int vol_no = t.flag_values[cell_flag_idx[vol_flag]];
  
             // record the material of this volume (consistency check)
             auto it = volume2mat.find( vol_no );
             if( it == volume2mat.end() )
                 volume2mat[vol_no] = mat_no;
             else if( it->second != mat_no )
             {
                 std::cerr << "Volume " << vol_no << " has conflicting material numbers: " << it->second << " and "
                           << mat_no << std::endl;
                 return MB_FAILURE;
             }
  
             // create material group the first time we meet this material
             if( mat_groups.find( mat_no ) == mat_groups.end() )
             {
                 std::string name = mat_cells[mat_idx.at( mat_no )].name;
                 if( name.rfind( "mat:", 0 ) != 0 ) name = "mat:" + name;  // exactly one prefix
  
                 EntityHandle mat_grp;
                 rval = create_material_group( name, mat_no, mat_grp );MB_CHK_ERR( rval );
                 mat_groups[mat_no] = mat_grp;
             }
         }
  
         // assigning volumes to material groups
         for( const auto& vp : volume2mat )
         {
             int vol_no = vp.first;
             int mat_no = vp.second;
             auto v_it  = volume_map.find( vol_no );
             auto m_it  = mat_groups.find( mat_no );
  
             if( v_it == volume_map.end() || m_it == mat_groups.end() )
             {
                 std::cerr << "Missing handle while adding volume " << vol_no << " to material " << mat_no << std::endl;
                 return MB_FAILURE;
             }
             EntityHandle vol_h = v_it->second;
             EntityHandle grp_h = m_it->second;
  
             rval = MBI->add_entities( grp_h, &vol_h, 1 );MB_CHK_ERR( rval );
         }
     }
  
     return rval;
 }

References moab::Interface::add_entities(), cell_flag_datas, cell_flag_idx, cell_flag_indexes, create_group(), create_material_group(), ErrorCode, get_material_ref_flag(), get_volume_ref_flag(), MB_CHK_ERR, and MBI.

Referenced by generate_topology().

◆ side_process_faces()

ErrorCode ReadRTT::side_process_faces	(	rtt_flags	side_flags,
		std::vector< side > &	side_data
	)

private

Process the FACES flag from the side_flags section

Parameters

side_flags,a	vector containing all the read side data
side_data,a	vector containing all the read side data

Returns: moab::ErrorCode

Definition at line 497 of file ReadRTT.cpp.

 {
     if( side_flags.find( "FACES" ) != side_flags.end() )
     {
         for( size_t i = 0; i < side_flags["FACES"].size(); i++ )
         {
             side data = ReadRTT::get_side_data( side_flags["FACES"][i] );
             side_data.push_back( data );
         }
     }
     if( side_data.size() == 0 ) return MB_FAILURE;
     return MB_SUCCESS;
 }

References get_side_data(), MB_SUCCESS, and side_data.

Referenced by read_side_flags().

◆ split_name()

ReadRTT::boundary ReadRTT::split_name ( std::string atilla_cellname )

private

Splits an Attila cellname and populates a boundary structure

Parameters

attila_cellname,string containing the boundary information

Returns: a boundary object

Definition at line 1144 of file ReadRTT.cpp.

 {
     boundary new_boundary;
     // default initialisation
     new_boundary.sense = 0;
     new_boundary.name  = "\0";
     // +ve sense
     if( atilla_cellname.find( "+" ) != std::string::npos )
     {
         new_boundary.sense = 1;
         // look for the @# we do not want it
         std::size_t found = atilla_cellname.find( "@" );
         if( found != std::string::npos )
             new_boundary.name = atilla_cellname.substr( 3, found );
         else
             new_boundary.name = atilla_cellname.substr( 3, atilla_cellname.length() );
     }
     else if( atilla_cellname.find( "-" ) != std::string::npos )
     {
         // negative sense
         new_boundary.sense = -1;
         new_boundary.name  = atilla_cellname.substr( 3, atilla_cellname.length() );
     }
     return new_boundary;
 }

References moab::ReadRTT::boundary::name, and moab::ReadRTT::boundary::sense.

Referenced by get_side_data().

◆ split_string()

std::vector< std::string > ReadRTT::split_string	(	std::string	string_to_split,
		char	split_char
	)

private

Splits a string into a vector of substrings delimited by split_char

Parameters

string_to_split,the	string that needs splitting into chunks
split_char,the	character to split the string with

Returns: a vector of strings that are delimited by split_char

Definition at line 1173 of file ReadRTT.cpp.

 {
     std::istringstream ss( string_to_split );
     std::vector< std::string > tokens;
     while( !ss.eof() )
     {
         std::string x;                      // here's a nice, empty string
         std::getline( ss, x, split_char );  // try to read the next field into it
         tokens.push_back( x );
     }
  
     // remove empty tokens
     std::vector< std::string >::iterator it;
     for( it = tokens.begin(); it != tokens.end(); )
     {
         std::string string = *it;
         if( string.compare( "\0" ) == 0 )
             it = tokens.erase( it );
         else
             ++it;
     }
     return tokens;
 }

Referenced by get_cell_data(), get_facet_data(), get_header_data(), get_node_data(), get_side_data(), get_tet_data(), parse_dims(), read_all_flags(), and read_cell_defs().

Member Data Documentation

◆ category_tag

Tag moab::ReadRTT::category_tag

private

Definition at line 678 of file ReadRTT.hpp.

Referenced by create_group(), create_material_group(), generate_topology(), and ReadRTT().

◆ cell_data

std::vector< cell > moab::ReadRTT::cell_data

private

Definition at line 667 of file ReadRTT.hpp.

Referenced by cell_process_flag(), generate_parent_child_links(), generate_topology(), get_max_name_size(), load_file(), read_cell_flags(), and set_surface_senses().

◆ cell_data_idx

std::map< int, int > moab::ReadRTT::cell_data_idx

private

Definition at line 668 of file ReadRTT.hpp.

Referenced by cell_process_flag(), and read_cell_flags().

◆ cell_def_data

std::map< int, cell_def > moab::ReadRTT::cell_def_data

private

Definition at line 666 of file ReadRTT.hpp.

Referenced by get_tet_data(), and read_cell_defs().

◆ cell_flag_datas

rtt_flags_data moab::ReadRTT::cell_flag_datas

private

Definition at line 655 of file ReadRTT.hpp.

Referenced by cell_process_flag(), get_material_ref_flag(), get_volume_ref_flag(), read_cell_flags(), and setup_group_data().

◆ cell_flag_idx

std::map< std::string, int > moab::ReadRTT::cell_flag_idx

private

Definition at line 658 of file ReadRTT.hpp.

Referenced by build_moab(), read_cell_flags(), and setup_group_data().

◆ cell_flag_indexes

std::map< std::string, std::map< int, int > > moab::ReadRTT::cell_flag_indexes

private

Definition at line 657 of file ReadRTT.hpp.

Referenced by cell_process_flag(), read_cell_flags(), and setup_group_data().

◆ dim_data

dimData moab::ReadRTT::dim_data

private

Definition at line 652 of file ReadRTT.hpp.

Referenced by get_facet_data(), get_tet_data(), parse_dims(), read_cell_flags(), and read_side_flags().

◆ faceting_tol_tag

Tag moab::ReadRTT::faceting_tol_tag

private

Definition at line 678 of file ReadRTT.hpp.

Referenced by ReadRTT().

◆ geom_tag

Tag moab::ReadRTT::geom_tag

private

Definition at line 678 of file ReadRTT.hpp.

Referenced by create_material_group(), generate_topology(), and ReadRTT().

◆ header_data

headerData moab::ReadRTT::header_data

private

Definition at line 651 of file ReadRTT.hpp.

Referenced by add_metadata(), get_facet_data(), get_header_data(), and get_tet_data().

◆ id_tag

Tag moab::ReadRTT::id_tag

private

Definition at line 678 of file ReadRTT.hpp.

Referenced by create_group(), create_material_group(), generate_topology(), and ReadRTT().

◆ MBI

Interface* moab::ReadRTT::MBI

private

Definition at line 674 of file ReadRTT.hpp.

Referenced by add_metadata(), build_moab(), create_facets(), create_group(), create_material_group(), generate_parent_child_links(), generate_topology(), ReadRTT(), setup_group_data(), and ~ReadRTT().

◆ myGeomTool

GeomTopoTool* moab::ReadRTT::myGeomTool

private

Definition at line 676 of file ReadRTT.hpp.

Referenced by ReadRTT(), set_surface_senses(), and ~ReadRTT().

◆ name_tag

Tag moab::ReadRTT::name_tag

private

Definition at line 678 of file ReadRTT.hpp.

Referenced by create_group(), create_material_group(), and ReadRTT().

◆ readMeshIface

ReadUtilIface* moab::ReadRTT::readMeshIface

private

Definition at line 672 of file ReadRTT.hpp.

Referenced by ReadRTT(), and ~ReadRTT().

◆ side_data

std::vector< side > moab::ReadRTT::side_data

private

Definition at line 670 of file ReadRTT.hpp.

Referenced by generate_parent_child_links(), generate_topology(), load_file(), read_side_flags(), set_surface_senses(), and side_process_faces().

◆ side_flag_datas

rtt_flags_data moab::ReadRTT::side_flag_datas

private

Definition at line 661 of file ReadRTT.hpp.

◆ side_flag_idx

std::map< std::string, int > moab::ReadRTT::side_flag_idx

private

Definition at line 663 of file ReadRTT.hpp.

Referenced by read_side_flags().

◆ side_flag_indexes

std::map< std::string, std::map< int, int > > moab::ReadRTT::side_flag_indexes

private

Definition at line 662 of file ReadRTT.hpp.

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

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ rtt_flags

◆ rtt_flags_data

Constructor & Destructor Documentation

◆ ReadRTT()

◆ ~ReadRTT()

Member Function Documentation

◆ add_metadata()

◆ build_moab()

◆ cell_process_flag()

◆ count_sides()

◆ create_facets()

◆ create_group()

◆ create_material_group()

◆ factory()

◆ generate_parent_child_links()

◆ generate_topology()

◆ get_cell_data()

◆ get_facet_data()

◆ get_header_data()

◆ get_material_ref_flag()

◆ get_max_name_size()

◆ get_node_data()

◆ get_side_data()

◆ get_tet_data()

◆ get_volume_ref_flag()

◆ load_file()

◆ parse_dims()

◆ read_all_flags()

◆ read_cell_defs()

◆ read_cell_flags()

◆ read_facets()

◆ read_header()

◆ read_nodes()

◆ read_side_flags()

◆ read_tag_values()

◆ read_tets()

◆ set_surface_senses()

◆ setup_group_data()

◆ side_process_faces()

◆ split_name()

◆ split_string()

Member Data Documentation

◆ category_tag

◆ cell_data

◆ cell_data_idx

◆ cell_def_data

◆ cell_flag_datas

◆ cell_flag_idx

◆ cell_flag_indexes

◆ dim_data

◆ faceting_tol_tag

◆ geom_tag

◆ header_data

◆ id_tag

◆ MBI

◆ myGeomTool

◆ name_tag

◆ readMeshIface

◆ side_data

◆ side_flag_datas

◆ side_flag_idx

◆ side_flag_indexes