Branch data Line data Source code
1 : : //- Class: TDFacetBoundaryPoint
2 : : //- Description: Tool data for storing additional information at
3 : : //- the boundary of a facet set
4 : : //- Owner: Steve Owen
5 : : //- Checked by:
6 : : //- Version:
7 : :
8 : : #include "TDFacetBoundaryPoint.hpp"
9 : : #include "CubitPoint.hpp"
10 : : #include "CubitFacet.hpp"
11 : : #include "CubitQuadFacet.hpp"
12 : : #include "CubitFacetEdge.hpp"
13 : : #include "CastTo.hpp"
14 : : #include "CubitTransformMatrix.hpp"
15 : : #include "GfxDebug.hpp"
16 : : #include "CubitMessage.hpp"
17 : :
18 [ + - ]: 1496 : TDFacetBoundaryPoint::TDFacetBoundaryPoint()
19 : : {
20 : :
21 : 748 : }
22 : :
23 [ # # ]: 0 : TDFacetBoundaryPoint::~TDFacetBoundaryPoint()
24 : : {
25 [ # # ][ # # ]: 0 : for (int ii=0; ii<pointDataList.size(); ii++)
26 : : {
27 [ # # ]: 0 : BoundaryPointData *bpd_ptr = pointDataList.get_and_step();
28 [ # # ][ # # ]: 0 : delete bpd_ptr;
29 : : }
30 [ # # ]: 0 : }
31 : :
32 : :
33 : : //-------------------------------------------------------------------------
34 : : // Purpose : create a new facet boundary edge
35 : : //
36 : : // Special Notes :
37 : : //
38 : : // Creator : Steve Owen
39 : : //
40 : : // Creation Date : 05/01
41 : : //-------------------------------------------------------------------------
42 : 748 : CubitStatus TDFacetBoundaryPoint::add_facet_boundary_point(
43 : : CubitPoint *point_ptr )
44 : : {
45 : : ToolData *td;
46 : 748 : td = point_ptr->get_TD(&TDFacetBoundaryPoint::is_facet_boundary_point);
47 [ + - ]: 748 : if ( td == NULL )
48 : : {
49 [ + - ]: 748 : TDFacetBoundaryPoint *td_gm = new TDFacetBoundaryPoint;
50 : 748 : point_ptr->add_TD( td_gm);
51 : 748 : td_gm->set_point( point_ptr );
52 : : }
53 : : else
54 : : {
55 [ # # ]: 0 : TDFacetBoundaryPoint *td_gm = CAST_TO(td, TDFacetBoundaryPoint);
56 : 0 : td_gm->set_point( point_ptr );
57 : : }
58 : 748 : return CUBIT_SUCCESS;
59 : : }
60 : :
61 : : //-------------------------------------------------------------------------
62 : : // Purpose : create a new facet boundary point
63 : : //
64 : : // Special Notes : this is used to create and initialize with one facet
65 : : // and its corresponding normal.
66 : : //
67 : : // Creator : Steve Owen
68 : : //
69 : : // Creation Date : 05/01
70 : : //-------------------------------------------------------------------------
71 : 0 : CubitStatus TDFacetBoundaryPoint::add_facet_boundary_point(
72 : : CubitPoint *point_ptr,
73 : : CubitFacet *facet_ptr,
74 : : CubitVector &pt_normal )
75 : : {
76 : : ToolData *td;
77 : 0 : TDFacetBoundaryPoint *td_gm = NULL;
78 [ # # ]: 0 : td = point_ptr->get_TD(&TDFacetBoundaryPoint::is_facet_boundary_point);
79 [ # # ]: 0 : if ( td == NULL )
80 : : {
81 [ # # ][ # # ]: 0 : td_gm = new TDFacetBoundaryPoint;
82 [ # # ]: 0 : point_ptr->add_TD( td_gm);
83 [ # # ]: 0 : td_gm->set_point( point_ptr );
84 : : }
85 : : else
86 : : {
87 [ # # ]: 0 : td_gm = CAST_TO(td, TDFacetBoundaryPoint);
88 [ # # ]: 0 : td_gm->set_point( point_ptr );
89 : : }
90 : :
91 [ # # ][ # # ]: 0 : BoundaryPointData *bpd_ptr = new BoundaryPointData;
92 [ # # ]: 0 : bpd_ptr->surfFacetList.append( facet_ptr );
93 : 0 : bpd_ptr->surfID = -1;
94 : 0 : bpd_ptr->uVal = 0.0;
95 : 0 : bpd_ptr->vVal = 0.0;
96 : 0 : bpd_ptr->sizeVal = 0.0;
97 [ # # ]: 0 : bpd_ptr->normal = pt_normal;
98 [ # # ]: 0 : td_gm->pointDataList.append( bpd_ptr );
99 : :
100 : 0 : return CUBIT_SUCCESS;
101 : : }
102 : :
103 : : //-------------------------------------------------------------------------
104 : : // Purpose : create a new facet boundary point
105 : : //
106 : : // Special Notes : this is used to create and initialize with one facet
107 : : // and its corresponding normal. Same as above but uses
108 : : // a CubitQuadFacet
109 : : //
110 : : // Creator : Steve Owen
111 : : //
112 : : // Creation Date : 01/2004
113 : : //-------------------------------------------------------------------------
114 : 0 : CubitStatus TDFacetBoundaryPoint::add_facet_boundary_point(
115 : : CubitPoint *point_ptr,
116 : : CubitQuadFacet *qfacet_ptr,
117 : : CubitVector &pt_normal )
118 : : {
119 : : ToolData *td;
120 : 0 : TDFacetBoundaryPoint *td_gm = NULL;
121 [ # # ]: 0 : td = point_ptr->get_TD(&TDFacetBoundaryPoint::is_facet_boundary_point);
122 [ # # ]: 0 : if ( td == NULL )
123 : : {
124 [ # # ][ # # ]: 0 : td_gm = new TDFacetBoundaryPoint;
125 [ # # ]: 0 : point_ptr->add_TD( td_gm);
126 [ # # ]: 0 : td_gm->set_point( point_ptr );
127 : : }
128 : : else
129 : : {
130 [ # # ]: 0 : td_gm = CAST_TO(td, TDFacetBoundaryPoint);
131 [ # # ]: 0 : td_gm->set_point( point_ptr );
132 : : }
133 : :
134 [ # # ]: 0 : CubitFacet *facet0 = qfacet_ptr->get_tri_facet(0);
135 [ # # ]: 0 : CubitFacet *facet1 = qfacet_ptr->get_tri_facet(1);
136 : :
137 [ # # ][ # # ]: 0 : BoundaryPointData *bpd_ptr = new BoundaryPointData;
138 [ # # ][ # # ]: 0 : if (facet0->point_index( point_ptr ) >= 0)
139 [ # # ]: 0 : bpd_ptr->surfFacetList.append( facet0 );
140 [ # # ][ # # ]: 0 : if (facet1->point_index( point_ptr ) >= 0)
141 [ # # ]: 0 : bpd_ptr->surfFacetList.append( facet1 );
142 : 0 : bpd_ptr->surfID = -1;
143 : 0 : bpd_ptr->uVal = 0.0;
144 : 0 : bpd_ptr->vVal = 0.0;
145 : 0 : bpd_ptr->sizeVal = 0.0;
146 [ # # ]: 0 : bpd_ptr->normal = pt_normal;
147 [ # # ]: 0 : td_gm->pointDataList.append( bpd_ptr );
148 : :
149 : 0 : return CUBIT_SUCCESS;
150 : : }
151 : :
152 : : //-------------------------------------------------------------------------
153 : : // Purpose : get the facet boundary point from a point
154 : : //
155 : : // Special Notes :
156 : : //
157 : : // Creator : Steve Owen
158 : : //
159 : : // Creation Date : 05/01
160 : : //-------------------------------------------------------------------------
161 : 9372 : TDFacetBoundaryPoint* TDFacetBoundaryPoint::get_facet_boundary_point(
162 : : CubitPoint *point_ptr )
163 : : {
164 : : ToolData *td;
165 : 9372 : td = point_ptr->get_TD(&TDFacetBoundaryPoint::is_facet_boundary_point);
166 [ + + ]: 9372 : if ( td != NULL )
167 : : {
168 [ - + ]: 7304 : TDFacetBoundaryPoint *td_gm = CAST_TO(td, TDFacetBoundaryPoint);
169 : 7304 : return td_gm;
170 : : }
171 : 2068 : return (TDFacetBoundaryPoint*) NULL;
172 : : }
173 : :
174 : :
175 : : //-------------------------------------------------------------------------
176 : : // Purpose : add a group of facets that are adjacent to this point
177 : : // that are on the same surface
178 : : //
179 : : // Special Notes :
180 : : //
181 : : // Creator : Steve Owen
182 : : //
183 : : // Creation Date : 05/01
184 : : //-------------------------------------------------------------------------
185 : 1276 : void TDFacetBoundaryPoint::add_surf_facets(
186 : : DLIList<CubitFacet *> adj_facet_list )
187 : : {
188 [ + - ][ + - ]: 1276 : BoundaryPointData *bpd_ptr = new BoundaryPointData;
189 : : int ii;
190 [ + - ][ + + ]: 3520 : for (ii=0; ii<adj_facet_list.size(); ii++)
191 : : {
192 [ + - ]: 2244 : CubitFacet *facet_ptr = adj_facet_list.get_and_step();
193 [ + - ]: 2244 : bpd_ptr->surfFacetList.append( facet_ptr );
194 : : }
195 : :
196 : 1276 : bpd_ptr->surfID = -1;
197 : 1276 : bpd_ptr->uVal = 0.0;
198 : 1276 : bpd_ptr->vVal = 0.0;
199 : 1276 : bpd_ptr->sizeVal = 0.0;
200 [ + - ]: 1276 : pointDataList.append( bpd_ptr );
201 [ + - ]: 1276 : init_normal( bpd_ptr );
202 : 1276 : }
203 : :
204 : : //-------------------------------------------------------------------------
205 : : // Purpose : get the normal from a boundary point
206 : : //
207 : : // Special Notes :
208 : : //
209 : : // Creator : Steve Owen
210 : : //
211 : : // Creation Date : 05/01
212 : : //-------------------------------------------------------------------------
213 : 0 : CubitStatus TDFacetBoundaryPoint::get_normal( int surf_id,
214 : : CubitVector &normal )
215 : : {
216 : 0 : int found = 0;
217 : 0 : BoundaryPointData *bpd_ptr = NULL;
218 [ # # ]: 0 : for (int ii=0; ii<pointDataList.size(); ii++)
219 : : {
220 : 0 : bpd_ptr = pointDataList.get_and_step();
221 [ # # ]: 0 : if(bpd_ptr->surfID == surf_id)
222 : 0 : found = 1;
223 : : }
224 [ # # ]: 0 : if (!found) // the surf_id does not match any in the list
225 : 0 : return CUBIT_FAILURE;
226 : :
227 : 0 : normal = bpd_ptr->normal;
228 : :
229 : 0 : return CUBIT_SUCCESS;
230 : : }
231 : :
232 : : //-------------------------------------------------------------------------
233 : : // Purpose : get the normal from a boundary point based on its
234 : : // adjacent facet
235 : : //
236 : : // Special Notes :
237 : : //
238 : : // Creator : Steve Owen
239 : : //
240 : : // Creation Date : 05/01
241 : : //-------------------------------------------------------------------------
242 : 2640 : CubitStatus TDFacetBoundaryPoint::get_normal( CubitFacet *adj_facet,
243 : : CubitVector &normal )
244 : : {
245 : 2640 : BoundaryPointData *bpd_ptr = get_bpd( adj_facet );
246 [ - + ]: 2640 : if (!bpd_ptr)
247 : 0 : return CUBIT_FAILURE;
248 : 2640 : normal = bpd_ptr->normal;
249 : 2640 : return CUBIT_SUCCESS;
250 : : }
251 : :
252 : : //-------------------------------------------------------------------------
253 : : // Purpose : get the normal from a boundary point based on its
254 : : // adjacent edge
255 : : //
256 : : // Special Notes : this is really only unique if the edge is non-manifold
257 : : // or the facets adjacent the edge all lie on the same
258 : : // surface
259 : : //
260 : : // Creator : Steve Owen
261 : : //
262 : : // Creation Date : 05/01
263 : : //-------------------------------------------------------------------------
264 : 132 : CubitStatus TDFacetBoundaryPoint::get_normal( CubitFacetEdge *edge_ptr,
265 : : CubitVector &normal )
266 : : {
267 [ + - ]: 132 : DLIList<CubitFacet *>adj_facets;
268 [ + - ]: 132 : edge_ptr->facets(adj_facets);
269 : 132 : BoundaryPointData *bpd_ptr = NULL;
270 [ + - ][ + - ]: 264 : for (int ii=0; ii<adj_facets.size() && bpd_ptr == NULL; ii++)
[ + + ][ + + ]
271 : : {
272 [ + - ][ + - ]: 132 : bpd_ptr = get_bpd( adj_facets.get_and_step() );
273 : : }
274 [ - + ]: 132 : if (!bpd_ptr)
275 : 0 : return CUBIT_FAILURE;
276 [ + - ]: 132 : normal = bpd_ptr->normal;
277 [ + - ]: 132 : return CUBIT_SUCCESS;
278 : : }
279 : :
280 : : //-------------------------------------------------------------------------
281 : : // Purpose : set the normal into a boundary point
282 : : //
283 : : // Special Notes :
284 : : //
285 : : // Creator : Steve Owen
286 : : //
287 : : // Creation Date : 05/01
288 : : //-------------------------------------------------------------------------
289 : 0 : CubitStatus TDFacetBoundaryPoint::set_normal( int surf_id,
290 : : CubitVector &normal )
291 : : {
292 : 0 : int found = 0;
293 : 0 : BoundaryPointData *bpd_ptr = NULL;
294 [ # # ]: 0 : for (int ii=0; ii<pointDataList.size(); ii++)
295 : : {
296 : 0 : bpd_ptr = pointDataList.get_and_step();
297 [ # # ]: 0 : if(bpd_ptr->surfID == surf_id)
298 : 0 : found = 1;
299 : : }
300 [ # # ]: 0 : if (!found) // the surf_id does not match any in the list
301 : 0 : return CUBIT_FAILURE;
302 : :
303 : 0 : bpd_ptr->normal = normal;
304 : :
305 : 0 : return CUBIT_SUCCESS;
306 : : }
307 : :
308 : : //-------------------------------------------------------------------------
309 : : // Purpose : reset the all normals for boundary points
310 : : //
311 : : // Special Notes :
312 : : //
313 : : // Creator : Michael Brewer
314 : : //
315 : : // Creation Date : 02/05
316 : : //-------------------------------------------------------------------------
317 : 0 : CubitStatus TDFacetBoundaryPoint::reset_normals( )
318 : : {
319 : : BoundaryPointData *bpd_ptr;
320 [ # # ]: 0 : for (int ii=0; ii<pointDataList.size(); ii++)
321 : : {
322 : 0 : bpd_ptr = pointDataList.get_and_step();
323 [ # # ]: 0 : if(bpd_ptr)
324 : 0 : init_normal(bpd_ptr);
325 : : else{
326 [ # # ][ # # ]: 0 : PRINT_ERROR("Could not determine boundary point data.\n");
327 : 0 : return CUBIT_FAILURE;
328 : : }
329 : : }
330 : 0 : return CUBIT_SUCCESS;
331 : : }
332 : :
333 : : //-------------------------------------------------------------------------
334 : : // Purpose : set the surface id of associated with one of the
335 : : // facets adjacent to this point
336 : : //
337 : : // Special Notes :
338 : : //
339 : : // Creator : Steve Owen
340 : : //
341 : : // Creation Date : 05/01
342 : : //-------------------------------------------------------------------------
343 : 2244 : void TDFacetBoundaryPoint::set_surf_id( CubitFacet *facet_ptr, int surf_id )
344 : : {
345 : 2244 : int found = 0;
346 : : int ii, jj;
347 : : CubitFacet *check_facet_ptr;
348 : : BoundaryPointData *bpd_ptr;
349 [ + + ][ + + ]: 7249 : for (ii=0; ii<pointDataList.size() && !found; ii++)
[ + + ]
350 : : {
351 : 5005 : bpd_ptr = pointDataList.get_and_step();
352 [ + + ][ + + ]: 13079 : for (jj=0; jj<bpd_ptr->surfFacetList.size() && !found; jj++)
[ + + ]
353 : : {
354 : 8074 : check_facet_ptr = bpd_ptr->surfFacetList.get_and_step();
355 [ + + ]: 8074 : if (check_facet_ptr == facet_ptr)
356 : : {
357 : 2244 : found = 1;
358 : 2244 : bpd_ptr->surfID = surf_id;
359 : : }
360 : : }
361 : : }
362 [ - + ]: 2244 : assert(found); // couldn't find the facet adjacent the surface
363 : 2244 : }
364 : :
365 : : //-------------------------------------------------------------------------
366 : : // Purpose : compute and set the normal
367 : : //
368 : : // Special Notes :
369 : : //
370 : : // Creator : Steve Owen
371 : : //
372 : : // Creation Date : 05/01
373 : : //-------------------------------------------------------------------------
374 : 1276 : void TDFacetBoundaryPoint::init_normal( BoundaryPointData *bpd_ptr )
375 : : {
376 : :
377 [ + - ][ + - ]: 1276 : if (bpd_ptr && bpd_ptr->surfFacetList.size() > 0) {
[ + - ]
378 : : CubitFacet *facet;
379 : : double angle;
380 : : int j;
381 [ + - ]: 1276 : CubitVector normal;
382 [ + - ]: 1276 : CubitVector avg_normal(0.0e0, 0.0e0, 0.0e0);
383 : 1276 : double totangle = 0.0e0;
384 : :
385 : : // weight the normal by the spanning angle at the point
386 : 1276 : int mydebug =0;
387 [ + - ][ + + ]: 3520 : for (j = 0; j < bpd_ptr->surfFacetList.size(); j++)
388 : : {
389 [ + - ]: 2244 : facet = bpd_ptr->surfFacetList.get_and_step();
390 [ + - ]: 2244 : angle = facet->angle( pointPtr );
391 [ + - ]: 2244 : facet->weight( angle );
392 : 2244 : totangle += angle;
393 [ - + ]: 2244 : if(mydebug){
394 [ # # ]: 0 : if(angle <= 0.0){
395 [ # # ][ # # ]: 0 : PRINT_INFO("Small angle.\n");
[ # # ][ # # ]
396 : : }
397 : : }
398 : : }
399 : : //First...
400 : : // Attempt to handle this very odd case. There is a facet with
401 : : // zero area on the boundary. Set normal to that of an adjacet
402 : : // facet that doesn't have zero area.
403 [ - + ][ # # ]: 1276 : if(totangle == 0 && bpd_ptr->surfFacetList.size() == 1){
[ # # ][ - + ]
404 [ # # ][ # # ]: 0 : PRINT_WARNING("Degenerate facet on edge of boundary.\n");
[ # # ][ # # ]
405 [ # # ]: 0 : facet = bpd_ptr->surfFacetList.get_and_step();
406 : :
407 : : CubitPoint* my_pt[3];
408 [ # # ]: 0 : my_pt[0] = facet->point(0);
409 [ # # ]: 0 : my_pt[1] = facet->point(1);
410 [ # # ]: 0 : my_pt[2] = facet->point(2);
411 : 0 : double largest_area=-1.0;
412 : 0 : double current_area=0.0;
413 [ # # ][ # # ]: 0 : if(my_pt[0] == NULL || my_pt[1] == NULL || my_pt[2] == NULL){
[ # # ]
414 [ # # ][ # # ]: 0 : PRINT_ERROR("Problem determining normal.\n");
[ # # ][ # # ]
415 : 0 : return;
416 : : }
417 : :
418 : : int tmp_i;
419 [ # # ]: 0 : for(tmp_i = 0; tmp_i < 3; tmp_i++){
420 : : CubitFacet* other_facet = facet->shared_facet(my_pt[tmp_i],
421 [ # # ]: 0 : my_pt[(tmp_i+1)%3]);
422 [ # # ]: 0 : if(other_facet != NULL){
423 [ # # ]: 0 : if(mydebug)
424 [ # # ]: 0 : other_facet->debug_draw(CUBIT_WHITE_INDEX);
425 [ # # ]: 0 : current_area=other_facet->area();
426 [ # # ]: 0 : if(current_area>largest_area){
427 : 0 : largest_area=current_area;
428 [ # # ][ # # ]: 0 : normal=other_facet->normal();
429 : : }
430 : : }
431 : : }
432 [ # # ]: 0 : if(largest_area < CUBIT_DBL_MIN){
433 [ # # ][ # # ]: 0 : PRINT_ERROR("Could not initialize facet normal.\n");
[ # # ][ # # ]
434 : 0 : return;
435 : : }
436 [ # # ]: 0 : if(mydebug){
437 [ # # ]: 0 : facet->debug_draw(CUBIT_RED_INDEX);
438 [ # # ][ # # ]: 0 : PRINT_INFO("\n\nLargest area = %f\n\n",largest_area);
[ # # ][ # # ]
439 [ # # ]: 0 : GfxDebug::mouse_xforms();
440 : : }
441 [ # # ]: 0 : bpd_ptr->normal = normal;
442 : :
443 : : }
444 : : //Now...
445 : : // Handle the normal case.
446 : : else{
447 [ + - ][ + + ]: 3520 : for (j = 0; j < bpd_ptr->surfFacetList.size(); j++)
448 : : {
449 [ + - ]: 2244 : facet = bpd_ptr->surfFacetList.get_and_step();
450 [ + - ][ + - ]: 2244 : normal = facet->normal();
451 [ + - ]: 2244 : normal.normalize();
452 [ + - ][ + - ]: 2244 : avg_normal += (facet->weight() / totangle) * normal;
[ + - ]
453 : : }
454 [ + - ]: 1276 : avg_normal.normalize();
455 [ + - ]: 1276 : bpd_ptr->normal = avg_normal;
456 : : }
457 : : }
458 : : }
459 : :
460 : : //-------------------------------------------------------------------------
461 : : // Purpose : return the boundary point data associated with a facet
462 : : //
463 : : // Special Notes :
464 : : //
465 : : // Creator : Steve Owen
466 : : //
467 : : // Creation Date : 05/01
468 : : //-------------------------------------------------------------------------
469 : 2772 : BoundaryPointData *TDFacetBoundaryPoint::get_bpd( CubitFacet *facet )
470 : : {
471 : 2772 : BoundaryPointData *bpd_ptr = NULL;
472 : 2772 : int found = 0;
473 : : int ii, jj;
474 [ + - ][ + - ]: 6193 : for (ii=0; ii<pointDataList.size() && !found; ii++)
[ + - ]
475 : : {
476 : 6193 : bpd_ptr = pointDataList.get_and_step();
477 [ + + ][ + - ]: 12133 : for (jj=0; jj<bpd_ptr->surfFacetList.size() && !found; jj++)
[ + + ]
478 : : {
479 [ + + ]: 8712 : if (bpd_ptr->surfFacetList.get_and_step() == facet)
480 : 2772 : return bpd_ptr;
481 : : }
482 : : }
483 : :
484 : 0 : return NULL;
485 : : }
486 : :
487 : : //===============================================================================
488 : : //Function: merge_normals (PRIVATE)
489 : : //Description: Enforce continuity across facets by merging the normals at two
490 : : // points. Assumes the points are coincident.
491 : : //Date: 05/01
492 : : //===============================================================================
493 : 0 : CubitStatus TDFacetBoundaryPoint::merge_normals(
494 : : CubitFacet *facet0,
495 : : CubitFacet *facet1)
496 : : {
497 : :
498 [ # # ]: 0 : BoundaryPointData *bpd0_ptr = get_bpd( facet0 );
499 [ # # ]: 0 : BoundaryPointData *bpd1_ptr = get_bpd( facet1 );
500 [ # # ][ # # ]: 0 : if (!bpd0_ptr || !bpd1_ptr)
501 : 0 : return CUBIT_FAILURE;
502 : :
503 [ # # ]: 0 : CubitVector avg_normal(0.0e0, 0.0e0, 0.0e0);
504 : 0 : double totangle = 0.0e0;
505 : : double angle;
506 : : CubitFacet *facet;
507 : : int j;
508 : :
509 : : // weight the normal by the spanning angle at the point
510 : :
511 [ # # ][ # # ]: 0 : for (j = 0; j < bpd0_ptr->surfFacetList.size(); j++)
512 : : {
513 [ # # ]: 0 : facet = bpd0_ptr->surfFacetList.get_and_step();
514 [ # # ]: 0 : angle = facet->angle( pointPtr );
515 [ # # ]: 0 : facet->weight( angle );
516 : 0 : totangle += angle;
517 : : }
518 : :
519 [ # # ][ # # ]: 0 : for (j = 0; j < bpd1_ptr->surfFacetList.size(); j++)
520 : : {
521 [ # # ]: 0 : facet = bpd1_ptr->surfFacetList.get_and_step();
522 [ # # ]: 0 : angle = facet->angle( pointPtr );
523 [ # # ]: 0 : facet->weight( angle );
524 : 0 : totangle += angle;
525 : : }
526 : :
527 : : // computed weighted normal
528 : :
529 [ # # ]: 0 : CubitVector normal;
530 [ # # ][ # # ]: 0 : for (j = 0; j < bpd0_ptr->surfFacetList.size(); j++)
531 : : {
532 [ # # ]: 0 : facet = bpd0_ptr->surfFacetList.get_and_step();
533 [ # # ][ # # ]: 0 : normal = facet->normal();
534 [ # # ]: 0 : normal.normalize();
535 [ # # ][ # # ]: 0 : avg_normal += (facet->weight() / totangle) * normal;
[ # # ]
536 : : }
537 : :
538 : : // orientation of facets may be opposite on opposing surfaces.
539 : : // Check for this case and correct of necessary
540 : :
541 [ # # ][ # # ]: 0 : CubitVector norm0, norm1;
542 [ # # ]: 0 : norm0 = bpd0_ptr->normal;
543 [ # # ]: 0 : norm0.normalize();
544 [ # # ]: 0 : norm1 = bpd1_ptr->normal;
545 [ # # ]: 0 : norm1.normalize();
546 [ # # ]: 0 : double dot = norm0 % norm1;
547 : 0 : double sign = 1.0;
548 [ # # ]: 0 : if (dot < 0.0)
549 : 0 : sign = -1.0;
550 : :
551 [ # # ][ # # ]: 0 : for (j = 0; j < bpd1_ptr->surfFacetList.size(); j++)
552 : : {
553 [ # # ]: 0 : facet = bpd1_ptr->surfFacetList.get_and_step();
554 [ # # ][ # # ]: 0 : normal = sign * facet->normal();
[ # # ]
555 [ # # ]: 0 : normal.normalize();
556 [ # # ][ # # ]: 0 : avg_normal += (facet->weight() / totangle) * normal;
[ # # ]
557 : : }
558 : :
559 : : // set the new normal on both points
560 : :
561 [ # # ]: 0 : avg_normal.normalize();
562 [ # # ]: 0 : bpd0_ptr->normal = avg_normal;
563 [ # # ]: 0 : CubitVector temp_vector = sign * avg_normal;
564 [ # # ]: 0 : bpd1_ptr->normal = temp_vector;
565 : :
566 : 0 : return CUBIT_SUCCESS;
567 : : }
568 : :
569 : : //===============================================================================
570 : : //Function: set_uv (PUBLIC)
571 : : //Description: set the u-v values on a boundary point data
572 : : //Date: 06/01
573 : : //===============================================================================
574 : 0 : CubitStatus TDFacetBoundaryPoint::set_uv( CubitFacet *adj_facet,
575 : : double u, double v )
576 : : {
577 : 0 : BoundaryPointData *bpd_ptr = get_bpd( adj_facet );
578 [ # # ]: 0 : if (!bpd_ptr)
579 : 0 : return CUBIT_FAILURE;
580 : 0 : bpd_ptr->uVal = u;
581 : 0 : bpd_ptr->vVal = v;
582 : 0 : return CUBIT_SUCCESS;
583 : : }
584 : : //===============================================================================
585 : : //Function: set_uvs (PUBLIC)
586 : : //Description: set the u-v values and size on a boundary point data
587 : : //Date: 06/01
588 : : //===============================================================================
589 : 0 : CubitStatus TDFacetBoundaryPoint::set_uvs( CubitFacet *adj_facet,
590 : : double u, double v, double s )
591 : : {
592 : 0 : BoundaryPointData *bpd_ptr = get_bpd( adj_facet );
593 [ # # ]: 0 : if (!bpd_ptr)
594 : 0 : return CUBIT_FAILURE;
595 : 0 : bpd_ptr->uVal = u;
596 : 0 : bpd_ptr->vVal = v;
597 : 0 : bpd_ptr->sizeVal = s;
598 : 0 : return CUBIT_SUCCESS;
599 : : }
600 : : //===============================================================================
601 : : //Function: u (PUBLIC)
602 : : //Description: get the u value from a boundary point data
603 : : //Date: 06/01
604 : : //===============================================================================
605 : 0 : double TDFacetBoundaryPoint::u( CubitFacet *adj_facet )
606 : : {
607 : 0 : BoundaryPointData *bpd_ptr = get_bpd( adj_facet );
608 [ # # ]: 0 : assert( bpd_ptr != 0 ); // adjacent facet was not found in list
609 : 0 : return bpd_ptr->uVal;
610 : : }
611 : :
612 : : //===============================================================================
613 : : //Function: v (PUBLIC)
614 : : //Description: get the v value from a boundary point data
615 : : //Date: 06/01
616 : : //===============================================================================
617 : 0 : double TDFacetBoundaryPoint::v( CubitFacet *adj_facet )
618 : : {
619 : 0 : BoundaryPointData *bpd_ptr = get_bpd( adj_facet );
620 [ # # ]: 0 : assert( bpd_ptr != 0 ); // adjacent facet was not found in list
621 : 0 : return bpd_ptr->vVal;
622 : : }
623 : : //===============================================================================
624 : : //Function: s (PUBLIC)
625 : : //Description: get the s value from a boundary point data
626 : : //Date: 07/02
627 : : //===============================================================================
628 : 0 : double TDFacetBoundaryPoint::s( CubitFacet *adj_facet )
629 : : {
630 : 0 : BoundaryPointData *bpd_ptr = get_bpd( adj_facet );
631 [ # # ]: 0 : assert( bpd_ptr != 0 ); // adjacent facet was not found in list
632 : 0 : return bpd_ptr->sizeVal;
633 : : }
634 : : //===============================================================================
635 : : //Function: get_uv (PUBLIC)
636 : : //Description: get the uv values from a boundary point data
637 : : //Date: 06/01
638 : : //===============================================================================
639 : 0 : CubitStatus TDFacetBoundaryPoint::get_uv( CubitFacet *adj_facet,
640 : : double &u, double &v )
641 : : {
642 : 0 : BoundaryPointData *bpd_ptr = get_bpd( adj_facet );
643 [ # # ]: 0 : if (!bpd_ptr)
644 : 0 : return CUBIT_FAILURE;
645 : 0 : u = bpd_ptr->uVal;
646 : 0 : v = bpd_ptr->vVal;
647 : 0 : return CUBIT_SUCCESS;
648 : : }
649 : :
650 : : //===============================================================================
651 : : //Function: get_uvs (PUBLIC)
652 : : //Description: get the uv values and size from a boundary point data
653 : : //Date: 7/02
654 : : //===============================================================================
655 : 0 : CubitStatus TDFacetBoundaryPoint::get_uvs( CubitFacet *adj_facet,
656 : : double &u, double &v, double &s )
657 : : {
658 : 0 : BoundaryPointData *bpd_ptr = get_bpd( adj_facet );
659 [ # # ]: 0 : if (!bpd_ptr)
660 : 0 : return CUBIT_FAILURE;
661 : 0 : u = bpd_ptr->uVal;
662 : 0 : v = bpd_ptr->vVal;
663 : 0 : s = bpd_ptr->sizeVal;
664 : 0 : return CUBIT_SUCCESS;
665 : : }
666 : :
667 : : //===============================================================================
668 : : //Function: rotate_normal (PUBLIC)
669 : : //Description: rotate the normal at this point
670 : : //Date: 03/02
671 : : //===============================================================================
672 : 0 : CubitStatus TDFacetBoundaryPoint::rotate_normal( CubitTransformMatrix &rotmat )
673 : : {
674 : : BoundaryPointData * bpd_ptr;
675 : :
676 : : int ii;
677 [ # # ]: 0 : for (ii=0; ii<pointDataList.size(); ii++)
678 : : {
679 : 0 : bpd_ptr = pointDataList.get_and_step();
680 [ # # ]: 0 : bpd_ptr->normal = rotmat * bpd_ptr->normal;
681 : : }
682 : 0 : return CUBIT_SUCCESS;
683 : : }
684 : :
685 : : //===============================================================================
686 : : //Function: get_boundary_point_data_size (PUBLIC)
687 : : //Description: get the size of the boundary point data for mem alloc. purposes
688 : : //Date: 01/23/2003
689 : : //===============================================================================
690 : 484 : CubitStatus TDFacetBoundaryPoint::get_boundary_point_data_size(
691 : : int &size_int_data,
692 : : int &size_double_data )
693 : : {
694 : 484 : int num_bpd = pointDataList.size();
695 : : int ii;
696 : : BoundaryPointData *bpd_ptr;
697 : :
698 : : //pointPtr->id() and pointDataList.size()
699 : 484 : size_int_data += 2;
700 [ + + ]: 1496 : for (ii=0; ii<num_bpd; ii++)
701 : : {
702 : 1012 : size_int_data += 2;
703 : 1012 : bpd_ptr = pointDataList.get_and_step();
704 : : //num_surfaces
705 : 1012 : size_int_data += bpd_ptr->surfFacetList.size();
706 : : }
707 : 484 : size_double_data += num_bpd * 6;
708 : 484 : return CUBIT_SUCCESS;
709 : : }
710 : :
711 : : //===============================================================================
712 : : //Function: get_boundary_point_data (PUBLIC)
713 : : //Description: retreive the boundary point data so it can be dumped to a file
714 : : // data must be allocated prior to calling this function!
715 : : //Date: 01/23/2003
716 : : //===============================================================================
717 : 484 : CubitStatus TDFacetBoundaryPoint::get_boundary_point_data(int *int_data,
718 : : double *double_data,
719 : : int &iidx,
720 : : int &didx )
721 : : {
722 : 484 : int_data[iidx++] = pointPtr->id();
723 : 484 : int num_bpd = pointDataList.size();
724 : 484 : int_data[iidx++] = num_bpd;
725 : :
726 : : BoundaryPointData *bpd_ptr;
727 : : int ii, jj;
728 : 484 : int numfacs = 0;
729 : : CubitFacet *facet_ptr;
730 [ + + ]: 1496 : for (ii=0; ii<num_bpd; ii++)
731 : : {
732 : 1012 : bpd_ptr = pointDataList.get_and_step();
733 : 1012 : numfacs = bpd_ptr->surfFacetList.size();
734 : 1012 : int_data[iidx++] = numfacs;
735 [ + + ]: 2728 : for (jj=0; jj<bpd_ptr->surfFacetList.size(); jj++)
736 : : {
737 : 1716 : facet_ptr = bpd_ptr->surfFacetList.get_and_step();
738 : 1716 : int_data[iidx++] = facet_ptr->id();
739 : : }
740 : 1012 : int_data[iidx++] = bpd_ptr->surfID;
741 : :
742 : 1012 : double_data[didx++] = bpd_ptr->normal.x();
743 : 1012 : double_data[didx++] = bpd_ptr->normal.y();
744 : 1012 : double_data[didx++] = bpd_ptr->normal.z();
745 : 1012 : double_data[didx++] = bpd_ptr->sizeVal;
746 : 1012 : double_data[didx++] = bpd_ptr->uVal;
747 : 1012 : double_data[didx++] = bpd_ptr->vVal;
748 : : }
749 : 484 : return CUBIT_SUCCESS;
750 : : }
751 : :
752 : : //===============================================================================
753 : : //Function: new_boundary_point_data (static PUBLIC)
754 : : //Description: create a new boundary point data and assign to a cubit point
755 : : //Author: sjowen
756 : : //Date: 01/26/2003
757 : : //===============================================================================
758 : 176 : CubitStatus TDFacetBoundaryPoint::new_facet_boundary_point(CubitPoint **points,
759 : : CubitFacet **facets,
760 : : int &iidx,
761 : : int &didx,
762 : : int *int_data,
763 : : double *double_data)
764 : : {
765 : 176 : int id = int_data[iidx++];
766 : 176 : CubitPoint *point_ptr = points[id];
767 : 176 : TDFacetBoundaryPoint::add_facet_boundary_point(point_ptr);
768 : : TDFacetBoundaryPoint *td = (TDFacetBoundaryPoint *)
769 : 176 : point_ptr->get_TD( &TDFacetBoundaryPoint::is_facet_boundary_point);
770 : :
771 : 176 : td->initialize( facets, iidx, didx, int_data, double_data );
772 : :
773 : 176 : return CUBIT_SUCCESS;
774 : : }
775 : :
776 : : //===============================================================================
777 : : //Function: initialize (PUBLIC)
778 : : //Description: initialize a boundary point data from data read from a CUB file
779 : : //Author: sjowen
780 : : //Date: 01/26/2003
781 : : //===============================================================================
782 : 176 : void TDFacetBoundaryPoint::initialize(CubitFacet **facets,
783 : : int &iidx,
784 : : int &didx,
785 : : int *int_data,
786 : : double *double_data)
787 : : {
788 : 176 : int num_bpd = int_data[iidx++];
789 : :
790 : : BoundaryPointData *bpd_ptr;
791 : : int ii, jj, id;
792 : 176 : int numfacs = 0;
793 : : CubitFacet *facet_ptr;
794 [ + + ]: 704 : for (ii=0; ii<num_bpd; ii++)
795 : : {
796 [ + - ][ + - ]: 528 : bpd_ptr = new BoundaryPointData;
797 [ + - ]: 528 : pointDataList.append(bpd_ptr);
798 : 528 : numfacs = int_data[iidx++];
799 [ + + ]: 1584 : for (jj=0; jj<numfacs; jj++)
800 : : {
801 : 1056 : id = int_data[iidx++];
802 : 1056 : facet_ptr = facets[id];
803 [ + - ]: 1056 : bpd_ptr->surfFacetList.append(facet_ptr);
804 : : }
805 : 528 : bpd_ptr->surfID = int_data[iidx++];
806 : :
807 [ + - ]: 528 : bpd_ptr->normal.x(double_data[didx++]);
808 [ + - ]: 528 : bpd_ptr->normal.y(double_data[didx++]);
809 [ + - ]: 528 : bpd_ptr->normal.z(double_data[didx++]);
810 : 528 : bpd_ptr->sizeVal = double_data[didx++];
811 : 528 : bpd_ptr->uVal = double_data[didx++];
812 : 528 : bpd_ptr->vVal = double_data[didx++];
813 : : }
814 : :
815 [ + - ][ + - ]: 6716 : }
816 : :
817 : : // eof
|
