Changeset 2048

Timestamp:

08/25/08 18:02:57 (3 months ago)

Author:

dcthomp

Message:

ENH: Checkpoint of progress. The input mesh and output mesh

need not be the same any longer.

STYLE: Moved some code dealing with parallel status/sharing

tags from the output functor to the tag manager.

Files:

• MOAB/trunk/refiner/MBEntityRefiner.hpp (modified) (4 diffs)
• MOAB/trunk/refiner/MBMeshOutputFunctor.cpp (modified) (9 diffs)
• MOAB/trunk/refiner/MBMeshOutputFunctor.hpp (modified) (1 diff)
• MOAB/trunk/refiner/MBProcessSet.cpp (modified) (1 diff)
• MOAB/trunk/refiner/MBRefinerTagManager.cpp (modified) (3 diffs)
• MOAB/trunk/refiner/MBRefinerTagManager.hpp (modified) (3 diffs)
• MOAB/trunk/refiner/MBSimplexTemplateRefiner.cpp (modified) (4 diffs)
• MOAB/trunk/refiner/MBSimplexTemplateRefiner.hpp (modified) (1 diff)
• MOAB/trunk/refiner/MBSplitVertices.cpp (modified) (2 diffs)
• MOAB/trunk/refiner/MBSplitVertices.hpp (modified) (7 diffs)
• MOAB/trunk/refiner/test_mesh_refiner.cpp (modified) (4 diffs)

MOAB/trunk/refiner/MBEntityRefiner.hpp

@@ -53 +53 @@
-  * the other used to finalize the creation of the entity by specifying its type.
-  *
+  * You are also responsible for implementing the map_vertex() function to map an input vertex handle
+  * into an output vertex handle (which may then be appended to an entity using the first form
+  * of the parenthesis operator above).
+  *
-  * \author David Thompson
-  * \author Philippe Pebay
@@ -73 +77 @@
-public:
-  virtual ~MBEntityRefinerOutputFunctor() { }
-
+
+
+
+
+
+
+
+
+
+
-  MBEntityHandle operator () ( MBEntityHandle h0, MBEntityHandle h1, const double* vcoords, const void* vtags )
-    {
@@ -81 +94 @@
-    return (*this)( 2, harr, vcoords, vtags );
-    }
+  /**\brief Create a new vertex on a triangular face.
+    *
+    * @param[in] h0 A triangle corner handle on the output mesh.
+    * @param[in] h1 A triangle corner handle on the output mesh.
+    * @param[in] h2 A triangle corner handle on the output mesh.
+    * @param[in] vcoords The location of the mid-face point in world coordinates.
+    * @param[in] vtags Field values at the mid-face point.
+    * @retval    A handle for the mid-face point on the output mesh.
+    */
-  virtual MBEntityHandle operator () ( MBEntityHandle h0, MBEntityHandle h1, MBEntityHandle h2, const double* vcoords, const void* vtags )
-    {
@@ -89 +111 @@
-    return (*this)( 3, harr, vcoords, vtags );
-    }
+  /**\brief Create a new vertex along a \f$k\f$-facet.
+    *
+    * @param[in] nhash The number of corner vertices (i.e, \f$k\f$ ).
+    * @param[in] hash An array of corner handles on the output mesh.
+    * @param[in] vcoords The location of the new point in world coordinates.
+    * @param[in] vtags Field values at the new point.
+    * @retval    A handle for the new point on the output mesh.
+    */
-  virtual MBEntityHandle operator () ( int nhash, MBEntityHandle* hash, const double* vcoords, const void* vtags ) = 0;
+  /**\brief Append an output vertex to the list of vertices defining a new entity.
+    *
+    * @param[in] vhash A vertex of the output mesh.
+    */
-  virtual void operator () ( MBEntityHandle vhash ) = 0;
+  /**\brief Create a new entity from all previously appended output vertices.
+    *
+    * This resets the list of appended vertices.
+    * @param[in] etyp The type of entity to create.
+    */
-  virtual void operator () ( MBEntityType etyp ) = 0;
-};

MOAB/trunk/refiner/MBMeshOutputFunctor.cpp

@@ -27 +27 @@
-  // Hold information about newly-created mesh entities (other than split vertices)
-  // This is necessary in order for global IDs to be assigned consistently across processes.
-4
+5
-  this->new_entities[0] = new MBSplitVertices<0>( this->tag_manager );
-  this->new_entities[1] = new MBSplitVertices<1>( this->tag_manager );
-  this->new_entities[2] = new MBSplitVertices<2>( this->tag_manager );
-  this->new_entities[3] = new MBSplitVertices<3>( this->tag_manager );
+  this->new_entities[4] = new MBSplitVertices<4>( this->tag_manager );
-}
-
-MBMeshOutputFunctor::~MBMeshOutputFunctor()
-{
-0
+1
-    delete this->split_vertices[i];
-4
+5
-    delete this->new_entities[i];
-}
-
-
+
+
-{
-  std::cout << "+ {";
@@ -64 +66 @@
-
-  std::cout << " >\n";
+  //std::cout << "##############################\n";
+  //this->mesh_out->list_entities( 0, 1 );
+  //std::cout << "##############################\n";
-}
-
@@ -145 +150 @@
-    }
-  std::vector<MBSplitVerticesBase*>::iterator vit;
-
+
+
+
+
+
+
+
+
-    {
-    if ( *vit )
-      (*vit)->assign_global_ids( gids );
-    }
-
-
-
-
-
+
+
+
+
-}
-
@@ -172 +183 @@
-}
-
-operator () 
+map_vertex
-{
-  if ( this->input_is_output )
@@ -180 +191 @@
-    }
-  MBEntityHandle vertex_handle;
-0
-
+1
+, false
-  if ( newly_created )
-    {
+    std::vector<int> gid;
-    this->assign_tags( vertex_handle, vtags );
+    if ( this->tag_manager->get_input_gids( 1, &vhash, gid ) == MB_SUCCESS )
+      {
+      this->tag_manager->set_gid( vertex_handle, gid[0] );
+      }
-    }
-  if ( ! vertex_handle )
@@ -197 +213 @@
-{
-  MBEntityHandle vertex_handle;
-
-
-
-
-
+
-    {
-    bool newly_created = this->split_vertices[nvhash]->find_or_create(
-
+, true
-    if ( newly_created )
-      {
@@ -213 +225 @@
-      std::cerr << "Could not insert mid-edge vertex!\n";
-      }
+    std::cout << "(-" << nvhash << "-) ";
-    this->print_vert_crud( vertex_handle, nvhash, vhash, vcoords, vtags );
-    }
@@ -226 +239 @@
-{
-  std::cout << h << " ";
+  if ( ! this->input_is_output )
+    {
+    // FIXME: Copy to output mesh
+    }
-  this->elem_vert.push_back( h );
-  if ( ! this->input_is_output )
-    {
-    // FIXME: Copy to output mesh
-    }
-}
-
@@ -237 +250 @@
-  MBEntityHandle elem_handle;
-  int nconn = this->elem_vert.size();
-  if ( this->mesh_out->create_element( etyp, &this->elem_vert[0], nconn, elem_handle ) == MB_FAILURE )
-    {
-    std::cerr << " *** ";
-    }
-  std::cout << "---------> " << elem_handle << " ( " << etyp << " )\n\n";
-#if 0
-  bool newly_created = this->new_entities[nconn]->create_element(
-
+etyp, nconn, 
-  if ( newly_created )
-    {
+    std::cout << " *** ";
-    // FIXME: Handle tag assignment for elements as well as vertices
-    //this->assign_tags( elem_handle, this->element_tag_data );
-    }
-
+
-  this->elem_vert.clear();
-}

MOAB/trunk/refiner/MBMeshOutputFunctor.hpp

@@ -49 +49 @@
-  void print_vert_crud( MBEntityHandle vout, int nvhash, MBEntityHandle* vhash, const double* vcoords, const void* vtags );
-  void assign_global_ids( MBParallelComm* comm );
+  void exchange_handles( MBParallelComm* comm );
-
-  void assign_tags( MBEntityHandle vhandle, const void* vtags );
-
-operator () 
+map_vertex
-  virtual MBEntityHandle operator () ( int nvhash, MBEntityHandle* vhash, const double* vcoords, const void* vtags );
-  virtual void operator () ( MBEntityHandle h );

MOAB/trunk/refiner/MBProcessSet.cpp

@@ -96 +96 @@
-      }
-    }
+  for ( i = procs.size(); i < MAX_SHARING_PROCS; ++ i )
+    {
+    procs.push_back( -1 ); // pad with invalid values
+    }
-  return rank_owner;
-}

MOAB/trunk/refiner/MBRefinerTagManager.cpp

@@ -3 +3 @@
-#include "MBInterface.hpp"
-#include "MBParallelComm.hpp"
+#include "MBParallelConventions.h"
+#include "MBTagConventions.hpp"
-
-#include <iostream>
+#include <stdexcept>
-#include <assert.h>
-
-/// Construct an evaluator.
-MBRefinerTagManager::MBRefinerTagManager( MBInterface* in_mesh, MBInterface* out_mesh )
+  : shared_procs_in( 5 * MAX_SHARING_PROCS, -1 ), shared_procs_out( MAX_SHARING_PROCS, -1 )
-{
-  assert( in_mesh );
@@ -18 +22 @@
-  this->reset_vertex_tags();
-  MBParallelComm* ipcomm = MBParallelComm::get_pcomm( this->input_mesh, 0 );
+  MBParallelComm* opcomm = 0;
+  if ( this->output_mesh != this->input_mesh )
+    {
+    opcomm = MBParallelComm::get_pcomm( this->output_mesh, 0 );
+    if ( ! opcomm )
+      {
+      std::cout << "Creating opcomm: " << opcomm << "\n";
+      opcomm = new MBParallelComm( this->output_mesh, MPI_COMM_WORLD );
+      }
+    }
+  else
+    {
+    opcomm = ipcomm;
+    }
+
-  if ( ipcomm )
-    {
-    ipcomm->get_shared_proc_tags(
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -182 +243 @@
-  byte_offset = it->second;
-}
+
+/**\brief Retrieve the global ID of each input entity and push it onto the output vector.
+  *
+  * The \a 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.
+  *
+  * @param[in] ents An array of entities in the input mesh whose global IDs you desire
+  * @param[in] n The number of entities in the \a ents array.
+  * @param[out] gids A vector to contain the resulting global IDs.
+  * @retval A MOAB error code as supplied by the MBInterface::tag_get_data() call.
+  */
+int MBRefinerTagManager::get_input_gids( int n, const MBEntityHandle* ents, std::vector<int>& gids )
+{
+  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;
+}
+
+/**\brief Retrieve the global ID of each output entity and push it onto the output vector.
+  *
+  * The \a 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.
+  *
+  * @param[in] ents An array of entities in the output mesh whose global IDs you desire
+  * @param[in] n The number of entities in the \a ents array.
+  * @param[out] gids A vector to contain the resulting global IDs.
+  * @retval A MOAB error code as supplied by the MBInterface::tag_get_data() call.
+  */
+int MBRefinerTagManager::get_output_gids( int n, const MBEntityHandle* ents, std::vector<int>& gids )
+{
+  int stat;
+  gids.clear();
+  for ( int i = 0; i < n; ++ i )
+    {
+    int gid = -1;
+    stat |= this->output_mesh->tag_get_data( this->tag_igid, ents + i, 1, &gid );
+    gids.push_back( gid );
+    }
+  return stat;
+}
+
+/**\brief Assign a global ID to an output entity.
+  *
+  * @param[in] ent The entity whose ID will be set
+  * @param[out] id The global ID
+  * @retval An error code as returned by MBInterface::tag_set_data().
+  */
+int MBRefinerTagManager::set_gid( MBEntityHandle ent, int gid )
+{
+  return this->output_mesh->tag_set_data( this->tag_ogid, &ent, 1, &gid );
+}
+
+/**\brief 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 \a procs contains any processes (the current process is assumed <b>not</b> to be set in \a procs).
+  *
+  * @param[in] ent_handle The entity whose information will be set
+  * @param[in] procs The set of sharing processes.
+  */
+void MBRefinerTagManager::set_sharing( MBEntityHandle ent_handle, MBProcessSet& procs )
+{
+  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";
+}
+
+/**\brief 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).
+  */
+void MBRefinerTagManager::get_common_processes(
+  int num, const MBEntityHandle* src, MBProcessSet& common_shared_procs, bool on_output_mesh )
+{
+  MBInterface* mesh;
+  MBTag psproc;
+  MBTag 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 )
+    {
+    MBEntityHandle 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
+      {
+      //std::cout << " not shared | ";
+      }
+    }
+  std::cout << "    Common procs " << common_shared_procs;
+  std::cout << "\n";
+}
+

MOAB/trunk/refiner/MBRefinerTagManager.hpp

@@ -29 +29 @@
-#include "MBTypes.h" // for MB_DLL_EXPORT
-
+#include "MBProcessSet.hpp"
+
-#include <vector>
-
@@ -52 +54 @@
-  MBInterface* get_output_mesh() { return this->output_mesh; }
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-
-protected:
@@ -62 +71 @@
-  MBInterface* input_mesh;
-  MBInterface* output_mesh;
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-};
-

MOAB/trunk/refiner/MBSimplexTemplateRefiner.cpp

@@ -31 +31 @@
-  this->corner_tags.resize( 8 ); // Hex has 8 verts (this is a pointer, not the actual tag data)
-  this->corner_handles.resize( 8 ); // Hex has 8 verts (this is a pointer, not actual hash data)
+  this->input_is_output = false; // Until we know better
-}
-
@@ -62 +63 @@
-  for ( int n = 0; n < num_nodes; ++ n )
-    {
-    this->corner_handles[n] = conn[n];
-    if ( imesh->get_coords( &conn[n], 1, &corner_coords[6 * n + 3] ) != MB_SUCCESS )
-      {
@@ -75 +75 @@
-        return false;
-        }
+      }
+    if ( this->input_is_output )
+      {
+      this->corner_handles[n] = conn[n];
+      }
+    else
+      {
+      this->corner_handles[n] = this->output_functor->map_vertex( conn[n], &corner_coords[6 * n], tag_data );
+#if 0
+      std::cout << "#+# " << this->corner_handles[n] << " < "
+        << corner_coords[ 6 * n + 3 ] << ", "
+        << corner_coords[ 6 * n + 4 ] << ", "
+        << corner_coords[ 6 * n + 5 ] << ">\n";
+#endif // 0
-      }
-    this->corner_tags[n] = tag_data;
@@ -171 +185 @@
-  this->tag_manager = tmgr;
-  this->tag_assigner->set_tag_manager( tmgr );
+  this->input_is_output = ( this->tag_manager->get_input_mesh() == this->tag_manager->get_output_mesh() );
-  //this->tag_assigner->set_edge_size_evaluator( this->edge_size_evaluator );
-  return this->MBEntityRefiner::prepare( tmgr, ofunc );

MOAB/trunk/refiner/MBSimplexTemplateRefiner.hpp

@@ -57 +57 @@
-  std::vector<void*> corner_tags;
-  std::vector<MBEntityHandle> corner_handles;
+  bool input_is_output;
-
-  static int template_index[64][2];

MOAB/trunk/refiner/MBSplitVertices.cpp

@@ -7 +7 @@
-{
-  this->tag_manager = tag_mgr;
-  this->mesh_in  = tag_mgr->get_input_mesh();
-  this->mesh_out = tag_mgr->get_output_mesh();
-  this->shared_procs_in.resize( MAX_SHARING_PROCS );
-  MBParallelComm* ipcomm = MBParallelComm::get_pcomm( this->mesh_in, 0 );
-  this->rank = ipcomm ? ipcomm->proc_config().proc_rank() : 0;
-  int zero = 0;
-  MBErrorCode result = this->mesh_out->tag_create(
-    GLOBAL_ID_TAG_NAME, sizeof(int), MB_TAG_DENSE, MB_TYPE_INTEGER, this->tag_gid, &zero, true );
-  if ( result != MB_SUCCESS && result != MB_ALREADY_ALLOCATED )
-    return;
-}
-
@@ -23 +14 @@
-}
-
-/// Determine which processes will contain an output vertex given the split vertices defining it.
-void MBSplitVerticesBase::update_partition_counts(
-  int num, const MBEntityHandle* split_src, std::map<MBProcessSet,int>& proc_partition_counts )
-{
-  this->begin_vertex_procs();
-  for ( int i = 0; i < num; ++ i )
-    {
-    this->add_vertex_procs( split_src[i] );
-    }
-  this->end_vertex_procs();
-  proc_partition_counts[this->common_shared_procs]++;
-}
-
-/// Prepare to compute the processes on which a new split-vertex will live.
-void MBSplitVerticesBase::begin_vertex_procs()
-{
-  this->first_vertex = true;
-  this->common_shared_procs.clear();
-}
-
-/// Call this for each existing corner vertex used to define a split-vertex.
-void MBSplitVerticesBase::add_vertex_procs( MBEntityHandle vert_in )
-{
-  int stat;
-  bool got = false;
-  this->current_shared_procs.clear();
-  stat = this->mesh_in->tag_get_data(
-    this->tag_manager->shared_proc(), &vert_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 = this->mesh_in->tag_get_data(
-    this->tag_manager->shared_procs(), &vert_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 ( this->first_vertex )
-      {
-      this->common_shared_procs.unite( this->current_shared_procs );
-      this->first_vertex = false;
-      }
-    else
-      {
-      this->common_shared_procs.intersect( this->current_shared_procs );
-      }
-    }
-  else
-    {
-    std::cout << " not shared | ";
-    }
-}
-
-/// Call this once after all the add_vertex_procs() calls for a split-vertex to prepare queues for the second stage MPI send. 
-void MBSplitVerticesBase::end_vertex_procs()
-{
-  std::cout << "    Common procs " << this->common_shared_procs;
-  std::cout << "\n";
-  // FIXME: Here is where we add the vertex to the appropriate queues.
-}
-
-void MBSplitVerticesBase::set_sharing( MBEntityHandle ent_handle, MBProcessSet& procs )
-{
-  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;
-  int sps = this->shared_procs_out.size();
-  std::cout << " new pstat: " << pstat << " sps: " << sps << "\n";
-  switch ( sps )
-    {
-  case 0:
-    break;
-  case 1:
-    this->mesh_out->tag_set_data( this->tag_manager->shared_proc(), &ent_handle, 1, &this->shared_procs_out[0] );
-    this->mesh_out->tag_set_data( this->tag_manager->parallel_status(), &ent_handle, 1, &pstat );
-    break;
-  default:
-    this->mesh_out->tag_set_data( this->tag_manager->shared_procs(), &ent_handle, sps, &this->shared_procs_out[0] );
-    this->mesh_out->tag_set_data( this->tag_manager->parallel_status(), &ent_handle, 1, &pstat );
-    break;
-    }
-}
-

MOAB/trunk/refiner/MBSplitVertices.hpp

@@ -91 +91 @@
-  virtual bool find_or_create(
-    const MBEntityHandle* split_src, const double* coords, MBEntityHandle& vert_handle,
+    std::map<MBProcessSet,int>& proc_partition_counts, bool handles_on_output_mesh ) = 0;
+
+  virtual bool create_element(
+    MBEntityType etyp, int nconn, const MBEntityHandle* elem_verts, MBEntityHandle& elem_handle,
-    std::map<MBProcessSet,int>& proc_partition_counts ) = 0;
-
-  virtual bool create_element(
-    const MBEntityHandle* split_src, MBEntityHandle& elem_handle,
-    std::map<MBProcessSet,int>& proc_partition_counts ) = 0;
-
-  virtual void assign_global_ids( std::map<MBProcessSet,int>& gids ) = 0;
-
-  /// Determine which processes will contain an output vertex given the split vertices defining it.
-  void update_partition_counts( int num, const MBEntityHandle* split_src, std::map<MBProcessSet,int>& proc_partition_counts );
-
-  /// Prepare to compute the processes on which a new split-vertex will live.
-  void begin_vertex_procs();
-
-  /// Call this for each existing corner vertex used to define a split-vertex.
-  void add_vertex_procs( MBEntityHandle vert_in );
-
-  /// Call this once after all the add_vertex_procs() calls for a split-vertex to prepare queues for the second stage MPI send. 
-  void end_vertex_procs();
-
-  /// Set the tags which indicate sharing process(es) for an entity.
-  void set_sharing( MBEntityHandle vert_handle, MBProcessSet& procs );
-
-  MBInterface* mesh_in; // Input mesh. Needed to determine tag values on split_src verts
-  MBInterface* mesh_out; // Output mesh. Needed for new vertex set in vert_handle
-  MBRefinerTagManager* tag_manager;
-  std::vector<int> shared_procs_in; // Used to hold procs sharing an input vert.
-  std::vector<int> shared_procs_out; // Used to hold procs sharing an output vert.
-  std::vector<int> split_gids; // Used to hold global IDs of split vertices
-  MBProcessSet current_shared_procs; // Holds process list as it is being accumulated
-  MBProcessSet common_shared_procs; // Holds intersection of several shared_procs_ins.
-  int rank; // This process' rank.
-  bool first_vertex; // True just after begin_vertex_procs() is called.
-  MBTag tag_gid;
-};
-
@@ -144 +122 @@
-  virtual bool find_or_create(
-    const MBEntityHandle* split_src, const double* coords, MBEntityHandle& vert_handle,
-
+, bool handles_on_output_mesh
-  virtual bool create_element(
-
+MBEntityType etyp, int nconn, 
-    std::map<MBProcessSet,int>& proc_partition_counts );
-
@@ -157 +135 @@
-  : MBSplitVerticesBase( tag_mgr )
-{
-  this->shared_procs_in.resize( _n * MAX_SHARING_PROCS );
-  this->split_gids.resize( _n );
-}
@@ -169 +146 @@
-bool MBSplitVertices<_n>::find_or_create(
-  const MBEntityHandle* split_src, const double* coords, MBEntityHandle& vert_handle,
-
+, bool handles_on_output_mesh
-{
-  // Get the global IDs of the input vertices
-  int stat;
-
-
-
-
-
+
+
+
+
+
+
+
-    }
-  MBSplitVertexIndex<_n> key( &this->split_gids[0] );
@@ -183 +162 @@
-  if ( it == this->end() )
-    {
-
+
+
+
-    key.set_common_processes( this->common_shared_procs );
-
+ + 3
-      {
-      return false;
-      }
-    (*this)[key] = vert_handle;
-
+tag_manager->
-    return true;
-    }
@@ -199 +180 @@
-template< int _n >
-bool MBSplitVertices<_n>::create_element(
-const MBEntityHandle* split_src
+MBEntityType etyp, int nconn, const MBEntityHandle* elem_verts
-  std::map<MBProcessSet,int>& proc_partition_counts )
-{
+  // Get the global IDs of the input vertices
+  int stat;
+  stat = this->tag_manager->get_input_gids( _n, elem_verts, this->split_gids );
+  MBSplitVertexIndex<_n> key( &this->split_gids[0] );
+  this->tag_manager->get_common_processes( _n, elem_verts, this->common_shared_procs );
+  proc_partition_counts[this->common_shared_procs]++;
+  key.set_common_processes( this->common_shared_procs );
+  if ( this->mesh_out->create_element( etyp, elem_verts, nconn, elem_handle ) != MB_SUCCESS )
+    {
+    return false;
+    }
+  (*this)[key] = elem_handle;
+  this->tag_manager->set_sharing( elem_handle, this->common_shared_procs );
+  return true;
-}
-
@@ -211 +206 @@
-    {
-    int gid = gids[it->first.process_set] ++;
-mesh_out->tag_set_data( this->tag_gid, &it->second, 1, &
-" << it->first << " ->
+tag_manager->set_gid( it->second, 
+entity: " << it->first << " GID:
-    }
-}

MOAB/trunk/refiner/test_mesh_refiner.cpp

@@ -31 +31 @@
-
-  // Create the input mesh and, if -new-mesh is specified, an output mesh
-/home/dcthomp/
+
-  bool input_is_output = ( argc > 2 && ! strcmp( argv[2], "-new-mesh" ) ) ? false : true;
-  MBInterface* imesh = new MBCore( rank, nprocs );
@@ -42 +42 @@
-#endif // USE_MPI
-
-  // Get the global ID tag so we can set things up for resolve_shared_ents
-  //MBTag tag_gid;
-  //imesh->tag_create( PARALLEL_GID_TAG_NAME, sizeof( int ), MB_TAG_DENSE, MB_TYPE_INTEGER, tag_gid, default_gid );
-
-#ifdef USE_MPI
-  // Get tags for the various data-distributed mesh annotations
-  MBTag tag_sproc;
-  MBTag tag_sprocs;
-  MBTag tag_shand;
-  MBTag tag_shands;
-  MBTag tag_pstat;
-  ipcomm->get_shared_proc_tags( tag_sproc, tag_sprocs, tag_shand, tag_shands, tag_pstat );
-  MBTag tag_part = ipcomm->partition_tag();
-#endif // USE_MPI
-
-  MBEntityHandle set_handle;
-  std::ostringstream parallel_options;
-  parallel_options
-also use
+use BCAST_DELETE or
-    << "PARTITION=MATERIAL_SET" << ";"
-    //<< "PARTITION_DISTRIBUTE" << ";"
@@ -84 +69 @@
-  imesh->list_entities( 0, 1 );
-#endif // USE_MPI
+  std::ostringstream ifs;
+  ifs << "prerefiner." << nprocs << "." << rank << ".vtk";
+  imesh->write_mesh( ifs.str().c_str() );
-
-  // The refiner will need an implicit function to be used as an indicator function for subdivision:
@@ -97 +85 @@
-  eref->set_edge_size_evaluator( eval );
-  MBRange ents_to_refine;
-
+
+
-  mref->refine( ents_to_refine );
-
+  std::ostringstream ofs;
+  ofs << "refiner." << nprocs << "." << rank << ".vtk";
+  omesh->write_mesh( ofs.str().c_str() );
-  // Print out the results, one process at a time
-#ifdef USE_MPI