Branch data Line data Source code
1 : : #include "SequenceManager.hpp"
2 : : #include "VertexSequence.hpp"
3 : : #include "UnstructuredElemSeq.hpp"
4 : : #include "ScdVertexData.hpp"
5 : : #include "MeshSetSequence.hpp"
6 : : #include "SweptElementSeq.hpp"
7 : : #include "StructuredElementSeq.hpp"
8 : : #include "moab/HomXform.hpp"
9 : : #include "PolyElementSeq.hpp"
10 : : #include "SysUtil.hpp"
11 : : #include "moab/Error.hpp"
12 : :
13 : : #include <assert.h>
14 : : #include <new>
15 : : #include <algorithm>
16 : :
17 : : #ifndef NDEBUG
18 : : #include <iostream>
19 : : #endif
20 : :
21 : : namespace moab
22 : : {
23 : :
24 : : const EntityID SequenceManager::DEFAULT_VERTEX_SEQUENCE_SIZE = 512 * 1024;
25 : : const EntityID SequenceManager::DEFAULT_ELEMENT_SEQUENCE_SIZE = DEFAULT_VERTEX_SEQUENCE_SIZE;
26 : : const EntityID SequenceManager::DEFAULT_POLY_SEQUENCE_SIZE = 16 * 1024;
27 : : const EntityID SequenceManager::DEFAULT_MESHSET_SEQUENCE_SIZE = DEFAULT_VERTEX_SEQUENCE_SIZE;
28 : :
29 : : const int UNUSED_SIZE = 0;
30 : :
31 : 28 : EntityID SequenceManager::default_poly_sequence_size( int conn_len )
32 : : {
33 [ + - ]: 28 : return std::max( DEFAULT_POLY_SEQUENCE_SIZE / conn_len, (EntityID)1 );
34 : : }
35 : :
36 : 5180 : SequenceManager::~SequenceManager()
37 : : {
38 : : // Release variable-length tag data
39 [ + + ]: 1000 : for( unsigned i = 0; i < tagSizes.size(); ++i )
40 [ - + ]: 630 : if( tagSizes[i] == MB_VARIABLE_LENGTH ) release_tag_array( 0, i, false );
41 [ + - ][ + + ]: 4810 : }
42 : :
43 : 66 : void SequenceManager::clear()
44 : : {
45 : : // reset sequence multiplier
46 : 66 : sequence_multiplier = 1.0;
47 : :
48 : : // Destroy all TypeSequenceManager instances
49 [ + - ][ + + ]: 858 : for( EntityType t = MBVERTEX; t < MBMAXTYPE; ++t )
50 : 792 : typeData[t].~TypeSequenceManager();
51 : :
52 : : // Now re-create TypeSequenceManager instances
53 [ + - ][ + + ]: 858 : for( EntityType t = MBVERTEX; t < MBMAXTYPE; ++t )
54 [ + - ][ + - ]: 792 : new( typeData + t ) TypeSequenceManager();
55 : 66 : }
56 : :
57 : 490 : void SequenceManager::get_entities( Range& entities_out ) const
58 : : {
59 [ + - ][ + + ]: 6370 : for( EntityType t = MBENTITYSET; t >= MBVERTEX; --t )
60 [ + - ]: 5880 : typeData[t].get_entities( entities_out );
61 : 490 : }
62 : :
63 : 1 : void SequenceManager::get_entities( std::vector< EntityHandle >& entities_out ) const
64 : : {
65 [ + - ][ + + ]: 13 : for( EntityType t = MBVERTEX; t != MBMAXTYPE; ++t )
66 [ + - ]: 12 : typeData[t].get_entities( entities_out );
67 : 1 : }
68 : :
69 : 1 : EntityID SequenceManager::get_number_entities() const
70 : : {
71 : 1 : EntityID sum = 0;
72 [ + - ][ + + ]: 13 : for( EntityType t = MBVERTEX; t != MBMAXTYPE; ++t )
73 [ + - ]: 12 : sum += typeData[t].get_number_entities();
74 : :
75 : 1 : return sum;
76 : : }
77 : :
78 : 300 : ErrorCode SequenceManager::check_valid_entities( Error* /* error */, const Range& entities ) const
79 : : {
80 : : ErrorCode rval;
81 [ + - ]: 300 : Range::const_pair_iterator i;
82 [ + - ][ + - ]: 13187 : for( i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
[ + - ][ + - ]
[ + + ]
83 : : {
84 [ + - ][ + - ]: 12893 : const EntityType type1 = TYPE_FROM_HANDLE( i->first );
85 [ + - ][ + - ]: 12893 : const EntityType type2 = TYPE_FROM_HANDLE( i->second );
86 [ + - ]: 12893 : if( type1 == type2 )
87 : : {
88 [ + - ][ + - ]: 12893 : rval = typeData[type1].check_valid_handles( NULL, i->first, i->second );
[ + - ]
89 [ + + ]: 12893 : if( MB_SUCCESS != rval ) return rval;
90 : : }
91 : : else
92 : : {
93 : : int junk;
94 [ # # ]: 0 : EntityHandle split = CREATE_HANDLE( type2, 0, junk );
95 [ # # ][ # # ]: 0 : rval = typeData[type1].check_valid_handles( NULL, i->first, split - 1 );
96 [ # # ]: 0 : if( MB_SUCCESS != rval ) return rval;
97 [ # # ][ # # ]: 0 : rval = typeData[type2].check_valid_handles( NULL, split, i->second );
98 [ # # ]: 0 : if( MB_SUCCESS != rval ) return rval;
99 : : }
100 : : }
101 : :
102 : 300 : return MB_SUCCESS;
103 : : }
104 : :
105 : 4278583 : ErrorCode SequenceManager::check_valid_entities( Error* /* error_handler */, const EntityHandle* entities,
106 : : size_t num_entities, bool root_set_okay ) const
107 : : {
108 : : ErrorCode rval;
109 : 4278583 : const EntitySequence* ptr = 0;
110 : :
111 : 4278583 : const EntityHandle* const end = entities + num_entities;
112 [ + + ]: 8557376 : for( ; entities < end; ++entities )
113 : : {
114 [ + - ]: 4278809 : rval = find( *entities, ptr );
115 [ + + ][ + + ]: 4278809 : if( MB_SUCCESS != rval && !( root_set_okay && !*entities ) )
[ + + ]
116 : : {
117 : : if( MB_ENTITY_NOT_FOUND == rval )
118 : : {
119 : : // MB_ENTITY_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
120 : : #if 0
121 : : fprintf(stderr, "[Warning]: Invalid entity handle: 0x%lx\n", (unsigned long)*entities);
122 : : #endif
123 : : }
124 : 16 : return rval;
125 : : }
126 : : }
127 : :
128 : 4278583 : return MB_SUCCESS;
129 : : }
130 : :
131 : 30113 : ErrorCode SequenceManager::delete_entity( Error* /* error */, EntityHandle entity )
132 : : {
133 : 30113 : return typeData[TYPE_FROM_HANDLE( entity )].erase( NULL, entity );
134 : : }
135 : :
136 : 56 : ErrorCode SequenceManager::delete_entities( Error* /* error */, const Range& entities )
137 : : {
138 [ + - ]: 56 : ErrorCode rval = check_valid_entities( NULL, entities );
139 [ - + ]: 56 : if( MB_SUCCESS != rval ) return rval;
140 : :
141 : 56 : ErrorCode result = MB_SUCCESS;
142 [ + - ]: 56 : Range::const_pair_iterator i;
143 [ + - ][ + - ]: 12329 : for( i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
[ + - ][ + - ]
[ + + ]
144 : : {
145 [ + - ][ + - ]: 12273 : const EntityType type1 = TYPE_FROM_HANDLE( i->first );
146 [ + - ][ + - ]: 12273 : const EntityType type2 = TYPE_FROM_HANDLE( i->second );
147 [ + - ]: 12273 : if( type1 == type2 )
148 : : {
149 [ + - ][ + - ]: 12273 : rval = typeData[type1].erase( NULL, i->first, i->second );
[ + - ]
150 [ - + ]: 12273 : if( MB_SUCCESS != rval ) return result = rval;
151 : : }
152 : : else
153 : : {
154 : : int junk;
155 [ # # ]: 0 : EntityHandle split = CREATE_HANDLE( type2, 0, junk );
156 [ # # ][ # # ]: 0 : rval = typeData[type1].erase( NULL, i->first, split - 1 );
157 [ # # ]: 0 : if( MB_SUCCESS != rval ) return result = rval;
158 [ # # ][ # # ]: 0 : rval = typeData[type2].erase( NULL, split, i->second );
159 [ # # ]: 0 : if( MB_SUCCESS != rval ) return result = rval;
160 : : }
161 : : }
162 : :
163 : 56 : return result;
164 : : }
165 : :
166 : 2114879 : ErrorCode SequenceManager::create_vertex( const double coords[3], EntityHandle& handle )
167 : : {
168 [ + - ]: 2114879 : const EntityHandle start = CREATE_HANDLE( MBVERTEX, MB_START_ID );
169 [ + - ]: 2114879 : const EntityHandle end = CREATE_HANDLE( MBVERTEX, MB_END_ID );
170 : : bool append;
171 [ + - ]: 2114879 : TypeSequenceManager::iterator seq = typeData[MBVERTEX].find_free_handle( start, end, append );
172 : : VertexSequence* vseq;
173 : :
174 [ + - ][ + - ]: 2114879 : if( seq == typeData[MBVERTEX].end() )
[ + + ]
175 : : {
176 : 217 : SequenceData* seq_data = 0;
177 : 217 : EntityID seq_data_size = 0;
178 : : handle =
179 [ + - ]: 217 : typeData[MBVERTEX].find_free_sequence( DEFAULT_VERTEX_SEQUENCE_SIZE, start, end, seq_data, seq_data_size );
180 [ - + ]: 217 : if( !handle ) return MB_FAILURE;
181 : :
182 [ - + ]: 217 : if( seq_data )
183 [ # # ][ # # ]: 0 : vseq = new VertexSequence( handle, 1, seq_data );
184 : : else
185 [ + - ][ + - ]: 217 : vseq = new VertexSequence( handle, 1, DEFAULT_VERTEX_SEQUENCE_SIZE );
186 : :
187 [ + - ]: 217 : ErrorCode rval = typeData[MBVERTEX].insert_sequence( vseq );
188 [ - + ]: 217 : if( MB_SUCCESS != rval )
189 : : {
190 [ # # ]: 0 : SequenceData* vdata = vseq->data();
191 [ # # ]: 0 : delete vseq;
192 [ # # ][ # # ]: 0 : if( !seq_data ) delete vdata;
193 : :
194 : 217 : return rval;
195 : : }
196 : : }
197 : : else
198 : : {
199 [ + - ]: 2114662 : vseq = reinterpret_cast< VertexSequence* >( *seq );
200 [ + - ]: 2114662 : if( append )
201 : : {
202 [ + - ]: 2114662 : vseq->push_back( 1 );
203 [ + - ]: 2114662 : handle = vseq->end_handle();
204 [ + - ]: 2114662 : typeData[MBVERTEX].notify_appended( seq );
205 : : }
206 : : else
207 : : {
208 [ # # ]: 0 : vseq->push_front( 1 );
209 [ # # ]: 0 : handle = vseq->start_handle();
210 [ # # ]: 0 : typeData[MBVERTEX].notify_prepended( seq );
211 : : }
212 : : }
213 : :
214 [ + - ]: 2114879 : return vseq->set_coordinates( handle, coords );
215 : : }
216 : :
217 : 417601 : ErrorCode SequenceManager::create_element( EntityType type, const EntityHandle* conn, unsigned conn_len,
218 : : EntityHandle& handle )
219 : : {
220 [ + - ][ - + ]: 417601 : if( type <= MBVERTEX || type >= MBENTITYSET ) return MB_TYPE_OUT_OF_RANGE;
221 : :
222 [ + - ]: 417601 : const EntityHandle start = CREATE_HANDLE( type, MB_START_ID );
223 [ + - ]: 417601 : const EntityHandle end = CREATE_HANDLE( type, MB_END_ID );
224 : : bool append;
225 [ + - ]: 417601 : TypeSequenceManager::iterator seq = typeData[type].find_free_handle( start, end, append, conn_len );
226 : : UnstructuredElemSeq* eseq;
227 : :
228 [ + - ][ + - ]: 417601 : if( seq == typeData[type].end() )
[ + + ]
229 : : {
230 : 390 : SequenceData* seq_data = 0;
231 : 390 : unsigned size = DEFAULT_ELEMENT_SEQUENCE_SIZE;
232 [ + + ][ + + ]: 390 : if( type == MBPOLYGON || type == MBPOLYHEDRON ) { size = default_poly_sequence_size( conn_len ); }
[ + - ]
233 : 390 : EntityID seq_data_size = 0;
234 [ + - ]: 390 : handle = typeData[type].find_free_sequence( size, start, end, seq_data, seq_data_size, conn_len );
235 [ - + ]: 390 : if( !handle ) return MB_FAILURE;
236 : :
237 [ + + ][ + + ]: 390 : if( MBPOLYGON == type || MBPOLYHEDRON == type )
238 : : {
239 [ - + ]: 56 : if( seq_data )
240 [ # # ][ # # ]: 0 : eseq = new PolyElementSeq( handle, 1, conn_len, seq_data );
241 : : else
242 [ + - ][ + - ]: 28 : eseq = new PolyElementSeq( handle, 1, conn_len, size );
243 : : }
244 : : else
245 : : {
246 [ - + ]: 362 : if( seq_data )
247 [ # # ][ # # ]: 0 : eseq = new UnstructuredElemSeq( handle, 1, conn_len, seq_data );
248 : : else
249 [ + - ][ + - ]: 362 : eseq = new UnstructuredElemSeq( handle, 1, conn_len, size );
250 : : }
251 : :
252 [ + - ]: 390 : ErrorCode rval = typeData[type].insert_sequence( eseq );
253 [ - + ]: 390 : if( MB_SUCCESS != rval )
254 : : {
255 [ # # ]: 0 : SequenceData* vdata = eseq->data();
256 [ # # ]: 0 : delete eseq;
257 [ # # ][ # # ]: 0 : if( !seq_data ) delete vdata;
258 : :
259 : 390 : return rval;
260 : : }
261 : : }
262 : : else
263 : : {
264 [ + - ]: 417211 : eseq = reinterpret_cast< UnstructuredElemSeq* >( *seq );
265 [ + + ]: 417211 : if( append )
266 : : {
267 [ + - ]: 417177 : eseq->push_back( 1 );
268 [ + - ]: 417177 : handle = eseq->end_handle();
269 [ + - ]: 417177 : typeData[type].notify_appended( seq );
270 : : }
271 : : else
272 : : {
273 [ + - ]: 34 : eseq->push_front( 1 );
274 [ + - ]: 34 : handle = eseq->start_handle();
275 [ + - ]: 34 : typeData[type].notify_prepended( seq );
276 : : }
277 : : }
278 : :
279 [ + - ]: 417601 : return eseq->set_connectivity( handle, conn, conn_len );
280 : : }
281 : :
282 : 31176 : ErrorCode SequenceManager::create_mesh_set( unsigned flags, EntityHandle& handle )
283 : : {
284 [ + - ]: 31176 : const EntityHandle start = CREATE_HANDLE( MBENTITYSET, MB_START_ID );
285 [ + - ]: 31176 : const EntityHandle end = CREATE_HANDLE( MBENTITYSET, MB_END_ID );
286 : : bool append;
287 [ + - ]: 31176 : TypeSequenceManager::iterator seq = typeData[MBENTITYSET].find_free_handle( start, end, append );
288 : : MeshSetSequence* msseq;
289 : :
290 [ + - ][ + - ]: 31176 : if( seq == typeData[MBENTITYSET].end() )
[ + + ]
291 : : {
292 : 286 : SequenceData* seq_data = 0;
293 : 286 : EntityID seq_data_size = 0;
294 : : handle = typeData[MBENTITYSET].find_free_sequence( DEFAULT_MESHSET_SEQUENCE_SIZE, start, end, seq_data,
295 [ + - ]: 286 : seq_data_size );
296 [ - + ]: 286 : if( !handle ) return MB_FAILURE;
297 : :
298 [ - + ]: 286 : if( seq_data )
299 [ # # ][ # # ]: 0 : msseq = new MeshSetSequence( handle, 1, flags, seq_data );
300 : : else
301 [ + - ][ + - ]: 286 : msseq = new MeshSetSequence( handle, 1, flags, DEFAULT_MESHSET_SEQUENCE_SIZE );
302 : :
303 [ + - ]: 286 : ErrorCode rval = typeData[MBENTITYSET].insert_sequence( msseq );
304 [ - + ]: 286 : if( MB_SUCCESS != rval )
305 : : {
306 [ # # ]: 0 : SequenceData* vdata = msseq->data();
307 [ # # ]: 0 : delete msseq;
308 [ # # ][ # # ]: 0 : if( !seq_data ) delete vdata;
309 : :
310 : 286 : return rval;
311 : : }
312 : : }
313 : : else
314 : : {
315 [ + - ]: 30890 : msseq = reinterpret_cast< MeshSetSequence* >( *seq );
316 [ + - ]: 30890 : if( append )
317 : : {
318 [ + - ]: 30890 : msseq->push_back( 1, &flags );
319 [ + - ]: 30890 : handle = msseq->end_handle();
320 [ + - ]: 30890 : typeData[MBENTITYSET].notify_appended( seq );
321 : : }
322 : : else
323 : : {
324 [ # # ]: 0 : msseq->push_front( 1, &flags );
325 [ # # ]: 0 : handle = msseq->start_handle();
326 [ # # ]: 0 : typeData[MBENTITYSET].notify_prepended( seq );
327 : : }
328 : : }
329 : :
330 : 31176 : return MB_SUCCESS;
331 : : }
332 : :
333 : 0 : ErrorCode SequenceManager::allocate_mesh_set( EntityHandle handle, unsigned flags )
334 : : {
335 : 0 : SequenceData* data = 0;
336 [ # # ]: 0 : TypeSequenceManager::iterator seqptr;
337 : 0 : EntityHandle block_start = 1, block_end = 0;
338 [ # # ]: 0 : ErrorCode rval = typeData[MBENTITYSET].is_free_handle( handle, seqptr, data, block_start, block_end );
339 [ # # ]: 0 : if( MB_SUCCESS != rval ) return rval;
340 : :
341 : : MeshSetSequence* seq;
342 [ # # ][ # # ]: 0 : if( seqptr != typeData[MBENTITYSET].end() )
[ # # ]
343 : : {
344 [ # # ]: 0 : seq = static_cast< MeshSetSequence* >( *seqptr );
345 [ # # ][ # # ]: 0 : if( seq->start_handle() - 1 == handle )
346 : : {
347 [ # # ]: 0 : rval = seq->push_front( 1, &flags );
348 [ # # ]: 0 : if( MB_SUCCESS == rval )
349 : : {
350 [ # # ]: 0 : rval = typeData[MBENTITYSET].notify_prepended( seqptr );
351 [ # # ][ # # ]: 0 : if( MB_SUCCESS != rval ) seq->pop_front( 1 );
352 : : }
353 : 0 : return rval;
354 : : }
355 [ # # ][ # # ]: 0 : else if( seq->end_handle() + 1 == handle )
356 : : {
357 [ # # ]: 0 : rval = seq->push_back( 1, &flags );
358 [ # # ]: 0 : if( MB_SUCCESS == rval )
359 : : {
360 [ # # ]: 0 : rval = typeData[MBENTITYSET].notify_appended( seqptr );
361 [ # # ][ # # ]: 0 : if( MB_SUCCESS != rval ) seq->pop_back( 1 );
362 : : }
363 : 0 : return rval;
364 : : }
365 : : else
366 : 0 : return MB_FAILURE; // Should be unreachable
367 : : }
368 : : else
369 : : {
370 [ # # ][ # # ]: 0 : if( data ) { seq = new MeshSetSequence( handle, 1, flags, data ); }
[ # # ]
371 : : else
372 : : {
373 [ # # ][ # # ]: 0 : assert( handle >= block_start && handle <= block_end );
374 [ # # ]: 0 : trim_sequence_block( handle, block_end, DEFAULT_MESHSET_SEQUENCE_SIZE );
375 [ # # ][ # # ]: 0 : seq = new MeshSetSequence( handle, 1, flags, block_end - handle + 1 );
376 : : }
377 : :
378 [ # # ]: 0 : rval = typeData[MBENTITYSET].insert_sequence( seq );
379 [ # # ]: 0 : if( MB_SUCCESS != rval )
380 : : {
381 [ # # ]: 0 : SequenceData* vdata = seq->data();
382 [ # # ]: 0 : delete seq;
383 [ # # ][ # # ]: 0 : if( !data ) delete vdata;
384 : 0 : return rval;
385 : : }
386 : :
387 : 0 : return MB_SUCCESS;
388 : : }
389 : : }
390 : :
391 : 0 : void SequenceManager::trim_sequence_block( EntityHandle start_handle, EntityHandle& end_handle, unsigned max_size )
392 : : {
393 [ # # ]: 0 : assert( end_handle >= start_handle );
394 [ # # ]: 0 : assert( (int)max_size > 0 ); // Cast to int also prohibits some ridiculously large values
395 : :
396 : : // If input range is larger than preferred size, trim it
397 [ # # ]: 0 : if( end_handle - start_handle >= max_size ) end_handle = start_handle + max_size - 1;
398 : 0 : }
399 : :
400 : 677 : EntityHandle SequenceManager::sequence_start_handle( EntityType type, EntityID count, int size, EntityID start,
401 : : SequenceData*& data, EntityID& data_size )
402 : : {
403 : 677 : TypeSequenceManager& tsm = typeData[type];
404 : 677 : data = 0;
405 : 677 : EntityHandle handle = CREATE_HANDLE( type, start );
406 [ + + ][ + + ]: 677 : if( start < MB_START_ID || !tsm.is_free_sequence( handle, count, data, size ) )
[ + + ]
407 : : {
408 : 416 : EntityHandle pstart = CREATE_HANDLE( type, MB_START_ID );
409 : 416 : EntityHandle pend = CREATE_HANDLE( type, MB_END_ID );
410 : 416 : handle = tsm.find_free_sequence( count, pstart, pend, data, data_size, size );
411 : : }
412 : :
413 : 677 : return handle;
414 : : }
415 : :
416 : 466 : EntityID SequenceManager::new_sequence_size( EntityHandle start, EntityID requested_size, int sequence_size ) const
417 : : {
418 : :
419 : 466 : requested_size = ( EntityID )( this->sequence_multiplier * requested_size );
420 : :
421 [ + - ]: 466 : if( sequence_size < (int)requested_size ) return requested_size;
422 : :
423 : 0 : EntityHandle last = typeData[TYPE_FROM_HANDLE( start )].last_free_handle( start );
424 [ # # ]: 0 : if( !last )
425 : : {
426 : 0 : assert( false );
427 : : return 0;
428 : : }
429 : :
430 : 0 : EntityID available_size = last - start + 1;
431 [ # # ]: 0 : if( sequence_size < available_size )
432 : 0 : return sequence_size;
433 : : else
434 : 0 : return available_size;
435 : : }
436 : :
437 : 551 : ErrorCode SequenceManager::create_entity_sequence( EntityType type, EntityID count, int size, EntityID start,
438 : : EntityHandle& handle, EntitySequence*& sequence, int sequence_size )
439 : : {
440 : 551 : SequenceData* data = NULL;
441 : 551 : EntityID data_size = 0;
442 [ + - ]: 551 : handle = sequence_start_handle( type, count, size, start, data, data_size );
443 : :
444 [ - + ]: 551 : if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
445 : :
446 [ - + - + ]: 551 : switch( type )
447 : : {
448 : : case MBENTITYSET:
449 : : case MBMAXTYPE:
450 : 0 : return MB_TYPE_OUT_OF_RANGE;
451 : :
452 : : case MBVERTEX:
453 [ - + ]: 233 : if( size != 0 ) return MB_INDEX_OUT_OF_RANGE;
454 : :
455 [ + + ]: 233 : if( data )
456 [ + - ][ + - ]: 42 : sequence = new VertexSequence( handle, count, data );
457 : : else
458 : : {
459 [ + - ][ + - ]: 191 : if( !data_size ) data_size = new_sequence_size( handle, count, sequence_size );
460 [ + - ][ + - ]: 191 : sequence = new VertexSequence( handle, count, data_size );
461 : : }
462 : 233 : break;
463 : :
464 : : case MBPOLYGON:
465 : : case MBPOLYHEDRON:
466 [ # # ]: 0 : if( size == 0 ) return MB_INDEX_OUT_OF_RANGE;
467 : :
468 [ # # ]: 0 : if( data )
469 [ # # ][ # # ]: 0 : sequence = new PolyElementSeq( handle, count, size, data );
470 : : else
471 : : {
472 [ # # ]: 0 : if( !data_size )
473 : : data_size = new_sequence_size(
474 [ # # ][ # # ]: 0 : handle, count, ( -1 == sequence_size ? default_poly_sequence_size( size ) : sequence_size ) );
[ # # ]
475 [ # # ][ # # ]: 0 : sequence = new PolyElementSeq( handle, count, size, data_size );
476 : : }
477 : 0 : break;
478 : :
479 : : default:
480 [ - + ]: 318 : if( size == 0 ) return MB_INDEX_OUT_OF_RANGE;
481 : :
482 [ + + ]: 318 : if( data )
483 [ + - ][ + - ]: 43 : sequence = new UnstructuredElemSeq( handle, count, size, data );
484 : : else
485 : : {
486 [ + - ][ + - ]: 275 : if( !data_size ) data_size = new_sequence_size( handle, count, sequence_size );
487 [ + - ][ + - ]: 275 : sequence = new UnstructuredElemSeq( handle, count, size, data_size );
488 : : }
489 : : // tjt calling new_sequence_size 'cuz don't have a sequence data;
490 : : // start 41467, count 246
491 : 318 : break;
492 : : }
493 : :
494 [ + - ]: 551 : ErrorCode result = typeData[type].insert_sequence( sequence );
495 [ - + ]: 551 : if( MB_SUCCESS != result )
496 : : {
497 : : // Change to NULL if had an existing data or if no existing data,
498 : : // change to the new data created
499 [ # # ][ # # ]: 0 : data = data ? 0 : sequence->data();
500 [ # # ]: 0 : delete sequence;
501 [ # # ]: 0 : delete data;
502 : 0 : return result;
503 : : }
504 : :
505 : 551 : return MB_SUCCESS;
506 : : }
507 : :
508 : 67 : ErrorCode SequenceManager::create_meshset_sequence( EntityID count, EntityID start, const unsigned* flags,
509 : : EntityHandle& handle, EntitySequence*& sequence )
510 : : {
511 : 67 : SequenceData* data = 0;
512 : 67 : EntityID data_size = 0;
513 [ + - ]: 67 : handle = sequence_start_handle( MBENTITYSET, count, 0, start, data, data_size );
514 : :
515 [ - + ]: 67 : if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
516 : :
517 [ + + ]: 67 : if( data )
518 [ + - ][ + - ]: 23 : sequence = new MeshSetSequence( handle, count, flags, data );
519 : : else
520 [ + - ][ + - ]: 44 : sequence = new MeshSetSequence( handle, count, flags, count );
521 : :
522 [ + - ]: 67 : ErrorCode result = typeData[MBENTITYSET].insert_sequence( sequence );
523 [ - + ]: 67 : if( MB_SUCCESS != result )
524 : : {
525 : : // Change to NULL if had an existing data or if no existing data,
526 : : // change to the new data created
527 [ # # ][ # # ]: 0 : data = data ? 0 : sequence->data();
528 [ # # ]: 0 : delete sequence;
529 [ # # ]: 0 : delete data;
530 : 0 : return result;
531 : : }
532 : :
533 : 67 : return MB_SUCCESS;
534 : : }
535 : :
536 : 0 : ErrorCode SequenceManager::create_meshset_sequence( EntityID count, EntityID start, unsigned flags,
537 : : EntityHandle& handle, EntitySequence*& sequence )
538 : : {
539 : 0 : SequenceData* data = 0;
540 : 0 : EntityID data_size = 0;
541 [ # # ]: 0 : handle = sequence_start_handle( MBENTITYSET, count, 0, start, data, data_size );
542 [ # # ]: 0 : if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
543 : :
544 [ # # ]: 0 : if( data )
545 [ # # ][ # # ]: 0 : sequence = new MeshSetSequence( handle, count, flags, data );
546 : : else
547 [ # # ][ # # ]: 0 : sequence = new MeshSetSequence( handle, count, flags, count );
548 : :
549 [ # # ]: 0 : ErrorCode result = typeData[MBENTITYSET].insert_sequence( sequence );
550 [ # # ]: 0 : if( MB_SUCCESS != result )
551 : : {
552 : : // Change to NULL if had an existing data or if no existing data,
553 : : // change to the new data created
554 [ # # ][ # # ]: 0 : data = data ? 0 : sequence->data();
555 [ # # ]: 0 : delete sequence;
556 [ # # ]: 0 : delete data;
557 : 0 : return result;
558 : : }
559 : :
560 : 0 : return MB_SUCCESS;
561 : : }
562 : :
563 : 59 : ErrorCode SequenceManager::create_scd_sequence( int imin, int jmin, int kmin, int imax, int jmax, int kmax,
564 : : EntityType type, EntityID start_id_hint, EntityHandle& handle,
565 : : EntitySequence*& sequence, int* is_periodic )
566 : : {
567 [ + - ]: 59 : int this_dim = CN::Dimension( type );
568 : :
569 : : // Use > instead of != in the following assert to also catch cases where imin > imax, etc.
570 [ + + ][ + - ]: 59 : assert( ( this_dim < 3 || kmax > kmin ) && ( this_dim < 2 || jmax > jmin ) && ( this_dim < 1 || imax > imin ) );
[ + + ][ + - ]
[ + + ][ - + ]
571 : :
572 : : // Compute # entities; not as easy as it would appear...
573 : : EntityID num_ent;
574 [ + + ]: 59 : if( MBVERTEX == type )
575 : 31 : num_ent = ( EntityID )( imax - imin + 1 ) * ( EntityID )( jmax - jmin + 1 ) * ( EntityID )( kmax - kmin + 1 );
576 : : else
577 : : {
578 [ + + ][ + + ]: 51 : num_ent = ( imax - imin + ( is_periodic && is_periodic[0] ? 1 : 0 ) ) *
[ + + ]
579 [ + + ][ + + ]: 51 : ( this_dim >= 2 ? ( jmax - jmin + ( is_periodic && is_periodic[1] ? 1 : 0 ) ) : 1 ) *
[ + + ]
580 : 28 : ( this_dim >= 3 ? ( kmax - kmin ) : 1 );
581 : : }
582 : :
583 [ + + ][ - + ]: 59 : if( MBVERTEX == type && ( is_periodic && ( is_periodic[0] || is_periodic[1] ) ) ) return MB_FAILURE;
[ # # ][ # # ]
584 : :
585 : : // Get a start handle
586 : 59 : SequenceData* data = 0;
587 : 59 : EntityID data_size = 0;
588 [ + - ]: 59 : handle = sequence_start_handle( type, num_ent, -1, start_id_hint, data, data_size );
589 : :
590 [ - + ]: 59 : if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
591 [ - + ]: 59 : assert( !data );
592 : :
593 [ + + - ]: 59 : switch( type )
594 : : {
595 : : case MBVERTEX:
596 [ + - ][ + - ]: 31 : data = new ScdVertexData( handle, imin, jmin, kmin, imax, jmax, kmax );
597 [ + - ][ + - ]: 31 : sequence = new VertexSequence( handle, data->size(), data );
[ + - ]
598 : 31 : break;
599 : : case MBEDGE:
600 : : case MBQUAD:
601 : : case MBHEX:
602 [ + - ][ + - ]: 28 : sequence = new StructuredElementSeq( handle, imin, jmin, kmin, imax, jmax, kmax, is_periodic );
603 : 28 : break;
604 : : default:
605 : 0 : return MB_TYPE_OUT_OF_RANGE;
606 : : }
607 : :
608 [ + - ]: 59 : ErrorCode result = typeData[type].insert_sequence( sequence );
609 [ - + ]: 59 : if( MB_SUCCESS != result )
610 : : {
611 [ # # ]: 0 : data = sequence->data();
612 [ # # ]: 0 : delete sequence;
613 [ # # ]: 0 : delete data;
614 : 0 : return result;
615 : : }
616 : :
617 : 59 : return MB_SUCCESS;
618 : : }
619 : :
620 : 59 : ErrorCode SequenceManager::create_scd_sequence( const HomCoord& coord_min, const HomCoord& coord_max, EntityType type,
621 : : EntityID start_id_hint, EntityHandle& first_handle_out,
622 : : EntitySequence*& sequence_out, int* is_periodic )
623 : : {
624 : : return create_scd_sequence( coord_min.i(), coord_min.j(), coord_min.k(), coord_max.i(), coord_max.j(),
625 : 59 : coord_max.k(), type, start_id_hint, first_handle_out, sequence_out, is_periodic );
626 : : }
627 : :
628 : 0 : ErrorCode SequenceManager::create_sweep_sequence( int imin, int jmin, int kmin, int imax, int jmax, int kmax, int* Cq,
629 : : EntityType type, EntityID start_id_hint, EntityHandle& handle,
630 : : EntitySequence*& sequence )
631 : : {
632 [ # # ]: 0 : int this_dim = CN::Dimension( type );
633 : :
634 [ # # ][ # # ]: 0 : assert( ( this_dim < 3 || kmax > kmin ) && ( this_dim < 2 || jmax > jmin ) && ( this_dim < 1 || imax > imin ) );
[ # # ][ # # ]
[ # # ][ # # ]
635 : :
636 : : EntityID num_ent;
637 [ # # ]: 0 : if( MBVERTEX == type )
638 : 0 : num_ent = ( EntityID )( imax - imin + 1 ) * ( EntityID )( jmax - jmin + 1 ) * ( EntityID )( kmax - kmin + 1 );
639 : : else
640 : : {
641 [ # # ][ # # ]: 0 : num_ent = ( imax - imin ) * ( this_dim >= 2 ? ( jmax - jmin ) : 1 ) * ( this_dim >= 3 ? ( kmax - kmin ) : 1 );
642 : : }
643 : :
644 : : // Get a start handle
645 : 0 : SequenceData* data = 0;
646 : 0 : EntityID data_size = 0;
647 [ # # ]: 0 : handle = sequence_start_handle( type, num_ent, -1, start_id_hint, data, data_size );
648 : :
649 [ # # ]: 0 : if( !handle ) return MB_MEMORY_ALLOCATION_FAILED;
650 [ # # ]: 0 : assert( !data );
651 : :
652 [ # # # ]: 0 : switch( type )
653 : : {
654 : : case MBVERTEX:
655 [ # # ][ # # ]: 0 : data = new ScdVertexData( handle, imin, jmin, kmin, imax, jmax, kmax );
656 [ # # ][ # # ]: 0 : sequence = new VertexSequence( handle, data->size(), data );
[ # # ]
657 : 0 : break;
658 : : case MBEDGE:
659 : : case MBQUAD:
660 : : case MBHEX:
661 [ # # ][ # # ]: 0 : sequence = new SweptElementSeq( handle, imin, jmin, kmin, imax, jmax, kmax, Cq );
662 : 0 : break;
663 : : default:
664 : 0 : return MB_TYPE_OUT_OF_RANGE;
665 : : }
666 : :
667 [ # # ]: 0 : ErrorCode result = typeData[type].insert_sequence( sequence );
668 [ # # ]: 0 : if( MB_SUCCESS != result )
669 : : {
670 [ # # ]: 0 : data = sequence->data();
671 [ # # ]: 0 : delete sequence;
672 [ # # ]: 0 : delete data;
673 : 0 : return result;
674 : : }
675 : :
676 : 0 : return MB_SUCCESS;
677 : : }
678 : :
679 : 0 : ErrorCode SequenceManager::create_sweep_sequence( const HomCoord& coord_min, const HomCoord& coord_max, int* Cq,
680 : : EntityType type, EntityID start_id_hint,
681 : : EntityHandle& first_handle_out, EntitySequence*& sequence_out )
682 : : {
683 : : return create_sweep_sequence( coord_min.i(), coord_min.j(), coord_min.k(), coord_max.i(), coord_max.j(),
684 : 0 : coord_max.k(), Cq, type, start_id_hint, first_handle_out, sequence_out );
685 : : }
686 : :
687 : 0 : ErrorCode SequenceManager::add_vsequence( EntitySequence* vert_seq, EntitySequence* elem_seq, const HomCoord& p1,
688 : : const HomCoord& q1, const HomCoord& p2, const HomCoord& q2,
689 : : const HomCoord& p3, const HomCoord& q3, bool bb_input, const HomCoord* bb_min,
690 : : const HomCoord* bb_max )
691 : : {
692 : : // Check first that they're structured vtx/elem sequences
693 [ # # ]: 0 : ScdVertexData* scd_vd = dynamic_cast< ScdVertexData* >( vert_seq->data() );
694 [ # # ]: 0 : if( !scd_vd ) return MB_FAILURE;
695 : :
696 [ # # ]: 0 : ScdElementData* scd_ed = dynamic_cast< ScdElementData* >( elem_seq->data() );
697 [ # # ]: 0 : if( !scd_ed ) return MB_FAILURE;
698 : :
699 [ # # ][ # # ]: 0 : if( bb_min && bb_max )
700 : 0 : return scd_ed->add_vsequence( scd_vd, p1, q1, p2, q2, p3, q3, bb_input, *bb_min, *bb_max );
701 : : else
702 : : return scd_ed->add_vsequence( scd_vd, p1, q1, p2, q2, p3, q3, bb_input, HomCoord::unitv[0],
703 : 0 : HomCoord::unitv[0] );
704 : : }
705 : :
706 : 13 : ErrorCode SequenceManager::replace_subsequence( EntitySequence* new_seq )
707 : : {
708 : 13 : const EntityType type = TYPE_FROM_HANDLE( new_seq->start_handle() );
709 : 13 : return typeData[type].replace_subsequence( new_seq, &tagSizes[0], tagSizes.size() );
710 : : }
711 : :
712 : 4 : void SequenceManager::get_memory_use( unsigned long long& total_entity_storage,
713 : : unsigned long long& total_storage ) const
714 : :
715 : : {
716 : 4 : total_entity_storage = 0;
717 : 4 : total_storage = 0;
718 : : unsigned long long temp_entity, temp_total;
719 [ + - ][ + + ]: 52 : for( EntityType i = MBVERTEX; i < MBMAXTYPE; ++i )
720 : : {
721 : 48 : temp_entity = temp_total = 0;
722 [ + - ]: 48 : get_memory_use( i, temp_entity, temp_total );
723 : 48 : total_entity_storage += temp_entity;
724 : 48 : total_storage += temp_total;
725 : : }
726 : 4 : }
727 : :
728 : 48 : void SequenceManager::get_memory_use( EntityType type, unsigned long long& total_entity_storage,
729 : : unsigned long long& total_storage ) const
730 : : {
731 : 48 : typeData[type].get_memory_use( total_entity_storage, total_storage );
732 : 48 : }
733 : :
734 : 4 : void SequenceManager::get_memory_use( const Range& entities, unsigned long long& total_entity_storage,
735 : : unsigned long long& total_amortized_storage ) const
736 : : {
737 : 4 : total_entity_storage = 0;
738 : 4 : total_amortized_storage = 0;
739 : : unsigned long long temp_entity, temp_total;
740 [ + - ]: 4 : Range::const_pair_iterator i;
741 [ + - ][ + - ]: 8 : for( i = entities.const_pair_begin(); i != entities.const_pair_end(); ++i )
[ + - ][ + - ]
[ + + ]
742 : : {
743 [ + - ][ + - ]: 4 : const EntityType t1 = TYPE_FROM_HANDLE( i->first );
744 [ + - ][ + - ]: 4 : const EntityType t2 = TYPE_FROM_HANDLE( i->second );
745 [ + - ]: 4 : if( t1 == t2 )
746 : : {
747 : 4 : temp_entity = temp_total = 0;
748 [ + - ][ + - ]: 4 : typeData[t1].get_memory_use( i->first, i->second, temp_entity, temp_total );
[ + - ]
749 : 4 : total_entity_storage += temp_entity;
750 : 4 : total_amortized_storage += temp_total;
751 : : }
752 : : else
753 : : {
754 : : int junk;
755 : :
756 : 0 : temp_entity = temp_total = 0;
757 [ # # ][ # # ]: 0 : typeData[t1].get_memory_use( i->first, CREATE_HANDLE( t1, MB_END_ID, junk ), temp_entity, temp_total );
[ # # ]
758 : 0 : total_entity_storage += temp_entity;
759 : 0 : total_amortized_storage += temp_total;
760 : :
761 : 0 : temp_entity = temp_total = 0;
762 [ # # ][ # # ]: 0 : typeData[t2].get_memory_use( CREATE_HANDLE( t2, MB_START_ID, junk ), i->second, temp_entity, temp_total );
[ # # ]
763 : 0 : total_entity_storage += temp_entity;
764 : 0 : total_amortized_storage += temp_total;
765 : : }
766 : : }
767 : 4 : }
768 : :
769 : 655 : ErrorCode SequenceManager::reserve_tag_array( Error* /* error_handler */, int size, int& index )
770 : : {
771 [ + + ][ - + ]: 655 : if( size < 1 && size != MB_VARIABLE_LENGTH ) { MB_SET_ERR( MB_INVALID_SIZE, "Invalid tag size: " << size ); }
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
772 : :
773 [ + - ]: 655 : std::vector< int >::iterator i = std::find( tagSizes.begin(), tagSizes.end(), UNUSED_SIZE );
774 [ + - ][ + + ]: 655 : if( i == tagSizes.end() )
775 : : {
776 : 637 : index = tagSizes.size();
777 [ + - ]: 637 : tagSizes.push_back( size );
778 : : }
779 : : else
780 : : {
781 [ + - ]: 18 : index = i - tagSizes.begin();
782 [ + - ]: 18 : *i = size;
783 : : }
784 : :
785 : 655 : return MB_SUCCESS;
786 : : }
787 : :
788 : 764 : ErrorCode SequenceManager::release_tag_array( Error* /* error_handler */, int index, bool release_id )
789 : : {
790 [ + - ][ - + ]: 764 : if( (unsigned)index >= tagSizes.size() || UNUSED_SIZE == tagSizes[index] )
[ - + ]
791 : : {
792 : : // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
793 : : #if 0
794 : : fprintf(stderr, "[Warning]: Invalid dense tag index: %d\n", index);
795 : : #endif
796 : 0 : return MB_TAG_NOT_FOUND;
797 : : }
798 : :
799 [ + - ][ + + ]: 9932 : for( EntityType t = MBVERTEX; t <= MBENTITYSET; ++t )
800 : : {
801 [ + - ]: 9168 : TypeSequenceManager& seqs = entity_map( t );
802 [ + - ][ + - ]: 20452 : for( TypeSequenceManager::iterator i = seqs.begin(); i != seqs.end(); ++i )
[ + - ][ + - ]
[ + + ]
803 [ + - ][ + - ]: 11284 : ( *i )->data()->release_tag_data( index, tagSizes[index] );
[ + - ][ + - ]
804 : : }
805 : :
806 [ + + ]: 764 : if( release_id ) tagSizes[index] = UNUSED_SIZE;
807 : :
808 : 764 : return MB_SUCCESS;
809 : : }
810 : :
811 : : // These are meant to be called from the debugger (not declared in any header)
812 : : // so leave them out of release builds (-DNDEBUG).
813 : : #ifndef NDEBUG
814 : :
815 : 0 : std::ostream& operator<<( std::ostream& s, const TypeSequenceManager& seq_man )
816 : : {
817 : 0 : const SequenceData* prev_data = 0;
818 [ # # ][ # # ]: 0 : for( TypeSequenceManager::const_iterator i = seq_man.begin(); i != seq_man.end(); ++i )
[ # # ][ # # ]
[ # # ]
819 : : {
820 [ # # ]: 0 : const EntitySequence* seq = *i;
821 [ # # ][ # # ]: 0 : if( seq->data() != prev_data )
822 : : {
823 [ # # ]: 0 : prev_data = seq->data();
824 [ # # ][ # # ]: 0 : s << "SequenceData [" << ID_FROM_HANDLE( seq->data()->start_handle() ) << ","
[ # # ][ # # ]
[ # # ][ # # ]
825 [ # # ][ # # ]: 0 : << ID_FROM_HANDLE( seq->data()->end_handle() ) << "]" << std::endl;
[ # # ][ # # ]
[ # # ][ # # ]
826 : : }
827 [ # # ][ # # ]: 0 : s << " Sequence [" << ID_FROM_HANDLE( seq->start_handle() ) << "," << ID_FROM_HANDLE( seq->end_handle() )
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
828 [ # # ][ # # ]: 0 : << "]" << std::endl;
829 : : }
830 : :
831 : 0 : return s;
832 : : }
833 : :
834 : 0 : std::ostream& operator<<( std::ostream& s, const SequenceManager& seq_man )
835 : : {
836 [ # # ][ # # ]: 0 : for( EntityType t = MBVERTEX; t < MBMAXTYPE; ++t )
837 : : {
838 [ # # ][ # # ]: 0 : if( !seq_man.entity_map( t ).empty() )
[ # # ]
839 [ # # ]: 0 : s << std::endl
840 [ # # ][ # # ]: 0 : << "****************** " << CN::EntityTypeName( t ) << " ******************" << std::endl
[ # # ][ # # ]
[ # # ]
841 [ # # ][ # # ]: 0 : << seq_man.entity_map( t ) << std::endl;
[ # # ]
842 : : }
843 : :
844 : 0 : return s;
845 : : }
846 : :
847 : 0 : void print_sequences( const SequenceManager& seqman )
848 : : {
849 : 0 : std::cout << seqman << std::endl;
850 : 0 : }
851 : :
852 : 0 : void print_sequences( const TypeSequenceManager& seqman )
853 : : {
854 : 0 : std::cout << seqman << std::endl;
855 : 0 : }
856 : :
857 : : #endif
858 : :
859 [ + - ][ + - ]: 228 : } // namespace moab
|
