Branch data Line data Source code
1 : : //-------------------------------------------------------------------------
2 : : // Filename : CompositeBody.cpp
3 : : //
4 : : // Purpose : Composite of BodySMs
5 : : //
6 : : // Special Notes :
7 : : //
8 : : // Creator : Jason Kraftcheck
9 : : //
10 : : // Creation Date : 01/11/02
11 : : //-------------------------------------------------------------------------
12 : :
13 : : #include "DLIList.hpp"
14 : : #include "CompositeBody.hpp"
15 : : #include "CompositeLump.hpp"
16 : : #include "VirtualQueryEngine.hpp"
17 : : #include "CompositeEngine.hpp"
18 : :
19 : 0 : CompositeBody::CompositeBody()
20 [ # # ]: 0 : : firstLump(0)
21 : : {
22 : 0 : }
23 : :
24 [ # # ][ # # ]: 0 : CompositeBody::~CompositeBody()
25 : : {
26 : : int i;
27 : :
28 [ # # ][ # # ]: 0 : for( i = 0; i < realBodies.size(); i++ )
29 [ # # ][ # # ]: 0 : if( realBodies[i]->owner() == this )
[ # # ]
30 [ # # ][ # # ]: 0 : realBodies[i]->owner(0);
31 : :
32 [ # # ]: 0 : while( firstLump )
33 [ # # ]: 0 : remove( firstLump );
34 [ # # ]: 0 : }
35 : :
36 : :
37 : 0 : CompositeLump* CompositeBody::next_lump( CompositeLump* prev ) const
38 : : {
39 [ # # ]: 0 : return prev ? prev->nextLump : firstLump;
40 : : }
41 : :
42 : 0 : CubitStatus CompositeBody::add( CompositeLump* lump )
43 : : {
44 [ # # ]: 0 : if( lump->myBody != 0 )
45 : 0 : return CUBIT_FAILURE;
46 : :
47 : 0 : lump->myBody = this;
48 : 0 : lump->nextLump = firstLump;
49 : 0 : firstLump = lump;
50 : 0 : return CUBIT_SUCCESS;
51 : : }
52 : :
53 : 0 : CubitStatus CompositeBody::remove( CompositeLump* lump )
54 : : {
55 [ # # ]: 0 : if( lump->myBody != this )
56 : 0 : return CUBIT_FAILURE;
57 : :
58 [ # # ]: 0 : if( firstLump == lump )
59 : : {
60 : 0 : firstLump = lump->nextLump;
61 : : }
62 : : else
63 : : {
64 : 0 : CompositeLump* prev = firstLump;
65 [ # # ][ # # ]: 0 : while( prev && prev->nextLump != lump )
66 : 0 : prev = prev->nextLump;
67 [ # # ]: 0 : assert( prev != NULL );
68 : :
69 : 0 : prev->nextLump = lump->nextLump;
70 : : }
71 : :
72 : 0 : lump->myBody = 0;
73 : 0 : lump->nextLump = 0;
74 : 0 : return CUBIT_SUCCESS;
75 : : }
76 : :
77 : 0 : CubitStatus CompositeBody::add( BodySM* body )
78 : : {
79 [ # # ]: 0 : if( index_of( body ) >= 0 )
80 : 0 : return CUBIT_FAILURE;
81 : :
82 [ # # ]: 0 : if( body->owner() )
83 : 0 : body->owner()->swap_bridge( body, this, false );
84 : 0 : body->owner(this);
85 : :
86 : 0 : realBodies.push( body );
87 : 0 : return CUBIT_SUCCESS;
88 : : }
89 : :
90 : 0 : CubitStatus CompositeBody::remove( BodySM* body )
91 : 0 : { return remove_body( index_of( body ) ); }
92 : :
93 : 0 : CubitStatus CompositeBody::remove_body( int index )
94 : : {
95 [ # # ]: 0 : if( index < 0 ) return CUBIT_FAILURE;
96 : :
97 [ # # ]: 0 : if( realBodies[index]->owner() == this )
98 : 0 : realBodies[index]->owner(0);
99 : 0 : realBodies.remove(index);
100 : 0 : return CUBIT_SUCCESS;
101 : : }
102 : : /*
103 : : CubitStatus CompositeBody::move( const CubitVector& offset )
104 : : {
105 : : int i;
106 : : for (i = 0; i < realBodies.size(); i++)
107 : : if (CUBIT_SUCCESS != realBodies[i]->move( offset ))
108 : : break;
109 : :
110 : : if (i == realBodies.size())
111 : : return CUBIT_SUCCESS;
112 : :
113 : : for (int j = 0; j < i; j++)
114 : : realBodies[j]->move( -offset );
115 : : return CUBIT_FAILURE;
116 : : }
117 : :
118 : :
119 : : CubitStatus CompositeBody::rotate( const CubitVector& axis, double angle )
120 : : {
121 : : int i;
122 : : for (i = 0; i < realBodies.size(); i++)
123 : : if (CUBIT_SUCCESS != realBodies[i]->rotate( axis, angle ))
124 : : break;
125 : :
126 : : if (i == realBodies.size())
127 : : return CUBIT_SUCCESS;
128 : :
129 : : for (int j = 0; j < i; j++)
130 : : realBodies[j]->rotate( axis, -angle );
131 : : return CUBIT_FAILURE;
132 : : }
133 : :
134 : : CubitStatus CompositeBody::scale( double factor )
135 : : {
136 : : int i;
137 : : for (i = 0; i < realBodies.size(); i++)
138 : : if (CUBIT_SUCCESS != realBodies[i]->scale( factor ))
139 : : break;
140 : :
141 : : if (i == realBodies.size())
142 : : return CUBIT_SUCCESS;
143 : :
144 : : for (int j = 0; j < i; j++)
145 : : realBodies[j]->scale( 1.0/factor );
146 : : return CUBIT_FAILURE;
147 : : }
148 : :
149 : : CubitStatus CompositeBody::scale( const CubitVector& factors )
150 : : {
151 : : int i;
152 : : for (i = 0; i < realBodies.size(); i++)
153 : : if (CUBIT_SUCCESS != realBodies[i]->scale( factors ))
154 : : break;
155 : :
156 : : if (i == realBodies.size())
157 : : return CUBIT_SUCCESS;
158 : :
159 : : const CubitVector unscale( 1.0/factors.x(), 1.0/factors.y(), 1.0/factors.z() );
160 : : for (int j = 0; j < i; j++)
161 : : realBodies[j]->scale( unscale );
162 : : return CUBIT_FAILURE;
163 : : }
164 : :
165 : :
166 : : CubitStatus CompositeBody::reflect( const CubitVector& axis )
167 : : {
168 : : int i;
169 : : for (i = 0; i < realBodies.size(); i++)
170 : : if (CUBIT_SUCCESS != realBodies[i]->reflect( axis ))
171 : : break;
172 : :
173 : : if (i == realBodies.size())
174 : : return CUBIT_SUCCESS;
175 : :
176 : : for (int j = 0; j < i; j++)
177 : : realBodies[j]->reflect( axis );
178 : : return CUBIT_FAILURE;
179 : : }
180 : :
181 : :
182 : : CubitStatus CompositeBody::restore()
183 : : { return CUBIT_FAILURE; }
184 : :
185 : : CubitStatus CompositeBody::reverse()
186 : : { return CUBIT_FAILURE; }
187 : : */
188 : 0 : CubitStatus CompositeBody::get_transforms( CubitTransformMatrix& )
189 : 0 : { return CUBIT_FAILURE; }
190 : :
191 : 0 : void CompositeBody::get_parents_virt( DLIList<TopologyBridge*>& )
192 : 0 : { }
193 : :
194 : 0 : void CompositeBody::get_children_virt( DLIList<TopologyBridge*>& children )
195 : : {
196 [ # # ]: 0 : for( CompositeLump* lump = firstLump; lump; lump = lump->nextLump )
197 [ # # ]: 0 : children.append( lump );
198 : 0 : }
199 : :
200 : :
201 : : //-------------------------------------------------------------------------
202 : : // Purpose : Get CompositeEngine
203 : : //
204 : : // Special Notes :
205 : : //
206 : : // Creator : Jason Kraftcheck
207 : : //
208 : : // Creation Date : 01/11/02
209 : : //-------------------------------------------------------------------------
210 : 0 : GeometryQueryEngine* CompositeBody::get_geometry_query_engine() const
211 : 0 : { return VirtualQueryEngine::instance(); }
212 : :
213 : :
214 : 0 : CubitStatus CompositeBody::remove_bridge( TopologyBridge* bridge )
215 : : {
216 : : int i;
217 [ # # ][ # # ]: 0 : for (i = realBodies.size() - 1; i >= 0 && realBodies[i] != bridge; --i);
[ # # ]
218 [ # # ]: 0 : if (i < 0)
219 : 0 : return CUBIT_FAILURE;
220 : :
221 [ # # ]: 0 : assert( bridge->owner() == this );
222 : 0 : bridge->owner( 0 );
223 : 0 : realBodies.remove( i );
224 : :
225 [ # # ]: 0 : if (realBodies.size() == 0)
226 : 0 : CompositeEngine::instance().notify_deactivated( this );
227 : :
228 : 0 : return CUBIT_SUCCESS;
229 : : }
230 : :
231 : :
232 : 0 : CubitStatus CompositeBody::swap_bridge( TopologyBridge* old_tb,
233 : : TopologyBridge* new_tb,
234 : : bool )
235 : : {
236 [ # # ][ # # ]: 0 : if( new_tb->owner() )
237 : 0 : return CUBIT_FAILURE;
238 : :
239 [ # # ]: 0 : BodySM* new_body = dynamic_cast<BodySM*>(new_tb);
240 [ # # ]: 0 : BodySM* old_body = dynamic_cast<BodySM*>(old_tb);
241 [ # # ]: 0 : int index = realBodies.find( old_body );
242 [ # # ][ # # ]: 0 : if( index >= 0 && new_body != 0 && realBodies.find(new_body) < 0 )
[ # # ][ # # ]
[ # # ]
243 : : {
244 [ # # ][ # # ]: 0 : if( old_body->owner() == this )
245 [ # # ]: 0 : old_body->owner(0);
246 [ # # ]: 0 : new_body->owner(this);
247 [ # # ]: 0 : realBodies[index] = new_body;
248 : 0 : return CUBIT_SUCCESS;
249 : : }
250 : :
251 : 0 : return CUBIT_FAILURE;
252 : : }
253 : :
254 : 0 : CubitBoolean CompositeBody::contains_bridge( TopologyBridge* bridge ) const
255 : : {
256 [ # # ][ # # ]: 0 : return index_of(dynamic_cast<BodySM*>(bridge)) < 0 ? CUBIT_FALSE : CUBIT_TRUE;
257 : : }
258 : :
259 : 0 : void CompositeBody::notify_reversed( TopologyBridge* )
260 : 0 : { assert(0); }
261 : :
262 : : //-------------------------------------------------------------------------
263 : : // Purpose : Attribute functions
264 : : //
265 : : // Special Notes :
266 : : //
267 : : // Creator : Jason Kraftcheck
268 : : //
269 : : // Creation Date : 01/11/02
270 : : //-------------------------------------------------------------------------
271 : 0 : void CompositeBody::append_simple_attribute_virt( const CubitSimpleAttrib& )
272 : 0 : { }
273 : 0 : void CompositeBody::remove_simple_attribute_virt( const CubitSimpleAttrib& )
274 : 0 : { }
275 : 0 : void CompositeBody::remove_all_simple_attribute_virt()
276 : 0 : { }
277 : 0 : CubitStatus CompositeBody::get_simple_attribute( DLIList<CubitSimpleAttrib>& )
278 : 0 : { return CUBIT_FAILURE; }
279 : 0 : CubitStatus CompositeBody::get_simple_attribute(
280 : : const CubitString& , DLIList<CubitSimpleAttrib>& )
281 : 0 : { return CUBIT_FAILURE; }
282 : :
283 : : //-------------------------------------------------------------------------
284 : : // Purpose :
285 : : //
286 : : // Special Notes :
287 : : //
288 : : // Creator : Jason Kraftcheck
289 : : //
290 : : // Creation Date : 05/10/04
291 : : //-------------------------------------------------------------------------
292 : 0 : CubitPointContainment CompositeBody::point_containment( const CubitVector& pos, double tolerance )
293 : : {
294 : 0 : int inside = 0;
295 : 0 : int boundary = 0;
296 : :
297 [ # # ]: 0 : for (int i = 0; i < realBodies.size(); ++i)
298 : : {
299 [ # # # # ]: 0 : switch( realBodies[i]->point_containment( pos, tolerance ) )
300 : : {
301 : : case CUBIT_PNT_BOUNDARY:
302 : 0 : boundary++;
303 : 0 : break;
304 : : case CUBIT_PNT_INSIDE:
305 : 0 : inside++;
306 : 0 : break;
307 : : case CUBIT_PNT_OUTSIDE:
308 : 0 : break;
309 : : default:
310 : 0 : return CUBIT_PNT_UNKNOWN;
311 : : }
312 : : }
313 : :
314 [ # # ]: 0 : if (inside)
315 : 0 : return CUBIT_PNT_INSIDE;
316 [ # # ]: 0 : else if (boundary > 1)
317 : 0 : return CUBIT_PNT_INSIDE;
318 [ # # ]: 0 : else if (boundary)
319 : 0 : return CUBIT_PNT_BOUNDARY;
320 : : else
321 : 0 : return CUBIT_PNT_OUTSIDE;
322 : : }
323 : :
324 : : //-------------------------------------------------------------------------
325 : : // Purpose :
326 : : //
327 : : // Special Notes :
328 : : //
329 : : // Creator : Jason Kraftcheck
330 : : //
331 : : // Creation Date : 05/10/04
332 : : //-------------------------------------------------------------------------
333 : 0 : CubitStatus CompositeBody::mass_properties( CubitVector& result,
334 : : double& volume )
335 : : {
336 : : double vol;
337 [ # # ]: 0 : CubitVector centroid;
338 [ # # ]: 0 : result.set( 0.0, 0.0, 0.0 );
339 : 0 : volume = 0;
340 : :
341 [ # # ][ # # ]: 0 : for (int i = 0; i < realBodies.size(); ++i)
342 : : {
343 [ # # ][ # # ]: 0 : if (CUBIT_FAILURE == realBodies[i]->mass_properties( centroid, vol ))
[ # # ]
344 : 0 : return CUBIT_FAILURE;
345 : :
346 [ # # ][ # # ]: 0 : result += vol * centroid;
347 : 0 : volume += vol;
348 : : }
349 : :
350 [ # # ]: 0 : if (volume > CUBIT_RESABS)
351 [ # # ]: 0 : result /= volume;
352 : 0 : return CUBIT_SUCCESS;
353 : : }
354 : :
355 : : //-------------------------------------------------------------------------
356 : : // Purpose : Combine
357 : : //
358 : : // Special Notes :
359 : : //
360 : : // Creator : Jason Kraftcheck
361 : : //
362 : : // Creation Date : 06/11/04
363 : : //-------------------------------------------------------------------------
364 : 0 : void CompositeBody::combine( CompositeBody* other )
365 : : {
366 : 0 : int oldsize = realBodies.size();
367 : 0 : realBodies.size( oldsize + other->realBodies.size() );
368 [ # # ]: 0 : for (int i = 0; i < other->realBodies.size(); i++)
369 : : {
370 : 0 : BodySM* bod = other->realBodies[i];
371 : 0 : realBodies[i+oldsize] = bod;
372 : 0 : bod->owner(this);
373 : : }
374 : 0 : other->realBodies.size(0);
375 : 0 : }
376 : :
|
