moab
|
#include <iostream>
#include <vector>
#include <cstdlib>
#include "parse.hpp"
#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include "moab/Interface.hpp"
#include "Internals.hpp"
Go to the source code of this file.
Defines | |
#define | IS_BUILDING_MB |
#define | CALL(A, B) |
Functions | |
static void | usage (bool error=true) |
static void | about (bool error=true) |
static void | parse_error (const char *msg, const char *val=0) |
int | main (int argc, char *argv[]) |
Variables | |
Interface * | iface = 0 |
const char * | exe_name = 0 |
#define CALL | ( | A, | |
B | |||
) |
do { ErrorCode _r = iface->A B ; \ if (MB_SUCCESS != _r) { \ std::cerr << #A << #B << " failed at " << __FILE__ << ":" << __LINE__ << std::endl; \ exit( 5 ); }\ } \ while (false)
Definition at line 41 of file propagate_tags.cpp.
#define IS_BUILDING_MB |
Definition at line 35 of file propagate_tags.cpp.
static void about | ( | bool | error = true | ) | [static] |
Definition at line 117 of file propagate_tags.cpp.
int main | ( | int | argc, |
char * | argv[] | ||
) |
Definition at line 136 of file propagate_tags.cpp.
{ Core mb_core; exe_name = argv[0]; iface = &mb_core; if (argc == 1) about(); // find file names // load input file before processing other options so // tags are defined const char* input_name = 0; const char* output_name = 0; for (int i = 1; i < argc; ++i) { if (argv[i][0] == '-') { switch (argv[i][1]) { case 't': case 'c': case 'd': case 'w': ++i; case 'n': case 'e': case 'E': break; case 'h': usage(false); break; default: parse_error( "Invalid option", argv[i] ); break; } } else if (!input_name) input_name = argv[i]; else if (!output_name) output_name = argv[i]; else parse_error( "Unexpected argument", argv[i] ); } if (!input_name) parse_error( "No input file specified." ); if (!output_name) parse_error( "No output file specified." ); // Read the input file if (MB_SUCCESS != iface->load_mesh( input_name )) { std::cerr << "Failed to read file: " << input_name << std::endl; std::string message; if (MB_SUCCESS == iface->get_last_error(message)) std::cerr << message << std::endl; return 2; } bool nodes_spec = false; bool elems_spec = false; bool node_from_elem_spec = false; bool have_data_tag = false; const char* write_tag_name = 0; Tag write_tag = 0; TagSpec data_tag = { 0, 0 }; typedef std::vector<TagSpec> TagVect; TagVect ident_tags; int data_size = 0; for (int i = 1; i < argc; ++i) { if (argv[i] == input_name || argv[i] == output_name) continue; else if (!strcmp(argv[i],"-n")) nodes_spec = true; else if (!strcmp(argv[i], "-e")) elems_spec = true; else if (!strcmp(argv[i], "-E")) { node_from_elem_spec = true; elems_spec = true; nodes_spec = false; } else if (!argv[i][0]) usage(); else { char flag = argv[i][1]; if ((flag != 't' && flag != 'd' && flag != 'w' && flag != 'c') || argv[i][2]) parse_error( "Invalid argument", argv[i] ); ++i; if (i == argc) parse_error( "Expected tag spec following option", argv[i-1] ); if (flag == 'w') { if (write_tag_name) parse_error( "Invalid argument", argv[i] ); write_tag_name = argv[i]; } else if (flag == 'c') { TagSpec spec; if (parse_tag_create( argv[i], spec, iface )) parse_error( "Failed to parse tag spec", argv[i] ); if (have_data_tag) parse_error( "Invalid argument", argv[i] ); data_tag = spec; have_data_tag = true; } else { TagSpec spec; if (parse_tag_spec( argv[i], spec, iface)) parse_error("Failed to parse tag spec", argv[i] ); if (flag == 'd') { if (have_data_tag) parse_error( "Invalid argument", argv[i] ); data_tag = spec; have_data_tag = true; } else { ident_tags.push_back( spec ); } } } } // for(args) // if neither, default to both if (!nodes_spec && !elems_spec) nodes_spec = elems_spec = true; // must have at least one identifying tag if (ident_tags.empty()) parse_error ("At least one identifying tag must be specified."); // If data tag wasn't specified, use identifying tag for data if (!have_data_tag) { if (ident_tags.size() > 1) parse_error ("No data tag specified."); data_tag.value = 0; data_tag.handle = ident_tags[0].handle; } CALL( tag_get_bytes, (data_tag.handle, data_size) ); // If write dat wasn't specified, use data tag if (!write_tag_name) { write_tag = data_tag.handle; } // If write tag was specified, if it exists its type // msut match that of the data tag. If it doesn't exist, // create it. else { DataType data_type; CALL( tag_get_data_type, (data_tag.handle, data_type) ); CALL( tag_get_handle, (write_tag_name, data_size, data_type, write_tag, MB_TAG_SPARSE|MB_TAG_BYTES|MB_TAG_CREAT) ); } /**************** Done processing input -- do actual work ****************/ // Get list of sets with identifying tags Range sets, temp; for (TagVect::iterator i = ident_tags.begin(); i != ident_tags.end(); ++i) { const void* value[] = { i->value }; CALL( get_entities_by_type_and_tag, (0, MBENTITYSET, &i->handle, i->value ? value : 0, 1, temp) ); sets.merge( temp ); } // For each set, set tag on contained entities std::vector<unsigned char> tag_data(data_size); for (Range::iterator i = sets.begin(); i != sets.end(); ++i) { // Get tag value ErrorCode rval = iface->tag_get_data( data_tag.handle, &*i, 1, &tag_data[0] ); if (MB_TAG_NOT_FOUND == rval) { if (!data_tag.value) { std::cerr << "Data tag not set for entityset " << iface->id_from_handle(*i) << std::endl; continue; } memcpy( &tag_data[0], data_tag.value, data_size ); } else if (MB_SUCCESS != rval) { CALL( tag_get_data, (data_tag.handle, &*i, 1, &tag_data[0]) ); } // Get entities Range entities; CALL( get_entities_by_handle, (*i, entities, true) ); int junk; Range::iterator eb = entities.lower_bound( entities.begin(), entities.end(), CREATE_HANDLE(MBEDGE,0,junk) ); if (elems_spec) for (Range::iterator j = eb; j != entities.end(); ++j) CALL( tag_set_data, (write_tag, &*j, 1, &tag_data[0]) ); if (nodes_spec) for (Range::iterator j = entities.begin(); j != eb; ++j) CALL( tag_set_data, (write_tag, &*j, 1, &tag_data[0]) ); if (node_from_elem_spec) { Range elems; elems.merge( eb, entities.end() ); entities.clear(); CALL( get_adjacencies, (elems, 0, false, entities, Interface::UNION) ); for (Range::iterator j = entities.begin(); j != entities.end(); ++j) CALL( tag_set_data, (write_tag, &*j, 1, &tag_data[0]) ); } } // Write the output file if (MB_SUCCESS != iface->write_mesh( output_name )) { std::cerr << "Failed to write file: " << output_name << std::endl; std::string message; if (MB_SUCCESS == iface->get_last_error(message)) std::cerr << message << std::endl; return 2; } return 0; }
static void parse_error | ( | const char * | msg, |
const char * | val = 0 |
||
) | [static] |
Definition at line 126 of file propagate_tags.cpp.
{ std::cerr << msg; if (val) std::cerr << ": " << val; std::cerr << std::endl; std::cerr << "Try '" << exe_name << " -h' for help" << std::endl; exit(1); }
static void usage | ( | bool | error = true | ) | [static] |
Definition at line 53 of file propagate_tags.cpp.
{ std::ostream& s = error ? std::cerr : std::cout; s << "Usage: " << exe_name << " <options> <input_file> <output_file>" << std::endl << " " << exe_name << " -h" << std::endl << "Options: " << std::endl << " -t <ident_tag>[=<value>] " << std::endl << " -d <data_tag>[=<default>] " << std::endl << " -c <data_tag=type:size>[=defult] " << std::endl << " -w <write_tag> " << std::endl << " -n|-e|-E " << std::endl << std::endl; if (error) { s << "Try '-h' for verbose help." << std::endl; exit(1); } s << "This utility will write tag data to a subset of the mesh entities " << std::endl << "contained in a file. The behavior is controlled by three main " << std::endl << "properties:" << std::endl << " 1) The ident_tag is used to identify sets of entities for which " << std::endl << " data will be stored on each contained element or node. The -n " << std::endl << " or -e flags can be used to restrict operation to only nodes or " << std::endl << " elements, respectively." << std::endl << " 2) The data_tag is used to identify which value to write on to " << std::endl << " each entity. This is a tag on the set containing the entities." << std::endl << " 3) The write_tag is the name of the tag that the data is stored in " << std::endl << " on each mesh entity." << std::endl << std::endl << " -t : Specify an ident_tag. If a value is specified, only those " << std::endl << " sets with the specified value are processed. At least one " << std::endl << " ident_tag must be specified. Multiple ident_tags may be " << std::endl << " specified, in which case any set that matches any of the " << std::endl << " specified ident_tags will be processed (logical OR)." << std::endl << std::endl << " -d : Specify the data_tag. If multiple ident_tags are specified " << std::endl << " then the data_tag must be specified. If only one ident_tag " << std::endl << " is specified then the data_tag specification is optional." << std::endl << " If no data_tag is specified, the value of the ident_tag " << std::endl << " will be used. If a value is specified for the data_tag, " << std::endl << " then the specified value will be used for any set that " << std::endl << " doesn't have a value for the data_tag." << std::endl << std::endl << " -c : Similar to -d, except that the tag is created if it doesn't" << std::endl << " already exist. If the tag is created, then all entities" << std::endl << " receive the specified default value for the tag. In this " << std::endl << " case it is an error if no default value is specified." << std::endl << std::endl << " -w : Specify the tag to create and store values in on mesh " << std::endl << " entities. If no write_tag is specified, the data_tag " << std::endl << " will be used." << std::endl << std::endl << " -n : Write tag data only on nodes (vertices)." << std::endl << " -e : Write tag data only on elements." << std::endl << " -E : Tag value on each node is that of one of its adjacent elements." << std::endl << std::endl << "The syntax for specifying tag values is as follows: " << std::endl << std::endl; tag_syntax(s); s << std::endl; exit(0); }
const char* exe_name = 0 |
Definition at line 51 of file propagate_tags.cpp.
Definition at line 50 of file propagate_tags.cpp.