Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : PartitionBody.cpp
3 : : //
4 : : // Purpose :
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Jason Kraftcheck
9 : : //
10 : : // Creation Date : 02/14/03
11 : : //-------------------------------------------------------------------------
12 : :
13 : : #include "PartitionBody.hpp"
14 : : #include "CubitTransformMatrix.hpp"
15 : : #include "CubitFacetData.hpp"
16 : : #include "CubitPointData.hpp"
17 : : #include "PartitionPoint.hpp"
18 : : #include "PartitionSurface.hpp"
19 : : #include "SegmentedCurve.hpp"
20 : : #include "PartitionCoEdge.hpp"
21 : : #include "PartitionLump.hpp"
22 : : #include "VirtualQueryEngine.hpp"
23 : :
24 : : //-------------------------------------------------------------------------
25 : : // Purpose : Constructor
26 : : //
27 : : // Special Notes :
28 : : //
29 : : // Creator : Jason Kraftcheck
30 : : //
31 : : // Creation Date : 02/14/03
32 : : //-------------------------------------------------------------------------
33 : 0 : PartitionBody::PartitionBody( BodySM* body )
34 [ # # ]: 0 : : childList(0)
35 : : {
36 [ # # ][ # # ]: 0 : SubEntitySet* set = new SubEntitySet( body,this );
37 : 0 : set->bodyNext = 0;
38 : 0 : set->bodyPtr = this;
39 : 0 : }
40 : :
41 : :
42 : : //-------------------------------------------------------------------------
43 : : // Purpose : Desturctor
44 : : //
45 : : // Special Notes :
46 : : //
47 : : // Creator : Jason Kraftcheck
48 : : //
49 : : // Creation Date : 02/14/03
50 : : //-------------------------------------------------------------------------
51 [ # # ]: 0 : PartitionBody::~PartitionBody()
52 : : {
53 [ # # ][ # # ]: 0 : assert(! sub_entity_set().bodyNext);
54 [ # # ]: 0 : sub_entity_set().bodyPtr = 0;
55 : :
56 [ # # ]: 0 : while( SubEntitySet* dead = childList )
57 : : {
58 : 0 : childList = dead->bodyNext;
59 : 0 : dead->bodyNext = 0;
60 : 0 : dead->bodyPtr = 0;
61 : 0 : }
62 [ # # ]: 0 : }
63 : :
64 : : //-------------------------------------------------------------------------
65 : : // Purpose : Get transform matrix
66 : : //
67 : : // Special Notes :
68 : : //
69 : : // Creator : Jason Kraftcheck
70 : : //
71 : : // Creation Date : 02/14/03
72 : : //-------------------------------------------------------------------------
73 : 0 : CubitStatus PartitionBody::get_transforms( CubitTransformMatrix& xforms )
74 : : {
75 : 0 : return real_body()->get_transforms( xforms );
76 : : }
77 : :
78 : : //-------------------------------------------------------------------------
79 : : // Purpose : Attributes
80 : : //
81 : : // Special Notes :
82 : : //
83 : : // Creator : Jason Kraftcheck
84 : : //
85 : : // Creation Date : 02/14/03
86 : : //-------------------------------------------------------------------------
87 : 0 : void PartitionBody::append_simple_attribute_virt(const CubitSimpleAttrib& csa)
88 : 0 : { real_body()->append_simple_attribute_virt(csa); }
89 : 0 : void PartitionBody::remove_simple_attribute_virt(const CubitSimpleAttrib& csa)
90 : 0 : { real_body()->remove_simple_attribute_virt(csa); }
91 : 0 : void PartitionBody::remove_all_simple_attribute_virt()
92 : 0 : { real_body()->remove_all_simple_attribute_virt(); }
93 : 0 : CubitStatus PartitionBody::get_simple_attribute(DLIList<CubitSimpleAttrib>& list)
94 : 0 : { return real_body()->get_simple_attribute(list); }
95 : 0 : CubitStatus PartitionBody::get_simple_attribute(const CubitString& name,
96 : : DLIList<CubitSimpleAttrib>& list)
97 : 0 : { return real_body()->get_simple_attribute(name,list); }
98 : :
99 : : //-------------------------------------------------------------------------
100 : : // Purpose : Which layer
101 : : //
102 : : // Special Notes :
103 : : //
104 : : // Creator : Jason Kraftcheck
105 : : //
106 : : // Creation Date : 02/14/03
107 : : //-------------------------------------------------------------------------
108 : 0 : int PartitionBody::layer() const
109 : 0 : { return sub_entity_set().get_owner_layer(); }
110 : :
111 : : //-------------------------------------------------------------------------
112 : : // Purpose : get children
113 : : //
114 : : // Special Notes :
115 : : //
116 : : // Creator : Jason Kraftcheck
117 : : //
118 : : // Creation Date : 02/14/03
119 : : //-------------------------------------------------------------------------
120 : 0 : void PartitionBody::get_parents_virt( DLIList<TopologyBridge*>& )
121 : 0 : { }
122 : 0 : void PartitionBody::get_children_virt( DLIList<TopologyBridge*>& list )
123 : 0 : { real_body()->get_children_virt(list); }
124 : :
125 : : //-------------------------------------------------------------------------
126 : : // Purpose : get GQE
127 : : //
128 : : // Special Notes :
129 : : //
130 : : // Creator : Jason Kraftcheck
131 : : //
132 : : // Creation Date : 02/14/03
133 : : //-------------------------------------------------------------------------
134 : 0 : GeometryQueryEngine* PartitionBody::get_geometry_query_engine() const
135 : 0 : { return VirtualQueryEngine::instance(); }
136 : :
137 : : //-------------------------------------------------------------------------
138 : : // Purpose : misc. junk from PartitionEntity
139 : : //
140 : : // Special Notes :
141 : : //
142 : : // Creator : Jason Kraftcheck
143 : : //
144 : : // Creation Date : 02/14/03
145 : : //-------------------------------------------------------------------------
146 : 0 : void PartitionBody::reverse_sense() { assert(0); }
147 : 0 : void PartitionBody::notify_split(FacetEntity*, FacetEntity* ) { assert(0); }
148 : 0 : CubitStatus PartitionBody::save(CubitSimpleAttrib&) { return CUBIT_FAILURE; }
149 : :
150 : :
151 : : //-------------------------------------------------------------------------
152 : : // Purpose : get bounding box
153 : : //
154 : : // Special Notes :
155 : : //
156 : : // Creator : Jason Kraftcheck
157 : : //
158 : : // Creation Date : 02/14/03
159 : : //-------------------------------------------------------------------------
160 : 0 : CubitBox PartitionBody::bounding_box() const
161 : : {
162 [ # # ]: 0 : DLIList<TopologyBridge*> lumps;
163 [ # # ][ # # ]: 0 : real_body()->get_children_virt(lumps);
164 : :
165 [ # # ][ # # ]: 0 : CubitBox result = dynamic_cast<Lump*>(lumps.step_and_get())->bounding_box();
[ # # ]
166 [ # # ][ # # ]: 0 : for( int i = 1; i < lumps.size(); i++ )
167 [ # # ][ # # ]: 0 : result |= dynamic_cast<Lump*>(lumps.step_and_get())->bounding_box();
[ # # ][ # # ]
[ # # ]
168 : :
169 [ # # ]: 0 : return result;
170 : : }
171 : :
172 : :
173 : : //-------------------------------------------------------------------------
174 : : // Purpose : Get BodySM
175 : : //
176 : : // Special Notes :
177 : : //
178 : : // Creator : Jason Kraftcheck
179 : : //
180 : : // Creation Date : 02/14/03
181 : : //-------------------------------------------------------------------------
182 : 0 : BodySM* PartitionBody::real_body() const
183 [ # # ]: 0 : { return dynamic_cast<BodySM*>(partitioned_entity()); }
184 : :
185 : :
186 : : //-------------------------------------------------------------------------
187 : : // Purpose : Add an entity to the list we need to transform
188 : : //
189 : : // Special Notes :
190 : : //
191 : : // Creator : Jason Kraftcheck
192 : : //
193 : : // Creation Date : 02/14/03
194 : : //-------------------------------------------------------------------------
195 : 0 : void PartitionBody::add( SubEntitySet& set )
196 : : {
197 [ # # ]: 0 : assert(!set.bodyPtr);
198 : 0 : set.bodyPtr = this;
199 : 0 : set.bodyNext = childList;
200 : 0 : childList = &set;
201 : 0 : }
202 : :
203 : : //-------------------------------------------------------------------------
204 : : // Purpose : Remove an entity from the list of entities to transform
205 : : //
206 : : // Special Notes :
207 : : //
208 : : // Creator : Jason Kraftcheck
209 : : //
210 : : // Creation Date : 02/14/03
211 : : //-------------------------------------------------------------------------
212 : 0 : void PartitionBody::remove( SubEntitySet& set )
213 : : {
214 [ # # ]: 0 : assert(set.bodyPtr == this);
215 [ # # ]: 0 : if( childList == &set )
216 : : {
217 : 0 : childList = set.bodyNext;
218 : : }
219 : : else
220 : : {
221 : 0 : SubEntitySet* ptr = childList;
222 [ # # ]: 0 : while( ptr->bodyNext != &set )
223 : : {
224 : 0 : ptr = ptr->bodyNext;
225 [ # # ]: 0 : assert(!!ptr);
226 : : }
227 : 0 : ptr->bodyNext = set.bodyNext;
228 : : }
229 : 0 : set.bodyNext = 0;
230 : 0 : set.bodyPtr = 0;
231 : 0 : }
232 : :
233 : :
234 : : //-------------------------------------------------------------------------
235 : : // Purpose : Remove all child partition geometry (body deleted)
236 : : //
237 : : // Special Notes :
238 : : //
239 : : // Creator : Jason Kraftcheck
240 : : //
241 : : // Creation Date : 04/04/03
242 : : //-------------------------------------------------------------------------
243 : 0 : void PartitionBody::destroy_all_children()
244 : : {
245 [ # # ]: 0 : DLIList<PartitionLump*> lumps;
246 [ # # ][ # # ]: 0 : DLIList<PartitionSurface*> surfs;
247 [ # # ][ # # ]: 0 : DLIList<PartitionCoEdge*> coedges;
248 [ # # ][ # # ]: 0 : DLIList<PartitionCurve*> curves;
249 [ # # ][ # # ]: 0 : DLIList<PartitionPoint*> points;
250 : :
251 [ # # ][ # # ]: 0 : DLIList<PartitionEntity*> sub_geom, split_geom;
[ # # ][ # # ]
252 [ # # ][ # # ]: 0 : for ( SubEntitySet* ptr = childList; ptr; ptr = ptr->next_in_body() )
253 : : {
254 [ # # ]: 0 : ptr->get_sub_entities( sub_geom );
255 [ # # ]: 0 : ptr->get_lower_order( split_geom );
256 [ # # ]: 0 : sub_geom += split_geom;
257 [ # # ]: 0 : split_geom.clean_out();
258 [ # # ][ # # ]: 0 : while( sub_geom.size() )
259 : : {
260 [ # # ]: 0 : PartitionEntity* ent = sub_geom.pop();
261 [ # # ][ # # ]: 0 : if ( PartitionPoint* point = dynamic_cast<PartitionPoint*>(ent) )
262 [ # # ]: 0 : points.append(point);
263 [ # # ][ # # ]: 0 : else if( PartitionCoEdge* coedge = dynamic_cast<PartitionCoEdge*>(ent) )
264 [ # # ]: 0 : coedges.append(coedge);
265 [ # # ][ # # ]: 0 : else if( PartitionCurve* curve = dynamic_cast<PartitionCurve*>(ent) )
266 [ # # ]: 0 : curves.append(curve);
267 [ # # ][ # # ]: 0 : else if( PartitionSurface* surf = dynamic_cast<PartitionSurface*>(ent) )
268 [ # # ]: 0 : surfs.append(surf);
269 [ # # ][ # # ]: 0 : else if ( PartitionLump* lump = dynamic_cast<PartitionLump*>(ent) )
270 [ # # ]: 0 : lumps.append(lump);
271 : : else
272 : 0 : assert(0);
273 : : }
274 : : }
275 : :
276 [ # # ][ # # ]: 0 : while( lumps.size() )
277 : : {
278 [ # # ]: 0 : PartitionLump* lump = lumps.pop();
279 [ # # ][ # # ]: 0 : while( PartitionShell* shell = lump->first_shell() )
280 : : {
281 [ # # ]: 0 : lump->remove(shell);
282 [ # # ]: 0 : shell->remove_all_surfaces();
283 [ # # ][ # # ]: 0 : delete shell;
284 : : }
285 [ # # ][ # # ]: 0 : delete lump;
286 : 0 : }
287 : :
288 [ # # ][ # # ]: 0 : while( surfs.size() )
289 : : {
290 [ # # ]: 0 : PartitionSurface* surf = surfs.pop();
291 [ # # ][ # # ]: 0 : while( PartitionLoop* loop = surf->next_loop(NULL) )
292 : : {
293 [ # # ]: 0 : surf->remove(loop);
294 [ # # ]: 0 : loop->remove_all_coedges();
295 [ # # ][ # # ]: 0 : delete loop;
296 : : }
297 [ # # ][ # # ]: 0 : delete surf;
298 : 0 : }
299 : :
300 [ # # ][ # # ]: 0 : while( coedges.size() )
301 : : {
302 [ # # ]: 0 : PartitionCoEdge* coedge = coedges.pop();
303 [ # # ][ # # ]: 0 : if (coedge->get_curve() != NULL)
304 [ # # ][ # # ]: 0 : coedge->get_curve()->remove( coedge );
305 [ # # ][ # # ]: 0 : delete coedge;
306 : : }
307 : :
308 [ # # ][ # # ]: 0 : while( curves.size() )
309 : : {
310 [ # # ]: 0 : PartitionCurve* curve = curves.pop();
311 [ # # ][ # # ]: 0 : assert( !curve->next_coedge(NULL) );
312 [ # # ][ # # ]: 0 : delete curve;
313 : : }
314 : :
315 [ # # ][ # # ]: 0 : while( points.size() )
316 : : {
317 [ # # ]: 0 : PartitionPoint* point = points.pop();
318 [ # # ][ # # ]: 0 : assert( !point->num_curves() );
319 [ # # ][ # # ]: 0 : delete point;
320 [ # # ]: 0 : }
321 : :
322 : : // All child SubEntitySets should have been deleted when they
323 : : // became empty, and should be removed from the list in this
324 : : // body as they are destroyed. However, when the last SubEntitySet
325 : : // in this body is destroyed, this body will be destroyed as well.
326 : : // So don't do this check!
327 : : //assert(!childList);
328 : 0 : }
329 : :
330 : : //-------------------------------------------------------------------------
331 : : // Purpose :
332 : : //
333 : : // Special Notes :
334 : : //
335 : : // Creator : Jason Kraftcheck
336 : : //
337 : : // Creation Date : 05/10/04
338 : : //-------------------------------------------------------------------------
339 : 0 : CubitStatus PartitionBody::mass_properties( CubitVector& result, double& volume )
340 : : {
341 [ # # ]: 0 : DLIList<Lump*> lump_list;
342 [ # # ]: 0 : lumps( lump_list );
343 : :
344 [ # # ][ # # ]: 0 : DLIList<PartitionLump*> part_list;
345 [ # # ][ # # ]: 0 : CAST_LIST( lump_list, part_list, PartitionLump );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
346 [ # # ][ # # ]: 0 : if (part_list.size() < lump_list.size())
[ # # ]
347 [ # # ][ # # ]: 0 : return real_body()->mass_properties( result, volume );
348 : :
349 [ # # ][ # # ]: 0 : CubitVector centroid(0.0, 0.0, 0.0), tmp_centroid;
350 : 0 : volume = 0.0;
351 : : double tmp_volume;
352 [ # # ][ # # ]: 0 : for (int i = part_list.size(); i--; )
353 : : {
354 [ # # ]: 0 : if (CUBIT_FAILURE ==
355 [ # # ][ # # ]: 0 : part_list.get_and_step()->mass_properties( tmp_centroid, tmp_volume ))
356 : 0 : return CUBIT_FAILURE;
357 : :
358 [ # # ][ # # ]: 0 : centroid += tmp_volume * tmp_centroid;
359 : 0 : volume += tmp_volume;
360 : : }
361 : :
362 [ # # ]: 0 : if (volume > CUBIT_RESABS)
363 : : {
364 [ # # ][ # # ]: 0 : result = centroid / volume;
365 : : }
366 : : else
367 : : {
368 [ # # ]: 0 : result.set( 0.0, 0.0, 0.0 );
369 : 0 : volume = 0.0;
370 : : }
371 [ # # ]: 0 : return CUBIT_SUCCESS;
372 : : }
373 : :
374 : : //-------------------------------------------------------------------------
375 : : // Purpose :
376 : : //
377 : : // Special Notes :
378 : : //
379 : : // Creator : Jason Kraftcheck
380 : : //
381 : : // Creation Date : 05/10/04
382 : : //-------------------------------------------------------------------------
383 : 0 : CubitPointContainment PartitionBody::point_containment( const CubitVector& pos,
384 : : double tolerance )
385 : : {
386 [ # # ]: 0 : DLIList<Lump*> lump_list;
387 [ # # ]: 0 : lumps( lump_list );
388 : :
389 [ # # ][ # # ]: 0 : DLIList<PartitionLump*> part_list;
390 [ # # ][ # # ]: 0 : CAST_LIST( lump_list, part_list, PartitionLump );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
391 : :
392 [ # # ][ # # ]: 0 : if (part_list.size() < lump_list.size())
[ # # ]
393 : : {
394 [ # # ][ # # ]: 0 : return real_body()->point_containment( pos, tolerance );
395 : : }
396 : :
397 : 0 : bool inside = false, on = false;
398 [ # # ]: 0 : part_list.reset();
399 [ # # ][ # # ]: 0 : for (int i = part_list.size(); i--; )
400 : : {
401 [ # # ][ # # ]: 0 : switch( part_list.get_and_step()->point_containment( pos ) )
[ # # # # ]
402 : : {
403 : : case CUBIT_PNT_INSIDE:
404 : 0 : inside = true;
405 : 0 : break;
406 : : case CUBIT_PNT_BOUNDARY:
407 : 0 : on = true;
408 : 0 : break;
409 : : case CUBIT_PNT_OUTSIDE:
410 : 0 : break;
411 : : default:
412 : 0 : return CUBIT_PNT_UNKNOWN;
413 : : }
414 : : }
415 : :
416 [ # # ]: 0 : if (inside)
417 : 0 : return CUBIT_PNT_INSIDE;
418 [ # # ]: 0 : else if(on)
419 : 0 : return CUBIT_PNT_BOUNDARY;
420 : : else
421 [ # # ]: 0 : return CUBIT_PNT_OUTSIDE;
422 : : }
423 : :
424 : : //-------------------------------------------------------------------------
425 : : // Purpose :
426 : : //
427 : : // Special Notes :
428 : : //
429 : : // Creator : Jason Kraftcheck
430 : : //
431 : : // Creation Date : 05/26/04
432 : : //-------------------------------------------------------------------------
433 : 0 : void PartitionBody::get_all_children( DLIList<PartitionEntity*>& list )
434 : : {
435 [ # # ]: 0 : DLIList<PartitionEntity*> tmp;
436 [ # # ]: 0 : for (SubEntitySet* ptr = childList; ptr; ptr = ptr->bodyNext )
437 : : {
438 [ # # ]: 0 : tmp.clean_out();
439 [ # # ]: 0 : ptr->get_sub_entities( tmp );
440 [ # # ]: 0 : list += tmp;
441 : :
442 [ # # ]: 0 : tmp.clean_out();
443 [ # # ]: 0 : ptr->get_lower_order( tmp );
444 [ # # ]: 0 : list += tmp;
445 [ # # ]: 0 : }
446 [ + - ][ + - ]: 6364 : }
|
