Skinner.hpp

Go to the documentation of this file.

#ifndef MOAB_SKINNER_HPP
#define MOAB_SKINNER_HPP

#include "moab/Forward.hpp"
#include "moab/Range.hpp"
#include <vector>

namespace moab {

class ScdBox;
    
class Skinner 
{

  enum direction{FORWARD=1, REVERSE=-1};
protected:
  Interface* thisMB;

  Tag mDeletableMBTag;
  Tag mAdjTag;
  int mTargetDim;

public:
  Skinner(Interface* mdb) 
    : thisMB(mdb), mDeletableMBTag(0), mAdjTag(0){}

  ~Skinner();

  ErrorCode find_geometric_skin(const EntityHandle meshset, Range &forward_target_entities);
  
  ErrorCode find_skin( const EntityHandle meshset,
                       const Range &entities,
                       bool get_vertices,
                       Range &output_handles,
                       Range *output_reverse_handles = 0,
                       bool create_vert_elem_adjs = false,
                       bool create_skin_elements = true,
                       bool look_for_scd = false);

  ErrorCode find_skin( const EntityHandle this_set,
                       const EntityHandle *entities,
                       int num_entities,
                       bool get_vertices,
                       Range &output_handles,
                       Range *output_reverse_handles = 0,
                       bool create_vert_elem_adjs = false,
                       bool create_skin_elements = true,
                       bool look_for_scd = false);

  ErrorCode find_skin(const EntityHandle this_set,
                      const Range &entities,
                      int dim,
                      Range &skin_entities,
                      bool create_vert_elem_adjs = false,
                      bool create_skin_elements = true);

  ErrorCode classify_2d_boundary( const Range &boundary,
                                     const Range &bar_elements,
                                     EntityHandle boundary_edges,
                                     EntityHandle inferred_edges,
                                     EntityHandle non_manifold_edges,
                                     EntityHandle other_edges,
                                     int &number_boundary_nodes);
  
  ErrorCode classify_2d_boundary( const Range  &boundary,
                                     const Range  &mesh_1d_elements,
                                     Range  &boundary_edges,
                                     Range  &inferred_edges,
                                     Range  &non_manifold_edges,
                                     Range  &other_edges,
                                     int &number_boundary_nodes);

protected:
  
  ErrorCode initialize();
  
  ErrorCode deinitialize();

  ErrorCode find_skin_noadj( const Range &source_entities,
                               Range &forward_target_entities,
                               Range &reverse_target_entities );

  ErrorCode add_adjacency(EntityHandle entity);
  
  void add_adjacency(EntityHandle entity, const EntityHandle *conn,
                     const int num_nodes);

  ErrorCode remove_adjacency(EntityHandle entity);

  bool entity_deletable(EntityHandle entity);

  void find_match( EntityType type, 
                   const EntityHandle *conn, 
                   const int num_nodes,
                   EntityHandle& match,
                   Skinner::direction &direct);

  bool connectivity_match(const EntityHandle *conn1,
                          const EntityHandle *conn2,
                          const int num_verts,
                          Skinner::direction &direct);

  void find_inferred_edges(Range &skin_boundary,
                           Range &candidate_edges,
                           Range &inferred_edges,
                           double reference_angle_degrees);

  bool has_larger_angle(EntityHandle &entity1,
                       EntityHandle &entity2,
                       double reference_angle_cosine);


  ErrorCode find_skin_vertices( const EntityHandle this_set,
                                const Range& entities,
                                  Range* skin_verts = 0,
                                  Range* skin_elems = 0,
                                  Range* rev_elems = 0,
                                  bool create_if_missing = true,
                                  bool corners_only = false );

  ErrorCode find_skin_vertices_1D( Tag tag,
                                     const Range& edges,
                                     Range& skin_verts );
                                     
  ErrorCode find_skin_vertices_2D( Tag tag,
                                     const Range& faces,
                                     Range* skin_verts = 0,
                                     Range* skin_edges = 0,
                                     Range* reverse_edges = 0,
                                     bool create_edges = false,
                                     bool corners_only = false );
                                     
  ErrorCode find_skin_vertices_3D( Tag tag,
                                     const Range& entities,
                                     Range* skin_verts = 0,
                                     Range* skin_faces = 0,
                                     Range* reverse_faces = 0,
                                     bool create_faces = false,
                                     bool corners_only = false );

  ErrorCode create_side( EntityHandle element,
                           EntityType side_type,
                           const EntityHandle* side_corners,
                           EntityHandle& side_elem_handle_out );
                           
  bool edge_reversed( EntityHandle face, const EntityHandle edge_ends[2] );
  bool face_reversed( EntityHandle region, const EntityHandle* face_conn, 
                      EntityType face_type );

  ErrorCode find_skin_scd(const Range& source_entities,
                          bool get_vertices,
                          Range& output_handles,
                          bool create_skin_elements);
  
  ErrorCode skin_box(ScdBox *box, bool get_vertices, Range &output_handles, 
                     bool create_skin_elements);
};

inline ErrorCode Skinner::find_skin( const EntityHandle this_set,
                                     const EntityHandle *entities,
                                     int num_entities,
                                     bool get_vertices,
                                     Range &output_handles,
                                     Range *output_reverse_handles,
                                     bool create_vert_elem_adjs,
                                     bool create_skin_elements,
                                     bool look_for_scd) 
{
  Range ents;
  std::copy(entities, entities+num_entities, range_inserter(ents));
  return find_skin(this_set, ents, get_vertices, output_handles, output_reverse_handles,
                   create_vert_elem_adjs, create_skin_elements, look_for_scd);
}
      
} // namespace moab 

#endif