Branch data Line data Source code
1 : : //- Class: ChollaSurface
2 : : //- Description: Temporary class for constructing the facet-based geometry
3 : : //-
4 : : //- Owner: Steven J. Owen
5 : : //- Checked by:
6 : : //- Version:
7 : : #include "ChollaSurface.hpp"
8 : : #include "ChollaCurve.hpp"
9 : : #include "ChollaPoint.hpp"
10 : : #include "TDGeomFacet.hpp"
11 : : #include "CastTo.hpp"
12 : : #include "CubitPoint.hpp"
13 : : #include "CubitFacet.hpp"
14 : : #include "CubitFacetData.hpp"
15 : : #include "CubitFacetEdge.hpp"
16 : : #include "CubitPointData.hpp"
17 : : #include "CubitFacetEdgeData.hpp"
18 : : #include "ChollaDebug.hpp"
19 : : #include "TDFacetBoundaryPoint.hpp"
20 : : #include "TDFacetBoundaryEdge.hpp"
21 : : #include "GfxDebug.hpp"
22 : : #include "FacetEvalTool.hpp"
23 : : #include "FacetDataUtil.hpp"
24 : :
25 : : //===============================================================================
26 : : //Function: ChollaSurface (PUBLIC) (constructor)
27 : : //===============================================================================
28 [ + - ][ + - ]: 682 : ChollaSurface::ChollaSurface(int block_id)
[ + - ]
29 : : {
30 : : static int count = 100;
31 : 341 : id = count++;
32 : 341 : myFlag = CUBIT_FALSE;
33 : 341 : mySurface = NULL;
34 : 341 : myEvalTool = NULL;
35 : 341 : blockId = block_id;
36 : 341 : myMergePartner = NULL;
37 : 341 : }
38 : : //===============================================================================
39 : : //Function: ~ChollaSurface (PUBLIC) (destructor)
40 : : //===============================================================================
41 [ + - ][ + - ]: 1023 : ChollaSurface::~ChollaSurface()
[ + - ]
42 : : {
43 [ - + ]: 682 : }
44 : :
45 : : //===========================================================================
46 : : //Function Name: check_faceting
47 : : //
48 : : //Member Type: PRIVATE
49 : : //Descriptoin: check the edge/face orientations
50 : : //===========================================================================
51 : 0 : void ChollaSurface::check_faceting()
52 : : {
53 : :
54 : 0 : }
55 : :
56 : :
57 : : //=============================================================================
58 : : //Function: split_surface (PUBLIC)
59 : : //Description: split this surface into multiple ChollaSurface where there are
60 : : // discontinuous faces.
61 : : //Author: sjowen
62 : : //Date: 12/22/00
63 : : //=============================================================================
64 : 88 : CubitStatus ChollaSurface::split_surface(
65 : : DLIList<ChollaSurface*> &facet_surface_list
66 : : )
67 : : {
68 [ + - ]: 88 : DLIList<ChollaSurface*> new_surface_list;
69 : 88 : CubitStatus stat = CUBIT_SUCCESS;
70 : :
71 : : // Go through the surfaceElemList and pull faces off one by one as we
72 : : // determine which surface it belongs to. Continue until we have depleted
73 : : // the list
74 : :
75 : : int jj;
76 : 88 : int mydebug = 0;
77 : 88 : int num_surfs_created = 0;
78 [ + - ][ + - ]: 341 : while( surfaceElemList.size() > 0)
79 : : {
80 : :
81 : : // start with the first face and create a list of all elements
82 : : // attached to the face
83 : :
84 [ + - ]: 341 : DLIList<FacetEntity*> face_list;
85 [ + - ]: 341 : FacetEntity *start_face_ptr = surfaceElemList.get_and_step();
86 [ + - ]: 341 : stat = get_adj_facets( start_face_ptr, face_list, mydebug );
87 [ - + ]: 341 : if (stat != CUBIT_SUCCESS)
88 : 0 : return stat;
89 : :
90 : : // if we have the same number of faces on the face_list as we do
91 : : // on the surfaceElemList, then we are done. This surface is
92 : : // not multiply connected. Oherwise continue...
93 : :
94 [ + - ][ + - ]: 341 : if (face_list.size() == surfaceElemList.size())
[ + + ]
95 : : {
96 : :
97 : : // if this surface had a curve already defined (its a 2D topology
98 : : // defined in skin2D) then its no longer valid if the surface was split
99 : : // (for 3D the curves aren't defined until later)
100 : :
101 [ + + ][ + - ]: 88 : if (num_surfs_created > 0 && curveList.size() > 0)
[ + - ][ + + ]
102 : : {
103 [ + - ]: 55 : ChollaCurve *fcm_ptr = curveList.get(); // there should only be 1
104 [ + - ]: 55 : curveList.remove();
105 [ + - ]: 55 : fcm_ptr->remove_td_associativity( this );
106 [ + - ][ + - ]: 55 : delete fcm_ptr;
107 : : }
108 : 88 : return CUBIT_SUCCESS;
109 : : }
110 : :
111 : : // create a new surface to hold the face info
112 : :
113 : 253 : num_surfs_created++;
114 [ + - ][ + - ]: 253 : ChollaSurface *fsm_ptr = new ChollaSurface( blockId );
115 [ + - ]: 253 : facet_surface_list.append( fsm_ptr );
116 : :
117 : : // update the geometric curve pointer
118 : :
119 [ + - ]: 253 : fsm_ptr->assign_geometric_surface( NULL );
120 : :
121 : : // add the faces to this surface and update the surface
122 : : // pointers in the face tool data
123 : :
124 : : // surfaceElemList: nullify the items then compress the list
125 : : // afterwards, instead of removing the items one by one, for
126 : : // speed.
127 [ + - ][ + + ]: 1144 : for (jj=face_list.size(); jj > 0; jj--)
[ + - ][ + + ]
128 : : {
129 [ + - ]: 803 : FacetEntity *face_ptr = face_list.get_and_step();
130 [ + - ]: 803 : TDGeomFacet *td_gm_face = TDGeomFacet::get_geom_facet(face_ptr);
131 [ + - ]: 803 : td_gm_face->remove_cholla_surf( this );
132 [ + - ]: 803 : td_gm_face->add_cholla_surf( fsm_ptr );
133 [ + - ]: 803 : surfaceElemList.move_to_nearby( face_ptr );
134 [ + - ]: 803 : surfaceElemList.extract();
135 [ + - ]: 803 : fsm_ptr->add_facet( face_ptr );
136 : : }
137 : 341 : }
138 : :
139 [ + - ]: 88 : return CUBIT_SUCCESS;
140 : : }
141 : :
142 : :
143 : : #if 0
144 : : //=============================================================================
145 : : //Function: get_adj_facets (PRIVATE)
146 : : //Description: recursive funstion that creates a list of all faces connected
147 : : // the passed in face
148 : : //Author: sjowen
149 : : //Date: 12/22/00
150 : : //=============================================================================
151 : : CubitStatus ChollaSurface::get_adj_facets(
152 : : FacetEntity *start_face_ptr,
153 : : DLIList<FacetEntity*> &face_list,
154 : : int mydebug)
155 : : {
156 : : CubitStatus stat = CUBIT_SUCCESS;
157 : :
158 : : // add this face to the list
159 : :
160 : : if (mydebug)
161 : : {
162 : : //start_face_ptr->draw( CUBIT_RED_INDEX );
163 : : //CDrawingTool::instance()->flush();
164 : : }
165 : : face_list.append( start_face_ptr );
166 : : TDGeomFacet *td_gm_face = TDGeomFacet::get_geom_facet(start_face_ptr);
167 : : td_gm_face->set_hit_flag( 0 );
168 : :
169 : : // loop through its edges
170 : :
171 : : CubitFacetEdge *edge_ptr;
172 : : FacetEntity *face_ptr;
173 : : DLIList<CubitFacetEdge*> edge_list;
174 : : start_face_ptr->edges( edge_list );
175 : : int ii;
176 : : for (ii=0; ii<edge_list.size(); ii++)
177 : : {
178 : : edge_ptr = edge_list.get_and_step();
179 : :
180 : : // edges that already have a tool data defined are the result
181 : : // of a feature angle. Don't traverse past a feature angle edge
182 : :
183 : : TDGeomFacet *td_gm_edge = TDGeomFacet::get_geom_facet(edge_ptr);
184 : : if (td_gm_edge == NULL)
185 : : {
186 : : DLIList<FacetEntity*> adj_face_list;
187 : : edge_ptr->get_parents( adj_face_list );
188 : :
189 : : // keep traversing only if there are two adjacent faces to this edge,
190 : : // otherwise, this is a boundary
191 : :
192 : : if (adj_face_list.size() == 2)
193 : : {
194 : : face_ptr = adj_face_list.get_and_step();
195 : : if (face_ptr == start_face_ptr)
196 : : face_ptr = adj_face_list.get();
197 : :
198 : : // go to its neighbor if it is part of the surface
199 : :
200 : : td_gm_face = TDGeomFacet::get_geom_facet(face_ptr);
201 : : if (td_gm_face->get_hit_flag() == id)
202 : : {
203 : : stat = get_adj_facets( face_ptr, face_list, mydebug );
204 : : if (stat != CUBIT_SUCCESS)
205 : : return stat;
206 : : }
207 : : }
208 : : }
209 : : }
210 : : return stat;
211 : : }
212 : : #endif
213 : :
214 : : //=============================================================================
215 : : //Function: get_adj_facets (PRIVATE)
216 : : //Description: non recursive function that creates a list of all facets connected
217 : : // to the passed in facet
218 : : //Author: sjowen
219 : : //Date: 12/22/00
220 : : //=============================================================================
221 : 341 : CubitStatus ChollaSurface::get_adj_facets(
222 : : FacetEntity *start_face_ptr,
223 : : DLIList<FacetEntity*> &face_list,
224 : : int mydebug,
225 : : bool bound_check,
226 : : bool feature_edge_check)
227 : : {
228 : : //int found = 0;
229 : : int ii;
230 : 341 : CubitStatus stat = CUBIT_SUCCESS;
231 [ + - ]: 341 : DLIList<FacetEntity*> temp_list;
232 : 341 : FacetEntity *face_ptr = NULL;
233 : 341 : FacetEntity *adj_face_ptr = NULL;
234 [ + - ][ + - ]: 682 : DLIList<CubitFacetEdge *>edge_list;
235 : 341 : CubitFacetEdge *edge_ptr = NULL;
236 [ + - ][ + - ]: 682 : DLIList<FacetEntity *>adj_face_list;
237 : :
238 [ - + ]: 341 : if (mydebug)
239 : : {
240 [ # # ][ # # ]: 0 : for(ii=0; ii<surfaceElemList.size(); ii++)
241 : : {
242 [ # # ]: 0 : face_ptr = surfaceElemList.get_and_step();
243 [ # # ]: 0 : TDGeomFacet *td_gm_face = TDGeomFacet::get_geom_facet(face_ptr);
244 [ # # ][ # # ]: 0 : PRINT_INFO("%d ", td_gm_face->get_hit_flag());
[ # # ][ # # ]
[ # # ]
245 [ # # ]: 0 : if (ii%10 == 0)
246 : : {
247 [ # # ][ # # ]: 0 : PRINT_INFO("\n");
[ # # ][ # # ]
248 : : }
249 : : }
250 : : }
251 : :
252 : : // add this face to the list
253 : :
254 [ + - ]: 341 : temp_list.append( start_face_ptr );
255 [ + - ]: 341 : TDGeomFacet *td_gm_face = TDGeomFacet::get_geom_facet(start_face_ptr);
256 [ + - ]: 341 : td_gm_face->set_hit_flag( 0 );
257 : :
258 [ + - ][ + + ]: 1397 : while (temp_list.size())
259 : : {
260 [ + - ]: 1056 : face_ptr = temp_list.pop();
261 [ + - ]: 1056 : td_gm_face = TDGeomFacet::get_geom_facet(face_ptr);
262 [ + - ][ + - ]: 1056 : if (td_gm_face->get_hit_flag() == 0)
263 : : {
264 [ + - ]: 1056 : face_list.append( face_ptr );
265 [ - + ]: 1056 : if (mydebug)
266 : : {
267 [ # # ]: 0 : face_ptr->debug_draw( CUBIT_RED_INDEX );
268 [ # # ]: 0 : GfxDebug::flush();
269 : : }
270 [ + - ]: 1056 : edge_list.clean_out();
271 [ + - ]: 1056 : face_ptr->edges( edge_list );
272 [ + - ][ + + ]: 4224 : for (ii=0; ii<edge_list.size(); ii++)
273 : : {
274 [ + - ]: 3168 : edge_ptr = edge_list.get_and_step();
275 : :
276 : : // edges that already have a tool data defined are the result
277 : : // of a feature angle. Don't traverse past a feature angle edge
278 : :
279 [ + - ]: 3168 : TDGeomFacet *td_gm_edge = TDGeomFacet::get_geom_facet(edge_ptr);
280 [ + + ][ - + ]: 3168 : if (td_gm_edge == NULL || !feature_edge_check )
281 : : {
282 [ + - ]: 1892 : adj_face_list.clean_out();
283 [ + - ]: 1892 : edge_ptr->get_parents( adj_face_list );
284 : :
285 : : // keep traversing only if there are two adjacent faces to this edge,
286 : : // otherwise, this is a boundary
287 : :
288 [ + - ][ - + ]: 1892 : if (adj_face_list.size() != 2)
289 : : {
290 : 0 : continue;
291 : : }
292 : :
293 [ - + ]: 1892 : if( bound_check )
294 : : {
295 [ # # ]: 0 : TDFacetBoundaryEdge *td_facet_bnd_edge = TDFacetBoundaryEdge::get_facet_boundary_edge( edge_ptr );
296 [ # # ]: 0 : if( td_facet_bnd_edge )
297 : 0 : continue;
298 : : }
299 : :
300 [ + - ]: 1892 : adj_face_ptr = adj_face_list.get_and_step();
301 [ + + ]: 1892 : if (adj_face_ptr == face_ptr)
302 [ + - ]: 946 : adj_face_ptr = adj_face_list.get();
303 : :
304 : : // go to its neighbor if it is part of the surface
305 : :
306 [ + - ]: 1892 : td_gm_face = TDGeomFacet::get_geom_facet(adj_face_ptr);
307 [ + - ][ + + ]: 1892 : if (td_gm_face->get_hit_flag() == id)
308 : : {
309 [ + - ]: 715 : temp_list.append( adj_face_ptr );
310 [ + - ]: 715 : td_gm_face->set_hit_flag( 0 );
311 : : }
312 : :
313 : : }
314 : : }
315 : : }
316 : : }
317 [ + - ]: 341 : return stat;
318 : : }
319 : :
320 : :
321 : :
322 : : //=============================================================================
323 : : //Function: feature_angle (PRIVATE)
324 : : //Description: mark all edges that exceed the specified feature angle
325 : : // min_dot is the minimum dot product between adjacent face normals
326 : : //Author: sjowen
327 : : //Date: 12/22/00
328 : : //=============================================================================
329 : 44 : CubitStatus ChollaSurface::feature_angle(
330 : : double min_dot,
331 : : DLIList<CubitFacetEdge *> &feature_edge_list)
332 : : {
333 : : //CubitStatus stat = CUBIT_SUCCESS;
334 : : int ii, jj;
335 : :
336 : : // compute face normals
337 : 44 : int mydebug = 0;
338 : : double dot;
339 [ + - ][ + - ]: 44 : CubitVector face_normal, adj_face_normal;
340 : : FacetEntity *face_ptr, *adj_face_ptr;
341 : : TDGeomFacet *td_gm_face;
342 : : CubitFacet *tri_ptr;
343 [ + - ][ + + ]: 968 : for (ii=0; ii<surfaceElemList.size(); ii++)
344 : : {
345 [ + - ]: 924 : face_ptr = surfaceElemList.get_and_step();
346 [ + - ]: 924 : td_gm_face = TDGeomFacet::get_geom_facet(face_ptr);
347 [ - + ]: 924 : tri_ptr = CAST_TO( face_ptr, CubitFacet );
348 [ + - ][ + - ]: 924 : face_normal = tri_ptr->normal( );
349 [ + - ]: 924 : face_normal.normalize();
350 [ + - ]: 924 : td_gm_face->set_normal( face_normal );
351 : : }
352 : :
353 : : // check adjacencies and compute the dot product between them
354 : : // where dot product is less than the min_dot, create a tool data
355 : : // on the edge
356 : :
357 [ - + ]: 44 : if(mydebug)
358 [ # # ]: 0 : GfxDebug::clear();
359 [ + - ][ + + ]: 968 : for (ii=0; ii<surfaceElemList.size(); ii++)
360 : : {
361 [ + - ]: 924 : face_ptr = surfaceElemList.get_and_step();
362 [ - + ]: 924 : CubitFacet* curr_facet = CAST_TO(face_ptr, CubitFacet);
363 : 924 : CubitFacet* temp_facet = NULL;
364 [ + - ]: 924 : double curr_area=curr_facet->area();
365 [ + - ]: 924 : td_gm_face = TDGeomFacet::get_geom_facet(face_ptr);
366 [ + - ][ + - ]: 924 : face_normal = td_gm_face->get_normal();
367 [ + - ]: 924 : DLIList<CubitFacetEdge*> edge_list;
368 [ + - ]: 924 : face_ptr->edges( edge_list );
369 [ + - ][ + + ]: 3696 : for (jj=0; jj<edge_list.size(); jj++)
370 : : {
371 [ + - ]: 2772 : CubitFacetEdge *edge_ptr = edge_list.get_and_step();
372 [ + - ]: 2772 : TDGeomFacet *td_gm_edge = TDGeomFacet::get_geom_facet(edge_ptr);
373 [ + + ]: 2772 : if (!td_gm_edge)
374 : : {
375 [ + - ]: 2244 : DLIList<FacetEntity*> adj_face_list;
376 [ + - ]: 2244 : edge_ptr->get_parents( adj_face_list );
377 : :
378 : : // it has to be an internal edge - ignore boundaries
379 [ + - ][ + - ]: 2244 : if (adj_face_list.size() == 2)
380 : : {
381 [ + - ]: 2244 : adj_face_ptr = adj_face_list.get_and_step();
382 : :
383 [ + + ]: 2244 : if (adj_face_ptr == face_ptr)
384 [ + - ]: 1320 : adj_face_ptr = adj_face_list.get();
385 [ + - ]: 2244 : td_gm_face = TDGeomFacet::get_geom_facet(adj_face_ptr);
386 : :
387 : : // make sure the adj face is on the same surface
388 : :
389 [ + - ][ + - ]: 2244 : if (td_gm_face->get_hit_flag() == id)
390 : : {
391 : :
392 : : // test the dot product between normals
393 : :
394 [ + - ][ + - ]: 2244 : adj_face_normal = td_gm_face->get_normal();
395 [ - + ]: 2244 : temp_facet = CAST_TO(adj_face_ptr, CubitFacet);
396 [ + - ]: 2244 : double adj_area=temp_facet->area();
397 : : //mbrewer:: ensure no NULL
398 [ + - ]: 2244 : dot = adj_face_normal % face_normal;
399 : 2244 : bool add_an_edge = true;
400 [ - + ]: 2244 : if(mydebug){
401 [ # # ][ # # ]: 0 : PRINT_INFO("This area %f, other %f\n",curr_area,adj_area);
[ # # ][ # # ]
402 : : }
403 [ - + ]: 2244 : if(curr_area<(1.e-10*adj_area)){
404 [ # # ]: 0 : DLIList<CubitFacetEdge*> edge_list_tmp;
405 : 0 : CubitFacetEdge* edge_ptr_tmp=NULL;
406 [ # # ]: 0 : curr_facet->edges(edge_list_tmp);
407 [ # # ]: 0 : double edge_length = edge_ptr->length();
408 : 0 : int k = 0;
409 [ # # ][ # # ]: 0 : if(edge_list_tmp.size()>0)
410 : 0 : add_an_edge=false;
411 [ # # ][ # # ]: 0 : for(k=edge_list_tmp.size();k>0;k--){
412 [ # # ]: 0 : edge_ptr_tmp=edge_list_tmp.get_and_step();
413 [ # # ][ # # ]: 0 : if(edge_ptr_tmp != edge_ptr &&
[ # # ]
414 [ # # ]: 0 : edge_ptr_tmp->length() > edge_length){
415 : 0 : add_an_edge=true;
416 : : }
417 [ # # ]: 0 : }
418 : : }
419 [ - + ]: 2244 : if(adj_area<(1.e-10*curr_area))
420 : : {
421 [ # # ]: 0 : DLIList<CubitFacetEdge*> edge_list_tmp;
422 : 0 : CubitFacetEdge* edge_ptr_tmp=NULL;
423 [ # # ]: 0 : temp_facet->edges(edge_list_tmp);
424 [ # # ]: 0 : double edge_length = edge_ptr->length();
425 : 0 : int k = 0;
426 [ # # ][ # # ]: 0 : if(edge_list_tmp.size()>0)
427 : 0 : add_an_edge=false;
428 [ # # ][ # # ]: 0 : for(k=edge_list_tmp.size();k>0;k--){
429 [ # # ]: 0 : edge_ptr_tmp=edge_list_tmp.get_and_step();
430 [ # # ][ # # ]: 0 : if(edge_ptr_tmp != edge_ptr &&
[ # # ]
431 [ # # ]: 0 : edge_ptr_tmp->length() > edge_length){
432 : 0 : add_an_edge=true;
433 : : }
434 [ # # ]: 0 : }
435 : : }
436 [ + + ][ + - ]: 2244 : if (dot <= min_dot && add_an_edge )
437 : : {
438 [ - + ]: 528 : if(mydebug){
439 [ # # ]: 0 : edge_ptr->debug_draw(CUBIT_MAGENTA_INDEX);
440 : : }
441 [ + - ]: 528 : TDGeomFacet::add_geom_facet(edge_ptr, -1);
442 [ + - ]: 528 : td_gm_edge = TDGeomFacet::get_geom_facet(edge_ptr);
443 [ + - ]: 528 : edge_ptr->set_as_feature();
444 [ + - ]: 2244 : feature_edge_list.append( edge_ptr );
445 : : }
446 : : }
447 : : }
448 : :
449 : : // non-manifold edges (edges with more than 2 adj facets)
450 : : // must be features
451 : :
452 [ # # ][ # # ]: 0 : else if (adj_face_list.size() > 2)
453 : : {
454 [ # # ]: 0 : TDGeomFacet::add_geom_facet(edge_ptr, -1);
455 [ # # ]: 0 : td_gm_edge = TDGeomFacet::get_geom_facet(edge_ptr);
456 [ # # ]: 0 : edge_ptr->set_as_feature();
457 [ # # ]: 0 : feature_edge_list.append( edge_ptr );
458 [ + - ]: 2244 : }
459 : : }
460 : : }
461 [ + - ]: 924 : }
462 [ - + ]: 44 : if(mydebug){
463 [ # # ]: 0 : GfxDebug::mouse_xforms();
464 : : }
465 : 44 : return CUBIT_SUCCESS;
466 : : }
467 : :
468 : : //=============================================================================
469 : : //Function: add_preexisting_feature_edges (PRIVATE)
470 : : //Description: edges that were marked previously in function ChollaEngine::mark_features
471 : : // are added to the feature edge list
472 : : //Author: sjowen
473 : : //Date: 01/08
474 : : //=============================================================================
475 : 88 : CubitStatus ChollaSurface::add_preexisting_feature_edges(
476 : : DLIList<CubitFacetEdge *> &feature_edge_list)
477 : : {
478 [ + - ]: 88 : DLIList<CubitFacetEdge *> edge_list;
479 [ + - ][ + - ]: 176 : DLIList<CubitFacet *> facet_list;
480 [ + - ][ + - ]: 1144 : CAST_LIST( surfaceElemList, facet_list, CubitFacet );
[ + - ][ - + ]
[ + - ][ + - ]
[ + + ]
481 [ + - ]: 88 : FacetDataUtil::get_edges( facet_list, edge_list );
482 : : int iedge;
483 : : CubitFacetEdge *edge;
484 [ + - ][ + + ]: 1782 : for (iedge=0; iedge < edge_list.size(); iedge++)
485 : : {
486 [ + - ]: 1694 : edge = edge_list.get_and_step();
487 [ + - ][ + + ]: 1694 : if (edge->is_feature())
488 [ + - ]: 220 : feature_edge_list.append(edge);
489 : : }
490 [ + - ]: 88 : return CUBIT_SUCCESS;
491 : : }
492 : :
493 : :
494 : : //=============================================================================
495 : : //Function: non_manifold_edges (PRIVATE)
496 : : //Description: mark all edges that are non-manifold (have more than 2 adj
497 : : // facets)
498 : : //Author: sjowen
499 : : //Date: 5/01
500 : : //=============================================================================
501 : 44 : CubitStatus ChollaSurface::non_manifold_edges(
502 : : DLIList<CubitFacetEdge *> &feature_edge_list)
503 : : {
504 : : //CubitStatus stat = CUBIT_SUCCESS;
505 : : int ii, jj;
506 [ + - ]: 44 : DLIList<CubitFacetEdge*> edge_list;
507 : : FacetEntity *face_ptr;
508 [ + - ][ + + ]: 176 : for (ii=0; ii<surfaceElemList.size(); ii++)
509 : : {
510 [ + - ]: 132 : face_ptr = surfaceElemList.get_and_step();
511 [ + - ]: 132 : edge_list.clean_out();
512 [ + - ]: 132 : face_ptr->edges( edge_list );
513 [ + - ][ + + ]: 528 : for (jj=0; jj<edge_list.size(); jj++)
514 : : {
515 [ + - ]: 396 : CubitFacetEdge *edge_ptr = edge_list.get_and_step();
516 [ + - ]: 396 : TDGeomFacet *td_gm_edge = TDGeomFacet::get_geom_facet(edge_ptr);
517 [ + + ]: 396 : if (!td_gm_edge)
518 : : {
519 [ + - ]: 176 : DLIList<FacetEntity*> adj_face_list;
520 [ + - ]: 176 : edge_ptr->get_parents( adj_face_list );
521 : :
522 : : // non-manifold edges (edges with more than 2 adj facets)
523 : : // must be features
524 : :
525 [ + - ][ + - ]: 176 : if (adj_face_list.size() > 2 || edge_ptr->is_feature())
[ + - ][ - + ]
[ - + ]
526 : : {
527 [ # # ]: 0 : TDGeomFacet::add_geom_facet(edge_ptr, -1);
528 [ # # ]: 0 : td_gm_edge = TDGeomFacet::get_geom_facet(edge_ptr);
529 [ # # ]: 0 : edge_ptr->set_as_feature();
530 [ # # ]: 0 : feature_edge_list.append( edge_ptr );
531 [ + - ]: 176 : }
532 : : }
533 : : }
534 : : }
535 [ + - ]: 44 : return CUBIT_SUCCESS;
536 : : }
537 : :
538 : :
539 : :
540 : : //=============================================================================
541 : : //Function: clean_features (PRIVATE)
542 : : //Description: clean up edges that do not form complete loops as a result
543 : : // of feature angle
544 : : //Author: sjowen
545 : : //Date: 12/22/00
546 : : //=============================================================================
547 : 0 : CubitStatus ChollaSurface::clean_features( )
548 : : {
549 : : int ii, jj;
550 [ # # ]: 0 : for (ii=0; ii<surfaceElemList.size(); ii++)
551 : : {
552 [ # # ]: 0 : FacetEntity *face_ptr = surfaceElemList.get_and_step();
553 [ # # ]: 0 : DLIList<CubitFacetEdge*> edge_list;
554 [ # # ]: 0 : face_ptr->edges( edge_list );
555 [ # # ][ # # ]: 0 : for (jj=0; jj<edge_list.size(); jj++)
556 : : {
557 [ # # ]: 0 : CubitFacetEdge *edge_ptr = edge_list.get_and_step();
558 [ # # ]: 0 : TDGeomFacet *td_gm_edge = TDGeomFacet::get_geom_facet(edge_ptr);
559 [ # # ]: 0 : if (td_gm_edge != NULL)
560 : : {
561 : :
562 : : // make sure this edge actually forms the boundary between two surfaces
563 : :
564 [ # # ]: 0 : DLIList<FacetEntity*> adj_face_list;
565 [ # # ]: 0 : edge_ptr->get_parents( adj_face_list );
566 : :
567 : : // it has to be an internal edge - ignore boundaries
568 : :
569 [ # # ][ # # ]: 0 : if (adj_face_list.size() == 2)
570 : : {
571 [ # # ]: 0 : FacetEntity *adj_face_ptr = adj_face_list.get_and_step();
572 [ # # ]: 0 : if (adj_face_ptr == face_ptr)
573 [ # # ]: 0 : adj_face_ptr = adj_face_list.get();
574 [ # # ]: 0 : TDGeomFacet *td_gm_adjface = TDGeomFacet::get_geom_facet(adj_face_ptr);
575 [ # # ]: 0 : if (td_gm_adjface != NULL)
576 : : {
577 [ # # ]: 0 : DLIList<ChollaSurface*> surf_list;
578 [ # # ]: 0 : td_gm_adjface->get_cholla_surfs( surf_list );
579 [ # # ]: 0 : ChollaSurface *adj_surf = surf_list.get(); // must be only 1 surf
580 [ # # ]: 0 : if (adj_surf == this)
581 : : {
582 : :
583 : : // the same surface is on both sides of this edge - Therefore it
584 : : // does not form a complete loop. Delete the tool data from
585 : : // this edge to indicate that it is not at a boundary.
586 : :
587 [ # # ]: 0 : edge_ptr->delete_TD( &TDGeomFacet::is_geom_facet );
588 [ # # ]: 0 : }
589 : : }
590 [ # # ]: 0 : }
591 : : }
592 : : }
593 [ # # ]: 0 : }
594 : 0 : return CUBIT_SUCCESS;
595 : : }
596 : :
597 : : //=============================================================================
598 : : //Function: init_hit_flags (PUBLIC)
599 : : //Description: initialize the hit flags to the block surface id - used for
600 : : // traversing the faces
601 : : //Author: sjowen
602 : : //Date: 01/22/01
603 : : //=============================================================================
604 : 0 : void ChollaSurface::init_hit_flags()
605 : : {
606 : : int ii;
607 [ # # ]: 0 : for (ii=0; ii<surfaceElemList.size(); ii++)
608 : : {
609 : 0 : FacetEntity *face_ptr = surfaceElemList.get_and_step();
610 : 0 : TDGeomFacet *td_gm = TDGeomFacet::get_geom_facet(face_ptr);
611 : 0 : td_gm->set_hit_flag( id );
612 : : }
613 : 0 : }
614 : :
615 : : //=============================================================================
616 : : //Function: get_points (PUBLIC)
617 : : //Description: compile a list of points on the surface
618 : : //Author: sjowen
619 : : //Date: 4/01
620 : : //=============================================================================
621 : 682 : void ChollaSurface::get_points( DLIList<CubitPoint *> &point_list )
622 : : {
623 : : int ii;
624 : : CubitPoint *point[3];
625 : : CubitFacet *facet;
626 : : FacetEntity *facet_entity;
627 [ + - ][ + + ]: 2794 : for (ii=0; ii<surfaceElemList.size(); ii++)
628 : : {
629 [ + - ]: 2112 : facet_entity = surfaceElemList.get_and_step();
630 [ - + ]: 2112 : facet = CAST_TO( facet_entity, CubitFacet );
631 [ + - ]: 2112 : facet->points( point[0], point[1], point[2] );
632 [ + - ]: 2112 : point[0]->marked(0);
633 [ + - ]: 2112 : point[1]->marked(0);
634 [ + - ]: 2112 : point[2]->marked(0);
635 : : }
636 : :
637 : : int jj;
638 [ + - ][ + + ]: 2794 : for (ii=0; ii<surfaceElemList.size(); ii++)
639 : : {
640 [ + - ]: 2112 : facet_entity = surfaceElemList.get_and_step();
641 [ - + ]: 2112 : facet = CAST_TO( facet_entity, CubitFacet );
642 [ + - ]: 2112 : facet->points( point[0], point[1], point[2] );
643 [ + + ]: 8448 : for (jj=0; jj<3; jj++)
644 : : {
645 [ + - ][ + + ]: 6336 : if (point[jj]->marked() == 0)
646 : : {
647 [ + - ]: 3036 : point[jj]->marked(1);
648 [ + - ]: 3036 : point_list.append(point[jj]);
649 : : }
650 : : }
651 : : }
652 : 682 : }
653 : :
654 : : //=============================================================================
655 : : //Function: update_boundary_tool_data (PUBLIC)
656 : : //Description: update the surface IDs on the boundary facet tooldatas
657 : : //Author: sjowen
658 : : //Date: 5/01
659 : : //=============================================================================
660 : 341 : CubitStatus ChollaSurface::update_boundary_tool_data()
661 : : {
662 : : int ii, jj;
663 : : CubitPoint *point_ptr;
664 : : CubitFacetEdge *edge_ptr;
665 : : CubitFacet *facet_ptr;
666 : : FacetEntity *facet_entity;
667 : :
668 : : TDFacetBoundaryPoint *td_fbp;
669 : : TDFacetBoundaryEdge *td_fbe;
670 [ + + ]: 1397 : for (ii=0; ii<surfaceElemList.size(); ii++)
671 : : {
672 : 1056 : facet_entity = surfaceElemList.get_and_step();
673 [ - + ]: 1056 : facet_ptr = CAST_TO( facet_entity, CubitFacet );
674 [ + + ]: 4224 : for (jj=0; jj<3; jj++)
675 : : {
676 : 3168 : point_ptr = facet_ptr->point(jj);
677 : 3168 : td_fbp = TDFacetBoundaryPoint::get_facet_boundary_point( point_ptr );
678 [ + + ]: 3168 : if (td_fbp != NULL)
679 : : {
680 : 2244 : td_fbp->set_surf_id( facet_ptr, id );
681 : : }
682 : :
683 : 3168 : edge_ptr = facet_ptr->edge(jj);
684 : 3168 : td_fbe = TDFacetBoundaryEdge::get_facet_boundary_edge( edge_ptr );
685 [ + + ]: 3168 : if (td_fbe != NULL)
686 : : {
687 : 1056 : td_fbe->set_surf_id( facet_ptr, id );
688 : : }
689 : : }
690 : : }
691 : :
692 : 341 : return CUBIT_SUCCESS;
693 : : }
694 : :
695 : : //=============================================================================
696 : : //Function: reset_facet_flags (PUBLIC)
697 : : //Description:
698 : : //Author: sjowen
699 : : //Date: 6/01
700 : : //=============================================================================
701 : 682 : void ChollaSurface::reset_facet_flags()
702 : : {
703 : : CubitFacet *facet_ptr;
704 : : FacetEntity *fe_ptr;
705 : : int ii;
706 [ + + ]: 2794 : for (ii=0; ii<surfaceElemList.size(); ii++)
707 : : {
708 : 2112 : fe_ptr = surfaceElemList.get_and_step();
709 [ - + ]: 2112 : facet_ptr = CAST_TO( fe_ptr, CubitFacet );
710 : 2112 : facet_ptr->marked( 0 );
711 : : }
712 : 682 : }
713 : :
714 : : //=============================================================================
715 : : //Function: is_adjacent (PUBLIC)
716 : : //Description: determine if this surface is adjacent to the given surface
717 : : //Author: sjowen
718 : : //Date: 02/11/2004
719 : : //=============================================================================
720 : 0 : CubitBoolean ChollaSurface::is_adjacent( ChollaSurface *other_surf )
721 : : {
722 : : DLIList<ChollaSurface *> *adjsurf_list_ptr;
723 : : ChollaCurve *curv;
724 : : ChollaSurface *surf;
725 : : int icurv, ii;
726 [ # # ]: 0 : for(icurv=0; icurv< curveList.size(); icurv++)
727 : : {
728 : 0 : curv = curveList.get_and_step();
729 : 0 : adjsurf_list_ptr = curv->get_surface_list_ptr();
730 [ # # ]: 0 : for(ii=0; ii<adjsurf_list_ptr->size(); ii++)
731 : : {
732 : 0 : surf = adjsurf_list_ptr->get_and_step();
733 [ # # ][ # # ]: 0 : if (surf != this && surf == other_surf)
734 : : {
735 : 0 : return CUBIT_TRUE;
736 : : }
737 : : }
738 : : }
739 : 0 : return CUBIT_FALSE;
740 : : }
741 : :
742 : : //=============================================================================
743 : : //Function: get_loop_edges (PUBLIC)
744 : : //Description: return the ordered list of edges on the boundary of this surface
745 : : //Author: sjowen
746 : : //Date: 02/23/2004
747 : : //=============================================================================
748 : 0 : DLIList<DLIList<CubitFacetEdge *>*> *ChollaSurface::get_loop_edges( )
749 : : {
750 [ # # ]: 0 : assert(myEvalTool != NULL);
751 : 0 : return myEvalTool->loops();
752 : : }
753 : :
754 : :
755 : : static int icolor = 0;
756 : 0 : void ChollaSurface::debug_draw()
757 : : {
758 : 0 : icolor++;
759 : 0 : icolor = (icolor%15)+1;
760 : 0 : dcolor(icolor);
761 : 0 : dldraw(surfaceElemList);
762 : 0 : }
763 : :
764 : : //=============================================================================
765 : : //Function: flip_facets (PUBLIC)
766 : : //Description: invert all facets on this surface
767 : : //Author: sjowen
768 : : //Date: 09/10/09
769 : : //=============================================================================
770 : 0 : void ChollaSurface::flip_facets()
771 : : {
772 : : FacetEntity *facet_entity;
773 : : CubitFacet *facet_ptr;
774 [ # # ]: 0 : for (int ii=0; ii<surfaceElemList.size(); ii++)
775 : : {
776 : 0 : facet_entity = surfaceElemList.get_and_step();
777 [ # # ]: 0 : facet_ptr = dynamic_cast<CubitFacet *> (facet_entity);
778 [ # # ]: 0 : assert( facet_ptr != NULL );
779 : 0 : facet_ptr->flip();
780 : : }
781 : 0 : }
782 : :
783 : : //=============================================================================
784 : : //Function: is_in_volume (PUBLIC)
785 : : //Description: return whether this surface is in a particular volume
786 : : //Author: sjowen
787 : : //Date: 09/11/09
788 : : //=============================================================================
789 : 0 : CubitBoolean ChollaSurface::is_in_volume( ChollaVolume *chvol_ptr )
790 : : {
791 : : ChollaVolume *mychvol_ptr;
792 [ # # ]: 0 : for (int ii=0; ii<volList.size(); ii++)
793 : : {
794 : 0 : mychvol_ptr = volList.get_and_step();
795 [ # # ]: 0 : if (mychvol_ptr == chvol_ptr)
796 : 0 : return CUBIT_TRUE;
797 : : }
798 : 0 : return CUBIT_FALSE;
799 : : }
800 : :
801 : : //=============================================================================
802 : : //Function: get_vertices (PUBLIC)
803 : : //Description: get the list of ChollaPoints on this surface
804 : : //Author: sjowen
805 : : //Date: 09/11/09
806 : : //=============================================================================
807 : 0 : void ChollaSurface::get_vertices( DLIList<ChollaPoint *> &chpt_list )
808 : : {
809 : 0 : chpt_list.clean_out();
810 : : ChollaCurve *chcurv_ptr;
811 [ # # ]: 0 : for (int ii=0; ii<curveList.size(); ii++)
812 : : {
813 [ # # ]: 0 : chcurv_ptr = curveList.get_and_step();
814 [ # # ][ # # ]: 0 : DLIList<ChollaPoint *> chc_pts = chcurv_ptr->get_points();
815 [ # # ]: 0 : chpt_list += chc_pts;
816 [ # # ]: 0 : }
817 : 0 : chpt_list.uniquify_unordered();
818 : 0 : }
819 : :
820 : 0 : bool ChollaSurface::is_contain( FacetEntity *facet )
821 : : {
822 [ # # ]: 0 : if( surfaceElemList.is_in_list( facet ) )
823 : 0 : return true;
824 : : else
825 : 0 : return false;
826 [ + - ][ + - ]: 6540 : }
827 : :
828 : : //EOF
829 : :
|
