 |
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 #ifndef MOAB_IMPL_GENERAL_HPP
17 #define MOAB_IMPL_GENERAL_HPP
18
19 #include "moab/Interface.hpp"
20 #include "moab/ReaderIface.hpp"
21 #include <map>
22 #include <list>
23
24 namespace moab
25 {
26
27 class WriteUtil;
28 class ReadUtil;
29 class ScdInterface;
30 class AEntityFactory;
31 class SequenceManager;
32 class Error;
33 class HomCoord;
34 class ReaderWriterSet;
35 class EntitySequence;
36 class FileOptions;
37 class SetIterator;
38
39 #ifdef MOAB_HAVE_AHF
40 class HalfFacetRep;
41 #endif
42
43 /**\class Core
44 * \brief Implementation of MOAB Interface
45 * Implementation of the MOAB Interface class. You shouldn't call functions directly
46 * on an object of type Core (use Interface instead), unless you really have to access
47 * non-API functionality.
48 */
49 class Core : public Interface
50 {
51
52 public:
53 friend class SetIterator;
54
55 //! constructor
56 Core();
57
58 //! destructor
59 ~Core();
60
61 //! Get a pointer to an internal MOAB interface
62 //!\return NULL if not found, iterface pointer otherwise
63 virtual ErrorCode query_interface_type( const std::type_info& interface_type, void*& ptr );
64
65 //! Release reference to MB interface
66 virtual ErrorCode release_interface_type( const std::type_info& interface_type, void* iface );
67
68 virtual int QueryInterface( const MBuuid& uuid, UnknownInterface** iface );
69
70 //! Returns the major.minor version number of the implementation
71 /**
72 \param iface_name If non-NULL, will be filled in with a string, possibly
73 containing implementation-specific information
74 */
75 virtual float impl_version( std::string* version_string = NULL );
76
77 //! get the type from a handle, returns type
78 virtual EntityType type_from_handle( const EntityHandle handle ) const;
79
80 //! get the id from a handle, returns id
81 virtual EntityID id_from_handle( const EntityHandle handle ) const;
82
83 //! get a handle from an id and type
84 virtual ErrorCode handle_from_id( const EntityType type, const EntityID id, EntityHandle& handle ) const;
85
86 virtual int dimension_from_handle( const EntityHandle ) const;
87
88 //! load mesh from data in file
89 //! NOTE: if there is mesh already present, the new mesh will be added
90 virtual ErrorCode load_mesh( const char* file_name,
91 const int* active_block_id_list = NULL,
92 const int num_blocks = 0 );
93
94 /**Load or import a file. */
95 virtual ErrorCode load_file( const char* file_name,
96 const EntityHandle* file_set = 0,
97 const char* options = 0,
98 const char* set_tag_name = 0,
99 const int* set_tag_vals = 0,
100 int num_set_tag_vals = 0 );
101
102 /**Load or import a file. */
103 ErrorCode serial_load_file( const char* file_name,
104 const EntityHandle* file_set,
105 const FileOptions& opts,
106 const ReaderIface::SubsetList* subsets = 0,
107 const Tag* file_id_tag = 0 );
108
109 ErrorCode serial_read_tag( const char* file_name,
110 const char* tag_name,
111 const FileOptions& opts,
112 std::vector< int >& tag_vals,
113 const ReaderIface::SubsetList* subsets = 0 );
114
115 virtual ErrorCode write_mesh( const char* file_name,
116 const EntityHandle* output_list = NULL,
117 const int num_sets = 0 );
118 /** Write or export a file. */
119 virtual ErrorCode write_file( const char* file_name,
120 const char* file_type = 0,
121 const char* options = 0,
122 const EntityHandle* output_sets = 0,
123 int num_output_sets = 0,
124 const Tag* tag_list = 0,
125 int num_tags = 0 );
126
127 /** Write or export a file */
128 virtual ErrorCode write_file( const char* file_name,
129 const char* file_type,
130 const char* options,
131 const Range& output_sets,
132 const Tag* tag_list = 0,
133 int num_tags = 0 );
134
135 //! deletes all mesh entities from this datastore
136 virtual ErrorCode delete_mesh();
137
138 //! get overall geometric dimension
139 virtual ErrorCode get_dimension( int& dim ) const;
140
141 //! set overall geometric dimension
142 /** Returns error if setting to 3 dimensions, mesh has been created, and
143 * there are only 2 dimensions on that mesh
144 */
145 virtual ErrorCode set_dimension( const int dim );
146
147 //! get blocked vertex coordinates for all vertices
148 /** Blocked = all x, then all y, etc.
149 */
150 virtual ErrorCode get_vertex_coordinates( std::vector< double >& coords ) const;
151
152 //! get pointers to coordinate data
153 virtual ErrorCode coords_iterate( Range::const_iterator iter,
154 Range::const_iterator end,
155 double*& xcoords_ptr,
156 double*& ycoords_ptr,
157 double*& zcoords_ptr,
158 int& count );
159
160 //! get the coordinate information for this handle if it is of type Vertex
161 //! otherwise, return an error
162 virtual ErrorCode get_coords( const Range& entities, double* coords ) const;
163
164 virtual ErrorCode get_coords( const EntityHandle* entities, const int num_entities, double* coords ) const;
165
166 virtual ErrorCode get_coords( const EntityHandle entity_handle,
167 const double*& x,
168 const double*& y,
169 const double*& z ) const;
170
171 virtual ErrorCode get_coords( const Range& entities, double* x_coords, double* y_coords, double* z_coords ) const;
172
173 //! set the coordinate information for this handle if it is of type Vertex
174 //! otherwise, return an error
175 virtual ErrorCode set_coords( const EntityHandle* entity_handles, const int num_entities, const double* coords );
176
177 //! set the coordinate information for this handle if it is of type Vertex
178 //! otherwise, return an error
179 virtual ErrorCode set_coords( Range entity_handles, const double* coords );
180
181 //! get global connectivity array for specified entity type
182 /** Assumes just vertices, no higher order nodes
183 */
184 virtual ErrorCode get_connectivity_by_type( const EntityType type, std::vector< EntityHandle >& connect ) const;
185
186 //! get pointer to connectivity data
187 virtual ErrorCode connect_iterate( Range::const_iterator iter,
188 Range::const_iterator end,
189 EntityHandle*& connect,
190 int& verts_per_entity,
191 int& count );
192
193 //! Gets the connectivity for an element EntityHandle.
194 /** For non-element handles (ie, MeshSets),
195 * returns an error. Connectivity data is copied from the database into the vector
196 * <em>connectivity</em>. The nodes in <em>connectivity</em> are properly ordered.
197 * \param entity_handle EntityHandle to get connectivity of.
198 * \param connectivity Vector in which connectivity of <em>entity_handle</em> is returned.
199 * Should contain MeshVertices.
200 * \param corners_only If true, returns only corner vertices, otherwise returns all of them
201 * (including any higher-order vertices)
202 *
203 * Example: \code
204 * std::vector<EntityHandle> conn;
205 * get_connectivity( entity_handle, conn ); \endcode
206 */
207 virtual ErrorCode get_connectivity( const EntityHandle* entity_handles,
208 const int num_handles,
209 std::vector< EntityHandle >& connectivity,
210 bool corners_only = false,
211 std::vector< int >* offsets = NULL ) const;
212
213 //! Gets the connectivity for a vector of elements
214 /** Same as vector-based version except range is returned (unordered!)
215 */
216 virtual ErrorCode get_connectivity( const EntityHandle* entity_handles,
217 const int num_handles,
218 Range& connectivity,
219 bool corners_only = false ) const;
220
221 //! Gets the connectivity for elements
222 /** Same as vector-based version except range is returned (unordered!)
223 */
224 virtual ErrorCode get_connectivity( const Range& from_entities,
225 Range& adj_entities,
226 bool corners_only = false ) const;
227
228 //! Gets a pointer to constant connectivity data of <em>entity_handle</em>
229 /** Sets <em>number_nodes</em> equal to the number of nodes of the <em>
230 entity_handle </em>. Faster then the other <em>get_connectivity</em> function.
231 The nodes in 'connectivity' are properly ordered.
232 \param entity_handle EntityHandle to get connectivity of.
233 \param connectivity Array in which connectivity of <em>entity_handle</em> is returned.
234 Should contain MBVERTEX's.
235 \param num_nodes Number of MeshVertices in array <em>connectivity</em>.
236
237 Example: \code
238 const EntityHandle* conn;
239 int number_nodes = 0;
240 get_connectivity( entity_handle, conn, number_nodes ); \endcode
241
242 Example2: \code
243 std::vector<EntityHandle> sm_storage;
244 const EntityHandle* conn;
245 int number_nodes;
246 get_connectivity( handle, conn, number_nodes, false, &sm_storage );
247 if (conn == &sm_storage[0])
248 std::cout << "Structured mesh element" << std::endl;
249 \endcode
250 */
251 virtual ErrorCode get_connectivity( const EntityHandle entity_handle,
252 const EntityHandle*& connectivity,
253 int& number_nodes,
254 bool corners_only = false,
255 std::vector< EntityHandle >* storage = 0 ) const;
256
257 //! Sets the connectivity for an EntityHandle. For non-element handles, return an error.
258 /** Connectivity is stored exactly as it is ordered in vector <em>connectivity</em>.
259 \param entity_handle EntityHandle to set connectivity of.
260 \param connect Vector containing new connectivity of <em>entity_handle</em>.
261 \param num_connect Number of vertices in <em>connect</em>
262
263 Example: \code
264 std::vector<EntityHandle> conn(3);
265 conn[0] = node1;
266 conn[1] = node2;
267 conn[2] = node3;
268 set_connectivity( entity_handle, conn, 3 ); \endcode */
269 virtual ErrorCode set_connectivity( const EntityHandle entity_handle,
270 EntityHandle* connect,
271 const int num_connect );
272
273 //! get the adjacencies associated with a set of entities
274 /** \param from_entities vector of EntityHandle to get adjacencies of.
275 \param to_dimension Dimension of desired adjacency information.
276 \param adj_entities Vector in which adjacent EntityHandles are returned.
277 \param operation_type enum of INTERSECT or UNION. Defines whether to take
278 the intersection or union of the set of adjacencies recovered for the from_entities.
279
280 The adjacent entities in vector <em>adjacencies</em> are not in any particular
281 order.
282
283 Example: \code
284 // get the set of edges that are adjacent to all entities in the from_entities list
285 std::vector<EntityHandle> from_entities = {hex1, hex2};
286 std::vector<EntityHandle> adjacencies;
287 get_adjacencies( from_entities, MB_1D_ENTITY, adjacencies );
288 \endcode */
289
290 virtual ErrorCode get_adjacencies( const EntityHandle* from_entities,
291 const int num_entities,
292 const int to_dimension,
293 const bool create_if_missing,
294 std::vector< EntityHandle >& adj_entities,
295 const int operation_type = Interface::INTERSECT );
296
297 virtual ErrorCode get_adjacencies( const EntityHandle* from_entities,
298 const int num_entities,
299 const int to_dimension,
300 const bool create_if_missing,
301 Range& adj_entities,
302 const int operation_type = Interface::INTERSECT );
303
304 virtual ErrorCode get_adjacencies( const Range& from_entities,
305 const int to_dimension,
306 const bool create_if_missing,
307 Range& adj_entities,
308 const int operation_type = Interface::INTERSECT );
309
310 /**\brief Get a ptr to adjacency lists
311 * Get a pointer to adjacency lists. These lists are std::vector<EntityHandle>, which are
312 * pointed to by adjs[i]. Adjacencies are not guaranteed to be in order of increasing
313 * dimension. Only a const version of this function is given, because adjacency data is managed
314 * more carefully in MOAB and should be treated as read-only by applications. If adjacencies
315 * have not yet been initialized, adjs_ptr will be NULL (i.e. adjs_ptr == NULL). There may also
316 * be NULL entries for individual entities, i.e. adjs_ptr[i] == NULL. \param iter Iterator to
317 * beginning of entity range desired \param end End iterator for which adjacencies are requested
318 * \param adjs_ptr Pointer to pointer to const std::vector<EntityHandle>; each member of that
319 * array is the vector of adjacencies for this entity \param count Number of entities in the
320 * contiguous chunk starting from *iter
321 */
322 ErrorCode adjacencies_iterate( Range::const_iterator iter,
323 Range::const_iterator end,
324 const std::vector< EntityHandle >**& adjs_ptr,
325 int& count );
326
327 /**\brief Get all vertices for input entities
328 *
329 * Special case of get_adjacencies where to_dimension == 0
330 * and operation_type == Interface::UNION.
331 *\Note This is not a variation of get_connectivity because
332 * the behavior is different for polyhedra.
333 */
334 virtual ErrorCode get_vertices( const Range& from_entities, Range& vertices );
335
336 //! Adds adjacencies
337 /** \param from_handle entities
338 \param both_ways add the adjacency information to both the
339 to_handle and and the from_from :handle
340
341 Example: \code
342 */
343 virtual ErrorCode add_adjacencies( const EntityHandle entity_handle,
344 const EntityHandle* adjacencies,
345 const int num_handles,
346 bool both_ways );
347
348 //! Adds adjacencies; same as vector-based, but with range instead
349 virtual ErrorCode add_adjacencies( const EntityHandle entity_handle, Range& adjacencies, bool both_ways );
350
351 //! Removes adjacencies
352 /** \param handle EntityHandle to get adjacencies of.
353
354 Example: \code
355 */
356 virtual ErrorCode remove_adjacencies( const EntityHandle entity_handle,
357 const EntityHandle* adjacencies,
358 const int num_handles );
359
360 //! Retrieves all entities in the database of given dimension.
361 /** \param dimension Dimension of entities desired.
362 \param entities Range in which entities of dimension <em>dimension</em> are returned.
363
364 Example: \code
365 int dimension = 2;
366 Range entities;
367 get_entities_by_dimension( dimension, entities ); //get 2D EntityHandles in the database
368 \endcode */
369 virtual ErrorCode get_entities_by_dimension( const EntityHandle meshset,
370 const int dimension,
371 Range& entities,
372 const bool recursive = false ) const;
373
374 virtual ErrorCode get_entities_by_dimension( const EntityHandle meshset,
375 const int dimension,
376 std::vector< EntityHandle >& entities,
377 const bool recursive = false ) const;
378
379 //! Retrieves all entities in the data base of given type.
380 /** \param type EntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc )
381 \param entities Range in which entities of EntityType <em>type</em> are returned.
382
383 Example: \code
384 EntityType type = MBTET;
385 Range entities;
386 get_entities_by_dimension( type, entities ); //get MBTET type EntityHandles in the database
387 \endcode */
388 virtual ErrorCode get_entities_by_type( const EntityHandle meshset,
389 const EntityType type,
390 Range& entities,
391 const bool recursive = false ) const;
392
393 //! Retrieves all entities in the data base of given type.
394 /** \param type EntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc )
395 \param entities Range in which entities of EntityType <em>type</em> are returned.
396
397 Example: \code
398 EntityType type = MBTET;
399 Range entities;
400 get_entities_by_dimension( type, entities ); //get MBTET type EntityHandles in the database
401 \endcode */
402 virtual ErrorCode get_entities_by_type( const EntityHandle meshset,
403 const EntityType type,
404 std::vector< EntityHandle >& entities,
405 const bool recursive = false ) const;
406
407 virtual ErrorCode get_entities_by_type_and_tag( const EntityHandle meshset,
408 const EntityType type,
409 const Tag* tags,
410 const void* const* values,
411 const int num_tags,
412 Range& entities,
413 const int condition = Interface::INTERSECT,
414 const bool recursive = false ) const;
415
416 //! Retrieves all entities in the data base
417 /** \param entities Range in which entities of EntityType <em>type</em> are returned.
418
419 Example: \code
420 Range entities;
421 get_entities( entities ); //get MBTET type EntityHandles in the database
422 \endcode */
423 virtual ErrorCode get_entities_by_handle( const EntityHandle meshset,
424 Range& entities,
425 const bool recursive = false ) const;
426
427 //! Retrieves all entities in the data base
428 /** \param entities Range in which entities of EntityType <em>type</em> are returned.
429
430 Example: \code
431 Range entities;
432 get_entities( entities ); //get MBTET type EntityHandles in the database
433 \endcode */
434 virtual ErrorCode get_entities_by_handle( const EntityHandle meshset,
435 std::vector< EntityHandle >& entities,
436 const bool recursive = false ) const;
437
438 //! Retrieves all entities in the database of given dimension.
439 /** \param dimension Dimension of entities desired.
440 \param entities Range in which entities of dimension <em>dimension</em> are returned.
441
442 Example: \code
443 int dimension = 2;
444 Range entities;
445 get_entities_by_dimension( dimension, entities ); //get 2D EntityHandles in the database
446 \endcode */
447 virtual ErrorCode get_number_entities_by_dimension( const EntityHandle meshset,
448 const int dimension,
449 int& number,
450 const bool recursive = false ) const;
451
452 //! Retrieves all entities in the data base of given type.
453 /** \param type EntityType of entities desired (ie, MBHEX, MBEDGE, MBTRI, etc )
454 \param entities Range in which entities of EntityType <em>type</em> are returned.
455
456 Example: \code
457 EntityType type = MBTET;
458 Range entities;
459 get_entities_by_dimension( type, entities ); //get MBTET type EntityHandles in the database
460 \endcode */
461 virtual ErrorCode get_number_entities_by_type( const EntityHandle meshset,
462 const EntityType type,
463 int& num_entities,
464 const bool recursive = false ) const;
465
466 virtual ErrorCode get_number_entities_by_type_and_tag( const EntityHandle meshset,
467 const EntityType type,
468 const Tag* tag_handles,
469 const void* const* values,
470 const int num_tags,
471 int& num_entities,
472 const int condition = Interface::INTERSECT,
473 const bool recursive = false ) const;
474
475 //! Retrieves all entities in the data base
476 /** \param entities Range in which entities of EntityType <em>type</em> are returned.
477
478 Example: \code
479 Range entities;
480 get_entities( entities ); //get MBTET type EntityHandles in the database
481 \endcode */
482 virtual ErrorCode get_number_entities_by_handle( const EntityHandle meshset,
483 int& num_entities,
484 const bool recursive = false ) const;
485
486 //! Creates an element based on the type and connectivity.
487 /** If connectivity vector is not correct for EntityType <em>type</em> (ie, a vector with
488 3 vertices is passed in to make an MBQUAD), the function returns MB_FAILURE.
489 \param type Type of element to create. (MBTET, MBTRI, MBKNIFE, etc.)
490 \param connectivity Vector containing connectivity of element to create.
491 \param handle EntityHandle representing the newly created element in the database.
492
493 Example: \code
494 EntityType type = MBQUAD;
495 std::vector<EntityHandle> connectivity(4);
496 quad_conn[0] = vertex0;
497 quad_conn[1] = vertex1;
498 quad_conn[2] = vertex2;
499 quad_conn[3] = vertex3;
500 EntityHandle element_handle;
501 create_element( type, connectivity, element_handle ); \endcode */
502 virtual ErrorCode create_element( const EntityType type,
503 const EntityHandle* connectivity,
504 const int num_nodes,
505 EntityHandle& element_handle );
506
507 //! Creates a vertex based on coordinates.
508 /**
509 \param coordinates Array that has 3 doubles in it.
510 \param entity_handle EntityHandle representing the newly created vertex in the database.
511
512 Example: \code
513 double *coordinates = double[3];
514 coordinates[0] = 1.034;
515 coordinates[1] = 23.23;
516 coordinates[2] = -0.432;
517 EntityHandle entity_handle = 0;
518 create_vertex( coordinates, entity_handle ); \endcode */
519 virtual ErrorCode create_vertex( const double coords[3], EntityHandle& entity_handle );
520
521 //! Create a set of vertices with the specified coordinates
522 /**
523 \param coordinates Array that has 3*n doubles in it.
524 \param nverts Number of vertices to create
525 \param entity_handles Range passed back with new vertex handles
526 */
527 virtual ErrorCode create_vertices( const double* coordinates, const int nverts, Range& entity_handles );
528
529 //! merges two entities
530 virtual ErrorCode merge_entities( EntityHandle entity_to_keep,
531 EntityHandle entity_to_remove,
532 bool auto_merge,
533 bool delete_removed_entity );
534
535 //! Removes entities in a vector from the data base.
536 /** If any of the entities are contained in any meshsets, it is removed from those meshsets
537 which were created with MESHSET_TRACK_OWNER option bit set. Tags for <em>entity<\em> are
538 removed as part of this function.
539 \param entities 1d vector of entities to delete
540 \param num_entities Number of entities in 1d vector
541 */
542 virtual ErrorCode delete_entities( const EntityHandle* entities, const int num_entities );
543
544 //! Removes entities in a range from the data base.
545 /** If any of the entities are contained in any meshsets, it is removed from those meshsets
546 which were created with MESHSET_TRACK_OWNER option bit set. Tags for <em>entity<\em> are
547 removed as part of this function.
548 \param entities Range of entities to delete
549 */
550 virtual ErrorCode delete_entities( const Range& range );
551
552 virtual ErrorCode list_entities( const Range& temp_range ) const;
553
554 virtual ErrorCode list_entities( const EntityHandle* entities, const int num_entities ) const;
555
556 virtual ErrorCode list_entity( const EntityHandle entity ) const;
557
558 typedef unsigned long long type_memstorage;
559
560 //! function object for recieving events from MB of higher order nodes
561 //! added to entities
562 class HONodeAddedRemoved
563 {
564 public:
565 HONodeAddedRemoved() {}
566 virtual ~HONodeAddedRemoved() {}
567 //! node_added called when a node was added to an element's connectivity array
568 //! note: connectivity array of element may be incomplete (corner nodes will exist always)
569 virtual void node_added( EntityHandle node, EntityHandle element );
570 virtual void node_removed( EntityHandle node );
571 };
572
573 virtual ErrorCode convert_entities( const EntityHandle meshset,
574 const bool mid_side,
575 const bool mid_face,
576 const bool mid_volume,
577 Interface::HONodeAddedRemoved* function_object = 0 );
578
579 //! function to get the side number given two elements; returns
580 //! MB_FAILURE if child not related to parent; does *not* create adjacencies
581 //! between parent and child
582 virtual ErrorCode side_number( const EntityHandle parent,
583 const EntityHandle child,
584 int& sd_number,
585 int& sense,
586 int& offset ) const;
587
588 //! given an entity and the connectivity and type of one of its subfacets, find the
589 //! high order node on that subfacet, if any
590 virtual ErrorCode high_order_node( const EntityHandle parent_handle,
591 const EntityHandle* subfacet_conn,
592 const EntityType subfacet_type,
593 EntityHandle& hon ) const;
594
595 //! given an entity and a target dimension & side number, get that entity
596 virtual ErrorCode side_element( const EntityHandle source_entity,
597 const int dim,
598 const int sd_number,
599 EntityHandle& target_entity ) const;
600
601 //-------------------------Tag Stuff-------------------------------------//
602
603 /**\brief Get a tag handle, possibly creating the tag
604 *
605 * Get a handle used to associate application-defined values
606 * with MOAB entities. If the tag does not already exist then
607 * \c flags should contain exactly one of \c MB_TAG_SPARSE,
608 * \c MB_TAG_DENSE, \c MB_TAG_MESH unless \c type is MB_TYPE_BIT,
609 * which implies \c MB_TAG_BIT storage.
610 * .
611 *\param name The tag name
612 *\param size Tag size as number of values of of data type per entity
613 * (or number of bytes if \c MB_TAG_BYTES is passed in flags). If \c
614 *MB_TAG_VARLEN is specified, this value is taken to be the size of the default value if one is
615 *specified and is otherwise ignored. \param type The type of the data (used for IO)
616 *\param tag_handle Output: the resulting tag handle.
617 *\param flags Bitwise OR of values from \c TagType
618 *\param default_value Optional default value for tag.
619 *\param created Optional returned boolean indicating that the tag
620 * was created.
621 *\return - \c MB_ALREADY_ALLOCATED if tag exists and \c MB_TAG_EXCL is specified, or
622 *default values do not match (and \c MB_TAG_ANY or \c MB_TAG_DFTOK not specified).
623 * - \c MB_TAG_NOT_FOUND if tag does not exist and \c MB_TAG_CREAT is not
624 *specified
625 * - \c MB_INVALID_SIZE if tag value size is not a multiple of the size of the
626 *data type (and \c MB_TAG_ANY not specified).
627 * - \c MB_TYPE_OUT_OF_RANGE invalid or inconsistent parameter
628 * - \c MB_VARIABLE_DATA_LENGTH if \c MB_TAG_VARLEN and \c default_value is non-null and
629 * \c default_value_size is not specified.
630 */
631 virtual ErrorCode tag_get_handle( const char* name,
632 int size,
633 DataType type,
634 Tag& tag_handle,
635 unsigned flags = 0,
636 const void* default_value = 0,
637 bool* created = 0 );
638
639 /**\brief same as non-const version, except that TAG_CREAT flag is ignored. */
640 virtual ErrorCode tag_get_handle( const char* name,
641 int size,
642 DataType type,
643 Tag& tag_handle,
644 unsigned flags = 0,
645 const void* default_value = 0 ) const;
646
647 //! Gets the tag name string of the tag_handle.
648 /** \param tag_handle Tag you want the name of.
649 \param tag_name Name string of <em>tag_handle</em>.
650
651 Example: \code
652 Tag tag_handle = 0;
653 std::string tag_name = "my_special_tag";
654 tag_get_name( tag_handle, tag_name ); //gets the Tag from the tag's name string
655 \endcode */
656 virtual ErrorCode tag_get_name( const Tag tag_handle, std::string& tag_name ) const;
657
658 /**\brief Gets the tag handle corresponding to a name
659 *
660 * If a tag of that name does not exist, returns MB_TAG_NOT_FOUND
661 * \param tag_name Name of the desired tag.
662 * \param tag_handle Tag handle corresponding to <em>tag_name</em>
663 */
664 virtual ErrorCode tag_get_handle( const char* tag_name, Tag& tag_handle ) const;
665
666 //! Get handles for all tags defined on this entity
667 virtual ErrorCode tag_get_tags_on_entity( const EntityHandle entity, std::vector< Tag >& tag_handles ) const;
668
669 //! Get the size of the specified tag in bytes
670 virtual ErrorCode tag_get_bytes( const Tag tag, int& tag_size ) const;
671
672 //! Get the array length of a tag
673 virtual ErrorCode tag_get_length( const Tag tag, int& tag_size ) const;
674
675 //! Get the default value of the specified tag
676 virtual ErrorCode tag_get_default_value( const Tag tag, void* def_val ) const;
677 virtual ErrorCode tag_get_default_value( Tag tag, const void*& ptr, int& size ) const;
678
679 //! get type of tag (sparse, dense, etc.; 0 = dense, 1 = sparse, 2 = bit, 3 = mesh)
680 virtual ErrorCode tag_get_type( const Tag, TagType& tag_type ) const;
681
682 /** \brief Get data type of tag.
683 *
684 * Get the type of the tag data. The tag is data is assumed to
685 * be a vector of this type. If the tag data vetcor contains
686 * more than one value, then the tag size must be a multiple of
687 * the size of this type.
688 * \param tag The tag
689 * \param type The type of the specified tag (output).
690 */
691 virtual ErrorCode tag_get_data_type( const Tag handle, DataType& type ) const;
692
693 //! get handles for all tags defined
694 virtual ErrorCode tag_get_tags( std::vector< Tag >& tag_handles ) const;
695
696 virtual ErrorCode tag_get_data( const Tag tag_handle,
697 const EntityHandle* entity_handles,
698 const int num_entities,
699 void* tag_data ) const;
700
701 virtual ErrorCode tag_get_data( const Tag tag_handle, const Range& entity_handles, void* tag_data ) const;
702
703 //! Sets the data of a given EntityHandle and Tag.
704 /** If the <em>tag_handle</em> and the entity type of <em>entity_handle</em> are not
705 compatible, data of <em>entity_handle</em> never existed and MB_FAILURE
706 is returned.
707 \param tag_handle Tag indicating what data is to be set.
708 \param entity_handle EntityHandle on which to set tag's data.
709 \param tag_data Data to set the <em>entity_handle</em>'s tag data to.
710
711 Example: \code
712 int tag_data = 1004;
713 tag_set_data( tag_handle, entity_handle, &tag_data ); \endcode */
714 virtual ErrorCode tag_set_data( Tag tag_handle,
715 const EntityHandle* entity_handles,
716 int num_entities,
717 const void* tag_data );
718
719 virtual ErrorCode tag_set_data( Tag tag_handle, const Range& entity_handles, const void* tag_data );
720
721 /**\brief Get pointers to tag data
722 *
723 * For a tag, get the values for a list of passed entity handles.
724 *\note This function may not be used for bit tags.
725 *\param tag_handle The tag
726 *\param entity_handles An array of entity handles for which to retreive tag values.
727 *\param num_entities The length of the 'entity_handles' array.
728 *\param tag_data An array of 'const void*'. Array must be at least
729 * 'num_entitities' long. Array is populated (output)
730 * with pointers to the internal storage for the
731 * tag value corresponding to each entity handle.
732 *\param tag_sizes The length of each tag value. Optional for
733 * fixed-length tags. Required for variable-length tags.
734 */
735 virtual ErrorCode tag_get_by_ptr( const Tag tag_handle,
736 const EntityHandle* entity_handles,
737 int num_entities,
738 const void** tag_data,
739 int* tag_sizes = 0 ) const;
740
741 /**\brief Get pointers to tag data
742 *
743 * For a tag, get the values for a list of passed entity handles.
744 *\note This function may not be used for bit tags.
745 *\param tag_handle The tag
746 *\param entity_handles The entity handles for which to retreive tag values.
747 *\param tag_data An array of 'const void*'. Array is populated (output)
748 * with pointers to the internal storage for the
749 * tag value corresponding to each entity handle.
750 *\param tag_sizes The length of each tag value. Optional for
751 * fixed-length tags. Required for variable-length tags.
752 */
753 virtual ErrorCode tag_get_by_ptr( const Tag tag_handle,
754 const Range& entity_handles,
755 const void** tag_data,
756 int* tag_sizes = 0 ) const;
757
758 /**\brief Set tag data given an array of pointers to tag values.
759 *
760 * For a tag, set the values for a list of passed entity handles.
761 *\note This function may not be used for bit tags.
762 *\param tag_handle The tag
763 *\param entity_handles An array of entity handles for which to set tag values.
764 *\param num_entities The length of the 'entity_handles' array.
765 *\param tag_data An array of 'const void*'. Array must be at least
766 * 'num_entitities' long. Array is expected to
767 * contain pointers to tag values for the corresponding
768 * EntityHandle in 'entity_handles'.
769 *\param tag_sizes The length of each tag value. Optional for
770 * fixed-length tags. Required for variable-length tags.
771 */
772 virtual ErrorCode tag_set_by_ptr( Tag tag_handle,
773 const EntityHandle* entity_handles,
774 int num_entities,
775 void const* const* tag_data,
776 const int* tag_sizes = 0 );
777
778 /**\brief Set tag data given an array of pointers to tag values.
779 *
780 * For a tag, set the values for a list of passed entity handles.
781 *\note This function may not be used for bit tags.
782 *\param tag_handle The tag
783 *\param entity_handles The entity handles for which to set tag values.
784 *\param tag_data An array of 'const void*'. Array is expected to
785 * contain pointers to tag values for the corresponding
786 * EntityHandle in 'entity_handles'.
787 *\param tag_sizes The length of each tag value. Optional for
788 * fixed-length tags. Required for variable-length tags.
789 */
790 virtual ErrorCode tag_set_by_ptr( Tag tag_handle,
791 const Range& entity_handles,
792 void const* const* tag_data,
793 const int* tag_sizes = 0 );
794
795 /**\brief Set tag data given value.
796 *
797 * For a tag, set the values for a list of passed entity handles to
798 * the same, specified value.
799 *
800 *\param tag_handle The tag
801 *\param entity_handles The entity handles for which to set tag values.
802 *\param tag_data A pointer to the tag value.
803 *\param tag_sizes For variable-length tags, the lenght of the
804 * tag value. This argument will be ignored for
805 * fixed-length tags.
806 */
807 virtual ErrorCode tag_clear_data( Tag tag_handle,
808 const Range& entity_handles,
809 const void* tag_data,
810 int tag_size = 0 );
811
812 /**\brief Set tag data given value.
813 *
814 * For a tag, set the values for a list of passed entity handles to
815 * the same, specified value.
816 *
817 *\param tag_handle The tag
818 *\param entity_handles The entity handles for which to set tag values.
819 *\param tag_data A pointer to the tag value.
820 *\param tag_sizes For variable-length tags, the lenght of the
821 * tag value. This argument will be ignored for
822 * fixed-length tags.
823 */
824 virtual ErrorCode tag_clear_data( Tag tag_handle,
825 const EntityHandle* entity_handles,
826 int num_entities,
827 const void* tag_data,
828 int tag_size = 0 );
829
830 //! Delete the data of a vector of entity handles and sparse tag
831 /** Delete the data of a tag on a vector of entity handles. Only sparse tag data are deleted
832 with this function; dense tags are deleted by deleting the tag itself using tag_delete.
833 \param tag_handle Handle of the (sparse) tag being deleted from entity
834 \param entity_handles 1d vector of entity handles from which the tag is being deleted
835 \param num_handles Number of entity handles in 1d vector
836 */
837 virtual ErrorCode tag_delete_data( Tag tag_handle, const EntityHandle* entity_handles, int num_entities );
838
839 //! Delete the data of a range of entity handles and sparse tag
840 /** Delete the data of a tag on a range of entity handles. Only sparse tag data are deleted
841 with this function; dense tags are deleted by deleting the tag itself using tag_delete.
842 \param tag_handle Handle of the (sparse) tag being deleted from entity
843 \param entity_range Range of entities from which the tag is being deleted
844 */
845 virtual ErrorCode tag_delete_data( Tag tag_handle, const Range& entity_handles );
846
847 //! Removes the tag from the database and deletes all of its associated data.
848 virtual ErrorCode tag_delete( Tag tag_handle );
849
850 /**\brief Access tag data via direct pointer into contiguous blocks
851 *
852 * Iteratively obtain direct access to contiguous blocks of tag
853 * storage. This function cannot be used with bit tags because
854 * of the compressed bit storage. This function cannot be used
855 * with variable length tags because it does not provide a mechanism
856 * to determine the length of the value for each entity. This
857 * function may be used with sparse tags, but if it is used, it
858 * will return data for a single entity at a time.
859 *
860 *\param tag_handle The handle of the tag for which to access data
861 *\param iter The first entity for which to return data.
862 *\param end One past the last entity for which data is desired.
863 *\param count The number of entities for which data was returned
864 *\param data_ptr Output: pointer to tag storage.
865 *\param allocate If true, space for this tag will be allocated, if not it wont
866 *
867 *\Note If this function is called for entities for which no tag value
868 * has been set, but for which a default value exists, it will
869 * force the allocation of explicit storage for each such entity
870 * even though MOAB would normally not explicitly store tag values
871 * for such entities.
872 *
873 *\Example:
874 *\code
875 * Range ents; // range to iterate over
876 * Tag tag; // tag for which to access data
877 * int bytes;
878 * ErrorCode err = mb.tag_get_size( tag, bytes );
879 * if (err) { ... }
880 *
881 * ...
882 * Range::iterator iter = ents.begin();
883 * while (iter != ents.end()) {
884 * int count;
885 * // get contiguous block of tag dat
886 * void* ptr;
887 * err = mb.tag_iterate( tag, iter, ents.end(), count, ptr );
888 * if (err) { ... }
889 * // do something with tag data
890 * process_Data( ptr, count );
891 * // advance to next block of data
892 * iter += count;
893 * }
894 *\endcode
895 */
896 virtual ErrorCode tag_iterate( Tag tag_handle,
897 Range::const_iterator iter,
898 Range::const_iterator end,
899 int& count,
900 void*& data_ptr,
901 bool allocate = true );
902
903 //! creates a mesh set
904 virtual ErrorCode create_meshset( const unsigned int options, EntityHandle& ms_handle, int start_id = 0 );
905
906 //! Empty a vector of mesh set
907 /** Empty a mesh set.
908 \param ms_handles 1d vector of handles of sets being emptied
909 \param num_meshsets Number of entities in 1d vector
910 */
911 virtual ErrorCode clear_meshset( const EntityHandle* ms_handles, const int num_meshsets );
912
913 //! Empty a range of mesh set
914 /** Empty a mesh set.
915 \param ms_handles Range of handles of sets being emptied
916 */
917 virtual ErrorCode clear_meshset( const Range& ms_handles );
918
919 //! get the options of a mesh set
920 virtual ErrorCode get_meshset_options( const EntityHandle ms_handle, unsigned int& options ) const;
921
922 //! set the options of a mesh set
923 virtual ErrorCode set_meshset_options( const EntityHandle ms_handle, const unsigned int options );
924
925 //! subtracts meshset2 from meshset1 - modifies meshset1
926 virtual ErrorCode subtract_meshset( EntityHandle meshset1, const EntityHandle meshset2 );
927
928 //! intersects meshset2 with meshset1 - modifies meshset1
929 virtual ErrorCode intersect_meshset( EntityHandle meshset1, const EntityHandle meshset2 );
930
931 //! unites meshset2 with meshset1 - modifies meshset1
932 virtual ErrorCode unite_meshset( EntityHandle meshset1, const EntityHandle meshset2 );
933
934 //! add entities to meshset
935 virtual ErrorCode add_entities( EntityHandle meshset, const Range& entities );
936
937 //! add entities to meshset
938 virtual ErrorCode add_entities( EntityHandle meshset, const EntityHandle* entities, const int num_entities );
939
940 //! remove entities from meshset
941 virtual ErrorCode remove_entities( EntityHandle meshset, const Range& entities );
942
943 //! remove entities from meshset
944 virtual ErrorCode remove_entities( EntityHandle meshset, const EntityHandle* entities, const int num_entities );
945
946 //! return true if all entities are contained in set
947 virtual bool contains_entities( EntityHandle meshset,
948 const EntityHandle* entities,
949 int num_entities,
950 const int operation_type = Interface::INTERSECT );
951
952 //! replace entities
953 virtual ErrorCode replace_entities( EntityHandle meshset,
954 const EntityHandle* old_entities,
955 const EntityHandle* new_entities,
956 int num_entities );
957
958 //------MeshSet Parent/Child functions------
959
960 //! get parent meshsets
961 virtual ErrorCode get_parent_meshsets( const EntityHandle meshset,
962 std::vector< EntityHandle >& parents,
963 const int num_hops = 1 ) const;
964
965 //! get parent meshsets
966 virtual ErrorCode get_parent_meshsets( const EntityHandle meshset, Range& parents, const int num_hops = 1 ) const;
967
968 //! get child meshsets
969 virtual ErrorCode get_child_meshsets( const EntityHandle meshset,
970 std::vector< EntityHandle >& children,
971 const int num_hops = 1 ) const;
972
973 //! get child meshsets
974 virtual ErrorCode get_child_meshsets( const EntityHandle meshset, Range& children, const int num_hops = 1 ) const;
975
976 //! get contained meshsets
977 virtual ErrorCode get_contained_meshsets( const EntityHandle meshset,
978 std::vector< EntityHandle >& children,
979 const int num_hops = 1 ) const;
980
981 //! get contained meshsets
982 virtual ErrorCode get_contained_meshsets( const EntityHandle meshset,
983 Range& children,
984 const int num_hops = 1 ) const;
985
986 //! gets number of parent meshsets
987 virtual ErrorCode num_parent_meshsets( const EntityHandle meshset, int* number, const int num_hops = 1 ) const;
988
989 //! gets number of child meshsets
990 virtual ErrorCode num_child_meshsets( const EntityHandle meshset, int* number, const int num_hops = 1 ) const;
991
992 //! gets number of contained meshsets
993 virtual ErrorCode num_contained_meshsets( const EntityHandle meshset, int* number, const int num_hops = 1 ) const;
994
995 //! add a parent meshset
996 virtual ErrorCode add_parent_meshset( EntityHandle meshset, const EntityHandle parent_meshset );
997
998 //! add parent meshsets
999 virtual ErrorCode add_parent_meshsets( EntityHandle meshset, const EntityHandle* parents, int count );
1000
1001 //! add a child meshset
1002 virtual ErrorCode add_child_meshset( EntityHandle meshset, const EntityHandle child_meshset );
1003
1004 //! add parent meshsets
1005 virtual ErrorCode add_child_meshsets( EntityHandle meshset, const EntityHandle* children, int count );
1006
1007 //! adds 'parent' to child's parent list and adds 'child' to parent's child list
1008 virtual ErrorCode add_parent_child( EntityHandle parent, EntityHandle child );
1009
1010 //! removes 'parent' to child's parent list and removes 'child' to parent's child list
1011 virtual ErrorCode remove_parent_child( EntityHandle parent, EntityHandle child );
1012
1013 //! remove parent meshset
1014 virtual ErrorCode remove_parent_meshset( EntityHandle meshset, const EntityHandle parent_meshset );
1015
1016 //! remove child meshset
1017 virtual ErrorCode remove_child_meshset( EntityHandle meshset, const EntityHandle child_meshset );
1018
1019 // ************************ tag information ***************
1020
1021 //! return various specific tag handles
1022 Tag material_tag();
1023 Tag neumannBC_tag();
1024 Tag dirichletBC_tag();
1025 Tag globalId_tag();
1026 Tag geom_dimension_tag();
1027
1028 //! get/set the number of nodes
1029 // int total_num_nodes() const;
1030 // void total_num_nodes(const int val);
1031
1032 //! get/set the number of elements
1033 // int total_num_elements() const;
1034 // void total_num_elements(const int val);
1035
1036 // ************************ structured sequence information ***************
1037
1038 //! return a reference to the sequence manager
1039 SequenceManager* sequence_manager()
1040 {
1041 return sequenceManager;
1042 }
1043 const SequenceManager* sequence_manager() const
1044 {
1045 return sequenceManager;
1046 }
1047
1048 /// create structured sequence
1049 ErrorCode create_scd_sequence( const HomCoord& coord_min,
1050 const HomCoord& coord_max,
1051 EntityType type,
1052 EntityID start_id_hint,
1053 EntityHandle& first_handle_out,
1054 EntitySequence*& sequence_out );
1055
1056 ErrorCode add_vsequence( EntitySequence* vert_seq,
1057 EntitySequence* elem_seq,
1058 const HomCoord& p1,
1059 const HomCoord& q1,
1060 const HomCoord& p2,
1061 const HomCoord& q2,
1062 const HomCoord& p3,
1063 const HomCoord& q3,
1064 bool bb_input = false,
1065 const HomCoord* bb_min = NULL,
1066 const HomCoord* bb_max = NULL );
1067
1068 //! return the a_entity_factory pointer
1069 AEntityFactory* a_entity_factory()
1070 {
1071 return aEntityFactory;
1072 }
1073 const AEntityFactory* a_entity_factory() const
1074 {
1075 return aEntityFactory;
1076 }
1077
1078 #ifdef MOAB_HAVE_AHF
1079 HalfFacetRep* a_half_facet_rep()
1080 {
1081 return ahfRep;
1082 }
1083 const HalfFacetRep* a_half_facet_rep() const
1084 {
1085 return ahfRep;
1086 }
1087 #endif
1088
1089 //! return set of registered IO tools
1090 ReaderWriterSet* reader_writer_set()
1091 {
1092 return readerWriterSet;
1093 }
1094
1095 //-----------------MeshSet Interface Functions------------------//
1096
1097 void print( const EntityHandle handle, const char* prefix, bool first_call = true ) const;
1098
1099 ErrorCode print_entity_tags( std::string indent_prefix, const EntityHandle handle, TagType tp ) const;
1100
1101 virtual ErrorCode get_last_error( std::string& info ) const;
1102
1103 virtual std::string get_error_string( const ErrorCode code ) const;
1104
1105 //! check all adjacencies for consistency
1106 ErrorCode check_adjacencies();
1107
1108 //! check some adjacencies for consistency
1109 ErrorCode check_adjacencies( const EntityHandle* ents, int num_ents );
1110
1111 //! return whether the input handle is valid or not
1112 bool is_valid( const EntityHandle this_ent ) const;
1113
1114 /** \brief Create an iterator over the set
1115 * Create a new iterator that iterates over entities with the specified type or dimension.
1116 * Only one of ent_type or dim can be set; use dim=-1 or ent_type=MBMAXTYPE for the other.
1117 * Iterators for list-type (ordered) sets are stable over set modification, unless entity
1118 * removed or deleted is the one at the current position of the iterator. If the check_valid
1119 * parameter is passed as true, entities are checked for validity before being passed back by
1120 * get_next_entities function (checking entity validity can have a non-negligible cost).
1121 *
1122 * Iterators returned by this function can be deleted using the normal C++ delete function.
1123 * After creating the iterator through this function, further interactions are through methods
1124 * on the SetIterator class.
1125 * \param meshset The entity set associated with this iterator (use 0 for whole instance)
1126 * \param ent_type Entity type associated with this iterator
1127 * \param ent_dim Dimension associated with this iterator
1128 * \param chunk_size Chunk size of the iterator
1129 * \param check_valid If true, entities are checked for validity before being returned
1130 */
1131 virtual ErrorCode create_set_iterator( EntityHandle meshset,
1132 EntityType ent_type,
1133 int ent_dim,
1134 int chunk_size,
1135 bool check_valid,
1136 SetIterator*& set_iter );
1137
1138 /** \brief Remove the set iterator from the instance's list
1139 * \param set_iter Set iterator being removed
1140 */
1141 ErrorCode remove_set_iterator( SetIterator* set_iter );
1142
1143 /** \brief Get all set iterators associated with the set passed in
1144 * \param meshset Meshset for which iterators are requested
1145 * \param set_iters Set iterators for the set
1146 */
1147 ErrorCode get_set_iterators( EntityHandle meshset, std::vector< SetIterator* >& set_iters );
1148
1149 //-----------------Memory Functions------------------//
1150
1151 /**\brief Calculate amount of memory used to store MOAB data
1152 *
1153 * This function calculates the amount of memory used to store
1154 * MOAB data.
1155 *
1156 * There are two possible values for each catagory of memory use.
1157 * The exact value and the amortized value. The exact value is the
1158 * amount of memory used to store the data for the specified entities.
1159 * The amortized value includes the exact value and an amortized
1160 * estimate of the memory consumed in overhead for storing the values
1161 * (indexing structures, access structures, etc.)
1162 *
1163 * Note: If ent_array is NULL, the total memory used by MOAB for storing
1164 * data will be returned in the address pointed to by
1165 * total_amortized_storage, if total_amortized_storage is not NULL.
1166 *
1167 *\param ent_array Array of entities for which to estimate the memory use.
1168 * If NULL, estimate is done for all entities.
1169 *\param num_ents The length of ent_array. Not used if ent_rray is NULL.
1170 *\param total_(amortized_)storage The sum of the memory entity, adjacency, and all tag storage.
1171 *\param (amortized_)entity_storage The storage for the entity definitions
1172 * (connectivity arrays for elements, coordinates for vertices,
1173 * list storage within sets, etc.)
1174 *\param (amortized_)adjacency_storage The storage for adjacency data.
1175 *\param tag_array An array of tags for which to calculate the memory use.
1176 *\param num_tags The lenght of tag_array
1177 *\param (amortized_)tag_storage If tag_array is not NULL, then one value
1178 * for each tag specifying the memory used for storing that
1179 * tag. If tag_array is NULL and this value is not, the
1180 * location at which to store the total memory used for
1181 * all tags.
1182 */
1183 void estimated_memory_use( const EntityHandle* ent_array = 0,
1184 unsigned long num_ents = 0,
1185 unsigned long long* total_storage = 0,
1186 unsigned long long* total_amortized_storage = 0,
1187 unsigned long long* entity_storage = 0,
1188 unsigned long long* amortized_entity_storage = 0,
1189 unsigned long long* adjacency_storage = 0,
1190 unsigned long long* amortized_adjacency_storage = 0,
1191 const Tag* tag_array = 0,
1192 unsigned num_tags = 0,
1193 unsigned long long* tag_storage = 0,
1194 unsigned long long* amortized_tag_storage = 0 );
1195
1196 /**\brief Calculate amount of memory used to store MOAB data
1197 *
1198 * This function calculates the amount of memory used to store
1199 * MOAB data.
1200 *
1201 * There are two possible values for each catagory of memory use.
1202 * The exact value and the amortized value. The exact value is the
1203 * amount of memory used to store the data for the specified entities.
1204 * The amortized value includes the exact value and an amortized
1205 * estimate of the memory consumed in overhead for storing the values
1206 * (indexing structures, access structures, etc.)
1207 *
1208 *\param ents Entities for which to estimate the memory use.
1209 *\param total_(amortized_)storage The sum of the memory entity, adjacency, and all tag storage.
1210 *\param (amortized_)entity_storage The storage for the entity definitions
1211 * (connectivity arrays for elements, coordinates for vertices,
1212 * list storage within sets, etc.)
1213 *\param (amortized_)adjacency_storage The storage for adjacency data.
1214 *\param tag_array An array of tags for which to calculate the memory use.
1215 *\param num_tags The lenght of tag_array
1216 *\param (amortized_)tag_storage If tag_array is not NULL, then one value
1217 * for each tag specifying the memory used for storing that
1218 * tag. If tag_array is NULL and this value is not, the
1219 * location at which to store the total memory used for
1220 * all tags.
1221 */
1222 void estimated_memory_use( const Range& ents,
1223 unsigned long long* total_storage = 0,
1224 unsigned long long* total_amortized_storage = 0,
1225 unsigned long long* entity_storage = 0,
1226 unsigned long long* amortized_entity_storage = 0,
1227 unsigned long long* adjacency_storage = 0,
1228 unsigned long long* amortized_adjacency_storage = 0,
1229 const Tag* tag_array = 0,
1230 unsigned num_tags = 0,
1231 unsigned long long* tag_storage = 0,
1232 unsigned long long* amortized_tag_storage = 0 );
1233
1234 void print_database() const;
1235
1236 /** \name Sequence Option controllers */
1237
1238 /**@{*/
1239
1240 /** \brief Interface to control memory allocation for sequences
1241 * Provide a factor that controls the size of the sequence that gets allocated.
1242 * This is typically useful in the parallel setting when a-priori, the number of ghost entities
1243 * and the memory required for them within the same sequence as the owned entities are unknown.
1244 * The default factor is 1.0 but this can be appropriately updated at runtime so that we do not
1245 * have broken sequences.
1246 */
1247 virtual double get_sequence_multiplier() const;
1248
1249 /** \brief Interface to control memory allocation for sequences
1250 * Provide a factor that controls the size of the sequence that gets allocated.
1251 * This is typically useful in the parallel setting when a-priori, the number of ghost entities
1252 * and the memory required for them within the same sequence as the owned entities are unknown.
1253 * The default factor is 1.0 but this can be appropriately updated at runtime so that we do not
1254 * have broken sequences.
1255 *
1256 * \param meshset User specified multiplier (should be greater than 1.0)
1257 */
1258 virtual void set_sequence_multiplier( double factor );
1259
1260 /**@}*/
1261
1262 private:
1263 /**\brief Do not allow copying */
1264 Core( const Core& copy );
1265 /**\brief Do not allow copying */
1266 Core& operator=( const Core& copy );
1267
1268 void estimated_memory_use_internal( const Range* ents,
1269 unsigned long long* total_storage,
1270 unsigned long long* total_amortized_storage,
1271 unsigned long long* entity_storage,
1272 unsigned long long* amortized_entity_storage,
1273 unsigned long long* adjacency_storage,
1274 unsigned long long* amortized_adjacency_storage,
1275 const Tag* tag_array,
1276 unsigned num_tags,
1277 unsigned long long* tag_storage,
1278 unsigned long long* amortized_tag_storage );
1279
1280 //! database init and de-init routines
1281 ErrorCode initialize();
1282 void deinitialize();
1283
1284 //! return the entity set representing the whole mesh
1285 EntityHandle get_root_set();
1286
1287 //!\brief Clean up after a file reader returns failure.
1288 //!
1289 //! Delete all entities not contained in initial_entities
1290 //! and all tags not contained in initial_tags.
1291 void clean_up_failed_read( const Range& initial_ents, std::vector< Tag > initial_tags );
1292
1293 // other interfaces for MB
1294 WriteUtil* mMBWriteUtil;
1295 ReadUtil* mMBReadUtil;
1296 ScdInterface* scdInterface;
1297
1298 //! store the total number of elements defined in this interface
1299 // int totalNumElements;
1300
1301 //! store the total number of nodes defined in this interface
1302 // int totalNumNodes;
1303
1304 //! the overall geometric dimension of this mesh
1305 int geometricDimension;
1306
1307 Tag materialTag;
1308 Tag neumannBCTag;
1309 Tag dirichletBCTag;
1310 Tag geomDimensionTag;
1311 Tag globalIdTag;
1312
1313 //! tag server for this interface
1314 std::list< TagInfo* > tagList;
1315 inline bool valid_tag_handle( const TagInfo* t ) const
1316 {
1317 return std::find( tagList.begin(), tagList.end(), t ) != tagList.end();
1318 }
1319
1320 SequenceManager* sequenceManager;
1321
1322 AEntityFactory* aEntityFactory;
1323
1324 ReaderWriterSet* readerWriterSet;
1325
1326 Error* mError;
1327 bool mpiFinalize;
1328 int writeMPELog;
1329 bool initErrorHandlerInCore;
1330
1331 //! list of iterators
1332 std::vector< SetIterator* > setIterators;
1333
1334 #ifdef MOAB_HAVE_AHF
1335 HalfFacetRep* ahfRep;
1336 bool mesh_modified;
1337 #endif
1338 };
1339
1340 } // namespace moab
1341
1342 #endif // MOAB_IMPL_GENERAL_HPP
1.9.1.