Mesh Oriented datABase  (version 5.5.1)
An array-based unstructured mesh library
Skinner.hpp
Go to the documentation of this file.
1 /**
2  * MOAB, a Mesh-Oriented datABase, is a software component for creating,
3  * storing and accessing finite element mesh data.
4  *
5  * Copyright 2004 Sandia Corporation. Under the terms of Contract
6  * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
7  * retains certain rights in this software.
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  */
15 
16 #ifndef MOAB_SKINNER_HPP
17 #define MOAB_SKINNER_HPP
18 
19 #include "moab/Forward.hpp"
20 #include "moab/Range.hpp"
21 #include <vector>
22 
23 namespace moab
24 {
25 
26 class ScdBox;
27 
28 /** \class Skinner
29  * \brief Class for constructing and querying skin of a mesh
30  * Class for constructing and querying skin of a mesh, defined as the outside lower-dimensional
31  * boundary of a mesh or a given set of entities. This class provides options for finding the
32  * forward- and reverse-oriented members of the skin. Several methods are available for computing
33  * the skin, e.g. using geometric topology sets, vertex-entity adjacencies, or directly from
34  * (n-1)-dimensional entities.
35  */
36 class Skinner
37 {
38 
39  enum direction
40  {
41  FORWARD = 1,
42  REVERSE = -1
43  };
44 
45  protected:
46  //! the MB instance that this works with
47  Interface* thisMB;
48 
49  Tag mDeletableMBTag;
50  Tag mAdjTag;
51  int mTargetDim;
52 
53  public:
54  //! constructor, takes mdb instance
55  Skinner( Interface* mdb ) : thisMB( mdb ), mDeletableMBTag( 0 ), mAdjTag( 0 ), mTargetDim( 0 ) {}
56 
57  //! destructor
58  ~Skinner();
59 
60  ErrorCode find_geometric_skin( const EntityHandle meshset, Range& forward_target_entities );
61 
62  /**\brief will accept entities all of one dimension and
63  * return entities of n-1 dimension; NOTE: get_vertices argument controls whether
64  * vertices or entities of n-1 dimension are returned, and only one of these is allowed
65  * (i.e. this function returns only vertices or (n-1)-dimensional entities, but not both)
66  * \param entities The elements for which to find the skin
67  * \param get_vertices If true, vertices on the skin are returned
68  * in the range, otherwise elements are returned
69  * \param output_handles Range holding skin entities returned
70  * \param output_reverse_handles Range holding entities on skin which
71  * are reversed wrt entities
72  * \param create_vert_elem_adjs If true, this function will cause
73  * vertex-element adjacencies to be generated
74  * \param create_skin_elements If true, this function will cause creation
75  * of skin entities, otherwise only skin entities already extant
76  * will be returned
77  */
78  ErrorCode find_skin( const EntityHandle meshset,
79  const Range& entities,
80  bool get_vertices,
81  Range& output_handles,
82  Range* output_reverse_handles = 0,
83  bool create_vert_elem_adjs = false,
84  bool create_skin_elements = true,
85  bool look_for_scd = false );
86 
87  /**\brief will accept entities all of one dimension and
88  * return entities of n-1 dimension; NOTE: get_vertices argument controls whether
89  * vertices or entities of n-1 dimension are returned, and only one of these is allowed
90  * (i.e. this function returns only vertices or (n-1)-dimensional entities, but not both)
91  * \param entities Pointer to elements for which to find the skin
92  * \param num_entities Number of entities in vector
93  * \param get_vertices If true, vertices on the skin are returned
94  * in the range, otherwise elements are returned
95  * \param output_handles Range holding skin entities returned
96  * \param output_reverse_handles Range holding entities on skin which
97  * are reversed wrt entities
98  * \param create_vert_elem_adjs If true, this function will cause
99  * vertex-element adjacencies to be generated
100  * \param create_skin_elements If true, this function will cause creation
101  * of skin entities, otherwise only skin entities already extant
102  * will be returned
103  */
104  ErrorCode find_skin( const EntityHandle this_set,
105  const EntityHandle* entities,
106  int num_entities,
107  bool get_vertices,
108  Range& output_handles,
109  Range* output_reverse_handles = 0,
110  bool create_vert_elem_adjs = false,
111  bool create_skin_elements = true,
112  bool look_for_scd = false );
113 
114  /**\brief get skin entities of prescribed dimension
115  * \param entities The elements for which to find the skin
116  * \param dim Dimension of skin entities requested
117  * \param skin_entities Range holding skin entities returned
118  * \param create_vert_elem_adjs If true, this function will cause
119  * vertex-element adjacencies to be generated
120  */
121  ErrorCode find_skin( const EntityHandle this_set,
122  const Range& entities,
123  int dim,
124  Range& skin_entities,
125  bool create_vert_elem_adjs = false,
126  bool create_skin_elements = true );
127 
128  ErrorCode classify_2d_boundary( const Range& boundary,
129  const Range& bar_elements,
130  EntityHandle boundary_edges,
131  EntityHandle inferred_edges,
132  EntityHandle non_manifold_edges,
133  EntityHandle other_edges,
134  int& number_boundary_nodes );
135 
136  //! given a skin of dimension 2, will classify and return edges
137  //! as boundary, inferred, and non-manifold, and the rest (other)
138  ErrorCode classify_2d_boundary( const Range& boundary,
139  const Range& mesh_1d_elements,
140  Range& boundary_edges,
141  Range& inferred_edges,
142  Range& non_manifold_edges,
143  Range& other_edges,
144  int& number_boundary_nodes );
145 
146  protected:
147  ErrorCode initialize();
148 
149  ErrorCode deinitialize();
150 
151  ErrorCode find_skin_noadj( const Range& source_entities,
152  Range& forward_target_entities,
153  Range& reverse_target_entities );
154 
155  ErrorCode add_adjacency( EntityHandle entity );
156 
157  void add_adjacency( EntityHandle entity, const EntityHandle* conn, const int num_nodes );
158 
159  ErrorCode remove_adjacency( EntityHandle entity );
160 
161  bool entity_deletable( EntityHandle entity );
162 
163  void find_match( EntityType type,
164  const EntityHandle* conn,
165  const int num_nodes,
166  EntityHandle& match,
167  Skinner::direction& direct );
168 
169  bool connectivity_match( const EntityHandle* conn1,
170  const EntityHandle* conn2,
171  const int num_verts,
172  Skinner::direction& direct );
173 
174  void find_inferred_edges( Range& skin_boundary,
175  Range& candidate_edges,
176  Range& inferred_edges,
177  double reference_angle_degrees );
178 
179  bool has_larger_angle( EntityHandle& entity1, EntityHandle& entity2, double reference_angle_cosine );
180 
181  /**\brief Find vertices on the skin of a set of mesh entities.
182  *\param entities The elements for which to find the skin. Range
183  * may NOT contain vertices, polyhedra, or entity sets.
184  * All elements in range must be of the same dimension.
185  *\param skin_verts Output: the vertices on the skin.
186  *\param skin_elems Optional output: elements representing sides of entities
187  * that are on the skin
188  *\param create_if_missing If skin_elemts is non-null and this is true,
189  * create new elements representing the sides of
190  * entities on the skin. If this is false, skin_elems
191  * will contain only those skin elements that already
192  * exist.
193  */
194  ErrorCode find_skin_vertices( const EntityHandle this_set,
195  const Range& entities,
196  Range* skin_verts = 0,
197  Range* skin_elems = 0,
198  Range* rev_elems = 0,
199  bool create_if_missing = true,
200  bool corners_only = false );
201 
202  /**\brief Skin edges
203  *
204  * Return any vertices adjacent to exactly one of the input edges.
205  */
206  ErrorCode find_skin_vertices_1D( Tag tag, const Range& edges, Range& skin_verts );
207 
208  /**\brief Skin faces
209  *
210  * For the set of face sides (logical edges), return
211  * vertices on such sides and/or edges equivalent to such sides.
212  *\param faces Set of toplogically 2D entities to skin.
213  *\param skin_verts If non-NULL, skin vertices will be added to this container.
214  *\param skin_edges If non-NULL, skin edges will be added to this container
215  *\param reverse_edges If skin_edges is not NULL and this is not NULL, then
216  * any existing skin edges that are reversed with respect
217  * to the skin side will be placed in this range instead of
218  * skin_edges. Note: this argument is ignored if skin_edges
219  * is NULL.
220  *\param create_edges If true, edges equivalent to face sides on the skin
221  * that don't already exist will be created. Note: this
222  * parameter is honored regardless of whether or not skin
223  * edges or vertices are returned.
224  *\param corners_only If true, only skin vertices that correspond to the
225  * corners of sides will be returned (i.e. no higher-order
226  * nodes.) This argument is ignored if skin_verts is NULL.
227  */
228  ErrorCode find_skin_vertices_2D( const EntityHandle this_set,
229  Tag tag,
230  const Range& faces,
231  Range* skin_verts = 0,
232  Range* skin_edges = 0,
233  Range* reverse_edges = 0,
234  bool create_edges = false,
235  bool corners_only = false );
236 
237  /**\brief Skin volume mesh
238  *
239  * For the set of element sides (logical faces), return
240  * vertices on such sides and/or faces equivalent to such sides.
241  *\param entities Set of toplogically 3D entities to skin.
242  *\param skin_verts If non-NULL, skin vertices will be added to this container.
243  *\param skin_faces If non-NULL, skin faces will be added to this container
244  *\param reverse_faces If skin_faces is not NULL and this is not NULL, then
245  * any existing skin faces that are reversed with respect
246  * to the skin side will be placed in this range instead of
247  * skin_faces. Note: this argument is ignored if skin_faces
248  * is NULL.
249  *\param create_faces If true, face equivalent to sides on the skin
250  * that don't already exist will be created. Note: this
251  * parameter is honored regardless of whether or not skin
252  * faces or vertices are returned.
253  *\param corners_only If true, only skin vertices that correspond to the
254  * corners of sides will be returned (i.e. no higher-order
255  * nodes.) This argument is ignored if skin_verts is NULL.
256  */
257  ErrorCode find_skin_vertices_3D( const EntityHandle this_set,
258  Tag tag,
259  const Range& entities,
260  Range* skin_verts = 0,
261  Range* skin_faces = 0,
262  Range* reverse_faces = 0,
263  bool create_faces = false,
264  bool corners_only = false );
265 
266  ErrorCode create_side( const EntityHandle this_set,
267  EntityHandle element,
268  EntityType side_type,
269  const EntityHandle* side_corners,
270  EntityHandle& side_elem_handle_out );
271 
272  bool edge_reversed( EntityHandle face, const EntityHandle edge_ends[2] );
273  bool face_reversed( EntityHandle region, const EntityHandle* face_conn, EntityType face_type );
274 
275  //! look for structured box comprising source_entities, and if one is found use
276  //! structured information to find the skin
277  ErrorCode find_skin_scd( const Range& source_entities,
278  bool get_vertices,
279  Range& output_handles,
280  bool create_skin_elements );
281 
282  //! skin a structured box, taking advantage of structured information
283  ErrorCode skin_box( ScdBox* box, bool get_vertices, Range& output_handles, bool create_skin_elements );
284 };
285 
286 inline ErrorCode Skinner::find_skin( const EntityHandle this_set,
287  const EntityHandle* entities,
288  int num_entities,
289  bool get_vertices,
290  Range& output_handles,
291  Range* output_reverse_handles,
292  bool create_vert_elem_adjs,
293  bool create_skin_elements,
294  bool look_for_scd )
295 {
296  Range ents;
297  std::copy( entities, entities + num_entities, range_inserter( ents ) );
298  return find_skin( this_set, ents, get_vertices, output_handles, output_reverse_handles, create_vert_elem_adjs,
299  create_skin_elements, look_for_scd );
300 }
301 
302 } // namespace moab
303 
304 #endif