Branch data Line data Source code
1 : : /** \class ChollaEngine
2 : : //-------------------------------------------------------------------------
3 : : // Filename : ChollaEngine.hpp
4 : : //
5 : : // Purpose : For a list of facets, builds a topology of
6 : : // surfaces, curves and vertices
7 : : //
8 : : // Special Notes :
9 : : //
10 : : // Creator : Steven J. Owen
11 : : //
12 : : // Date : 4/29/2001
13 : : //
14 : : // Owner : Steven J. Owen
15 : : //-------------------------------------------------------------------------
16 : : */
17 : : #ifndef CHOLLAENGINE_HPP
18 : : #define CHOLLAENGINE_HPP
19 : :
20 : : #include <set>
21 : : #include <map>
22 : : #include <vector>
23 : : #include "DLIList.hpp"
24 : :
25 : : #define FACET_ENTITY_UNINITIALIZED -1
26 : :
27 : : class FacetEntity;
28 : : class ChollaVolume;
29 : : class ChollaCurve;
30 : : class ChollaSurface;
31 : : class ChollaPoint;
32 : : class CubitPoint;
33 : : class CubitFacetEdge;
34 : : class CubitFacet;
35 : : class GMem;
36 : : class ChollaEntity;
37 : : class FacetEvalTool;
38 : : class ChollaMesh;
39 : :
40 : : class ChollaEngine
41 : : {
42 : : public:
43 : : //! Constructor
44 : : ChollaEngine( );
45 : : //! Constructor
46 : : ChollaEngine(DLIList<FacetEntity*> &face_list,
47 : : DLIList<FacetEntity*> &edge_list,
48 : : DLIList<FacetEntity*> &point_list );
49 : : //! Constructor
50 : : ChollaEngine(DLIList<CubitFacet*> &facet_list,
51 : : DLIList<CubitFacetEdge*> &edge_list,
52 : : DLIList<CubitPoint*> &point_list );
53 : :
54 : : //! Constructor
55 : : ChollaEngine(DLIList<CubitFacet*> &facet_list,
56 : : DLIList<CubitFacetEdge*> &edge_list,
57 : : DLIList<CubitPoint*> &point_list,
58 : : DLIList<ChollaVolume *> &cholla_volumes,
59 : : DLIList<ChollaSurface *> &cholla_surfaces,
60 : : DLIList<ChollaCurve *> &cholla_curves,
61 : : DLIList<ChollaPoint *> &cholla_points );
62 : :
63 : : //! Destructor
64 : : ~ChollaEngine();
65 : : void delete_me();
66 : :
67 : : //! Creates the geometry infrastructure based on the given mesh data.
68 : : CubitStatus create_geometry (CubitBoolean use_feature_angle = CUBIT_TRUE,
69 : : double angle = 135.0,
70 : : int interp_order = 0,
71 : : CubitBoolean smooth_non_manifold = CUBIT_TRUE,
72 : : CubitBoolean split_surfaces = CUBIT_FALSE);
73 : :
74 : : void get_volumes( DLIList<ChollaVolume *> & cholla_volume_list )
75 : : { cholla_volume_list += chollaVolumeList; }
76 : 88 : void get_surfaces( DLIList<ChollaSurface *> & cholla_surface_list )
77 : 88 : { cholla_surface_list += chollaSurfaceList; }
78 : 88 : void get_curves( DLIList<ChollaCurve *> & cholla_curve_list )
79 : 88 : { cholla_curve_list += chollaCurveList; }
80 : 88 : void get_points( DLIList<ChollaPoint *> & cholla_point_list )
81 : 88 : { cholla_point_list += chollaPointList; }
82 : :
83 : : void delete_eval_tools();
84 : : //! delete the eval tools associated with the cholla geom entities
85 : : void delete_eval_tools_but_not_facets();
86 : :
87 : :
88 : : // collapses a cholla curve
89 : : CubitStatus collapse_curve( ChollaCurve *cholla_curve, ChollaPoint *point_to_keep );
90 : :
91 : : // disassociate cholla surface
92 : : CubitStatus disassociate_surface( ChollaSurface *cholla_surf );
93 : :
94 : : // collase a cholla surface
95 : : CubitStatus collapse_surface( ChollaSurface *cholla_surface );
96 : :
97 : : // remove functions to update facet entities
98 : : CubitStatus remove_facet_entity( CubitFacet *facet, ChollaSurface *cholla_surf = NULL );
99 : : CubitStatus remove_facet_entity( CubitFacetEdge *facet_edge, ChollaCurve *cholla_curve = NULL);
100 : : CubitStatus remove_facet_entity( CubitPoint *facet_pnt, ChollaPoint *cholla_point = NULL );
101 : : CubitStatus remove_facet_entity( CubitFacet *facet, std::set<ChollaEntity *> &cholla_surfs );
102 : : CubitStatus remove_facet_entity( CubitFacetEdge *facet_edge, std::set<ChollaEntity *> &cholla_curves );
103 : : CubitStatus remove_facet_entity( CubitPoint *facet_pnt, std::set<ChollaEntity *> &cholla_points );
104 : :
105 : : // replace funcctions to update facet entities in cholla entities
106 : : CubitStatus replace_facet_entity( CubitFacetEdge *remove_edge, CubitFacetEdge *replace_edge, std::set<ChollaEntity *> cholla_curves );
107 : :
108 : :
109 : : //! Create the new features by cracking the facets at feature edges.
110 : : //! Creates new edges and points and updates connectivity
111 : :
112 : : static CubitStatus make_features( DLIList<CubitFacetEdge *> &feature_edge_list,
113 : : CubitBoolean split_surfaces );
114 : :
115 : : #ifdef ALPHA_CABLE
116 : : CubitStatus split_surface_at_edges( ChollaSurface* owning_surface,
117 : : DLIList<CubitFacetEdge *> &feature_edge_list,
118 : : DLIList<ChollaCurve*> &cholla_curves,
119 : : DLIList<ChollaSurface*> &cholla_surfaces);
120 : : // given a list of edges, crack the surface.
121 : : #endif
122 : : //! assumes that valid CubitPoint* are supplied
123 : : //! marks the CubitPoints as features to manually break up curves
124 : : //! and surfaces
125 : : static void mark_features (DLIList<CubitPoint*> &feature_points);
126 : : static void mark_features (DLIList<CubitFacetEdge*> &feature_edges);
127 : :
128 : : //! fix the control points so they are C-zero
129 : : static CubitStatus fix_geometry( CubitBoolean smooth_non_manifold,
130 : : CubitBoolean split_surfaces,
131 : : CubitBoolean use_feature_angle,
132 : : double min_dot,
133 : : DLIList <CubitFacetEdge *> &feature_edge_list );
134 : :
135 : : //! ensure facets are all oriented consistently
136 : : //Cubit is not using this anymore.
137 : : static CubitStatus check_all_facet_orientations( DLIList <CubitFacet*> &facet_list,
138 : : CubitBoolean do_flip = CUBIT_FALSE);
139 : :
140 : : //! determine orienation of curve w.r.t. the surface
141 : : static CubitStatus determine_curve_orientation( ChollaSurface *chsurf_ptr,
142 : : ChollaCurve *chcurv_ptr,
143 : : CubitSense & orientation );
144 : :
145 : : static CubitStatus get_facets(GMem& gmem, DLIList<CubitFacet*> &facet_list,
146 : : DLIList<CubitPoint*> &dl_point_list,
147 : : bool insert_null_facets = false);
148 : :
149 : : //set the ChollaEngine to actually flip facets, or to just set a flag
150 : : // when facets need to be reoriented
151 : 55 : void set_flip_flag(CubitBoolean flip){ doFlip = flip; }
152 : :
153 : : void print_me();
154 : : void dump( const char *filename, double angle );
155 : :
156 : : // create cholla curve
157 : : //CubitStatus create_curve( int block_id, ChollaPoint *new_ch_pnt0, ChollaPoint *new_ch_pnt1, ChollaCurve *&new_ch_curve );
158 : : CubitStatus create_curve( int block_id,
159 : : ChollaPoint *new_ch_pnt0,
160 : : ChollaPoint *new_ch_pnt1,
161 : : ChollaCurve *&new_ch_curve
162 : : );
163 : :
164 : :
165 : :
166 : : CubitStatus create_point( CubitPoint *pnt, ChollaPoint *&new_ch_pnt );
167 : :
168 : : CubitStatus create_surface( int block_id,
169 : : ChollaSurface *&new_ch_surf );
170 : :
171 : : // disassoicate ch_curve from ch_points, ch_curve, ch_surf, and ch_engine
172 : : CubitStatus disassociate_curve( ChollaCurve *ch_curve,
173 : : bool disassociate_with_vert = true,
174 : : bool disassociate_with_surf = true,
175 : : bool disassociate_with_model = true );
176 : : // remove a cholla sub-entities
177 : 0 : void remove_curve( ChollaCurve *ch_curve ){ chollaCurveList.remove( ch_curve ); }
178 : 0 : void remove_surface( ChollaSurface *ch_surface ){ chollaSurfaceList.remove( ch_surface ); }
179 : 0 : void remove_point( ChollaPoint *ch_pnt ){ chollaPointList.remove( ch_pnt ); }
180 : :
181 : : // Create independent manifold volumes from the non-manifold set
182 : : CubitStatus detach_volumes();
183 : :
184 : : //! From the facet surface list, create geometric surface,
185 : : //! loops and coedges for each surface in the list
186 : : CubitStatus build_surface_and_curve_eval_tools( DLIList<ChollaSurface*> &cholla_surface_list,
187 : : int interp_order, double min_dot);
188 : :
189 : : CubitStatus rebuild_surface_and_curve_eval_tools(DLIList<ChollaSurface*> &cholla_surface_list,
190 : : int interp_order, double min_dot);
191 : :
192 : : // verify the connectivity between points and curves
193 : : CubitStatus verify_points_to_curves();
194 : :
195 : : //calls private build_eval_tools function
196 : : CubitStatus build_eval_tools();
197 : :
198 : : // merges two points
199 : : CubitStatus merge_two_points( ChollaPoint *point_to_keep, ChollaPoint *point_to_del );
200 : :
201 : : private:
202 : :
203 : : DLIList<FacetEntity*> faceList;
204 : : DLIList<FacetEntity*> edgeList;
205 : : DLIList<FacetEntity*> pointList;
206 : : DLIList<ChollaVolume*> chollaVolumeList;
207 : : DLIList<ChollaSurface*> chollaSurfaceList;
208 : : DLIList<ChollaCurve*> chollaCurveList;
209 : : DLIList<ChollaPoint*> chollaPointList;
210 : :
211 : : DLIList<ChollaCurve*> *hashCurveArray;
212 : : int hashCurveSize;
213 : : DLIList<ChollaPoint*> *hashPointArray;
214 : : int hashPointSize;
215 : : //boolean to determine whether flip the facets (when needed) or set
216 : : // the isBackwards flag.
217 : : CubitBoolean doFlip;
218 : :
219 : : void set_up_tool_datas( );
220 : : void delete_tool_datas( );
221 : :
222 : : //! returns the dimension of the facet entity.
223 : : int facet_dimension(FacetEntity *facet_ptr);
224 : :
225 : : //! creates the correct facetsurfaces for all the element blocks.
226 : : CubitStatus create_volume_boundaries( DLIList<ChollaSurface*> &facet_surface_sheets,
227 : : CubitBoolean use_feature_angle,
228 : : double min_dot,
229 : : CubitBoolean split_surfaces );
230 : :
231 : : //! creates the correct blockcurves for all the surfaces
232 : : CubitStatus create_surface_boundaries( DLIList<ChollaSurface*> &cholla_surface_list,
233 : : DLIList<ChollaCurve*> &cholla_curve_list,
234 : : CubitBoolean use_feature_angle,
235 : : double min_dot );
236 : :
237 : : //! creates the correct blockpoints for all the curves
238 : : CubitStatus create_curve_boundaries( DLIList<ChollaCurve*> &cholla_curve_list,
239 : : DLIList<ChollaPoint*> &cholla_point_list );
240 : :
241 : : //! sorts a edge into its correct curve based on its associated
242 : : //! blocks and sidesets. Creates a new facet curve if necessary.
243 : : CubitStatus classify_edge( FacetEntity *edge_ptr,
244 : : DLIList<ChollaCurve*> &cholla_curve_list,
245 : : ChollaSurface *fsm_ptr );
246 : :
247 : : //! sorts a node into correct point based on its associated
248 : : //! curve. Creates a new facet point if necessary
249 : : CubitStatus classify_point(CubitPoint *point_ptr,
250 : : DLIList<ChollaPoint*> &cholla_point_list,
251 : : ChollaCurve *fcm_ptr );
252 : :
253 : : //! build the CUBIT geometry based on the Facet entity class lists
254 : : CubitStatus build_eval_tools( DLIList<ChollaSurface*> &cholla_surface_list,
255 : : DLIList<ChollaCurve*> &cholla_curve_list,
256 : : int interp_order,
257 : : CubitBoolean use_feature_angle,
258 : : double min_dot,
259 : : CubitBoolean smooth_non_manifold ,
260 : : CubitBoolean split_surfaces );
261 : : //! build the CUBIT geometry based on the Facet entity class lists
262 : : //! From the facet curve list, create geometric curves for each
263 : : CubitStatus build_curve_eval_tools( DLIList<ChollaCurve*> &cholla_curve_list,
264 : : int interp_order );
265 : :
266 : :
267 : : //! functions for hashing curves - to speed up edge classification
268 : : CubitStatus init_hash_curves( );
269 : : void delete_hash_curves( );
270 : : int get_curve_hash_key( DLIList<ChollaSurface*> *bsm_list_ptr );
271 : :
272 : : //! functions for hashing points - to speed up node classification
273 : : CubitStatus init_hash_points( );
274 : : void delete_hash_points( );
275 : : int get_point_hash_key( DLIList<ChollaCurve*> *bsm_list_ptr );
276 : :
277 : : //! fix the edge control points and the normals so they are conforming
278 : : //! (or non-conforming) accross curves
279 : : CubitStatus clean_geometry( CubitBoolean smooth_non_manifold,
280 : : CubitBoolean split_surfaces,
281 : : CubitBoolean use_feature_angle,
282 : : double min_dot,
283 : : DLIList <ChollaCurve *> &cholla_curve_list );
284 : :
285 : :
286 : : //! make sure the facets are oriented consistently
287 : : static CubitStatus check_facet_orientation( CubitFacet *facet,
288 : : CubitBoolean do_flip,
289 : : int &nfacets, int mydebug = 0 );
290 : :
291 : : //! split the surface facets at a point if required based on features.
292 : : //! Create new points and edges as needed
293 : : static CubitStatus crack_open_point( CubitPoint *point_ptr, int mydebug );
294 : :
295 : : //! does the same as crack_open_point, but does not create new facet entities
296 : : //! at surface boundaries. Instead, it creates facet boundary tooldatas
297 : : //! to hold the additional control point and normal data
298 : : static CubitStatus insert_discontinuity_at_point( CubitPoint *point_ptr );
299 : :
300 : : //! recursive function - returns a list of facets adjacent to
301 : : //! a point that are bounded by feature edges
302 : : static CubitStatus get_facets_at_point( CubitPoint *point_ptr,
303 : : CubitFacet *facet_ptr,
304 : : DLIList<CubitFacet *> &facet_list,
305 : : DLIList<CubitFacetEdge *> &feature_edge_list );
306 : : //! fix control points on a single edge and its partners
307 : : static CubitStatus fix_edge( CubitFacetEdge *edge_ptr,
308 : : DLIList<CubitFacet *> &update_facet_list );
309 : : static CubitStatus fix_split_edge( CubitFacetEdge *edge_ptr,
310 : : DLIList<CubitFacet *> &update_facet_list );
311 : :
312 : : //! fix normals at non-manifold edges to maintain
313 : : //! continuity across facets that don't meet feature angle criteria
314 : : static CubitStatus fix_split_non_manifold_edge( CubitFacetEdge *edge_ptr,
315 : : double min_dot,
316 : : DLIList <CubitPoint *> &changed_points );
317 : : static CubitStatus fix_non_manifold_edge( CubitFacetEdge *edge_ptr,
318 : : double min_dot,
319 : : DLIList <CubitPoint *> &changed_points );
320 : :
321 : : //! update the edge control points at all edges connected to points
322 : : //! in point_list
323 : : static CubitStatus update_edges_at_points( CubitBoolean split_surfaces,
324 : : DLIList<CubitPoint *> &point_list,
325 : : DLIList<CubitFacet *> &facet_update_list,
326 : : double mindot );
327 : : //! set the normals on two points so they are the same
328 : : static CubitStatus merge_normals( CubitPoint *pt0, CubitPoint *pt1);
329 : :
330 : :
331 : : // given a non-manifold surface in a cholla model, create a copy and update child entities
332 : : CubitStatus detach_surfaces(DLIList<ChollaSurface*> &chsurfs,
333 : : DLIList<ChollaCurve*> &chcurves,
334 : : ChollaVolume *detaching_volume,
335 : : std::map<ChollaSurface *, ChollaSurface *> &surf_map,
336 : : std::map<ChollaCurve *, ChollaCurve *> &curve_map,
337 : : std::map<ChollaPoint *, ChollaPoint *> &point_map);
338 : :
339 : : CubitStatus detach_curves( DLIList<ChollaCurve*> &curves,
340 : : ChollaVolume *detaching_volume,
341 : : std::map<ChollaCurve *, ChollaCurve *> &curve_map,
342 : : std::map<ChollaPoint *, ChollaPoint *> &point_map );
343 : :
344 : : CubitStatus detach_curve(ChollaCurve *chcurv_ptr,
345 : : DLIList<ChollaSurface*> &new_surfs,
346 : : ChollaVolume *chvol2_ptr,
347 : : std::map<ChollaCurve*, ChollaCurve*> &curve_map,
348 : : std::map<ChollaPoint*, ChollaPoint*> &point_map );
349 : :
350 : : CubitStatus detach_point(ChollaPoint *chpt_ptr,
351 : : ChollaVolume *chvol2_ptr,
352 : : std::map<ChollaPoint*, ChollaPoint*> &point_map,
353 : : std::map<ChollaCurve*, ChollaCurve*> &curve_map );
354 : :
355 : : // Create independent manifold volumes from the non-manifold set
356 : : CubitStatus detach_facets( DLIList<ChollaSurface*> &chsurfs,
357 : : DLIList<ChollaCurve*> &chcurves,
358 : : ChollaVolume *chvol,
359 : : std::map<ChollaSurface *, ChollaSurface *> &surf_map,
360 : : std::map<ChollaCurve *, ChollaCurve *> &curve_map,
361 : : std::map<ChollaPoint *, ChollaPoint *> &point_map);
362 : :
363 : : CubitStatus detach_facet_edges(DLIList<ChollaCurve*> &chcurves,
364 : : ChollaVolume *detaching_volume,
365 : : std::map<ChollaCurve *, ChollaCurve *> &curve_map,
366 : : std::map<ChollaPoint *, ChollaPoint *> &point_map);
367 : :
368 : : CubitStatus copy_facets_at_interface(DLIList<ChollaSurface*> &chsurfs,
369 : : DLIList<ChollaCurve*> &chcurves,
370 : : std::vector<CubitPoint *> &new_points,
371 : : std::vector<CubitFacetEdge *> &new_edges,
372 : : std::map<ChollaSurface *, ChollaSurface *> &surf_map,
373 : : std::map<ChollaCurve *, ChollaCurve *> &curve_map,
374 : : std::map<ChollaPoint *, ChollaPoint *> &point_map);
375 : :
376 : : CubitStatus copy_facet_edges_at_interface(DLIList<ChollaCurve*> &chcurves,
377 : : std::vector<CubitPoint *> &new_points,
378 : : std::vector<CubitFacetEdge *> &new_edges,
379 : : std::map<ChollaCurve *, ChollaCurve *> &curve_map,
380 : : std::map<ChollaPoint *, ChollaPoint *> &point_map);
381 : :
382 : : CubitStatus copy_points_at_interface(DLIList<FacetEntity *> &facet_list,
383 : : std::vector<CubitPoint *> &new_points,
384 : : std::map<ChollaSurface *, ChollaSurface *> &surf_map,
385 : : std::map<ChollaCurve *, ChollaCurve *> &curve_map,
386 : : std::map<ChollaPoint *, ChollaPoint *> &point_map);
387 : : CubitStatus copy_edges_at_interface(DLIList<FacetEntity *> &facet_list,
388 : : std::vector<CubitPoint *> &new_points,
389 : : std::vector<CubitFacetEdge *> &new_edges,
390 : : std::map<ChollaSurface *, ChollaSurface *> &surf_map,
391 : : std::map<ChollaCurve *, ChollaCurve *> &curve_map,
392 : : std::map<ChollaPoint *, ChollaPoint *> &point_map);
393 : :
394 : : // detach the facets from original points and edges and reattach to new copy
395 : : CubitStatus connect_facets_at_interface(DLIList<ChollaSurface*> &chsurfs,
396 : : DLIList<ChollaCurve*> &churves,
397 : : ChollaVolume *chvol_ptr,
398 : : std::vector<CubitPoint *> &new_points,
399 : : std::vector<CubitFacetEdge *> &new_edges);
400 : : CubitStatus connect_points_at_interface(ChollaCurve *chcurv_ptr,
401 : : ChollaVolume *chvol_ptr,
402 : : std::vector<CubitPoint *> &new_points);
403 : : CubitStatus connect_edges_at_interface(ChollaCurve *chcurv_ptr,
404 : : ChollaVolume *chvol_ptr,
405 : : std::vector<CubitFacetEdge *> &new_edges);
406 : :
407 : : // update the ownenrship of the new detached facet entity based uponthe map set up in detach_volumes
408 : : CubitStatus set_new_facet_owners(int type, //0, 1, or 2 based on dimension of facet entity
409 : : FacetEntity *fe_ptr, FacetEntity *newfe_ptr,
410 : : std::map<ChollaSurface *, ChollaSurface *> &surf_map,
411 : : std::map<ChollaCurve *, ChollaCurve *> &curve_map,
412 : : std::map<ChollaPoint *, ChollaPoint *> &point_map );
413 : :
414 : : // set the end points of the curves that are adjacent to the interface surface
415 : : CubitStatus set_curve_endpoints(std::map<ChollaPoint*, ChollaPoint*> &point_map,
416 : : std::map<ChollaCurve*, ChollaCurve*> &curve_map );
417 : :
418 : : };
419 : :
420 : : #endif
421 : :
422 : :
|
