kd_tree_tool.cpp File Reference

#include "moab/Core.hpp"
#include "moab/CartVect.hpp"
#include "moab/AdaptiveKDTree.hpp"
#include "moab/GeomUtil.hpp"
#include "Internals.hpp"
#include "moab/Range.hpp"
#include "moab/FileOptions.hpp"
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <limits>
#include <sstream>
#include <cstdlib>
#include <ctime>
#include <unistd.h>
#include <sys/stat.h>
#include <fcntl.h>

Include dependency graph for kd_tree_tool.cpp:

Go to the source code of this file.

Functions
std::string	clock_to_string (clock_t t)
std::string	mem_to_string (unsigned long mem)
void	build_tree (Interface *interface, const Range &elems, FileOptions &opts)
void	build_grid (Interface *iface, const double dims[3])
void	delete_existing_tree (Interface *interface)
void	print_stats (Interface *interface)
void	tag_elements (Interface *interface)
void	tag_vertices (Interface *interface)
void	write_tree_blocks (Interface *interface, const char *file)
static void	usage (bool err=true)
static int	parseint (int &i, int argc, char *argv[])
static void	parsedims (int &i, int argc, char *argv[], double dims[3])
int	main (int argc, char *argv[])
static int	hash_handle (EntityHandle handle)

Variables
const int	MAX_TAG_VALUE = 32
const char *	TAG_NAME = "TREE_CELL"

Function Documentation

build_grid()

void build_grid	(	Interface *	iface,
		const double	dims[3]
	)

Definition at line 386 of file kd_tree_tool.cpp.

{
 ErrorCode rval;
 EntityHandle root = 0;
 AdaptiveKDTree tool( interface );
 AdaptiveKDTreeIter iter;
 AdaptiveKDTree::Plane plane;
 
 double min[3] = { -0.5 * dims[0], -0.5 * dims[1], -0.5 * dims[2] };
 double max[3] = { 0.5 * dims[0], 0.5 * dims[1], 0.5 * dims[2] };
 rval = tool.create_root( min, max, root );
 if( MB_SUCCESS != rval || !root )
 {
 std::cerr << "Failed to create tree root." << std::endl;
 exit( 4 );
 }
 
 rval = tool.get_tree_iterator( root, iter );
 if( MB_SUCCESS != rval )
 {
 std::cerr << "Failed to get tree iterator." << std::endl;
 }
 
 do
 {
 while( iter.depth() < tool.get_max_depth() )
 {
 plane.norm = iter.depth() % 3;
 plane.coord = 0.5 * ( iter.box_min()[plane.norm] + iter.box_max()[plane.norm] );
 rval = tool.split_leaf( iter, plane );
 if( MB_SUCCESS != rval )
 {
 std::cerr << "Failed to split tree leaf at depth " << iter.depth() << std::endl;
 exit( 4 );
 }
 }
 } while( ( rval = iter.step() ) == MB_SUCCESS );
 
 if( rval != MB_ENTITY_NOT_FOUND )
 {
 std::cerr << "Error stepping KDTree iterator." << std::endl;
 exit( 4 );
 }
}

References moab::AdaptiveKDTreeIter::box_max(), moab::AdaptiveKDTreeIter::box_min(), moab::AdaptiveKDTree::Plane::coord, moab::Tree::create_root(), moab::AdaptiveKDTreeIter::depth(), ErrorCode, moab::Tree::get_max_depth(), moab::AdaptiveKDTree::get_tree_iterator(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, moab::AdaptiveKDTree::Plane::norm, moab::AdaptiveKDTree::split_leaf(), and moab::AdaptiveKDTreeIter::step().

Referenced by main().

build_tree()

void build_tree	(	Interface *	interface,
		const Range &	elems,
		FileOptions &	opts
	)

Definition at line 373 of file kd_tree_tool.cpp.

{
 EntityHandle root = 0;
 
 if( elems.empty() )
 {
 std::cerr << "No elements from which to build tree." << std::endl;
 exit( 4 );
 }
 
 AdaptiveKDTree tool( interface, elems, &root, &opts );
}

References moab::Range::empty().

Referenced by main().

clock_to_string()

std::string clock_to_string

(

clock_t

t

)

Definition at line 431 of file kd_tree_tool.cpp.

{
 char unit[5] = "s";
 char buffer[256];
 double dt = t / (double)CLOCKS_PER_SEC;
 // if (dt > 300) {
 // dt /= 60;
 // strcpy( unit, "min" );
 //}
 // if (dt > 300) {
 // dt /= 60;
 // strcpy( unit, "hr" );
 //}
 // if (dt > 100) {
 // dt /= 24;
 // strcpy( unit, "days" );
 //}
 sprintf( buffer, "%0.2f%s", dt, unit );
 return buffer;
}

References buffer, t, and moab::unit().

Referenced by main().

delete_existing_tree()

void delete_existing_tree

(

Interface *

interface

)

Definition at line 354 of file kd_tree_tool.cpp.

{
 Range trees;
 AdaptiveKDTree tool( interface );
 
 tool.find_all_trees( trees );
 if( !trees.empty() ) std::cout << "Destroying existing tree(s) contained in file" << std::endl;
 for( Range::iterator i = trees.begin(); i != trees.end(); ++i )
 tool.reset_tree();
 
 trees.clear();
 tool.find_all_trees( trees );
 if( !trees.empty() )
 {
 std::cerr << "Failed to destroy existing trees. Aborting" << std::endl;
 exit( 5 );
 }
}

References moab::Range::begin(), moab::Range::clear(), moab::Range::empty(), moab::Range::end(), moab::Tree::find_all_trees(), and moab::AdaptiveKDTree::reset_tree().

Referenced by main().

hash_handle()

static int hash_handle ( EntityHandle  handle )

static

Definition at line 452 of file kd_tree_tool.cpp.

{
 EntityID h = ID_FROM_HANDLE( handle );
 return (int)( ( h * 13 + 7 ) % MAX_TAG_VALUE ) + 1;
}

References moab::ID_FROM_HANDLE(), and MAX_TAG_VALUE.

Referenced by tag_elements(), tag_vertices(), and write_tree_blocks().

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 155 of file kd_tree_tool.cpp.

{
 bool surf_elems = false, vol_elems = false;
 const char* input_file = 0;
 const char* output_file = 0;
 const char* tree_file = 0;
 std::ostringstream options;
 bool tag_elems = false;
 clock_t load_time, build_time, stat_time, tag_time, write_time, block_time;
 bool make_grid = false;
 double dims[3];
 
 for( int i = 1; i < argc; ++i )
 {
 if( argv[i][0] != '-' )
 {
 if( !input_file )
 input_file = argv[i];
 else if( !output_file )
 output_file = argv[i];
 else
 usage();
 continue;
 }
 
 if( !argv[i][1] || argv[i][2] ) usage();
 
 switch( argv[i][1] )
 {
 case '2':
 surf_elems = true;
 break;
 case '3':
 vol_elems = true;
 break;
 case 'S':
 options << "MESHSET_FLAGS=" << MESHSET_ORDERED << ";";
 break;
 case 's':
 break;
 case 'd':
 options << "MAX_DEPTH=" << parseint( i, argc, argv ) << ";";
 break;
 case 'n':
 options << "MAX_PER_LEAF=" << parseint( i, argc, argv ) << ";";
 break;
 case 'u':
 options << "CANDIDATE_PLANE_SET=" << AdaptiveKDTree::SUBDIVISION << ";";
 break;
 case 'p':
 options << "CANDIDATE_PLANE_SET=" << AdaptiveKDTree::SUBDIVISION_SNAP << ";";
 break;
 case 'm':
 options << "CANDIDATE_PLANE_SET=" << AdaptiveKDTree::VERTEX_MEDIAN << ";";
 break;
 case 'v':
 options << "CANDIDATE_PLANE_SET=" << AdaptiveKDTree::VERTEX_SAMPLE << ";";
 break;
 case 'N':
 options << "SPLITS_PER_DIR=" << parseint( i, argc, argv ) << ";";
 break;
 case 't':
 tag_elems = true;
 break;
 case 'T':
 tree_file = argv[++i];
 break;
 case 'G':
 make_grid = true;
 parsedims( i, argc, argv, dims );
 break;
 case 'h':
 usage( false );
 break;
 default:
 usage();
 }
 }
 
 // this test relies on not cleaning up trees
 options << "CLEAN_UP=false;";
 
 if( make_grid != !output_file ) usage();
 
 // default to both
 if( !surf_elems && !vol_elems ) surf_elems = vol_elems = true;
 
 ErrorCode rval;
 Core moab_core;
 Interface* interface = &moab_core;
 FileOptions opts( options.str().c_str() );
 
 if( make_grid )
 {
 load_time = 0;
 output_file = input_file;
 input_file = 0;
 build_time = clock();
 build_grid( interface, dims );
 build_time = clock() - build_time;
 }
 else
 {
 load_time = clock();
 rval = interface->load_mesh( input_file );
 if( MB_SUCCESS != rval )
 {
 std::cerr << "Error reading file: " << input_file << std::endl;
 exit( 2 );
 }
 load_time = clock() - load_time;
 
 delete_existing_tree( interface );
 
 std::cout << "Building tree..." << std::endl;
 build_time = clock();
 Range elems;
 if( !surf_elems )
 {
 interface->get_entities_by_dimension( 0, 3, elems );
 }
 else
 {
 interface->get_entities_by_dimension( 0, 2, elems );
 if( vol_elems )
 {
 Range tmp;
 interface->get_entities_by_dimension( 0, 3, tmp );
 elems.merge( tmp );
 }
 }
 
 build_tree( interface, elems, opts );
 build_time = clock() - build_time;
 }
 
 std::cout << "Calculating stats..." << std::endl;
 AdaptiveKDTree tool( interface );
 Range range;
 tool.find_all_trees( range );
 if( range.size() != 1 )
 {
 if( range.empty() )
 std::cerr << "Internal error: Failed to retreive tree." << std::endl;
 else
 std::cerr << "Internal error: Multiple tree roots." << std::endl;
 exit( 5 );
 }
 tool.print();
 
 stat_time = clock() - build_time;
 
 if( tag_elems )
 {
 std::cout << "Tagging tree..." << std::endl;
 tag_elements( interface );
 tag_vertices( interface );
 }
 tag_time = clock() - stat_time;
 
 std::cout << "Writing file... ";
 std::cout.flush();
 rval = interface->write_mesh( output_file );
 if( MB_SUCCESS != rval )
 {
 std::cerr << "Error writing file: " << output_file << std::endl;
 exit( 3 );
 }
 write_time = clock() - tag_time;
 std::cout << "Wrote " << output_file << std::endl;
 
 if( tree_file )
 {
 std::cout << "Writing tree block rep...";
 std::cout.flush();
 write_tree_blocks( interface, tree_file );
 std::cout << "Wrote " << tree_file << std::endl;
 }
 block_time = clock() - write_time;
 
 std::cout << "Times: "
 << " Load"
 << " Build"
 << " Stats"
 << " Write";
 if( tag_elems ) std::cout << "Tag Sets";
 if( tree_file ) std::cout << "Block ";
 std::cout << std::endl;
 
 std::cout << " " << std::setw( 8 ) << clock_to_string( load_time ) << std::setw( 8 )
 << clock_to_string( build_time ) << std::setw( 8 ) << clock_to_string( stat_time ) << std::setw( 8 )
 << clock_to_string( write_time );
 if( tag_elems ) std::cout << std::setw( 8 ) << clock_to_string( tag_time );
 if( tree_file ) std::cout << std::setw( 8 ) << clock_to_string( block_time );
 std::cout << std::endl;
 
 return 0;
}

References build_grid(), build_time, build_tree(), clock_to_string(), delete_existing_tree(), moab::Range::empty(), ErrorCode, moab::Tree::find_all_trees(), input_file, load_time, MB_SUCCESS, moab::Range::merge(), parsedims(), parseint(), moab::AdaptiveKDTree::print(), moab::Range::size(), moab::AdaptiveKDTree::SUBDIVISION, moab::AdaptiveKDTree::SUBDIVISION_SNAP, tag_elements(), tag_time(), tag_vertices(), usage(), moab::AdaptiveKDTree::VERTEX_MEDIAN, moab::AdaptiveKDTree::VERTEX_SAMPLE, and write_tree_blocks().

mem_to_string()

std::string mem_to_string

(

unsigned long

mem

)

Definition at line 360 of file obb_tree_tool.cpp.

{
 char unit[3] = "B";
 if( mem > 9 * 1024 )
 {
 mem = ( mem + 512 ) / 1024;
 strcpy( unit, "kB" );
 }
 if( mem > 9 * 1024 )
 {
 mem = ( mem + 512 ) / 1024;
 strcpy( unit, "MB" );
 }
 if( mem > 9 * 1024 )
 {
 mem = ( mem + 512 ) / 1024;
 strcpy( unit, "GB" );
 }
 char buffer[256];
 sprintf( buffer, "%lu %s", mem, unit );
 return buffer;
}

References buffer, and moab::unit().

Referenced by print_stats().

parsedims()

static void parsedims ( int &  i, int  argc, char *  argv[], double  dims[3]  )

static

Definition at line 116 of file kd_tree_tool.cpp.

{
 char* end;
 ++i;
 if( i == argc )
 {
 std::cerr << "Expected value following '" << argv[i - 1] << "'" << std::endl;
 usage();
 }
 
 dims[0] = strtod( argv[i], &end );
 if( *end == '\0' )
 {
 dims[2] = dims[1] = dims[0];
 return;
 }
 else if( *end != 'x' && *end != 'X' )
 goto error;
 
 ++end;
 dims[1] = strtod( end, &end );
 if( *end == '\0' )
 {
 dims[2] = dims[1];
 return;
 }
 else if( *end != 'x' && *end != 'X' )
 goto error;
 
 ++end;
 dims[2] = strtod( end, &end );
 if( *end != '\0' ) goto error;
 
 return;
error:
 std::cerr << "Invaild dimension specification." << std::endl;
 usage();
}

References moab::error(), and usage().

Referenced by main().

parseint()

static int parseint ( int &  i, int  argc, char *  argv[]  )

static

Definition at line 96 of file kd_tree_tool.cpp.

{
 char* end;
 ++i;
 if( i == argc )
 {
 std::cerr << "Expected value following '" << argv[i - 1] << "'" << std::endl;
 usage();
 }
 
 int result = strtol( argv[i], &end, 0 );
 if( result < 0 || *end )
 {
 std::cerr << "Expected positive integer following '" << argv[i - 1] << "'" << std::endl;
 usage();
 }
 
 return result;
}

References usage().

Referenced by main().

print_stats()

void print_stats

(

Interface *

interface

)

Definition at line 410 of file obb_tree_tool.cpp.

{
 EntityHandle root;
 Range range;
 ErrorCode rval;
 rval = get_root( interface, root );
 if( MB_SUCCESS != rval )
 {
 std::cerr << "Internal error: Failed to retrieve root." << std::endl;
 exit( 5 );
 }
 OrientedBoxTreeTool tool( interface );
 
 Range tree_sets, triangles, verts;
 // interface->get_child_meshsets( root, tree_sets, 0 );
 interface->get_entities_by_type( 0, MBENTITYSET, tree_sets );
 tree_sets.erase( tree_sets.begin(), Range::lower_bound( tree_sets.begin(), tree_sets.end(), root ) );
 interface->get_entities_by_type( 0, MBTRI, triangles );
 interface->get_entities_by_type( 0, MBVERTEX, verts );
 triangles.merge( verts );
 tree_sets.insert( root );
 unsigned long long set_used, set_amortized, set_store_used, set_store_amortized, set_tag_used, set_tag_amortized,
 tri_used, tri_amortized;
 interface->estimated_memory_use( tree_sets, &set_used, &set_amortized, &set_store_used, &set_store_amortized, 0, 0,
 0, 0, &set_tag_used, &set_tag_amortized );
 interface->estimated_memory_use( triangles, &tri_used, &tri_amortized );
 
 int num_tri = 0;
 interface->get_number_entities_by_type( 0, MBTRI, num_tri );
 
 tool.stats( root, std::cout );
 
 unsigned long long real_rss, real_vsize;
 memory_use( real_vsize, real_rss );
 
 printf( "------------------------------------------------------------------\n" );
 printf( "\nmemory: used amortized\n" );
 printf( " ---------- ----------\n" );
 printf( "triangles %10s %10s\n", mem_to_string( tri_used ).c_str(), mem_to_string( tri_amortized ).c_str() );
 printf( "sets (total)%10s %10s\n", mem_to_string( set_used ).c_str(), mem_to_string( set_amortized ).c_str() );
 printf( "sets %10s %10s\n", mem_to_string( set_store_used ).c_str(),
 mem_to_string( set_store_amortized ).c_str() );
 printf( "set tags %10s %10s\n", mem_to_string( set_tag_used ).c_str(),
 mem_to_string( set_tag_amortized ).c_str() );
 printf( "total real %10s %10s\n", mem_to_string( real_rss ).c_str(), mem_to_string( real_vsize ).c_str() );
 printf( "------------------------------------------------------------------\n" );
}

References moab::Range::begin(), moab::Range::end(), moab::Range::erase(), ErrorCode, moab::Interface::estimated_memory_use(), moab::Interface::get_entities_by_type(), moab::Interface::get_number_entities_by_type(), get_root(), moab::Range::insert(), MB_SUCCESS, MBENTITYSET, MBTRI, MBVERTEX, mem_to_string(), memory_use(), moab::Range::merge(), and moab::OrientedBoxTreeTool::stats().

Referenced by main().

tag_elements()

void tag_elements

(

Interface *

interface

)

Definition at line 458 of file kd_tree_tool.cpp.

{
 EntityHandle root;
 Range range;
 AdaptiveKDTree tool( moab );
 
 tool.find_all_trees( range );
 if( range.size() != 1 )
 {
 if( range.empty() )
 std::cerr << "Internal error: Failed to retreive tree." << std::endl;
 else
 std::cerr << "Internal error: Multiple tree roots." << std::endl;
 exit( 5 );
 }
 
 root = *range.begin();
 range.clear();
 
 Tag tag;
 int zero = 0;
 moab->tag_get_handle( TAG_NAME, 1, MB_TYPE_INTEGER, tag, MB_TAG_DENSE | MB_TAG_CREAT, &zero );
 
 AdaptiveKDTreeIter iter;
 tool.get_tree_iterator( root, iter );
 
 std::vector< int > tag_vals;
 do
 {
 range.clear();
 moab->get_entities_by_handle( iter.handle(), range );
 tag_vals.clear();
 tag_vals.resize( range.size(), hash_handle( iter.handle() ) );
 moab->tag_set_data( tag, range, &tag_vals[0] );
 } while( MB_SUCCESS == iter.step() );
}

References moab::Range::begin(), moab::Range::clear(), moab::Range::empty(), moab::Tree::find_all_trees(), moab::AdaptiveKDTree::get_tree_iterator(), moab::AdaptiveKDTreeIter::handle(), hash_handle(), MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_INTEGER, moab::Range::size(), moab::AdaptiveKDTreeIter::step(), and TAG_NAME.

Referenced by main().

tag_vertices()

void tag_vertices

(

Interface *

interface

)

Definition at line 495 of file kd_tree_tool.cpp.

{
 EntityHandle root;
 Range range;
 AdaptiveKDTree tool( moab );
 
 tool.find_all_trees( range );
 if( range.size() != 1 )
 {
 if( range.empty() )
 std::cerr << "Internal error: Failed to retreive tree." << std::endl;
 else
 std::cerr << "Internal error: Multiple tree roots." << std::endl;
 exit( 5 );
 }
 
 root = *range.begin();
 range.clear();
 
 Tag tag;
 int zero = 0;
 moab->tag_get_handle( TAG_NAME, 1, MB_TYPE_INTEGER, tag, MB_TAG_DENSE | MB_TAG_CREAT, &zero );
 
 AdaptiveKDTreeIter iter;
 tool.get_tree_iterator( root, iter );
 
 do
 {
 range.clear();
 moab->get_entities_by_handle( iter.handle(), range );
 
 int tag_val = hash_handle( iter.handle() );
 Range verts;
 moab->get_adjacencies( range, 0, false, verts, Interface::UNION );
 for( Range::iterator i = verts.begin(); i != verts.end(); ++i )
 {
 CartVect coords;
 moab->get_coords( &*i, 1, coords.array() );
 if( GeomUtil::box_point_overlap( CartVect( iter.box_min() ), CartVect( iter.box_max() ), coords, 1e-7 ) )
 moab->tag_set_data( tag, &*i, 1, &tag_val );
 }
 } while( MB_SUCCESS == iter.step() );
}

References moab::CartVect::array(), moab::Range::begin(), moab::AdaptiveKDTreeIter::box_max(), moab::AdaptiveKDTreeIter::box_min(), moab::GeomUtil::box_point_overlap(), moab::Range::clear(), moab::Range::empty(), moab::Range::end(), moab::Tree::find_all_trees(), moab::AdaptiveKDTree::get_tree_iterator(), moab::AdaptiveKDTreeIter::handle(), hash_handle(), MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_INTEGER, moab::Range::size(), moab::AdaptiveKDTreeIter::step(), TAG_NAME, and moab::Interface::UNION.

Referenced by main().

usage()

static void usage ( bool  err = true )

static

Definition at line 37 of file kd_tree_tool.cpp.

{
 std::ostream& s = err ? std::cerr : std::cout;
 s << "kd_tree_tool [-d <int>] [-2|-3] [-n <int>] [-u|-p|-m|-v] [-N <int>] [-s|-S] <input file> "
 "<output file>"
 << std::endl
 << "kd_tree_tool [-d <int>] -G <dims> [-s|-S] <output file>" << std::endl
 << "kd_tree_tool [-h]" << std::endl;
 if( !err )
 {
 s << "Tool to build adaptive kd-Tree" << std::endl;
 s << " -d <int> Specify maximum depth for tree. Default: 30" << std::endl
 << " -n <int> Specify maximum entities per leaf. Default: 6" << std::endl
 << " -2 Build tree from surface elements. Default: yes" << std::endl
 << " -3 Build tree from volume elements. Default: yes" << std::endl
 << " -u Use 'SUBDIVISION' scheme for tree construction" << std::endl
 << " -p Use 'SUBDIVISION_SNAP' tree construction algorithm." << std::endl
 << " -m Use 'VERTEX_MEDIAN' tree construction algorithm." << std::endl
 << " -v Use 'VERTEX_SAMPLE' tree construction algorithm." << std::endl
 << " -N <int> Specify candidate split planes per axis. Default: 3" << std::endl
 << " -t Tag elements will tree cell number." << std::endl
 << " -T Write tree boxes to file." << std::endl
 << " -G <dims> Generate grid - no input elements. Dims must be " << std::endl
 << " HxWxD or H." << std::endl
 << " -s Use range-based sets for tree nodes" << std::endl
 << " -S Use vector-based sets for tree nodes" << std::endl
 << std::endl;
 }
 exit( err );
}

Referenced by main(), parsedims(), and parseint().

write_tree_blocks()

void write_tree_blocks	(	Interface *	interface,
		const char *	file
	)

Definition at line 539 of file kd_tree_tool.cpp.

{
 EntityHandle root;
 Range range;
 AdaptiveKDTree tool( interface );
 
 tool.find_all_trees( range );
 if( range.size() != 1 )
 {
 if( range.empty() )
 std::cerr << "Internal error: Failed to retreive tree." << std::endl;
 else
 std::cerr << "Internal error: Multiple tree roots." << std::endl;
 exit( 5 );
 }
 
 root = *range.begin();
 range.clear();
 
 Core moab2;
 Tag tag;
 int zero = 0;
 moab2.tag_get_handle( TAG_NAME, 1, MB_TYPE_INTEGER, tag, MB_TAG_DENSE | MB_TAG_CREAT, &zero );
 
 AdaptiveKDTreeIter iter;
 tool.get_tree_iterator( root, iter );
 
 do
 {
 double x1 = iter.box_min()[0];
 double y1 = iter.box_min()[1];
 double z1 = iter.box_min()[2];
 double x2 = iter.box_max()[0];
 double y2 = iter.box_max()[1];
 double z2 = iter.box_max()[2];
 double coords[24] = { x1, y1, z1, x2, y1, z1, x2, y2, z1, x1, y2, z1,
 x1, y1, z2, x2, y1, z2, x2, y2, z2, x1, y2, z2 };
 EntityHandle verts[8], elem;
 for( int i = 0; i < 8; ++i )
 moab2.create_vertex( coords + 3 * i, verts[i] );
 moab2.create_element( MBHEX, verts, 8, elem );
 int tag_val = hash_handle( iter.handle() );
 moab2.tag_set_data( tag, &elem, 1, &tag_val );
 } while( MB_SUCCESS == iter.step() );
 
 moab2.write_mesh( file );
}

References moab::Range::begin(), moab::AdaptiveKDTreeIter::box_max(), moab::AdaptiveKDTreeIter::box_min(), moab::Range::clear(), moab::Core::create_element(), moab::Core::create_vertex(), moab::Range::empty(), moab::Tree::find_all_trees(), moab::AdaptiveKDTree::get_tree_iterator(), moab::AdaptiveKDTreeIter::handle(), hash_handle(), MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_INTEGER, MBHEX, moab::Range::size(), moab::AdaptiveKDTreeIter::step(), moab::Core::tag_get_handle(), TAG_NAME, moab::Core::tag_set_data(), and moab::Core::write_mesh().

Referenced by main().

Variable Documentation

MAX_TAG_VALUE

const int MAX_TAG_VALUE = 32

Definition at line 23 of file kd_tree_tool.cpp.

Referenced by hash_handle().

TAG_NAME

const char* TAG_NAME = "TREE_CELL"

Definition at line 24 of file kd_tree_tool.cpp.

Referenced by tag_elements(), tag_vertices(), and write_tree_blocks().