Branch data Line data Source code
1 : : //- Class: ChollaCurve
2 : : //- Description: Temporary class for constructing the facet-based geometry
3 : : //-
4 : : //- Owner: Steven J. Owen
5 : : //- Checked by:
6 : : //- Version:
7 : :
8 : : #include "CubitVector.hpp"
9 : : #include "ChollaCurve.hpp"
10 : : #include "ChollaSurface.hpp"
11 : : #include "ChollaPoint.hpp"
12 : : #include "TDGeomFacet.hpp"
13 : : #include "CastTo.hpp"
14 : : #include "CubitFacet.hpp"
15 : : #include "CubitFacetData.hpp"
16 : : #include "CubitFacetEdge.hpp"
17 : : #include "CubitFacetEdgeData.hpp"
18 : : #include "ChollaDebug.hpp"
19 : : #include "GfxDebug.hpp"
20 : : #include "CurveFacetEvalTool.hpp"
21 : : #include "ChollaEngine.hpp"
22 : : #include "ChollaVolume.hpp"
23 : : #include "CubitMessage.hpp"
24 : :
25 : :
26 : : //===============================================================================
27 : : //Function: ChollaCurve (PUBLIC) (constructor)
28 : : //===============================================================================
29 [ + - ][ + - ]: 3168 : ChollaCurve::ChollaCurve( int block_id )
[ + - ]
30 : : {
31 : : static int count = 1;
32 : 1584 : id = count++;
33 : 1584 : myCurve = NULL;
34 : 1584 : myEvalTool = NULL;
35 : 1584 : startPoint = NULL;
36 : 1584 : endPoint = NULL;
37 : 1584 : blockID = block_id;
38 : 1584 : myLength = MYLENGTH_UNINITIALIZED;
39 : 1584 : myMergePartner = NULL;
40 : 1584 : }
41 : :
42 : : //===============================================================================
43 : : //Function: ~ChollaCurve (PUBLIC) (destructor)
44 : : //===============================================================================
45 [ + - ][ + - ]: 4752 : ChollaCurve::~ChollaCurve()
[ + - ]
46 : : {
47 [ - + ]: 3168 : }
48 : :
49 : : //===============================================================================
50 : : //Function: remove_td_associativity (PUBLIC)
51 : : //===============================================================================
52 : 55 : void ChollaCurve::remove_td_associativity( ChollaSurface *fsm_ptr )
53 : : {
54 : : int i;
55 : : TDGeomFacet *td;
56 : : FacetEntity *edge_ptr;
57 [ + + ]: 187 : for(i=0; i<curveEdgeList.size(); i++)
58 : : {
59 : 132 : edge_ptr = curveEdgeList.get_and_step();
60 : 132 : td = TDGeomFacet::get_geom_facet( edge_ptr );
61 [ + - ]: 132 : if (td)
62 : : {
63 : 132 : td->remove_cholla_curve( this );
64 : 132 : td->remove_cholla_surf( fsm_ptr );
65 : : }
66 : : }
67 : 55 : }
68 : :
69 : :
70 : : //=============================================================================
71 : : //Function: get_ends (PUBLIC)
72 : : //Description: returns the end locations of the curve. Determines their
73 : : // location if not yet defined
74 : : //Author: sjowen
75 : : //Date: 12/4/00
76 : : //=============================================================================
77 : 0 : CubitStatus ChollaCurve::get_ends( CubitVector &start, CubitVector &end )
78 : : {
79 [ # # ][ # # ]: 0 : if (startPoint && endPoint)
80 : : {
81 [ # # ]: 0 : start = startPoint->coordinates();
82 [ # # ]: 0 : end = endPoint->coordinates();
83 : : }
84 : : else
85 : : {
86 : 0 : CubitStatus stat = determine_ends();
87 [ # # ]: 0 : if (stat == CUBIT_FAILURE)
88 : 0 : return stat;
89 [ # # ]: 0 : start = startPoint->coordinates();
90 [ # # ]: 0 : end = endPoint->coordinates();
91 : : }
92 : 0 : return CUBIT_SUCCESS;
93 : : }
94 : :
95 : : //=============================================================================
96 : : //Function: get_ends (PUBLIC)
97 : : //Description: returns the end nodes of the curve. Determines the
98 : : // nodes if not yet defined
99 : : //Author: sjowen
100 : : //Date: 12/4/00
101 : : //=============================================================================
102 : 4026 : CubitStatus ChollaCurve::get_ends( CubitPoint *&start_ptr, CubitPoint *&end_ptr )
103 : : {
104 [ + - ][ + - ]: 4026 : if (startPoint && endPoint )
105 : : {
106 : 4026 : start_ptr = startPoint;
107 : 4026 : end_ptr = endPoint;
108 : : }
109 : : else
110 : : {
111 : 0 : CubitStatus stat = determine_ends();
112 [ # # ]: 0 : if (stat == CUBIT_FAILURE)
113 : 0 : return stat;
114 : 0 : start_ptr = startPoint;
115 : 0 : end_ptr = endPoint;
116 : : }
117 : 4026 : return CUBIT_SUCCESS;
118 : : }
119 : :
120 : : //=============================================================================
121 : : //Function: split_curve (PRIVATE)
122 : : //Description: split this curve into multiple ChollaCurve where there are
123 : : // discontinuous strings of edges. Define start and end nodes
124 : : // for each curve while we are at it
125 : : //Author: sjowen
126 : : //Date: 12/4/00
127 : : //=============================================================================
128 : 594 : CubitStatus ChollaCurve::split_curve(
129 : : DLIList<ChollaCurve*> &facet_curve_list)
130 : : {
131 [ + - ]: 594 : DLIList<ChollaCurve*> new_curve_list;
132 : :
133 : : // Go through the curveEdgeList and pull edges off one by one as we
134 : : // determine which curve it belongs to. Continue until we have depleted
135 : : // the list
136 : :
137 : 594 : int periodic = 0;
138 [ + - ]: 594 : int start_size = curveEdgeList.size();
139 : 594 : int icount = 0;
140 : :
141 [ + - ]: 594 : curveEdgeList.reset();
142 [ + - ][ + + ]: 1474 : while( curveEdgeList.size() > 0)
143 : : {
144 : :
145 : : // First, find an edge that has a start point on it
146 : :
147 [ + - ]: 880 : CubitFacetEdge *start_edge_ptr = (CubitFacetEdge *)curveEdgeList.get_and_step();
148 [ + - ]: 880 : CubitPoint *point0_ptr = start_edge_ptr->point(0);
149 [ + - ]: 880 : CubitPoint *point1_ptr = start_edge_ptr->point(1);
150 : 880 : CubitPoint *start_point = NULL;
151 [ + + ]: 880 : if (periodic)
152 : : {
153 : 66 : start_point = startPoint;
154 : : }
155 : : else
156 : : {
157 [ + - ][ + + ]: 814 : if (next_edge( point0_ptr, start_edge_ptr ) == NULL)
158 : 528 : start_point = point0_ptr;
159 [ + - ][ - + ]: 286 : else if(next_edge( point1_ptr, start_edge_ptr ) == NULL)
160 : 0 : start_point = point1_ptr;
161 : : }
162 [ + + ][ - + ]: 880 : if (start_point != NULL || periodic)
163 : : {
164 : :
165 : : // create a new curve to hold the edge info
166 : :
167 [ + - ]: 594 : TDGeomFacet *td_gm_edge = TDGeomFacet::get_geom_facet(start_edge_ptr);
168 [ + - ][ + - ]: 594 : int block_id = (td_gm_edge == NULL) ? -1 : td_gm_edge->get_block_id();
169 [ + - ][ + - ]: 594 : ChollaCurve *fcm_ptr = new ChollaCurve( block_id );
170 [ + - ]: 594 : new_curve_list.append( fcm_ptr );
171 : :
172 : : // assign the edges to the new curve in the correct order and orientation
173 : :
174 [ + - ]: 594 : CubitStatus rv = fcm_ptr->build_curve_from_edges( start_point, periodic, start_size, start_edge_ptr, this );
175 [ - + ]: 594 : if (rv != CUBIT_SUCCESS)
176 : 0 : return rv;
177 : :
178 : : // remove the edges in the new curve from this curve
179 : :
180 : : int ii;
181 [ + - ][ + - ]: 594 : DLIList<FacetEntity *> flist = fcm_ptr->get_facet_list();
182 [ + - ][ + - ]: 1188 : DLIList<CubitFacetEdge *> elist;
183 : : CubitFacetEdge *edge_ptr;
184 [ + - ][ + - ]: 1342 : CAST_LIST( flist, elist, CubitFacetEdge );
[ + - ][ - + ]
[ + - ][ + - ]
[ + + ]
185 [ + - ][ + + ]: 1342 : for ( ii = elist.size(); ii > 0; ii-- )
186 : : {
187 [ + - ]: 748 : edge_ptr = elist.get_and_step();
188 [ + - ]: 748 : curveEdgeList.remove( edge_ptr );
189 : : }
190 [ + - ]: 594 : start_size = curveEdgeList.size();
191 : 594 : icount = 0;
192 [ + - ]: 594 : periodic = 0;
193 : : }
194 : :
195 : : // if we have gone through all of the edges without finding an end,
196 : : // then we have a periodic curve. Choose an arbirary node to act as
197 : : // the beginning and end
198 : :
199 [ + - ][ + + ]: 880 : if (curveEdgeList.size() > 0)
200 : : {
201 : 286 : icount++;
202 [ + + ]: 286 : if (icount > start_size)
203 : : {
204 [ + - ]: 66 : curveEdgeList.reset();
205 [ + - ]: 66 : CubitFacetEdge *edge = (CubitFacetEdge *)curveEdgeList.get();
206 [ + - ]: 66 : CubitPoint *point_ptr = edge->point(0);
207 : 66 : startPoint = point_ptr;
208 : 66 : endPoint = point_ptr;
209 : 286 : periodic = 1;
210 : : }
211 : : }
212 : : }
213 : :
214 : : // add the new curves to the global curve list
215 : :
216 : : int ii, jj;
217 [ + - ][ + + ]: 1188 : for (ii=new_curve_list.size(); ii>0; ii--)
218 : : {
219 [ + - ]: 594 : ChollaCurve *fcm_ptr = new_curve_list.get_and_step();
220 : :
221 [ + - ]: 594 : facet_curve_list.append( fcm_ptr );
222 : :
223 : : // update the surface info
224 : :
225 [ + - ][ + + ]: 1716 : for (jj=surfaceList.size(); jj>0; jj--)
226 : : {
227 [ + - ]: 1122 : ChollaSurface *fsm_ptr = surfaceList.get_and_step();
228 [ + - ]: 1122 : fcm_ptr->add_surface( fsm_ptr );
229 [ + - ]: 1122 : fsm_ptr->remove_curve( this );
230 [ + - ]: 1122 : fsm_ptr->add_curve( fcm_ptr );
231 : : }
232 : :
233 : : // update the geometric curve pointer
234 : :
235 [ + - ]: 594 : fcm_ptr->assign_geometric_curve( NULL );
236 : :
237 : : // update the curve pointers in the edge tool data
238 : :
239 [ + - ][ + - ]: 594 : DLIList<FacetEntity*> facet_list = fcm_ptr->get_facet_list();
240 [ + - ][ + + ]: 1342 : for (jj=facet_list.size(); jj > 0; jj--)
241 : : {
242 [ + - ]: 748 : FacetEntity *edge_ptr = facet_list.get_and_step();
243 [ + - ]: 748 : TDGeomFacet *td_gm_edge = TDGeomFacet::get_geom_facet(edge_ptr);
244 [ + - ]: 748 : td_gm_edge->remove_cholla_curve( this );
245 [ + - ]: 748 : td_gm_edge->add_cholla_curve( fcm_ptr );
246 : : }
247 [ + - ]: 594 : }
248 : :
249 [ + - ]: 594 : return CUBIT_SUCCESS;
250 : : }
251 : :
252 : : //=============================================================================
253 : : //Function: build_curve_from_edges
254 : : //Description: insert the ordered and oriented edges into this cholla curve
255 : : //Notes: traverses starting at start_point and gathers facet edges until it
256 : : // runs into another curve.
257 : : // start_point is an existing CubitPoint at either end of the curve
258 : : // max_edges is the maximum number of edges on this curve. should be
259 : : // known beforehand (used for error checking).
260 : : //
261 : : // ***this function used to be part of split_curve. ***
262 : : //Author: sjowen
263 : : //Return:
264 : : //Date: 09/07/2009
265 : : //=============================================================================
266 : 594 : CubitStatus ChollaCurve::build_curve_from_edges( CubitPoint *start_point,
267 : : int periodic,
268 : : int max_edges,
269 : : CubitFacetEdge *start_edge_ptr,
270 : : ChollaCurve *parent_curve )
271 : : {
272 : :
273 : : // find the first edge. Match the chollacurve owner with this curve
274 : : // do this only if the start_edge_ptr was not passed in
275 : :
276 [ + - ]: 594 : DLIList<CubitFacetEdge *> point_edge_list;
277 [ + - ]: 594 : start_point->edges(point_edge_list);
278 : : CubitFacetEdge *edge_ptr;
279 [ - + ]: 594 : if (start_edge_ptr == NULL)
280 : : {
281 [ # # ][ # # ]: 0 : for (int ii=0; ii<point_edge_list.size() && !start_edge_ptr; ii++)
[ # # ][ # # ]
282 : : {
283 [ # # ]: 0 : edge_ptr = point_edge_list.get_and_step();
284 [ # # ]: 0 : TDGeomFacet *td_geom = TDGeomFacet::get_geom_facet( edge_ptr );
285 : :
286 : : // assumes that the TDGeomFacet info has already been set up for the edges
287 [ # # ]: 0 : assert(td_geom != NULL);
288 : :
289 [ # # ]: 0 : DLIList<ChollaCurve *> cholla_curves;
290 [ # # ]: 0 : td_geom->get_cholla_curves(cholla_curves);
291 : :
292 : : // currently should be only one-to-one relationship
293 : : // could also be edge on surface in which case no curves associated
294 [ # # ][ # # ]: 0 : assert(cholla_curves.size() <= 1);
295 [ # # ][ # # ]: 0 : if (cholla_curves.size())
296 : : {
297 [ # # ][ # # ]: 0 : if (cholla_curves.get() == this)
298 : 0 : start_edge_ptr = edge_ptr;
299 : : }
300 [ # # ]: 0 : }
301 [ # # ]: 0 : assert(start_edge_ptr != NULL); // didn't find an edge that marched this chollacurve
302 : : }
303 : :
304 : : // create a new curve to hold the edge info
305 : :
306 [ + - ]: 594 : this->set_start( start_point );
307 [ + - ]: 594 : start_point->set_as_feature();
308 : :
309 [ + - ]: 594 : this->add_facet( start_edge_ptr );
310 : 594 : int iedgecount = 0;
311 : 594 : edge_ptr = start_edge_ptr;
312 : 594 : CubitPoint *point0_ptr = start_point, *point1_ptr;
313 : 594 : CubitPoint *end_point = NULL;
314 [ + + ]: 1342 : while(!end_point)
315 : : {
316 [ + - ]: 748 : point1_ptr = edge_ptr->other_point( point0_ptr );
317 [ + - ][ + + ]: 748 : if ((edge_ptr = parent_curve->next_edge( point1_ptr, edge_ptr )) == NULL)
318 : : {
319 : 594 : end_point = point1_ptr;
320 : : }
321 : : else
322 : : {
323 : 154 : iedgecount++;
324 [ - + ]: 154 : if (iedgecount > max_edges)
325 : : {
326 [ # # ][ # # ]: 0 : PRINT_ERROR("ChollaCurve has start, but no end\n");
[ # # ][ # # ]
327 : 0 : return CUBIT_FAILURE;
328 : : }
329 : :
330 [ + - ]: 154 : this->add_facet( edge_ptr );
331 [ + - ][ - + ]: 154 : if (periodic && point1_ptr == start_point)
332 : 0 : end_point = start_point;
333 : 154 : point0_ptr = point1_ptr;
334 : : }
335 : : }
336 [ + - ]: 594 : this->set_end( end_point );
337 [ + - ]: 594 : end_point->set_as_feature();
338 : :
339 : : // make sure all the edges are oriented correctly
340 : :
341 : : int i;
342 [ + - ][ + - ]: 1188 : DLIList<FacetEntity *> flist = this->get_facet_list();
[ + - ]
343 [ + - ]: 594 : flist.reset();
344 [ + - ][ + - ]: 1188 : DLIList<CubitFacetEdge *> elist;
345 [ + - ][ + - ]: 1342 : CAST_LIST( flist, elist, CubitFacetEdge );
[ + - ][ - + ]
[ + - ][ + - ]
[ + + ]
346 [ + - ]: 594 : elist.reset();
347 : 594 : CubitPoint *cur_pt = start_point, *tmp_pt;
348 [ + - ][ + + ]: 1342 : for ( i = elist.size(); i > 0; i-- )
349 : : {
350 [ + - ]: 748 : edge_ptr = elist.get_and_step();
351 [ + - ]: 748 : point0_ptr = edge_ptr->point(0);
352 [ + - ]: 748 : point1_ptr = edge_ptr->point(1);
353 [ - + ]: 748 : if (point0_ptr != cur_pt)
354 : : {
355 [ # # ]: 0 : assert( cur_pt == point1_ptr );
356 [ # # ]: 0 : edge_ptr->flip();
357 : 0 : tmp_pt = point0_ptr;
358 : 0 : point0_ptr = point1_ptr;
359 : 0 : point1_ptr = tmp_pt;
360 [ # # ][ # # ]: 0 : assert( point0_ptr == edge_ptr->point(0) &&
[ # # ]
361 [ # # ]: 0 : point1_ptr == edge_ptr->point(1) );
362 : : }
363 : 748 : cur_pt = point1_ptr;
364 : : }
365 : :
366 : 594 : int mydebug = 0;
367 [ - + ]: 594 : if (mydebug)
368 : : {
369 : : int i;
370 [ # # ][ # # ]: 0 : DLIList<FacetEntity *> flist = this->get_facet_list();
371 [ # # ]: 0 : flist.reset();
372 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge *> elist;
373 [ # # ][ # # ]: 0 : CAST_LIST( flist, elist, CubitFacetEdge );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
374 [ # # ]: 0 : elist.reset();
375 [ # # ][ # # ]: 0 : for ( i = elist.size(); i > 0; i-- ) {
376 [ # # ]: 0 : CubitFacetEdge *edge = elist.get_and_step();
377 [ # # ][ # # ]: 0 : CubitVector pt0_v = edge->point(0)->coordinates();
378 [ # # ][ # # ]: 0 : CubitVector pt1_v = edge->point(1)->coordinates();
379 [ # # ]: 0 : GfxDebug::draw_point(pt0_v, CUBIT_GREEN_INDEX );
380 [ # # ]: 0 : GfxDebug::draw_point(pt1_v, CUBIT_RED_INDEX );
381 [ # # ]: 0 : GfxDebug::draw_line( pt0_v, pt1_v, CUBIT_YELLOW_INDEX );
382 [ # # ]: 0 : GfxDebug::flush();
383 : 0 : int view = 0;
384 [ # # ]: 0 : if (view)
385 [ # # ]: 0 : dview();
386 [ # # ]: 0 : }
387 : : }
388 [ + - ]: 594 : return CUBIT_SUCCESS;
389 : : }
390 : :
391 : 594 : CubitStatus ChollaCurve::order_edges()
392 : : {
393 : : int i;
394 : 594 : bool periodic = false;
395 [ - + ]: 594 : if (NULL == startPoint)
396 : : {
397 [ # # ][ # # ]: 0 : DLIList<ChollaPoint *> cholla_points = get_points();
398 [ # # ]: 0 : periodic = (cholla_points.size() == 1);
399 : :
400 [ # # ]: 0 : ChollaPoint *chpt = cholla_points.get();
401 [ # # ][ # # ]: 0 : CubitPoint *start_point = dynamic_cast<CubitPoint *> (chpt->get_facets());
402 : :
403 [ # # ]: 0 : this->set_start( start_point );
404 [ # # ]: 0 : if (NULL == start_point)
405 : 0 : return CUBIT_FAILURE;
406 [ # # ]: 0 : start_point->set_as_feature();
407 : :
408 [ # # ]: 0 : if (periodic)
409 : : {
410 [ # # ]: 0 : this->set_end(start_point);
411 : : }
412 : : else
413 : : {
414 [ # # ]: 0 : chpt = cholla_points.step_and_get();
415 [ # # ][ # # ]: 0 : CubitPoint *end_point = dynamic_cast<CubitPoint *> (chpt->get_facets());
416 [ # # ]: 0 : if (NULL == end_point)
417 : 0 : return CUBIT_FAILURE;
418 [ # # ]: 0 : this->set_end(end_point);
419 [ # # ][ # # ]: 0 : end_point->set_as_feature();
[ # # ]
420 : 0 : }
421 : : }
422 : :
423 [ - + ]: 594 : assert(startPoint);
424 [ - + ]: 594 : assert(endPoint);
425 : :
426 [ + - ][ + + ]: 594 : if (curveEdgeList.size() > 1)
427 : : {
428 [ + - ]: 66 : DLIList<CubitFacetEdge*> edges_ordered;
429 [ + - ][ + - ]: 286 : CAST_LIST(curveEdgeList, edges_ordered, CubitFacetEdge);
[ + - ][ - + ]
[ + - ][ + - ]
[ + + ]
430 : :
431 [ + - ]: 66 : CubitStatus stat = CubitFacetEdge::order_edge_list(edges_ordered, startPoint, endPoint);
432 : :
433 [ - + ]: 66 : if (CUBIT_FAILURE == stat)
434 : 0 : return CUBIT_FAILURE;
435 : :
436 : : // store the edges in the correct order
437 [ + - ]: 66 : clean_out_edges();
438 : :
439 [ + - ]: 66 : edges_ordered.reset();
440 [ + - ][ + + ]: 286 : for (i=0; i< edges_ordered.size(); i++)
[ + - ][ + - ]
441 : : {
442 [ + - ][ + - ]: 220 : this->add_facet(edges_ordered.get_and_step());
443 : 66 : }
444 : : }
445 : :
446 : :
447 : : // make sure all the edges are oriented correctly
448 [ + - ][ + - ]: 594 : DLIList<FacetEntity *> flist = this->get_facet_list();
449 [ + - ]: 594 : flist.reset();
450 [ + - ][ + - ]: 1188 : DLIList<CubitFacetEdge *> elist;
451 [ + - ][ + - ]: 1342 : CAST_LIST( flist, elist, CubitFacetEdge );
[ + - ][ - + ]
[ + - ][ + - ]
[ + + ]
452 [ + - ]: 594 : elist.reset();
453 : 594 : CubitPoint *cur_pt = startPoint, *tmp_pt;
454 [ + - ][ + + ]: 1342 : for ( i = elist.size(); i > 0; i-- )
455 : : {
456 [ + - ]: 748 : CubitFacetEdge *edge_ptr = elist.get_and_step();
457 [ + - ]: 748 : CubitPoint *point0_ptr = edge_ptr->point(0);
458 [ + - ]: 748 : CubitPoint *point1_ptr = edge_ptr->point(1);
459 [ + + ]: 748 : if (point0_ptr != cur_pt)
460 : : {
461 [ - + ]: 44 : assert( cur_pt == point1_ptr );
462 [ + - ]: 44 : edge_ptr->flip();
463 : 44 : tmp_pt = point0_ptr;
464 : 44 : point0_ptr = point1_ptr;
465 : 44 : point1_ptr = tmp_pt;
466 [ + - ][ + - ]: 88 : assert( point0_ptr == edge_ptr->point(0) &&
[ - + ]
467 [ + - ]: 44 : point1_ptr == edge_ptr->point(1) );
468 : : }
469 : 748 : cur_pt = point1_ptr;
470 : : }
471 : :
472 : 594 : int mydebug = 0;
473 [ - + ]: 594 : if (mydebug)
474 : : {
475 : : int i;
476 [ # # ][ # # ]: 0 : DLIList<FacetEntity *> flist = this->get_facet_list();
477 [ # # ]: 0 : flist.reset();
478 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge *> elist;
479 [ # # ][ # # ]: 0 : CAST_LIST( flist, elist, CubitFacetEdge );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
480 [ # # ]: 0 : elist.reset();
481 [ # # ][ # # ]: 0 : for ( i = elist.size(); i > 0; i-- ) {
482 [ # # ]: 0 : CubitFacetEdge *edge = elist.get_and_step();
483 [ # # ][ # # ]: 0 : CubitVector pt0_v = edge->point(0)->coordinates();
484 [ # # ][ # # ]: 0 : CubitVector pt1_v = edge->point(1)->coordinates();
485 [ # # ]: 0 : GfxDebug::draw_point(pt0_v, CUBIT_GREEN_INDEX );
486 [ # # ]: 0 : GfxDebug::draw_point(pt1_v, CUBIT_RED_INDEX );
487 [ # # ]: 0 : GfxDebug::draw_line( pt0_v, pt1_v, CUBIT_YELLOW_INDEX );
488 [ # # ]: 0 : GfxDebug::flush();
489 : 0 : int view = 0;
490 [ # # ]: 0 : if (view)
491 [ # # ]: 0 : dview();
492 [ # # ]: 0 : }
493 : : }
494 [ + - ]: 594 : return CUBIT_SUCCESS;
495 : : }
496 : :
497 : : //=============================================================================
498 : : //Function: length
499 : : //Description:
500 : : //Author: sjowen
501 : : //Date: 04/21/2009
502 : : //============================================================================
503 : 0 : double ChollaCurve::length()
504 : : {
505 [ # # ]: 0 : if (myLength > MYLENGTH_UNINITIALIZED)
506 : 0 : return myLength;
507 : :
508 : : CubitFacetEdge *edge;
509 : : FacetEntity *fent;
510 : 0 : myLength = 0.0;
511 [ # # ]: 0 : for (int iedge=0; iedge<curveEdgeList.size(); iedge++)
512 : : {
513 : 0 : fent = curveEdgeList.get_and_step();
514 [ # # ]: 0 : edge = dynamic_cast<CubitFacetEdge *> (fent);
515 : 0 : myLength += edge->length();
516 : : }
517 : :
518 : 0 : return myLength;
519 : : }
520 : :
521 : : //=============================================================================
522 : : //Function: find adjacent edges at a point that lie on the curve
523 : : //Description: determine the next edge from a given edge - return NULL if at the end
524 : : //Author: william roshan quadros
525 : : //Return: returns false if no adj_edges can be found
526 : : //Date: 04/21/2009
527 : : //=============================================================================
528 : 0 : bool ChollaCurve::adj_facet_edges( CubitPoint *node_ptr, CubitFacetEdge *&adj_edge1, CubitFacetEdge *&adj_edge2 )
529 : : {
530 : : // initialize adj_edge1 and adj_edge2
531 : 0 : adj_edge1 = adj_edge2 = NULL;
532 : :
533 [ # # ]: 0 : DLIList<CubitFacetEdge*> node_edge_list;
534 [ # # ]: 0 : node_ptr->edges( node_edge_list );
535 : :
536 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge*> curve_edge_list;
537 [ # # ][ # # ]: 0 : CAST_LIST(curveEdgeList, curve_edge_list, CubitFacetEdge);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
538 : :
539 [ # # ]: 0 : curve_edge_list.intersect(node_edge_list);
540 [ # # ][ # # ]: 0 : assert(curve_edge_list.size() < 3);
541 : :
542 [ # # ][ # # ]: 0 : if (0 == curve_edge_list.size())
543 : 0 : return false;
544 : :
545 [ # # ]: 0 : curve_edge_list.reset();
546 [ # # ]: 0 : adj_edge1 = curve_edge_list.get();
547 : :
548 [ # # ][ # # ]: 0 : if (curve_edge_list.size() > 1)
549 [ # # ]: 0 : adj_edge2 = curve_edge_list.next();
550 : :
551 [ # # ]: 0 : return true;
552 : : }
553 : :
554 : : //=============================================================================
555 : : //Function: next_edge (PRIVATE)
556 : : //Description: determine the next edge from a given edge - return NULL if at
557 : : // the end
558 : : //Author: sjowen
559 : : //Date: 12/4/00
560 : : //=============================================================================
561 : 2904 : CubitFacetEdge *ChollaCurve::next_edge( CubitPoint *node_ptr,
562 : : CubitFacetEdge *edge_ptr )
563 : : {
564 : : // check if this node has its hit flag set - we are at a feature break.
565 : :
566 [ + - ]: 2904 : TDGeomFacet *td_gm_node = TDGeomFacet::get_geom_facet(node_ptr);
567 [ + - ][ + + ]: 2904 : if (td_gm_node->get_hit_flag() == 1 || node_ptr->is_feature())
[ + - ][ + + ]
[ + + ]
568 : 1826 : return NULL;
569 : :
570 : : int jj, kk;
571 : :
572 : : // find the next edge
573 : :
574 : 1078 : CubitFacetEdge *next_edge_on_curve = NULL;
575 [ + - ]: 1078 : DLIList<CubitFacetEdge*> edge_list;
576 [ + - ]: 1078 : node_ptr->edges( edge_list );
577 : 1078 : int num_adj_curves = 1; // keep track of the number of curves at this node
578 [ + - ][ + + ]: 3993 : for (jj=0; jj<edge_list.size(); jj++)
579 : : {
580 [ + - ]: 3267 : CubitFacetEdge *node_edge_ptr = edge_list.get_and_step();
581 [ + + ]: 3267 : if (node_edge_ptr != edge_ptr)
582 : : {
583 [ + - ]: 2299 : TDGeomFacet *td_gm_edge = TDGeomFacet::get_geom_facet(node_edge_ptr);
584 [ + + ]: 2299 : if (td_gm_edge != NULL)
585 : : {
586 [ + - ]: 1430 : DLIList<ChollaCurve*> fcurve_list;
587 [ + - ]: 1430 : td_gm_edge->get_cholla_curves( fcurve_list );
588 [ + - ][ + - ]: 1430 : if (fcurve_list.size() > 0)
589 : : {
590 : :
591 : : // if 3 or more curves meet at this node, then force the curve to terminate here
592 : :
593 : 1430 : num_adj_curves++;
594 [ + + ]: 1430 : if (num_adj_curves >= 3)
595 : : {
596 : 352 : return NULL;
597 : : }
598 : :
599 : : // otherwise try to match the curve to the edge to find the next edge
600 : :
601 [ + - ][ + + ]: 2508 : for (kk=0; kk<fcurve_list.size(); kk++)
[ + - ][ + + ]
602 : : {
603 [ + - ]: 1078 : ChollaCurve *fcm_ptr = fcurve_list.get_and_step();
604 [ + + ]: 1078 : if (fcm_ptr == this)
605 : : {
606 : 726 : next_edge_on_curve = node_edge_ptr;
607 : : }
608 : : }
609 : 2299 : }
610 : : }
611 : : }
612 : : }
613 [ + - ]: 2904 : return next_edge_on_curve;
614 : : }
615 : :
616 : :
617 : : //=============================================================================
618 : : //Function: determine_ends (PRIVATE)
619 : : //Description: determine the end nodes of the curve
620 : : // Assumes that there is one continuous string of edges
621 : : // (may need to call split_curve first)
622 : : //Author: sjowen
623 : : //Date: 12/4/00
624 : : //=============================================================================
625 : 0 : CubitStatus ChollaCurve::determine_ends( )
626 : : {
627 : : int ii, jj, kk, inode;
628 : : CubitFacetEdge *edge_ptr;
629 : : CubitPoint *node0_ptr, *node1_ptr, *node_ptr;
630 : 0 : startPoint = endPoint = NULL;
631 : 0 : int done = 0;
632 [ # # ][ # # ]: 0 : for(ii=0; ii<curveEdgeList.size() && !done; ii++)
[ # # ]
633 : : {
634 : 0 : edge_ptr = (CubitFacetEdge *)curveEdgeList.get_and_step();
635 : 0 : node0_ptr = edge_ptr->point(0);
636 : 0 : node1_ptr = edge_ptr->point(1);
637 [ # # ][ # # ]: 0 : for (inode=0; inode<2 && !done; inode++)
638 : : {
639 [ # # ]: 0 : node_ptr = (inode==0) ? node0_ptr : node1_ptr;
640 [ # # ]: 0 : DLIList<CubitFacetEdge*> edge_list;
641 [ # # ]: 0 : node_ptr->edges( edge_list );
642 [ # # ][ # # ]: 0 : for (jj=0; jj<edge_list.size() && !done; jj++)
[ # # ][ # # ]
643 : : {
644 [ # # ]: 0 : CubitFacetEdge *node_edge_ptr = edge_list.get_and_step();
645 [ # # ]: 0 : if (node_edge_ptr != edge_ptr)
646 : : {
647 [ # # ]: 0 : TDGeomFacet *td_gm_edge = TDGeomFacet::get_geom_facet(node_edge_ptr);
648 [ # # ]: 0 : if (td_gm_edge != NULL)
649 : : {
650 : 0 : int found = 0;
651 [ # # ]: 0 : DLIList<ChollaCurve*> fcurve_list;
652 [ # # ]: 0 : td_gm_edge->get_cholla_curves( fcurve_list );
653 [ # # ][ # # ]: 0 : for (kk=0; kk<fcurve_list.size() && !found; kk++)
[ # # ][ # # ]
654 : : {
655 [ # # ]: 0 : ChollaCurve *fcm_ptr = fcurve_list.get_and_step();
656 [ # # ]: 0 : if (fcm_ptr == this)
657 : 0 : found = 1;
658 : : }
659 [ # # ]: 0 : if (!found)
660 : : {
661 [ # # ]: 0 : if (startPoint == NULL)
662 : : {
663 : 0 : startPoint = node_ptr;
664 : : }
665 : : else
666 : : {
667 : 0 : endPoint = node_ptr;
668 : 0 : done = 1;
669 : : }
670 [ # # ]: 0 : }
671 : : }
672 : : }
673 : : }
674 [ # # ]: 0 : }
675 : :
676 : : }
677 : :
678 : : // check for periodic condition - just choose an arbitrary node to serve as
679 : : // both start and end of the curve
680 : :
681 [ # # ][ # # ]: 0 : if (startPoint == NULL && endPoint == NULL)
682 : : {
683 : 0 : curveEdgeList.reset();
684 : 0 : edge_ptr = (CubitFacetEdge *)curveEdgeList.get();
685 : 0 : node_ptr = edge_ptr->point(0);
686 : 0 : startPoint = node_ptr;
687 : 0 : endPoint = node_ptr;
688 : : }
689 [ # # ][ # # ]: 0 : else if ( ( startPoint == NULL && endPoint != NULL ) ||
[ # # ]
690 [ # # ]: 0 : ( startPoint != NULL && endPoint == NULL ) )
691 : : {
692 [ # # ][ # # ]: 0 : PRINT_ERROR("Could not determine start and end of curve in ChollaCurve\n");
693 : 0 : return CUBIT_FAILURE;
694 : : }
695 : 0 : return CUBIT_SUCCESS;
696 : : }
697 : :
698 : :
699 : 0 : CubitStatus ChollaCurve::build_curve_facet_eval_tool( void )
700 : : {
701 : : //debug this function as point list is not valid
702 : :
703 [ # # ][ # # ]: 0 : if( this->get_eval_tool() )
704 : : {
705 : 0 : assert(false); //WARNING: Curve facet eval tool already exist!
706 : : }
707 : :
708 [ # # ][ # # ]: 0 : CurveFacetEvalTool *curv_eval_tool_ptr = new CurveFacetEvalTool();
709 : :
710 : : // Step 1: Initialize facet_edge_list and point_list
711 : : CubitStatus stat;
712 [ # # ]: 0 : DLIList<CubitPoint *> point_list;
713 : : int i;
714 : : // insert start point of every facet_edge
715 [ # # ]: 0 : curveEdgeList.reset();
716 [ # # ][ # # ]: 0 : for( i = 0; i < curveEdgeList.size(); i++ )
717 : : {
718 [ # # ][ # # ]: 0 : point_list.append( CAST_TO( curveEdgeList.get_and_step(), CubitFacetEdge )->point(0) );
[ # # ][ # # ]
719 : : }
720 : : // insert end point of last facet_edge
721 [ # # ][ # # ]: 0 : curveEdgeList.step( curveEdgeList.size() - 1 );
722 [ # # ][ # # ]: 0 : point_list.append( CAST_TO( curveEdgeList.get(), CubitFacetEdge )->point(1) );
[ # # ][ # # ]
723 : :
724 [ # # ][ # # ]: 0 : DLIList<CubitFacetEdge *> edge_list;
725 [ # # ][ # # ]: 0 : CAST_LIST( curveEdgeList, edge_list, CubitFacetEdge );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
726 [ # # ]: 0 : stat = curv_eval_tool_ptr->initialize( edge_list, point_list );
727 [ # # ]: 0 : if( stat != CUBIT_SUCCESS )
728 : : {
729 : 0 : return stat;
730 : : }
731 : :
732 : : /*
733 : : // Step 2: find sense of curve_facet_eval_tool /// this is done internally in next Step in initialize()
734 : : if( this->startPoint )
735 : : {
736 : : stat = curv_eval_tool_ptr->find_curv_sense( this->startPoint );
737 : : if( stat != CUBIT_SUCCESS )
738 : : {
739 : : return stat;
740 : : }
741 : : }
742 : : */
743 : : // Step 2: Initialize adj_surface_facet_eval_tool with orientation_wrt_surface
744 [ # # ][ # # ]: 0 : if( surfaceList.size() )
745 : : {
746 : : CubitSense orientation_wrt_surface;
747 [ # # ][ # # ]: 0 : if( CUBIT_SUCCESS == ChollaEngine::determine_curve_orientation( surfaceList.get(), this, orientation_wrt_surface ) )
[ # # ]
748 : : {
749 [ # # ][ # # ]: 0 : if( this->startPoint && this->endPoint )
750 : : {
751 [ # # ]: 0 : stat = curv_eval_tool_ptr->initialize( surfaceList.get()->get_eval_tool(),
752 : : this->startPoint,
753 : : this->endPoint,
754 [ # # ][ # # ]: 0 : orientation_wrt_surface);
755 : : }
756 : : }
757 : : else
758 : : {
759 : 0 : assert(false);
760 : : }
761 : :
762 [ # # ]: 0 : if( stat != CUBIT_SUCCESS )
763 : : {
764 : 0 : assert( false );
765 : : return stat;
766 : : }
767 : : }
768 : : else
769 : : {
770 : 0 : assert(false); //WARNING: No adjacent cholla surface available
771 : : }
772 : :
773 : : // Step 4: assign the new curv_eval_tool to cholla_curve
774 [ # # ]: 0 : assign_eval_tool( curv_eval_tool_ptr );
775 : :
776 [ # # ]: 0 : return stat;
777 : : }
778 : :
779 : : //=============================================================================
780 : : //Function: feature_angle (PRIVATE)
781 : : //Description: compute angles at nodes on the curve to see if we need to split
782 : : // the curve. Mark the node tooldata hitflag if the node will
783 : : // break the curve (this is refernced in next_edge)
784 : : //Author: sjowen
785 : : //Date: 12/4/00
786 : : //=============================================================================
787 : 528 : CubitStatus ChollaCurve::feature_angle(
788 : : double min_dot )
789 : : {
790 : : // first compute all of the edge vector and store with the edge tooldata
791 : :
792 : : int ii, jj;
793 : : FacetEntity *facet_ptr;
794 : : CubitFacetEdge *edge_ptr;
795 : : CubitPoint *start_node;
796 : : CubitPoint *end_node;
797 [ + - ]: 528 : CubitVector tangent;
798 : : TDGeomFacet *td_gm;
799 [ + - ][ + + ]: 1056 : for (ii=0; ii<curveEdgeList.size(); ii++)
800 : : {
801 : :
802 : : // compute the tangent vector of the edge and store it with its tooldata
803 : :
804 [ + - ]: 528 : facet_ptr = curveEdgeList.get_and_step();
805 [ - + ]: 528 : edge_ptr = CAST_TO( facet_ptr, CubitFacetEdge );
806 [ + - ]: 528 : start_node = edge_ptr->point(0);
807 [ + - ]: 528 : end_node = edge_ptr->point(1);
808 [ + - ][ + - ]: 528 : tangent = end_node->coordinates() - start_node->coordinates();
[ + - ][ + - ]
809 [ + - ]: 528 : tangent.normalize();
810 [ + - ]: 528 : td_gm = TDGeomFacet::get_geom_facet( edge_ptr );
811 [ + - ]: 528 : td_gm->set_normal( tangent );
812 : :
813 : : // initialize the nodes tooldata hit flags - set them all to -1
814 : :
815 [ + - ]: 528 : td_gm = TDGeomFacet::get_geom_facet(start_node);
816 [ + - ]: 528 : td_gm->set_hit_flag(-1);
817 [ + - ]: 528 : td_gm = TDGeomFacet::get_geom_facet(end_node);
818 [ + - ]: 528 : td_gm->set_hit_flag(-1);
819 : : }
820 : :
821 : : // now go through them again and compute the dot product between edges
822 : :
823 [ + - ]: 528 : CubitVector tang0;
824 [ + - ]: 528 : CubitVector tang1;
825 : : double dot;
826 : : CubitPoint *node_ptr;
827 : : CubitFacetEdge *next_edge_ptr;
828 : : TDGeomFacet *td_gm_node;
829 : :
830 [ + - ][ + + ]: 1056 : for (ii=0; ii<curveEdgeList.size(); ii++)
831 : : {
832 [ + - ]: 528 : facet_ptr = curveEdgeList.get_and_step();
833 [ - + ]: 528 : edge_ptr = CAST_TO( facet_ptr, CubitFacetEdge );
834 [ + - ]: 528 : start_node = edge_ptr->point(0);
835 [ + - ]: 528 : end_node = edge_ptr->point(1);
836 [ + + ]: 1584 : for (jj=0; jj<2; jj++)
837 : : {
838 [ + + ]: 1056 : node_ptr = (jj==0) ? start_node : end_node;
839 [ + - ]: 1056 : td_gm_node = TDGeomFacet::get_geom_facet( node_ptr );
840 [ + - ][ + - ]: 1056 : if (td_gm_node->get_hit_flag() == -1)
841 : : {
842 [ + - ]: 1056 : next_edge_ptr = next_edge( node_ptr, edge_ptr );
843 [ + - ]: 1056 : if (next_edge_ptr == NULL)
844 : : {
845 [ + - ]: 1056 : td_gm_node->set_hit_flag( 1 );
846 [ + - ]: 1056 : node_ptr->set_as_feature();
847 : : }
848 : : else
849 : : {
850 [ # # ]: 0 : td_gm = TDGeomFacet::get_geom_facet( edge_ptr );
851 [ # # ][ # # ]: 0 : tang0 = td_gm->get_normal();
852 [ # # ]: 0 : td_gm = TDGeomFacet::get_geom_facet( next_edge_ptr );
853 [ # # ][ # # ]: 0 : tang1 = td_gm->get_normal();
854 : :
855 : : // change the sign of the tangent vectors if the
856 : : // sense of the edges are not the same
857 : :
858 [ # # ]: 0 : if (node_ptr == start_node)
859 : : {
860 [ # # ][ # # ]: 0 : if (node_ptr != next_edge_ptr->point(1))
861 [ # # ][ # # ]: 0 : tang0 = -tang0;
862 : : }
863 : : else
864 : : {
865 [ # # ][ # # ]: 0 : if (node_ptr != next_edge_ptr->point(0))
866 [ # # ][ # # ]: 0 : tang0 = -tang0;
867 : : }
868 : :
869 : : // compute the dot product between tangemt vectors
870 : :
871 [ # # ]: 0 : dot = tang0 % tang1;
872 : :
873 : : // set the hit flag if there needs to be a feature break here
874 : :
875 [ # # ]: 0 : if (dot <= min_dot)
876 : : {
877 [ # # ]: 0 : td_gm_node->set_hit_flag( 1 );
878 [ # # ]: 0 : node_ptr->set_as_feature();
879 : : }
880 : : else
881 : : {
882 [ # # ]: 1056 : td_gm_node->set_hit_flag( 0 );
883 : : }
884 : : }
885 : : }
886 : : }
887 : : }
888 : 528 : return CUBIT_SUCCESS;
889 : : }
890 : :
891 : : static int icolor = 0;
892 : 0 : void ChollaCurve::debug_draw()
893 : : {
894 : 0 : icolor++;
895 : 0 : icolor = icolor%15;
896 : 0 : dcolor(icolor);
897 : 0 : dldraw(curveEdgeList);
898 : 0 : }
899 : :
900 : 0 : void ChollaCurve::print()
901 : : {
902 : 0 : FILE *fp = fopen("debug.curve", "a");
903 : 0 : fprintf(fp,"*** Curve %d ***\n", id);
904 [ # # ]: 0 : for (int ii=0; ii<curveEdgeList.size(); ii++)
905 : : {
906 : 0 : FacetEntity *fe_ptr = curveEdgeList.get_and_step();
907 [ # # ]: 0 : CubitFacetEdge *cfe_ptr = CAST_TO(fe_ptr, CubitFacetEdge );
908 : 0 : CubitPoint *cp0_ptr = cfe_ptr->point(0);
909 : 0 : CubitPoint *cp1_ptr = cfe_ptr->point(1);
910 : 0 : fprintf(fp," Edge (%d)\n", cfe_ptr->id() );
911 : : fprintf(fp," Point (%d) %8.4f %8.4f %8.4f\n",
912 : 0 : cp0_ptr->id(), cp0_ptr->x(), cp0_ptr->y(), cp0_ptr->z());
913 : : fprintf(fp," Point (%d) %8.4f %8.4f %8.4f\n",
914 : 0 : cp1_ptr->id(), cp1_ptr->x(), cp1_ptr->y(), cp1_ptr->z());
915 : : }
916 : 0 : fclose(fp);
917 : 0 : }
918 : :
919 : :
920 : : // disassociate from cholla points
921 : 0 : CubitStatus ChollaCurve::disassociate_from_points( void )
922 : : {
923 : :
924 : : /*
925 : : if( startPoint )
926 : : {
927 : : startPoint->remove_curve( this );
928 : : startPoint = NULL;
929 : : }
930 : : if( endPoint )
931 : : {
932 : : endPoint->remove_curve( this );
933 : : endPoint = NULL;
934 : : }
935 : : */
936 : :
937 : : int i;
938 [ # # ]: 0 : for( i = 0; i < pointList.size(); i++ )
939 : : {
940 : 0 : pointList.get_and_step()->remove_curve( this );
941 : : }
942 : 0 : pointList.clean_out();
943 : :
944 : 0 : return CUBIT_SUCCESS;
945 : : }
946 : :
947 : : // disassociate from cholla surface
948 : 0 : CubitStatus ChollaCurve::disassociate_from_surfaces( void)
949 : : {
950 : : int i;
951 [ # # ]: 0 : for( i = 0; i < surfaceList.size(); i++ )
952 : : {
953 : 0 : surfaceList.get_and_step()->remove_curve( this );
954 : : }
955 : 0 : surfaceList.clean_out();
956 : 0 : return CUBIT_SUCCESS;
957 : : }
958 : :
959 : :
960 : 0 : CubitStatus ChollaCurve::replace_facet( FacetEntity *remove_edge, FacetEntity *replace_edge )
961 : : {
962 : 0 : curveEdgeList.move_to( remove_edge );
963 : 0 : curveEdgeList.insert( replace_edge );
964 : 0 : curveEdgeList.remove( remove_edge );
965 : 0 : myLength = MYLENGTH_UNINITIALIZED;
966 : 0 : return CUBIT_SUCCESS;
967 : : }
968 : :
969 : 0 : CubitStatus ChollaCurve::insert_facet( FacetEntity *old_edge, FacetEntity *new_edge )
970 : : {
971 : 0 : curveEdgeList.move_to( old_edge );
972 : 0 : curveEdgeList.insert( new_edge );
973 : :
974 : 0 : return CUBIT_SUCCESS;
975 : : }
976 : :
977 : 0 : CubitStatus ChollaCurve::is_contain( FacetEntity *edge )
978 : : {
979 [ # # ]: 0 : if( curveEdgeList.is_in_list( edge ) )
980 : 0 : return CUBIT_SUCCESS;
981 : : else
982 : 0 : return CUBIT_FAILURE;
983 : : }
984 : :
985 : :
986 : : //=============================================================================
987 : : //Function: is_in_volume (PUBLIC)
988 : : //Description: return whether this curve is contained within the specified volume
989 : : //Author: sjowen
990 : : //Date: 9/11/2009
991 : : //=============================================================================
992 : 0 : CubitBoolean ChollaCurve::is_in_volume( ChollaVolume *chvol_ptr )
993 : : {
994 [ # # ]: 0 : for (int ii=0; ii<surfaceList.size(); ii++)
995 : : {
996 [ # # ]: 0 : ChollaSurface *chsurf_ptr = surfaceList.get_and_step();
997 [ # # ]: 0 : DLIList<ChollaVolume *> chvol_list;
998 [ # # ]: 0 : chsurf_ptr->get_volumes(chvol_list);
999 [ # # ][ # # ]: 0 : for (int jj=0; jj<chvol_list.size(); jj++)
[ # # ][ # # ]
1000 : : {
1001 [ # # ]: 0 : ChollaVolume *mychvol_ptr = chvol_list.get_and_step();
1002 [ # # ]: 0 : if (mychvol_ptr == chvol_ptr)
1003 : 0 : return CUBIT_TRUE;
1004 : : }
1005 : 0 : }
1006 : 0 : return CUBIT_FALSE;
1007 : : }
1008 : :
1009 : : //=============================================================================
1010 : : //Function: is_in_surface (PUBLIC)
1011 : : //Description: return whether this curve is contained within the specified surface
1012 : : //Author: sjowen
1013 : : //Date: 9/18/2009
1014 : : //=============================================================================
1015 : 0 : CubitBoolean ChollaCurve::is_in_surface( ChollaSurface *chsurf_ptr )
1016 : : {
1017 [ # # ]: 0 : for (int ii=0; ii<surfaceList.size(); ii++)
1018 : : {
1019 : 0 : ChollaSurface *mysurf_ptr = surfaceList.get_and_step();
1020 [ # # ]: 0 : if (mysurf_ptr == chsurf_ptr)
1021 : : {
1022 : 0 : return CUBIT_TRUE;
1023 : : }
1024 : : }
1025 : 0 : return CUBIT_FALSE;
1026 : : }
1027 : :
1028 : :
1029 : : //=============================================================================
1030 : : //Function: get_facet_points (PUBLIC)
1031 : : //Description: return the list of facet points on this chollacurve
1032 : : //Notes: inclusive = true will return end points as well, otherwise only
1033 : : // interior points will be returned
1034 : : //Author: sjowen
1035 : : //Date: 9/11/2009
1036 : : //=============================================================================
1037 : 0 : void ChollaCurve::get_facet_points( DLIList<CubitPoint *> &point_list, CubitBoolean inclusive)
1038 : : {
1039 : : FacetEntity *fe_ptr;
1040 : : CubitFacetEdge *edge_ptr;
1041 : : CubitPoint *pts[2];
1042 [ # # ][ # # ]: 0 : for (int ii=0; ii<curveEdgeList.size(); ii++)
1043 : : {
1044 [ # # ]: 0 : fe_ptr = curveEdgeList.get_and_step();
1045 [ # # ]: 0 : edge_ptr = dynamic_cast<CubitFacetEdge *> (fe_ptr);
1046 [ # # ]: 0 : assert(edge_ptr != NULL);
1047 [ # # ]: 0 : for (int jj=0; jj<2; jj++)
1048 : : {
1049 [ # # ]: 0 : pts[jj] = edge_ptr->point(jj);
1050 [ # # ]: 0 : if (inclusive)
1051 : : {
1052 [ # # ]: 0 : point_list.append(pts[jj]);
1053 : : }
1054 : : else
1055 : : {
1056 [ # # ][ # # ]: 0 : if (pts[jj] != startPoint && pts[jj] != endPoint)
1057 : : {
1058 [ # # ]: 0 : point_list.append(pts[jj]);
1059 : : }
1060 : : }
1061 : : }
1062 : : }
1063 [ # # ]: 0 : point_list.uniquify_ordered();
1064 : 0 : }
1065 : :
1066 : : //=============================================================================
1067 : : //Function: has_point (PUBLIC)
1068 : : //Description: return whether the curve contains the gicen point
1069 : : //Notes:
1070 : : //=============================================================================
1071 : 0 : CubitBoolean ChollaCurve::has_point( ChollaPoint *chpt )
1072 : : {
1073 [ # # ]: 0 : for(int ii=0; ii<pointList.size(); ii++)
1074 : : {
1075 : 0 : ChollaPoint *pt = pointList.get_and_step();
1076 [ # # ]: 0 : if (pt == chpt)
1077 : 0 : return CUBIT_TRUE;
1078 : : }
1079 : 0 : return CUBIT_FALSE;
1080 : : }
1081 : :
1082 : : //=============================================================================
1083 : : //Function: verify_points (PUBLIC)
1084 : : //Description: verify that all points on this curve have this curve as an adjacency
1085 : : //Notes:
1086 : : //=============================================================================
1087 : 0 : CubitStatus ChollaCurve::verify_points()
1088 : : {
1089 [ # # ]: 0 : for(int ii=0; ii<pointList.size(); ii++)
1090 : : {
1091 : 0 : ChollaPoint *pt = pointList.get_and_step();
1092 [ # # ]: 0 : if (!pt->is_in_curve(this))
1093 : 0 : return CUBIT_FAILURE;
1094 : : }
1095 : 0 : return CUBIT_SUCCESS;
1096 : : }
1097 : :
1098 : 0 : int ChollaCurve::num_volumes()
1099 : : {
1100 : :
1101 [ # # ]: 0 : DLIList<ChollaVolume *> chvol_list;
1102 [ # # ][ # # ]: 0 : for (int i=0; i<surfaceList.size(); i++)
1103 : : {
1104 [ # # ]: 0 : ChollaSurface *chsurf_ptr = surfaceList.get_and_step();
1105 [ # # ]: 0 : DLIList<ChollaVolume*> tmp_vols;
1106 [ # # ]: 0 : chsurf_ptr->get_volumes(tmp_vols);
1107 [ # # ]: 0 : chvol_list += tmp_vols;
1108 [ # # ]: 0 : }
1109 : :
1110 [ # # ]: 0 : chvol_list.uniquify_unordered();
1111 [ # # ][ # # ]: 0 : return chvol_list.size();
1112 [ + - ][ + - ]: 6540 : }
1113 : :
1114 : : //EOF
1115 : :
|
