#include <RefinerTagManager.hpp>

Public Member Functions
	RefinerTagManager (Interface in_mesh, Interface out_mesh)
	Construct an evaluator.
virtual	~RefinerTagManager ()
	Destruction is virtual so subclasses may clean up after refinement.
void	reset_vertex_tags ()
	Clear the list of tag values that will appear past the vertex coordinates in p0, p1, and p2.
int	add_vertex_tag (Tag tag_handle)
int	get_vertex_tag_size () const
	Return the number of bytes to allocate for tag data per point.
int	get_number_of_vertex_tags () const
	Return the number of tags that will be output with each new vertex.
void	reset_element_tags ()
	Clear the list of tag values that will appear past the element coordinates in p0, p1, and p2.
int	add_element_tag (Tag tag_handle)
int	get_element_tag_size () const
	Return the number of bytes to allocate for tag data per point.
int	get_number_of_element_tags () const
	Return the number of tags that will be output with each new element.
void	create_output_tags ()
	Populate the list of output tags to match the list of input tags.
void	get_input_vertex_tag (int i, Tag &tag, int &byte_offset)
	Return the tag handle and its offset in the array of tag data of each vertex.
void	get_output_vertex_tag (int i, Tag &tag, int &byte_offset)
	Return the tag handle and its offset in the array of tag data of each vertex.
void	get_input_element_tag (int i, Tag &tag, int &byte_offset)
void	get_output_element_tag (int i, Tag &tag, int &byte_offset)
Interface *	get_input_mesh ()
Interface *	get_output_mesh ()
Tag	input_parallel_status ()
Tag	input_shared_proc ()
Tag	input_shared_procs ()
int	get_input_gids (int n, const EntityHandle *ents, std::vector< int > &gids)
	Retrieve the global ID of each input entity and push it onto the output vector.
int	get_output_gids (int n, const EntityHandle *ents, std::vector< int > &gids)
	Retrieve the global ID of each output entity and push it onto the output vector.
int	set_gid (EntityHandle ent, int gid)
	Assign a global ID to an output entity.
int	copy_gid (EntityHandle ent_input, EntityHandle ent_output)
	Copy a global ID from an entity of the input mesh to an entity of the output mesh.
void	set_sharing (EntityHandle ent_handle, ProcessSet &procs)
	Set parallel status and sharing process list on an entity.
void	get_common_processes (int num, const EntityHandle *src, ProcessSet &common_shared_procs, bool on_output_mesh=true)
	Determine the subset of processes which all share the specified entities.
void	set_element_tags_from_ent (EntityHandle ent_input)
void	assign_element_tags (EntityHandle ent_output)
void	set_element_procs_from_ent (EntityHandle ent_input)
ProcessSet &	get_element_procs ()
void	set_element_sharing (EntityHandle ent_output)
Protected Member Functions
void	create_tag_internal (Tag, int)
Protected Attributes
std::vector< std::pair< Tag, int > >	input_vertex_tags
std::vector< std::pair< Tag, int > >	output_vertex_tags
std::vector< std::pair< Tag, int > >	input_element_tags
std::vector< std::pair< Tag, int > >	output_element_tags
int	vertex_size
int	element_size
Interface *	input_mesh
Interface *	output_mesh
Tag	tag_ipstatus
Tag	tag_ipsprocs
Tag	tag_ipsproc
Tag	tag_ipshands
Tag	tag_ipshand
Tag	tag_igid
Tag	tag_opstatus
Tag	tag_opsprocs
Tag	tag_opsproc
Tag	tag_opshands
Tag	tag_opshand
Tag	tag_ogid
int	rank
std::vector< int >	shared_procs_in
std::vector< int >	shared_procs_out
ProcessSet	current_shared_procs
ProcessSet	current_element_procs
std::vector< char >	element_tag_data

Detailed Description

This a class that manages which tags an edge refiner should include on output vertices created during mesh refinement. The

Author:: David Thompson

Date:: 12 June 2008

Definition at line 38 of file RefinerTagManager.hpp.

Constructor & Destructor Documentation

moab::RefinerTagManager::RefinerTagManager	(	Interface *	in_mesh,
		Interface *	out_mesh
	)

Construct an evaluator.

Definition at line 17 of file RefinerTagManager.cpp.

  : shared_procs_in( 5 * MAX_SHARING_PROCS, -1 ), shared_procs_out( MAX_SHARING_PROCS, -1 )
{
  assert( in_mesh );
  if ( ! out_mesh )
    out_mesh = in_mesh;

  this->input_mesh = in_mesh;
  this->output_mesh = out_mesh;
  this->reset_vertex_tags();
  this->reset_element_tags();
  ParallelComm* ipcomm = ParallelComm::get_pcomm( this->input_mesh, 0 );
  ParallelComm* opcomm = 0;
  if ( this->output_mesh != this->input_mesh )
    {
    opcomm = ParallelComm::get_pcomm( this->output_mesh, 0 );
    if ( ! opcomm )
      {
#ifdef MB_DEBUG
      std::cout << "Creating opcomm: " << opcomm << "\n";
#endif // MB_DEBUG
      opcomm = new ParallelComm( this->output_mesh, MPI_COMM_WORLD );
      }
    }
  else
    {
    opcomm = ipcomm;
    }

  if ( ipcomm )
    {
    ipcomm->get_shared_proc_tags(
      this->tag_ipsproc, this->tag_ipsprocs,
      this->tag_ipshand, this->tag_ipshands,
      this->tag_ipstatus );
    }
  else
    {
    this->tag_ipsproc = this->tag_ipsprocs = 0;
    this->tag_ipshand = this->tag_ipshands = 0;
    this->tag_ipstatus = 0;
    }

  if ( opcomm )
    {
    opcomm->get_shared_proc_tags(
      this->tag_opsproc, this->tag_opsprocs,
      this->tag_opshand, this->tag_opshands,
      this->tag_opstatus );
    }
  else
    {
    this->tag_opsproc = this->tag_opsprocs = 0;
    this->tag_opshand = this->tag_opshands = 0;
    this->tag_opstatus = 0;
    }

  this->rank =
    ipcomm ? ipcomm->proc_config().proc_rank() :
    ( opcomm ? opcomm->proc_config().proc_rank() : 0 );

  // Create the mesh global ID tags if they aren't already there.
  int zero = 0;
  ErrorCode result;
  result = this->input_mesh->tag_get_handle(
    GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, this->tag_igid, MB_TAG_DENSE|MB_TAG_CREAT, &zero );
  if ( result != MB_SUCCESS )
    {
    throw new std::logic_error( "Unable to find input mesh global ID tag \"" GLOBAL_ID_TAG_NAME "\"" );
    }
  result = this->output_mesh->tag_get_handle(
    GLOBAL_ID_TAG_NAME, 1, MB_TYPE_INTEGER, this->tag_ogid, MB_TAG_DENSE|MB_TAG_CREAT, &zero );
  if ( result != MB_SUCCESS )
    {
    throw new std::logic_error( "Unable to find/create output mesh global ID tag \"" GLOBAL_ID_TAG_NAME "\"" );
    }

#ifdef MB_DEBUG
  std::cout
    << "psproc:  " << this->tag_ipsproc  << ", " << this->tag_opsproc << "\n"
    << "psprocs: " << this->tag_ipsprocs << ", " << this->tag_opsprocs << "\n"
    << "pshand:  " << this->tag_ipshand  << ", " << this->tag_opshand << "\n"
    << "pshands: " << this->tag_ipshands << ", " << this->tag_opshands << "\n"
    << "pstatus: " << this->tag_ipstatus << ", " << this->tag_opstatus << "\n"
    << "gid:     " << this->tag_igid     << ", " << this->tag_ogid     << "\n";
#endif // MB_DEBUG
}

moab::RefinerTagManager::~RefinerTagManager ( ) [virtual]

Destruction is virtual so subclasses may clean up after refinement.

Definition at line 106 of file RefinerTagManager.cpp.

{
}

Member Function Documentation

int moab::RefinerTagManager::add_element_tag ( Tag tag_handle )

Add a tag to the list of tag values that will appear past the element coordinates. The return value is the offset into each element coordinate pointer (p0, p1, p2) where the tag value(s) will be stored.

Definition at line 194 of file RefinerTagManager.cpp.

{
  int offset = this->element_size; // old size is offset of tag being added
  int tag_size;
  TagType tagType;
  if ( this->input_mesh->tag_get_bytes( tag_handle, tag_size ) != MB_SUCCESS )
    return -1;

  if ( this->input_mesh->tag_get_type( tag_handle, tagType ) != MB_SUCCESS )
    return -1;

  if ( tagType == MB_TAG_BIT )
    {
    // Pad any bit tags to a size in full bytes.
    tag_size = ( tag_size % 8 ? 1 : 0 ) + ( tag_size / 8 );
    }

  // Now pad so that the next tag will be word-aligned:
  while ( tag_size % sizeof(int) )
    ++tag_size;

  this->element_size += tag_size;
  this->element_tag_data.resize( this->element_size );

  this->input_element_tags.push_back( std::pair< Tag, int >( tag_handle, offset ) );
  return offset;
}

int moab::RefinerTagManager::add_vertex_tag ( Tag tag_handle )

Add a tag to the list of tag values that will appear past the vertex coordinates. The return value is the offset into each vertex coordinate pointer (p0, p1, p2) where the tag value(s) will be stored.

Definition at line 146 of file RefinerTagManager.cpp.

{
  int offset = this->vertex_size; // old size is offset of tag being added
  int tag_size;
  TagType tagType;
  if ( this->input_mesh->tag_get_bytes( tag_handle, tag_size ) != MB_SUCCESS )
    return -1;

  if ( this->input_mesh->tag_get_type( tag_handle, tagType ) != MB_SUCCESS )
    return -1;

  if ( tagType == MB_TAG_BIT )
    {
    // Pad any bit tags to a size in full bytes.
    tag_size = ( tag_size % 8 ? 1 : 0 ) + ( tag_size / 8 );
    }

  // Now pad so that the next tag will be word-aligned:
  while ( tag_size % sizeof(int) )
    ++tag_size;

  this->vertex_size += tag_size;

  this->input_vertex_tags.push_back( std::pair< Tag, int >( tag_handle, offset ) );
  return offset;
}

void moab::RefinerTagManager::assign_element_tags ( EntityHandle ent_output )

Definition at line 516 of file RefinerTagManager.cpp.

{
  std::vector< std::pair< Tag, int > >::iterator it;
  for ( it = this->output_element_tags.begin(); it != this->output_element_tags.end(); ++ it )
    {
    this->output_mesh->tag_set_data( it->first, &ent_output, 1, &this->element_tag_data[it->second] );
    }
}

int moab::RefinerTagManager::copy_gid	(	EntityHandle	ent_input,
		EntityHandle	ent_output
	)

Copy a global ID from an entity of the input mesh to an entity of the output mesh.

Parameters:

[in]	ent_input	An entity on the input mesh with a global ID.
[in]	ent_output	An entity on the output mesh whose global ID should be set.

Return values:

Normally MB_SUCCESS, but returns other values if tag_get_data or tag_set_data fail.

Definition at line 346 of file RefinerTagManager.cpp.

{
  int gid = -1;
  int status;
  if ( ( status =  this->input_mesh->tag_get_data( this->tag_igid, &ent_input, 1, &gid ) ) == MB_SUCCESS )
    {
    status = this->output_mesh->tag_set_data( this->tag_ogid, &ent_output, 1, &gid );
    }
  return status;
}

void moab::RefinerTagManager::create_output_tags ( )

Populate the list of output tags to match the list of input tags.

When the input mesh and output mesh pointers are identical, this simply copies the list of input tags. When the two meshes are distinct, the corresponding tags are created on the output mesh.

Definition at line 235 of file RefinerTagManager.cpp.

{
  if ( this->input_mesh == this->output_mesh )
    {
    this->output_vertex_tags = this->input_vertex_tags;
    this->output_element_tags = this->input_element_tags;
    return;
    }

  std::vector< std::pair< Tag, int > >::iterator it;
  for ( it = this->input_vertex_tags.begin(); it != this->input_vertex_tags.end(); ++ it )
    {
    this->create_tag_internal( it->first, it->second );
    }
}

void moab::RefinerTagManager::create_tag_internal	(	Tag	tag_in,
		int	offset
	)		`[protected]`

Definition at line 472 of file RefinerTagManager.cpp.

{
  std::pair< Tag, int > tag_rec;
  std::vector< char > tag_default;
  std::string tag_name;
  TagType tag_type;
  DataType tag_data_type;
  int tag_size;

  tag_rec.second = offset;
  this->input_mesh->tag_get_name( tag_in, tag_name );
  this->input_mesh->tag_get_bytes( tag_in, tag_size );
  this->input_mesh->tag_get_type( tag_in, tag_type );
  this->input_mesh->tag_get_data_type( tag_in, tag_data_type );
  this->input_mesh->tag_get_default_value( tag_in, (void*) &tag_default[0] );
  tag_default.resize( tag_size );
  ErrorCode res = this->output_mesh->tag_get_handle(
    tag_name.c_str(), tag_size, tag_data_type, tag_rec.first, tag_type|MB_TAG_BYTES|MB_TAG_EXCL, &tag_default[0] );
#ifdef MB_DEBUG
  std::cout
    << "Creating output tag: \"" << tag_name.c_str() << "\" handle: " << tag_rec.first
    << " input handle: " << tag_in << "\n";
#endif // MB_DEBUG
  if ( res == MB_FAILURE )
    {
    std::cerr
      << "Could not create output tag name: \"" << tag_name.c_str() << "\" type: "
      << tag_type << " data type: " << tag_data_type << "\n";
    }
  else
    {
    this->output_vertex_tags.push_back( tag_rec );
    }
}

void moab::RefinerTagManager::get_common_processes	(	int	num,
		const EntityHandle *	src,
		ProcessSet &	common_shared_procs,
		bool	on_output_mesh = `true`
	)

Determine the subset of processes which all share the specified entities.

This is used to determine which processes an output entity should reside on when it is defined using several input entities (such as vertices).

Definition at line 401 of file RefinerTagManager.cpp.

{
  Interface* mesh;
  Tag psproc;
  Tag psprocs;
  if ( on_output_mesh )
    {
    mesh = this->output_mesh;
    psproc = this->tag_opsproc;
    psprocs = this->tag_opsprocs;
    }
  else
    {
    mesh = this->input_mesh;
    psproc = this->tag_ipsproc;
    psprocs = this->tag_ipsprocs;
    }
  bool first_ent = true;
  common_shared_procs.clear();
  for ( int i = 0; i < num; ++ i )
    {
    EntityHandle ent_in = src[i];
    //std::cout << "<(" << ent_in << ")>";
    int stat;
    bool got = false;
    this->current_shared_procs.clear();
    stat = mesh->tag_get_data( psproc, &ent_in, 1, &this->shared_procs_in[0] );
    if ( stat == MB_SUCCESS && this->shared_procs_in[0] != -1 )
      {
      got = true;
      //std::cout << " s" << this->rank << " s" << this->shared_procs_in[0] << " | ";
      this->shared_procs_in[1] = -1;
      }
    stat = mesh->tag_get_data( psprocs, &ent_in, 1, &this->shared_procs_in[0] );
    if ( stat == MB_SUCCESS && this->shared_procs_in[0] != -1 )
      {
      got = true;
      /*
      int i;
      for ( i = 0; i < MAX_SHARING_PROCS && this->shared_procs_in[i] != -1; ++ i )
        std::cout << " m" << this->shared_procs_in[i];
      std::cout << " | ";
      */
      }
    if ( got )
      {
      this->current_shared_procs.set_process_members( this->shared_procs_in );
      this->current_shared_procs.set_process_member( this->rank );
      if ( first_ent )
        {
        common_shared_procs.unite( this->current_shared_procs );
        first_ent = false;
        }
      else
        {
        common_shared_procs.intersect( this->current_shared_procs );
        }
      }
    else
      {
      // not shared, but everthing exists on this process, so make sure that bit is set...
      common_shared_procs.set_process_member( this->rank );
      }
    }
#ifdef MB_DEBUG
  std::cout << "    Common procs " << common_shared_procs;
  std::cout << "\n";
#endif // MB_DEBUG
}

ProcessSet& moab::RefinerTagManager::get_element_procs ( ) [inline]

Definition at line 84 of file RefinerTagManager.hpp.

    {
    return this->current_element_procs;
    }

int moab::RefinerTagManager::get_element_tag_size ( ) const [inline]

Return the number of bytes to allocate for tag data per point.

Definition at line 51 of file RefinerTagManager.hpp.

{ return this->element_size; }

void moab::RefinerTagManager::get_input_element_tag	(	int	i,
		Tag &	tag,
		int &	byte_offset
	)

int moab::RefinerTagManager::get_input_gids	(	int	n,
		const EntityHandle *	ents,
		std::vector< int > &	gids
	)

Retrieve the global ID of each input entity and push it onto the output vector.

The gids array is emptied by this call before any new values are added. Note that this routine fetches global IDs from the input mesh, not the output mesh; your entity handles must be from the input mesh.

Parameters:

[in]	ents	An array of entities in the input mesh whose global IDs you desire
[in]	n	The number of entities in the ents array.
[out]	gids	A vector to contain the resulting global IDs.

Return values:

A	MOAB error code as supplied by the Interface::tag_get_data() call.

Definition at line 288 of file RefinerTagManager.cpp.

{
  int stat;
  gids.clear();
  for ( int i = 0; i < n; ++ i )
    {
    int gid = -1;
    stat |= this->input_mesh->tag_get_data( this->tag_igid, ents + i, 1, &gid );
    gids.push_back( gid );
    }
  return stat;
}

Interface* moab::RefinerTagManager::get_input_mesh ( ) [inline]

Definition at line 62 of file RefinerTagManager.hpp.

{ return this->input_mesh; }

void moab::RefinerTagManager::get_input_vertex_tag	(	int	i,
		Tag &	tag,
		int &	byte_offset
	)

Return the tag handle and its offset in the array of tag data of each vertex.

Parameters:

[in]	i	An index into the list of tags for the vertex.
[out]	tag	The tag handle on the input mesh for the $i$-th vertex tag.
[out]	byte_offset	The offset (in bytes) of the start of this tag's data in a vertex tag record.

Definition at line 257 of file RefinerTagManager.cpp.

{
  std::vector< std::pair< Tag, int > >::iterator it = this->input_vertex_tags.begin() + i;
  tag = it->first;
  byte_offset = it->second;
}

int moab::RefinerTagManager::get_number_of_element_tags ( ) const [inline]

Return the number of tags that will be output with each new element.

Definition at line 52 of file RefinerTagManager.hpp.

{ return this->input_element_tags.size(); }

int moab::RefinerTagManager::get_number_of_vertex_tags ( ) const [inline]

Return the number of tags that will be output with each new vertex.

Definition at line 47 of file RefinerTagManager.hpp.

{ return this->input_vertex_tags.size(); }

void moab::RefinerTagManager::get_output_element_tag	(	int	i,
		Tag &	tag,
		int &	byte_offset
	)

int moab::RefinerTagManager::get_output_gids	(	int	n,
		const EntityHandle *	ents,
		std::vector< int > &	gids
	)

Retrieve the global ID of each output entity and push it onto the output vector.

The gids array is emptied by this call before any new values are added. Note that this routine fetches global IDs from the output mesh, not the input mesh; your entity handles must be from the output mesh. Also, be aware that many output entities will not have global IDs assigned; only those vertices which exist in the input mesh are guaranteed to have global IDs assigned to them -- vertices that only exist in the output mesh and all higher-dimensional output entities have no global IDs assigned until after a complete subdivision pass has been made.

Parameters:

[in]	ents	An array of entities in the output mesh whose global IDs you desire
[in]	n	The number of entities in the ents array.
[out]	gids	A vector to contain the resulting global IDs.

Return values:

A	MOAB error code as supplied by the Interface::tag_get_data() call.

Definition at line 316 of file RefinerTagManager.cpp.

{
  int stat;
  gids.clear();
  for ( int i = 0; i < n; ++ i )
    {
    int gid = -1;
    stat |= this->output_mesh->tag_get_data( this->tag_ogid, ents + i, 1, &gid );
    gids.push_back( gid );
    }
  return stat;
}

Interface* moab::RefinerTagManager::get_output_mesh ( ) [inline]

Definition at line 63 of file RefinerTagManager.hpp.

{ return this->output_mesh; }

void moab::RefinerTagManager::get_output_vertex_tag	(	int	i,
		Tag &	tag,
		int &	byte_offset
	)

Return the tag handle and its offset in the array of tag data of each vertex.

Parameters:

[in]	i	An index into the list of tags for the vertex.
[out]	tag	The tag handle on the output mesh for the $i$-th vertex tag.
[out]	byte_offset	The offset (in bytes) of the start of this tag's data in a vertex tag record.

Definition at line 270 of file RefinerTagManager.cpp.

{
  std::vector< std::pair< Tag, int > >::iterator it = this->output_vertex_tags.begin() + i;
  tag = it->first;
  byte_offset = it->second;
}

int moab::RefinerTagManager::get_vertex_tag_size ( ) const [inline]

Return the number of bytes to allocate for tag data per point.

Definition at line 46 of file RefinerTagManager.hpp.

{ return this->vertex_size; }

Tag moab::RefinerTagManager::input_parallel_status ( ) [inline]

Definition at line 65 of file RefinerTagManager.hpp.

{ return this->tag_ipstatus; }

Tag moab::RefinerTagManager::input_shared_proc ( ) [inline]

Definition at line 66 of file RefinerTagManager.hpp.

{ return this->tag_ipsproc; }

Tag moab::RefinerTagManager::input_shared_procs ( ) [inline]

Definition at line 67 of file RefinerTagManager.hpp.

{ return this->tag_ipsprocs; }

void moab::RefinerTagManager::reset_element_tags ( )

Clear the list of tag values that will appear past the element coordinates in p0, p1, and p2.

Definition at line 182 of file RefinerTagManager.cpp.

{
  this->element_size = 0;
  this->input_element_tags.clear();
  this->output_element_tags.clear();
  this->element_tag_data.clear();
}

void moab::RefinerTagManager::reset_vertex_tags ( )

Clear the list of tag values that will appear past the vertex coordinates in p0, p1, and p2.

Definition at line 135 of file RefinerTagManager.cpp.

{
  this->vertex_size = 0;
  this->input_vertex_tags.clear();
  this->output_vertex_tags.clear();
}

void moab::RefinerTagManager::set_element_procs_from_ent ( EntityHandle ent_input ) [inline]

Definition at line 80 of file RefinerTagManager.hpp.

    {
    this->get_common_processes( 1, &ent_input, this->current_element_procs, false );
    }

void moab::RefinerTagManager::set_element_sharing ( EntityHandle ent_output ) [inline]

Definition at line 88 of file RefinerTagManager.hpp.

    {
    this->set_sharing( ent_output, this->current_element_procs );
    }

void moab::RefinerTagManager::set_element_tags_from_ent ( EntityHandle ent_input )

Definition at line 507 of file RefinerTagManager.cpp.

{
  std::vector< std::pair< Tag, int > >::iterator it;
  for ( it = this->input_element_tags.begin(); it != this->input_element_tags.end(); ++ it )
    {
    this->input_mesh->tag_get_data( it->first, &ent_input, 1, &this->element_tag_data[it->second] );
    }
}

int moab::RefinerTagManager::set_gid	(	EntityHandle	ent,
		int	gid
	)

Assign a global ID to an output entity.

Parameters:

[in]	ent	The entity whose ID will be set
[out]	id	The global ID

Return values:

An	error code as returned by Interface::tag_set_data().

Definition at line 335 of file RefinerTagManager.cpp.

{
  return this->output_mesh->tag_set_data( this->tag_ogid, &ent, 1, &gid );
}

void moab::RefinerTagManager::set_sharing	(	EntityHandle	ent_handle,
		ProcessSet &	procs
	)

Set parallel status and sharing process list on an entity.

This sets tag values for the PARALLEL_STATUS and one of PARALLEL_SHARED_PROC or PARALLEL_SHARED_PROCS tags if procs contains any processes (the current process is assumed not to be set in procs).

Parameters:

[in]	ent_handle	The entity whose information will be set
[in]	procs	The set of sharing processes.

Definition at line 365 of file RefinerTagManager.cpp.

{
  int pstat;
  if ( procs.get_process_members( this->rank, this->shared_procs_out ) )
    pstat = PSTATUS_SHARED | PSTATUS_INTERFACE;
  else
    pstat = PSTATUS_SHARED | PSTATUS_INTERFACE | PSTATUS_NOT_OWNED;
  if ( this->shared_procs_out[0] >= 0 )
    {
    // assert( MAX_SHARING_PROCS > 1 );
    // Since get_process_members pads to MAX_SHARING_PROCS, this will be work:
    if ( this->shared_procs_out[1] <= 0 )
      {
      //std::cout << "  (proc )";
      this->output_mesh->tag_set_data( this->tag_opsproc, &ent_handle, 1, &this->shared_procs_out[0] );
      this->output_mesh->tag_set_data( this->tag_opstatus, &ent_handle, 1, &pstat );
      }
    else
      {
      //std::cout << "  (procS)";
      this->output_mesh->tag_set_data( this->tag_opsprocs, &ent_handle, 1, &this->shared_procs_out[0] );
      this->output_mesh->tag_set_data( this->tag_opstatus, &ent_handle, 1, &pstat );
      }
    }
  else
    {
    //std::cout << "  (none )";
    }
  //std::cout << " new pstat: " << pstat << "\n";
}