Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : RefFace.cpp
3 : : //
4 : : // Purpose : This file contains the implementation of the class
5 : : // RefFace.
6 : : //
7 : : // Special Notes :
8 : : //
9 : : // Creator :
10 : : //
11 : : // Creation Date :
12 : : //
13 : : // Owner :
14 : : //-------------------------------------------------------------------------
15 : :
16 : : #include <stdio.h>
17 : : #include <math.h>
18 : : #include "CubitDefines.h"
19 : : #include "CubitVector.hpp"
20 : :
21 : : #include "Body.hpp"
22 : : #include "RefVolume.hpp"
23 : : #include "RefFace.hpp"
24 : : #include "RefEdge.hpp"
25 : : #include "RefVertex.hpp"
26 : :
27 : : #include "CubitObserver.hpp"
28 : : #include "RefEntityFactory.hpp"
29 : : #include "GeometryQueryTool.hpp"
30 : : #include "GfxDebug.hpp"
31 : : #include "GeometryDefines.h"
32 : : #include "Loop.hpp"
33 : :
34 : : #include "CoFace.hpp"
35 : : #include "CoEdge.hpp"
36 : :
37 : : #include "Surface.hpp"
38 : :
39 : : // lists
40 : : #include "DLIList.hpp"
41 : :
42 : : #include "CastTo.hpp"
43 : : #include "CubitString.hpp"
44 : : #include "CubitUtil.hpp"
45 : : //for measuring/cacheing the area of the surface.
46 : : #include "GeomMeasureTool.hpp"
47 : :
48 : : #include "GeometryUtil.hpp"
49 : : #include "ModelQueryEngine.hpp"
50 : :
51 : : //static RefEdge* find_edge_to_adjust(DLIList<RefEdge*>& ref_edge_list);
52 : :
53 : : //-------------------------------------------------------------------------
54 : : // Purpose : Constructor with a pointer to a Surface
55 : : //
56 : : // Special Notes :
57 : : //
58 : : // Creator : Xuechen Liu
59 : : //
60 : : // Creation Date : 07/11/96
61 : : //-------------------------------------------------------------------------
62 [ + - ]: 32092 : RefFace::RefFace(Surface* surfacePtr)
63 : : {
64 : : // Set the GeometryEntity pointer if (surfacePtr != NULL)
65 [ + - ]: 16046 : if (surfacePtr != NULL)
66 : : {
67 [ + - ]: 16046 : set_geometry_entity_ptr(surfacePtr) ;
68 : : }
69 : : else
70 : : {
71 [ # # ][ # # ]: 0 : PRINT_ERROR("In the RefFace(Surface*) constructor\n"
[ # # ]
72 [ # # ]: 0 : " Input Surface pointer is NULL\n");
73 : 0 : assert(CUBIT_FALSE);
74 : : }
75 : :
76 : : // Initialize the member data
77 [ + - ]: 16046 : initialize();
78 : 16046 : }
79 : :
80 : : //-------------------------------------------------------------------------
81 : : // Purpose : The destructor.
82 : : //
83 : : // Special Notes : Note that the GeometryEntity associated with this
84 : : // RefEntity is deleted in the destructor of the
85 : : // BasicTopologyEntity class.
86 : : //
87 : : // Creator : Malcolm J. Panthaki
88 : : //
89 : : // Creation Date : 10/22/96
90 : : //-------------------------------------------------------------------------
91 [ + - ]: 29760 : RefFace::~RefFace()
92 : : {
93 : : // Delete the hardpoints associated with this RefFace
94 : :
95 : :
96 : : // // Delete the contents of the SurfVertexList
97 : : // for ( i = surfVertexList.size(); i > 0; i --)
98 : : // {
99 : : // delete surfVertexList.get_and_step();
100 : : // }
101 : :
102 : : // Delete the contents of the HardPointList (these are RefVertices).
103 : : // Calling the remove() function ensures that the DAG cleaned out
104 : : // appropriately.
105 : : int i;
106 [ + - ][ - + ]: 9920 : for ( i = hardPointList.size(); i > 0; i --)
107 : : {
108 [ # # ][ # # ]: 0 : hardPointList.get_and_step()->remove_from_DAG();
109 : : }
110 : :
111 [ + - ]: 9920 : remove_from_observers();
112 [ - + ]: 19840 : }
113 : :
114 : :
115 : 0 : static void dist_between(RefEdge* edge1, RefEdge* edge2, CubitVector& v1, CubitVector& v2, double& dist)
116 : : {
117 : : // check compatibility first
118 [ # # ]: 0 : DLIList<TopologyEntity*> entity_list(2);
119 [ # # ][ # # ]: 0 : DLIList<TopologyBridge*> bridge_list(2);
120 [ # # ]: 0 : entity_list.append(edge1);
121 [ # # ]: 0 : entity_list.append(edge2);
122 [ # # ][ # # ]: 0 : GeometryQueryEngine* gqe = GeometryQueryTool::instance()->common_query_engine( entity_list, bridge_list );
123 [ # # ]: 0 : if(gqe)
124 [ # # ][ # # ]: 0 : GeometryQueryTool::instance()->entity_entity_distance(edge1, edge2, v1, v2, dist);
[ # # ][ # # ]
125 : : else
126 : : {
127 : 0 : BasicTopologyEntity* bte1 = dynamic_cast<BasicTopologyEntity*>(edge1);
128 : 0 : BasicTopologyEntity* bte2 = dynamic_cast<BasicTopologyEntity*>(edge2);
129 [ # # ][ # # ]: 0 : if(bte1 && bte2)
130 : : {
131 [ # # ][ # # ]: 0 : GeometryEntity *ge1 = dynamic_cast<GeometryEntity*>(bte1->bridge_manager()->topology_bridge());
[ # # ]
132 [ # # ][ # # ]: 0 : GeometryEntity *ge2 = dynamic_cast<GeometryEntity*>(bte2->bridge_manager()->topology_bridge());
[ # # ]
133 [ # # ][ # # ]: 0 : GeometryQueryTool::instance()->entity_entity_distance(ge1, ge2, v1, v2, dist);
134 : : }
135 [ # # ]: 0 : }
136 : 0 : }
137 : :
138 : 0 : double RefFace::get_crack_length()
139 : : {
140 : : // find two loops to check the shortest distance between as that's where Cubit is most
141 : : // likely to crack surfaces
142 : :
143 [ # # ]: 0 : DLIList<Loop*> crack_loops;
144 : :
145 [ # # ][ # # ]: 0 : DLIList<Loop*> loops;
146 [ # # ]: 0 : this->loops(loops);
147 : :
148 : : int i, j;
149 [ # # ][ # # ]: 0 : for(i=0; i<loops.size(); i++)
150 : : {
151 [ # # ]: 0 : Loop* l = loops.get_and_step();
152 [ # # ]: 0 : LoopType loop_type = l->loop_type();
153 [ # # ][ # # ]: 0 : if(loop_type == LOOP_TYPE_U_PERIODIC || loop_type == LOOP_TYPE_V_PERIODIC)
154 [ # # ]: 0 : crack_loops.append(l);
155 : : }
156 : :
157 [ # # ][ # # ]: 0 : if(crack_loops.size() >= 2)
158 : : {
159 [ # # ]: 0 : Loop* loop1 = crack_loops.get_and_step();
160 [ # # ]: 0 : Loop* loop2 = crack_loops.get_and_step();
161 : :
162 [ # # ]: 0 : DLIList<RefEdge*> loop1_edges;
163 [ # # ]: 0 : loop1->ref_edges(loop1_edges);
164 [ # # ][ # # ]: 0 : DLIList<RefEdge*> loop2_edges;
165 [ # # ]: 0 : loop2->ref_edges(loop2_edges);
166 : :
167 [ # # ][ # # ]: 0 : CubitVector p1, p2;
168 : 0 : double min_dist = -1.0;
169 : :
170 [ # # ][ # # ]: 0 : for(i=0; i<loop1_edges.size(); i++)
171 : : {
172 [ # # ]: 0 : RefEdge* edge1 = loop1_edges.get_and_step();
173 [ # # ][ # # ]: 0 : for(j=0; j<loop2_edges.size(); j++)
174 : : {
175 [ # # ]: 0 : RefEdge* edge2 = loop2_edges.get_and_step();
176 [ # # ]: 0 : if(edge2 != edge1)
177 : : {
178 [ # # ][ # # ]: 0 : CubitVector v1, v2;
179 : 0 : double dist = -1;
180 [ # # ]: 0 : dist_between(edge1, edge2, v1, v2, dist);
181 [ # # ][ # # ]: 0 : if(min_dist < 0 || (dist < min_dist && dist > 0))
[ # # ]
182 : : {
183 : 0 : min_dist = dist;
184 [ # # ]: 0 : p1 = v1;
185 [ # # ]: 0 : p2 = v2;
186 : : }
187 : : }
188 : : }
189 : : }
190 : :
191 : : // estimate distance along the surface in case of curvature
192 [ # # ]: 0 : if(min_dist > 0)
193 : : {
194 : 0 : double new_min_dist = 0;
195 : : double start_uv[2];
196 : : double end_uv[2];
197 [ # # ]: 0 : this->u_v_from_position(p1, start_uv[0], start_uv[1]);
198 [ # # ]: 0 : this->u_v_from_position(p2, end_uv[0], end_uv[1]);
199 : : double delta_uv[2];
200 : 0 : delta_uv[0] = (end_uv[0] - start_uv[0]) / 10.0;
201 : 0 : delta_uv[1] = (end_uv[1] - start_uv[1]) / 10.0;
202 : :
203 [ # # ]: 0 : CubitVector start = p1;
204 [ # # ]: 0 : CubitVector next;
205 [ # # ]: 0 : for(i=0; i<10; i++)
206 : : {
207 : 0 : start_uv[0] += delta_uv[0];
208 : 0 : start_uv[1] += delta_uv[1];
209 [ # # ][ # # ]: 0 : next = this->position_from_u_v( start_uv[0], start_uv[1] );
210 [ # # ]: 0 : new_min_dist += start.distance_between(next);
211 [ # # ]: 0 : start = next;
212 : : }
213 : 0 : min_dist = new_min_dist;
214 : : }
215 : :
216 [ # # ]: 0 : if(min_dist < 0)
217 : : {
218 : 0 : min_dist = 0;
219 : : }
220 : :
221 [ # # ][ # # ]: 0 : PRINT_DEBUG_99("Crack_length is %f\n", min_dist);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
222 [ # # ]: 0 : return min_dist;
223 : : }
224 : :
225 [ # # ][ # # ]: 0 : PRINT_DEBUG_99("No valid crack length for surface %i\n", this->id());
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
226 [ # # ]: 0 : return 0.0;
227 : : }
228 : :
229 : 3591286 : CubitVector RefFace::normal_at ( const CubitVector& location,
230 : : RefVolume* volume,
231 : : double* u_guess, double* v_guess)
232 : : {
233 : : // The Surface::normal_at function not only returns the normal, but
234 : : // also returns the point on the actual surface that is closest to
235 : : // the input location. The normal is actually computed at *this*
236 : : // (closest) point on the surface, not at the input location.
237 [ + - ]: 3591286 : CubitVector normal;
238 : : CubitStatus result;
239 [ + - ]: 3591286 : Surface* surface_ptr = get_surface_ptr();
240 : :
241 [ - + ][ # # ]: 3591286 : if(!u_guess || !v_guess) // no guess was provided
242 : : {
243 [ + - ][ - + ]: 3591286 : if (u_guess || v_guess)
244 : : {
245 [ # # ][ # # ]: 0 : PRINT_ERROR("normal_at(): neither or both of u_guess and "
[ # # ]
246 [ # # ]: 0 : "v_guess must be specified.\n");
247 [ # # ][ # # ]: 0 : assert(u_guess && v_guess);
248 : : }
249 [ + - ]: 3591286 : result = surface_ptr->closest_point(location, NULL, &normal);
250 : : }
251 : : else
252 : : {
253 : : result = surface_ptr->closest_point_uv_guess(location,
254 : : *u_guess, *v_guess,
255 [ # # ]: 0 : NULL, &normal );
256 : : }
257 : :
258 [ - + ]: 3591286 : if (result == CUBIT_FAILURE)
259 : : {
260 [ # # ][ # # ]: 0 : PRINT_ERROR("In RefFace::normal_at\n"
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
261 : : " Could not compute the requested normal at "
262 : : "location {%f %f %f} on %s (surface %d).\n",
263 : : location.x(), location.y(), location.z(),
264 : : this->entity_name().c_str(),
265 [ # # ]: 0 : this->id());
266 : : //assert ( result == CUBIT_SUCCESS );
267 [ # # ]: 0 : return CubitVector(0.0, 0.0, 0.0);
268 : : }
269 : :
270 [ + - ][ - + ]: 3591286 : if (surface_ptr->bridge_sense() == CUBIT_REVERSED)
271 [ # # ][ # # ]: 0 : normal = -normal;
272 : :
273 [ - + ]: 3591286 : if ( volume )
274 : : {
275 [ # # ]: 0 : CubitSense s = sense( volume );
276 [ # # ][ # # ]: 0 : if( s != CUBIT_FORWARD && s != CUBIT_REVERSED )
277 : : {
278 [ # # ][ # # ]: 0 : if(!(volume->is_sheet()))
279 : : {
280 [ # # ][ # # ]: 0 : PRINT_ERROR("Surface %d has bad sense information with respect to volume %d\n"
[ # # ][ # # ]
[ # # ][ # # ]
281 : : " Probably is a 2-sided surface embedded in volume %d\n"
282 [ # # ]: 0 : " Cannot handle this case.\n", id(), volume->id(), volume->id() );
283 [ # # ]: 0 : return CubitVector(0.0, 0.0, 0.0);
284 : : }
285 : : }
286 : :
287 [ # # ]: 0 : if ( s == CUBIT_REVERSED )
288 [ # # ][ # # ]: 0 : normal = -normal;
289 : : }
290 : :
291 [ + - ]: 3591286 : return normal;
292 : : }
293 : :
294 : 0 : CubitStatus RefFace::uv_derivitives( double u_param,
295 : : double v_param,
296 : : CubitVector &du,
297 : : CubitVector &dv )
298 : : {
299 : 0 : return get_surface_ptr()->uv_derivitives(u_param, v_param, du, dv);
300 : : }
301 : :
302 : 0 : void RefFace::find_closest_point_trimmed(CubitVector from_point,
303 : : CubitVector& point_on_surface)
304 : : {
305 [ # # ]: 0 : get_surface_ptr()->closest_point_trimmed(from_point, point_on_surface);
306 : 0 : }
307 : :
308 : 0 : void RefFace::find_closest_points_trimmed(std::vector<CubitVector> &from_points,
309 : : std::vector<CubitVector> &points_on_surface)
310 : : {
311 : 0 : get_surface_ptr()->closest_points_trimmed(from_points, points_on_surface);
312 : 0 : }
313 : :
314 : 0 : CubitStatus RefFace::move_to_surface ( CubitVector& location,
315 : : CubitVector& along_vec )
316 : : {
317 [ # # ]: 0 : CubitVector closest_location;
318 [ # # ]: 0 : CubitStatus status = get_surface_ptr()->closest_point_along_vector(location, along_vec,
319 [ # # ]: 0 : closest_location);
320 : :
321 [ # # ]: 0 : if( CUBIT_SUCCESS == status )
322 [ # # ]: 0 : location.set ( closest_location.x(),
323 [ # # ]: 0 : closest_location.y(),
324 [ # # ][ # # ]: 0 : closest_location.z() );
325 : :
326 : 0 : return status;
327 : : }
328 : :
329 : 4095 : void RefFace::move_to_surface ( CubitVector& location,
330 : : double* u_guess, double* v_guess )
331 : : {
332 [ + - ]: 4095 : CubitVector closest_location;
333 : : CubitStatus result;
334 : :
335 [ - + ][ # # ]: 4095 : if(!u_guess || !v_guess) // no guess was provided
336 : : {
337 [ + - ][ - + ]: 4095 : if (u_guess || v_guess)
338 : : {
339 [ # # ][ # # ]: 0 : PRINT_ERROR("move_to_surface(): neither or both of u_guess and "
[ # # ]
340 [ # # ]: 0 : "v_guess must be specified.\n");
341 [ # # ][ # # ]: 0 : assert(u_guess && v_guess);
342 : : }
343 [ + - ][ + - ]: 4095 : result = get_surface_ptr()->closest_point(location, &closest_location);
344 : : }
345 : : else
346 : : {
347 [ # # ]: 0 : result = get_surface_ptr()->closest_point_uv_guess(location,
348 : : *u_guess, *v_guess,
349 [ # # ]: 0 : &closest_location);
350 : : }
351 : :
352 : :
353 [ - + ]: 4095 : if (result == CUBIT_FAILURE)
354 : : {
355 [ # # ][ # # ]: 0 : PRINT_ERROR("In RefFace::move_to_surface\n"
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
356 : : " Could not compute the closest point to "
357 : : "location {%f %f %f} on %s (surface %d).\n",
358 : : location.x(), location.y(), location.z(),
359 : : this->entity_name().c_str(),
360 [ # # ]: 0 : this->id());
361 [ # # ]: 0 : assert ( result == CUBIT_SUCCESS );
362 : 4095 : return;
363 : : }
364 : :
365 [ + - ]: 4095 : location.set ( closest_location.x(),
366 [ + - ]: 4095 : closest_location.y(),
367 [ + - ][ + - ]: 8190 : closest_location.z() );
368 : : }
369 : :
370 : 0 : CubitPointContainment RefFace::point_containment( const CubitVector &point )
371 : : {
372 : 0 : Surface *surf = get_surface_ptr();
373 : 0 : return surf->point_containment(point);
374 : : }
375 : :
376 : 0 : CubitPointContainment RefFace::point_containment( double u, double v )
377 : : {
378 : 0 : Surface *surf = get_surface_ptr();
379 : 0 : return surf->point_containment(u, v);
380 : : }
381 : : /*
382 : : CubitPointContainment RefFace::point_containment( CubitVector &point,
383 : : double u, double v )
384 : : {
385 : : Surface *surf = get_surface_ptr();
386 : : return surf->point_containment(point, u, v);
387 : : }
388 : : */
389 : 0 : CubitStatus RefFace::get_principal_curvatures( const CubitVector& point,
390 : : double& curvature1,
391 : : double& curvature2,
392 : : RefVolume* ref_volume_ptr )
393 : : {
394 : 0 : Surface* surface_ptr = get_surface_ptr();
395 : :
396 : : // Call the relevant function to compute the curvatures
397 : : CubitStatus status = surface_ptr->
398 : 0 : principal_curvatures( point, curvature1, curvature2 );
399 [ # # ]: 0 : if ( status != CUBIT_SUCCESS )
400 : 0 : return status;
401 : :
402 [ # # ]: 0 : if (surface_ptr->bridge_sense() == CUBIT_REVERSED) {
403 : 0 : curvature1 = -curvature1;
404 : 0 : curvature2 = -curvature2;
405 : : }
406 : :
407 [ # # ]: 0 : if ( ref_volume_ptr ) {
408 : 0 : CubitSense s = sense( ref_volume_ptr );
409 [ # # ]: 0 : if ( s == CUBIT_REVERSED ) {
410 : 0 : curvature1 = -curvature1;
411 : 0 : curvature2 = -curvature2;
412 : : }
413 : : }
414 : 0 : return CUBIT_SUCCESS;
415 : : }
416 : :
417 : 0 : int RefFace::genus()
418 : : {
419 : 0 : int nloops = num_loops();
420 [ # # ]: 0 : if (nloops > 0) return (nloops - 1);
421 : : else {
422 : : // need to compute poles
423 : 0 : int num_poles = this->num_poles();
424 : 0 : return -(num_poles+1);
425 : : }
426 : : }
427 : :
428 : 0 : int RefFace::num_poles()
429 : : {
430 : 0 : int num_poles = 0;
431 : : double u_low, u_high, v_low, v_high;
432 [ # # ]: 0 : get_param_range_U(u_low, u_high);
433 [ # # ]: 0 : get_param_range_V(v_low, v_high);
434 [ # # ][ # # ]: 0 : if (is_singular_in_U(u_low)) num_poles++;
435 [ # # ][ # # ]: 0 : if (is_singular_in_U(u_high)) num_poles++;
436 [ # # ][ # # ]: 0 : if (is_singular_in_V(v_low)) num_poles++;
437 [ # # ][ # # ]: 0 : if (is_singular_in_V(v_high)) num_poles++;
438 : 0 : return num_poles;
439 : : }
440 : :
441 : 2511 : CubitVector RefFace::center_point ()
442 : : {
443 [ + - ]: 2511 : CubitVector center_pt = bounding_box().center();
444 : 2511 : move_to_surface(center_pt);
445 : 2511 : return center_pt;
446 : : }
447 : :
448 : 132 : int RefFace::number_of_Loops ()
449 : : {
450 : 132 : int number_of_loops = 0;
451 : :
452 : : // Get the GroupingEntities (Loops) associated with this
453 : : // BasicTopologyEntity (RefFace)
454 [ + - ]: 132 : DLIList<GroupingEntity*> loopList;
455 [ + - ][ + - ]: 132 : if ( this->get_grouping_entity_list(loopList) == CUBIT_SUCCESS)
456 : : {
457 [ + - ]: 132 : number_of_loops = loopList.size();
458 : : }
459 : :
460 : : else
461 : : {
462 [ # # ][ # # ]: 0 : PRINT_ERROR("In RefFace::number_of_Loops\n"
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
463 : : " Unknown problem retrieving Loops "
464 : : "for %s (surface %d).\n",
465 : : entity_name().c_str(),
466 [ # # ]: 0 : this->id());
467 : 0 : number_of_loops = 0;
468 : : }
469 : :
470 [ + - ]: 132 : return number_of_loops;
471 : : }
472 : :
473 : 0 : CubitSense RefFace::sense(RefVolume* volume)
474 : : {
475 : 0 : SenseEntity* co_face = find_sense_entity(volume);
476 [ # # ]: 0 : return co_face ? co_face->get_sense() : CUBIT_UNKNOWN;
477 : : }
478 : :
479 : 0 : CubitSense RefFace::sense( RefFace* face_ptr )
480 : : {
481 [ # # ][ # # ]: 0 : DLIList<RefEdge*> edge_list, other_edge_list;
[ # # ]
482 [ # # ]: 0 : ref_edges( edge_list );
483 [ # # ]: 0 : face_ptr->ref_edges( other_edge_list );
484 [ # # ]: 0 : edge_list.intersect( other_edge_list );
485 : :
486 : 0 : CubitSense result = CUBIT_UNKNOWN;
487 [ # # ][ # # ]: 0 : if( edge_list.size() > 0 )
488 : : {
489 [ # # ]: 0 : RefEdge* edge = edge_list.get_and_step();
490 [ # # ][ # # ]: 0 : if( edge->sense(this) == edge->sense(face_ptr) )
[ # # ]
491 : 0 : result = CUBIT_REVERSED;
492 : 0 : else result = CUBIT_FORWARD;
493 : : }
494 [ # # ][ # # ]: 0 : for( int i = edge_list.size(); i > 1; i-- )
495 : : {
496 [ # # ]: 0 : RefEdge* edge = edge_list.get_and_step();
497 [ # # ][ # # ]: 0 : CubitSense temp = (edge->sense(this)==edge->sense(face_ptr))
498 : 0 : ? CUBIT_FORWARD : CUBIT_REVERSED;
499 [ # # ]: 0 : if( temp != result )
500 : : {
501 : 0 : result = CUBIT_UNKNOWN;
502 : 0 : break;
503 : : }
504 : : }
505 [ # # ]: 0 : return result;
506 : : }
507 : :
508 : :
509 : :
510 : : //-------------------------------------------------------------------------
511 : : // Purpose : Spatially compare two RefFaces. Compare bounding boxes
512 : : // first, then compare each of the ref-edges. This function
513 : : // works strictly off of the ref-entities.
514 : : //
515 : : // Special Notes :
516 : : //
517 : : // Creator : Malcolm J. Panthaki
518 : : //
519 : : // Creation Date : 04/07/97
520 : : //-------------------------------------------------------------------------
521 : 5012 : CubitBoolean RefFace::about_spatially_equal(
522 : : RefFace* ref_face_ptr_2,
523 : : double tolerance_factor,
524 : : CubitBoolean notify_refEntity,
525 : : CubitBoolean test_bbox,
526 : : int test_internal )
527 : : {
528 : : // Get rid of the trivial case...
529 [ - + ]: 5012 : if( this == ref_face_ptr_2)
530 : : {
531 [ # # ]: 0 : if (notify_refEntity)
532 [ # # ]: 0 : remove_compare_data();
533 : 0 : return CUBIT_TRUE;
534 : : }
535 : :
536 : 5012 : const double tolerance = tolerance_factor * GEOMETRY_RESABS;
537 [ + - ]: 5012 : CubitBox box_1 = this->bounding_box();
538 [ + - ][ + - ]: 10024 : CubitBox box_2 = ref_face_ptr_2->bounding_box();
539 [ + - ][ + + ]: 5012 : if (!box_1.overlap( tolerance, box_2) )
540 : 629 : return CUBIT_FALSE;
541 : :
542 : :
543 [ + - ]: 4383 : GeometryQueryTool* gqt = GeometryQueryTool::instance();
544 [ + - ][ + - ]: 8766 : DLIList<RefEdge*> ref_edge_list_1, ref_edge_list_2;
[ + - ][ + - ]
545 [ + - ]: 4383 : this->ref_edges( ref_edge_list_1 );
546 [ + - ]: 4383 : ref_face_ptr_2->ref_edges( ref_edge_list_2 );
547 : :
548 : : //compare the size of the two lists.
549 [ + - ][ + - ]: 4383 : if ( ref_edge_list_1.size() != ref_edge_list_2.size() )
[ + + ]
550 : 1986 : return CUBIT_FALSE;
551 : :
552 [ + - ]: 2397 : if (test_internal == 2) // Do internal test for splines only
553 : : {
554 [ + - ]: 2397 : const GeometryType this_type = this->geometry_type();
555 [ + - ]: 2397 : const GeometryType othr_type = ref_face_ptr_2->geometry_type();
556 [ + - ][ + - ]: 2397 : if (this_type != SPLINE_SURFACE_TYPE &&
557 [ + - ]: 2397 : this_type != BEST_FIT_SURFACE_TYPE &&
558 [ + - ]: 2397 : this_type != UNDEFINED_SURFACE_TYPE &&
559 [ + - ]: 2397 : othr_type != SPLINE_SURFACE_TYPE &&
560 [ + - ]: 2397 : othr_type != BEST_FIT_SURFACE_TYPE &&
561 : : othr_type != UNDEFINED_SURFACE_TYPE )
562 : 2397 : test_internal = 0;
563 : : else
564 : 2397 : test_bbox = CUBIT_FALSE;
565 : : }
566 : :
567 : :
568 : : //This compare precedure does the following :
569 : : // 1. Test the bounding boxes of the 2 faces for equality;
570 : : // If they are "equal" (within "resabs*tolerance_factor"):
571 : : // 2. Compare the ref-edges.
572 : : // 3. Test a point on the two surfaces.
573 : : // 4. When notify_refEntity is CUBIT_TRUE, whenever find an
574 : : // two ReEntity's are spatially equal, notify the RefEntity.
575 : : //**** Reorderd by J.Kraftcheck, Sept 22, 2003 ****
576 : : // - Check mergable curves first. Then check boxes and finally
577 : : // the internal position.
578 : :
579 [ + - ][ + - ]: 4794 : DLIList<Loop*> loop_list_1, loop_list_2;
[ + - ][ + - ]
580 [ + - ][ + - ]: 4794 : DLIList<CoEdge*> loop_1_coedges;
581 [ + - ]: 2397 : this->loops( loop_list_1 );
582 [ + - ]: 2397 : ref_face_ptr_2->loops( loop_list_2 );
583 [ + - ][ + - ]: 2397 : if( loop_list_1.size() != loop_list_2.size() )
[ - + ]
584 : 0 : return CUBIT_FALSE;
585 : :
586 [ + - ]: 2397 : CubitSense relative_sense = compare_alignment( ref_face_ptr_2 );
587 : :
588 : : // match each loop in loop_list_1 with one in loop_list_2
589 [ + - ][ + + ]: 2511 : for( int i1 = loop_list_1.size(); i1 > 0; i1-- )
590 : : {
591 [ + - ]: 2397 : Loop* loop_1 = loop_list_1.get_and_step();
592 [ + - ]: 2397 : loop_1_coedges.clean_out();
593 [ + - ]: 2397 : loop_1->ordered_co_edges( loop_1_coedges );
594 : 2397 : bool loop_match = false;
595 : :
596 : : // check every loop in loop_list_2 to see if it matches
597 : : // the current loop from loop_list_1
598 [ + - ][ + + ]: 4794 : for( int i2 = loop_list_2.size(); (i2 > 0) && !loop_match; i2-- )
[ + - ]
599 : : {
600 [ + - ]: 2397 : Loop* loop_2 = loop_list_2.step_and_get();
601 : : loop_match = loop_2->about_spatially_equal( loop_1_coedges,
602 : : relative_sense,
603 : : tolerance_factor,
604 [ + - ]: 2397 : notify_refEntity );
605 : : }
606 : :
607 : : // loop from loop_list_1 did not match any loop in loop_list_2
608 [ + + ]: 2397 : if( ! loop_match )
609 : 2283 : return CUBIT_FALSE;
610 : :
611 : : // found a match for the current one, so remove it
612 [ + - ]: 114 : loop_list_2.extract();
613 : :
614 : : } // for( loop_list_1 )
615 : :
616 : :
617 [ + - ]: 114 : if ( test_bbox )
618 : : {
619 : : // This test checks to see that the min and max vectors of the
620 : : // bounding boxes are within 10% of the length of the bbox diagonal.
621 : : // Note that this assumes the default values of resabs=1e-6 and
622 : : // tolerance_factor=500
623 : :
624 : : // It has already been determined that the RefEdges of the
625 : : // surfaces are mergeable, so the bounding boxes of the
626 : : // RefEdges should be equivalent. Consider the bounding box
627 : : // of each RefFace to be the RefFace's box united with the
628 : : // box of all the curves. This removes any potential issues
629 : : // with non-tight bounding boxes for spline curves from
630 : : // consideration, while still comparing any extend of the boxes
631 : : // that is the result of some internal feature of the surfaces.
632 [ + - ][ + - ]: 114 : if (ref_edge_list_1.size())
633 : : {
634 : : int i;
635 : : // Call 'unmerged_bounding_box' here so that we get the aggregate bounding box
636 : : // of all of the Topology Bridges of curves that are already merged. If we don't
637 : : // do this we may not expand the bounding boxes sufficiently to get correct results.
638 [ + - ][ + - ]: 114 : CubitBox edge_box = ref_edge_list_1.step_and_get()->unmerged_bounding_box();
639 [ + - ][ + + ]: 436 : for (i = ref_edge_list_1.size(); i > 1; i--)
640 [ + - ][ + - ]: 322 : edge_box |= ref_edge_list_1.step_and_get()->unmerged_bounding_box();
[ + - ][ + - ]
641 [ + - ][ + + ]: 550 : for (i = ref_edge_list_2.size(); i > 0; i--)
642 [ + - ][ + - ]: 436 : edge_box |= ref_edge_list_2.step_and_get()->unmerged_bounding_box();
[ + - ][ + - ]
643 [ + - ]: 114 : box_1 |= edge_box;
644 [ + - ][ + - ]: 114 : box_2 |= edge_box;
645 : : }
646 : :
647 : : CubitVector tol_vect(
648 [ + - ][ + - ]: 114 : CUBIT_MIN(box_1.x_range(), box_2.x_range()),
649 [ + - ][ + - ]: 114 : CUBIT_MIN(box_1.y_range(), box_2.y_range()),
650 [ + - ][ + - ]: 342 : CUBIT_MIN(box_1.z_range(), box_2.z_range()) );
[ - + ][ # # ]
[ + - ][ - + ]
[ # # ][ + - ]
[ - + ][ # # ]
[ + - ][ + - ]
651 [ + - ]: 114 : tol_vect *= 200.0 * tolerance;
652 : :
653 [ + - ][ + + ]: 114 : if( tol_vect.x() < tolerance ) tol_vect.x(tolerance);
[ + - ]
654 [ + - ][ + + ]: 114 : if( tol_vect.y() < tolerance ) tol_vect.y(tolerance);
[ + - ]
655 [ + - ][ - + ]: 114 : if( tol_vect.z() < tolerance ) tol_vect.z(tolerance);
[ # # ]
656 : :
657 [ + - ][ + - ]: 342 : if( (fabs(box_1.minimum().x() - box_2.minimum().x()) > tol_vect.x()) ||
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ - + # #
# # ]
658 [ + - ][ + - ]: 342 : (fabs(box_1.maximum().x() - box_2.maximum().x()) > tol_vect.x()) ||
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ # # # # ]
659 [ + - ][ + - ]: 342 : (fabs(box_1.minimum().y() - box_2.minimum().y()) > tol_vect.y()) ||
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ # # # # ]
660 [ + - ][ + - ]: 342 : (fabs(box_1.maximum().y() - box_2.maximum().y()) > tol_vect.y()) ||
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + - ]
[ # # # # ]
661 [ + - ][ + - ]: 456 : (fabs(box_1.minimum().z() - box_2.minimum().z()) > tol_vect.z()) ||
[ + - ][ + - ]
[ + - ][ + - ]
[ - + ][ + - ]
[ + - ]
[ # # # # ]
662 [ + - ][ + - ]: 228 : (fabs(box_1.maximum().z() - box_2.maximum().z()) > tol_vect.z()) )
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
[ # # # # ]
663 : : {
664 : 114 : return CUBIT_FALSE;
665 : : }
666 : : }
667 : :
668 : : //if both lists of edges are zero, this is the concentric sphere or torus case.
669 : : //must look for a point on the surface then.
670 [ + - ][ - + ]: 114 : if ( (ref_edge_list_1.size() == 0 && ref_edge_list_2.size() == 0 ) ||
[ # # ][ # # ]
[ - + ][ - + ]
671 : : test_internal != 0 )
672 : : {
673 : : //test a point in the middle.
674 [ # # ][ # # ]: 0 : CubitVector center_1, center_2;
675 [ # # ]: 0 : CubitVector temp_1 = this->center_point();
676 [ # # ][ # # ]: 0 : this->find_closest_point_trimmed( temp_1, center_1);
677 : : //Okay, now we have the point. See if this point is on the other
678 : : //surface.
679 [ # # ][ # # ]: 0 : ref_face_ptr_2->find_closest_point_trimmed( center_1, center_2 );
680 [ # # ][ # # ]: 0 : if ( !gqt->about_spatially_equal(center_1, center_2, tolerance_factor ) )
681 : 0 : return CUBIT_FALSE;
682 : : }
683 : :
684 : :
685 : : // If we have come this far, we have found matches for
686 : : // every edge of the FACEs. Now notify the associated RefEntities
687 : : // that a match was found.
688 [ + - ]: 114 : if (notify_refEntity == CUBIT_TRUE )
689 : : {
690 [ + - ][ + - ]: 114 : this->comparison_found(ref_face_ptr_2);
691 : : }
692 : :
693 [ + - ]: 5126 : return CUBIT_TRUE;
694 : :
695 : : }
696 : :
697 : : //-NOTE: For this function it is assumed that the second_ref_face
698 : : //- is spacially equivalient to the first one.
699 : : //- This function could explode if this is not followed.
700 : : //- If you don't know about the closness of the two faces, check the
701 : : //- previous compare function first.
702 : 2511 : CubitSense RefFace::compare_alignment( RefFace* second_ref_face_ptr )
703 : : {
704 : : //Get the sense by testing the two RefFace's at their common
705 : : //center point.
706 [ + - ]: 2511 : CubitVector center_point = this->center_point();
707 [ + - ][ + - ]: 2511 : CubitVector normal_this, normal_second;
708 [ + - ][ + - ]: 2511 : normal_this = this->normal_at( center_point );
709 [ + - ][ + - ]: 2511 : normal_second = second_ref_face_ptr->normal_at( center_point );
710 : :
711 [ + - ]: 2511 : double dot = normal_this % normal_second;
712 : :
713 : 2511 : CubitSense sense = CUBIT_FORWARD;
714 [ + + ]: 2511 : if ( dot < 0 )
715 : : {
716 : 86 : sense = CUBIT_REVERSED;
717 : : }
718 : : // Moved this warning into merge tool because this function can
719 : : // be used by other code, for which this warning is misleading.
720 : : // j.k. - 10/11/01
721 : : // else
722 : : // {
723 : : // PRINT_WARNING("Merging %s (surface %d) and %s (surface %d) "
724 : : // " which have the same sense.\n"
725 : : // "This may indicate bad geometry.\n",
726 : : // entity_name().c_str(), id(),
727 : : // second_ref_face_ptr->entity_name().c_str(),
728 : : // second_ref_face_ptr->id() );
729 : : // }
730 : 2511 : return sense;
731 : : }
732 : :
733 : : class LoopAngles
734 : : {
735 : : public:
736 : : Loop* loopPtr;
737 : : double angleMetric;
738 : :
739 : 0 : LoopAngles(Loop *loop_ptr )
740 : 0 : { loopPtr = loop_ptr; }
741 : :
742 : 0 : double angle_metric()
743 : 0 : { return angleMetric; }
744 : : };
745 : :
746 : :
747 : : #include "SDLList.hpp"
748 [ - + ][ - + ]: 594 : SDLListdeclare(SDLLoopAngles, LoopAngles*, angle_metric, double)
[ + - ]
749 : :
750 : : // KGM -- These changes break pave-ansys/anc101.jou
751 : : // create a sorting function for DLIList
752 : : //template <> struct DLIListSorter<LoopAngles*>
753 : : //{
754 : : // bool operator()(LoopAngles* a, LoopAngles* b) { return a->angle_metric() < b->angle_metric(); }
755 : : //};
756 : :
757 : 198 : CubitStatus RefFace::ordered_loops( DLIList<Loop*> &loop_list )
758 : : {
759 : : CubitStatus status;
760 [ + - ]: 198 : SDLLoopAngles loop_angle_list;
761 : : // DLIList<LoopAngles*> loop_angle_list;
762 [ + - ][ + - ]: 396 : DLIList<Loop*> temp_loop_list;
763 : : //Get all of the loops for this RefFace.
764 [ + - ]: 198 : loops( temp_loop_list );
765 : :
766 [ + - ][ + - ]: 198 : if ( temp_loop_list.size() < 2 )
767 : : {
768 [ + - ]: 198 : loop_list += temp_loop_list;
769 : : }
770 : : else
771 : : {
772 : : // See if the underlying geometry engine can give us the ordered list
773 : : // before trying to do it manually.
774 [ # # ][ # # ]: 0 : GeometryQueryTool::instance()->get_ordered_loops(this, loop_list);
775 [ # # ][ # # ]: 0 : if(loop_list.size() > 0 && loop_list.size() == temp_loop_list.size())
[ # # ][ # # ]
[ # # ][ # # ]
776 : 0 : return CUBIT_SUCCESS;
777 : : else
778 [ # # ]: 0 : loop_list.clean_out();
779 : :
780 : : // If we were not able to get the ordered list from the underlying
781 : : // geometry engine we will do it manually.
782 : :
783 : : // Order the list of loops from outside to inside.
784 : : Loop *loop_ptr;
785 : : LoopAngles *loop_angles;
786 : :
787 [ # # ][ # # ]: 0 : for ( int ii = temp_loop_list.size(); ii > 0; ii-- )
788 : : {
789 [ # # ]: 0 : loop_ptr = temp_loop_list.get_and_step();
790 [ # # ][ # # ]: 0 : loop_angles = new LoopAngles( loop_ptr );
791 [ # # ]: 0 : status = loop_ptr->get_angle_metric( loop_angles->angleMetric );
792 [ # # ]: 0 : if ( status == CUBIT_FAILURE )
793 : : {
794 [ # # ][ # # ]: 0 : PRINT_ERROR("In RefFace::ordered_loops\n"
[ # # ]
795 : : " Unknown problem computing the angle metric"
796 [ # # ]: 0 : " of the Loop.\n");
797 : 0 : delete loop_angles;
798 : :
799 [ # # ][ # # ]: 0 : while( loop_angle_list.size() != 0 )
800 [ # # ]: 0 : delete loop_angle_list.remove();
801 : :
802 : 0 : return CUBIT_FAILURE;
803 : : }
804 [ # # ]: 0 : loop_angle_list.append( loop_angles );
805 : : }
806 : :
807 [ # # ]: 0 : loop_angle_list.sort();
808 : : // std::stable_sort(&loop_angle_list[0], &loop_angle_list[0]+loop_angle_list.size(), DLIListSorter<LoopAngles*>());
809 [ # # ]: 0 : loop_angle_list.reset();
810 [ # # ][ # # ]: 0 : for ( int jj = 0; jj < loop_angle_list.size(); jj++ )
811 : : {
812 [ # # ]: 0 : Loop* loop = loop_angle_list.get_and_step()->loopPtr;
813 [ # # ]: 0 : loop_list.append( loop );
814 : 0 : bool debug = false;
815 [ # # ]: 0 : if (debug)
816 : : {
817 [ # # ]: 0 : DLIList<RefEdge*> edge_list;
818 [ # # ]: 0 : loop->ordered_ref_edges(edge_list);
819 [ # # ][ # # ]: 0 : for (int kk = 0; kk < edge_list.size(); kk++)
820 : : {
821 [ # # ]: 0 : RefEdge *e = edge_list[kk];
822 [ # # ]: 0 : GfxDebug::highlight_ref_edge(e);
823 [ # # ]: 0 : GfxDebug::flush();
824 : : }
825 [ # # ][ # # ]: 0 : GfxDebug::clear_highlight();
826 : : }
827 : : }
828 : :
829 : : //Delete loop_angles
830 [ # # ][ # # ]: 0 : while( loop_angle_list.size() != 0 )
831 [ # # ]: 0 : delete loop_angle_list.remove();
832 : : }
833 : :
834 : 198 : bool debug = false;
835 [ - + ]: 198 : if (debug)
836 : : {
837 [ # # ][ # # ]: 0 : PRINT_INFO("Debugging ordered_loops\n");
[ # # ][ # # ]
838 [ # # ][ # # ]: 0 : for (int i = 0; i < loop_list.size(); i++)
839 : : {
840 [ # # ]: 0 : DLIList<RefEdge*> edge_list;
841 [ # # ]: 0 : Loop* loop = loop_list[i];
842 [ # # ]: 0 : loop->ordered_ref_edges(edge_list);
843 [ # # ][ # # ]: 0 : PRINT_INFO(" Edges: ");
[ # # ][ # # ]
844 [ # # ][ # # ]: 0 : for (int j = 0; j < edge_list.size(); j++)
845 : : {
846 [ # # ][ # # ]: 0 : PRINT_INFO("%d ", edge_list[j]->id());
[ # # ][ # # ]
[ # # ][ # # ]
847 : : }
848 [ # # ][ # # ]: 0 : PRINT_INFO("\n");
[ # # ][ # # ]
849 [ # # ]: 0 : }
850 : : }
851 [ + - ]: 396 : return CUBIT_SUCCESS;
852 : : }
853 : :
854 : 66 : int RefFace::co_edge_loops ( DLIList<DLIList<CoEdge*> >& co_edge_loops )
855 : : {
856 [ + - ]: 66 : DLIList<DLIList<CoEdge*> > temp_loop_list;
857 [ + - ][ + - ]: 132 : DLIList<Loop*> loop_list;
858 : 66 : CubitStatus status = CUBIT_FAILURE;
859 : : Loop *loop_ptr;
860 : :
861 : : //Get the ordered loops (outside to inside);
862 [ + - ]: 66 : status = ordered_loops( loop_list );
863 [ - + ]: 66 : if ( status == CUBIT_FAILURE )
864 : 0 : return status;
865 : :
866 : : //Now get the co_edges associated with the loops.
867 [ + - ][ + + ]: 132 : for ( int ii = loop_list.size(); ii > 0; ii-- )
868 : : {
869 [ + - ]: 66 : loop_ptr = loop_list.get_and_step();
870 : :
871 : : // Get the CoEdges on this Loop (the "24" is just a memory allocation
872 : : // chunking value and doesn't imply that we have a list of size 24!!)
873 [ + - ]: 66 : DLIList<CoEdge*> co_edge_list;
874 : :
875 : : //Get the ref_edges with respect to the loop.
876 [ + - ]: 66 : status = loop_ptr->ordered_co_edges( co_edge_list );
877 [ - + ]: 66 : if ( status == CUBIT_FAILURE )
878 : : {
879 : 0 : return status;
880 : : }
881 [ + - ][ + - ]: 66 : temp_loop_list.append( co_edge_list );
[ + - ]
882 : 66 : }
883 [ + - ]: 66 : co_edge_loops += temp_loop_list;
884 : :
885 [ + - ]: 132 : return CUBIT_SUCCESS;
886 : : }
887 : :
888 : 132 : int RefFace::ref_edge_loops ( DLIList<DLIList<RefEdge*> >& ref_edge_loops )
889 : : {
890 : : // NOTE: all of the ref_edge_list's will need to be deleted by
891 : : // the calling function...
892 : :
893 [ + - ]: 132 : DLIList<RefEdge*> ref_edge_list;
894 [ + - ][ + - ]: 264 : DLIList<DLIList<RefEdge*> > temp_loop_list;
895 [ + - ][ + - ]: 264 : DLIList<Loop*> loop_list;
896 : 132 : CubitStatus status = CUBIT_FAILURE;
897 : : Loop *loop_ptr;
898 : :
899 : : //Get the ordered loops (outside to inside);
900 [ + - ]: 132 : status = ordered_loops( loop_list );
901 [ - + ]: 132 : if ( status == CUBIT_FAILURE )
902 : 0 : return status;
903 : :
904 : : //Now get the ref-edges associated with the loops.
905 [ + - ][ + + ]: 264 : for ( int ii = loop_list.size(); ii > 0; ii-- )
906 : : {
907 [ + - ]: 132 : loop_ptr = loop_list.get_and_step();
908 : :
909 [ + - ]: 132 : ref_edge_list.clean_out();
910 : :
911 : : //Get the ref_edges with respect to the loop.
912 [ + - ]: 132 : status = loop_ptr->ordered_ref_edges( ref_edge_list );
913 [ - + ]: 132 : if ( status == CUBIT_FAILURE )
914 : : {
915 : 0 : return status;
916 : : }
917 [ + - ]: 132 : temp_loop_list.append( ref_edge_list );
918 : : }
919 [ + - ]: 132 : ref_edge_loops += temp_loop_list;
920 : :
921 [ + - ]: 264 : return CUBIT_SUCCESS;
922 : : }
923 : :
924 : :
925 : 0 : RefVolume* RefFace::ref_volume()
926 : : {
927 [ # # ]: 0 : DLIList<RefEntity*> entity_list;
928 [ # # ][ # # ]: 0 : DLIList<RefVolume*> vol_list;
929 : : RefVolume *vol_ptr;
930 : :
931 : : // Get the list of RefVolumes that own this RefFace.
932 [ # # ]: 0 : get_parent_ref_entities( entity_list );
933 [ # # ][ # # ]: 0 : CAST_LIST( entity_list, vol_list , RefVolume);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
934 : :
935 : : // Return the first valid RefVolume from the list.
936 [ # # ]: 0 : vol_list.reset();
937 [ # # ][ # # ]: 0 : for( int i = vol_list.size(); i>0; i-- )
938 : : {
939 [ # # ]: 0 : vol_ptr = vol_list.get_and_step();
940 [ # # ]: 0 : if( vol_ptr )
941 : 0 : return vol_ptr;
942 : : }
943 : :
944 : : // Print ERROR if no valid RefVolume was found.
945 [ # # ][ # # ]: 0 : PRINT_ERROR("No RefVolume found for the RefEdge.\n");
[ # # ][ # # ]
946 [ # # ]: 0 : return NULL;
947 : : }
948 : :
949 : : //NOTE: There could be more than one CoFace that is associated with this
950 : : // volume and ref-faces, (hard-surfaces).
951 : 0 : CoFace* RefFace::get_matching_CoFace(RefVolume* ref_volume_ptr)
952 : : {
953 [ # # ]: 0 : return dynamic_cast<CoFace*>(find_sense_entity(ref_volume_ptr));
954 : : }
955 : :
956 : :
957 : 0 : void RefFace::add_hard_point( RefVertex* ref_vertex_ptr)
958 : : {
959 : 0 : hardPointList.append( ref_vertex_ptr );
960 : 0 : }
961 : :
962 : 0 : void RefFace::hard_points( DLIList<RefVertex*>& new_hard_point_list )
963 : : {
964 : 0 : new_hard_point_list = hardPointList;
965 : 0 : }
966 : :
967 : 0 : CubitVector RefFace::position_from_u_v (double u, double v)
968 : : {
969 : : // Get the Surface this object points to
970 : 0 : Surface* surfacePtr = get_surface_ptr();
971 : :
972 : : // Make sure we get a valid Surface
973 [ # # ]: 0 : assert(surfacePtr != NULL) ;
974 : :
975 : : // Ask the Surface to do the real work
976 : 0 : return surfacePtr->position_from_u_v(u, v) ;
977 : : }
978 : :
979 : 1232 : CubitStatus RefFace::u_v_from_position (CubitVector const& location,
980 : : double& u,
981 : : double& v,
982 : : CubitVector* closest_location )
983 : : {
984 : : //- This function returns the {u, v} coordinates of the point
985 : : //- on the Surface closest to the input point (specified in global
986 : : //- space). The closest_location is also returned.
987 : :
988 : : // pass call directly to surface
989 : 1232 : Surface *surface = get_surface_ptr();
990 : :
991 : : // check surface ptr
992 [ - + ]: 1232 : assert(surface != NULL);
993 : :
994 [ + - ]: 1232 : if(is_parametric() == CUBIT_TRUE)
995 : : {
996 : : return surface->u_v_from_position (location, u, v,
997 : 1232 : closest_location);
998 : : }
999 : : else
1000 : : {
1001 : 0 : return CUBIT_FAILURE;
1002 : : }
1003 : : }
1004 : :
1005 : :
1006 : 3068 : CubitBoolean RefFace::is_parametric()
1007 : : {
1008 : : //- This function determines whether the underlying geometry of the
1009 : : //- Surface is parametrically defined or not. Returns CUBIT_TRUE if
1010 : : //- it is and CUBIT_FALSE if it is not.
1011 : :
1012 : : // pass call directly to surface
1013 : 3068 : Surface *surface = get_surface_ptr();
1014 : :
1015 : : // check surface ptr
1016 [ - + ]: 3068 : assert(surface != NULL);
1017 : :
1018 : 3068 : return surface->is_parametric();
1019 : : }
1020 : :
1021 : 197 : CubitBoolean RefFace::get_param_range_U( double& lower_bound,
1022 : : double& upper_bound )
1023 : : {
1024 : : //- Returns the lower and upper parametric bounds of the
1025 : : //- surface in U, if it is parametric. Otherwise, it returns
1026 : : //- CUBIT_FALSE and zeroes for the upper and lower parametric
1027 : : //- bounds.
1028 : :
1029 : : // pass call directly to surface
1030 : 197 : Surface *surface = get_surface_ptr();
1031 : :
1032 : : // check surface ptr
1033 [ - + ]: 197 : assert(surface != NULL);
1034 : :
1035 : 197 : return surface->get_param_range_U(lower_bound, upper_bound);
1036 : : }
1037 : :
1038 : :
1039 : 197 : CubitBoolean RefFace::get_param_range_V( double& lower_bound,
1040 : : double& upper_bound )
1041 : : {
1042 : : //- Returns the lower and upper parametric bounds of the
1043 : : //- surface in V, if it is parametric. Otherwise, it returns
1044 : : //- CUBIT_FALSE and zeroes for the upper and lower parametric
1045 : : //- bounds.
1046 : :
1047 : : // pass call directly to surface
1048 : 197 : Surface *surface = get_surface_ptr();
1049 : :
1050 : : // check surface ptr
1051 [ - + ]: 197 : assert(surface != NULL);
1052 : :
1053 : 197 : return surface->get_param_range_V(lower_bound, upper_bound);
1054 : : }
1055 : :
1056 : 0 : CubitBoolean RefFace::is_periodic()
1057 : : {
1058 : : //- This function determines whether the underlying geometry of the
1059 : : //- Surface is periodic or not. Returns CUBIT_TRUE if it is and
1060 : : //- CUBIT_FALSE if it is not.
1061 : :
1062 : : // pass call directly to surface
1063 : 0 : Surface *surface = get_surface_ptr();
1064 : :
1065 : : // check surface ptr
1066 [ # # ]: 0 : assert(surface != NULL);
1067 : :
1068 : 0 : return surface->is_periodic();
1069 : : }
1070 : :
1071 : 240 : CubitBoolean RefFace::is_periodic_in_U( double& period )
1072 : : {
1073 : : //- Determines whether the surface object is
1074 : : //- periodic in the U direction or not. If it is, it
1075 : : //- returns CUBIT_TRUE and the value of the period. Otherwise,
1076 : : //- it returns CUBIT_FALSE and a value of 0.0 or the period.
1077 : :
1078 : : // pass call directly to surface
1079 : 240 : Surface *surface = get_surface_ptr();
1080 : :
1081 : : // check surface ptr
1082 [ - + ]: 240 : assert(surface != NULL);
1083 : :
1084 : 240 : return surface->is_periodic_in_U(period);
1085 : : }
1086 : :
1087 : 240 : CubitBoolean RefFace::is_periodic_in_V( double& period )
1088 : : {
1089 : : //- Determines whether the surface object is
1090 : : //- periodic in the V direction or not. If it is, it
1091 : : //- returns CUBIT_TRUE and the value of the period. Otherwise,
1092 : : //- it returns CUBIT_FALSE and a value of 0.0 or the period.
1093 : :
1094 : : // pass call directly to surface
1095 : 240 : Surface *surface = get_surface_ptr();
1096 : :
1097 : : // check surface ptr
1098 [ - + ]: 240 : assert(surface != NULL);
1099 : :
1100 : 240 : return surface->is_periodic_in_V(period);
1101 : : }
1102 : 0 : CubitBoolean RefFace::is_singular_in_U( double u_param )
1103 : : {
1104 : : //- Determines whether the surface object is
1105 : : //- singular in the U direction or not.
1106 : : // pass call directly to surface
1107 : 0 : Surface *surface = get_surface_ptr();
1108 : :
1109 : : // check surface ptr
1110 [ # # ]: 0 : assert(surface != NULL);
1111 : :
1112 : 0 : return surface->is_singular_in_U(u_param);
1113 : : }
1114 : 0 : CubitBoolean RefFace::is_singular_in_V( double v_param )
1115 : : {
1116 : : //- Determines whether the surface object is
1117 : : //- singular in the V direction or not.
1118 : : // pass call directly to surface
1119 : 0 : Surface *surface = get_surface_ptr();
1120 : :
1121 : : // check surface ptr
1122 [ # # ]: 0 : assert(surface != NULL);
1123 : :
1124 : 0 : return surface->is_singular_in_V(v_param);
1125 : : }
1126 : :
1127 : 0 : RefEdge* RefFace::common_ref_edge ( RefFace* input_face_ptr )
1128 : : {
1129 [ # # ]: 0 : DLIList<RefEdge*> this_edge_list;
1130 [ # # ]: 0 : ref_edges ( this_edge_list );
1131 : :
1132 [ # # ][ # # ]: 0 : for ( int i = this_edge_list.size(); i > 0; i--)
1133 : : {
1134 [ # # ]: 0 : RefEdge* edge = this_edge_list.get_and_step();
1135 [ # # ][ # # ]: 0 : if (edge->find_sense_entity(input_face_ptr))
1136 : 0 : return edge;
1137 : : }
1138 : :
1139 [ # # ]: 0 : return NULL;
1140 : : }
1141 : :
1142 : 0 : int RefFace::common_ref_edges ( RefFace* input_face_ptr, DLIList<RefEdge*> &common_edge_list )
1143 : : {
1144 [ # # ]: 0 : DLIList<RefEdge*> this_edge_list;
1145 [ # # ]: 0 : ref_edges ( this_edge_list );
1146 : 0 : int nedges = 0;
1147 : :
1148 [ # # ][ # # ]: 0 : for ( int i = this_edge_list.size(); i > 0; i--)
1149 : : {
1150 [ # # ]: 0 : RefEdge* edge = this_edge_list.get_and_step();
1151 [ # # ][ # # ]: 0 : if (edge->find_sense_entity(input_face_ptr))
1152 : : {
1153 [ # # ]: 0 : common_edge_list.append(edge);
1154 : 0 : nedges++;
1155 : : }
1156 : : }
1157 : :
1158 [ # # ]: 0 : return nedges;
1159 : : }
1160 : :
1161 : 0 : RefVolume* RefFace::common_ref_volume ( RefFace* input_face_ptr )
1162 : : {
1163 [ # # ]: 0 : DLIList<RefVolume*> this_volume_list;
1164 [ # # ][ # # ]: 0 : DLIList<RefVolume*> input_volume_list;
1165 : :
1166 [ # # ]: 0 : ref_volumes ( this_volume_list );
1167 [ # # ]: 0 : input_face_ptr->ref_volumes ( input_volume_list );
1168 : :
1169 [ # # ][ # # ]: 0 : for ( int i = this_volume_list.size(); i > 0; i--)
1170 : : {
1171 [ # # ][ # # ]: 0 : if (input_volume_list.move_to (this_volume_list.get()))
[ # # ]
1172 : : {
1173 [ # # ]: 0 : return this_volume_list.get();
1174 : : }
1175 : :
1176 [ # # ]: 0 : this_volume_list.step();
1177 : : }
1178 : :
1179 [ # # ]: 0 : return NULL;
1180 : : }
1181 : :
1182 : 747506 : int RefFace::dimension() const
1183 : : {
1184 : 747506 : return 2;
1185 : : }
1186 : 720 : double RefFace::area()
1187 : : {
1188 : 720 : return GeomMeasureTool::measure_area(this);
1189 : : }
1190 : :
1191 : 720 : double RefFace::measure()
1192 : : {
1193 : 720 : return this->area();
1194 : : }
1195 : :
1196 : 0 : CubitString RefFace::measure_label()
1197 : : {
1198 : 0 : return "area";
1199 : : }
1200 : :
1201 : : //-------------------------------------------------------------------------
1202 : : // Purpose : Return a pointer to the surface associated with a face.
1203 : : //
1204 : : // Special Notes :
1205 : : //
1206 : : // Creator : Xuechen Liu
1207 : : //
1208 : : // Creation Date : 08/02/96
1209 : : //-------------------------------------------------------------------------
1210 : 3801157 : Surface* RefFace::get_surface_ptr()
1211 : : {
1212 : : // Just do one cast instead of two -- KGM
1213 : 3801157 : TopologyBridge* bridge = bridge_manager()->topology_bridge();
1214 [ + - ]: 3801157 : return CAST_TO(bridge, Surface);
1215 : : //return CAST_TO(get_geometry_entity_ptr(), Surface);
1216 : : }
1217 : :
1218 : 0 : const Surface* RefFace::get_surface_ptr() const
1219 : : {
1220 [ # # ]: 0 : return CAST_TO(get_geometry_entity_ptr(), Surface);
1221 : : }
1222 : :
1223 : :
1224 : : //-------------------------------------------------------------------------
1225 : : // Purpose : This function returns CUBIT_TRUE if the underlying
1226 : : // geometry of the face is planar. CUBIT_FALSE otherwise.
1227 : : //
1228 : : // Special Notes :
1229 : : //
1230 : : // Creator : Raikanta Sahu
1231 : : //
1232 : : // Creation Date : 12/17/96
1233 : : //-------------------------------------------------------------------------
1234 : 0 : CubitBoolean RefFace::is_planar()
1235 : : {
1236 : : // Cast the generic GeometryEntity pointer to Surface pointer
1237 : 0 : Surface* surfacePtr = this->get_surface_ptr() ;
1238 : :
1239 : : // Check if we have a valid Surface. If so, return the result of
1240 : : // querying the Surface if it is planar.
1241 [ # # ]: 0 : if ( surfacePtr != NULL )
1242 : : {
1243 : : GeometryType geo_type;
1244 : 0 : geo_type = surfacePtr->geometry_type();
1245 [ # # ]: 0 : return geo_type == PLANE_SURFACE_TYPE ? CUBIT_TRUE : CUBIT_FALSE;
1246 : : }
1247 : : else
1248 : : {
1249 [ # # ][ # # ]: 0 : PRINT_WARNING("In RefFace::is_planar\n"
[ # # ][ # # ]
1250 : : " %s (surface %d) is not associated with a valid\n"
1251 : : " underlying geoemtric Surface\n",
1252 [ # # ]: 0 : entity_name().c_str(), id()) ;
1253 : 0 : return CUBIT_FALSE ;
1254 : : }
1255 : : }
1256 : :
1257 : :
1258 : : //-------------------------------------------------------------------------
1259 : : // Purpose : This function returns CUBIT_TRUE if the underlying
1260 : : // geometry of the face is cylindrical. CUBIT_FALSE otherwise.
1261 : : //
1262 : : // Special Notes :
1263 : : //
1264 : : // Creator : KGM
1265 : : //
1266 : : // Creation Date : 03/22/07
1267 : : //-------------------------------------------------------------------------
1268 : 0 : CubitBoolean RefFace::is_cylindrical()
1269 : : {
1270 : : // Cast the generic GeometryEntity pointer to Surface pointer
1271 : 0 : Surface* surfacePtr = this->get_surface_ptr() ;
1272 : :
1273 : : // Check if we have a valid Surface. If so, return the result of
1274 : : // querying the Surface if it is planar.
1275 [ # # ]: 0 : if ( surfacePtr != NULL )
1276 : : {
1277 : : GeometryType geo_type;
1278 : 0 : geo_type = surfacePtr->is_cylindrical();
1279 [ # # ]: 0 : return geo_type == CYLINDER_SURFACE_TYPE ? CUBIT_TRUE : CUBIT_FALSE;
1280 : : }
1281 : : else
1282 : : {
1283 [ # # ][ # # ]: 0 : PRINT_WARNING("In RefFace::is_cylindrical\n"
[ # # ][ # # ]
1284 : : " %s (surface %d) is not associated with a valid\n"
1285 : : " underlying geoemtric Surface\n",
1286 [ # # ]: 0 : entity_name().c_str(), id()) ;
1287 : 0 : return CUBIT_FALSE ;
1288 : : }
1289 : : }
1290 : :
1291 : 0 : CubitStatus RefFace::get_point_normal( CubitVector& origin, CubitVector& normal )
1292 : : {
1293 [ # # ]: 0 : if( is_planar() == CUBIT_FALSE)
1294 : 0 : return CUBIT_FAILURE;
1295 : :
1296 : 0 : Surface* surface_ptr = get_surface_ptr();
1297 : :
1298 [ # # ]: 0 : if( surface_ptr != NULL )
1299 : : {
1300 [ # # ]: 0 : if( surface_ptr->get_point_normal( origin, normal ) == CUBIT_FAILURE )
1301 : 0 : return CUBIT_FAILURE;
1302 : : }
1303 : : else
1304 : : {
1305 [ # # ][ # # ]: 0 : PRINT_WARNING("In RefFace::get_point_normal\n"
[ # # ][ # # ]
1306 : : " %s (surface %d) is not associated with a valid\n"
1307 : : " underlying geoemtric Surface\n",
1308 [ # # ]: 0 : entity_name().c_str(), id()) ;
1309 : 0 : return CUBIT_FAILURE;
1310 : : }
1311 : :
1312 [ # # ]: 0 : if (surface_ptr->bridge_sense() == CUBIT_REVERSED)
1313 [ # # ]: 0 : normal = -normal;
1314 : :
1315 : 0 : return CUBIT_SUCCESS;
1316 : : }
1317 : :
1318 : 0 : int RefFace::validate()
1319 : : {
1320 : : //- This function determines whether the entity is valid.
1321 : : //- Several types of checks can be done,
1322 : 0 : int error = 0;
1323 : :
1324 : : // Perform general RefEntity checks (measure > 0)
1325 : 0 : error += RefEntity::validate();
1326 : :
1327 : : // Pass through to surface and add in its validation
1328 : 0 : Surface *surface = get_surface_ptr();
1329 : :
1330 : : // check surface ptr
1331 [ # # ]: 0 : if (surface != NULL) {
1332 : : // Check underlying surface
1333 [ # # ]: 0 : DLIList <TopologyEntity*> bad_entities;
1334 [ # # ][ # # ]: 0 : error += surface->validate(entity_name(), bad_entities);
[ # # ][ # # ]
1335 : : } else {
1336 [ # # ][ # # ]: 0 : PRINT_WARNING("\tWARNING: Null underlying surface for %s, (%s %d)\n",
[ # # ][ # # ]
1337 [ # # ]: 0 : entity_name().c_str(), class_name(), id());
1338 : 0 : error++;
1339 : : }
1340 : 0 : return error;
1341 : : }
1342 : :
1343 : : //-------------------------------------------------------------------------
1344 : : // Purpose : Initializes all member data
1345 : : //
1346 : : // Special Notes :
1347 : : //
1348 : : // Creator : Malcolm J. Panthaki
1349 : : //
1350 : : // Creation Date : 09/25/96
1351 : : //-------------------------------------------------------------------------
1352 : 16046 : void RefFace::initialize()
1353 : : {
1354 : : // Set the Entity ID for this new RefFace
1355 [ + - ]: 16046 : GeometryEntity* geom_ptr = get_geometry_entity_ptr();
1356 [ + - ]: 16046 : int saved_id = geom_ptr->get_saved_id();
1357 [ - + ][ # # ]: 16046 : if ( !saved_id || RefEntityFactory::instance()->get_ref_face(saved_id) )
[ # # ][ # # ]
[ + - ]
1358 : : {
1359 [ + - ][ + - ]: 16046 : saved_id = RefEntityFactory::instance()->next_ref_face_id();
1360 [ + - ]: 16046 : geom_ptr->set_saved_id(saved_id);
1361 : : }
1362 : 16046 : entityId = saved_id;
1363 : :
1364 : : // Default graphics attributes
1365 : 16046 : hardPointColor = 1;
1366 : :
1367 : : // initialize meshing data
1368 : :
1369 : : // initialize the bounding box
1370 [ + - ]: 16046 : CubitBox bound_box = bounding_box();
1371 : : maxPositionDeviation =
1372 [ + - ][ + - ]: 16046 : (bound_box.maximum() - bound_box.minimum()).length()/10.0;
[ + - ][ + - ]
1373 : :
1374 : : // read and initialize attributes
1375 [ + - ]: 16046 : auto_read_cubit_attrib();
1376 [ + - ]: 16046 : auto_actuate_cubit_attrib();
1377 : :
1378 : : #ifdef ALPHA_TREADSWEEP
1379 : : if(entityId != saved_id)
1380 : : geom_ptr->set_saved_id(entityId);
1381 : : #endif
1382 : :
1383 : : // Assign a default entity name
1384 [ + - ][ + - ]: 16046 : assign_default_name();
1385 : :
1386 : 16046 : }
1387 : :
1388 : 0 : void RefFace::reverse_topology()
1389 : : {
1390 : :
1391 : : int i;
1392 : :
1393 : : // switch sense going up in dimension
1394 [ # # ]: 0 : DLIList<CoFace*> co_face_list;
1395 [ # # ]: 0 : co_faces( co_face_list );
1396 [ # # ][ # # ]: 0 : for ( i = co_face_list.size(); i--; ) {
1397 [ # # ]: 0 : CoFace *co_face = co_face_list.get_and_step();
1398 [ # # ][ # # ]: 0 : co_face->set_sense( CubitUtil::opposite_sense( co_face->get_sense() ) );
[ # # ]
1399 : : }
1400 : :
1401 : : // switch sense going down in dimension
1402 [ # # ][ # # ]: 0 : DLIList<Loop*> loop_list;
1403 [ # # ]: 0 : loops( loop_list );
1404 [ # # ][ # # ]: 0 : for ( i = loop_list.size(); i--; )
1405 [ # # ][ # # ]: 0 : loop_list.get_and_step()->reverse_direction();
[ # # ]
1406 : 0 : }
1407 : :
1408 : 0 : void RefFace::reverse_normal()
1409 : : {
1410 : 0 : bridge_manager()->reverse_bridge_senses();
1411 : 0 : reverse_topology();
1412 : 0 : }
1413 : :
1414 : 0 : CubitBoolean RefFace::set_outward_normal( RefVolume *volume )
1415 : : {
1416 : 0 : CubitSense vol_sense = sense( volume );
1417 [ # # ]: 0 : if ( vol_sense == CUBIT_UNKNOWN )
1418 : 0 : return CUBIT_FALSE;
1419 [ # # ][ # # ]: 0 : assert( vol_sense == CUBIT_FORWARD || vol_sense == CUBIT_REVERSED );
1420 [ # # ]: 0 : if ( vol_sense == CUBIT_REVERSED ) {
1421 : 0 : reverse_normal();
1422 : 0 : return CUBIT_TRUE;
1423 : : }
1424 : : // else already right pointing right way.
1425 : 0 : return CUBIT_FALSE;
1426 : : }
1427 : :
1428 : 2877 : CubitStatus RefFace::get_graphics( GMem& facets,
1429 : : unsigned short normal_tolerance,
1430 : : double distance_tolerance,
1431 : : double longest_edge )
1432 : : {
1433 : 2877 : Surface* surf_ptr = get_surface_ptr();
1434 [ - + ]: 2877 : if (!surf_ptr)
1435 : : {
1436 [ # # ][ # # ]: 0 : PRINT_ERROR("RefFace %d is invalid -- no attached Surface.\n",id());
1437 : 0 : return CUBIT_FAILURE;
1438 : : }
1439 : :
1440 : 2877 : return surf_ptr->get_geometry_query_engine()->
1441 : : get_graphics(surf_ptr, &facets,
1442 : 2877 : normal_tolerance, distance_tolerance, longest_edge );
1443 : : }
1444 : :
1445 : 0 : CubitBoolean RefFace::is_closed_in_U()
1446 : : {
1447 : 0 : Surface* surface_ptr = get_surface_ptr();
1448 : 0 : return surface_ptr->is_closed_in_U();
1449 : : }
1450 : :
1451 : 0 : CubitBoolean RefFace::is_closed_in_V()
1452 : : {
1453 : 0 : Surface* surface_ptr = get_surface_ptr();
1454 : 0 : return surface_ptr->is_closed_in_V();
1455 : : }
1456 : :
1457 : 0 : CubitStatus RefFace::evaluate( double u, double v,
1458 : : CubitVector *position,
1459 : : CubitVector *normal,
1460 : : CubitVector *curvature1,
1461 : : CubitVector *curvature2 )
1462 : : {
1463 [ # # ][ # # ]: 0 : if( NULL == position && NULL == normal &&
[ # # ]
1464 [ # # ]: 0 : NULL == curvature1 && NULL == curvature2 )
1465 : 0 : return CUBIT_FAILURE;
1466 : :
1467 : 0 : Surface* surf_ptr = get_surface_ptr();
1468 [ # # ]: 0 : if (!surf_ptr)
1469 : : {
1470 [ # # ][ # # ]: 0 : PRINT_ERROR("RefFace %d is invalid -- no attached Surface.\n",id());
1471 : 0 : return CUBIT_FAILURE;
1472 : : }
1473 : :
1474 : 0 : return surf_ptr->evaluate(u, v, position, normal, curvature1, curvature2 );
1475 : : }
1476 : :
1477 : :
1478 : 0 : CubitStatus RefFace::get_projected_distance_on_surface( CubitVector *pos1,
1479 : : CubitVector *pos2,
1480 : : double &distance )
1481 : : {
1482 [ # # ]: 0 : if( pos1 == pos2 )
1483 : 0 : return CUBIT_FAILURE;
1484 : :
1485 [ # # ][ # # ]: 0 : if( NULL == pos1 || NULL == pos2 )
1486 : 0 : return CUBIT_FAILURE;
1487 : :
1488 : 0 : Surface* surf_ptr = get_surface_ptr();
1489 [ # # ]: 0 : if (!surf_ptr)
1490 : : {
1491 [ # # ][ # # ]: 0 : PRINT_ERROR("RefFace %d is invalid -- no attached Surface.\n",id());
1492 : 0 : return CUBIT_FAILURE;
1493 : : }
1494 : :
1495 : 0 : return surf_ptr->get_projected_distance_on_surface( pos1, pos2, distance );
1496 : : }
1497 : :
1498 : 114 : void RefFace::get_parent_ref_entities(DLIList<RefEntity*>& entity_list)
1499 : : {
1500 : :
1501 : : // First get the type of RefEntity that is a child of "this" one
1502 [ + - ]: 114 : DagType parent_type = get_parent_ref_entity_type();;
1503 : :
1504 [ + - ]: 114 : DLIList<TopologyEntity*> tempList ;
1505 : :
1506 : : CubitStatus result = ModelQueryEngine::instance()->
1507 [ + - ][ + - ]: 114 : query_model( *this, parent_type, tempList );
1508 [ - + ]: 114 : if (result == CUBIT_FAILURE)
1509 : : {
1510 [ # # ][ # # ]: 0 : PRINT_ERROR("In RefEntity::get_parent_ref_entities\n");
[ # # ][ # # ]
1511 [ # # ][ # # ]: 0 : PRINT_ERROR(" Query failed for unknown reason.\n");
[ # # ][ # # ]
1512 : 114 : return;
1513 : : }
1514 : :
1515 [ + - ]: 114 : entity_list.clean_out();
1516 [ + - ][ + + ]: 228 : for(int i=0; i<tempList.size(); i++)
[ + - ][ + - ]
1517 : : {
1518 [ + - ][ + - ]: 114 : entity_list.append(static_cast<ParentType*>(tempList[i]));
[ + - ]
1519 : 114 : }
1520 [ + - ][ + - ]: 6540 : }
|
