 |
Mesh Oriented datABase
(version 5.5.1)
An array-based unstructured mesh library
|
|
Mesh Oriented datABase
(version 5.5.1)
An array-based unstructured mesh library
|
1 /**
2 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
3 * storing and accessing finite element mesh data.
4 *
5 * Copyright 2004 Sandia Corporation. Under the terms of Contract
6 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
7 * retains certain rights in this software.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 */
15
16 //-------------------------------------------------------------------------
17 // Filename : WriteHDF5.cpp
18 //
19 // Purpose : TSTT HDF5 Writer
20 //
21 // Special Notes : WriteSLAC used as template for this
22 //
23 // Creator : Jason Kraftcheck
24 //
25 // Creation Date : 04/01/04
26 //-------------------------------------------------------------------------
27
28 #include <cassert>
29 #if defined( _MSC_VER )
30 typedef int id_t;
31 #elif defined( __MINGW32__ )
32 #include <sys/time.h>
33 #else
34 #include <ctime>
35 #endif
36
37 #include <cstdlib>
38 #include <cstring>
39 #include <cstdarg>
40 #include <limits>
41 #include <cstdio>
42 #include <iostream>
43 #include "WriteHDF5.hpp"
44 #include <H5Tpublic.h>
45 #include <H5Ppublic.h>
46 #include <H5Epublic.h>
47 #include "moab/Interface.hpp"
48 #include "Internals.hpp"
49 #include "MBTagConventions.hpp"
50 #include "moab/CN.hpp"
51 #include "moab/FileOptions.hpp"
52 #include "moab/CpuTimer.hpp"
53 #include "IODebugTrack.hpp"
54 #include "mhdf.h"
55
56 #ifndef MOAB_HAVE_HDF5
57 #error Attempt to compile WriteHDF5 with HDF5 support disabled
58 #endif
59
60 #undef BLOCKED_COORD_IO
61
62 #ifdef MOAB_HAVE_VALGRIND
63 #include <valgrind/memcheck.h>
64
65 template < typename T >
66 inline void VALGRIND_MAKE_VEC_UNDEFINED( std::vector< T >& v )
67 {
68 (void)VALGRIND_MAKE_MEM_UNDEFINED( (T*)&v[0], v.size() * sizeof( T ) );
69 }
70
71 #else
72 #ifndef VALGRIND_CHECK_MEM_IS_DEFINED
73 #define VALGRIND_CHECK_MEM_IS_DEFINED( a, b ) ( (void)0 )
74 #endif
75 #ifndef VALGRIND_CHECK_MEM_IS_ADDRESSABLE
76 #define VALGRIND_CHECK_MEM_IS_ADDRESSABLE( a, b ) ( (void)0 )
77 #endif
78 #ifndef VALGRIND_MAKE_MEM_UNDEFINED
79 #define VALGRIND_MAKE_MEM_UNDEFINED( a, b ) ( (void)0 )
80 #endif
81
82 template < typename T >
83 inline void VALGRIND_MAKE_VEC_UNDEFINED( std::vector< T >& )
84 {
85 (void)VALGRIND_MAKE_MEM_UNDEFINED( 0, 0 );
86 }
87
88 #endif
89
90 namespace moab
91 {
92
93 #define WRITE_HDF5_BUFFER_SIZE ( 40 * 1024 * 1024 )
94
95 static hid_t get_id_type()
96 {
97 if( 8 == sizeof( WriteHDF5::wid_t ) )
98 {
99 if( 8 == sizeof( long ) )
100 return H5T_NATIVE_ULONG;
101 else
102 return H5T_NATIVE_UINT64;
103 }
104 else if( 4 == sizeof( WriteHDF5::wid_t ) )
105 {
106 if( 4 == sizeof( int ) )
107 return H5T_NATIVE_UINT;
108 else
109 return H5T_NATIVE_UINT32;
110 }
111 else
112 {
113 assert( 0 );
114 return (hid_t)-1;
115 }
116 }
117
118 // This is the HDF5 type used to store file IDs
119 const hid_t WriteHDF5::id_type = get_id_type();
120
121 // This function doesn't do anything useful. It's just a nice
122 // place to set a break point to determine why the writer fails.
123 static inline ErrorCode error( ErrorCode rval )
124 {
125 return rval;
126 }
127
128 // Call \c error function during HDF5 library errors to make
129 // it easier to trap such errors in the debugger. This function
130 // gets registered with the HDF5 library as a callback. It
131 // works the same as the default (H5Eprint), except that it
132 // also calls the \c error function as a no-op.
133 #if defined( H5E_auto_t_vers ) && H5E_auto_t_vers > 1
134 static herr_t handle_hdf5_error( hid_t stack, void* data )
135 {
136 WriteHDF5::HDF5ErrorHandler* h = reinterpret_cast< WriteHDF5::HDF5ErrorHandler* >( data );
137 herr_t result = 0;
138 if( h->func ) result = ( *h->func )( stack, h->data );
139 error( MB_FAILURE );
140 return result;
141 }
142 #else
143 static herr_t handle_hdf5_error( void* data )
144 {
145 WriteHDF5::HDF5ErrorHandler* h = reinterpret_cast< WriteHDF5::HDF5ErrorHandler* >( data );
146 herr_t result = 0;
147 if( h->func ) result = ( *h->func )( h->data );
148 error( MB_FAILURE );
149 return result;
150 }
151 #endif
152
153 // Some macros to handle error checking. The
154 // CHK_MHDF__ERR* macros check the value of an mhdf_Status
155 // object. The CHK_MB_ERR_* check the value of an ErrorCode.
156 // The *_0 macros accept no other arguments. The *_1
157 // macros accept a single hdf5 handle to close on error.
158 // The *_2 macros accept an array of two hdf5 handles to
159 // close on error. The _*2C macros accept one hdf5 handle
160 // to close on error and a bool and an hdf5 handle where
161 // the latter handle is conditionally closed depending on
162 // the value of the bool. All macros contain a "return"
163 // statement.
164 #define CHK_MHDF_ERR_0( A ) \
165 do \
166 { \
167 if( mhdf_isError( &( A ) ) ) \
168 { \
169 MB_SET_ERR_CONT( mhdf_message( &( A ) ) ); \
170 assert( 0 ); \
171 return error( MB_FAILURE ); \
172 } \
173 } while( false )
174
175 #define CHK_MHDF_ERR_1( A, B ) \
176 do \
177 { \
178 if( mhdf_isError( &( A ) ) ) \
179 { \
180 MB_SET_ERR_CONT( mhdf_message( &( A ) ) ); \
181 assert( 0 ); \
182 mhdf_closeData( filePtr, ( B ), &( A ) ); \
183 return error( MB_FAILURE ); \
184 } \
185 } while( false )
186
187 #define CHK_MHDF_ERR_2( A, B ) \
188 do \
189 { \
190 if( mhdf_isError( &( A ) ) ) \
191 { \
192 MB_SET_ERR_CONT( mhdf_message( &( A ) ) ); \
193 assert( 0 ); \
194 mhdf_closeData( filePtr, ( B )[0], &( A ) ); \
195 mhdf_closeData( filePtr, ( B )[1], &( A ) ); \
196 return error( MB_FAILURE ); \
197 } \
198 } while( false )
199
200 #define CHK_MHDF_ERR_3( A, B ) \
201 do \
202 { \
203 if( mhdf_isError( &( A ) ) ) \
204 { \
205 MB_SET_ERR_CONT( mhdf_message( &( A ) ) ); \
206 assert( 0 ); \
207 mhdf_closeData( filePtr, ( B )[0], &( A ) ); \
208 mhdf_closeData( filePtr, ( B )[1], &( A ) ); \
209 mhdf_closeData( filePtr, ( B )[2], &( A ) ); \
210 return error( MB_FAILURE ); \
211 } \
212 } while( false )
213
214 #define CHK_MHDF_ERR_2C( A, B, C, D ) \
215 do \
216 { \
217 if( mhdf_isError( &( A ) ) ) \
218 { \
219 MB_SET_ERR_CONT( mhdf_message( &( A ) ) ); \
220 assert( 0 ); \
221 mhdf_closeData( filePtr, ( B ), &( A ) ); \
222 if( C ) mhdf_closeData( filePtr, ( D ), &( A ) ); \
223 return error( MB_FAILURE ); \
224 } \
225 } while( false )
226
227 #define CHK_MB_ERR_0( A ) \
228 do \
229 { \
230 if( MB_SUCCESS != ( A ) ) \
231 { \
232 MB_CHK_ERR_CONT( ( A ) ); \
233 return error( A ); \
234 } \
235 } while( false )
236
237 #define CHK_MB_ERR_1( A, B, C ) \
238 do \
239 { \
240 if( MB_SUCCESS != ( A ) ) \
241 { \
242 MB_CHK_ERR_CONT( ( A ) ); \
243 mhdf_closeData( filePtr, ( B ), &( C ) ); \
244 assert( 0 ); \
245 return error( A ); \
246 } \
247 } while( false )
248
249 #define CHK_MB_ERR_2( A, B, C ) \
250 do \
251 { \
252 if( MB_SUCCESS != ( A ) ) \
253 { \
254 MB_CHK_ERR_CONT( ( A ) ); \
255 mhdf_closeData( filePtr, ( B )[0], &( C ) ); \
256 mhdf_closeData( filePtr, ( B )[1], &( C ) ); \
257 write_finished(); \
258 assert( 0 ); \
259 return error( A ); \
260 } \
261 } while( false )
262
263 #define CHK_MB_ERR_3( A, B, C ) \
264 do \
265 { \
266 if( MB_SUCCESS != ( A ) ) \
267 { \
268 MB_CHK_ERR_CONT( ( A ) ); \
269 mhdf_closeData( filePtr, ( B )[0], &( C ) ); \
270 mhdf_closeData( filePtr, ( B )[1], &( C ) ); \
271 mhdf_closeData( filePtr, ( B )[2], &( C ) ); \
272 write_finished(); \
273 assert( 0 ); \
274 return error( A ); \
275 } \
276 } while( false )
277
278 #define CHK_MB_ERR_2C( A, B, C, D, E ) \
279 do \
280 { \
281 if( MB_SUCCESS != ( A ) ) \
282 { \
283 MB_CHK_ERR_CONT( ( A ) ); \
284 mhdf_closeData( filePtr, ( B ), &( E ) ); \
285 if( C ) mhdf_closeData( filePtr, ( D ), &( E ) ); \
286 write_finished(); \
287 assert( 0 ); \
288 return error( A ); \
289 } \
290 } while( false )
291
292 #define debug_barrier() debug_barrier_line( __LINE__ )
293 void WriteHDF5::debug_barrier_line( int ) {}
294
295 class CheckOpenWriteHDF5Handles
296 {
297 int fileline;
298 mhdf_FileHandle handle;
299 int enter_count;
300
301 public:
302 CheckOpenWriteHDF5Handles( mhdf_FileHandle file, int line )
303 : fileline( line ), handle( file ), enter_count( mhdf_countOpenHandles( file ) )
304 {
305 }
306
307 ~CheckOpenWriteHDF5Handles()
308 {
309 int new_count = mhdf_countOpenHandles( handle );
310 if( new_count != enter_count )
311 {
312 std::cout << "Leaked HDF5 object handle in function at " << __FILE__ << ":" << fileline << std::endl
313 << "Open at entrance: " << enter_count << std::endl
314 << "Open at exit: " << new_count << std::endl;
315 }
316 }
317 };
318
319 MPEState WriteHDF5::topState;
320 MPEState WriteHDF5::subState;
321
322 #ifdef NDEBUG
323 #define CHECK_OPEN_HANDLES
324 #else
325 #define CHECK_OPEN_HANDLES CheckOpenWriteHDF5Handles check_open_handles_( filePtr, __LINE__ )
326 #endif
327
328 bool WriteHDF5::convert_handle_tag( const EntityHandle* source, EntityHandle* dest, size_t count ) const
329 {
330 bool some_valid = false;
331 for( size_t i = 0; i < count; ++i )
332 {
333 if( !source[i] )
334 dest[i] = 0;
335 else
336 {
337 dest[i] = idMap.find( source[i] );
338 if( dest[i] ) some_valid = true;
339 }
340 }
341
342 return some_valid;
343 }
344
345 bool WriteHDF5::convert_handle_tag( EntityHandle* data, size_t count ) const
346 {
347 assert( sizeof( EntityHandle ) == sizeof( wid_t ) );
348 return convert_handle_tag( data, data, count );
349 }
350
351 ErrorCode WriteHDF5::assign_ids( const Range& entities, wid_t id )
352 {
353 Range::const_pair_iterator pi;
354 for( pi = entities.const_pair_begin(); pi != entities.const_pair_end(); ++pi )
355 {
356 const EntityHandle n = pi->second - pi->first + 1;
357 dbgOut.printf( 3, "Assigning %s %lu to %lu to file IDs [%lu,%lu]\n",
358 CN::EntityTypeName( TYPE_FROM_HANDLE( pi->first ) ),
359 (unsigned long)( ID_FROM_HANDLE( pi->first ) ),
360 (unsigned long)( ID_FROM_HANDLE( pi->first ) + n - 1 ), (unsigned long)id,
361 (unsigned long)( id + n - 1 ) );
362 if( TYPE_FROM_HANDLE( pi->first ) == MBPOLYGON || TYPE_FROM_HANDLE( pi->first ) == MBPOLYHEDRON )
363 {
364 int num_vertices = 0;
365 const EntityHandle* conn = 0;
366 iFace->get_connectivity( pi->first, conn, num_vertices );
367 dbgOut.printf( 3, " poly with %d verts/faces \n", num_vertices );
368 }
369 if( !idMap.insert( pi->first, id, n ).second ) return error( MB_FAILURE );
370 id += n;
371 }
372
373 return MB_SUCCESS;
374 }
375
376 const char* WriteHDF5::ExportSet::name() const
377 {
378 static char buffer[128];
379 switch( type )
380 {
381 case MBVERTEX:
382 return mhdf_node_type_handle();
383 case MBENTITYSET:
384 return mhdf_set_type_handle();
385 default:
386 snprintf( buffer, 128, "%s%d", CN::EntityTypeName( type ), num_nodes );
387 return buffer;
388 }
389 }
390
391 WriterIface* WriteHDF5::factory( Interface* iface )
392 {
393 return new WriteHDF5( iface );
394 }
395
396 WriteHDF5::WriteHDF5( Interface* iface )
397 : bufferSize( WRITE_HDF5_BUFFER_SIZE ), dataBuffer( 0 ), iFace( iface ), writeUtil( 0 ), filePtr( 0 ),
398 setContentsOffset( 0 ), setChildrenOffset( 0 ), setParentsOffset( 0 ), maxNumSetContents( 0 ),
399 maxNumSetChildren( 0 ), maxNumSetParents( 0 ), writeSets( false ), writeSetContents( false ),
400 writeSetChildren( false ), writeSetParents( false ), parallelWrite( false ), collectiveIO( false ),
401 writeTagDense( false ), writeProp( H5P_DEFAULT ), dbgOut( "H5M", stderr ), debugTrack( false )
402 {
403 }
404
405 ErrorCode WriteHDF5::init()
406 {
407 ErrorCode rval;
408
409 if( writeUtil ) // init has already been called
410 return MB_SUCCESS;
411 /*
412 #ifdef DEBUG
413 H5Eset_auto(&hdf_error_handler, writeUtil); // HDF5 callback for errors
414 #endif
415 */
416 // For known tag types, store the corresponding HDF5 in which
417 // the tag data is to be written in the file.
418 // register_known_tag_types(iFace);
419
420 // Get the util interface
421 rval = iFace->query_interface( writeUtil );
422 CHK_MB_ERR_0( rval );
423
424 idMap.clear();
425
426 #if defined( H5Eget_auto_vers ) && H5Eget_auto_vers > 1
427 herr_t err = H5Eget_auto( H5E_DEFAULT, &errorHandler.func, &errorHandler.data );
428 #else
429 herr_t err = H5Eget_auto( &errorHandler.func, &errorHandler.data );
430 #endif
431 if( err < 0 )
432 {
433 errorHandler.func = 0;
434 errorHandler.data = 0;
435 }
436 else
437 {
438 #if defined( H5Eset_auto_vers ) && H5Eset_auto_vers > 1
439 err = H5Eset_auto( H5E_DEFAULT, &handle_hdf5_error, &errorHandler );
440 #else
441 err = H5Eset_auto( &handle_hdf5_error, &errorHandler );
442 #endif
443 if( err < 0 )
444 {
445 errorHandler.func = 0;
446 errorHandler.data = 0;
447 }
448 }
449
450 if( !topState.valid() ) topState = MPEState( "WriteHDF5", "yellow" );
451 if( !subState.valid() ) subState = MPEState( "WriteHDF5 subevent", "cyan" );
452
453 return MB_SUCCESS;
454 }
455
456 ErrorCode WriteHDF5::write_finished()
457 {
458 // Release memory allocated in lists
459 exportList.clear();
460 nodeSet.range.clear();
461 setSet.range.clear();
462 tagList.clear();
463 idMap.clear();
464
465 HDF5ErrorHandler handler;
466 #if defined( H5Eget_auto_vers ) && H5Eget_auto_vers > 1
467 herr_t err = H5Eget_auto( H5E_DEFAULT, &handler.func, &handler.data );
468 #else
469 herr_t err = H5Eget_auto( &handler.func, &handler.data );
470 #endif
471 if( err >= 0 && handler.func == &handle_hdf5_error )
472 {
473 assert( handler.data == &errorHandler );
474 #if defined( H5Eget_auto_vers ) && H5Eget_auto_vers > 1
475 H5Eset_auto( H5E_DEFAULT, errorHandler.func, errorHandler.data );
476 #else
477 H5Eset_auto( errorHandler.func, errorHandler.data );
478 #endif
479 }
480
481 return MB_SUCCESS;
482 }
483
484 WriteHDF5::~WriteHDF5()
485 {
486 if( !writeUtil ) // init() failed.
487 return;
488
489 iFace->release_interface( writeUtil );
490 }
491
492 ErrorCode WriteHDF5::write_file( const char* filename,
493 bool overwrite,
494 const FileOptions& opts,
495 const EntityHandle* set_array,
496 const int num_sets,
497 const std::vector< std::string >& qa_records,
498 const Tag* tag_list,
499 int num_tags,
500 int user_dimension )
501 {
502 mhdf_Status status;
503
504 parallelWrite = false;
505 collectiveIO = false;
506
507 // Enable debug output
508 int tmpval = 0;
509 if( MB_SUCCESS == opts.get_int_option( "DEBUG_IO", 1, tmpval ) ) dbgOut.set_verbosity( tmpval );
510
511 // writeTagDense = (MB_SUCCESS == opts.get_null_option("DENSE_TAGS"));
512 writeTagDense = true;
513
514 // Enable some extra checks for reads. Note: amongst other things this
515 // will print errors if the entire file is not read, so if doing a
516 // partial read that is not a parallel read, this should be disabled.
517 debugTrack = ( MB_SUCCESS == opts.get_null_option( "DEBUG_BINIO" ) );
518
519 bufferSize = WRITE_HDF5_BUFFER_SIZE;
520 int buf_size;
521 ErrorCode rval = opts.get_int_option( "BUFFER_SIZE", buf_size );
522 if( MB_SUCCESS == rval && buf_size >= 24 ) bufferSize = buf_size;
523
524 // Allocate internal buffer to use when gathering data to write.
525 dataBuffer = (char*)malloc( bufferSize );
526 if( !dataBuffer ) return error( MB_MEMORY_ALLOCATION_FAILED );
527
528 // Clear filePtr so we know if it is open upon failure
529 filePtr = 0;
530
531 // Do actual write.
532 writeProp = H5P_DEFAULT;
533 ErrorCode result = write_file_impl( filename, overwrite, opts, set_array, num_sets, qa_records, tag_list, num_tags,
534 user_dimension );
535 // Close writeProp if it was opened
536 if( writeProp != H5P_DEFAULT ) H5Pclose( writeProp );
537
538 // Free memory buffer
539 free( dataBuffer );
540 dataBuffer = 0;
541
542 // Close file
543 bool created_file = false;
544 if( filePtr )
545 {
546 created_file = true;
547 mhdf_closeFile( filePtr, &status );
548 filePtr = 0;
549 if( mhdf_isError( &status ) )
550 {
551 MB_SET_ERR_CONT( mhdf_message( &status ) );
552 if( MB_SUCCESS == result ) result = MB_FAILURE;
553 }
554 }
555
556 // Release other resources
557 if( MB_SUCCESS == result )
558 result = write_finished();
559 else
560 write_finished();
561
562 // If write failed, remove file unless KEEP option was specified
563 if( MB_SUCCESS != result && created_file && MB_ENTITY_NOT_FOUND == opts.get_null_option( "KEEP" ) )
564 remove( filename );
565
566 return result;
567 }
568
569 ErrorCode WriteHDF5::write_file_impl( const char* filename,
570 bool overwrite,
571 const FileOptions& opts,
572 const EntityHandle* set_array,
573 const int num_sets,
574 const std::vector< std::string >& qa_records,
575 const Tag* tag_list,
576 int num_tags,
577 int user_dimension )
578 {
579 ErrorCode result;
580 std::list< TagDesc >::const_iterator t_itor;
581 std::list< ExportSet >::iterator ex_itor;
582 EntityHandle elem_count, max_id;
583 double times[NUM_TIMES] = { 0 };
584
585 if( MB_SUCCESS != init() ) return error( MB_FAILURE );
586
587 // See if we need to report times
588 bool cputime = false;
589 result = opts.get_null_option( "CPUTIME" );
590 if( MB_SUCCESS == result ) cputime = true;
591
592 CpuTimer timer;
593
594 dbgOut.tprint( 1, "Gathering Mesh\n" );
595 topState.start( "gathering mesh" );
596
597 // Gather mesh to export
598 exportList.clear();
599 if( 0 == num_sets || ( 1 == num_sets && set_array[0] == 0 ) )
600 {
601 result = gather_all_mesh();
602 topState.end( result );
603 CHK_MB_ERR_0( result );
604 }
605 else
606 {
607 std::vector< EntityHandle > passed_export_list( set_array, set_array + num_sets );
608 result = gather_mesh_info( passed_export_list );
609 topState.end( result );
610 CHK_MB_ERR_0( result );
611 }
612
613 times[GATHER_TIME] = timer.time_elapsed();
614
615 // if (nodeSet.range.size() == 0)
616 // return error(MB_ENTITY_NOT_FOUND);
617
618 dbgOut.tprint( 1, "Checking ID space\n" );
619
620 // Make sure ID space is sufficient
621 elem_count = nodeSet.range.size() + setSet.range.size();
622 for( ex_itor = exportList.begin(); ex_itor != exportList.end(); ++ex_itor )
623 elem_count += ex_itor->range.size();
624 max_id = (EntityHandle)1 << ( 8 * sizeof( wid_t ) - 1 );
625 if( elem_count > max_id )
626 {
627 MB_SET_ERR_CONT( "ID space insufficient for mesh size" );
628 return error( result );
629 }
630
631 dbgOut.tprint( 1, "Creating File\n" );
632
633 // Figure out the dimension in which to write the mesh.
634 int mesh_dim;
635 result = iFace->get_dimension( mesh_dim );
636 CHK_MB_ERR_0( result );
637
638 if( user_dimension < 1 ) user_dimension = mesh_dim;
639 user_dimension = user_dimension > mesh_dim ? mesh_dim : user_dimension;
640
641 // Create the file layout, including all tables (zero-ed) and
642 // all structure and meta information.
643 const char* optnames[] = { "WRITE_PART", "FORMAT", 0 };
644 int junk;
645 parallelWrite = ( MB_SUCCESS == opts.match_option( "PARALLEL", optnames, junk ) );
646 if( parallelWrite )
647 {
648 // Just store Boolean value based on string option here.
649 // parallel_create_file will set writeProp accordingly.
650 // collectiveIO = (MB_SUCCESS == opts.get_null_option("COLLECTIVE"));
651 // dbgOut.printf(2, "'COLLECTIVE' option = %s\n", collectiveIO ? "YES" : "NO");
652 // Do this all the time, as it appears to be much faster than indep in some cases
653 collectiveIO = true;
654 result =
655 parallel_create_file( filename, overwrite, qa_records, opts, tag_list, num_tags, user_dimension, times );
656 }
657 else
658 {
659 result = serial_create_file( filename, overwrite, qa_records, tag_list, num_tags, user_dimension );
660 }
661 if( MB_SUCCESS != result ) return error( result );
662
663 times[CREATE_TIME] = timer.time_elapsed();
664
665 dbgOut.tprint( 1, "Writing Nodes.\n" );
666 // Write node coordinates
667 if( !nodeSet.range.empty() || parallelWrite )
668 {
669 topState.start( "writing coords" );
670 result = write_nodes();
671 topState.end( result );
672 if( MB_SUCCESS != result ) return error( result );
673 }
674
675 times[COORD_TIME] = timer.time_elapsed();
676
677 dbgOut.tprint( 1, "Writing connectivity.\n" );
678
679 // Write element connectivity
680 for( ex_itor = exportList.begin(); ex_itor != exportList.end(); ++ex_itor )
681 {
682 topState.start( "writing connectivity for ", ex_itor->name() );
683 result = write_elems( *ex_itor );
684 topState.end( result );
685 if( MB_SUCCESS != result ) return error( result );
686 }
687 times[CONN_TIME] = timer.time_elapsed();
688
689 dbgOut.tprint( 1, "Writing sets.\n" );
690
691 // Write meshsets
692 result = write_sets( times );
693 if( MB_SUCCESS != result ) return error( result );
694 debug_barrier();
695
696 times[SET_TIME] = timer.time_elapsed();
697 dbgOut.tprint( 1, "Writing adjacencies.\n" );
698
699 // Write adjacencies
700 // Tim says don't save node adjacencies!
701 #ifdef MB_H5M_WRITE_NODE_ADJACENCIES
702 result = write_adjacencies( nodeSet );
703 if( MB_SUCCESS != result ) return error( result );
704 #endif
705 for( ex_itor = exportList.begin(); ex_itor != exportList.end(); ++ex_itor )
706 {
707 topState.start( "writing adjacencies for ", ex_itor->name() );
708 result = write_adjacencies( *ex_itor );
709 topState.end( result );
710 if( MB_SUCCESS != result ) return error( result );
711 }
712 times[ADJ_TIME] = timer.time_elapsed();
713
714 dbgOut.tprint( 1, "Writing tags.\n" );
715
716 // Write tags
717 for( t_itor = tagList.begin(); t_itor != tagList.end(); ++t_itor )
718 {
719 std::string name;
720 iFace->tag_get_name( t_itor->tag_id, name );
721 topState.start( "writing tag: ", name.c_str() );
722 result = write_tag( *t_itor, times );
723 topState.end( result );
724 if( MB_SUCCESS != result ) return error( result );
725 }
726 times[TAG_TIME] = timer.time_elapsed();
727
728 times[TOTAL_TIME] = timer.time_since_birth();
729
730 if( cputime )
731 {
732 print_times( times );
733 }
734
735 return MB_SUCCESS;
736 }
737
738 ErrorCode WriteHDF5::initialize_mesh( const Range ranges[5] )
739 {
740 ErrorCode rval;
741
742 if( !ranges[0].all_of_type( MBVERTEX ) ) return error( MB_FAILURE );
743 nodeSet.range = ranges[0];
744 nodeSet.type = MBVERTEX;
745 nodeSet.num_nodes = 1;
746 nodeSet.max_num_ents = nodeSet.max_num_adjs = 0;
747
748 if( !ranges[4].all_of_type( MBENTITYSET ) ) return error( MB_FAILURE );
749 setSet.range = ranges[4];
750 setSet.type = MBENTITYSET;
751 setSet.num_nodes = 0;
752 setSet.max_num_ents = setSet.max_num_adjs = 0;
753 maxNumSetContents = maxNumSetChildren = maxNumSetParents = 0;
754
755 exportList.clear();
756 std::vector< Range > bins( 1024 ); // Sort entities by connectivity length
757 // Resize is expensive due to Range copy, so start big
758 for( EntityType type = MBEDGE; type < MBENTITYSET; ++type )
759 {
760 ExportSet set;
761 set.max_num_ents = set.max_num_adjs = 0;
762 const int dim = CN::Dimension( type );
763
764 // Group entities by connectivity length
765 bins.clear();
766 assert( dim >= 0 && dim <= 4 );
767 std::pair< Range::const_iterator, Range::const_iterator > p = ranges[dim].equal_range( type );
768 Range::const_iterator i = p.first;
769 while( i != p.second )
770 {
771 Range::const_iterator first = i;
772 EntityHandle const* conn;
773 int len, firstlen;
774
775 // Dummy storage vector for structured mesh "get_connectivity" function
776 std::vector< EntityHandle > storage;
777
778 rval = iFace->get_connectivity( *i, conn, firstlen, false, &storage );
779 if( MB_SUCCESS != rval ) return error( rval );
780
781 for( ++i; i != p.second; ++i )
782 {
783 rval = iFace->get_connectivity( *i, conn, len, false, &storage );
784 if( MB_SUCCESS != rval ) return error( rval );
785
786 if( len != firstlen ) break;
787 }
788
789 if( firstlen >= (int)bins.size() ) bins.resize( firstlen + 1 );
790 bins[firstlen].merge( first, i );
791 }
792 // Create ExportSet for each group
793 for( std::vector< Range >::iterator j = bins.begin(); j != bins.end(); ++j )
794 {
795 if( j->empty() ) continue;
796
797 set.range.clear();
798 set.type = type;
799 set.num_nodes = j - bins.begin();
800 exportList.push_back( set );
801 exportList.back().range.swap( *j );
802 }
803 }
804
805 return MB_SUCCESS;
806 }
807
808 // Gather the mesh to be written from a list of owning meshsets.
809 ErrorCode WriteHDF5::gather_mesh_info( const std::vector< EntityHandle >& export_sets )
810 {
811 ErrorCode rval;
812
813 int dim;
814 Range range; // Temporary storage
815 Range ranges[5]; // Lists of entities to export, grouped by dimension
816
817 // Gather list of all related sets
818 std::vector< EntityHandle > stack( export_sets );
819 std::copy( export_sets.begin(), export_sets.end(), stack.begin() );
820 std::vector< EntityHandle > set_children;
821 while( !stack.empty() )
822 {
823 EntityHandle meshset = stack.back();
824 stack.pop_back();
825 ranges[4].insert( meshset );
826
827 // Get contained sets
828 range.clear();
829 rval = iFace->get_entities_by_type( meshset, MBENTITYSET, range );
830 CHK_MB_ERR_0( rval );
831 for( Range::iterator ritor = range.begin(); ritor != range.end(); ++ritor )
832 {
833 if( ranges[4].find( *ritor ) == ranges[4].end() ) stack.push_back( *ritor );
834 }
835
836 // Get child sets
837 set_children.clear();
838 rval = iFace->get_child_meshsets( meshset, set_children, 1 );
839 CHK_MB_ERR_0( rval );
840 for( std::vector< EntityHandle >::iterator vitor = set_children.begin(); vitor != set_children.end(); ++vitor )
841 {
842 if( ranges[4].find( *vitor ) == ranges[4].end() ) stack.push_back( *vitor );
843 }
844 }
845
846 // Gather list of all mesh entities from list of sets,
847 // grouped by dimension.
848 for( Range::iterator setitor = ranges[4].begin(); setitor != ranges[4].end(); ++setitor )
849 {
850 for( dim = 0; dim < 4; ++dim )
851 {
852 range.clear();
853 rval = iFace->get_entities_by_dimension( *setitor, dim, range, false );
854 CHK_MB_ERR_0( rval );
855
856 ranges[dim].merge( range );
857 }
858 }
859
860 // For each list of elements, append adjacent children and
861 // nodes to lists.
862 for( dim = 3; dim > 0; --dim )
863 {
864 for( int cdim = 1; cdim < dim; ++cdim )
865 {
866 range.clear();
867 rval = iFace->get_adjacencies( ranges[dim], cdim, false, range );
868 CHK_MB_ERR_0( rval );
869 ranges[cdim].merge( range );
870 }
871 range.clear();
872 rval = writeUtil->gather_nodes_from_elements( ranges[dim], 0, range );
873 CHK_MB_ERR_0( rval );
874 ranges[0].merge( range );
875 }
876
877 return initialize_mesh( ranges );
878 }
879
880 // Gather all the mesh and related information to be written.
881 ErrorCode WriteHDF5::gather_all_mesh()
882 {
883 ErrorCode rval;
884 Range ranges[5];
885
886 rval = iFace->get_entities_by_type( 0, MBVERTEX, ranges[0] );
887 if( MB_SUCCESS != rval ) return error( rval );
888
889 rval = iFace->get_entities_by_dimension( 0, 1, ranges[1] );
890 if( MB_SUCCESS != rval ) return error( rval );
891
892 rval = iFace->get_entities_by_dimension( 0, 2, ranges[2] );
893 if( MB_SUCCESS != rval ) return error( rval );
894
895 rval = iFace->get_entities_by_dimension( 0, 3, ranges[3] );
896 if( MB_SUCCESS != rval ) return error( rval );
897
898 rval = iFace->get_entities_by_type( 0, MBENTITYSET, ranges[4] );
899 if( MB_SUCCESS != rval ) return error( rval );
900
901 return initialize_mesh( ranges );
902 }
903
904 ErrorCode WriteHDF5::write_nodes()
905 {
906 mhdf_Status status;
907 int dim, mesh_dim;
908 ErrorCode rval;
909 hid_t node_table;
910 long first_id, num_nodes;
911
912 if( !nodeSet.total_num_ents ) return MB_SUCCESS; // No nodes!
913
914 CHECK_OPEN_HANDLES;
915
916 rval = iFace->get_dimension( mesh_dim );
917 CHK_MB_ERR_0( rval );
918
919 debug_barrier();
920 dbgOut.print( 3, "Opening Node Coords\n" );
921 node_table = mhdf_openNodeCoords( filePtr, &num_nodes, &dim, &first_id, &status );
922 CHK_MHDF_ERR_0( status );
923 IODebugTrack track( debugTrack, "nodes", num_nodes );
924
925 double* buffer = (double*)dataBuffer;
926 #ifdef BLOCKED_COORD_IO
927 int chunk_size = bufferSize / sizeof( double );
928 #else
929 int chunk_size = bufferSize / ( 3 * sizeof( double ) );
930 #endif
931
932 long remaining = nodeSet.range.size();
933 long num_writes = ( remaining + chunk_size - 1 ) / chunk_size;
934 if( nodeSet.max_num_ents )
935 {
936 assert( nodeSet.max_num_ents >= remaining );
937 num_writes = ( nodeSet.max_num_ents + chunk_size - 1 ) / chunk_size;
938 }
939 long remaining_writes = num_writes;
940
941 long offset = nodeSet.offset;
942 Range::const_iterator iter = nodeSet.range.begin();
943 dbgOut.printf( 3, "Writing %ld nodes in %ld blocks of %d\n", remaining, ( remaining + chunk_size - 1 ) / chunk_size,
944 chunk_size );
945 while( remaining )
946 {
947 (void)VALGRIND_MAKE_MEM_UNDEFINED( dataBuffer, bufferSize );
948 long count = chunk_size < remaining ? chunk_size : remaining;
949 remaining -= count;
950 Range::const_iterator end = iter;
951 end += count;
952
953 #ifdef BLOCKED_COORD_IO
954 for( int d = 0; d < dim; d++ )
955 {
956 if( d < mesh_dim )
957 {
958 rval = writeUtil->get_node_coords( d, iter, end, count, buffer );
959 CHK_MB_ERR_1( rval, node_table, status );
960 }
961 else
962 memset( buffer, 0, count * sizeof( double ) );
963
964 dbgOut.printf( 3, " writing %c node chunk %ld of %ld, %ld values at %ld\n", (char)( 'X' + d ),
965 num_writes - remaining_writes + 1, num_writes, count, offset );
966 mhdf_writeNodeCoordWithOpt( node_table, offset, count, d, buffer, writeProp, &status );
967 CHK_MHDF_ERR_1( status, node_table );
968 }
969 #else
970 rval = writeUtil->get_node_coords( -1, iter, end, 3 * count, buffer );
971 CHK_MB_ERR_1( rval, node_table, status );
972 dbgOut.printf( 3, " writing node chunk %ld of %ld, %ld values at %ld\n", num_writes - remaining_writes + 1,
973 num_writes, count, offset );
974 mhdf_writeNodeCoordsWithOpt( node_table, offset, count, buffer, writeProp, &status );
975 CHK_MHDF_ERR_1( status, node_table );
976 #endif
977 track.record_io( offset, count );
978
979 iter = end;
980 offset += count;
981 --remaining_writes;
982 }
983
984 // Do empty writes if necessary for parallel collective IO
985 if( collectiveIO )
986 {
987 while( remaining_writes-- )
988 {
989 assert( writeProp != H5P_DEFAULT );
990 #ifdef BLOCKED_COORD_IO
991 for( int d = 0; d < dim; ++d )
992 {
993 dbgOut.printf( 3, " writing (empty) %c node chunk %ld of %ld.\n", (char)( 'X' + d ),
994 num_writes - remaining_writes, num_writes );
995 mhdf_writeNodeCoordWithOpt( node_table, offset, 0, d, 0, writeProp, &status );
996 CHK_MHDF_ERR_1( status, node_table );
997 }
998 #else
999 dbgOut.printf( 3, " writing (empty) node chunk %ld of %ld.\n", num_writes - remaining_writes, num_writes );
1000 mhdf_writeNodeCoordsWithOpt( node_table, offset, 0, 0, writeProp, &status );
1001 CHK_MHDF_ERR_1( status, node_table );
1002 #endif
1003 }
1004 }
1005
1006 mhdf_closeData( filePtr, node_table, &status );
1007 CHK_MHDF_ERR_0( status );
1008
1009 track.all_reduce();
1010 return MB_SUCCESS;
1011 }
1012
1013 ErrorCode WriteHDF5::write_elems( ExportSet& elems )
1014 {
1015 mhdf_Status status;
1016 ErrorCode rval;
1017 long first_id;
1018 int nodes_per_elem;
1019 long table_size;
1020
1021 CHECK_OPEN_HANDLES;
1022
1023 debug_barrier();
1024 dbgOut.printf( 2, "Writing %lu elements of type %s%d\n", (unsigned long)elems.range.size(),
1025 CN::EntityTypeName( elems.type ), elems.num_nodes );
1026 dbgOut.print( 3, "Writing elements", elems.range );
1027
1028 hid_t elem_table = mhdf_openConnectivity( filePtr, elems.name(), &nodes_per_elem, &table_size, &first_id, &status );
1029 CHK_MHDF_ERR_0( status );
1030 IODebugTrack track( debugTrack, elems.name() && strlen( elems.name() ) ? elems.name() : "<ANONYMOUS ELEM SET?>",
1031 table_size );
1032
1033 assert( (unsigned long)first_id <= elems.first_id );
1034 assert( (unsigned long)table_size >= elems.offset + elems.range.size() );
1035
1036 EntityHandle* buffer = (EntityHandle*)dataBuffer;
1037 int chunk_size = bufferSize / ( elems.num_nodes * sizeof( wid_t ) );
1038 long offset = elems.offset;
1039 long remaining = elems.range.size();
1040 long num_writes = ( remaining + chunk_size - 1 ) / chunk_size;
1041 if( elems.max_num_ents )
1042 {
1043 assert( elems.max_num_ents >= remaining );
1044 num_writes = ( elems.max_num_ents + chunk_size - 1 ) / chunk_size;
1045 }
1046 long remaining_writes = num_writes;
1047 Range::iterator iter = elems.range.begin();
1048
1049 while( remaining )
1050 {
1051 (void)VALGRIND_MAKE_MEM_UNDEFINED( dataBuffer, bufferSize );
1052 long count = chunk_size < remaining ? chunk_size : remaining;
1053 remaining -= count;
1054
1055 Range::iterator next = iter;
1056 next += count;
1057 rval = writeUtil->get_element_connect( iter, next, elems.num_nodes, count * elems.num_nodes, buffer );
1058 CHK_MB_ERR_1( rval, elem_table, status );
1059 iter = next;
1060
1061 for( long i = 0; i < count * nodes_per_elem; ++i )
1062 {
1063 buffer[i] = idMap.find( buffer[i] );
1064 if( 0 == buffer[i] )
1065 {
1066 MB_SET_ERR_CONT( "Invalid " << elems.name() << " element connectivity. Write Aborted" );
1067 mhdf_closeData( filePtr, elem_table, &status );
1068 return error( MB_FAILURE );
1069 }
1070 }
1071
1072 dbgOut.printf( 3, " writing node connectivity %ld of %ld, %ld values at %ld\n",
1073 num_writes - remaining_writes + 1, num_writes, count, offset );
1074 track.record_io( offset, count );
1075 mhdf_writeConnectivityWithOpt( elem_table, offset, count, id_type, buffer, writeProp, &status );
1076 CHK_MHDF_ERR_1( status, elem_table );
1077
1078 offset += count;
1079 --remaining_writes;
1080 }
1081
1082 // Do empty writes if necessary for parallel collective IO
1083 if( collectiveIO )
1084 {
1085 while( remaining_writes-- )
1086 {
1087 assert( writeProp != H5P_DEFAULT );
1088 dbgOut.printf( 3, " writing (empty) connectivity chunk %ld of %ld.\n", num_writes - remaining_writes + 1,
1089 num_writes );
1090 mhdf_writeConnectivityWithOpt( elem_table, offset, 0, id_type, 0, writeProp, &status );
1091 CHK_MHDF_ERR_1( status, elem_table );
1092 }
1093 }
1094
1095 mhdf_closeData( filePtr, elem_table, &status );
1096 CHK_MHDF_ERR_0( status );
1097
1098 track.all_reduce();
1099 return MB_SUCCESS;
1100 }
1101
1102 ErrorCode WriteHDF5::get_set_info( EntityHandle set,
1103 long& num_entities,
1104 long& num_children,
1105 long& num_parents,
1106 unsigned long& flags )
1107 {
1108 ErrorCode rval;
1109 int i;
1110 unsigned int u;
1111
1112 rval = iFace->get_number_entities_by_handle( set, i, false );
1113 CHK_MB_ERR_0( rval );
1114 num_entities = i;
1115
1116 rval = iFace->num_child_meshsets( set, &i );
1117 CHK_MB_ERR_0( rval );
1118 num_children = i;
1119
1120 rval = iFace->num_parent_meshsets( set, &i );
1121 CHK_MB_ERR_0( rval );
1122 num_parents = i;
1123
1124 rval = iFace->get_meshset_options( set, u );
1125 CHK_MB_ERR_0( rval );
1126 flags = u;
1127
1128 return MB_SUCCESS;
1129 }
1130
1131 ErrorCode WriteHDF5::write_set_data( const WriteUtilIface::EntityListType which_data,
1132 const hid_t handle,
1133 IODebugTrack& track,
1134 Range* ranged,
1135 Range* null_stripped,
1136 std::vector< long >* set_sizes )
1137 {
1138 // ranged must be non-null for CONTENTS and null for anything else
1139 assert( ( which_data == WriteUtilIface::CONTENTS ) == ( 0 != ranged ) );
1140 ErrorCode rval;
1141 mhdf_Status status;
1142
1143 debug_barrier();
1144
1145 // Function pointer type used to write set data
1146 void ( *write_func )( hid_t, long, long, hid_t, const void*, hid_t, mhdf_Status* );
1147 long max_vals; // Max over all procs of number of values to write to data set
1148 long offset; // Offset in HDF5 dataset at which to write next block of data
1149 switch( which_data )
1150 {
1151 case WriteUtilIface::CONTENTS:
1152 assert( ranged != 0 && null_stripped != 0 && set_sizes != 0 );
1153 write_func = &mhdf_writeSetDataWithOpt;
1154 max_vals = maxNumSetContents;
1155 offset = setContentsOffset;
1156 dbgOut.print( 2, "Writing set contents\n" );
1157 break;
1158 case WriteUtilIface::CHILDREN:
1159 assert( !ranged && !null_stripped && !set_sizes );
1160 write_func = &mhdf_writeSetParentsChildrenWithOpt;
1161 max_vals = maxNumSetChildren;
1162 offset = setChildrenOffset;
1163 dbgOut.print( 2, "Writing set child lists\n" );
1164 break;
1165 case WriteUtilIface::PARENTS:
1166 assert( !ranged && !null_stripped && !set_sizes );
1167 write_func = &mhdf_writeSetParentsChildrenWithOpt;
1168 max_vals = maxNumSetParents;
1169 offset = setParentsOffset;
1170 dbgOut.print( 2, "Writing set parent lists\n" );
1171 break;
1172 default:
1173 assert( false );
1174 return MB_FAILURE;
1175 }
1176 // assert(max_vals > 0); // Should have skipped this function otherwise
1177
1178 // buffer to use for IO
1179 wid_t* buffer = reinterpret_cast< wid_t* >( dataBuffer );
1180 // number of handles that will fit in the buffer
1181 const size_t buffer_size = bufferSize / sizeof( EntityHandle );
1182 // the total number of write calls that must be made, including no-ops for collective io
1183 const size_t num_total_writes = ( max_vals + buffer_size - 1 ) / buffer_size;
1184
1185 std::vector< SpecialSetData >::iterator si = specialSets.begin();
1186
1187 std::vector< wid_t > remaining; // data left over from prev iteration because it didn't fit in buffer
1188 size_t remaining_offset = 0; // avoid erasing from front of 'remaining'
1189 const EntityHandle* remaining_ptr = 0; // remaining for non-ranged data
1190 size_t remaining_count = 0;
1191 const wid_t* special_rem_ptr = 0;
1192 Range::const_iterator i = setSet.range.begin(), j, rhint, nshint;
1193 if( ranged ) rhint = ranged->begin();
1194 if( null_stripped ) nshint = null_stripped->begin();
1195 for( size_t w = 0; w < num_total_writes; ++w )
1196 {
1197 if( i == setSet.range.end() && !remaining.empty() && !remaining_ptr )
1198 {
1199 // If here, then we've written everything but we need to
1200 // make more write calls because we're doing collective IO
1201 // in parallel
1202 ( *write_func )( handle, 0, 0, id_type, 0, writeProp, &status );
1203 CHK_MHDF_ERR_0( status );
1204 continue;
1205 }
1206
1207 // If we had some left-over data from a range-compacted set
1208 // from the last iteration, add it to the buffer now
1209 size_t count = 0;
1210 if( !remaining.empty() )
1211 {
1212 count = remaining.size() - remaining_offset;
1213 if( count > buffer_size )
1214 {
1215 memcpy( buffer, &remaining[remaining_offset], buffer_size * sizeof( wid_t ) );
1216 count = buffer_size;
1217 remaining_offset += buffer_size;
1218 }
1219 else
1220 {
1221 memcpy( buffer, &remaining[remaining_offset], count * sizeof( wid_t ) );
1222 remaining_offset = 0;
1223 remaining.clear();
1224 }
1225 }
1226 // If we had some left-over data from a non-range-compacted set
1227 // from the last iteration, add it to the buffer now
1228 else if( remaining_ptr )
1229 {
1230 if( remaining_count > buffer_size )
1231 {
1232 rval = vector_to_id_list( remaining_ptr, buffer, buffer_size );
1233 CHK_MB_ERR_0( rval );
1234 count = buffer_size;
1235 remaining_ptr += count;
1236 remaining_count -= count;
1237 }
1238 else
1239 {
1240 rval = vector_to_id_list( remaining_ptr, buffer, remaining_count );
1241 CHK_MB_ERR_0( rval );
1242 count = remaining_count;
1243 remaining_ptr = 0;
1244 remaining_count = 0;
1245 }
1246 }
1247 // If we had some left-over data from a "special" (i.e. parallel shared)
1248 // set.
1249 else if( special_rem_ptr )
1250 {
1251 if( remaining_count > buffer_size )
1252 {
1253 memcpy( buffer, special_rem_ptr, buffer_size * sizeof( wid_t ) );
1254 count = buffer_size;
1255 special_rem_ptr += count;
1256 remaining_count -= count;
1257 }
1258 else
1259 {
1260 memcpy( buffer, special_rem_ptr, remaining_count * sizeof( wid_t ) );
1261 count = remaining_count;
1262 special_rem_ptr = 0;
1263 remaining_count = 0;
1264 }
1265 }
1266
1267 // While there is both space remaining in the buffer and
1268 // more sets to write, append more set data to buffer.
1269
1270 while( count < buffer_size && i != setSet.range.end() )
1271 {
1272 // Special case for "special" (i.e. parallel shared) sets:
1273 // we already have the data in a vector, just copy it.
1274 if( si != specialSets.end() && si->setHandle == *i )
1275 {
1276 std::vector< wid_t >& list = ( which_data == WriteUtilIface::CONTENTS ) ? si->contentIds
1277 : ( which_data == WriteUtilIface::PARENTS ) ? si->parentIds
1278 : si->childIds;
1279 size_t append = list.size();
1280 if( count + list.size() > buffer_size )
1281 {
1282 append = buffer_size - count;
1283 special_rem_ptr = &list[append];
1284 remaining_count = list.size() - append;
1285 }
1286 memcpy( buffer + count, &list[0], append * sizeof( wid_t ) );
1287 ++i;
1288 ++si;
1289 count += append;
1290 continue;
1291 }
1292
1293 j = i;
1294 ++i;
1295 const EntityHandle* ptr;
1296 int len;
1297 unsigned char flags;
1298 rval = writeUtil->get_entity_list_pointers( j, i, &ptr, which_data, &len, &flags );
1299 if( MB_SUCCESS != rval ) return rval;
1300 if( which_data == WriteUtilIface::CONTENTS && !( flags & MESHSET_ORDERED ) )
1301 {
1302 bool compacted;
1303 remaining.clear();
1304 if( len == 0 )
1305 compacted = false;
1306 else
1307 {
1308 assert( !( len % 2 ) );
1309 rval = range_to_blocked_list( ptr, len / 2, remaining, compacted );
1310 if( MB_SUCCESS != rval ) return rval;
1311 }
1312 if( compacted )
1313 {
1314 rhint = ranged->insert( rhint, *j );
1315 set_sizes->push_back( remaining.size() );
1316 }
1317 else if( remaining.size() != (unsigned)len )
1318 {
1319 nshint = null_stripped->insert( nshint, *j );
1320 set_sizes->push_back( remaining.size() );
1321 }
1322
1323 if( count + remaining.size() <= buffer_size )
1324 {
1325 if( !remaining.empty() )
1326 memcpy( buffer + count, &remaining[0], sizeof( wid_t ) * remaining.size() );
1327 count += remaining.size();
1328 remaining.clear();
1329 remaining_offset = 0;
1330 }
1331 else
1332 {
1333 remaining_offset = buffer_size - count;
1334 memcpy( buffer + count, &remaining[0], sizeof( wid_t ) * remaining_offset );
1335 count += remaining_offset;
1336 }
1337 }
1338 else
1339 {
1340 if( count + len > buffer_size )
1341 {
1342 size_t append = buffer_size - count;
1343 remaining_ptr = ptr + append;
1344 remaining_count = len - append;
1345 len = append;
1346 }
1347
1348 rval = vector_to_id_list( ptr, buffer + count, len );
1349 count += len;
1350 }
1351 }
1352
1353 // Write the buffer.
1354 ( *write_func )( handle, offset, count, id_type, buffer, writeProp, &status );
1355 CHK_MHDF_ERR_0( status );
1356 track.record_io( offset, count );
1357 offset += count;
1358 }
1359
1360 return MB_SUCCESS;
1361 }
1362
1363 ErrorCode WriteHDF5::write_sets( double* times )
1364 {
1365 mhdf_Status status;
1366 ErrorCode rval;
1367 long first_id, size;
1368 hid_t table;
1369 CpuTimer timer;
1370
1371 CHECK_OPEN_HANDLES;
1372 /* If no sets, just return success */
1373 if( !writeSets ) return MB_SUCCESS;
1374
1375 debug_barrier();
1376 dbgOut.printf( 2, "Writing %lu non-shared sets\n", (unsigned long)setSet.range.size() );
1377 dbgOut.print( 3, "Non-shared sets", setSet.range );
1378
1379 /* Write set parents */
1380 if( writeSetParents )
1381 {
1382 topState.start( "writing parent lists for local sets" );
1383 table = mhdf_openSetParents( filePtr, &size, &status );
1384 CHK_MHDF_ERR_0( status );
1385 IODebugTrack track( debugTrack, "SetParents", size );
1386
1387 rval = write_set_data( WriteUtilIface::PARENTS, table, track );
1388 topState.end( rval );
1389 CHK_MB_ERR_1( rval, table, status );
1390
1391 mhdf_closeData( filePtr, table, &status );
1392 CHK_MHDF_ERR_0( status );
1393
1394 times[SET_PARENT] = timer.time_elapsed();
1395 track.all_reduce();
1396 }
1397
1398 /* Write set children */
1399 if( writeSetChildren )
1400 {
1401 topState.start( "writing child lists for local sets" );
1402 table = mhdf_openSetChildren( filePtr, &size, &status );
1403 CHK_MHDF_ERR_0( status );
1404 IODebugTrack track( debugTrack, "SetChildren", size );
1405
1406 rval = write_set_data( WriteUtilIface::CHILDREN, table, track );
1407 topState.end( rval );
1408 CHK_MB_ERR_1( rval, table, status );
1409
1410 mhdf_closeData( filePtr, table, &status );
1411 CHK_MHDF_ERR_0( status );
1412
1413 times[SET_CHILD] = timer.time_elapsed();
1414 track.all_reduce();
1415 }
1416
1417 /* Write set contents */
1418 Range ranged_sets, null_stripped_sets;
1419 std::vector< long > set_sizes;
1420 if( writeSetContents )
1421 {
1422 topState.start( "writing content lists for local sets" );
1423 table = mhdf_openSetData( filePtr, &size, &status );
1424 CHK_MHDF_ERR_0( status );
1425 IODebugTrack track( debugTrack, "SetContents", size );
1426
1427 rval = write_set_data( WriteUtilIface::CONTENTS, table, track, &ranged_sets, &null_stripped_sets, &set_sizes );
1428 topState.end( rval );
1429 CHK_MB_ERR_1( rval, table, status );
1430
1431 mhdf_closeData( filePtr, table, &status );
1432 CHK_MHDF_ERR_0( status );
1433
1434 times[SET_CONTENT] = timer.time_elapsed();
1435 track.all_reduce();
1436 }
1437 assert( ranged_sets.size() + null_stripped_sets.size() == set_sizes.size() );
1438
1439 /* Write set description table */
1440
1441 debug_barrier();
1442 topState.start( "writing descriptions of local sets" );
1443 dbgOut.printf( 2, "Writing %lu non-shared sets\n", (unsigned long)setSet.range.size() );
1444 dbgOut.print( 3, "Non-shared sets", setSet.range );
1445
1446 /* Open the table */
1447 table = mhdf_openSetMeta( filePtr, &size, &first_id, &status );
1448 CHK_MHDF_ERR_0( status );
1449 IODebugTrack track_meta( debugTrack, "SetMeta", size );
1450
1451 /* Some debug stuff */
1452 debug_barrier();
1453 dbgOut.printf( 2, "Writing %lu non-shared sets\n", (unsigned long)setSet.range.size() );
1454 dbgOut.print( 3, "Non-shared sets", setSet.range );
1455
1456 /* Counts and buffers and such */
1457 mhdf_index_t* const buffer = reinterpret_cast< mhdf_index_t* >( dataBuffer );
1458 const size_t buffer_size = bufferSize / ( 4 * sizeof( mhdf_index_t ) );
1459 const size_t num_local_writes = ( setSet.range.size() + buffer_size - 1 ) / buffer_size;
1460 const size_t num_global_writes = ( setSet.max_num_ents + buffer_size - 1 ) / buffer_size;
1461 assert( num_local_writes <= num_global_writes );
1462 assert( num_global_writes > 0 );
1463
1464 /* data about sets for which number of handles written is
1465 * not the same as the number of handles in the set
1466 * (range-compacted or null handles stripped out)
1467 */
1468 Range::const_iterator i = setSet.range.begin();
1469 Range::const_iterator r = ranged_sets.begin();
1470 Range::const_iterator s = null_stripped_sets.begin();
1471 std::vector< mhdf_index_t >::const_iterator n = set_sizes.begin();
1472 assert( ranged_sets.size() + null_stripped_sets.size() == set_sizes.size() );
1473
1474 /* We write the end index for each list, rather than the count */
1475 mhdf_index_t prev_contents_end = setContentsOffset - 1;
1476 mhdf_index_t prev_children_end = setChildrenOffset - 1;
1477 mhdf_index_t prev_parents_end = setParentsOffset - 1;
1478
1479 /* While there is more data to write */
1480 size_t offset = setSet.offset;
1481 std::vector< SpecialSetData >::const_iterator si = specialSets.begin();
1482 for( size_t w = 0; w < num_local_writes; ++w )
1483 {
1484 // Get a buffer full of data
1485 size_t count = 0;
1486 while( count < buffer_size && i != setSet.range.end() )
1487 {
1488 // Get set properties
1489 long num_ent, num_child, num_parent;
1490 unsigned long flags;
1491 if( si != specialSets.end() && si->setHandle == *i )
1492 {
1493 flags = si->setFlags;
1494 num_ent = si->contentIds.size();
1495 num_child = si->childIds.size();
1496 num_parent = si->parentIds.size();
1497 ++si;
1498 if( r != ranged_sets.end() && *i == *r )
1499 {
1500 assert( flags & mhdf_SET_RANGE_BIT );
1501 ++r;
1502 ++n;
1503 }
1504 else if( s != null_stripped_sets.end() && *i == *s )
1505 {
1506 ++s;
1507 ++n;
1508 }
1509 }
1510 else
1511 {
1512 assert( si == specialSets.end() || si->setHandle > *i );
1513
1514 // Get set properties
1515 rval = get_set_info( *i, num_ent, num_child, num_parent, flags );
1516 CHK_MB_ERR_1( rval, table, status );
1517
1518 // Check if size is something other than num handles in set
1519 if( r != ranged_sets.end() && *i == *r )
1520 {
1521 num_ent = *n;
1522 ++r;
1523 ++n;
1524 flags |= mhdf_SET_RANGE_BIT;
1525 }
1526 else if( s != null_stripped_sets.end() && *i == *s )
1527 {
1528 num_ent = *n;
1529 ++s;
1530 ++n;
1531 }
1532 }
1533
1534 // Put data in buffer
1535 mhdf_index_t* local = buffer + 4 * count;
1536 prev_contents_end += num_ent;
1537 prev_children_end += num_child;
1538 prev_parents_end += num_parent;
1539 local[0] = prev_contents_end;
1540 local[1] = prev_children_end;
1541 local[2] = prev_parents_end;
1542 local[3] = flags;
1543
1544 // Iterate
1545 ++count;
1546 ++i;
1547 }
1548
1549 // Write the data
1550 mhdf_writeSetMetaWithOpt( table, offset, count, MHDF_INDEX_TYPE, buffer, writeProp, &status );
1551 CHK_MHDF_ERR_1( status, table );
1552 track_meta.record_io( offset, count );
1553 offset += count;
1554 }
1555 assert( r == ranged_sets.end() );
1556 assert( s == null_stripped_sets.end() );
1557 assert( n == set_sizes.end() );
1558
1559 /* If doing parallel write with collective IO, do null write
1560 * calls because other procs aren't done yet and write calls
1561 * are collective */
1562 for( size_t w = num_local_writes; w != num_global_writes; ++w )
1563 {
1564 mhdf_writeSetMetaWithOpt( table, 0, 0, MHDF_INDEX_TYPE, 0, writeProp, &status );
1565 CHK_MHDF_ERR_1( status, table );
1566 }
1567
1568 topState.end();
1569 mhdf_closeData( filePtr, table, &status );
1570 CHK_MHDF_ERR_0( status );
1571
1572 times[SET_META] = timer.time_elapsed();
1573 track_meta.all_reduce();
1574
1575 return MB_SUCCESS;
1576 }
1577
1578 template < class HandleRangeIter >
1579 inline size_t count_num_handles( HandleRangeIter iter, HandleRangeIter end )
1580 {
1581 size_t result = 0;
1582 for( ; iter != end; ++iter )
1583 result += iter->second - iter->first + 1;
1584
1585 return result;
1586 }
1587
1588 template < class HandleRangeIter >
1589 inline ErrorCode range_to_id_list_templ( HandleRangeIter begin,
1590 HandleRangeIter end,
1591 const RangeMap< EntityHandle, WriteHDF5::wid_t >& idMap,
1592 WriteHDF5::wid_t* array )
1593 {
1594 ErrorCode rval = MB_SUCCESS;
1595 RangeMap< EntityHandle, WriteHDF5::wid_t >::iterator ri = idMap.begin();
1596 WriteHDF5::wid_t* i = array;
1597 for( HandleRangeIter pi = begin; pi != end; ++pi )
1598 {
1599 EntityHandle h = pi->first;
1600 while( h <= pi->second )
1601 {
1602 ri = idMap.lower_bound( ri, idMap.end(), h );
1603 if( ri == idMap.end() || ri->begin > h )
1604 {
1605 rval = MB_ENTITY_NOT_FOUND;
1606 *i = 0;
1607 ++i;
1608 ++h;
1609 continue;
1610 }
1611
1612 // compute the last available value of the found target range (ri iterator)
1613 WriteHDF5::wid_t last_valid_input_value_in_current_map_range = ri->begin + ri->count - 1;
1614 // limit the number of steps we do on top of h so we do not overflow the output range
1615 // span
1616 WriteHDF5::wid_t step_until = std::min( last_valid_input_value_in_current_map_range, pi->second );
1617 WriteHDF5::wid_t n = step_until - h + 1;
1618 assert( n > 0 ); // We must at least step 1
1619
1620 WriteHDF5::wid_t id = ri->value + ( h - ri->begin );
1621 for( WriteHDF5::wid_t j = 0; j < n; ++i, ++j )
1622 *i = id + j;
1623 h += n;
1624 }
1625 }
1626
1627 assert( i == array + count_num_handles( begin, end ) );
1628 return rval;
1629 }
1630
1631 template < class HandleRangeIter >
1632 inline ErrorCode range_to_blocked_list_templ( HandleRangeIter begin,
1633 HandleRangeIter end,
1634 const RangeMap< EntityHandle, WriteHDF5::wid_t >& idMap,
1635 std::vector< WriteHDF5::wid_t >& output_id_list,
1636 bool& ranged_list )
1637 {
1638 output_id_list.clear();
1639 if( begin == end )
1640 {
1641 ranged_list = false;
1642 return MB_SUCCESS;
1643 }
1644
1645 // First try ranged format, but give up if we reach the
1646 // non-range format size.
1647 RangeMap< EntityHandle, WriteHDF5::wid_t >::iterator ri = idMap.begin();
1648
1649 const size_t num_handles = count_num_handles( begin, end );
1650 // If we end up with more than this many range blocks, then
1651 // we're better off just writing the set as a simple list
1652 size_t pairs_remaining = num_handles / 2;
1653 for( HandleRangeIter pi = begin; pi != end; ++pi )
1654 {
1655 EntityHandle h = pi->first;
1656 WriteHDF5::wid_t local_mapped_from_subrange = 0;
1657 while( h <= pi->second )
1658 {
1659 ri = idMap.lower_bound( ri, idMap.end(), h );
1660 if( ri == idMap.end() || ri->begin > h )
1661 {
1662 ++h;
1663 continue;
1664 }
1665
1666 WriteHDF5::wid_t n = pi->second - pi->first + 1 - local_mapped_from_subrange;
1667 if( n > ri->count ) n = ri->count;
1668
1669 WriteHDF5::wid_t id = ri->value + ( h - ri->begin );
1670 // see if we can go to the end of the range
1671 if( id + n > ri->value + ri->count ) // we have to reduce n, because we cannot go over next subrange
1672 {
1673 if( ri->value + ri->count - id > 0 ) n = ri->value + ri->count - id;
1674 }
1675
1676 // See if we can append it to the previous range
1677 if( !output_id_list.empty() && output_id_list[output_id_list.size() - 2] + output_id_list.back() == id )
1678 {
1679 output_id_list.back() += n;
1680 }
1681
1682 // If we ran out of space, (or set is empty) just do list format
1683 else if( !pairs_remaining )
1684 {
1685 ranged_list = false;
1686 output_id_list.resize( num_handles );
1687 range_to_id_list_templ( begin, end, idMap, &output_id_list[0] );
1688 output_id_list.erase( std::remove( output_id_list.begin(), output_id_list.end(), 0u ),
1689 output_id_list.end() );
1690 return MB_SUCCESS;
1691 }
1692
1693 //
1694 else
1695 {
1696 --pairs_remaining;
1697 output_id_list.push_back( id );
1698 output_id_list.push_back( n );
1699 }
1700 local_mapped_from_subrange += n; // we already mapped so many
1701 h += n;
1702 }
1703 }
1704
1705 ranged_list = true;
1706 return MB_SUCCESS;
1707 }
1708
1709 ErrorCode WriteHDF5::range_to_blocked_list( const Range& input_range,
1710 std::vector< wid_t >& output_id_list,
1711 bool& ranged_list )
1712 {
1713 return range_to_blocked_list_templ( input_range.const_pair_begin(), input_range.const_pair_end(), idMap,
1714 output_id_list, ranged_list );
1715 }
1716
1717 ErrorCode WriteHDF5::range_to_blocked_list( const EntityHandle* array,
1718 size_t num_input_ranges,
1719 std::vector< wid_t >& output_id_list,
1720 bool& ranged_list )
1721 {
1722 // We assume this in the cast on the following line
1723 typedef std::pair< EntityHandle, EntityHandle > mtype;
1724 assert( sizeof( mtype ) == 2 * sizeof( EntityHandle ) );
1725 const mtype* arr = reinterpret_cast< const mtype* >( array );
1726 return range_to_blocked_list_templ( arr, arr + num_input_ranges, idMap, output_id_list, ranged_list );
1727 }
1728
1729 ErrorCode WriteHDF5::range_to_id_list( const Range& range, wid_t* array )
1730 {
1731 return range_to_id_list_templ( range.const_pair_begin(), range.const_pair_end(), idMap, array );
1732 }
1733
1734 ErrorCode WriteHDF5::vector_to_id_list( const EntityHandle* input,
1735 size_t input_len,
1736 wid_t* output,
1737 size_t& output_len,
1738 bool remove_zeros )
1739 {
1740 const EntityHandle* i_iter = input;
1741 const EntityHandle* i_end = input + input_len;
1742 wid_t* o_iter = output;
1743 for( ; i_iter != i_end; ++i_iter )
1744 {
1745 wid_t id = idMap.find( *i_iter );
1746 if( !remove_zeros || id != 0 )
1747 {
1748 *o_iter = id;
1749 ++o_iter;
1750 }
1751 }
1752 output_len = o_iter - output;
1753
1754 return MB_SUCCESS;
1755 }
1756
1757 ErrorCode WriteHDF5::vector_to_id_list( const std::vector< EntityHandle >& input,
1758 std::vector< wid_t >& output,
1759 bool remove_zeros )
1760 {
1761 output.resize( input.size() );
1762 size_t output_size = 0;
1763 ErrorCode rval = vector_to_id_list( &input[0], input.size(), &output[0], output_size, remove_zeros );
1764 output.resize( output_size );
1765 return rval;
1766 }
1767
1768 ErrorCode WriteHDF5::vector_to_id_list( const EntityHandle* input, wid_t* output, size_t count )
1769 {
1770 size_t output_len;
1771 return vector_to_id_list( input, count, output, output_len, false );
1772 }
1773
1774 inline ErrorCode WriteHDF5::get_adjacencies( EntityHandle entity, std::vector< wid_t >& adj )
1775 {
1776 const EntityHandle* adj_array;
1777 int num_adj;
1778 ErrorCode rval = writeUtil->get_adjacencies( entity, adj_array, num_adj );
1779 if( MB_SUCCESS != rval ) return error( rval );
1780
1781 size_t j = 0;
1782 adj.resize( num_adj );
1783 for( int i = 0; i < num_adj; ++i )
1784 if( wid_t id = idMap.find( adj_array[i] ) ) adj[j++] = id;
1785 adj.resize( j );
1786
1787 return MB_SUCCESS;
1788 }
1789
1790 ErrorCode WriteHDF5::write_adjacencies( const ExportSet& elements )
1791 {
1792 ErrorCode rval;
1793 mhdf_Status status;
1794 Range::const_iterator iter;
1795 const Range::const_iterator end = elements.range.end();
1796 std::vector< wid_t > adj_list;
1797
1798 CHECK_OPEN_HANDLES;
1799
1800 debug_barrier();
1801
1802 /* Count Adjacencies */
1803 long count = 0;
1804 // for (iter = elements.range.begin(); iter != end; ++iter) {
1805 // adj_list.clear();
1806 // rval = get_adjacencies(*iter, adj_list);CHK_MB_ERR_0(rval);
1807 //
1808 // if (adj_list.size() > 0)
1809 // count += adj_list.size() + 2;
1810 //}
1811
1812 // if (count == 0)
1813 // return MB_SUCCESS;
1814
1815 long offset = elements.adj_offset;
1816 if( elements.max_num_adjs == 0 ) return MB_SUCCESS;
1817
1818 /* Create data list */
1819 hid_t table = mhdf_openAdjacency( filePtr, elements.name(), &count, &status );
1820 CHK_MHDF_ERR_0( status );
1821 IODebugTrack track( debugTrack, "Adjacencies", count );
1822
1823 /* Write data */
1824 wid_t* buffer = (wid_t*)dataBuffer;
1825 long chunk_size = bufferSize / sizeof( wid_t );
1826 long num_writes = ( elements.max_num_adjs + chunk_size - 1 ) / chunk_size;
1827 (void)VALGRIND_MAKE_MEM_UNDEFINED( dataBuffer, bufferSize );
1828 count = 0;
1829 for( iter = elements.range.begin(); iter != end; ++iter )
1830 {
1831 adj_list.clear();
1832 rval = get_adjacencies( *iter, adj_list );
1833 CHK_MB_ERR_1( rval, table, status );
1834 if( adj_list.size() == 0 ) continue;
1835
1836 // If buffer is full, flush it
1837 if( count + adj_list.size() + 2 > (unsigned long)chunk_size )
1838 {
1839 dbgOut.print( 3, " writing adjacency chunk.\n" );
1840 track.record_io( offset, count );
1841 mhdf_writeAdjacencyWithOpt( table, offset, count, id_type, buffer, writeProp, &status );
1842 CHK_MHDF_ERR_1( status, table );
1843 (void)VALGRIND_MAKE_MEM_UNDEFINED( dataBuffer, bufferSize );
1844
1845 offset += count;
1846 count = 0;
1847 }
1848
1849 buffer[count++] = idMap.find( *iter );
1850 buffer[count++] = adj_list.size();
1851
1852 assert( adj_list.size() + 2 < (unsigned long)chunk_size );
1853 memcpy( buffer + count, &adj_list[0], adj_list.size() * sizeof( wid_t ) );
1854 count += adj_list.size();
1855 }
1856
1857 if( count )
1858 {
1859 dbgOut.print( 2, " writing final adjacency chunk.\n" );
1860 mhdf_writeAdjacencyWithOpt( table, offset, count, id_type, buffer, writeProp, &status );
1861 CHK_MHDF_ERR_1( status, table );
1862
1863 offset += count;
1864 count = 0;
1865 --num_writes;
1866 }
1867
1868 // Do empty writes if necessary for parallel collective IO
1869 if( collectiveIO )
1870 {
1871 while( num_writes > 0 )
1872 {
1873 --num_writes;
1874 assert( writeProp != H5P_DEFAULT );
1875 dbgOut.print( 2, " writing empty adjacency chunk.\n" );
1876 mhdf_writeAdjacencyWithOpt( table, offset, 0, id_type, 0, writeProp, &status );
1877 CHK_MHDF_ERR_1( status, table );
1878 }
1879 }
1880
1881 mhdf_closeData( filePtr, table, &status );
1882 CHK_MHDF_ERR_0( status );
1883
1884 track.all_reduce();
1885 return MB_SUCCESS;
1886 }
1887
1888 ErrorCode WriteHDF5::write_tag( const TagDesc& tag_data, double* times )
1889 {
1890 std::string name;
1891 ErrorCode rval = iFace->tag_get_name( tag_data.tag_id, name );
1892 if( MB_SUCCESS != rval ) return error( rval );
1893
1894 CHECK_OPEN_HANDLES;
1895 debug_barrier();
1896 dbgOut.tprintf( 1, "Writing tag: \"%s\"\n", name.c_str() );
1897
1898 int moab_size, elem_size, array_len;
1899 DataType moab_type;
1900 mhdf_TagDataType mhdf_type;
1901 hid_t hdf5_type;
1902 rval = get_tag_size( tag_data.tag_id, moab_type, moab_size, elem_size, array_len, mhdf_type, hdf5_type );
1903 if( MB_SUCCESS != rval ) return error( rval );
1904
1905 CpuTimer timer;
1906 if( array_len == MB_VARIABLE_LENGTH && tag_data.write_sparse )
1907 {
1908 dbgOut.printf( 2, "Writing sparse data for var-len tag: \"%s\"\n", name.c_str() );
1909 rval = write_var_len_tag( tag_data, name, moab_type, hdf5_type, elem_size );
1910 times[VARLEN_TAG_TIME] += timer.time_elapsed();
1911 }
1912 else
1913 {
1914 int data_len = elem_size;
1915 if( moab_type != MB_TYPE_BIT ) data_len *= array_len;
1916 if( tag_data.write_sparse )
1917 {
1918 dbgOut.printf( 2, "Writing sparse data for tag: \"%s\"\n", name.c_str() );
1919 rval = write_sparse_tag( tag_data, name, moab_type, hdf5_type, data_len );
1920 times[SPARSE_TAG_TIME] += timer.time_elapsed();
1921 }
1922 for( size_t i = 0; MB_SUCCESS == rval && i < tag_data.dense_list.size(); ++i )
1923 {
1924 const ExportSet* set = find( tag_data.dense_list[i] );
1925 assert( 0 != set );
1926 debug_barrier();
1927 dbgOut.printf( 2, "Writing dense data for tag: \"%s\" on group \"%s\"\n", name.c_str(), set->name() );
1928 subState.start( "writing dense data for tag: ", ( name + ":" + set->name() ).c_str() );
1929 rval = write_dense_tag( tag_data, *set, name, moab_type, hdf5_type, data_len );
1930 subState.end( rval );
1931 }
1932 times[DENSE_TAG_TIME] += timer.time_elapsed();
1933 }
1934
1935 H5Tclose( hdf5_type );
1936 return MB_SUCCESS == rval ? MB_SUCCESS : error( rval );
1937 }
1938
1939 ErrorCode WriteHDF5::write_sparse_ids( const TagDesc& tag_data,
1940 const Range& range,
1941 hid_t id_table,
1942 size_t table_size,
1943 const char* name )
1944 {
1945 ErrorCode rval;
1946 mhdf_Status status;
1947
1948 CHECK_OPEN_HANDLES;
1949
1950 std::string tname( name ? name : "<UNKNOWN TAG?>" );
1951 tname += " - Ids";
1952 IODebugTrack track( debugTrack, tname, table_size );
1953
1954 // Set up data buffer for writing IDs
1955 size_t chunk_size = bufferSize / sizeof( wid_t );
1956 wid_t* id_buffer = (wid_t*)dataBuffer;
1957
1958 // Write IDs of tagged entities.
1959 long remaining = range.size();
1960 long offset = tag_data.sparse_offset;
1961 long num_writes = ( remaining + chunk_size - 1 ) / chunk_size;
1962 if( tag_data.max_num_ents )
1963 {
1964 assert( tag_data.max_num_ents >= (unsigned long)remaining );
1965 num_writes = ( tag_data.max_num_ents + chunk_size - 1 ) / chunk_size;
1966 }
1967 Range::const_iterator iter = range.begin();
1968 while( remaining )
1969 {
1970 (void)VALGRIND_MAKE_MEM_UNDEFINED( dataBuffer, bufferSize );
1971
1972 // Write "chunk_size" blocks of data
1973 long count = (unsigned long)remaining > chunk_size ? chunk_size : remaining;
1974 remaining -= count;
1975 Range::const_iterator stop = iter;
1976 stop += count;
1977 Range tmp;
1978 ;
1979 tmp.merge( iter, stop );
1980 iter = stop;
1981 assert( tmp.size() == (unsigned)count );
1982
1983 rval = range_to_id_list( tmp, id_buffer );
1984 CHK_MB_ERR_0( rval );
1985
1986 // Write the data
1987 dbgOut.print( 3, " writing sparse tag entity chunk.\n" );
1988 track.record_io( offset, count );
1989 mhdf_writeSparseTagEntitiesWithOpt( id_table, offset, count, id_type, id_buffer, writeProp, &status );
1990 CHK_MHDF_ERR_0( status );
1991
1992 offset += count;
1993 --num_writes;
1994 } // while (remaining)
1995
1996 // Do empty writes if necessary for parallel collective IO
1997 if( collectiveIO )
1998 {
1999 while( num_writes-- )
2000 {
2001 assert( writeProp != H5P_DEFAULT );
2002 dbgOut.print( 3, " writing empty sparse tag entity chunk.\n" );
2003 mhdf_writeSparseTagEntitiesWithOpt( id_table, offset, 0, id_type, 0, writeProp, &status );
2004 CHK_MHDF_ERR_0( status );
2005 }
2006 }
2007
2008 track.all_reduce();
2009 return MB_SUCCESS;
2010 }
2011
2012 ErrorCode WriteHDF5::write_sparse_tag( const TagDesc& tag_data,
2013 const std::string& name,
2014 DataType mb_data_type,
2015 hid_t value_type,
2016 int value_type_size )
2017 {
2018 ErrorCode rval;
2019 mhdf_Status status;
2020 hid_t tables[3];
2021 long table_size, data_size;
2022
2023 CHECK_OPEN_HANDLES;
2024
2025 // Get entities for which to write tag values
2026 Range range;
2027 rval = get_sparse_tagged_entities( tag_data, range );
2028
2029 // Open tables to write info
2030 mhdf_openSparseTagData( filePtr, name.c_str(), &table_size, &data_size, tables, &status );
2031 CHK_MHDF_ERR_0( status );
2032 assert( range.size() + tag_data.sparse_offset <= (unsigned long)table_size );
2033 // Fixed-length tag
2034 assert( table_size == data_size );
2035
2036 // Write IDs for tagged entities
2037 subState.start( "writing sparse ids for tag: ", name.c_str() );
2038 rval = write_sparse_ids( tag_data, range, tables[0], table_size, name.c_str() );
2039 subState.end( rval );
2040 CHK_MB_ERR_2( rval, tables, status );
2041 mhdf_closeData( filePtr, tables[0], &status );
2042 CHK_MHDF_ERR_1( status, tables[1] );
2043
2044 // Set up data buffer for writing tag values
2045 IODebugTrack track( debugTrack, name + " Data", data_size );
2046 subState.start( "writing sparse values for tag: ", name.c_str() );
2047 rval = write_tag_values( tag_data.tag_id, tables[1], tag_data.sparse_offset, range, mb_data_type, value_type,
2048 value_type_size, tag_data.max_num_ents, track );
2049 subState.end( rval );
2050 CHK_MB_ERR_0( rval );
2051 mhdf_closeData( filePtr, tables[1], &status );
2052 CHK_MHDF_ERR_0( status );
2053
2054 track.all_reduce();
2055 return MB_SUCCESS;
2056 }
2057
2058 ErrorCode WriteHDF5::write_var_len_indices( const TagDesc& tag_data,
2059 const Range& range,
2060 hid_t idx_table,
2061 size_t table_size,
2062 int /*type_size*/,
2063 const char* name )
2064 {
2065 ErrorCode rval;
2066 mhdf_Status status;
2067
2068 CHECK_OPEN_HANDLES;
2069
2070 std::string tname( name ? name : "<UNKNOWN TAG?>" );
2071 tname += " - End Indices";
2072 IODebugTrack track( debugTrack, tname, table_size );
2073
2074 // Set up data buffer for writing indices
2075 size_t chunk_size = bufferSize / ( std::max( sizeof( void* ), sizeof( long ) ) + sizeof( int ) );
2076 mhdf_index_t* idx_buffer = (mhdf_index_t*)dataBuffer;
2077 const void** junk = (const void**)dataBuffer;
2078 int* size_buffer = (int*)( dataBuffer + chunk_size * std::max( sizeof( void* ), sizeof( mhdf_index_t ) ) );
2079
2080 // Write IDs of tagged entities.
2081 long data_offset = tag_data.var_data_offset - 1; // Offset at which to write data buffer
2082 size_t remaining = range.size();
2083 size_t offset = tag_data.sparse_offset;
2084 size_t num_writes = ( remaining + chunk_size - 1 ) / chunk_size;
2085 if( tag_data.max_num_ents )
2086 {
2087 assert( tag_data.max_num_ents >= (unsigned long)remaining );
2088 num_writes = ( tag_data.max_num_ents + chunk_size - 1 ) / chunk_size;
2089 }
2090 Range::const_iterator iter = range.begin();
2091 while( remaining )
2092 {
2093 (void)VALGRIND_MAKE_MEM_UNDEFINED( dataBuffer, bufferSize );
2094
2095 // Write "chunk_size" blocks of data
2096 size_t count = remaining > chunk_size ? chunk_size : remaining;
2097 remaining -= count;
2098 Range::const_iterator stop = iter;
2099 stop += count;
2100 Range tmp;
2101 tmp.merge( iter, stop );
2102 iter = stop;
2103 assert( tmp.size() == (unsigned)count );
2104
2105 rval = iFace->tag_get_by_ptr( tag_data.tag_id, tmp, junk, size_buffer );
2106 CHK_MB_ERR_0( rval );
2107
2108 // Calculate end indices
2109 dbgOut.print( 3, " writing var-len tag offset chunk.\n" );
2110 track.record_io( offset, count );
2111 for( size_t i = 0; i < count; ++i )
2112 {
2113 data_offset += size_buffer[i];
2114 idx_buffer[i] = data_offset;
2115 }
2116
2117 // Write
2118 mhdf_writeSparseTagIndicesWithOpt( idx_table, offset, count, MHDF_INDEX_TYPE, idx_buffer, writeProp, &status );
2119 CHK_MHDF_ERR_0( status );
2120
2121 offset += count;
2122 --num_writes;
2123 } // while (remaining)
2124
2125 // Do empty writes if necessary for parallel collective IO
2126 if( collectiveIO )
2127 {
2128 while( num_writes-- )
2129 {
2130 assert( writeProp != H5P_DEFAULT );
2131 dbgOut.print( 3, " writing empty sparse tag entity chunk.\n" );
2132 mhdf_writeSparseTagIndicesWithOpt( idx_table, offset, 0, id_type, 0, writeProp, &status );
2133 CHK_MHDF_ERR_0( status );
2134 }
2135 }
2136
2137 track.all_reduce();
2138 return MB_SUCCESS;
2139 }
2140
2141 ErrorCode WriteHDF5::write_var_len_data( const TagDesc& tag_data,
2142 const Range& range,
2143 hid_t table,
2144 size_t table_size,
2145 bool handle_tag,
2146 hid_t hdf_type,
2147 int type_size,
2148 const char* name )
2149 {
2150 ErrorCode rval;
2151 mhdf_Status status;
2152
2153 CHECK_OPEN_HANDLES;
2154 assert( !handle_tag || sizeof( EntityHandle ) == type_size );
2155
2156 std::string tname( name ? name : "<UNKNOWN TAG?>" );
2157 tname += " - Values";
2158 IODebugTrack track( debugTrack, tname, table_size );
2159
2160 const size_t buffer_size = bufferSize / type_size;
2161
2162 size_t num_writes = ( table_size + buffer_size - 1 ) / buffer_size;
2163 if( collectiveIO )
2164 {
2165 assert( tag_data.max_num_vals > 0 );
2166 num_writes = ( tag_data.max_num_vals + buffer_size - 1 ) / buffer_size;
2167 }
2168
2169 unsigned char* buffer = (unsigned char*)dataBuffer;
2170 const void* prev_data = 0; // Data left over from prev iteration
2171 size_t prev_len = 0;
2172 Range::const_iterator iter = range.begin();
2173 long offset = tag_data.var_data_offset;
2174 while( prev_data || iter != range.end() )
2175 {
2176 size_t count = 0;
2177 if( prev_data )
2178 {
2179 size_t len;
2180 const void* ptr = prev_data;
2181 if( prev_len <= buffer_size )
2182 {
2183 len = prev_len;
2184 prev_data = 0;
2185 prev_len = 0;
2186 }
2187 else
2188 {
2189 len = buffer_size;
2190 prev_data = ( (const char*)prev_data ) + buffer_size * type_size;
2191 prev_len -= buffer_size;
2192 }
2193
2194 if( handle_tag )
2195 convert_handle_tag( (const EntityHandle*)ptr, (EntityHandle*)buffer, len );
2196 else
2197 memcpy( buffer, ptr, len * type_size );
2198 count = len;
2199 }
2200
2201 for( ; count < buffer_size && iter != range.end(); ++iter )
2202 {
2203 int len;
2204 const void* ptr;
2205 rval = iFace->tag_get_by_ptr( tag_data.tag_id, &*iter, 1, &ptr, &len );
2206 CHK_MB_ERR_0( rval );
2207 if( len + count > buffer_size )
2208 {
2209 prev_len = len + count - buffer_size;
2210 len = buffer_size - count;
2211 prev_data = ( (const char*)ptr ) + len * type_size;
2212 }
2213
2214 if( handle_tag )
2215 convert_handle_tag( (const EntityHandle*)ptr, ( (EntityHandle*)buffer ) + count, len );
2216 else
2217 memcpy( buffer + count * type_size, ptr, len * type_size );
2218 count += len;
2219 }
2220
2221 track.record_io( offset, count );
2222 mhdf_writeTagValuesWithOpt( table, offset, count, hdf_type, buffer, writeProp, &status );
2223 offset += count;
2224 CHK_MHDF_ERR_0( status );
2225 --num_writes;
2226 }
2227
2228 // Do empty writes if necessary for parallel collective IO
2229 if( collectiveIO )
2230 {
2231 while( num_writes-- )
2232 {
2233 assert( writeProp != H5P_DEFAULT );
2234 dbgOut.print( 3, " writing empty var-len tag data chunk.\n" );
2235 mhdf_writeTagValuesWithOpt( table, 0, 0, hdf_type, 0, writeProp, &status );
2236 CHK_MHDF_ERR_0( status );
2237 }
2238 }
2239
2240 track.all_reduce();
2241 return MB_SUCCESS;
2242 }
2243
2244 ErrorCode WriteHDF5::write_var_len_tag( const TagDesc& tag_data,
2245 const std::string& name,
2246 DataType mb_data_type,
2247 hid_t hdf_type,
2248 int type_size )
2249 {
2250 ErrorCode rval;
2251 mhdf_Status status;
2252 hid_t tables[3];
2253 long table_size;
2254 long data_table_size;
2255
2256 CHECK_OPEN_HANDLES;
2257
2258 // Get entities for which to write tag values
2259 Range range;
2260 rval = get_sparse_tagged_entities( tag_data, range );
2261
2262 // Open tables to write info
2263 mhdf_openSparseTagData( filePtr, name.c_str(), &table_size, &data_table_size, tables, &status );
2264 CHK_MHDF_ERR_0( status );
2265 assert( range.size() + tag_data.sparse_offset <= (unsigned long)table_size );
2266
2267 // Write IDs for tagged entities
2268 subState.start( "writing ids for var-len tag: ", name.c_str() );
2269 rval = write_sparse_ids( tag_data, range, tables[0], table_size, name.c_str() );
2270 subState.end( rval );
2271 CHK_MB_ERR_2( rval, tables, status );
2272 mhdf_closeData( filePtr, tables[0], &status );
2273 CHK_MHDF_ERR_2( status, tables + 1 );
2274
2275 // Write offsets for tagged entities
2276 subState.start( "writing indices for var-len tag: ", name.c_str() );
2277 rval = write_var_len_indices( tag_data, range, tables[2], table_size, type_size, name.c_str() );
2278 subState.end( rval );
2279 CHK_MB_ERR_1( rval, tables[1], status );
2280 mhdf_closeData( filePtr, tables[2], &status );
2281 CHK_MHDF_ERR_1( status, tables[1] );
2282
2283 // Write the actual tag data
2284 subState.start( "writing values for var-len tag: ", name.c_str() );
2285 rval = write_var_len_data( tag_data, range, tables[1], data_table_size, mb_data_type == MB_TYPE_HANDLE, hdf_type,
2286 type_size, name.c_str() );
2287 subState.end( rval );
2288 CHK_MB_ERR_0( rval );
2289 mhdf_closeData( filePtr, tables[1], &status );
2290 CHK_MHDF_ERR_0( status );
2291
2292 return MB_SUCCESS;
2293 }
2294
2295 ErrorCode WriteHDF5::write_dense_tag( const TagDesc& tag_data,
2296 const ExportSet& elem_data,
2297 const std::string& name,
2298 DataType mb_data_type,
2299 hid_t value_type,
2300 int value_type_size )
2301 {
2302 CHECK_OPEN_HANDLES;
2303
2304 // Open tables to write info
2305 mhdf_Status status;
2306 long table_size;
2307 hid_t table = mhdf_openDenseTagData( filePtr, name.c_str(), elem_data.name(), &table_size, &status );
2308 CHK_MHDF_ERR_0( status );
2309 assert( elem_data.range.size() + elem_data.offset <= (unsigned long)table_size );
2310
2311 IODebugTrack track( debugTrack, name + " " + elem_data.name() + " Data", table_size );
2312 ErrorCode rval = write_tag_values( tag_data.tag_id, table, elem_data.offset, elem_data.range, mb_data_type,
2313 value_type, value_type_size, elem_data.max_num_ents, track );
2314 CHK_MB_ERR_0( rval );
2315 mhdf_closeData( filePtr, table, &status );
2316 CHK_MHDF_ERR_0( status );
2317
2318 return MB_SUCCESS;
2319 }
2320
2321 ErrorCode WriteHDF5::write_tag_values( Tag tag_id,
2322 hid_t data_table,
2323 unsigned long offset_in,
2324 const Range& range_in,
2325 DataType mb_data_type,
2326 hid_t value_type,
2327 int value_type_size,
2328 unsigned long max_num_ents,
2329 IODebugTrack& track )
2330 {
2331 mhdf_Status status;
2332
2333 CHECK_OPEN_HANDLES;
2334
2335 // Set up data buffer for writing tag values
2336 size_t chunk_size = bufferSize / value_type_size;
2337 assert( chunk_size > 0 );
2338 char* tag_buffer = (char*)dataBuffer;
2339
2340 // Write the tag values
2341 size_t remaining = range_in.size();
2342 size_t offset = offset_in;
2343 Range::const_iterator iter = range_in.begin();
2344 long num_writes = ( remaining + chunk_size - 1 ) / chunk_size;
2345 if( max_num_ents )
2346 {
2347 assert( max_num_ents >= remaining );
2348 num_writes = ( max_num_ents + chunk_size - 1 ) / chunk_size;
2349 }
2350 while( remaining )
2351 {
2352 (void)VALGRIND_MAKE_MEM_UNDEFINED( dataBuffer, bufferSize );
2353
2354 // Write "chunk_size" blocks of data
2355 long count = (unsigned long)remaining > chunk_size ? chunk_size : remaining;
2356 remaining -= count;
2357 memset( tag_buffer, 0, count * value_type_size );
2358 Range::const_iterator stop = iter;
2359 stop += count;
2360 Range range;
2361 range.merge( iter, stop );
2362 iter = stop;
2363 assert( range.size() == (unsigned)count );
2364
2365 ErrorCode rval = iFace->tag_get_data( tag_id, range, tag_buffer );
2366 CHK_MB_ERR_0( rval );
2367
2368 // Convert EntityHandles to file ids
2369 if( mb_data_type == MB_TYPE_HANDLE )
2370 convert_handle_tag( reinterpret_cast< EntityHandle* >( tag_buffer ),
2371 count * value_type_size / sizeof( EntityHandle ) );
2372
2373 // Write the data
2374 dbgOut.print( 2, " writing tag value chunk.\n" );
2375 track.record_io( offset, count );
2376 assert( value_type > 0 );
2377 mhdf_writeTagValuesWithOpt( data_table, offset, count, value_type, tag_buffer, writeProp, &status );
2378 CHK_MHDF_ERR_0( status );
2379
2380 offset += count;
2381 --num_writes;
2382 } // while (remaining)
2383
2384 // Do empty writes if necessary for parallel collective IO
2385 if( collectiveIO )
2386 {
2387 while( num_writes-- )
2388 {
2389 assert( writeProp != H5P_DEFAULT );
2390 dbgOut.print( 2, " writing empty tag value chunk.\n" );
2391 assert( value_type > 0 );
2392 mhdf_writeTagValuesWithOpt( data_table, offset, 0, value_type, 0, writeProp, &status );
2393 CHK_MHDF_ERR_0( status );
2394 }
2395 }
2396
2397 track.all_reduce();
2398 return MB_SUCCESS;
2399 }
2400
2401 ErrorCode WriteHDF5::write_qa( const std::vector< std::string >& list )
2402 {
2403 const char* app = "MOAB";
2404 const char* vers = MOAB_VERSION;
2405 char date_str[64];
2406 char time_str[64];
2407
2408 CHECK_OPEN_HANDLES;
2409
2410 std::vector< const char* > strs( list.size() ? list.size() : 4 );
2411 if( list.size() == 0 )
2412 {
2413 time_t t = time( NULL );
2414 tm* lt = localtime( &t );
2415 #ifdef WIN32
2416 strftime( date_str, sizeof( date_str ), "%m/%d/%y", lt ); // VS 2008 does not support %D
2417 strftime( time_str, sizeof( time_str ), "%H:%M:%S", lt ); // VS 2008 does not support %T
2418 #else
2419 strftime( date_str, sizeof( date_str ), "%D", lt );
2420 strftime( time_str, sizeof( time_str ), "%T", lt );
2421 #endif
2422
2423 strs[0] = app;
2424 strs[1] = vers;
2425 strs[2] = date_str;
2426 strs[3] = time_str;
2427 }
2428 else
2429 {
2430 for( unsigned int i = 0; i < list.size(); ++i )
2431 strs[i] = list[i].c_str();
2432 }
2433
2434 mhdf_Status status;
2435 dbgOut.print( 2, " writing QA history.\n" );
2436 mhdf_writeHistory( filePtr, &strs[0], strs.size(), &status );
2437 CHK_MHDF_ERR_0( status );
2438
2439 return MB_SUCCESS;
2440 }
2441
2442 /*
2443 ErrorCode WriteHDF5::register_known_tag_types(Interface* iface)
2444 {
2445 hid_t int4, double16;
2446 hsize_t dim[1];
2447 int error = 0;
2448 ErrorCode rval;
2449
2450 dim[0] = 4;
2451 int4 = H5Tarray_create(H5T_NATIVE_INT, 1, dim, NULL);
2452
2453 dim[0] = 16;
2454 double16 = H5Tarray_create(H5T_NATIVE_DOUBLE, 1, dim, NULL);
2455
2456 if (int4 < 0 || double16 < 0)
2457 error = 1;
2458
2459 struct { const char* name; hid_t type; } list[] = {
2460 { GLOBAL_ID_TAG_NAME, H5T_NATIVE_INT } ,
2461 { MATERIAL_SET_TAG_NAME, H5T_NATIVE_INT },
2462 { DIRICHLET_SET_TAG_NAME, H5T_NATIVE_INT },
2463 { NEUMANN_SET_TAG_NAME, H5T_NATIVE_INT },
2464 { HAS_MID_NODES_TAG_NAME, int4 },
2465 { GEOM_DIMENSION_TAG_NAME, H5T_NATIVE_INT },
2466 { MESH_TRANSFORM_TAG_NAME, double16 },
2467 { 0, 0 } };
2468
2469 for (int i = 0; list[i].name; ++i) {
2470 if (list[i].type < 1) {
2471 ++error;
2472 continue;
2473 }
2474
2475 Tag handle;
2476
2477 std::string name("__hdf5_tag_type_");
2478 name += list[i].name;
2479
2480 rval = iface->tag_get_handle(name.c_str(), handle);
2481 if (MB_TAG_NOT_FOUND == rval) {
2482 rval = iface->tag_create(name.c_str(), sizeof(hid_t), MB_TAG_SPARSE, handle, NULL);
2483 if (MB_SUCCESS != rval) {
2484 ++error;
2485 continue;
2486 }
2487
2488 hid_t copy_id = H5Tcopy(list[i].type);
2489 const EntityHandle mesh = 0;
2490 rval = iface->tag_set_data(handle, &mesh, 1, ©_id);
2491 if (MB_SUCCESS != rval) {
2492 ++error;
2493 continue;
2494 }
2495 }
2496 }
2497
2498 H5Tclose(int4);
2499 H5Tclose(double16);
2500 return error ? MB_FAILURE : MB_SUCCESS;
2501 }
2502 */
2503
2504 ErrorCode WriteHDF5::gather_tags( const Tag* user_tag_list, int num_tags )
2505 {
2506 ErrorCode result;
2507 std::vector< Tag > tag_list;
2508 std::vector< Tag >::iterator t_itor;
2509 Range range;
2510
2511 // Get list of Tags to write
2512 result = writeUtil->get_tag_list( tag_list, user_tag_list, num_tags );
2513 CHK_MB_ERR_0( result );
2514
2515 // Get list of tags
2516 for( t_itor = tag_list.begin(); t_itor != tag_list.end(); ++t_itor )
2517 {
2518 // Add tag to export list
2519 TagDesc tag_data;
2520 tag_data.write_sparse = false;
2521 tag_data.tag_id = *t_itor;
2522 tag_data.sparse_offset = 0;
2523 tag_data.var_data_offset = 0;
2524 tag_data.max_num_ents = 0;
2525 tag_data.max_num_vals = 0;
2526 tagList.push_back( tag_data );
2527 }
2528
2529 return MB_SUCCESS;
2530 }
2531
2532 // If we support parallel, then this function will have been
2533 // overridden with an alternate version in WriteHDF5Parallel
2534 // that supports parallel I/O. If we're here
2535 // then MOAB was not built with support for parallel HDF5 I/O.
2536 ErrorCode WriteHDF5::parallel_create_file( const char* /* filename */,
2537 bool /* overwrite */,
2538 const std::vector< std::string >& /* qa_records */,
2539 const FileOptions& /* opts */,
2540 const Tag* /* tag_list */,
2541 int /* num_tags */,
2542 int /* dimension */,
2543 double* /* times */ )
2544 {
2545 MB_SET_ERR( MB_NOT_IMPLEMENTED, "WriteHDF5 does not support parallel writing" );
2546 }
2547
2548 ErrorCode WriteHDF5::serial_create_file( const char* filename,
2549 bool overwrite,
2550 const std::vector< std::string >& qa_records,
2551 const Tag* user_tag_list,
2552 int num_user_tags,
2553 int dimension )
2554 {
2555 long first_id;
2556 mhdf_Status status;
2557 hid_t handle;
2558 std::list< ExportSet >::iterator ex_itor;
2559 ErrorCode rval;
2560
2561 topState.start( "creating file" );
2562
2563 const char* type_names[MBMAXTYPE];
2564 memset( type_names, 0, MBMAXTYPE * sizeof( char* ) );
2565 for( EntityType i = MBEDGE; i < MBENTITYSET; ++i )
2566 type_names[i] = CN::EntityTypeName( i );
2567
2568 // Create the file
2569 filePtr = mhdf_createFile( filename, overwrite, type_names, MBMAXTYPE, id_type, &status );
2570 CHK_MHDF_ERR_0( status );
2571 assert( !!filePtr );
2572
2573 rval = write_qa( qa_records );
2574 CHK_MB_ERR_0( rval );
2575
2576 // Create node table
2577 if( nodeSet.range.size() )
2578 {
2579 nodeSet.total_num_ents = nodeSet.range.size();
2580 handle = mhdf_createNodeCoords( filePtr, dimension, nodeSet.total_num_ents, &first_id, &status );
2581 CHK_MHDF_ERR_0( status );
2582 mhdf_closeData( filePtr, handle, &status );
2583 CHK_MHDF_ERR_0( status );
2584 nodeSet.first_id = (wid_t)first_id;
2585 rval = assign_ids( nodeSet.range, nodeSet.first_id );
2586 CHK_MB_ERR_0( rval );
2587 }
2588 else
2589 {
2590 nodeSet.first_id = std::numeric_limits< wid_t >::max();
2591 }
2592 nodeSet.offset = 0;
2593
2594 // Create element tables
2595 for( ex_itor = exportList.begin(); ex_itor != exportList.end(); ++ex_itor )
2596 {
2597 ex_itor->total_num_ents = ex_itor->range.size();
2598 rval = create_elem_table( *ex_itor, ex_itor->total_num_ents, first_id );
2599 CHK_MB_ERR_0( rval );
2600
2601 ex_itor->first_id = (wid_t)first_id;
2602 ex_itor->offset = 0;
2603 rval = assign_ids( ex_itor->range, ex_itor->first_id );
2604 CHK_MB_ERR_0( rval );
2605 }
2606 // Create set tables
2607 writeSets = !setSet.range.empty();
2608 if( writeSets )
2609 {
2610 long contents_len, children_len, parents_len;
2611
2612 setSet.total_num_ents = setSet.range.size();
2613 setSet.max_num_ents = setSet.total_num_ents;
2614 rval = create_set_meta( setSet.total_num_ents, first_id );
2615 CHK_MB_ERR_0( rval );
2616
2617 setSet.first_id = (wid_t)first_id;
2618 rval = assign_ids( setSet.range, setSet.first_id );
2619 CHK_MB_ERR_0( rval );
2620
2621 rval = count_set_size( setSet.range, contents_len, children_len, parents_len );
2622 CHK_MB_ERR_0( rval );
2623
2624 rval = create_set_tables( contents_len, children_len, parents_len );
2625 CHK_MB_ERR_0( rval );
2626
2627 setSet.offset = 0;
2628 setContentsOffset = 0;
2629 setChildrenOffset = 0;
2630 setParentsOffset = 0;
2631 writeSetContents = !!contents_len;
2632 writeSetChildren = !!children_len;
2633 writeSetParents = !!parents_len;
2634
2635 maxNumSetContents = contents_len;
2636 maxNumSetChildren = children_len;
2637 maxNumSetParents = parents_len;
2638 } // if (!setSet.range.empty())
2639
2640 // Create adjacency table after set table, because sets do not have yet an id
2641 // some entities are adjacent to sets (exodus?)
2642 // Create node adjacency table
2643 wid_t num_adjacencies;
2644 #ifdef MB_H5M_WRITE_NODE_ADJACENCIES
2645 rval = count_adjacencies( nodeSet.range, num_adjacencies );
2646 CHK_MB_ERR_0( rval );
2647 nodeSet.adj_offset = 0;
2648 nodeSet.max_num_adjs = num_adjacencies;
2649 if( num_adjacencies > 0 )
2650 {
2651 handle = mhdf_createAdjacency( filePtr, mhdf_node_type_handle(), num_adjacencies, &status );
2652 CHK_MHDF_ERR_0( status );
2653 mhdf_closeData( filePtr, handle, &status );
2654 }
2655 #endif
2656
2657 // Create element adjacency tables
2658 for( ex_itor = exportList.begin(); ex_itor != exportList.end(); ++ex_itor )
2659 {
2660 rval = count_adjacencies( ex_itor->range, num_adjacencies );
2661 CHK_MB_ERR_0( rval );
2662
2663 ex_itor->adj_offset = 0;
2664 ex_itor->max_num_adjs = num_adjacencies;
2665 if( num_adjacencies > 0 )
2666 {
2667 handle = mhdf_createAdjacency( filePtr, ex_itor->name(), num_adjacencies, &status );
2668 CHK_MHDF_ERR_0( status );
2669 mhdf_closeData( filePtr, handle, &status );
2670 }
2671 }
2672
2673 dbgOut.tprint( 1, "Gathering Tags\n" );
2674
2675 rval = gather_tags( user_tag_list, num_user_tags );
2676 CHK_MB_ERR_0( rval );
2677
2678 // Create the tags and tag data tables
2679 std::list< TagDesc >::iterator tag_iter = tagList.begin();
2680 for( ; tag_iter != tagList.end(); ++tag_iter )
2681 {
2682 // As we haven't yet added any ExportSets for which to write
2683 // dense tag data to the TagDesc struct pointed to by
2684 // tag_iter, this call will initially return all tagged entities
2685 // in the set of entities to be written.
2686 Range range;
2687 rval = get_sparse_tagged_entities( *tag_iter, range );
2688 CHK_MB_ERR_0( rval );
2689
2690 int s;
2691 bool var_len = ( MB_VARIABLE_DATA_LENGTH == iFace->tag_get_length( tag_iter->tag_id, s ) );
2692
2693 // Determine which ExportSets we want to write dense
2694 // data for. We never write dense data for variable-length
2695 // tag data.
2696 if( !var_len && writeTagDense )
2697 {
2698 // Check if we want to write this tag in dense format even if not
2699 // all of the entities have a tag value. The criterion of this
2700 // is that the tag be dense, have a default value, and have at
2701 // least 2/3 of the entities tagged.
2702 bool prefer_dense = false;
2703 TagType type;
2704 rval = iFace->tag_get_type( tag_iter->tag_id, type );
2705 CHK_MB_ERR_0( rval );
2706 if( MB_TAG_DENSE == type )
2707 {
2708 const void* defval = 0;
2709 rval = iFace->tag_get_default_value( tag_iter->tag_id, defval, s );
2710 if( MB_SUCCESS == rval ) prefer_dense = true;
2711 }
2712
2713 if( check_dense_format_tag( nodeSet, range, prefer_dense ) )
2714 {
2715 range -= nodeSet.range;
2716 tag_iter->dense_list.push_back( nodeSet );
2717 }
2718
2719 std::list< ExportSet >::const_iterator ex = exportList.begin();
2720 for( ; ex != exportList.end(); ++ex )
2721 {
2722 if( check_dense_format_tag( *ex, range, prefer_dense ) )
2723 {
2724 range -= ex->range;
2725 tag_iter->dense_list.push_back( *ex );
2726 }
2727 }
2728
2729 if( check_dense_format_tag( setSet, range, prefer_dense ) )
2730 {
2731 range -= setSet.range;
2732 tag_iter->dense_list.push_back( setSet );
2733 }
2734 }
2735
2736 tag_iter->write_sparse = !range.empty();
2737
2738 unsigned long var_len_total = 0;
2739 if( var_len )
2740 {
2741 rval = get_tag_data_length( *tag_iter, range, var_len_total );
2742 CHK_MB_ERR_0( rval );
2743 }
2744
2745 rval = create_tag( *tag_iter, range.size(), var_len_total );
2746 CHK_MB_ERR_0( rval );
2747 } // for (tags)
2748
2749 topState.end();
2750 return MB_SUCCESS;
2751 }
2752
2753 bool WriteHDF5::check_dense_format_tag( const ExportSet& ents, const Range& all_tagged, bool prefer_dense )
2754 {
2755 // If there are no tagged entities, then don't write anything
2756 if( ents.range.empty() ) return false;
2757
2758 // If all of the entities are tagged, then write in dense format
2759 if( all_tagged.contains( ents.range ) ) return true;
2760
2761 // Unless asked for more lenient choice of dense format, return false
2762 if( !prefer_dense ) return false;
2763
2764 // If we're being lenient about choosing dense format, then
2765 // return true if at least 2/3 of the entities are tagged.
2766 Range xsect = intersect( setSet.range, all_tagged );
2767 if( 3 * xsect.size() >= 2 * setSet.range.size() ) return true;
2768
2769 return false;
2770 }
2771
2772 ErrorCode WriteHDF5::count_adjacencies( const Range& set, wid_t& result )
2773 {
2774 ErrorCode rval;
2775 std::vector< wid_t > adj_list;
2776 Range::const_iterator iter = set.begin();
2777 const Range::const_iterator end = set.end();
2778 result = 0;
2779 for( ; iter != end; ++iter )
2780 {
2781 adj_list.clear();
2782 rval = get_adjacencies( *iter, adj_list );
2783 CHK_MB_ERR_0( rval );
2784
2785 if( adj_list.size() > 0 ) result += 2 + adj_list.size();
2786 }
2787
2788 return MB_SUCCESS;
2789 }
2790
2791 ErrorCode WriteHDF5::create_elem_table( const ExportSet& block, long num_entities, long& first_id_out )
2792 {
2793 mhdf_Status status;
2794 hid_t handle;
2795
2796 CHECK_OPEN_HANDLES;
2797
2798 mhdf_addElement( filePtr, block.name(), block.type, &status );
2799 CHK_MHDF_ERR_0( status );
2800
2801 handle = mhdf_createConnectivity( filePtr, block.name(), block.num_nodes, num_entities, &first_id_out, &status );
2802 CHK_MHDF_ERR_0( status );
2803 mhdf_closeData( filePtr, handle, &status );
2804 CHK_MHDF_ERR_0( status );
2805
2806 return MB_SUCCESS;
2807 }
2808
2809 ErrorCode WriteHDF5::count_set_size( const Range& sets,
2810 long& contents_length_out,
2811 long& children_length_out,
2812 long& parents_length_out )
2813 {
2814 ErrorCode rval;
2815 Range set_contents;
2816 long contents_length_set, children_length_set, parents_length_set;
2817 unsigned long flags;
2818 std::vector< wid_t > set_contents_ids;
2819 std::vector< SpecialSetData >::const_iterator si = specialSets.begin();
2820
2821 contents_length_out = 0;
2822 children_length_out = 0;
2823 parents_length_out = 0;
2824
2825 for( Range::const_iterator iter = sets.begin(); iter != sets.end(); ++iter )
2826 {
2827 while( si != specialSets.end() && si->setHandle < *iter )
2828 ++si;
2829
2830 if( si != specialSets.end() && si->setHandle == *iter )
2831 {
2832 contents_length_out += si->contentIds.size();
2833 children_length_out += si->childIds.size();
2834 parents_length_out += si->parentIds.size();
2835 ++si;
2836 continue;
2837 }
2838
2839 rval = get_set_info( *iter, contents_length_set, children_length_set, parents_length_set, flags );
2840 CHK_MB_ERR_0( rval );
2841
2842 // Check if can and should compress as ranges
2843 if( !( flags & MESHSET_ORDERED ) && contents_length_set )
2844 {
2845 set_contents.clear();
2846 rval = iFace->get_entities_by_handle( *iter, set_contents, false );
2847 CHK_MB_ERR_0( rval );
2848
2849 bool blocked_list;
2850 rval = range_to_blocked_list( set_contents, set_contents_ids, blocked_list );
2851 CHK_MB_ERR_0( rval );
2852
2853 if( blocked_list )
2854 {
2855 assert( set_contents_ids.size() % 2 == 0 );
2856 contents_length_set = set_contents_ids.size();
2857 }
2858 }
2859
2860 contents_length_out += contents_length_set;
2861 children_length_out += children_length_set;
2862 parents_length_out += parents_length_set;
2863 }
2864
2865 return MB_SUCCESS;
2866 }
2867
2868 ErrorCode WriteHDF5::create_set_meta( long num_sets, long& first_id_out )
2869 {
2870 hid_t handle;
2871 mhdf_Status status;
2872
2873 CHECK_OPEN_HANDLES;
2874
2875 handle = mhdf_createSetMeta( filePtr, num_sets, &first_id_out, &status );
2876 CHK_MHDF_ERR_0( status );
2877 mhdf_closeData( filePtr, handle, &status );
2878
2879 return MB_SUCCESS;
2880 }
2881
2882 WriteHDF5::SpecialSetData* WriteHDF5::find_set_data( EntityHandle h )
2883 {
2884 SpecialSetData tmp;
2885 tmp.setHandle = h;
2886 std::vector< SpecialSetData >::iterator i;
2887 i = std::lower_bound( specialSets.begin(), specialSets.end(), tmp, SpecSetLess() );
2888 return ( i == specialSets.end() || i->setHandle != h ) ? 0 : &*i;
2889 }
2890
2891 ErrorCode WriteHDF5::create_set_tables( long num_set_contents, long num_set_children, long num_set_parents )
2892 {
2893 hid_t handle;
2894 mhdf_Status status;
2895
2896 CHECK_OPEN_HANDLES;
2897
2898 if( num_set_contents > 0 )
2899 {
2900 handle = mhdf_createSetData( filePtr, num_set_contents, &status );
2901 CHK_MHDF_ERR_0( status );
2902 mhdf_closeData( filePtr, handle, &status );
2903 }
2904
2905 if( num_set_children > 0 )
2906 {
2907 handle = mhdf_createSetChildren( filePtr, num_set_children, &status );
2908 CHK_MHDF_ERR_0( status );
2909 mhdf_closeData( filePtr, handle, &status );
2910 }
2911
2912 if( num_set_parents > 0 )
2913 {
2914 handle = mhdf_createSetParents( filePtr, num_set_parents, &status );
2915 CHK_MHDF_ERR_0( status );
2916 mhdf_closeData( filePtr, handle, &status );
2917 }
2918
2919 return MB_SUCCESS;
2920 }
2921
2922 ErrorCode WriteHDF5::get_tag_size( Tag tag,
2923 DataType& moab_type,
2924 int& num_bytes,
2925 int& type_size,
2926 int& array_length,
2927 mhdf_TagDataType& file_type,
2928 hid_t& hdf_type )
2929 {
2930 ErrorCode rval;
2931 Tag type_handle;
2932 std::string tag_name, tag_type_name;
2933
2934 CHECK_OPEN_HANDLES;
2935
2936 // We return NULL for hdf_type if it can be determined from
2937 // the file_type. The only case where it is non-zero is
2938 // if the user specified a specific type via a mesh tag.
2939 hdf_type = (hid_t)0;
2940 bool close_hdf_type = false;
2941
2942 rval = iFace->tag_get_data_type( tag, moab_type );
2943 CHK_MB_ERR_0( rval );
2944 rval = iFace->tag_get_length( tag, array_length );
2945 if( MB_VARIABLE_DATA_LENGTH == rval )
2946 {
2947 array_length = MB_VARIABLE_LENGTH;
2948 }
2949 else if( MB_SUCCESS != rval )
2950 return error( rval );
2951 rval = iFace->tag_get_bytes( tag, num_bytes );
2952 if( MB_VARIABLE_DATA_LENGTH == rval )
2953 num_bytes = MB_VARIABLE_LENGTH;
2954 else if( MB_SUCCESS != rval )
2955 return error( rval );
2956
2957 switch( moab_type )
2958 {
2959 case MB_TYPE_INTEGER:
2960 type_size = sizeof( int );
2961 file_type = mhdf_INTEGER;
2962 hdf_type = H5T_NATIVE_INT;
2963 close_hdf_type = false;
2964 break;
2965 case MB_TYPE_DOUBLE:
2966 type_size = sizeof( double );
2967 file_type = mhdf_FLOAT;
2968 hdf_type = H5T_NATIVE_DOUBLE;
2969 close_hdf_type = false;
2970 break;
2971 case MB_TYPE_BIT:
2972 type_size = sizeof( bool );
2973 file_type = mhdf_BITFIELD;
2974 assert( array_length <= 8 );
2975 hdf_type = H5Tcopy( H5T_NATIVE_B8 );
2976 H5Tset_precision( hdf_type, array_length );
2977 close_hdf_type = true;
2978 break;
2979 case MB_TYPE_HANDLE:
2980 type_size = sizeof( EntityHandle );
2981 file_type = mhdf_ENTITY_ID;
2982 hdf_type = id_type;
2983 close_hdf_type = false;
2984 break;
2985 case MB_TYPE_OPAQUE:
2986 file_type = mhdf_OPAQUE;
2987 rval = iFace->tag_get_name( tag, tag_name );
2988 CHK_MB_ERR_0( rval );
2989 tag_type_name = "__hdf5_tag_type_";
2990 tag_type_name += tag_name;
2991 rval = iFace->tag_get_handle( tag_type_name.c_str(), 0, MB_TYPE_OPAQUE, type_handle, MB_TAG_ANY );
2992 if( MB_TAG_NOT_FOUND == rval )
2993 {
2994 if( num_bytes == MB_VARIABLE_LENGTH )
2995 type_size = 1;
2996 else
2997 type_size = num_bytes;
2998 hdf_type = H5Tcreate( H5T_OPAQUE, type_size );
2999 close_hdf_type = true;
3000 }
3001 else if( MB_SUCCESS == rval )
3002 {
3003 int hsize;
3004 rval = iFace->tag_get_bytes( type_handle, hsize );
3005 if( hsize != sizeof( hid_t ) ) return error( MB_FAILURE );
3006
3007 const EntityHandle root = 0;
3008 rval = iFace->tag_get_data( type_handle, &root, 1, &hdf_type );
3009 if( rval != MB_SUCCESS ) return error( rval );
3010
3011 type_size = H5Tget_size( hdf_type );
3012 if( type_size != num_bytes ) return error( MB_FAILURE );
3013
3014 close_hdf_type = false;
3015 }
3016 else
3017 return error( rval );
3018 num_bytes = array_length;
3019 array_length = ( num_bytes == MB_VARIABLE_LENGTH ) ? MB_VARIABLE_LENGTH : 1;
3020 break;
3021 default:
3022 break;
3023 }
3024
3025 assert( num_bytes == MB_VARIABLE_LENGTH || ( moab_type == MB_TYPE_BIT && num_bytes == 1 ) ||
3026 array_length * type_size == num_bytes );
3027
3028 if( num_bytes == MB_VARIABLE_LENGTH )
3029 {
3030 array_length = MB_VARIABLE_LENGTH;
3031 if( !close_hdf_type )
3032 {
3033 hdf_type = H5Tcopy( hdf_type );
3034 // close_hdf_type = true;
3035 }
3036 }
3037 else if( array_length > 1 && moab_type != MB_TYPE_BIT )
3038 {
3039 hsize_t len = array_length;
3040 #if defined( H5Tarray_create_vers ) && ( H5Tarray_create_vers > 1 )
3041 hid_t temp_id = H5Tarray_create2( hdf_type, 1, &len );
3042 #else
3043 hid_t temp_id = H5Tarray_create( hdf_type, 1, &len, NULL );
3044 #endif
3045 if( close_hdf_type ) H5Tclose( hdf_type );
3046 hdf_type = temp_id;
3047 }
3048 else if( !close_hdf_type )
3049 {
3050 hdf_type = H5Tcopy( hdf_type );
3051 // close_hdf_type = true;
3052 }
3053
3054 return MB_SUCCESS;
3055 }
3056
3057 ErrorCode WriteHDF5::get_tag_data_length( const TagDesc& tag_info, const Range& range, unsigned long& result )
3058 {
3059 ErrorCode rval;
3060 result = 0;
3061
3062 // Split buffer into two pieces, one for pointers and one for sizes
3063 size_t step, remaining;
3064 step = bufferSize / ( sizeof( int ) + sizeof( void* ) );
3065 const void** ptr_buffer = reinterpret_cast< const void** >( dataBuffer );
3066 int* size_buffer = reinterpret_cast< int* >( ptr_buffer + step );
3067 Range subrange;
3068 Range::const_iterator iter = range.begin();
3069 for( remaining = range.size(); remaining >= step; remaining -= step )
3070 {
3071 // Get subset of range containing 'count' entities
3072 Range::const_iterator end = iter;
3073 end += step;
3074 subrange.clear();
3075 subrange.merge( iter, end );
3076 iter = end;
3077 // Get tag sizes for entities
3078 rval = iFace->tag_get_by_ptr( tag_info.tag_id, subrange, ptr_buffer, size_buffer );
3079 if( MB_SUCCESS != rval ) return error( rval );
3080 // Sum lengths
3081 for( size_t i = 0; i < step; ++i )
3082 result += size_buffer[i];
3083 }
3084 // Process remaining
3085 subrange.clear();
3086 subrange.merge( iter, range.end() );
3087 assert( subrange.size() == remaining );
3088 rval = iFace->tag_get_by_ptr( tag_info.tag_id, subrange, ptr_buffer, size_buffer );
3089 if( MB_SUCCESS != rval ) return error( rval );
3090 for( size_t i = 0; i < remaining; ++i )
3091 result += size_buffer[i];
3092
3093 return MB_SUCCESS;
3094 }
3095
3096 ErrorCode WriteHDF5::create_tag( const TagDesc& tag_data,
3097 unsigned long num_sparse_entities,
3098 unsigned long data_table_size )
3099 {
3100 TagType mb_storage;
3101 DataType mb_type;
3102 mhdf_TagDataType mhdf_type;
3103 int tag_bytes, type_size, num_vals, storage;
3104 hid_t hdf_type = (hid_t)0;
3105 hid_t handles[3];
3106 std::string tag_name;
3107 ErrorCode rval;
3108 mhdf_Status status;
3109
3110 CHECK_OPEN_HANDLES;
3111
3112 // Get tag properties
3113 rval = iFace->tag_get_type( tag_data.tag_id, mb_storage );
3114 CHK_MB_ERR_0( rval );
3115 switch( mb_storage )
3116 {
3117 case MB_TAG_DENSE:
3118 storage = mhdf_DENSE_TYPE;
3119 break;
3120 case MB_TAG_SPARSE:
3121 storage = mhdf_SPARSE_TYPE;
3122 break;
3123 case MB_TAG_BIT:
3124 storage = mhdf_BIT_TYPE;
3125 break;
3126 case MB_TAG_MESH:
3127 storage = mhdf_MESH_TYPE;
3128 break;
3129 default:
3130 return error( MB_FAILURE );
3131 }
3132 rval = iFace->tag_get_name( tag_data.tag_id, tag_name );
3133 CHK_MB_ERR_0( rval );
3134 rval = get_tag_size( tag_data.tag_id, mb_type, tag_bytes, type_size, num_vals, mhdf_type, hdf_type );
3135 CHK_MB_ERR_0( rval );
3136
3137 // Get default value
3138 const void *def_value, *mesh_value;
3139 int def_val_len, mesh_val_len;
3140 rval = iFace->tag_get_default_value( tag_data.tag_id, def_value, def_val_len );
3141 if( MB_ENTITY_NOT_FOUND == rval )
3142 {
3143 def_value = 0;
3144 def_val_len = 0;
3145 }
3146 else if( MB_SUCCESS != rval )
3147 {
3148 H5Tclose( hdf_type );
3149 return error( rval );
3150 }
3151
3152 // Get mesh value
3153 unsigned char byte;
3154 const EntityHandle root = 0;
3155 if( mb_storage == MB_TAG_BIT )
3156 {
3157 rval = iFace->tag_get_data( tag_data.tag_id, &root, 1, &byte );
3158 mesh_value = &byte;
3159 mesh_val_len = 1;
3160 }
3161 else
3162 {
3163 rval = iFace->tag_get_by_ptr( tag_data.tag_id, &root, 1, &mesh_value, &mesh_val_len );
3164 }
3165 if( MB_TAG_NOT_FOUND == rval )
3166 {
3167 mesh_value = 0;
3168 mesh_val_len = 0;
3169 }
3170 else if( MB_SUCCESS != rval )
3171 {
3172 H5Tclose( hdf_type );
3173 return error( rval );
3174 }
3175
3176 // For handle-type tags, need to convert from handles to file ids
3177 if( MB_TYPE_HANDLE == mb_type )
3178 {
3179 // Make sure there's room in the buffer for both
3180 assert( ( def_val_len + mesh_val_len ) * sizeof( long ) < (size_t)bufferSize );
3181
3182 // Convert default value
3183 if( def_value )
3184 {
3185 memcpy( dataBuffer, def_value, def_val_len * sizeof( EntityHandle ) );
3186 convert_handle_tag( reinterpret_cast< EntityHandle* >( dataBuffer ), def_val_len );
3187 def_value = dataBuffer;
3188 }
3189
3190 // Convert mesh value
3191 if( mesh_value )
3192 {
3193 EntityHandle* ptr = reinterpret_cast< EntityHandle* >( dataBuffer ) + def_val_len;
3194 memcpy( ptr, mesh_value, mesh_val_len * sizeof( EntityHandle ) );
3195 if( convert_handle_tag( ptr, mesh_val_len ) )
3196 mesh_value = ptr;
3197 else
3198 mesh_value = 0;
3199 }
3200 }
3201
3202 if( MB_VARIABLE_LENGTH != tag_bytes )
3203 {
3204 // Write the tag description to the file
3205 mhdf_createTag( filePtr, tag_name.c_str(), mhdf_type, num_vals, storage, def_value, mesh_value, hdf_type,
3206 mb_type == MB_TYPE_HANDLE ? id_type : 0, &status );
3207 CHK_MHDF_ERR_0( status );
3208 H5Tclose( hdf_type );
3209
3210 // Create empty table for tag data
3211 if( num_sparse_entities )
3212 {
3213 mhdf_createSparseTagData( filePtr, tag_name.c_str(), num_sparse_entities, handles, &status );
3214 CHK_MHDF_ERR_0( status );
3215 mhdf_closeData( filePtr, handles[0], &status );
3216 mhdf_closeData( filePtr, handles[1], &status );
3217 }
3218
3219 for( size_t i = 0; i < tag_data.dense_list.size(); ++i )
3220 {
3221 const ExportSet* ex = find( tag_data.dense_list[i] );
3222 assert( 0 != ex );
3223 handles[0] = mhdf_createDenseTagData( filePtr, tag_name.c_str(), ex->name(), ex->total_num_ents, &status );
3224 CHK_MHDF_ERR_0( status );
3225 mhdf_closeData( filePtr, handles[0], &status );
3226 }
3227 }
3228 else
3229 {
3230 mhdf_createVarLenTag( filePtr, tag_name.c_str(), mhdf_type, storage, def_value, def_val_len, mesh_value,
3231 mesh_val_len, hdf_type, mb_type == MB_TYPE_HANDLE ? id_type : 0, &status );
3232 CHK_MHDF_ERR_0( status );
3233 H5Tclose( hdf_type );
3234
3235 // Create empty table for tag data
3236 if( num_sparse_entities )
3237 {
3238 mhdf_createVarLenTagData( filePtr, tag_name.c_str(), num_sparse_entities, data_table_size, handles,
3239 &status );
3240 CHK_MHDF_ERR_0( status );
3241 mhdf_closeData( filePtr, handles[0], &status );
3242 mhdf_closeData( filePtr, handles[1], &status );
3243 mhdf_closeData( filePtr, handles[2], &status );
3244 }
3245 }
3246
3247 return MB_SUCCESS;
3248 }
3249
3250 ErrorCode WriteHDF5::get_num_sparse_tagged_entities( const TagDesc& tag, size_t& count )
3251 {
3252 Range tmp;
3253 ErrorCode rval = get_sparse_tagged_entities( tag, tmp );
3254 count = tmp.size();
3255 return rval;
3256 }
3257
3258 ErrorCode WriteHDF5::get_sparse_tagged_entities( const TagDesc& tag, Range& results )
3259 {
3260 results.clear();
3261 if( !tag.have_dense( setSet ) ) results.merge( setSet.range );
3262 std::list< ExportSet >::reverse_iterator e;
3263 for( e = exportList.rbegin(); e != exportList.rend(); ++e )
3264 {
3265 if( !tag.have_dense( *e ) ) results.merge( e->range );
3266 }
3267 if( !tag.have_dense( nodeSet ) ) results.merge( nodeSet.range );
3268 if( results.empty() ) return MB_SUCCESS;
3269
3270 return iFace->get_entities_by_type_and_tag( 0, MBMAXTYPE, &tag.tag_id, 0, 1, results, Interface::INTERSECT );
3271 }
3272
3273 void WriteHDF5::get_write_entities( Range& range )
3274 {
3275 range.clear();
3276 range.merge( setSet.range );
3277 std::list< ExportSet >::reverse_iterator e;
3278 for( e = exportList.rbegin(); e != exportList.rend(); ++e )
3279 range.merge( e->range );
3280 range.merge( nodeSet.range );
3281 }
3282
3283 void WriteHDF5::print_id_map() const
3284 {
3285 print_id_map( std::cout, "" );
3286 }
3287
3288 void WriteHDF5::print_id_map( std::ostream& s, const char* pfx ) const
3289 {
3290 RangeMap< EntityHandle, wid_t >::const_iterator i;
3291 for( i = idMap.begin(); i != idMap.end(); ++i )
3292 {
3293 const char* n1 = CN::EntityTypeName( TYPE_FROM_HANDLE( i->begin ) );
3294 EntityID id = ID_FROM_HANDLE( i->begin );
3295 if( 1 == i->count )
3296 {
3297 s << pfx << n1 << " " << id << " -> " << i->value << std::endl;
3298 }
3299 else
3300 {
3301 const char* n2 = CN::EntityTypeName( TYPE_FROM_HANDLE( i->begin + i->count - 1 ) );
3302 if( n1 == n2 )
3303 {
3304 s << pfx << n1 << " " << id << "-" << id + i->count - 1 << " -> " << i->value << "-"
3305 << i->value + i->count - 1 << std::endl;
3306 }
3307 else
3308 {
3309 s << pfx << n1 << " " << id << "-" << n1 << " " << ID_FROM_HANDLE( i->begin + i->count - 1 ) << " -> "
3310 << i->value << "-" << i->value + i->count - 1 << std::endl;
3311 }
3312 }
3313 }
3314 }
3315
3316 void WriteHDF5::print_times( const double* t ) const
3317 {
3318 std::cout << "WriteHDF5: " << t[TOTAL_TIME] << std::endl
3319 << " gather mesh: " << t[GATHER_TIME] << std::endl
3320 << " create file: " << t[CREATE_TIME] << std::endl
3321 << " create nodes: " << t[CREATE_NODE_TIME] << std::endl
3322 << " negotiate types: " << t[NEGOTIATE_TYPES_TIME] << std::endl
3323 << " create elem: " << t[CREATE_ELEM_TIME] << std::endl
3324 << " file id exch: " << t[FILEID_EXCHANGE_TIME] << std::endl
3325 << " create adj: " << t[CREATE_ADJ_TIME] << std::endl
3326 << " create set: " << t[CREATE_SET_TIME] << std::endl
3327 << " shared ids: " << t[SHARED_SET_IDS] << std::endl
3328 << " shared data: " << t[SHARED_SET_CONTENTS] << std::endl
3329 << " set offsets: " << t[SET_OFFSET_TIME] << std::endl
3330 << " create tags: " << t[CREATE_TAG_TIME] << std::endl
3331 << " coordinates: " << t[COORD_TIME] << std::endl
3332 << " connectivity: " << t[CONN_TIME] << std::endl
3333 << " sets: " << t[SET_TIME] << std::endl
3334 << " set descrip: " << t[SET_META] << std::endl
3335 << " set content: " << t[SET_CONTENT] << std::endl
3336 << " set parent: " << t[SET_PARENT] << std::endl
3337 << " set child: " << t[SET_CHILD] << std::endl
3338 << " adjacencies: " << t[ADJ_TIME] << std::endl
3339 << " tags: " << t[TAG_TIME] << std::endl
3340 << " dense data: " << t[DENSE_TAG_TIME] << std::endl
3341 << " sparse data: " << t[SPARSE_TAG_TIME] << std::endl
3342 << " var-len data: " << t[VARLEN_TAG_TIME] << std::endl;
3343 }
3344
3345 } // namespace moab
1.9.1.