Mesh Oriented datABase  (version 5.5.0)
An array-based unstructured mesh library
mhdf.h File Reference
#include "moab/mhdf_public.h"
+ Include dependency graph for mhdf.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define MHDF_INDEX_TYPE   H5T_NATIVE_LONG
 
#define mhdf_SET_OWNER_BIT   0x1
 Make entities in set aware of owning set (MOAB-specific?) More...
 
#define mhdf_SET_UNIQUE_BIT   0x2
 Set cannot contain duplicates. More...
 
#define mhdf_SET_ORDER_BIT   0x4
 Set order is preserved. More...
 
#define mhdf_SET_RANGE_BIT   0x8
 The bit specifying set storage format. More...
 
#define mhdf_DENSE_TYPE   2
 Was dense tag data in mesh database. More...
 
#define mhdf_SPARSE_TYPE   1
 Was sparse tag data in mesh database. More...
 
#define mhdf_BIT_TYPE   0
 Was bit-field tag data in mesh database. More...
 
#define mhdf_MESH_TYPE   3
 Unused. More...
 

Functions

const char * mhdf_node_type_handle (void)
 Get an mhdf_ElemHandle object for the node data.
More...
 
const char * mhdf_set_type_handle (void)
 Return a special element group handle used to specify the set group. More...
 
void mhdf_getElemName (mhdf_FileHandle file_handle, unsigned int type_index, char *buffer, size_t buffer_size, mhdf_Status *status)
 Given an element type Id, get the name. Fails if buffer is not of sufficient size. More...
 
int mhdf_checkOpenHandles (mhdf_FileHandle handle, mhdf_Status *status)
 
void mhdf_closeData (mhdf_FileHandle file, hid_t handle, mhdf_Status *status)
 Common close function for all data handle types. More...
 
void mhdf_getNextStartId (mhdf_FileHandle file, mhdf_index_t *start_id_out, mhdf_Status *status)
 Get start ID that will be assigned to next created dataset. More...
 
void mhdf_writeHistory (mhdf_FileHandle file, const char **strings, int num_strings, mhdf_Status *status)
 Write the file history as a list of strings. More...
 
char ** mhdf_readHistory (mhdf_FileHandle file, int *num_records_out, mhdf_Status *status)
 Read the file history as a list of strings. More...
 
int mhdf_haveNodes (mhdf_FileHandle file_handle, mhdf_Status *status)
 
hid_t mhdf_createNodeCoords (mhdf_FileHandle file_handle, int dimension, long num_nodes, long *first_node_id_out, mhdf_Status *status)
 Create new table for node coordinate data. More...
 
hid_t mhdf_openNodeCoords (mhdf_FileHandle file_handle, long *num_nodes_out, int *dimension_out, long *first_node_id_out, mhdf_Status *status)
 Open table containing node coordinate data. More...
 
hid_t mhdf_openNodeCoordsSimple (mhdf_FileHandle file_handle, mhdf_Status *status)
 
void mhdf_writeNodeCoords (hid_t data_handle, long offset, long count, const double *coords, mhdf_Status *status)
 Write node coordinate data. More...
 
void mhdf_writeNodeCoordsWithOpt (hid_t data_handle, long offset, long count, const double *coords, hid_t write_prop, mhdf_Status *status)
 
void mhdf_writeNodeCoord (hid_t data_handle, long offset, long count, int dimension, const double *coords, mhdf_Status *status)
 Write node coordinate data. More...
 
void mhdf_writeNodeCoordWithOpt (hid_t data_handle, long offset, long count, int dimension, const double *coords, hid_t write_prop, mhdf_Status *status)
 
void mhdf_readNodeCoords (hid_t data_handle, long offset, long count, double *coordinates, mhdf_Status *status)
 Read node coordinate data. More...
 
void mhdf_readNodeCoordsWithOpt (hid_t data_handle, long offset, long count, double *coordinates, hid_t read_prop, mhdf_Status *status)
 
void mhdf_readNodeCoord (hid_t data_handle, long offset, long count, int dimension, double *coords, mhdf_Status *status)
 Read node coordinate data. More...
 
void mhdf_readNodeCoordWithOpt (hid_t data_handle, long offset, long count, int dimension, double *coords, hid_t read_prop, mhdf_Status *status)
 
void mhdf_addElement (mhdf_FileHandle file_handle, const char *elem_handle, unsigned int named_elem_type, mhdf_Status *status)
 Add a new table of element data to the file. More...
 
char ** mhdf_getElemHandles (mhdf_FileHandle file_handle, unsigned int *count_out, mhdf_Status *status)
 Get the list of element groups in the file. More...
 
void mhdf_getElemTypeName (mhdf_FileHandle file_handle, const char *elem_handle, char *buffer, size_t buf_len, mhdf_Status *status)
 Get the element type name for a given element group handle. More...
 
int mhdf_isPolyElement (mhdf_FileHandle file_handle, const char *elem_handle, mhdf_Status *status)
 Check if an element group contains polygon or polyhedron. More...
 
hid_t mhdf_createConnectivity (mhdf_FileHandle file_handle, const char *elem_handle, int num_nodes_per_elem, long num_elements, long *first_elem_id_out, mhdf_Status *status)
 Create connectivity table for an element group. More...
 
hid_t mhdf_openConnectivity (mhdf_FileHandle file_handle, const char *elem_handle, int *num_nodes_per_elem_out, long *num_elements_out, long *first_elem_id_out, mhdf_Status *status)
 Open connectivity table for an element group. More...
 
hid_t mhdf_openConnectivitySimple (mhdf_FileHandle file_handle, const char *elem_handle, mhdf_Status *status)
 
void mhdf_writeConnectivity (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, const void *node_id_list, mhdf_Status *status)
 Write element coordinate data. More...
 
void mhdf_writeConnectivityWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, const void *node_id_list, hid_t write_prop, mhdf_Status *status)
 
void mhdf_readConnectivity (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *node_id_list, mhdf_Status *status)
 Read element coordinate data. More...
 
void mhdf_readConnectivityWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *node_id_list, hid_t read_prop, mhdf_Status *status)
 
void mhdf_createPolyConnectivity (mhdf_FileHandle file_handle, const char *elem_handle, long num_poly, long data_list_length, long *first_id_out, hid_t idx_and_id_handles_out[2], mhdf_Status *status)
 Create a new table for polygon or polyhedron connectivity data. More...
 
void mhdf_openPolyConnectivity (mhdf_FileHandle file_handle, const char *elem_handle, long *num_poly_out, long *data_list_length_out, long *first_id_out, hid_t idx_and_id_handles_out[2], mhdf_Status *status)
 Open a table of polygon or polyhedron connectivity data. More...
 
void mhdf_writePolyConnIndices (hid_t poly_handle, long offset, long count, hid_t hdf_integer_type, const void *index_list, mhdf_Status *status)
 Write polygon or polyhedron index data. More...
 
void mhdf_writePolyConnIndicesWithOpt (hid_t poly_handle, long offset, long count, hid_t hdf_integer_type, const void *index_list, hid_t write_prop, mhdf_Status *status)
 
void mhdf_writePolyConnIDs (hid_t poly_handle, long offset, long count, hid_t hdf_integer_type, const void *id_list, mhdf_Status *status)
 Write polygon or polyhedron connectivity data. More...
 
void mhdf_writePolyConnIDsWithOpt (hid_t poly_handle, long offset, long count, hid_t hdf_integer_type, const void *id_list, hid_t write_prop, mhdf_Status *status)
 
void mhdf_readPolyConnIndices (hid_t poly_handle, long offset, long count, hid_t hdf_integer_type, void *index_list, mhdf_Status *status)
 Read polygon or polyhedron index data. More...
 
void mhdf_readPolyConnIndicesWithOpt (hid_t poly_handle, long offset, long count, hid_t hdf_integer_type, void *index_list, hid_t read_prop, mhdf_Status *status)
 
void mhdf_readPolyConnIDs (hid_t poly_handle, long offset, long count, hid_t hdf_integer_type, void *id_list, mhdf_Status *status)
 Read polygon or polyhedron connectivity data. More...
 
void mhdf_readPolyConnIDsWithOpt (hid_t poly_handle, long offset, long count, hid_t hdf_integer_type, void *id_list, hid_t read_prop, mhdf_Status *status)
 
hid_t mhdf_createAdjacency (mhdf_FileHandle file_handle, const char *elem_handle, long adj_list_size, mhdf_Status *status)
 Create adjacency data table for nodes, elements, polys, etc. More...
 
int mhdf_haveAdjacency (mhdf_FileHandle file, const char *elem_handle, mhdf_Status *status)
 Check if adjacency data is present in the file for the specified element group. More...
 
hid_t mhdf_openAdjacency (mhdf_FileHandle file_handle, const char *elem_handle, long *adj_list_size, mhdf_Status *status)
 Open adjacency data table for nodes, elements, polys, etc. More...
 
void mhdf_writeAdjacency (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, const void *adj_list_data, mhdf_Status *status)
 Write node/element adjacency data. More...
 
void mhdf_writeAdjacencyWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, const void *adj_list_data, hid_t write_prop, mhdf_Status *status)
 
void mhdf_readAdjacency (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *adj_list_data_out, mhdf_Status *status)
 Read node/element adjacency data. More...
 
void mhdf_readAdjacencyWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *adj_list_data_out, hid_t read_prop, mhdf_Status *status)
 
hid_t mhdf_createSetMeta (mhdf_FileHandle file_handle, long num_sets, long *first_set_id_out, mhdf_Status *status)
 Create table holding list of meshsets and their properties. More...
 
int mhdf_haveSets (mhdf_FileHandle file, int *have_set_data_out, int *have_set_child_out, int *have_set_parents_out, mhdf_Status *status)
 Check if file contains any sets. More...
 
hid_t mhdf_openSetMeta (mhdf_FileHandle file_handle, long *num_sets_out, long *first_set_id_out, mhdf_Status *status)
 Open table holding list of meshsets and their properties. More...
 
hid_t mhdf_openSetMetaSimple (mhdf_FileHandle file_handle, mhdf_Status *status)
 
void mhdf_readSetMeta (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *set_desc_data, mhdf_Status *status)
 Read list of sets and meta-information about sets. More...
 
void mhdf_readSetMetaWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *set_desc_data, hid_t read_prop, mhdf_Status *status)
 
void mhdf_readSetFlags (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *set_flag_data, mhdf_Status *status)
 Read only the flags portion of the set description table. More...
 
void mhdf_readSetFlagsWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *set_flag_data, hid_t read_prop, mhdf_Status *status)
 
void mhdf_readSetContentEndIndices (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *end_indices_out, mhdf_Status *status)
 Read only the content end indices portion of the set description table. More...
 
void mhdf_readSetContentEndIndicesWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *end_indices_out, hid_t read_prop, mhdf_Status *status)
 
void mhdf_readSetChildEndIndices (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *end_indices_out, mhdf_Status *status)
 Read only the child end indices portion of the set description table. More...
 
void mhdf_readSetChildEndIndicesWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *end_indices_out, hid_t read_prop, mhdf_Status *status)
 
void mhdf_readSetParentEndIndices (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *end_indices_out, mhdf_Status *status)
 Read only the parent end indices portion of the set description table. More...
 
void mhdf_readSetParentEndIndicesWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *end_indices_out, hid_t read_prop, mhdf_Status *status)
 
void mhdf_writeSetMeta (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, const void *set_desc_data, mhdf_Status *status)
 Write list of sets and meta-information about sets. More...
 
void mhdf_writeSetMetaWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, const void *set_desc_data, hid_t write_prop, mhdf_Status *status)
 
hid_t mhdf_createSetData (mhdf_FileHandle file_handle, long data_list_size, mhdf_Status *status)
 Create file object to hold list of meshset contents. More...
 
hid_t mhdf_openSetData (mhdf_FileHandle file_handle, long *data_list_size_out, mhdf_Status *status)
 Open the file object for the meshset contents. More...
 
void mhdf_writeSetData (hid_t set_handle, long offset, long count, hid_t hdf_integer_type, const void *set_data, mhdf_Status *status)
 Write set contents. More...
 
void mhdf_writeSetDataWithOpt (hid_t set_handle, long offset, long count, hid_t hdf_integer_type, const void *set_data, hid_t write_prop, mhdf_Status *status)
 
void mhdf_readSetData (hid_t set_handle, long offset, long count, hid_t hdf_integer_type, void *set_data, mhdf_Status *status)
 Read set contents. More...
 
void mhdf_readSetDataWithOpt (hid_t set_handle, long offset, long count, hid_t hdf_integer_type, void *set_data, hid_t read_prop, mhdf_Status *status)
 
hid_t mhdf_createSetChildren (mhdf_FileHandle file_handle, long child_list_size, mhdf_Status *status)
 Create file object for storing the set child list. More...
 
hid_t mhdf_openSetChildren (mhdf_FileHandle file_handle, long *child_list_size, mhdf_Status *status)
 Open the file object containing the set child list. More...
 
hid_t mhdf_createSetParents (mhdf_FileHandle file_handle, long parent_list_size, mhdf_Status *status)
 Create file object for storing the set parent list. More...
 
hid_t mhdf_openSetParents (mhdf_FileHandle file_handle, long *parent_list_size, mhdf_Status *status)
 Open the file object containing the set parent list. More...
 
void mhdf_writeSetParentsChildren (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, const void *id_list, mhdf_Status *status)
 Write set parent/child list. More...
 
void mhdf_writeSetParentsChildrenWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, const void *id_list, hid_t write_prop, mhdf_Status *status)
 
void mhdf_readSetParentsChildren (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *id_list, mhdf_Status *status)
 Read set parent/child list. More...
 
void mhdf_readSetParentsChildrenWithOpt (hid_t data_handle, long offset, long count, hid_t hdf_integer_type, void *id_list, hid_t read_prop, mhdf_Status *status)
 
hid_t mhdf_getNativeType (hid_t input_type, int size, mhdf_Status *status)
 Make type native-endian. More...
 
void mhdf_createTag (mhdf_FileHandle file_handle, const char *tag_name, enum mhdf_TagDataType tag_type, int size, int storage, const void *default_value, const void *global_value, hid_t hdf_type, hid_t mhdf_base_type, mhdf_Status *status)
 Add a tag to the file. More...
 
hid_t mhdf_getTagDataType (mhdf_FileHandle file_handle, const char *tag_name, mhdf_Status *status)
 Get handle to HDF5 type object for tag data. More...
 
void mhdf_createVarLenTag (mhdf_FileHandle file_handle, const char *tag_name, enum mhdf_TagDataType tag_type, int storage, const void *default_value, int default_value_length, const void *global_value, int global_value_length, hid_t hdf_type, hid_t hdf_base_type, mhdf_Status *status)
 Add variable-length tag to file. More...
 
int mhdf_getNumberTags (mhdf_FileHandle file_handle, mhdf_Status *status)
 Get the number of tags in the file. More...
 
char ** mhdf_getTagNames (mhdf_FileHandle file_handle, int *num_names_out, mhdf_Status *status)
 Get the name for each tag defined in the file. More...
 
void mhdf_getTagInfo (mhdf_FileHandle file_handle, const char *tag_name, enum mhdf_TagDataType *class_out, int *size_out, int *tstt_storage_out, int *have_default_out, int *have_global_out, int *have_sparse_out, mhdf_Status *status)
 Get the description of a specified tag. More...
 
void mhdf_getTagValues (mhdf_FileHandle file_handle, const char *tag_name, hid_t output_data_type, void *default_value, void *global_value, mhdf_Status *status)
 Get the default and global values of the tag. More...
 
int mhdf_haveDenseTag (mhdf_FileHandle file_handle, const char *tag_name, const char *elem_group, mhdf_Status *status)
 Check if the file contains dense tag data for the specified tag and element group. More...
 
hid_t mhdf_createDenseTagData (mhdf_FileHandle file_handle, const char *tag_name, const char *elem_group, long num_values, mhdf_Status *status)
 Create an object to hold dense tag values for a given element group. More...
 
hid_t mhdf_openDenseTagData (mhdf_FileHandle file_handle, const char *tag_name, const char *elem_group, long *num_values_out, mhdf_Status *status)
 Open the object containing dense tag values for a given element group. More...
 
void mhdf_createSparseTagData (mhdf_FileHandle file_handle, const char *tag_name, long num_values, hid_t entities_and_values_out[2], mhdf_Status *status)
 Create file objects to store sparse tag data. More...
 
void mhdf_createVarLenTagData (mhdf_FileHandle file_handle, const char *tag_name, long num_entities, long num_values, hid_t entities_and_values_out[3], mhdf_Status *status)
 Create file objects to store (sparse) variable-length tag data. More...
 
void mhdf_openSparseTagData (mhdf_FileHandle file_handle, const char *tag_name, long *num_entity_out, long *num_values_out, hid_t entities_and_values_out[3], mhdf_Status *status)
 Create file objects to read sparse tag data. More...
 
void mhdf_writeSparseTagEntities (hid_t id_handle, long offset, long count, hid_t hdf_integer_type, const void *id_list, mhdf_Status *status)
 Write Global ID list for sparse tag data. More...
 
void mhdf_writeSparseTagEntitiesWithOpt (hid_t id_handle, long offset, long count, hid_t hdf_integer_type, const void *id_list, hid_t write_prop, mhdf_Status *status)
 
void mhdf_writeTagValues (hid_t value_handle, long offset, long count, hid_t hdf_tag_data_type, const void *tag_data, mhdf_Status *status)
 Write tag values. More...
 
void mhdf_writeTagValuesWithOpt (hid_t value_handle, long offset, long count, hid_t hdf_tag_data_type, const void *tag_data, hid_t write_prop, mhdf_Status *status)
 
void mhdf_writeSparseTagIndices (hid_t tag_handle, long offset, long count, hid_t hdf_integer_type, const void *end_indices, mhdf_Status *status)
 Write sparse tag end indices for variable-length tag data. More...
 
void mhdf_writeSparseTagIndicesWithOpt (hid_t tag_handle, long offset, long count, hid_t hdf_integer_type, const void *end_indices, hid_t write_prop, mhdf_Status *status)
 
void mhdf_readSparseTagEntities (hid_t id_handle, long offset, long count, hid_t hdf_integer_type, void *id_list, mhdf_Status *status)
 Read Global ID list for sparse tag data. More...
 
void mhdf_readSparseTagEntitiesWithOpt (hid_t id_handle, long offset, long count, hid_t hdf_integer_type, void *id_list, hid_t read_prop, mhdf_Status *status)
 
void mhdf_readTagValues (hid_t value_handle, long offset, long count, hid_t hdf_type, void *memory, mhdf_Status *status)
 Read tag values. More...
 
void mhdf_readTagValuesWithOpt (hid_t value_handle, long offset, long count, hid_t hdf_type, void *memory, hid_t read_prop, mhdf_Status *status)
 
void mhdf_readSparseTagIndices (hid_t tag_handle, long offset, long count, hid_t hdf_integer_type, void *end_indices, mhdf_Status *status)
 Read sparse tag end indices for variable-length tag data. More...
 
void mhdf_readSparseTagIndicesWithOpt (hid_t tag_handle, long offset, long count, hid_t hdf_integer_type, void *end_indices, hid_t read_prop, mhdf_Status *status)
 

Macro Definition Documentation

◆ mhdf_BIT_TYPE

#define mhdf_BIT_TYPE   0

Was bit-field tag data in mesh database.

Definition at line 1388 of file mhdf.h.

◆ mhdf_DENSE_TYPE

#define mhdf_DENSE_TYPE   2

Was dense tag data in mesh database.

Tag data.

The data for each tag can be stored in two places/formats: sparse and/or dense. The data may be stored in both, but there should not be redundant values for the same entity.

Dense tag data is stored as multiple tables of tag values, one for each element group. (Note: special mhdf_ElemHandle values are available for accessing dense tag data on nodes or meshsets via the mhdf_node_type_handle and mhdf_set_type_handle functions.) Each dense tag table should contain the same number of entries as the element connectivity table. The tag values are associated with the corresponding element in the connectivity table.

Sparse tag data is stored as a global table pair for each tag type. The first if the pair of tables is a list of Global IDs. The second is the corresponding tag value for each entity in the ID list. Tag type values (MOAB-specific)

Definition at line 1384 of file mhdf.h.

◆ MHDF_INDEX_TYPE

#define MHDF_INDEX_TYPE   H5T_NATIVE_LONG

Definition at line 51 of file mhdf.h.

◆ mhdf_MESH_TYPE

#define mhdf_MESH_TYPE   3

Unused.

Definition at line 1390 of file mhdf.h.

◆ mhdf_SET_ORDER_BIT

#define mhdf_SET_ORDER_BIT   0x4

Set order is preserved.

Definition at line 887 of file mhdf.h.

◆ mhdf_SET_OWNER_BIT

#define mhdf_SET_OWNER_BIT   0x1

Make entities in set aware of owning set (MOAB-specific?)

Meshset data.

Meshset data is divided into three groups of data. The set-list/meta-information table, the set contents table and the set children table. Each is written and read independently.

The set list table contains one row for each set. Each row contains four values: {content list end index, child list end index, parent list end index, and flags}. The flags value is a collection of bits with values defined in mhdf_set_flag . The all the flags except mhdf_SET_RANGE_BIT are saved properties of the mesh data and are not relevant to the actual file in any way. The mhdf_SET_RANGE_BIT flag is a toggle for how the meshset contents (not children) are saved. It is an internal property of the file format and should not be passed on to the mesh database. The content list end index and child list end index are the indices of the last entry for the set in the contents and children tables respectively. In the case where a set has either no children or no contents, the last index of should be the same as the last index of the previous set in the table, or -1 for the first set in the table. Thus the first index is always one greater than the last index of the previous set. If the first index, calculated as one greater that the last index of the previous set is greater than the last index of the current set, then there are no values in the corresponding contents or children table for that set.

The set contents table is a vector of integer global IDs that is the concatenation of the contents data for all of the mesh sets. The values are stored corresponding to the order of the sets in the set list table. Depending on the value of mhdf_SET_RANGE_BIT in the flags field of the set list table, the contents for a specific set may be stored in one of two formats. If the flag is set, the contents list is a list of pairs where each pair is a starting global Id and a count. For each pair, the set contains the range of global Ids beginning at the start value. If the mhdf_SET_RANGE_BIT flag is not set, the meshset contents are a simple list of global Ids.

The meshset child table is a vector of integer global IDs. It is a concatenation of the child lists for all the mesh sets, in the order the sets occur in the meshset list table. The values are always simple lists. The child table may never contain ranges of IDs. Set flag bits

Definition at line 883 of file mhdf.h.

◆ mhdf_SET_RANGE_BIT

#define mhdf_SET_RANGE_BIT   0x8

The bit specifying set storage format.

If this bit is set, then the contents of a set (not the children) is written as set of ranges, where each range is of the form {global start id, count}. For such a range, the set contains the count entities with sequential global IDs beginning with the specified start ID. If this bit is not set in the set flags, the contents of the set are stored as a simple list of global IDs.

Definition at line 898 of file mhdf.h.

◆ mhdf_SET_UNIQUE_BIT

#define mhdf_SET_UNIQUE_BIT   0x2

Set cannot contain duplicates.

Definition at line 885 of file mhdf.h.

◆ mhdf_SPARSE_TYPE

#define mhdf_SPARSE_TYPE   1

Was sparse tag data in mesh database.

Definition at line 1386 of file mhdf.h.

Function Documentation

◆ mhdf_addElement()

void mhdf_addElement ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
unsigned int  named_elem_type,
mhdf_Status status 
)

Add a new table of element data to the file.

Add a element group to the file. An element group is the data for a block of elements with the same TSTT type and same number of nodes in their connectivity data. (e.g. all the MBHEX20 elements). This function is also used to create the groups for general polygon data and general polyhedron data. The requirement that all elements have the same number of nodes in their connectivity does not apply for poly(gons|hedra).

Parameters
file_handleFile in which to create the element type.
elem_handleThe name to use for the element data. This name is used as an identifier to reference the data for this element type later. The selected name also appears explicitly in the file and therefore should be something descriptive of the element type such as the 'base type' and number of nodes (e.g. "Hex20").
named_elem_typeAn index into the list of named element types passed to mhdf_createFile .
statusPassed back status of API call.

Definition at line 507 of file file.c.

508 {
509  FileHandle* file_ptr = (FileHandle*)file_handle;
510  hid_t group_id, tag_id, enum_id;
511  char *path, *ptr;
512  size_t name_len;
513  herr_t rval;
514  API_BEGIN;
515 
516  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
517 
518  name_len = mhdf_name_to_path( name, NULL, 0 );
519  name_len += strlen( ELEMENT_GROUP ) + 1;
520  path = (char*)mhdf_malloc( name_len, status );
521  if( !path ) return;
522 
523  strcpy( path, ELEMENT_GROUP );
524  ptr = path + strlen( ELEMENT_GROUP );
525  if( !mhdf_path_to_name( name, ptr ) )
526  {
527  mhdf_setFail( status, "Invalid character string in internal file path: \"%s\"\n", name );
528  return;
529  }
530 
531 #if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
532  group_id = H5Gcreate2( file_ptr->hdf_handle, path, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
533 #else
534  group_id = H5Gcreate( file_ptr->hdf_handle, path, 3 );
535 #endif
536  if( group_id < 0 )
537  {
538  mhdf_setFail( status, "Creation of \"%s\" group failed.\n", path );
539  free( path );
540  return;
541  }
542  free( path );
543 
544 #if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
545  tag_id = H5Gcreate2( group_id, DENSE_TAG_SUBGROUP, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
546 #else
547  tag_id = H5Gcreate( group_id, DENSE_TAG_SUBGROUP, 0 );
548 #endif
549  if( tag_id < 0 )
550  {
551  H5Gclose( group_id );
552  mhdf_setFail( status, "Creation of tag subgroup failed.\n" );
553  return;
554  }
555  H5Gclose( tag_id );
556 
557  enum_id = get_elem_type_enum( file_ptr, status );
558  if( enum_id < 0 )
559  {
560  H5Gclose( group_id );
561  return;
562  }
563 
564  rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super( enum_id ), 1, &elem_type, NULL, H5P_DEFAULT );
565  if( rval < 0 )
566  {
567  H5Gclose( group_id );
568  H5Tclose( enum_id );
569  mhdf_setFail( status, "Internal error converting to enum type." );
570  return;
571  }
572 
573  rval = mhdf_create_scalar_attrib( group_id, ELEM_TYPE_ATTRIB, enum_id, &elem_type, status );
574  H5Tclose( enum_id );
575  if( rval < 0 )
576  {
577  H5Gclose( group_id );
578  return;
579  }
580 
581  H5Gclose( group_id );
582  mhdf_setOkay( status );
583  API_END;
584 }

References API_BEGIN, API_END, DENSE_TAG_SUBGROUP, ELEM_TYPE_ATTRIB, ELEMENT_GROUP, get_elem_type_enum(), struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_create_scalar_attrib(), mhdf_malloc(), mhdf_name_to_path(), mhdf_path_to_name(), mhdf_setFail(), and mhdf_setOkay().

Referenced by moab::WriteHDF5::create_elem_table().

◆ mhdf_checkOpenHandles()

int mhdf_checkOpenHandles ( mhdf_FileHandle  handle,
mhdf_Status status 
)

Definition at line 409 of file file.c.

410 {
411  FileHandle* file_ptr;
412  int result;
413  API_BEGIN;
414 
415  file_ptr = (FileHandle*)( handle );
416  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
417 
418  /* Check for open handles. HDF5 will not actually close the
419  file until all handles are closed. */
420  result = H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ALL );
421  if( result != 1 )
422  {
423  mhdf_setFail( status,
424  "Cannot close file with open handles: "
425  "%d file, %d data, %d group, %d type, %d attr\n",
426  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_FILE ) - 1,
427  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATASET ),
428  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_GROUP ),
429  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATATYPE ),
430  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ATTR ) );
431  return result - 1;
432  }
433 
434  API_END_H( 0 );
435  return 0;
436 }

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), and mhdf_setFail().

Referenced by mhdf_closeFile().

◆ mhdf_closeData()

void mhdf_closeData ( mhdf_FileHandle  file,
hid_t  handle,
mhdf_Status status 
)

Common close function for all data handle types.

Close an hid_t-type handle returned from any of the following functions. Any hid_t passed-back or returned must be closed via this function to avoid resource loss.

Parameters
fileThe file the object pointed to by the passed data handled exists int.
handleThe data object to close.
statusPassed back status of API call.

Definition at line 470 of file file.c.

471 {
472  FileHandle* file_ptr;
473  herr_t rval = -1;
474 
475  file_ptr = (FileHandle*)( file );
476  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
477 
478  switch( H5Iget_type( handle ) )
479  {
480  case H5I_GROUP:
481  rval = H5Gclose( handle );
482  break;
483  case H5I_DATATYPE:
484  rval = H5Tclose( handle );
485  break;
486  case H5I_DATASPACE:
487  rval = H5Sclose( handle );
488  break;
489  case H5I_DATASET:
490  rval = H5Dclose( handle );
491  break;
492  default:
493  rval = -1;
494  }
495 
496  if( rval < 0 )
497  {
498  mhdf_setFail( status, "H5Xclose failed. Invalid handle?\n" );
499  }
500  else
501  {
502  file_ptr->open_handle_count--;
503  mhdf_setOkay( status );
504  }
505 }

References mhdf_check_valid_file(), mhdf_setFail(), mhdf_setOkay(), and struct_FileHandle::open_handle_count.

Referenced by check_valid_adjacencies(), check_valid_elem_conn(), check_valid_poly_conn(), check_valid_sets(), check_valid_tag(), check_valid_var_len_tag(), moab::WriteHDF5Parallel::create_adjacency_tables(), moab::WriteHDF5::create_elem_table(), moab::WriteHDF5Parallel::create_node_table(), moab::WriteHDF5::create_set_meta(), moab::WriteHDF5::create_set_tables(), moab::WriteHDF5::create_tag(), moab::ReadHDF5::find_sets_containing(), get_elem_desc(), moab::ReadHDF5::get_tagged_entities(), moab::ReadHDF5::load_file_impl(), moab::ReadHDF5::load_file_partial(), main(), mhdf_getFileSummary(), moab::ReadHDF5::read_all_set_meta(), moab::ReadHDF5::read_node_adj_elems(), moab::ReadHDF5::read_nodes(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::search_tag_values(), moab::WriteHDF5::serial_create_file(), moab::WriteHDF5::write_adjacencies(), moab::WriteHDF5::write_dense_tag(), moab::WriteHDF5::write_elems(), moab::WriteHDF5::write_nodes(), moab::WriteHDF5::write_sets(), moab::WriteHDF5::write_sparse_tag(), and moab::WriteHDF5::write_var_len_tag().

◆ mhdf_createAdjacency()

hid_t mhdf_createAdjacency ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
long  adj_list_size,
mhdf_Status status 
)

Create adjacency data table for nodes, elements, polys, etc.

Adjacency data.

Adjacency data is formated as a sequence of integer groups where the first entry in each group is the ID of the element for which adjacencies are being specified, the second value is the count of adjacent entities, and the remainder of the group is the list of IDs of the adjacent entities.

Create file object for adjacency data for a nodes or a specified element group.

Adjacency data is formated as a sequence of integer groups where the first entry in each group is the ID of the element for which adjacencies are being specified, the second value is the count of adjacent entities, and the remainder of the group is the list of IDs of the adjacent entities.

Parameters
file_handleThe file.
elem_handleThe element group (or the result of mhdf_node_type_handle for nodes) for which the adjacency data is to be specified.
adj_list_sizeThe total number of integer values contained in the adjacency data for the specified element group.
statusPassed back status of API call.
Returns
The HDF5 handle to the connectivity data.

Definition at line 61 of file adjacency.c.

62 {
63  FileHandle* file_ptr;
64  hid_t elem_id, table_id;
65  hsize_t dim = (hsize_t)adj_list_size;
66  API_BEGIN;
67 
68  file_ptr = (FileHandle*)( file );
69  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
70 
71  if( adj_list_size < 1 )
72  {
73  mhdf_setFail( status, "Invalid argument.\n" );
74  return -1;
75  }
76 
77  if( elem_handle == mhdf_node_type_handle() )
78  {
79  table_id = mhdf_create_table( file_ptr->hdf_handle, NODE_ADJCY_PATH, file_ptr->id_type, 1, &dim, status );
80  }
81  else
82  {
83  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
84  if( elem_id < 0 ) return -1;
85 
86  table_id = mhdf_create_table( elem_id, ADJACENCY_NAME, file_ptr->id_type, 1, &dim, status );
87  H5Gclose( elem_id );
88  }
89 
90  API_END_H( 1 );
91  return table_id;
92 }

References ADJACENCY_NAME, API_BEGIN, API_END_H, dim, struct_FileHandle::hdf_handle, struct_FileHandle::id_type, mhdf_check_valid_file(), mhdf_create_table(), mhdf_elem_group_from_handle(), mhdf_node_type_handle(), mhdf_setFail(), and NODE_ADJCY_PATH.

Referenced by moab::WriteHDF5Parallel::create_adjacency_tables(), and moab::WriteHDF5::serial_create_file().

◆ mhdf_createConnectivity()

hid_t mhdf_createConnectivity ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
int  nodes_per_elem,
long  count,
long *  first_id_out,
mhdf_Status status 
)

Create connectivity table for an element group.

Create fixed-connectivity data for an element group. Do NOT use this function for poly(gon/hedron) data.

Parameters
file_handleThe file.
elem_handleThe element group.
num_nodes_per_elemThe number of nodes in the connectivity data for each element.
num_elementsThe number of elements to be written to the table.
first_elem_id_outElements are assigned global IDs in sequential blocks where the block is the table in which their connectivity data is written and the sequence is the sequence in which they are written in that table. The global ID for the first element in this group is passed back at this address. The global IDs for all other elements in the table are assigned in the sequence in which they are written in the table.
statusPassed back status of API call.
Returns
The HDF5 handle to the connectivity data.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

Copyright 2004 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Definition at line 26 of file connectivity.c.

32 {
33  FileHandle* file_ptr;
34  hid_t elem_id, table_id;
35  hsize_t dims[2];
36  long first_id;
37  API_BEGIN;
38 
39  file_ptr = (FileHandle*)( file_handle );
40  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
41 
42  if( nodes_per_elem <= 0 || count < 0 || !first_id_out )
43  {
44  mhdf_setFail( status, "Invalid argument." );
45  return -1;
46  }
47 
48  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
49  if( elem_id < 0 ) return -1;
50 
51  dims[0] = (hsize_t)count;
52  dims[1] = (hsize_t)nodes_per_elem;
53  table_id = mhdf_create_table( elem_id, CONNECTIVITY_NAME, file_ptr->id_type, 2, dims, status );
54  H5Gclose( elem_id );
55  if( table_id < 0 ) return -1;
56 
57  first_id = file_ptr->max_id + 1;
58  if( !mhdf_create_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status ) )
59  {
60  H5Dclose( table_id );
61  return -1;
62  }
63 
64  *first_id_out = first_id;
65  file_ptr->max_id += count;
66  if( !mhdf_write_max_id( file_ptr, status ) )
67  {
68  H5Dclose( table_id );
69  return -1;
70  }
71  file_ptr->open_handle_count++;
72  mhdf_setOkay( status );
73 
74  API_END_H( 1 );
75  return table_id;
76 }

References API_BEGIN, API_END_H, CONNECTIVITY_NAME, struct_FileHandle::id_type, struct_FileHandle::max_id, mhdf_check_valid_file(), mhdf_create_scalar_attrib(), mhdf_create_table(), mhdf_elem_group_from_handle(), mhdf_setFail(), mhdf_setOkay(), mhdf_write_max_id(), struct_FileHandle::open_handle_count, and START_ID_ATTRIB.

Referenced by moab::WriteHDF5::create_elem_table().

◆ mhdf_createDenseTagData()

hid_t mhdf_createDenseTagData ( mhdf_FileHandle  file_handle,
const char *  tag_name,
const char *  elem_group,
long  num_values,
mhdf_Status status 
)

Create an object to hold dense tag values for a given element group.

Parameters
file_handleThe file.
tag_nameThe tag.
elem_groupThe element group handle, or the return value of mhdf_node_type_handle or mhdf_set_type_handle for nodes or sets respectively.
num_valuesThe number of tag values to be written. Must be The same as the number of elements in the group. Specified here to allow tag values to be written before node coordinates, element connectivity or meshsets.
statusPassed back status of API call.
Returns
Handle to data object in file.

Definition at line 1268 of file tags.c.

1273 {
1274  char* path;
1275  hid_t elem_id, data_id, type_id;
1276  FileHandle* file_ptr;
1277  size_t name_len, path_len, dir_len;
1278  hsize_t size;
1279  API_BEGIN;
1280 
1281  file_ptr = (FileHandle*)file_handle;
1282  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
1283 
1284  if( type_handle == mhdf_node_type_handle() )
1285  {
1286 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
1287  elem_id = H5Gopen2( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
1288 #else
1289  elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
1290 #endif
1291  if( elem_id < 0 ) mhdf_setFail( status, "Could not open node group." );
1292  }
1293  else if( type_handle == mhdf_set_type_handle() )
1294  {
1295 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
1296  elem_id = H5Gopen2( file_ptr->hdf_handle, SET_GROUP, H5P_DEFAULT );
1297 #else
1298  elem_id = H5Gopen( file_ptr->hdf_handle, SET_GROUP );
1299 #endif
1300  if( elem_id < 0 ) mhdf_setFail( status, "Could not open set group." );
1301  }
1302  else
1303  {
1304  elem_id = mhdf_elem_group_from_handle( file_ptr, type_handle, status );
1305  }
1306  if( elem_id < 0 ) return -1;
1307 
1308  dir_len = strlen( DENSE_TAG_SUBGROUP );
1309  name_len = mhdf_name_to_path( tag_name, NULL, 0 );
1310  path_len = dir_len + name_len + 1;
1311  path = (char*)mhdf_malloc( path_len, status );
1312  if( NULL == path )
1313  {
1314  H5Gclose( elem_id );
1315  return -1;
1316  }
1317  strcpy( path, DENSE_TAG_SUBGROUP );
1318  mhdf_name_to_path( tag_name, path + dir_len, name_len + 1 );
1319 
1320  type_id = get_tag_type( file_ptr, path + dir_len, status );
1321  if( type_id < 0 )
1322  {
1323  H5Gclose( elem_id );
1324  return -1;
1325  }
1326 
1327  size = (hsize_t)num_values;
1328  data_id = mhdf_create_table( elem_id, path, type_id, 1, &size, status );
1329  free( path );
1330  H5Gclose( elem_id );
1331  H5Tclose( type_id );
1332 
1333  if( data_id > 0 ) mhdf_setOkay( status );
1334 
1335  API_END_H( 1 );
1336  return data_id;
1337 }

References API_BEGIN, API_END_H, DENSE_TAG_SUBGROUP, get_tag_type(), struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_create_table(), mhdf_elem_group_from_handle(), mhdf_malloc(), mhdf_name_to_path(), mhdf_node_type_handle(), mhdf_set_type_handle(), mhdf_setFail(), mhdf_setOkay(), NODE_GROUP, SET_GROUP, and size.

Referenced by moab::WriteHDF5::create_tag().

◆ mhdf_createNodeCoords()

hid_t mhdf_createNodeCoords ( mhdf_FileHandle  file_handle,
int  dimension,
long  num_nodes,
long *  first_node_id_out,
mhdf_Status status 
)

Create new table for node coordinate data.

Parameters
file_handleThe file.
dimensionNumber of coordinate values per node.
num_nodesThe number of nodes the table will contain.
first_node_id_outNodes are assigned IDs sequentially in the order they occur in the table, where the ID of the first node in the table is this passed-back value.
statusPassed back status of API call.
Returns
An HDF5 handle to the coordinate table.

Definition at line 72 of file nodes.c.

77 {
78  FileHandle* file_ptr = (FileHandle*)file_handle;
79  hid_t table_id;
80  hsize_t dims[2];
81  long first_id;
82  API_BEGIN;
83 
84  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
85 
86  if( dimension < 1 )
87  {
88  mhdf_setFail( status, "Invalid argument: dimension = %d.", dimension );
89  return -1;
90  }
91 
92  dims[0] = (hsize_t)num_nodes;
93  dims[1] = (hsize_t)dimension;
94  table_id = mhdf_create_table( file_ptr->hdf_handle, NODE_COORD_PATH, H5T_NATIVE_DOUBLE, 2, dims, status );
95  if( table_id < 0 ) return -1;
96 
97  first_id = file_ptr->max_id + 1;
98  if( !mhdf_create_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status ) )
99  {
100  H5Dclose( table_id );
101  return -1;
102  }
103 
104  *first_id_out = first_id;
105  file_ptr->max_id += num_nodes;
106  if( !mhdf_write_max_id( file_ptr, status ) )
107  {
108  H5Dclose( table_id );
109  return -1;
110  }
111  file_ptr->open_handle_count++;
112  mhdf_setOkay( status );
113 
114  API_END_H( 1 );
115  return table_id;
116 }

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, struct_FileHandle::max_id, mhdf_check_valid_file(), mhdf_create_scalar_attrib(), mhdf_create_table(), mhdf_setFail(), mhdf_setOkay(), mhdf_write_max_id(), NODE_COORD_PATH, struct_FileHandle::open_handle_count, and START_ID_ATTRIB.

Referenced by moab::WriteHDF5Parallel::create_node_table(), and moab::WriteHDF5::serial_create_file().

◆ mhdf_createPolyConnectivity()

void mhdf_createPolyConnectivity ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
long  num_poly,
long  data_list_length,
long *  first_id_out,
hid_t  idx_and_id_handles_out[2],
mhdf_Status status 
)

Create a new table for polygon or polyhedron connectivity data.

Poly (polygon or polyhedron) connectivity is stored as two lists. One list is the concatenation of the the connectivity data for all the polys in the group. The other contains one value per poly where that value is the index of the last entry in the connectivity of the corresponding poly. The ID list for polygons contains global node IDs. The ID list for polyhedra contains the global IDs of faces (either polygons or 2D fixed-connectivity elements.)

Parameters
file_handleThe file to write.
elem_handleThe element group.
num_polyThe total number number of polygons or polyhedra to be written in the table.
data_list_lengthThe total number of values to be written to the table (the number of polys plus the sum of the number of entities in each poly's connectivity data.)
first_id_outElements are assigned global IDs in sequential blocks where the block is the table in which their connectivity data is written and the sequence is the sequence in which they are written in that table. The global ID for the first element in this group is passed back at this address. The global IDs for all other elements in the table are assigned in the sequence in which they are written in the table.
idx_and_id_handles_outThe handles for the index list and connectivity list, respectively.
statusPassed back status of API call.

Definition at line 187 of file connectivity.c.

194 {
195  FileHandle* file_ptr;
196  hid_t elem_id, index_id, conn_id;
197  hsize_t dim;
198  long first_id;
199  API_BEGIN;
200 
201  file_ptr = (FileHandle*)( file_handle );
202  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
203 
204  if( num_poly <= 0 || data_list_length <= 0 || !first_id_out )
205  {
206  mhdf_setFail( status, "Invalid argument." );
207  return;
208  }
209 
210  if( data_list_length < 3 * num_poly )
211  {
212  /* Could check agains 4*num_poly, but allow degenerate polys
213  (1 for count plus 2 dim-1 defining entities, where > 2
214  defining entities is a normal poly, 2 defining entities
215  is a degenerate poly and 1 defning entity is not valid.)
216  */
217 
218  mhdf_setFail( status,
219  "Invalid polygon data: data length of %ld is "
220  "insufficient for %ld poly(gons/hedra).\n",
221  data_list_length, num_poly );
222  return;
223  }
224 
225  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_type, status );
226  if( elem_id < 0 ) return;
227 
228  dim = (hsize_t)num_poly;
229  index_id = mhdf_create_table( elem_id, POLY_INDEX_NAME, MHDF_INDEX_TYPE, 1, &dim, status );
230  if( index_id < 0 )
231  {
232  H5Gclose( elem_id );
233  return;
234  }
235 
236  dim = (hsize_t)data_list_length;
237  conn_id = mhdf_create_table( elem_id, CONNECTIVITY_NAME, file_ptr->id_type, 1, &dim, status );
238  H5Gclose( elem_id );
239  if( conn_id < 0 )
240  {
241  H5Dclose( index_id );
242  return;
243  }
244 
245  first_id = file_ptr->max_id + 1;
246  if( !mhdf_create_scalar_attrib( conn_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status ) )
247  {
248  H5Dclose( index_id );
249  H5Dclose( conn_id );
250  return;
251  }
252 
253  *first_id_out = first_id;
254  file_ptr->max_id += num_poly;
255  if( !mhdf_write_max_id( file_ptr, status ) )
256  {
257  H5Dclose( index_id );
258  H5Dclose( conn_id );
259  return;
260  }
261  file_ptr->open_handle_count++;
262  mhdf_setOkay( status );
263  handles_out[0] = index_id;
264  handles_out[1] = conn_id;
265  API_END_H( 2 );
266 }

References API_BEGIN, API_END_H, CONNECTIVITY_NAME, dim, struct_FileHandle::id_type, struct_FileHandle::max_id, mhdf_check_valid_file(), mhdf_create_scalar_attrib(), mhdf_create_table(), mhdf_elem_group_from_handle(), MHDF_INDEX_TYPE, mhdf_setFail(), mhdf_setOkay(), mhdf_write_max_id(), struct_FileHandle::open_handle_count, POLY_INDEX_NAME, and START_ID_ATTRIB.

◆ mhdf_createSetChildren()

hid_t mhdf_createSetChildren ( mhdf_FileHandle  file_handle,
long  child_list_size,
mhdf_Status status 
)

Create file object for storing the set child list.

Create a data group for the list of set children.
The format of this data is the concatenation of the lists of global IDs of child sets for each set. The order of the sets and the number of children for each set is contained in the set meta table. (See mhdf_createSetMeta ).

Parameters
file_handleThe file
child_list_sizeThe total length of the data (the sum of the number of children for each set.)
statusPassed back status of API call.
Returns
A handle to the data object in the file.

Definition at line 718 of file sets.c.

719 {
720  FileHandle* file_ptr;
721  hid_t table_id;
722  hsize_t dim = (hsize_t)child_list_size;
723  API_BEGIN;
724 
725  file_ptr = (FileHandle*)( file_handle );
726  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
727 
728  if( child_list_size < 1 )
729  {
730  mhdf_setFail( status, "Invalid argument.\n" );
731  return -1;
732  }
733 
734  table_id = mhdf_create_table( file_ptr->hdf_handle, SET_CHILD_PATH, file_ptr->id_type, 1, &dim, status );
735 
736  API_END_H( 1 );
737  return table_id;
738 }

References API_BEGIN, API_END_H, dim, struct_FileHandle::hdf_handle, struct_FileHandle::id_type, mhdf_check_valid_file(), mhdf_create_table(), mhdf_setFail(), and SET_CHILD_PATH.

Referenced by moab::WriteHDF5::create_set_tables().

◆ mhdf_createSetData()

hid_t mhdf_createSetData ( mhdf_FileHandle  file_handle,
long  data_list_size,
mhdf_Status status 
)

Create file object to hold list of meshset contents.

Create set contents data object. The format of this data is a vector of integer values which is the concatenation of the contents list for all the meshsets. The length and format of the data for each set is stored in the set meta table. See mhdf_createSetMeta and mhdf_SET_RANGE_BIT for a description of that data.

Parameters
file_handleThe file.
data_list_sizeThe total length (number of integer values) to be written for all the sets.
statusPassed back status of API call.
Returns
A handle to the table.

Definition at line 635 of file sets.c.

636 {
637  FileHandle* file_ptr;
638  hid_t table_id;
639  hsize_t dim = (hsize_t)data_list_size;
640  API_BEGIN;
641 
642  file_ptr = (FileHandle*)( file_handle );
643  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
644 
645  if( data_list_size < 1 )
646  {
647  mhdf_setFail( status, "Invalid argument.\n" );
648  return -1;
649  }
650 
651  table_id = mhdf_create_table( file_ptr->hdf_handle, SET_DATA_PATH, file_ptr->id_type, 1, &dim, status );
652 
653  API_END_H( 1 );
654  return table_id;
655 }

References API_BEGIN, API_END_H, dim, struct_FileHandle::hdf_handle, struct_FileHandle::id_type, mhdf_check_valid_file(), mhdf_create_table(), mhdf_setFail(), and SET_DATA_PATH.

Referenced by moab::WriteHDF5::create_set_tables().

◆ mhdf_createSetMeta()

hid_t mhdf_createSetMeta ( mhdf_FileHandle  file_handle,
long  num_sets,
long *  first_set_id_out,
mhdf_Status status 
)

Create table holding list of meshsets and their properties.

The set table contains description of sets, but not contents or children. The table is a n x 4 matrix of values.
One row for each of n sets. Each row contains the end index for the set in the contents table, the end index for the set in the children table, the end index for the set in the parents table, and the set flags, respectively. The mhdf_SET_RANGE_BIT bit in the flags specifies the format of the contents list for each set. See a description of the mhdf_SET_RANGE_BIT flag for a description of the two possible data formats. The index values in the first two columns of the table are the index of the last value for the set in the corresponding contents and children lists. The first index is always one greater than the last index for the previous set in the table. The first index of the first set in the table is implicitly zero. A special value of -1 in the appropriate column should be used to indicate that the first set contains no contents or has no children. For any other set, if the last index for the set is the same as that of the previous set, it has no data in the corresponding list.

Parameters
file_handleThe file.
num_setsThe number of sets in the table.
first_set_id_outThe global ID that will be assigned to the first set in the table. All subsequent sets in the table will be assigned sequential global IDs.
statusPassed back status of API call.
Returns
The handle to the set meta-data table.

Definition at line 109 of file sets.c.

110 {
111  FileHandle* file_ptr = (FileHandle*)file;
112  hid_t table_id;
113  hsize_t dims[2];
114  long first_id;
115  API_BEGIN;
116 
117  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
118 
119  dims[0] = (hsize_t)num_sets;
120  dims[1] = (hsize_t)4;
121  table_id = mhdf_create_table( file_ptr->hdf_handle, SET_META_PATH, MHDF_INDEX_TYPE, 2, dims, status );
122  if( table_id < 0 ) return -1;
123 
124  first_id = file_ptr->max_id + 1;
125  if( !mhdf_create_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status ) )
126  {
127  H5Dclose( table_id );
128  return -1;
129  }
130 
131  *first_id_out = first_id;
132  file_ptr->max_id += num_sets;
133  if( !mhdf_write_max_id( file_ptr, status ) )
134  {
135  H5Dclose( table_id );
136  return -1;
137  }
138  file_ptr->open_handle_count++;
139  mhdf_setOkay( status );
140 
141  API_END_H( 1 );
142  return table_id;
143 }

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, struct_FileHandle::max_id, mhdf_check_valid_file(), mhdf_create_scalar_attrib(), mhdf_create_table(), MHDF_INDEX_TYPE, mhdf_setOkay(), mhdf_write_max_id(), struct_FileHandle::open_handle_count, SET_META_PATH, and START_ID_ATTRIB.

Referenced by moab::WriteHDF5::create_set_meta().

◆ mhdf_createSetParents()

hid_t mhdf_createSetParents ( mhdf_FileHandle  file_handle,
long  parent_list_size,
mhdf_Status status 
)

Create file object for storing the set parent list.

Create a data group for the list of set parents.
The format of this data is the concatenation of the lists of global IDs of parent sets for each set. The order of the sets and the number of parents for each set is contained in the set meta table. (See mhdf_createSetMeta ).

Parameters
file_handleThe file
parent_list_sizeThe total length of the data (the sum of the number of parents for each set.)
statusPassed back status of API call.
Returns
A handle to the data object in the file.

Definition at line 763 of file sets.c.

764 {
765  FileHandle* file_ptr;
766  hid_t table_id;
767  hsize_t dim = (hsize_t)parent_list_size;
768  API_BEGIN;
769 
770  file_ptr = (FileHandle*)( file_handle );
771  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
772 
773  if( parent_list_size < 1 )
774  {
775  mhdf_setFail( status, "Invalid argument.\n" );
776  return -1;
777  }
778 
779  table_id = mhdf_create_table( file_ptr->hdf_handle, SET_PARENT_PATH, file_ptr->id_type, 1, &dim, status );
780 
781  API_END_H( 1 );
782  return table_id;
783 }

References API_BEGIN, API_END_H, dim, struct_FileHandle::hdf_handle, struct_FileHandle::id_type, mhdf_check_valid_file(), mhdf_create_table(), mhdf_setFail(), and SET_PARENT_PATH.

Referenced by moab::WriteHDF5::create_set_tables().

◆ mhdf_createSparseTagData()

void mhdf_createSparseTagData ( mhdf_FileHandle  file_handle,
const char *  tag_name,
long  num_values,
hid_t  entities_and_values_out[2],
mhdf_Status status 
)

Create file objects to store sparse tag data.

Create the file objects to store all sparse data for a given tag in. The sparse data is stored in a pair of objects. The first is a vector of global IDs. The second is a vector of tag values for each entity specified in the list of global IDs.

Parameters
file_handleThe file.
tag_nameThe tag.
num_valuesThe number of tag values to be written.
entities_and_values_outThe handles to the file objects. The first is the vector of global IDs. The second is the list of corresponding tag values.
statusPassed back status of API call.

Definition at line 1402 of file tags.c.

1407 {
1408  hid_t tag_id, index_id, data_id, type_id, id_type;
1409  hsize_t count = (hsize_t)num_values;
1410  API_BEGIN;
1411 
1412  tag_id = get_tag( file_handle, tag_name, &id_type, status );
1413  if( tag_id < 0 ) return;
1414 
1415 #if defined( H5Topen_vers ) && H5Topen_vers > 1
1416  type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
1417 #else
1418  type_id = H5Topen( tag_id, TAG_TYPE_NAME );
1419 #endif
1420  if( type_id < 0 )
1421  {
1422  H5Gclose( tag_id );
1423  mhdf_setFail( status, "Failed to get type object for tag \"%s\".", tag_name );
1424  return;
1425  }
1426 
1427  index_id = mhdf_create_table( tag_id, SPARSE_ENTITY_NAME, id_type, 1, &count, status );
1428  if( index_id < 0 )
1429  {
1430  H5Gclose( tag_id );
1431  H5Tclose( type_id );
1432  return;
1433  }
1434 
1435  data_id = mhdf_create_table( tag_id, SPARSE_VALUES_NAME, type_id, 1, &count, status );
1436  H5Tclose( type_id );
1437  H5Gclose( tag_id );
1438  if( data_id < 0 )
1439  {
1440  H5Dclose( index_id );
1441  return;
1442  }
1443 
1444  handles_out[0] = index_id;
1445  handles_out[1] = data_id;
1446  mhdf_setOkay( status );
1447  API_END_H( 2 );
1448 }

References API_BEGIN, API_END_H, get_tag(), mhdf_create_table(), mhdf_setFail(), mhdf_setOkay(), SPARSE_ENTITY_NAME, SPARSE_VALUES_NAME, and TAG_TYPE_NAME.

Referenced by moab::WriteHDF5::create_tag().

◆ mhdf_createTag()

void mhdf_createTag ( mhdf_FileHandle  file_handle,
const char *  tag_name,
enum mhdf_TagDataType  tag_type,
int  size,
int  storage,
const void *  default_value,
const void *  global_value,
hid_t  hdf_type,
hid_t  mhdf_base_type,
mhdf_Status status 
)

Add a tag to the file.

Add a new tag to the file. This function must be called to define the tag characteristics before values for the tag can be written.

Parameters
file_handleThe file
tag_nameThe tag name
tag_typeThe tag type.
sizeIf tag_type == mhdf_BITFIELD, the number of bits. If tag_type == mhdf_OPAQUE, the size of the opaque type in bytes. Otherwise the length of the array of tag_type entities associated with each mesh entity, or 1 for a scalar value.
storageMOAB storage type (dense, sparse, etc.)
default_valueDefault value for tag, or NULL if none.
global_valueGlobal value for tag, or NULL if none.
hdf_typeIf non-zero, assumed to be a user-specified type for opaque data. Ignored if tag_type is not mhdf_OPAQUE.
hdf_base_typeIgnored if hdf_type is non-zero. If hdf_type is zero and this type is non-zero, it is used either as the type or as the base type for an array type for default_value and global_value, respectively. Typically used to specify the input data type for mhdf_ENTITY_ID tags.

Definition at line 570 of file tags.c.

580 {
581  hid_t tag_id;
582  API_BEGIN;
583  tag_id = create_tag_common( file_handle, tag_name, tag_type, size, storage, default_value, 1, global_value, 1,
584  hdf_type, hdf_base_type, status );
585  if( tag_id >= 0 ) H5Gclose( tag_id );
586  API_END;
587 }

References API_BEGIN, API_END, create_tag_common(), and size.

Referenced by moab::WriteHDF5::create_tag().

◆ mhdf_createVarLenTag()

void mhdf_createVarLenTag ( mhdf_FileHandle  file_handle,
const char *  tag_name,
enum mhdf_TagDataType  tag_type,
int  storage,
const void *  default_value,
int  default_value_length,
const void *  global_value,
int  global_value_length,
hid_t  hdf_type,
hid_t  hdf_base_type,
mhdf_Status status 
)

Add variable-length tag to file.

Add a new tag to the file. This function must be called to define the tag characteristics before values for the tag can be written. Use this function if the tag values are not fixed-length.

Parameters
file_handleThe file
tag_nameThe tag name
tag_typeThe tag type.
storageMOAB storage type (dense, sparse, etc.)
default_valueDefault value for tag, or NULL if none.
default_value_lengthLength of default value.
global_valueGlobal value for tag, or NULL if none.
global_value_lengthLength of global value.
hdf_typeIf non-zero, assumed to be a user-specified type for opaque data. Ignored if tag_type is not mhdf_OPAQUE.
hdf_base_typeIgnored if hdf_type is non-zero. If hdf_type is zero and this type is non-zero, it is used either as the type or as the base type for an array type for default_value and global_value, respectively. Typically used to specify the input data type for mhdf_ENTITY_ID tags.

Definition at line 589 of file tags.c.

600 {
601  hid_t tag_id;
602  int one = 1;
603 
604  API_BEGIN;
605  tag_id = create_tag_common( file_handle, tag_name, tag_type, -1, storage, default_value, default_value_length,
606  global_value, global_value_length, hdf_type, hdf_base_type, status );
607  if( tag_id >= 0 )
608  {
609  mhdf_create_scalar_attrib( tag_id, TAG_VARLEN_ATTRIB, H5T_NATIVE_INT, &one, status );
610  H5Gclose( tag_id );
611  }
612  API_END;
613 }

References API_BEGIN, API_END, create_tag_common(), mhdf_create_scalar_attrib(), and TAG_VARLEN_ATTRIB.

Referenced by moab::WriteHDF5::create_tag().

◆ mhdf_createVarLenTagData()

void mhdf_createVarLenTagData ( mhdf_FileHandle  file_handle,
const char *  tag_name,
long  num_entities,
long  num_values,
hid_t  entities_and_values_out[3],
mhdf_Status status 
)

Create file objects to store (sparse) variable-length tag data.

Create the file objects to store all sparse data for a given tag in. The sparse data is stored in a pair of objects. The first is a vector of global IDs. The second is a vector of tag values for each entity specified in the list of global IDs.

Parameters
file_handleThe file.
tag_nameThe tag.
num_entitiesThe number of entities for which tag values are to be stored
num_valuesThe total number of scalar values to be written (the total number of bytes of data for all tags for opaque data.)
entities_and_values_outThe handles to the file objects. The first is the vector of global IDs. The second is the list of corresponding tag values. The third is the handle to the index table.
statusPassed back status of API call.

Definition at line 1450 of file tags.c.

1456 {
1457  hid_t tag_id, index_id, data_id, type_id, offset_id, id_type;
1458  hsize_t count = (hsize_t)num_entities;
1459  API_BEGIN;
1460 
1461  tag_id = get_tag( file_handle, tag_name, &id_type, status );
1462  if( tag_id < 0 ) return;
1463 
1464 #if defined( H5Topen_vers ) && H5Topen_vers > 1
1465  type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
1466 #else
1467  type_id = H5Topen( tag_id, TAG_TYPE_NAME );
1468 #endif
1469  if( type_id < 0 )
1470  {
1471  H5Gclose( tag_id );
1472  mhdf_setFail( status, "Failed to get type object for tag \"%s\".", tag_name );
1473  return;
1474  }
1475 
1476  index_id = mhdf_create_table( tag_id, SPARSE_ENTITY_NAME, id_type, 1, &count, status );
1477  if( index_id < 0 )
1478  {
1479  H5Gclose( tag_id );
1480  H5Tclose( type_id );
1481  return;
1482  }
1483 
1484  offset_id = mhdf_create_table( tag_id, TAG_VAR_INDICES, MHDF_INDEX_TYPE, 1, &count, status );
1485  if( index_id < 0 )
1486  {
1487  H5Dclose( offset_id );
1488  H5Gclose( tag_id );
1489  H5Tclose( type_id );
1490  return;
1491  }
1492 
1493  count = (hsize_t)num_values;
1494  data_id = mhdf_create_table( tag_id, SPARSE_VALUES_NAME, type_id, 1, &count, status );
1495  H5Tclose( type_id );
1496  H5Gclose( tag_id );
1497  if( data_id < 0 )
1498  {
1499  H5Dclose( offset_id );
1500  H5Dclose( index_id );
1501  return;
1502  }
1503 
1504  handles_out[0] = index_id;
1505  handles_out[1] = data_id;
1506  handles_out[2] = offset_id;
1507  mhdf_setOkay( status );
1508  API_END_H( 3 );
1509 }

References API_BEGIN, API_END_H, get_tag(), mhdf_create_table(), MHDF_INDEX_TYPE, mhdf_setFail(), mhdf_setOkay(), SPARSE_ENTITY_NAME, SPARSE_VALUES_NAME, TAG_TYPE_NAME, and TAG_VAR_INDICES.

Referenced by moab::WriteHDF5::create_tag().

◆ mhdf_getElemHandles()

char** mhdf_getElemHandles ( mhdf_FileHandle  file_handle,
unsigned int *  count_out,
mhdf_Status status 
)

Get the list of element groups in the file.

Get the list of element groups in the file. An element group is the data for a block of elements with the same TSTT type and same number of nodes in their connectivity data. (e.g. all the MBHEX20 elements). This function is also used to retrieve the groups for general polygon data and general polyhedron data. The requirement that all elements have the same number of nodes in their connectivity does not apply for poly(gons|hedra).

Parameters
file_handleThe file.
count_outMemory location at which to store the length of the returned array.
statusPassed back status of API call.
Returns
An array of pointers to element group names. This array is allocated as a single memory block and should be freed with one call to free().

Definition at line 586 of file file.c.

587 {
588  hsize_t count, length, i;
589  char** buffer;
590  char* current;
591  hid_t group_id;
592  herr_t rval;
593  ssize_t rlen = 0;
594  size_t remaining;
595  FileHandle* file_ptr = (FileHandle*)file_handle;
596  if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
597 
598 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
599  group_id = H5Gopen2( file_ptr->hdf_handle, ELEMENT_GROUP, H5P_DEFAULT );
600 #else
601  group_id = H5Gopen( file_ptr->hdf_handle, ELEMENT_GROUP );
602 #endif
603  if( group_id < 0 )
604  {
605  mhdf_setFail( status, "Invalid file -- element group does not exist." );
606  return NULL;
607  }
608 
609  rval = H5Gget_num_objs( group_id, &count );
610  if( rval < 0 )
611  {
612  H5Gclose( group_id );
613  mhdf_setFail( status, "Internal error calling H5Gget_num_objs." );
614  return NULL;
615  }
616  *count_out = count;
617 
618  for( i = 0; i < count; ++i )
619  {
620  rlen += H5Gget_objname_by_idx( group_id, i, NULL, 0 ) + 1;
621  }
622 
623  length = count * sizeof( char* ) + rlen;
624  buffer = (char**)mhdf_malloc( length, status );
625  if( !buffer )
626  {
627  H5Gclose( group_id );
628  return NULL;
629  }
630  current = (char*)( buffer + count );
631  remaining = rlen;
632 
633  for( i = 0; i < count; ++i )
634  {
635  buffer[i] = current;
636  rlen = H5Gget_objname_by_idx( group_id, i, current, remaining ) + 1;
637  if( rlen < 0 )
638  {
639  H5Gclose( group_id );
640  free( buffer );
641  mhdf_setFail( status, "Internal error calling H5Gget_objname_by_idx." );
642  return NULL;
643  }
644 
645  mhdf_path_to_name( current, current );
646  remaining -= rlen;
647  current += rlen;
648  }
649 
650  H5Gclose( group_id );
651  mhdf_setOkay( status );
652  return buffer;
653 }

References buffer, ELEMENT_GROUP, struct_FileHandle::hdf_handle, length(), mhdf_check_valid_file(), mhdf_malloc(), mhdf_path_to_name(), mhdf_setFail(), and mhdf_setOkay().

Referenced by main(), and mhdf_getFileSummary().

◆ mhdf_getElemName()

void mhdf_getElemName ( mhdf_FileHandle  file_handle,
unsigned int  type_index,
char *  buffer,
size_t  buffer_size,
mhdf_Status status 
)

Given an element type Id, get the name. Fails if buffer is not of sufficient size.

Parameters
file_handleThe file.
type_indexThe type index. Corresponds to indices into the element type list passed to mhdf_createFile.
bufferThe buffer into which to copy the name.
buffer_sizeThe length of buffer.
statusPassed back status of API call.

Definition at line 368 of file file.c.

373 {
374  FileHandle* file_ptr;
375  herr_t rval;
376  hid_t enum_id;
377  API_BEGIN;
378 
379  if( type_index > 255 )
380  {
381  mhdf_setFail( status, "Type index out of bounds." );
382  return;
383  }
384 
385  file_ptr = (FileHandle*)( file_handle );
386  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
387 
388  enum_id = get_elem_type_enum( file_ptr, status );
389  if( enum_id < 0 ) return;
390 
391  rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super( enum_id ), 1, &type_index, NULL, H5P_DEFAULT );
392  if( rval < 0 )
393  {
394  H5Tclose( enum_id );
395  mhdf_setFail( status, "Internal error converting to enum type." );
396  return;
397  }
398 
399  rval = H5Tenum_nameof( enum_id, &type_index, buffer, buf_size );
400  H5Tclose( enum_id );
401  if( rval < 0 )
402  mhdf_setFail( status, "H5Tenum_nameof failed. Invalid type index?" );
403  else
404  mhdf_setOkay( status );
405 
406  API_END;
407 }

References API_BEGIN, API_END, buffer, get_elem_type_enum(), mhdf_check_valid_file(), mhdf_setFail(), and mhdf_setOkay().

◆ mhdf_getElemTypeName()

void mhdf_getElemTypeName ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
char *  buffer,
size_t  buf_len,
mhdf_Status status 
)

Get the element type name for a given element group handle.

Fails if name is longer than buf_len.

Parameters
file_handleThe file.
elem_handleOne of the group names passed back from mhdf_getElemHandles
bufferA buffer to copy the name into.
buf_lenThe length of buffer.
statusPassed back status of API call.

Definition at line 655 of file file.c.

660 {
661  FileHandle* file_ptr;
662  hid_t elem_id, type_id, attr_id;
663  char bytes[16];
664  herr_t rval;
665  API_BEGIN;
666 
667  if( NULL == buffer || buf_len < 2 )
668  {
669  mhdf_setFail( status, "invalid input" );
670  return;
671  }
672  buffer[0] = '\0';
673 
674  file_ptr = (FileHandle*)( file_handle );
675  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
676 
677  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
678  if( elem_id < 0 ) return;
679 
680  attr_id = H5Aopen_name( elem_id, ELEM_TYPE_ATTRIB );
681  H5Gclose( elem_id );
682  if( attr_id < 0 )
683  {
684  mhdf_setFail( status, "Missing element type attribute. Invalid file." );
685  return;
686  }
687 
688  type_id = H5Aget_type( attr_id );
689  assert( type_id > 0 );
690 
691  rval = H5Aread( attr_id, type_id, bytes );
692  H5Aclose( attr_id );
693  if( rval < 0 )
694  {
695  H5Tclose( type_id );
696  mhdf_setFail( status, "Failed to read element type attribute. Invalid file." );
697  return;
698  }
699 
700  rval = H5Tenum_nameof( type_id, bytes, buffer, buf_len );
701  H5Tclose( type_id );
702  if( rval < 0 )
703  {
704  mhdf_setFail( status, "Invalid datatype for element type attribute. Invalid file." );
705  return;
706  }
707 
708  mhdf_setOkay( status );
709  API_END;
710  return;
711 }

References API_BEGIN, API_END, buffer, ELEM_TYPE_ATTRIB, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_setFail(), and mhdf_setOkay().

Referenced by get_elem_desc(), and main().

◆ mhdf_getNativeType()

hid_t mhdf_getNativeType ( hid_t  input_type,
int  size,
mhdf_Status status 
)

Make type native-endian.

Given an atomic HDF5 data type, return the built-in type that matches the class of the passed type and is the specified size.

This function is provided to allow converting the stored tag type in a file to the preferred type for it's representation in memory when reading tag values.

This function works only for atomic types. The returned type will be a pre-defined HDF5 object and does not need to be closed/released.

Parameters
input_typeThe type to convert.
sizeThe desired size in bytes.
statusPassed back status of API call.
Returns
The converted type.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

Copyright 2004 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Definition at line 30 of file tags.c.

31 {
32  H5T_sign_t sgn;
33  H5T_class_t cls;
34  hid_t tmp_id, type_id;
35 
36  mhdf_setOkay( status );
37 
38  cls = H5Tget_class( input_type );
39  switch( cls )
40  {
41  case H5T_FLOAT:
42  switch( size )
43  {
44  case 4:
45  return H5T_NATIVE_FLOAT;
46  case 8:
47  return H5T_NATIVE_DOUBLE;
48  case 16:
49  return H5T_NATIVE_LDOUBLE;
50  default:
51  mhdf_setFail( status, "Invalid size for floating point type: %d", size );
52  return -1;
53  }
54 
55  case H5T_INTEGER:
56  sgn = H5Tget_sign( input_type );
57  if( H5T_SGN_ERROR == sgn )
58  {
59  mhdf_setFail( status, "Internall errror calling H5Tget_sign." );
60  return -1;
61  }
62  if( sizeof( char ) == size )
63  return sgn == H5T_SGN_NONE ? H5T_NATIVE_UCHAR : H5T_NATIVE_SCHAR;
64  else if( sizeof( short ) == size )
65  return sgn == H5T_SGN_NONE ? H5T_NATIVE_USHORT : H5T_NATIVE_SHORT;
66  else if( sizeof( int ) == size )
67  return sgn == H5T_SGN_NONE ? H5T_NATIVE_UINT : H5T_NATIVE_INT;
68  else if( sizeof( long ) == size )
69  return sgn == H5T_SGN_NONE ? H5T_NATIVE_ULONG : H5T_NATIVE_LONG;
70  else if( (int)H5Tget_size( H5T_NATIVE_LLONG ) == size )
71  return sgn == H5T_SGN_NONE ? H5T_NATIVE_ULLONG : H5T_NATIVE_LLONG;
72 
73  mhdf_setFail( status, "Invalid size for integer type: %d", size );
74  return -1;
75 
76  case H5T_ENUM:
77  tmp_id = H5Tget_super( input_type );
78  if( tmp_id < 0 )
79  {
80  mhdf_setFail( status, "Internal error calling H5Tget_super." );
81  return -1;
82  }
83  type_id = mhdf_getNativeType( tmp_id, size, status );
84  H5Tclose( tmp_id );
85  return type_id;
86 
87  case H5T_TIME:
88  case H5T_OPAQUE:
89  case H5T_REFERENCE:
90  mhdf_setFail( status, "Unsupported type class." );
91  return -1;
92 
93  case H5T_COMPOUND:
94  case H5T_VLEN:
95  case H5T_ARRAY:
96  case H5T_STRING:
97  mhdf_setFail( status, "Only atomic types are supported." );
98  return -1;
99 
100  default:
101  mhdf_setFail( status, "Internal error calling H5Tget_class. Bad handle?" );
102  return -1;
103  }
104 }

References mhdf_getNativeType(), mhdf_setFail(), mhdf_setOkay(), and size.

Referenced by mhdf_getNativeType().

◆ mhdf_getNextStartId()

void mhdf_getNextStartId ( mhdf_FileHandle  file,
mhdf_index_t start_id_out,
mhdf_Status status 
)

Get start ID that will be assigned to next created dataset.

Get the first_id parameter that will be returned from the next call to any of mhdf_createNodeCoords, mhdf_createConnectivity, mhdf_createPolyConnectivity, or mhdf_createSetMeta

Definition at line 925 of file file.c.

926 {
927  FileHandle* file_ptr = (FileHandle*)file;
928  API_BEGIN;
929 
930  mhdf_setOkay( status );
931  if( mhdf_check_valid_file( file_ptr, status ) ) *start_id_out = file_ptr->max_id + 1;
932 
933  API_END;
934 }

References API_BEGIN, API_END, struct_FileHandle::max_id, mhdf_check_valid_file(), and mhdf_setOkay().

◆ mhdf_getNumberTags()

int mhdf_getNumberTags ( mhdf_FileHandle  file_handle,
mhdf_Status status 
)

Get the number of tags in the file.

Parameters
file_handleThe file.
statusPassed back status of API call.
Returns
The number of tags.

Definition at line 615 of file tags.c.

616 {
617  hid_t group_id;
618  hsize_t result;
619  FileHandle* file_ptr;
620  API_BEGIN;
621 
622  /* Validate input */
623 
624  file_ptr = (FileHandle*)file_handle;
625  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
626 
627  /* Open the tags group */
628 
629 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
630  group_id = H5Gopen2( file_ptr->hdf_handle, TAG_GROUP, H5P_DEFAULT );
631 #else
632  group_id = H5Gopen( file_ptr->hdf_handle, TAG_GROUP );
633 #endif
634  if( group_id < 0 )
635  {
636  mhdf_setFail( status, "H5Gopen(\"%s\") failed", TAG_GROUP );
637  return -1;
638  }
639 
640  /* Get number of objects in tags group */
641 
642  if( H5Gget_num_objs( group_id, &result ) < 0 )
643  {
644  mhdf_setFail( status, "Internal failure calling H5Gget_num_objs." );
645  H5Gclose( group_id );
646  return -1;
647  }
648 
649  H5Gclose( group_id );
650  mhdf_setOkay( status );
651  API_END;
652  return (int)result;
653 }

References API_BEGIN, API_END, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_setFail(), mhdf_setOkay(), and TAG_GROUP.

◆ mhdf_getTagDataType()

hid_t mhdf_getTagDataType ( mhdf_FileHandle  file_handle,
const char *  tag_name,
mhdf_Status status 
)

Get handle to HDF5 type object for tag data.

Definition at line 537 of file tags.c.

538 {
539  FileHandle* file_ptr;
540  hid_t result;
541  char* path;
542  API_BEGIN;
543 
544  /* Validate input */
545 
546  file_ptr = (FileHandle*)file_handle;
547  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
548 
549  if( !tag_name || !*tag_name )
550  {
551  mhdf_setFail( status, "Invalid tag name" );
552  return -1;
553  }
554 
555  /* Create path string for tag object */
556 
557  path = mhdf_name_to_path_copy( tag_name, status );
558  if( !path )
559  {
560  return -1;
561  }
562 
563  result = get_tag_type( file_ptr, path, status );
564 
565  free( path );
566  API_END;
567  return result;
568 }

References API_BEGIN, API_END, get_tag_type(), mhdf_check_valid_file(), mhdf_name_to_path_copy(), and mhdf_setFail().

◆ mhdf_getTagInfo()

void mhdf_getTagInfo ( mhdf_FileHandle  file_handle,
const char *  tag_name,
enum mhdf_TagDataType class_out,
int *  size_out,
int *  tstt_storage_out,
int *  have_default_out,
int *  have_global_out,
int *  have_sparse_out,
mhdf_Status status 
)

Get the description of a specified tag.

Get everything about a tag except the actual values.

Parameters
file_handleThe file.
tag_nameThe name of the tag to retrieve the data for.
class_outThe TSTT class of the tag data.
size_outDepends on value of class_out:
  • mhdf_OPAQUE - size of opaque data in bytes
  • mhdf_BITFIELD - number of bits
  • if data is fixed-length array, length of array
  • if data is single value, 1
  • if data is a variable-length array, -1
tstt_storage_outThe value of the TSTT enum for storage (dense, sparse, etc.)
have_default_outNon-zero if file contains a default value for the tag. Length of default value if variable-lenth tag.
have_global_outNon-zero if the file contains a global/mesh value for the tag.
have_sparse_outNon-zero if the file contains a sparse data table for this tag.

Definition at line 806 of file tags.c.

815 {
816  hid_t tag_id, type_id, super_id;
817  int i, rval, is_handle;
818  hsize_t size, sup_size;
819  unsigned int idx;
820  int rank, var_data;
821  hsize_t dims[H5S_MAX_RANK];
822  int perm[H5S_MAX_RANK];
823  H5T_class_t class_tmp;
824 
825  API_BEGIN;
826 
827  /* Validate input */
828  if( NULL == tag_name || NULL == class_out || NULL == size_out || NULL == tstt_storage_out ||
829  NULL == have_default_out || NULL == have_global_out || NULL == have_sparse_out )
830  {
831  mhdf_setFail( status, "Invalid input." );
832  return;
833  }
834 
835  /* Get group for tag */
836  tag_id = get_tag( file_handle, tag_name, NULL, status );
837  if( tag_id < 0 ) return;
838 
839  /* Check for sparse data */
840  rval = mhdf_is_in_group( tag_id, SPARSE_ENTITY_NAME, status );
841  if( rval < 0 )
842  {
843  H5Gclose( tag_id );
844  return;
845  }
846  *have_sparse_out = rval ? 1 : 0;
847 
848  /* Check for variable-length tag data */
849  rval = mhdf_find_attribute( tag_id, TAG_VARLEN_ATTRIB, &idx, status );
850  if( rval < 0 )
851  {
852  H5Gclose( tag_id );
853  return;
854  }
855  var_data = rval ? 1 : 0;
856 
857  /* Check if have default value for tag */
858  rval = mhdf_find_attribute( tag_id, TAG_DEFAULT_ATTRIB, &idx, status );
859  if( rval < 0 )
860  {
861  H5Gclose( tag_id );
862  return;
863  }
864  if( !rval )
865  *have_default_out = 0;
866  else if( !var_data )
867  *have_default_out = 1;
868  else
869  {
870  /* *have_default_out = get_attrib_array_length_index( tag_id, index ); */
871  *have_default_out = get_attrib_array_length_name( tag_id, TAG_DEFAULT_ATTRIB );
872  if( *have_default_out < 0 )
873  {
874  mhdf_setFail( status, "Error checking length of default value for tag: %s\n", tag_name );
875  H5Gclose( tag_id );
876  return;
877  }
878  }
879 
880  /* Check if have global value for tag */
881  rval = mhdf_find_attribute( tag_id, TAG_GLOBAL_ATTRIB, &idx, status );
882  if( rval < 0 )
883  {
884  H5Gclose( tag_id );
885  return;
886  }
887  if( !rval )
888  *have_global_out = 0;
889  else if( !var_data )
890  *have_global_out = 1;
891  else
892  {
893  /* *have_global_out = get_attrib_array_length_index( tag_id, index ); */
894  *have_global_out = get_attrib_array_length_name( tag_id, TAG_GLOBAL_ATTRIB );
895  if( *have_global_out < 0 )
896  {
897  mhdf_setFail( status, "Error checking length of global value for tag: %s\n", tag_name );
898  H5Gclose( tag_id );
899  return;
900  }
901  }
902 
903  /* Get TSTT tag class */
904  rval = mhdf_read_scalar_attrib( tag_id, TAG_TYPE_ATTRIB, H5T_NATIVE_INT, tstt_storage_out, status );
905  if( rval < 1 )
906  {
907  H5Gclose( tag_id );
908  return;
909  }
910 
911  /* Check if tag is storing entity handles */
912  rval = mhdf_find_attribute( tag_id, TAG_HANDLE_TYPE_ATTRIB, &idx, status );
913  if( rval < 0 )
914  {
915  H5Gclose( tag_id );
916  return;
917  }
918  is_handle = rval;
919 
920  /* Get tag type */
921 #if defined( H5Topen_vers ) && H5Topen_vers > 1
922  type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
923 #else
924  type_id = H5Topen( tag_id, TAG_TYPE_NAME );
925 #endif
926  if( type_id < 0 )
927  {
928  H5Gclose( tag_id );
929  mhdf_setFail( status, "Failed to get type object for tag \"%s\".", tag_name );
930  return;
931  }
932 
933  class_tmp = H5Tget_class( type_id );
934  if( class_tmp < 0 )
935  {
936  mhdf_setFail( status, "H5Tget_class failed." );
937  H5Gclose( tag_id );
938  H5Tclose( type_id );
939  return;
940  }
941 
942  size = H5Tget_size( type_id );
943  if( size <= 0 )
944  {
945  mhdf_setFail( status, "H5Tget_size failed." );
946  H5Gclose( tag_id );
947  H5Tclose( type_id );
948  return;
949  }
950 
951  switch( class_tmp )
952  {
953  case H5T_INTEGER:
954  *class_out = ( size == 1 ) ? mhdf_BOOLEAN : mhdf_INTEGER;
955  *size_out = 1;
956  break;
957 
958  case H5T_FLOAT:
959  *class_out = mhdf_FLOAT;
960  *size_out = 1;
961  break;
962 
963  case H5T_BITFIELD:
964  *class_out = mhdf_BITFIELD;
965  *size_out = H5Tget_precision( type_id );
966  if( *size_out <= 0 )
967  {
968  mhdf_setFail( status, "H5Tget_precision failed." );
969  H5Gclose( tag_id );
970  H5Tclose( type_id );
971  return;
972  }
973  break;
974 
975  default:
976  case H5T_OPAQUE:
977  *class_out = mhdf_OPAQUE;
978  *size_out = size;
979  break;
980 
981  case H5T_ARRAY:
982 
983 #if defined( H5Tget_array_dims_vers ) && H5Tget_array_dims_vers > 1
984  (void)perm; /* suppress warning */
985  rank = H5Tget_array_dims2( type_id, dims );
986 #else
987  rank = H5Tget_array_dims( type_id, dims, perm );
988 #endif
989  if( rank <= 0 )
990  {
991  mhdf_setFail( status, "H5Tget_size failed." );
992  H5Gclose( tag_id );
993  H5Tclose( type_id );
994  return;
995  }
996  for( i = 1; i < rank; ++i )
997  dims[0] *= dims[i];
998 
999  super_id = H5Tget_super( type_id );
1000  if( super_id < 0 )
1001  {
1002  mhdf_setFail( status, "H5Tget_super failed" );
1003  H5Gclose( tag_id );
1004  H5Tclose( type_id );
1005  return;
1006  }
1007 
1008  class_tmp = H5Tget_class( super_id );
1009  if( class_tmp < 0 )
1010  {
1011  mhdf_setFail( status, "H5Tget_class failed." );
1012  H5Gclose( tag_id );
1013  H5Tclose( type_id );
1014  H5Tclose( super_id );
1015  return;
1016  }
1017 
1018  sup_size = H5Tget_size( super_id );
1019  H5Tclose( super_id );
1020  if( sup_size <= 0 )
1021  {
1022  mhdf_setFail( status, "H5Tget_size failed." );
1023  H5Gclose( tag_id );
1024  H5Tclose( type_id );
1025  return;
1026  }
1027 
1028  switch( class_tmp )
1029  {
1030  case H5T_INTEGER:
1031  *class_out = ( sup_size == 1 ) ? mhdf_BOOLEAN : mhdf_INTEGER;
1032  *size_out = dims[0];
1033  break;
1034 
1035  case H5T_FLOAT:
1036  *class_out = mhdf_FLOAT;
1037  *size_out = dims[0];
1038  break;
1039 
1040  default:
1041  *class_out = mhdf_OPAQUE;
1042  *size_out = size;
1043  break;
1044  }
1045 
1046  break;
1047  }
1048  H5Tclose( type_id );
1049  H5Gclose( tag_id );
1050 
1051  if( is_handle )
1052  {
1053  if( *class_out != mhdf_INTEGER )
1054  {
1055  mhdf_setFail( status, "Non-integer tag marked as handle type." );
1056  return;
1057  }
1058  *class_out = mhdf_ENTITY_ID;
1059  }
1060 
1061  if( var_data )
1062  {
1063  if( *size_out != 1 || *class_out == mhdf_BITFIELD )
1064  {
1065  mhdf_setFail( status, "Invalid or unexpected variable-length tag data" );
1066  return;
1067  }
1068  *size_out = -1;
1069  }
1070 
1071  mhdf_setOkay( status );
1072  API_END;
1073 }

References API_BEGIN, API_END, get_attrib_array_length_name(), get_tag(), mhdf_BITFIELD, mhdf_BOOLEAN, mhdf_ENTITY_ID, mhdf_find_attribute(), mhdf_FLOAT, mhdf_INTEGER, mhdf_is_in_group(), mhdf_OPAQUE, mhdf_read_scalar_attrib(), mhdf_setFail(), mhdf_setOkay(), size, SPARSE_ENTITY_NAME, TAG_DEFAULT_ATTRIB, TAG_GLOBAL_ATTRIB, TAG_HANDLE_TYPE_ATTRIB, TAG_TYPE_ATTRIB, TAG_TYPE_NAME, and TAG_VARLEN_ATTRIB.

Referenced by get_tag_desc(), and main().

◆ mhdf_getTagNames()

char** mhdf_getTagNames ( mhdf_FileHandle  file_handle,
int *  num_names_out,
mhdf_Status status 
)

Get the name for each tag defined in the file.

Parameters
file_handleThe file.
num_names_outThe length of the returned array of strings.
statusPassed back status of API call.
Returns
An array of null-terminated strings. The array and each string is allocated with malloc. The caller should release this memory by calling free for each string and the array.

Definition at line 655 of file tags.c.

656 {
657  hid_t group_id;
658  FileHandle* file_ptr;
659  hsize_t count, idx;
660  char* name;
661  char** result;
662  ssize_t size;
663  API_BEGIN;
664 
665  /* Validate input */
666 
667  file_ptr = (FileHandle*)file_handle;
668  if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
669 
670  /* Open the tags group */
671 
672 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
673  group_id = H5Gopen2( file_ptr->hdf_handle, TAG_GROUP, H5P_DEFAULT );
674 #else
675  group_id = H5Gopen( file_ptr->hdf_handle, TAG_GROUP );
676 #endif
677  if( group_id < 0 )
678  {
679  mhdf_setFail( status, "H5Gopen(\"%s\") failed", TAG_GROUP );
680  return NULL;
681  }
682 
683  /* Get number of objects in tags group */
684 
685  if( H5Gget_num_objs( group_id, &count ) < 0 )
686  {
687  mhdf_setFail( status, "Internal failure calling H5Gget_num_objs." );
688  H5Gclose( group_id );
689  return NULL;
690  }
691 
692  /* No tags? */
693 
694  *num_names_out = (int)count;
695  if( count == 0 )
696  {
697  H5Gclose( group_id );
698  mhdf_setOkay( status );
699  return NULL;
700  }
701 
702  /* Allocate string array */
703 
704  result = (char**)mhdf_malloc( sizeof( char* ) * count, status );
705  if( NULL == result )
706  {
707  H5Gclose( group_id );
708  return NULL;
709  }
710 
711  /* Get names */
712 
713  for( idx = 0; idx < count; ++idx )
714  {
715  size = H5Gget_objname_by_idx( group_id, idx, NULL, 0 );
716  if( size < 1 || NULL == ( name = (char*)mhdf_malloc( size + 1, status ) ) )
717  {
718  while( ( --idx ) > 0 )
719  free( result[idx] );
720  free( result );
721  H5Gclose( group_id );
722  mhdf_setFail( status, "Internal failure calling H5Gget_objname_by_idx." );
723  return NULL;
724  }
725 
726  H5Gget_objname_by_idx( group_id, idx, name, size + 1 );
727  if( !mhdf_path_to_name( name, name ) )
728  {
729  mhdf_setFail( status, "Invalid character string in internal file path: \"%s\"\n", name );
730  return NULL;
731  }
732  result[idx] = name;
733  }
734 
735  H5Gclose( group_id );
736  mhdf_setOkay( status );
737  API_END;
738  return result;
739 }

References API_BEGIN, API_END, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_malloc(), mhdf_path_to_name(), mhdf_setFail(), mhdf_setOkay(), size, and TAG_GROUP.

Referenced by mhdf_getFileSummary().

◆ mhdf_getTagValues()

void mhdf_getTagValues ( mhdf_FileHandle  file_handle,
const char *  tag_name,
hid_t  output_data_type,
void *  default_value,
void *  global_value,
mhdf_Status status 
)

Get the default and global values of the tag.

Parameters
file_handleThe file.
tag_nameThe tag name.
output_data_typeThe HDF5 type for the memory into which the tag data is to be written. If zero, then the value(s) will be read as opaque data.
default_valueMemory location at which to write the default value of the tag.
global_valueIf the tag has a global value, the memory location at which to write that value.
statusPassed back status of API call.

Definition at line 1135 of file tags.c.

1141 {
1142  hid_t tag_id;
1143  int rval, var_data;
1144  unsigned int idx;
1145  API_BEGIN;
1146 
1147  /* check args */
1148  if( NULL == tag_name || !*tag_name )
1149  {
1150  mhdf_setFail( status, "Invalid input." );
1151  return;
1152  }
1153 
1154  /* Get the tag group */
1155  tag_id = get_tag( file_handle, tag_name, NULL, status );
1156  if( tag_id < 0 ) return;
1157 
1158  /* Check for variable-length tag data */
1159  rval = mhdf_find_attribute( tag_id, TAG_VARLEN_ATTRIB, &idx, status );
1160  if( rval < 0 )
1161  {
1162  H5Gclose( tag_id );
1163  return;
1164  }
1165  var_data = rval ? 1 : 0;
1166 
1167  /* Read default value if present */
1168  rval = read_tag_attrib_data( tag_id, TAG_DEFAULT_ATTRIB, output_data_type, default_value, var_data, status );
1169  if( !rval )
1170  {
1171  H5Gclose( tag_id );
1172  return;
1173  }
1174 
1175  /* Read mesh value if present */
1176  rval = read_tag_attrib_data( tag_id, TAG_GLOBAL_ATTRIB, output_data_type, global_value, var_data, status );
1177  if( !rval )
1178  {
1179  H5Gclose( tag_id );
1180  return;
1181  }
1182 
1183  H5Gclose( tag_id );
1184  mhdf_setOkay( status );
1185  API_END;
1186 }

References API_BEGIN, API_END, get_tag(), mhdf_find_attribute(), mhdf_setFail(), mhdf_setOkay(), read_tag_attrib_data(), TAG_DEFAULT_ATTRIB, TAG_GLOBAL_ATTRIB, and TAG_VARLEN_ATTRIB.

Referenced by moab::ReadHDF5::create_tag(), and get_tag_desc().

◆ mhdf_haveAdjacency()

int mhdf_haveAdjacency ( mhdf_FileHandle  file,
const char *  elem_group,
mhdf_Status status 
)

Check if adjacency data is present in the file for the specified element group.

Parameters
fileThe file.
elem_handleA handle to an element group.
statusPassed back status of API call.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

Copyright 2004 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Definition at line 25 of file adjacency.c.

26 {
27  FileHandle* file_ptr;
28  hid_t elem_id;
29  int result;
30  API_BEGIN;
31 
32  file_ptr = (FileHandle*)( file );
33  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
34 
35  if( elem_group == mhdf_node_type_handle() )
36  {
37 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
38  elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
39 #else
40  elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
41 #endif
42  if( elem_id < 0 )
43  {
44  mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.\n", NODE_GROUP );
45  return -1;
46  }
47  }
48  else
49  {
50  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_group, status );
51  if( elem_id < 0 ) return -1;
52  }
53 
54  result = mhdf_is_in_group( elem_id, ADJACENCY_NAME, status );
55  H5Gclose( elem_id );
56  mhdf_setOkay( status );
57  API_END;
58  return result;
59 }

References ADJACENCY_NAME, API_BEGIN, API_END, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_is_in_group(), mhdf_node_type_handle(), mhdf_setFail(), mhdf_setOkay(), and NODE_GROUP.

Referenced by get_elem_desc().

◆ mhdf_haveDenseTag()

int mhdf_haveDenseTag ( mhdf_FileHandle  file_handle,
const char *  tag_name,
const char *  elem_group,
mhdf_Status status 
)

Check if the file contains dense tag data for the specified tag and element group.

Check if there is dense tag data for a given element type for the specified tag.

Parameters
file_handleThe file.
tag_nameThe tag.
elem_groupThe element group handle, or the return value of mhdf_node_type_handle or mhdf_set_type_handle for nodes or sets respectively.
statusPassed back status of API call.
Returns
Non-zero if file contains specified data. Zero otherwise.

Definition at line 1188 of file tags.c.

1189 {
1190  char* path;
1191  hid_t elem_id, group_id;
1192  FileHandle* file_ptr;
1193  int rval = 0;
1194  API_BEGIN;
1195 
1196  file_ptr = (FileHandle*)file_handle;
1197  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
1198 
1199  if( type_handle == mhdf_node_type_handle() )
1200  {
1201 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
1202  elem_id = H5Gopen2( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
1203 #else
1204  elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
1205 #endif
1206  if( elem_id < 0 ) mhdf_setFail( status, "Could not open node group." );
1207  }
1208  else if( type_handle == mhdf_set_type_handle() )
1209  {
1210 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
1211  elem_id = H5Gopen2( file_ptr->hdf_handle, SET_GROUP, H5P_DEFAULT );
1212 #else
1213  elem_id = H5Gopen( file_ptr->hdf_handle, SET_GROUP );
1214 #endif
1215  if( elem_id < 0 ) mhdf_setFail( status, "Could not open set group." );
1216  }
1217  else
1218  {
1219  elem_id = mhdf_elem_group_from_handle( file_ptr, type_handle, status );
1220  }
1221  if( elem_id < 0 ) return -1;
1222 
1223  rval = mhdf_is_in_group( elem_id, TAG_GROUP_NAME, status );
1224  if( rval < 0 )
1225  {
1226  H5Gclose( elem_id );
1227  return -1;
1228  }
1229  else if( rval == 0 )
1230  {
1231  H5Gclose( elem_id );
1232  mhdf_setOkay( status );
1233  return 0;
1234  }
1235 
1236 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
1237  group_id = H5Gopen2( elem_id, DENSE_TAG_SUBGROUP, H5P_DEFAULT );
1238 #else
1239  group_id = H5Gopen( elem_id, DENSE_TAG_SUBGROUP );
1240 #endif
1241  H5Gclose( elem_id );
1242  if( group_id < 0 )
1243  {
1244  mhdf_setFail( status, "Could not open tag subgroup." );
1245  return -1;
1246  }
1247 
1248  path = mhdf_name_to_path_copy( tag_name, status );
1249  if( NULL == path )
1250  {
1251  H5Gclose( group_id );
1252  return -1;
1253  }
1254 
1255  rval = mhdf_is_in_group( group_id, path, status );
1256  H5Gclose( group_id );
1257  free( path );
1258 
1259  if( rval >= 0 )
1260  {
1261  mhdf_setOkay( status );
1262  }
1263 
1264  API_END;
1265  return rval;
1266 }

References API_BEGIN, API_END, DENSE_TAG_SUBGROUP, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_is_in_group(), mhdf_name_to_path_copy(), mhdf_node_type_handle(), mhdf_set_type_handle(), mhdf_setFail(), mhdf_setOkay(), NODE_GROUP, SET_GROUP, and TAG_GROUP_NAME.

Referenced by main(), and mhdf_getFileSummary().

◆ mhdf_haveNodes()

int mhdf_haveNodes ( mhdf_FileHandle  file,
mhdf_Status status 
)

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

Copyright 2004 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Definition at line 26 of file nodes.c.

27 {
28  FileHandle* file_ptr = (FileHandle*)file;
29  hid_t root_id, node_id;
30  int result;
31  API_BEGIN;
32 
33  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
34 
35 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
36  root_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
37 #else
38  root_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
39 #endif
40  if( root_id < 0 )
41  {
42  mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", ROOT_GROUP );
43  return -1;
44  }
45 
46  result = mhdf_is_in_group( root_id, NODE_GROUP_NAME, status );
47  if( result < 1 )
48  {
49  H5Gclose( root_id );
50  return result;
51  }
52 
53 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
54  node_id = H5Gopen2( root_id, NODE_GROUP_NAME, H5P_DEFAULT );
55 #else
56  node_id = H5Gopen( root_id, NODE_GROUP_NAME );
57 #endif
58  H5Gclose( root_id );
59  if( node_id < 0 )
60  {
61  mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", NODE_GROUP );
62  return -1;
63  }
64 
65  result = mhdf_is_in_group( node_id, NODE_COORD_NAME, status );
66  if( result >= 0 ) mhdf_setOkay( status );
67  H5Gclose( node_id );
68  API_END;
69  return result;
70 }

References API_BEGIN, API_END, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_is_in_group(), mhdf_setFail(), mhdf_setOkay(), NODE_COORD_NAME, NODE_GROUP, NODE_GROUP_NAME, and ROOT_GROUP.

Referenced by mhdf_getFileSummary().

◆ mhdf_haveSets()

int mhdf_haveSets ( mhdf_FileHandle  file,
int *  have_data,
int *  have_child,
int *  have_parent,
mhdf_Status status 
)

Check if file contains any sets.

Parameters
fileThe file.
have_set_data_outIf non-null set to 1 if file contains table of set contents, zero otherwise.
have_set_child_outIf non-null set to 1 if file contains table of set children, zero otherwise.
have_set_parents_outIf non-null set to 1 if file contains table of set parents, zero otherwise.
statusPassed back status of API call.
Returns
Zero if the file does not contain any sets, one if it does.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

Copyright 2004 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Definition at line 27 of file sets.c.

28 {
29  FileHandle* file_ptr = (FileHandle*)file;
30  hid_t root_id, set_id;
31  int result;
32  API_BEGIN;
33 
34  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
35 
36 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
37  root_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
38 #else
39  root_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
40 #endif
41  if( root_id < 0 )
42  {
43  mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", ROOT_GROUP );
44  return -1;
45  }
46 
47  result = mhdf_is_in_group( root_id, SET_GROUP_NAME, status );
48  if( result < 1 )
49  {
50  H5Gclose( root_id );
51  return result;
52  }
53 
54 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
55  set_id = H5Gopen2( root_id, SET_GROUP_NAME, H5P_DEFAULT );
56 #else
57  set_id = H5Gopen( root_id, SET_GROUP_NAME );
58 #endif
59  H5Gclose( root_id );
60  if( set_id < 0 )
61  {
62  mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", SET_GROUP );
63  return -1;
64  }
65 
66  result = mhdf_is_in_group( set_id, SET_META_NAME, status );
67  if( result < 0 )
68  {
69  H5Gclose( set_id );
70  return result;
71  }
72 
73  if( have_data )
74  {
75  *have_data = mhdf_is_in_group( set_id, SET_DATA_NAME, status );
76  if( *have_data < 0 )
77  {
78  H5Gclose( set_id );
79  return *have_data;
80  }
81  }
82 
83  if( have_child )
84  {
85  *have_child = mhdf_is_in_group( set_id, SET_CHILD_NAME, status );
86  if( *have_child < 0 )
87  {
88  H5Gclose( set_id );
89  return *have_child;
90  }
91  }
92 
93  if( have_parent )
94  {
95  *have_parent = mhdf_is_in_group( set_id, SET_PARENT_NAME, status );
96  if( *have_parent < 0 )
97  {
98  H5Gclose( set_id );
99  return *have_parent;
100  }
101  }
102 
103  mhdf_setOkay( status );
104  H5Gclose( set_id );
105  API_END;
106  return result;
107 }

References API_BEGIN, API_END, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_is_in_group(), mhdf_setFail(), mhdf_setOkay(), ROOT_GROUP, SET_CHILD_NAME, SET_DATA_NAME, SET_GROUP, SET_GROUP_NAME, SET_META_NAME, and SET_PARENT_NAME.

Referenced by mhdf_getFileSummary().

◆ mhdf_isPolyElement()

int mhdf_isPolyElement ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
mhdf_Status status 
)

Check if an element group contains polygon or polyhedron.

Check if an element group contains general polygon or polyhedrons rather than typically fixed-connectivity elements.

Parameters
file_handleThe file.
elem_handleThe element group.
statusPassed back status of API call.
Returns
Zero if normal fixed-connectivity element data. Non-zero if poly(gon/hedron) general-connectivity data.

Definition at line 748 of file file.c.

749 {
750  FileHandle* file_ptr;
751  hid_t elem_id;
752  int rval;
753  API_BEGIN;
754 
755  file_ptr = (FileHandle*)( file_handle );
756  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
757 
758  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
759  if( elem_id < 0 ) return -1;
760 
761  mhdf_setOkay( status );
762  rval = mhdf_is_in_group( elem_id, POLY_INDEX_NAME, status );
763  H5Gclose( elem_id );
764  API_END;
765  return rval;
766 }

References API_BEGIN, API_END, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_is_in_group(), mhdf_setOkay(), and POLY_INDEX_NAME.

Referenced by get_elem_desc().

◆ mhdf_node_type_handle()

const char* mhdf_node_type_handle ( void  )

Get an mhdf_ElemHandle object for the node data.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

Copyright 2004 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. MHDF API for reading/writing MOAB-format HDF5 mesh files. Error handling Element group handle

Returns
A special element group handle used when specifying adjacency or tag data for nodes.

Definition at line 736 of file file.c.

737 {
738  static const char rval[] = "nodes";
739  return rval;
740 }

Referenced by check_valid_tag(), main(), mhdf_createAdjacency(), mhdf_createDenseTagData(), mhdf_getFileSummary(), mhdf_haveAdjacency(), mhdf_haveDenseTag(), mhdf_openAdjacency(), mhdf_openDenseTagData(), moab::WriteHDF5::ExportSet::name(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::read_tag_values_partial(), moab::ReadHDF5::search_tag_values(), and moab::WriteHDF5::serial_create_file().

◆ mhdf_openAdjacency()

hid_t mhdf_openAdjacency ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
long *  adj_list_size,
mhdf_Status status 
)

Open adjacency data table for nodes, elements, polys, etc.

Open the file object containing adjacency data for a nodes or a specified element group.

Adjacency data is formated as a sequence of integer groups where the first entry in each group is the ID of the element for which adjacencies are being specified, the second value is the count of adjacent entities, and the remainder of the group is the list of IDs of the adjacent entities.

Parameters
file_handleThe file.
elem_handleThe element group (or the result of mhdf_node_type_handle for nodes) for which the adjacency data is to be specified.
adj_list_sizeThe total number of integer values contained in the adjacency data for the specified element group.
statusPassed back status of API call.
Returns
The HDF5 handle to the connectivity data.

Definition at line 94 of file adjacency.c.

96 {
97  FileHandle* file_ptr;
98  hid_t elem_id, table_id;
99  hsize_t dim;
100  API_BEGIN;
101 
102  file_ptr = (FileHandle*)( file );
103  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
104 
105  if( !adj_list_size_out )
106  {
107  mhdf_setFail( status, "Invalid argument.\n" );
108  return -1;
109  }
110 
111  if( elem_handle == mhdf_node_type_handle() )
112  {
113  table_id = mhdf_open_table( file_ptr->hdf_handle, NODE_ADJCY_PATH, 1, &dim, status );
114  }
115  else
116  {
117  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
118  if( elem_id < 0 ) return -1;
119  table_id = mhdf_open_table( elem_id, ADJACENCY_NAME, 1, &dim, status );
120  H5Gclose( elem_id );
121  }
122 
123  *adj_list_size_out = (long)dim;
124  API_END_H( 1 );
125  return table_id;
126 }

References ADJACENCY_NAME, API_BEGIN, API_END_H, dim, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_node_type_handle(), mhdf_open_table(), mhdf_setFail(), and NODE_ADJCY_PATH.

Referenced by check_valid_adjacencies(), moab::ReadHDF5::load_file_impl(), moab::ReadHDF5::load_file_partial(), and moab::WriteHDF5::write_adjacencies().

◆ mhdf_openConnectivity()

hid_t mhdf_openConnectivity ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
int *  num_nodes_per_elem_out,
long *  num_elements_out,
long *  first_elem_id_out,
mhdf_Status status 
)

Open connectivity table for an element group.

Open fixed-connectivity data for an element group. Do NOT use this function for poly(gon/hedron) data. Use mhdf_isPolyElement or mhdf_getTsttElemType to check if the data is poly(gon|hedron) data before calling this function to open the data.

Parameters
file_handleThe file.
elem_handleThe element group.
num_nodes_per_elem_outUsed to pass back the number of nodes in each element.
num_elements_outPass back the number of elements in the table.
first_elem_id_outElements are assigned global IDs in sequential blocks where the block is the table in which their connectivity data is written and the sequence is the sequence in which they are written in that table. The global ID for the first element in this group is passed back at this address. The global IDs for all other elements in the table are assigned in the sequence in which they are written in the table.
statusPassed back status of API call.
Returns
The HDF5 handle to the connectivity data.

Definition at line 78 of file connectivity.c.

84 {
85  FileHandle* file_ptr;
86  hid_t elem_id, table_id;
87  hsize_t dims[2];
88  API_BEGIN;
89 
90  file_ptr = (FileHandle*)( file_handle );
91  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
92 
93  if( !num_nodes_per_elem_out || !num_elements_out || !first_elem_id_out )
94  {
95  mhdf_setFail( status, "Invalid argument." );
96  return -1;
97  }
98 
99  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
100  if( elem_id < 0 ) return -1;
101 
102  table_id = mhdf_open_table2( elem_id, CONNECTIVITY_NAME, 2, dims, first_elem_id_out, status );
103 
104  H5Gclose( elem_id );
105  if( table_id < 0 ) return -1;
106 
107  *num_elements_out = dims[0];
108  *num_nodes_per_elem_out = dims[1];
109 
110  file_ptr->open_handle_count++;
111  mhdf_setOkay( status );
112  API_END_H( 1 );
113  return table_id;
114 }

References API_BEGIN, API_END_H, CONNECTIVITY_NAME, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_open_table2(), mhdf_setFail(), mhdf_setOkay(), and struct_FileHandle::open_handle_count.

Referenced by get_elem_desc(), main(), and moab::WriteHDF5::write_elems().

◆ mhdf_openConnectivitySimple()

hid_t mhdf_openConnectivitySimple ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
mhdf_Status status 
)

Definition at line 116 of file connectivity.c.

117 {
118  FileHandle* file_ptr;
119  hid_t elem_id, table_id;
120  API_BEGIN;
121 
122  file_ptr = (FileHandle*)( file_handle );
123  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
124 
125  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
126  if( elem_id < 0 ) return -1;
127 
128  table_id = mhdf_open_table_simple( elem_id, CONNECTIVITY_NAME, status );
129 
130  H5Gclose( elem_id );
131  if( table_id < 0 ) return -1;
132 
133  file_ptr->open_handle_count++;
134  mhdf_setOkay( status );
135  API_END_H( 1 );
136  return table_id;
137 }

References API_BEGIN, API_END_H, CONNECTIVITY_NAME, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_open_table_simple(), mhdf_setOkay(), and struct_FileHandle::open_handle_count.

Referenced by check_valid_elem_conn(), moab::ReadHDF5::read_elems(), and moab::ReadHDF5::read_node_adj_elems().

◆ mhdf_openDenseTagData()

hid_t mhdf_openDenseTagData ( mhdf_FileHandle  file_handle,
const char *  tag_name,
const char *  elem_group,
long *  num_values_out,
mhdf_Status status 
)

Open the object containing dense tag values for a given element group.

Parameters
file_handleThe file.
tag_nameThe tag.
elem_groupThe element group handle, or the return value of mhdf_node_type_handle or mhdf_set_type_handle for nodes or sets respectively.
num_values_outThe number of tag values to be written. Must be The same as the number of elements in the group.
statusPassed back status of API call.
Returns
Handle to data object in file.

Definition at line 1339 of file tags.c.

1344 {
1345  char* path;
1346  hid_t elem_id, data_id;
1347  FileHandle* file_ptr;
1348  size_t name_len, path_len, dir_len;
1349  hsize_t size;
1350  API_BEGIN;
1351 
1352  file_ptr = (FileHandle*)file_handle;
1353  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
1354 
1355  if( type_handle == mhdf_node_type_handle() )
1356  {
1357 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
1358  elem_id = H5Gopen2( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
1359 #else
1360  elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
1361 #endif
1362  if( elem_id < 0 ) mhdf_setFail( status, "Could not open node group." );
1363  }
1364  else if( type_handle == mhdf_set_type_handle() )
1365  {
1366 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
1367  elem_id = H5Gopen2( file_ptr->hdf_handle, SET_GROUP, H5P_DEFAULT );
1368 #else
1369  elem_id = H5Gopen( file_ptr->hdf_handle, SET_GROUP );
1370 #endif
1371  if( elem_id < 0 ) mhdf_setFail( status, "Could not open set group." );
1372  }
1373  else
1374  {
1375  elem_id = mhdf_elem_group_from_handle( file_ptr, type_handle, status );
1376  }
1377  if( elem_id < 0 ) return -1;
1378 
1379  dir_len = strlen( DENSE_TAG_SUBGROUP );
1380  name_len = mhdf_name_to_path( tag_name, NULL, 0 );
1381  path_len = dir_len + name_len + 1;
1382  path = (char*)mhdf_malloc( path_len, status );
1383  if( NULL == path )
1384  {
1385  H5Gclose( elem_id );
1386  return -1;
1387  }
1388  strcpy( path, DENSE_TAG_SUBGROUP );
1389  mhdf_name_to_path( tag_name, path + dir_len, name_len + 1 );
1390 
1391  data_id = mhdf_open_table( elem_id, path, 1, &size, status );
1392  free( path );
1393  H5Gclose( elem_id );
1394  *num_values_out = (long)size;
1395 
1396  if( data_id >= 0 ) mhdf_setOkay( status );
1397 
1398  API_END_H( 1 );
1399  return data_id;
1400 }

References API_BEGIN, API_END_H, DENSE_TAG_SUBGROUP, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_malloc(), mhdf_name_to_path(), mhdf_node_type_handle(), mhdf_open_table(), mhdf_set_type_handle(), mhdf_setFail(), mhdf_setOkay(), NODE_GROUP, SET_GROUP, and size.

Referenced by check_valid_tag(), main(), mhdf_getFileSummary(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::read_tag_values_partial(), moab::ReadHDF5::search_tag_values(), and moab::WriteHDF5::write_dense_tag().

◆ mhdf_openNodeCoords()

hid_t mhdf_openNodeCoords ( mhdf_FileHandle  file_handle,
long *  num_nodes_out,
int *  dimension_out,
long *  first_node_id_out,
mhdf_Status status 
)

Open table containing node coordinate data.

Parameters
file_handleThe file.
dimension_outNumber of coordinate values per node.
num_nodes_outThe number of nodes the table contains.
first_node_id_outNodes are assigned IDs sequentially in the order they occur in the table, where the ID of the first node in the table is this passed-back value.
statusPassed back status of API call.
Returns
An HDF5 handle to the coordinate table.

Definition at line 118 of file nodes.c.

123 {
124  FileHandle* file_ptr = (FileHandle*)file_handle;
125  hid_t table_id;
126  hsize_t dims[2];
127  API_BEGIN;
128 
129  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
130 
131  table_id = mhdf_open_table2( file_ptr->hdf_handle, NODE_COORD_PATH, 2, dims, first_id_out, status );
132  if( table_id < 0 ) return -1;
133 
134  *num_nodes_out = dims[0];
135  *dimension_out = dims[1];
136  file_ptr->open_handle_count++;
137  mhdf_setOkay( status );
138  API_END_H( 1 );
139  return table_id;
140 }

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_open_table2(), mhdf_setOkay(), NODE_COORD_PATH, and struct_FileHandle::open_handle_count.

Referenced by main(), mhdf_getFileSummary(), and moab::WriteHDF5::write_nodes().

◆ mhdf_openNodeCoordsSimple()

hid_t mhdf_openNodeCoordsSimple ( mhdf_FileHandle  file_handle,
mhdf_Status status 
)

Definition at line 142 of file nodes.c.

143 {
144  FileHandle* file_ptr = (FileHandle*)file_handle;
145  hid_t table_id;
146  API_BEGIN;
147 
148  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
149 
150  table_id = mhdf_open_table_simple( file_ptr->hdf_handle, NODE_COORD_PATH, status );
151  if( table_id < 0 ) return -1;
152 
153  file_ptr->open_handle_count++;
154  mhdf_setOkay( status );
155  API_END_H( 1 );
156  return table_id;
157 }

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_open_table_simple(), mhdf_setOkay(), NODE_COORD_PATH, and struct_FileHandle::open_handle_count.

Referenced by moab::ReadHDF5::read_nodes().

◆ mhdf_openPolyConnectivity()

void mhdf_openPolyConnectivity ( mhdf_FileHandle  file_handle,
const char *  elem_handle,
long *  num_poly_out,
long *  data_list_length_out,
long *  first_id_out,
hid_t  idx_and_id_handles_out[2],
mhdf_Status status 
)

Open a table of polygon or polyhedron connectivity data.

Poly (polygon or polyhedron) connectivity is stored as two lists. One list is the concatenation of the the connectivity data for all the polys in the group. The other contains one value per poly where that value is the index of the last entry in the connectivity of the corresponding poly. The ID list for polygons contains global node IDs. The ID list for polyhedra contains the global IDs of faces (either polygons or 2D fixed-connectivity elements.)

Parameters
file_handleThe file to write.
elem_handleThe element group.
num_poly_outThe total number number of polygons or polyhedra to be written in the table.
data_list_length_outThe total number of values to be written to the table (the number of polys plus the sum of the number of entities in each poly's connectivity data.)
first_id_outElements are assigned global IDs in sequential blocks where the block is the table in which their connectivity data is written and the sequence is the sequence in which they are written in that table. The global ID for the first element in this group is passed back at this address. The global IDs for all other elements in the table are assigned in the sequence in which they are written in the table.
idx_and_id_handles_outThe handles for the index list and connectivity list, respectively.
statusPassed back status of API call.

Definition at line 268 of file connectivity.c.

275 {
276  FileHandle* file_ptr;
277  hid_t elem_id, table_id, index_id;
278  hsize_t row_count;
279  API_BEGIN;
280 
281  file_ptr = (FileHandle*)( file_handle );
282  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
283 
284  if( !num_poly_out || !data_list_length_out || !first_poly_id_out )
285  {
286  mhdf_setFail( status, "Invalid argument." );
287  return;
288  }
289 
290  elem_id = mhdf_elem_group_from_handle( file_ptr, element_handle, status );
291  if( elem_id < 0 ) return;
292 
293  index_id = mhdf_open_table( elem_id, POLY_INDEX_NAME, 1, &row_count, status );
294  if( index_id < 0 )
295  {
296  H5Gclose( elem_id );
297  return;
298  }
299  *num_poly_out = (int)row_count;
300 
301  table_id = mhdf_open_table( elem_id, CONNECTIVITY_NAME, 1, &row_count, status );
302 
303  H5Gclose( elem_id );
304  if( table_id < 0 )
305  {
306  H5Dclose( index_id );
307  return;
308  }
309  *data_list_length_out = (long)row_count;
310 
311  if( !mhdf_read_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, first_poly_id_out, status ) )
312  {
313  H5Dclose( table_id );
314  H5Dclose( index_id );
315  return;
316  }
317 
318  file_ptr->open_handle_count++;
319  handles_out[0] = index_id;
320  handles_out[1] = table_id;
321  mhdf_setOkay( status );
322  API_END_H( 2 );
323 }

References API_BEGIN, API_END_H, CONNECTIVITY_NAME, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_open_table(), mhdf_read_scalar_attrib(), mhdf_setFail(), mhdf_setOkay(), struct_FileHandle::open_handle_count, POLY_INDEX_NAME, and START_ID_ATTRIB.

Referenced by check_valid_poly_conn(), get_elem_desc(), and moab::ReadHDF5::read_poly().

◆ mhdf_openSetChildren()

hid_t mhdf_openSetChildren ( mhdf_FileHandle  file_handle,
long *  child_list_size,
mhdf_Status status 
)

Open the file object containing the set child list.

Open the data group containing the list of set children.
See mhdf_createSetChildren and mhdf_createSetMeta for a description of this data.

Parameters
file_handleThe file
child_list_sizeThe total length of the data (the sum of the number of children for each set.)
statusPassed back status of API call.
Returns
A handle to the data object in the file.

Definition at line 740 of file sets.c.

741 {
742  FileHandle* file_ptr;
743  hid_t table_id;
744  hsize_t dim;
745  API_BEGIN;
746 
747  file_ptr = (FileHandle*)( file_handle );
748  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
749 
750  if( !child_list_size )
751  {
752  mhdf_setFail( status, "Invalid argument.\n" );
753  return -1;
754  }
755 
756  table_id = mhdf_open_table( file_ptr->hdf_handle, SET_CHILD_PATH, 1, &dim, status );
757 
758  *child_list_size = (long)dim;
759  API_END_H( 1 );
760  return table_id;
761 }

References API_BEGIN, API_END_H, dim, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_open_table(), mhdf_setFail(), and SET_CHILD_PATH.

Referenced by check_valid_sets(), moab::ReadHDF5::read_set_ids_recursive(), moab::ReadHDF5::read_sets(), and moab::WriteHDF5::write_sets().

◆ mhdf_openSetData()

hid_t mhdf_openSetData ( mhdf_FileHandle  file_handle,
long *  data_list_size_out,
mhdf_Status status 
)

Open the file object for the meshset contents.

Open set contents data object. The format of this data is a vector of integer values which is the concatenation of the contents list for all the meshsets. The length and format of the data for each set is stored in the set meta table. See mhdf_createSetMeta and mhdf_SET_RANGE_BIT for a description of that data.

Parameters
file_handleThe file.
data_list_size_outThe length of the table.
statusPassed back status of API call.
Returns
A handle to the table.

Definition at line 657 of file sets.c.

658 {
659  FileHandle* file_ptr;
660  hid_t table_id;
661  hsize_t dim;
662  API_BEGIN;
663 
664  file_ptr = (FileHandle*)( file_handle );
665  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
666 
667  if( !data_list_size_out )
668  {
669  mhdf_setFail( status, "Invalid argument.\n" );
670  return -1;
671  }
672 
673  table_id = mhdf_open_table( file_ptr->hdf_handle, SET_DATA_PATH, 1, &dim, status );
674 
675  *data_list_size_out = (long)dim;
676  API_END_H( 1 );
677  return table_id;
678 }

References API_BEGIN, API_END_H, dim, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_open_table(), mhdf_setFail(), and SET_DATA_PATH.

Referenced by check_valid_sets(), moab::ReadHDF5::find_sets_containing(), moab::ReadHDF5::get_set_contents(), moab::ReadHDF5::read_set_ids_recursive(), moab::ReadHDF5::read_sets(), and moab::WriteHDF5::write_sets().

◆ mhdf_openSetMeta()

hid_t mhdf_openSetMeta ( mhdf_FileHandle  file_handle,
long *  num_sets_out,
long *  first_set_id_out,
mhdf_Status status 
)

Open table holding list of meshsets and their properties.

Open set list.
See mhdf_createSetMeta or mhdf Meshset data for a description of this data.

Parameters
file_handleThe file.
num_sets_outThe number of sets in the table.
first_set_id_outThe global ID that will of the first set in the table. All subsequent sets in the table have sequential global IDs.
statusPassed back status of API call.
Returns
The handle to the set meta-data table.

Definition at line 145 of file sets.c.

146 {
147  FileHandle* file_ptr = (FileHandle*)file;
148  hid_t table_id;
149  hsize_t dims[2];
150  API_BEGIN;
151 
152  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
153 
154  table_id = mhdf_open_table2( file_ptr->hdf_handle, SET_META_PATH, 2, dims, first_id_out, status );
155  if( table_id < 0 ) return -1;
156 
157  /* If dims[1] == 3, then old format of table.
158  * Deal with it in mhdf_readSetMeta and mhdf_writeSetMeta
159  */
160  if( dims[1] != 4 && dims[1] != 3 )
161  {
162  mhdf_setFail( status, "Invalid format for meshset table.\n" );
163  H5Dclose( table_id );
164  return -1;
165  }
166 
167  *num_sets = dims[0];
168  file_ptr->open_handle_count++;
169  mhdf_setOkay( status );
170  API_END_H( 1 );
171  return table_id;
172 }

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_open_table2(), mhdf_setFail(), mhdf_setOkay(), struct_FileHandle::open_handle_count, and SET_META_PATH.

Referenced by check_valid_sets(), mhdf_getFileSummary(), and moab::WriteHDF5::write_sets().

◆ mhdf_openSetMetaSimple()

hid_t mhdf_openSetMetaSimple ( mhdf_FileHandle  file_handle,
mhdf_Status status 
)

Definition at line 174 of file sets.c.

175 {
176  FileHandle* file_ptr = (FileHandle*)file;
177  hid_t table_id;
178  API_BEGIN;
179 
180  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
181 
182  table_id = mhdf_open_table_simple( file_ptr->hdf_handle, SET_META_PATH, status );
183  if( table_id < 0 ) return -1;
184 
185  file_ptr->open_handle_count++;
186  mhdf_setOkay( status );
187  API_END_H( 1 );
188  return table_id;
189 }

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_open_table_simple(), mhdf_setOkay(), struct_FileHandle::open_handle_count, and SET_META_PATH.

Referenced by moab::ReadHDF5::read_all_set_meta().

◆ mhdf_openSetParents()

hid_t mhdf_openSetParents ( mhdf_FileHandle  file_handle,
long *  parent_list_size,
mhdf_Status status 
)

Open the file object containing the set parent list.

Open the data group containing the list of set parents.
See mhdf_createSetParents and mhdf_createSetMeta for a description of this data.

Parameters
file_handleThe file
parent_list_sizeThe total length of the data (the sum of the number of parents for each set.)
statusPassed back status of API call.
Returns
A handle to the data object in the file.

Definition at line 785 of file sets.c.

786 {
787  FileHandle* file_ptr;
788  hid_t table_id;
789  hsize_t dim;
790  API_BEGIN;
791 
792  file_ptr = (FileHandle*)( file_handle );
793  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
794 
795  if( !parent_list_size )
796  {
797  mhdf_setFail( status, "Invalid argument.\n" );
798  return -1;
799  }
800 
801  table_id = mhdf_open_table( file_ptr->hdf_handle, SET_PARENT_PATH, 1, &dim, status );
802 
803  *parent_list_size = (long)dim;
804  API_END_H( 1 );
805  return table_id;
806 }

References API_BEGIN, API_END_H, dim, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_open_table(), mhdf_setFail(), and SET_PARENT_PATH.

Referenced by check_valid_sets(), moab::ReadHDF5::read_sets(), and moab::WriteHDF5::write_sets().

◆ mhdf_openSparseTagData()

void mhdf_openSparseTagData ( mhdf_FileHandle  file_handle,
const char *  tag_name,
long *  num_entity_out,
long *  num_values_out,
hid_t  entities_and_values_out[3],
mhdf_Status status 
)

Create file objects to read sparse tag data.

Open the file objects containing all sparse data for a given tag in. The sparse data is stored in a pair of objects. The first is a vector of global IDs. The second is a vector of tag values for each entity specified in the list of global IDs. For variable-length tags, a third table containing end offsets for each tag value is returned in the third position of the output hid_t array (see mhdf_readSparseTagIndices.)

Parameters
file_handleThe file.
tag_nameThe tag.
num_entity_outThe number of entities for which there are tag values.
num_values_outThe number of data values. For fixed-length tags, this is the same as num_entity_out. For variable-length tags, it is the total number of values in the data table.
entities_and_values_outThe handles to the pair of file objects. The first is the vector of global IDs. The second is the list of corresponding tag values. The third is the handle to the index table, iff the tag is variable-length. If the tag is fixed-length, this value is not set.
statusPassed back status of API call.

Definition at line 1511 of file tags.c.

1517 {
1518  hid_t tag_id, index_id, data_id, offset_id = -1;
1519  hsize_t num_ent, data_size, num_data;
1520  int rval;
1521  unsigned idx;
1522  API_BEGIN;
1523 
1524  tag_id = get_tag( file_handle, tag_name, NULL, status );
1525  if( tag_id < 0 ) return;
1526 
1527  index_id = mhdf_open_table( tag_id, SPARSE_ENTITY_NAME, 1, &num_ent, status );
1528  if( index_id < 0 )
1529  {
1530  H5Gclose( tag_id );
1531  return;
1532  }
1533 
1534  data_id = mhdf_open_table( tag_id, SPARSE_VALUES_NAME, 1, &data_size, status );
1535  if( data_id < 0 )
1536  {
1537  H5Gclose( tag_id );
1538  H5Dclose( index_id );
1539  return;
1540  }
1541 
1542  /* check if tag is variable-lentgth */
1543  rval = mhdf_find_attribute( tag_id, TAG_VARLEN_ATTRIB, &idx, status );
1544  if( rval < 0 )
1545  {
1546  H5Gclose( tag_id );
1547  H5Dclose( index_id );
1548  H5Dclose( data_id );
1549  return;
1550  }
1551 
1552  /* If variable length... */
1553  if( rval )
1554  {
1555  offset_id = mhdf_open_table( tag_id, TAG_VAR_INDICES, 1, &num_data, status );
1556  if( offset_id < 0 )
1557  {
1558  H5Gclose( tag_id );
1559  H5Dclose( index_id );
1560  H5Dclose( data_id );
1561  return;
1562  }
1563  }
1564  /* Otherwise the number of values is the same as the size of the data table */
1565  else
1566  {
1567  num_data = data_size;
1568  }
1569 
1570  H5Gclose( tag_id );
1571  if( num_ent != num_data )
1572  {
1573  mhdf_setFail( status, "Data length mismatch for sparse tag data -- invalid file." );
1574  if( offset_id >= 0 ) H5Dclose( offset_id );
1575  H5Dclose( index_id );
1576  H5Dclose( data_id );
1577  return;
1578  }
1579  *num_entity_out = (long)num_ent;
1580  if( num_values_out ) *num_values_out = (long)data_size;
1581 
1582  handles_out[0] = index_id;
1583  handles_out[1] = data_id;
1584  if( offset_id >= 0 ) handles_out[2] = offset_id;
1585  mhdf_setOkay( status );
1586  API_END_H( 2 );
1587 }

References API_BEGIN, API_END_H, get_tag(), mhdf_find_attribute(), mhdf_open_table(), mhdf_setFail(), mhdf_setOkay(), SPARSE_ENTITY_NAME, SPARSE_VALUES_NAME, TAG_VAR_INDICES, and TAG_VARLEN_ATTRIB.

Referenced by check_valid_tag(), check_valid_var_len_tag(), moab::ReadHDF5::get_tagged_entities(), main(), mhdf_getFileSummary(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::read_tag_values_partial(), moab::ReadHDF5::search_tag_values(), moab::WriteHDF5::write_sparse_tag(), and moab::WriteHDF5::write_var_len_tag().

◆ mhdf_readAdjacency()

void mhdf_readAdjacency ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  adj_list_data_out,
mhdf_Status status 
)

Read node/element adjacency data.

Read adjacency data.

Adjacency data is formated as a sequence of integer groups where the first entry in each group is the ID of the element for which adjacencies are being specified, the second value is the count of adjacent entities, and the remainder of the group is the list of IDs of the adjacent entities.

Parameters
data_handleHandle returned from mhdf_createAdjacency or mhdf_openAdjacency.
offsetList position at which to start reading. Offset is from the count if integer values written, NOT a count of the number of elements for which adjacency data is written.
countNumber of integer values to reading.
hdf_integer_typeThe type of the integer data in adj_list_data_out. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
adj_list_data_outPointer to memory at which to write adjacency data.
statusPassed back status of API call.

Definition at line 148 of file adjacency.c.

149 {
150  API_BEGIN;
151  mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
152  API_END;
153 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_adjacencies().

◆ mhdf_readAdjacencyWithOpt()

void mhdf_readAdjacencyWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  adj_list_data_out,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 154 of file adjacency.c.

161 {
162  API_BEGIN;
163  mhdf_read_data( table_id, offset, count, type, data, prop, status );
164  API_END;
165 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by moab::ReadHDF5::read_adjacencies().

◆ mhdf_readConnectivity()

void mhdf_readConnectivity ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  node_id_list,
mhdf_Status status 
)

Read element coordinate data.

Read interleaved fixed-connectivity element data for a block of elements. Note: Do not use this for polygon or polyhedron data.

Parameters
data_handleHandle returned from mhdf_createConnectivity or mhdf_openConnectivity.
offsetTable row (element index) at which to start read.
countNumber of rows (number of elements) to read.
hdf_integer_typeThe type of the integer data in node_id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
node_id_listPointer to memory at which to write interleaved connectivity data specified as global node IDs.
statusPassed back status of API call.

Definition at line 163 of file connectivity.c.

169 {
170  API_BEGIN;
171  mhdf_read_data( table_id, offset, count, hdf_integer_type, nodes, H5P_DEFAULT, status );
172  API_END;
173 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_elem_conn(), and main().

◆ mhdf_readConnectivityWithOpt()

void mhdf_readConnectivityWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  node_id_list,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 174 of file connectivity.c.

181 {
182  API_BEGIN;
183  mhdf_read_data( table_id, offset, count, hdf_integer_type, nodes, prop, status );
184  API_END;
185 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by moab::ReadHDF5::read_node_adj_elems().

◆ mhdf_readHistory()

char** mhdf_readHistory ( mhdf_FileHandle  file,
int *  num_records_out,
mhdf_Status status 
)

Read the file history as a list of strings.

Each entry is composed of four strings: application, version, date, and time.

Strings and array are allocated with malloc. Caller must release them by calling free

Parameters
fileThe file.
num_records_outThe length of the returned array.
statusPassed back status of API call.
Returns
An array of null-terminates strings.

Definition at line 823 of file file.c.

824 {
825  FileHandle* file_ptr;
826  hid_t data_id, type_id, space_id, group_id;
827  hsize_t dim;
828  herr_t rval;
829  char** array;
830  API_BEGIN;
831 
832  file_ptr = (FileHandle*)( file_handle );
833  if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
834 
835  /* check if file contains history data */
836 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
837  group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
838 #else
839  group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
840 #endif
841  if( group_id < 0 )
842  {
843  mhdf_setFail( status, "Could not open root group. Invalid file." );
844  return NULL;
845  }
846 
847  rval = mhdf_is_in_group( group_id, HISTORY_NAME, status );
848  if( rval < 1 )
849  {
850  H5Gclose( group_id );
851  *num_strings = 0;
852  if( 0 == rval ) mhdf_setOkay( status );
853  return NULL;
854  }
855 
856 #if defined( H5Dopen_vers ) && H5Dopen_vers > 1
857  data_id = H5Dopen2( group_id, HISTORY_NAME, H5P_DEFAULT );
858 #else
859  data_id = H5Dopen( group_id, HISTORY_NAME );
860 #endif
861  H5Gclose( group_id );
862  if( data_id < 0 )
863  {
864  mhdf_setFail( status, "Failed to open \"%s\".", HISTORY_PATH );
865  return NULL;
866  }
867 
868  space_id = H5Dget_space( data_id );
869  if( space_id < 0 )
870  {
871  H5Dclose( data_id );
872  mhdf_setFail( status, "Internal error calling H5Dget_space." );
873  return NULL;
874  }
875 
876  if( 1 != H5Sget_simple_extent_ndims( space_id ) || 1 != H5Sget_simple_extent_dims( space_id, &dim, NULL ) )
877  {
878  H5Dclose( data_id );
879  mhdf_setFail( status, "Invalid dimension for \"%s\".", HISTORY_PATH );
880  return NULL;
881  }
882  H5Sclose( space_id );
883 
884  if( 0 == dim )
885  {
886  H5Dclose( data_id );
887  *num_strings = 0;
888  mhdf_setOkay( status );
889  return NULL;
890  }
891 
892  array = (char**)mhdf_malloc( dim * sizeof( char* ), status );
893  if( !array )
894  {
895  H5Dclose( data_id );
896  return NULL;
897  }
898 
899  type_id = H5Tcopy( H5T_C_S1 );
900  if( type_id < 0 || H5Tset_size( type_id, H5T_VARIABLE ) < 0 )
901  {
902  H5Dclose( data_id );
903  if( type_id >= 0 ) H5Tclose( type_id );
904  mhdf_setFail( status, "Could not create variable length string type." );
905  free( array );
906  return NULL;
907  }
908 
909  rval = H5Dread( data_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, array );
910  H5Tclose( type_id );
911  H5Dclose( data_id );
912  if( rval < 0 )
913  {
914  free( array );
915  mhdf_setFail( status, "H5Dread failed." );
916  return NULL;
917  }
918 
919  *num_strings = dim;
920  mhdf_setOkay( status );
921  API_END;
922  return array;
923 }

References API_BEGIN, API_END, dim, struct_FileHandle::hdf_handle, HISTORY_NAME, HISTORY_PATH, mhdf_check_valid_file(), mhdf_is_in_group(), mhdf_malloc(), mhdf_setFail(), mhdf_setOkay(), and ROOT_GROUP.

Referenced by moab::ReadHDF5::read_qa().

◆ mhdf_readNodeCoord()

void mhdf_readNodeCoord ( hid_t  data_handle,
long  offset,
long  count,
int  dimension,
double *  coords,
mhdf_Status status 
)

Read node coordinate data.

Read a single coordinate value (e.g. the 'x' coordinate) for a block of nodes.

Parameters
data_handleHandle returned from mhdf_createNodeCoords or mhdf_openNodeCoords.
offsetTable row (node index) at which to start reading.
countNumber of rows (number of nodes) to read.
dimensionThe coordinate to read (0->x, 1->y, ...)
coordsBuffer in which to write node coordinate data.
statusPassed back status of API call.

Definition at line 219 of file nodes.c.

220 {
221  API_BEGIN;
222  mhdf_read_column( table_id, dimension, offset, count, H5T_NATIVE_DOUBLE, coords, H5P_DEFAULT, status );
223  API_END;
224 }

References API_BEGIN, API_END, and mhdf_read_column().

◆ mhdf_readNodeCoords()

void mhdf_readNodeCoords ( hid_t  data_handle,
long  offset,
long  count,
double *  coordinates,
mhdf_Status status 
)

Read node coordinate data.

Read interleaved coordinate data for a block of nodes

Parameters
data_handleHandle returned from mhdf_createNodeCoords or mhdf_openNodeCoords.
offsetTable row (node index) at which to start reading.
countNumber of rows (number of nodes) to read.
coordinatesBuffer in which to write node coordinate data.
statusPassed back status of API call.

Definition at line 177 of file nodes.c.

178 {
179  API_BEGIN;
180  mhdf_read_data( table_id, offset, count, H5T_NATIVE_DOUBLE, coords, H5P_DEFAULT, status );
181  API_END;
182 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by main().

◆ mhdf_readNodeCoordsWithOpt()

void mhdf_readNodeCoordsWithOpt ( hid_t  data_handle,
long  offset,
long  count,
double *  coordinates,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 183 of file nodes.c.

189 {
190  API_BEGIN;
191  mhdf_read_data( table_id, offset, count, H5T_NATIVE_DOUBLE, coords, prop, status );
192  API_END;
193 }

References API_BEGIN, API_END, and mhdf_read_data().

◆ mhdf_readNodeCoordWithOpt()

void mhdf_readNodeCoordWithOpt ( hid_t  data_handle,
long  offset,
long  count,
int  dimension,
double *  coords,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 225 of file nodes.c.

232 {
233  API_BEGIN;
234  mhdf_read_column( table_id, dimension, offset, count, H5T_NATIVE_DOUBLE, coords, prop, status );
235  API_END;
236 }

References API_BEGIN, API_END, and mhdf_read_column().

◆ mhdf_readPolyConnIDs()

void mhdf_readPolyConnIDs ( hid_t  poly_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  id_list,
mhdf_Status status 
)

Read polygon or polyhedron connectivity data.

Poly (polygon or polyhedron) connectivity is stored as two lists. One list is the concatenation of the the connectivity data for all the polys in the group. The other contains one value per poly where that value is the index of the last entry in the connectivity of the corresponding poly. The ID list for polygons contains global node IDs. The ID list for polyhedra contains the global IDs of faces (either polygons or 2D fixed-connectivity elements.)

Parameters
poly_handleThe handle returned from mhdf_createPolyConnectivity or mhdf_openPolyConnectivity.
offsetThe offset in the table at which to read. The offset is in terms of the integer values in the table, not the count of polys.
countThe size of the integer list to read.
hdf_integer_typeThe type of the integer data as written into memory. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
id_listThe memory location at which to write the connectivity data.
statusPassed back status of API call.

Definition at line 397 of file connectivity.c.

403 {
404  API_BEGIN;
405  mhdf_read_data( table_id, offset, count, hdf_integer_type, id_list, H5P_DEFAULT, status );
406  API_END;
407 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_poly_conn().

◆ mhdf_readPolyConnIDsWithOpt()

void mhdf_readPolyConnIDsWithOpt ( hid_t  poly_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  id_list,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 408 of file connectivity.c.

415 {
416  API_BEGIN;
417  mhdf_read_data( table_id, offset, count, hdf_integer_type, id_list, prop, status );
418  API_END;
419 }

References API_BEGIN, API_END, and mhdf_read_data().

◆ mhdf_readPolyConnIndices()

void mhdf_readPolyConnIndices ( hid_t  poly_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  index_list,
mhdf_Status status 
)

Read polygon or polyhedron index data.

Poly (polygon or polyhedron) connectivity is stored as two lists. One list is the concatenation of the the connectivity data for all the polys in the group. The other contains one value per poly where that value is the index of the last entry in the connectivity of the corresponding poly. The ID list for polygons contains global node IDs. The ID list for polyhedra contains the global IDs of faces (either polygons or 2D fixed-connectivity elements.)

Parameters
poly_handleThe handle returned from mhdf_createPolyConnectivity or mhdf_openPolyConnectivity.
offsetThe offset in the table at which to read. The offset is in terms of the integer values in the table, not the count of polys.
countThe size of the integer list to read.
hdf_integer_typeThe type of the integer data as written into memory. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
index_listThe memory location at which to write the indices.
statusPassed back status of API call.

Definition at line 349 of file connectivity.c.

355 {
356  API_BEGIN;
357  mhdf_read_data( table_id, offset, count, hdf_integer_type, index_list, H5P_DEFAULT, status );
358  API_END;
359 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_poly_conn().

◆ mhdf_readPolyConnIndicesWithOpt()

void mhdf_readPolyConnIndicesWithOpt ( hid_t  poly_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  index_list,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 360 of file connectivity.c.

367 {
368  API_BEGIN;
369  mhdf_read_data( table_id, offset, count, hdf_integer_type, index_list, prop, status );
370  API_END;
371 }

References API_BEGIN, API_END, and mhdf_read_data().

◆ mhdf_readSetChildEndIndices()

void mhdf_readSetChildEndIndices ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  end_indices_out,
mhdf_Status status 
)

Read only the child end indices portion of the set description table.

For each set, read the last index of that set's data in the set children table.

NOTE: This is a signed value. Any sets w/out contents that occur first in the list will have an end index of -1.

Parameters
data_handleThe handle returned from mdhf_createSetMeta or mhdf_openSetMeta
offsetThe offset (set index) at which to begin reading.
countThe number of values (number of sets) to read.
hdf_integer_typeThe integer type of the input array 'set_flag_data'.
end_indices_outArray of indices.
statusLocation at which to store status of API call.

Definition at line 592 of file sets.c.

593 {
594  API_BEGIN;
595  mhdf_readSetMetaColumn( table_id, CHILDREN, offset, count, type, data, H5P_DEFAULT, status );
596  API_END;
597 }

References API_BEGIN, API_END, CHILDREN, and mhdf_readSetMetaColumn().

Referenced by check_valid_parents_children().

◆ mhdf_readSetChildEndIndicesWithOpt()

void mhdf_readSetChildEndIndicesWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  end_indices_out,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 598 of file sets.c.

605 {
606  API_BEGIN;
607  mhdf_readSetMetaColumn( table_id, CHILDREN, offset, count, type, data, prop, status );
608  API_END;
609 }

References API_BEGIN, API_END, CHILDREN, and mhdf_readSetMetaColumn().

◆ mhdf_readSetContentEndIndices()

void mhdf_readSetContentEndIndices ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  end_indices_out,
mhdf_Status status 
)

Read only the content end indices portion of the set description table.

For each set, read the last index of that set's data in the set contents table.

NOTE: This is a signed value. Any sets w/out contents that occur first in the list will have an end index of -1.

Parameters
data_handleThe handle returned from mdhf_createSetMeta or mhdf_openSetMeta
offsetThe offset (set index) at which to begin reading.
countThe number of values (number of sets) to read.
hdf_integer_typeThe integer type of the input array 'set_flag_data'.
end_indices_outArray of indices.
statusLocation at which to store status of API call.

Definition at line 568 of file sets.c.

574 {
575  API_BEGIN;
576  mhdf_readSetMetaColumn( table_id, CONTENT, offset, count, type, data, H5P_DEFAULT, status );
577  API_END;
578 }

References API_BEGIN, API_END, CONTENT, and mhdf_readSetMetaColumn().

Referenced by check_valid_set_contents().

◆ mhdf_readSetContentEndIndicesWithOpt()

void mhdf_readSetContentEndIndicesWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  end_indices_out,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 579 of file sets.c.

586 {
587  API_BEGIN;
588  mhdf_readSetMetaColumn( table_id, CONTENT, offset, count, type, data, prop, status );
589  API_END;
590 }

References API_BEGIN, API_END, CONTENT, and mhdf_readSetMetaColumn().

◆ mhdf_readSetData()

void mhdf_readSetData ( hid_t  set_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  set_data,
mhdf_Status status 
)

Read set contents.

Read data specifying entities contained in sets. The format of this data is a vector of integer values which is the concatenation of the contents list for all the meshsets. The length and format of the data for each set is stored in the set meta table. See mhdf_createSetMeta and mhdf_SET_RANGE_BIT for a description of that data.

Parameters
set_handleThe handle returned from mhdf_createSetData or mhdf_openSetData .
offsetThe position at which to read from the integer vector.
countThe number of values to read from the data vector.
hdf_integer_typeThe type of the integer data in set_data. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
set_dataA pointer to memory at which to store the read data.
statusPassed back status of API call.

Definition at line 699 of file sets.c.

700 {
701  API_BEGIN;
702  mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
703  API_END;
704 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_set_contents(), and moab::ReadHDF5::find_sets_containing().

◆ mhdf_readSetDataWithOpt()

void mhdf_readSetDataWithOpt ( hid_t  set_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  set_data,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 705 of file sets.c.

712 {
713  API_BEGIN;
714  mhdf_read_data( table_id, offset, count, type, data, prop, status );
715  API_END;
716 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by moab::ReadHDF5::find_sets_containing().

◆ mhdf_readSetFlags()

void mhdf_readSetFlags ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  set_flag_data,
mhdf_Status status 
)

Read only the flags portion of the set description table.

Read flags for each set from the set description table. See mhdf_createSetMeta for a description of this data.

Parameters
data_handleThe handle returned from mdhf_createSetMeta or mhdf_openSetMeta
offsetThe offset (set index) at which to begin reading.
countThe number of values (number of sets) to read.
hdf_integer_typeThe integer type of the input array 'set_flag_data'.
set_flag_dataArray of integers.
statusLocation at which to store status of API call.

Definition at line 549 of file sets.c.

550 {
551  API_BEGIN;
552  mhdf_readSetMetaColumn( table_id, FLAGS, offset, count, type, data, H5P_DEFAULT, status );
553  API_END;
554 }

References API_BEGIN, API_END, FLAGS, and mhdf_readSetMetaColumn().

Referenced by check_valid_set_contents().

◆ mhdf_readSetFlagsWithOpt()

void mhdf_readSetFlagsWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  set_flag_data,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 555 of file sets.c.

562 {
563  API_BEGIN;
564  mhdf_readSetMetaColumn( table_id, FLAGS, offset, count, type, data, prop, status );
565  API_END;
566 }

References API_BEGIN, API_END, FLAGS, and mhdf_readSetMetaColumn().

◆ mhdf_readSetMeta()

void mhdf_readSetMeta ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  set_desc_data,
mhdf_Status status 
)

Read list of sets and meta-information about sets.

Read set descriptions. See mhdf_createSetMeta or mhdf Meshset data for a description of this data.

Parameters
data_handleThe handle returned from mhdf_createSetMeta or mhdf_openSetMeta.
offsetThe offset (set index) to begin reading at.
countThe number of rows (sets, integer triples) to read.
hdf_integer_typeThe type of the integer data in set_desc_data. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
statusPassed back status of API call.
set_desc_dataThe memory location at which to write the data.

Definition at line 367 of file sets.c.

368 {
369  API_BEGIN;
370  mhdf_readwriteSetMeta( table_id, 1, offset, count, type, data, H5P_DEFAULT, status );
371  API_END;
372 }

References API_BEGIN, API_END, and mhdf_readwriteSetMeta().

◆ mhdf_readSetMetaWithOpt()

void mhdf_readSetMetaWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  set_desc_data,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 373 of file sets.c.

380 {
381  API_BEGIN;
382  mhdf_readwriteSetMeta( table_id, 1, offset, count, type, data, prop, status );
383  API_END;
384 }

References API_BEGIN, API_END, and mhdf_readwriteSetMeta().

Referenced by moab::ReadHDF5::read_all_set_meta().

◆ mhdf_readSetParentEndIndices()

void mhdf_readSetParentEndIndices ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  end_indices_out,
mhdf_Status status 
)

Read only the parent end indices portion of the set description table.

For each set, read the last index of that set's data in the set parents table.

NOTE: This is a signed value. Any sets w/out contents that occur first in the list will have an end index of -1.

Parameters
data_handleThe handle returned from mdhf_createSetMeta or mhdf_openSetMeta
offsetThe offset (set index) at which to begin reading.
countThe number of values (number of sets) to read.
hdf_integer_typeThe integer type of the input array 'set_flag_data'.
end_indices_outArray of indices.
statusLocation at which to store status of API call.

Definition at line 611 of file sets.c.

617 {
618  API_BEGIN;
619  mhdf_readSetMetaColumn( table_id, PARENTS, offset, count, type, data, H5P_DEFAULT, status );
620  API_END;
621 }

References API_BEGIN, API_END, mhdf_readSetMetaColumn(), and PARENTS.

Referenced by check_valid_parents_children().

◆ mhdf_readSetParentEndIndicesWithOpt()

void mhdf_readSetParentEndIndicesWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  end_indices_out,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 622 of file sets.c.

629 {
630  API_BEGIN;
631  mhdf_readSetMetaColumn( table_id, PARENTS, offset, count, type, data, prop, status );
632  API_END;
633 }

References API_BEGIN, API_END, mhdf_readSetMetaColumn(), and PARENTS.

◆ mhdf_readSetParentsChildren()

void mhdf_readSetParentsChildren ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  id_list,
mhdf_Status status 
)

Read set parent/child list.

Read from the list of parent or child IDs for sets. See mhdf_createSetChildren and mhdf_createSetMeta for a description of this data.

Parameters
data_handleThe value returned from mhdf_createSetChildren or mhdf_openSetChildren.
offsetThe offset into the list of global IDs.
countThe number of global IDs to read.
hdf_integer_typeThe type of the integer data in child_id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
id_listPointer to memory in which to the read data.
statusPassed back status of API call.

Definition at line 832 of file sets.c.

833 {
834  API_BEGIN;
835  mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
836  API_END;
837 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_parents_children().

◆ mhdf_readSetParentsChildrenWithOpt()

void mhdf_readSetParentsChildrenWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  id_list,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 838 of file sets.c.

845 {
846  API_BEGIN;
847  mhdf_read_data( table_id, offset, count, type, data, prop, status );
848  API_END;
849 }

References API_BEGIN, API_END, and mhdf_read_data().

◆ mhdf_readSparseTagEntities()

void mhdf_readSparseTagEntities ( hid_t  id_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  id_list,
mhdf_Status status 
)

Read Global ID list for sparse tag data.

Parameters
id_handleThe first handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData.
offsetThe offset at which to begin reading.
countThe number of global IDs to read.
hdf_integer_typeThe type of the integer data in id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
id_listThe memory location at which to store the global IDs.
statusPassed back status of API call.

Definition at line 1660 of file tags.c.

1666 {
1667  API_BEGIN;
1668  mhdf_read_data( table_id, offset, count, int_type, id_list, H5P_DEFAULT, status );
1669  API_END;
1670 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_tag(), check_valid_var_len_tag(), and main().

◆ mhdf_readSparseTagEntitiesWithOpt()

void mhdf_readSparseTagEntitiesWithOpt ( hid_t  id_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  id_list,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 1671 of file tags.c.

1678 {
1679  API_BEGIN;
1680  mhdf_read_data( table_id, offset, count, int_type, id_list, io_prop, status );
1681  API_END;
1682 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by moab::ReadHDF5::get_tagged_entities(), and moab::ReadHDF5::search_tag_values().

◆ mhdf_readSparseTagIndices()

void mhdf_readSparseTagIndices ( hid_t  tag_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  end_indices,
mhdf_Status status 
)

Read sparse tag end indices for variable-length tag data.

Read sparse tag end indices for variable-length tag data. Each value in the list is the last index (zero-based) into the tag data for the corresponding entity.

Parameters
tag_handlehandle to the data object to read from.
offsetThe offset into the table at which to begin reading
countThe number of values to read.
hdf_integer_typeThe type of the values pointed to by end_indices (must be an integer type).
end_indicesMemory in which to store the data read from the table.
statusOutput: API result.

Definition at line 1701 of file tags.c.

1707 {
1708  API_BEGIN;
1709  mhdf_read_data( table_id, offset, count, int_type, indices, H5P_DEFAULT, status );
1710  API_END;
1711 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by check_valid_var_len_tag().

◆ mhdf_readSparseTagIndicesWithOpt()

void mhdf_readSparseTagIndicesWithOpt ( hid_t  tag_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
void *  end_indices,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 1712 of file tags.c.

1719 {
1720  API_BEGIN;
1721  mhdf_read_data( table_id, offset, count, int_type, indices, io_prop, status );
1722  API_END;
1723 }

References API_BEGIN, API_END, and mhdf_read_data().

◆ mhdf_readTagValues()

void mhdf_readTagValues ( hid_t  value_handle,
long  offset,
long  count,
hid_t  hdf_type,
void *  memory,
mhdf_Status status 
)

Read tag values.

Parameters
value_handleThe second handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData; or the handle returned by mhdf_createDenseTagData or mhdf_openDenseTagData.
offsetThe offset at which to begin reading.
countThe number of tag values to read.
hdf_typeThe type of the data in memory. If this is specified, it must be possible for the HDF library to convert between this type and the type the tag data is stored as. If zero, the values will be read as opaque data.
memoryMemory location at which to store tag values.
statusPassed back status of API call.

Definition at line 1684 of file tags.c.

1685 {
1686  mhdf_readTagValuesWithOpt( table_id, offset, count, tag_type, tag_data, H5P_DEFAULT, status );
1687 }

References mhdf_readTagValuesWithOpt().

Referenced by check_valid_tag(), check_valid_var_len_tag(), and mhdf_getFileSummary().

◆ mhdf_readTagValuesWithOpt()

void mhdf_readTagValuesWithOpt ( hid_t  value_handle,
long  offset,
long  count,
hid_t  hdf_type,
void *  memory,
hid_t  read_prop,
mhdf_Status status 
)

Definition at line 1688 of file tags.c.

1695 {
1696  API_BEGIN;
1697  mhdf_read_data( table_id, offset, count, tag_type, tag_data, io_prop, status );
1698  API_END;
1699 }

References API_BEGIN, API_END, and mhdf_read_data().

Referenced by mhdf_readTagValues(), moab::ReadHDF5::read_tag_values_all(), and moab::ReadHDF5::search_tag_values().

◆ mhdf_set_type_handle()

const char* mhdf_set_type_handle ( void  )

Return a special element group handle used to specify the set group.

Returns
A special element group handle used to specify the set group for reading/writing tag data on sets.

Definition at line 742 of file file.c.

743 {
744  static const char rval[] = "sets";
745  return rval;
746 }

Referenced by check_valid_tag(), mhdf_createDenseTagData(), mhdf_getFileSummary(), mhdf_haveDenseTag(), mhdf_openDenseTagData(), moab::WriteHDF5::ExportSet::name(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::read_tag_values_partial(), and moab::ReadHDF5::search_tag_values().

◆ mhdf_writeAdjacency()

void mhdf_writeAdjacency ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  adj_list_data,
mhdf_Status status 
)

Write node/element adjacency data.

Write adjacency data.

Adjacency data is formated as a sequence of integer groups where the first entry in each group is the ID of the element for which adjacencies are being specified, the second value is the count of adjacent entities, and the remainder of the group is the list of IDs of the adjacent entities.

Parameters
data_handleHandle returned from mhdf_createAdjacency or mhdf_openAdjacency.
offsetList position at which to start writing. Offset is from the count if integer values written, NOT a count of the number of elements for which adjacency data is written.
countNumber of integer values to write.
hdf_integer_typeThe type of the integer data in adj_list_data. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
adj_list_dataAdjacency data to write.
statusPassed back status of API call.

Definition at line 128 of file adjacency.c.

129 {
130  API_BEGIN;
131  mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
132  API_END;
133 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writeAdjacencyWithOpt()

void mhdf_writeAdjacencyWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  adj_list_data,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 135 of file adjacency.c.

142 {
143  API_BEGIN;
144  mhdf_write_data( table_id, offset, count, type, data, prop, status );
145  API_END;
146 }

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by moab::WriteHDF5::write_adjacencies().

◆ mhdf_writeConnectivity()

void mhdf_writeConnectivity ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  node_id_list,
mhdf_Status status 
)

Write element coordinate data.

Write interleaved fixed-connectivity element data for a block of elements. Note: Do not use this for polygon or polyhedron data.

Parameters
data_handleHandle returned from mhdf_createConnectivity or mhdf_openConnectivity.
offsetTable row (element index) at which to start writing.
countNumber of rows (number of elements) to write.
hdf_integer_typeThe type of the integer data in node_id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
node_id_listInterleaved connectivity data specified as global node IDs.
statusPassed back status of API call.

Definition at line 139 of file connectivity.c.

145 {
146  API_BEGIN;
147  mhdf_write_data( table_id, offset, count, hdf_integer_type, nodes, H5P_DEFAULT, status );
148  API_END;
149 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writeConnectivityWithOpt()

void mhdf_writeConnectivityWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  node_id_list,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 150 of file connectivity.c.

157 {
158  API_BEGIN;
159  mhdf_write_data( table_id, offset, count, hdf_integer_type, nodes, prop, status );
160  API_END;
161 }

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by moab::WriteHDF5::write_elems().

◆ mhdf_writeHistory()

void mhdf_writeHistory ( mhdf_FileHandle  file,
const char **  strings,
int  num_strings,
mhdf_Status status 
)

Write the file history as a list of strings.

Each entry is composed of four strings: application, version, date, and time.

Parameters
fileThe file.
stringsAn array of null-terminated strings.
num_stringsThe length of strings
statusPassed back status of API call.

Definition at line 768 of file file.c.

769 {
770  FileHandle* file_ptr;
771  hid_t data_id, type_id, space_id;
772  hsize_t dim = (hsize_t)num_strings;
773  herr_t rval;
774  API_BEGIN;
775 
776  file_ptr = (FileHandle*)( file_handle );
777  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
778 
779  type_id = H5Tcopy( H5T_C_S1 );
780  if( type_id < 0 || H5Tset_size( type_id, H5T_VARIABLE ) < 0 )
781  {
782  if( type_id >= 0 ) H5Tclose( type_id );
783  mhdf_setFail( status, "Could not create variable length string type." );
784  return;
785  }
786 
787  space_id = H5Screate_simple( 1, &dim, NULL );
788  if( space_id < 0 )
789  {
790  H5Tclose( type_id );
791  mhdf_setFail( status, "H5Screate_simple failed." );
792  return;
793  }
794 
795 #if defined( H5Dcreate_vers ) && H5Dcreate_vers > 1
796  data_id =
797  H5Dcreate2( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
798 #else
799  data_id = H5Dcreate( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT );
800 #endif
801  H5Sclose( space_id );
802  if( data_id < 0 )
803  {
804  H5Tclose( type_id );
805  mhdf_setFail( status, "Failed to create \"%s\".", HISTORY_PATH );
806  return;
807  }
808 
809  rval = H5Dwrite( data_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, strings );
810  H5Dclose( data_id );
811  H5Tclose( type_id );
812  if( rval < 0 )
813  {
814  H5Gunlink( file_ptr->hdf_handle, HISTORY_PATH );
815  mhdf_setFail( status, "Failed to write history data." );
816  return;
817  }
818 
819  mhdf_setOkay( status );
820  API_END;
821 }

References API_BEGIN, API_END, dim, struct_FileHandle::hdf_handle, HISTORY_PATH, mhdf_check_valid_file(), mhdf_setFail(), and mhdf_setOkay().

Referenced by moab::WriteHDF5::write_qa().

◆ mhdf_writeNodeCoord()

void mhdf_writeNodeCoord ( hid_t  data_handle,
long  offset,
long  count,
int  dimension,
const double *  coords,
mhdf_Status status 
)

Write node coordinate data.

Write a single coordinate value (e.g. the 'x' coordinate) for a block of nodes.

Parameters
data_handleHandle returned from mhdf_createNodeCoords or mhdf_openNodeCoords.
offsetTable row (node index) at which to start writing.
countNumber of rows (number of nodes) to write.
dimensionThe coordinate to write (0->x, 1->y, ...)
coordsCoordinate list.
statusPassed back status of API call.

Definition at line 195 of file nodes.c.

201 {
202  API_BEGIN;
203  mhdf_write_column( table_id, dimension, offset, count, H5T_NATIVE_DOUBLE, coords, H5P_DEFAULT, status );
204  API_END;
205 }

References API_BEGIN, API_END, and mhdf_write_column().

◆ mhdf_writeNodeCoords()

void mhdf_writeNodeCoords ( hid_t  data_handle,
long  offset,
long  count,
const double *  coords,
mhdf_Status status 
)

Write node coordinate data.

Write interleaved coordinate data for a block of nodes

Parameters
data_handleHandle returned from mhdf_createNodeCoords or mhdf_openNodeCoords.
offsetTable row (node index) at which to start writing.
countNumber of rows (number of nodes) to write.
coordsInterleaved node coordinate data.
statusPassed back status of API call.

Definition at line 159 of file nodes.c.

160 {
161  API_BEGIN;
162  mhdf_write_data( table_id, offset, count, H5T_NATIVE_DOUBLE, coords, H5P_DEFAULT, status );
163  API_END;
164 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writeNodeCoordsWithOpt()

void mhdf_writeNodeCoordsWithOpt ( hid_t  data_handle,
long  offset,
long  count,
const double *  coords,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 165 of file nodes.c.

171 {
172  API_BEGIN;
173  mhdf_write_data( table_id, offset, count, H5T_NATIVE_DOUBLE, coords, prop, status );
174  API_END;
175 }

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by moab::WriteHDF5::write_nodes().

◆ mhdf_writeNodeCoordWithOpt()

void mhdf_writeNodeCoordWithOpt ( hid_t  data_handle,
long  offset,
long  count,
int  dimension,
const double *  coords,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 206 of file nodes.c.

213 {
214  API_BEGIN;
215  mhdf_write_column( table_id, dimension, offset, count, H5T_NATIVE_DOUBLE, coords, prop, status );
216  API_END;
217 }

References API_BEGIN, API_END, and mhdf_write_column().

Referenced by moab::WriteHDF5::write_nodes().

◆ mhdf_writePolyConnIDs()

void mhdf_writePolyConnIDs ( hid_t  poly_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  id_list,
mhdf_Status status 
)

Write polygon or polyhedron connectivity data.

Poly (polygon or polyhedron) connectivity is stored as two lists. One list is the concatenation of the the connectivity data for all the polys in the group. The other contains one value per poly where that value is the index of the last entry in the connectivity of the corresponding poly. The ID list for polygons contains global node IDs. The ID list for polyhedra contains the global IDs of faces (either polygons or 2D fixed-connectivity elements.)

This function writes the connectivity/ID list.

Parameters
poly_handleThe handle returned from mhdf_createPolyConnectivity or mhdf_openPolyConnectivity.
offsetThe offset in the table at which to write. The offset is in terms of the integer values in the table, not the count of polys.
countThe size of the integer list to write.
hdf_integer_typeThe type of the integer data in id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
id_listThe count/global ID list specifying the connectivity of the polys.
statusPassed back status of API call.

Definition at line 373 of file connectivity.c.

379 {
380  API_BEGIN;
381  mhdf_write_data( table_id, offset, count, hdf_integer_type, id_list, H5P_DEFAULT, status );
382  API_END;
383 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writePolyConnIDsWithOpt()

void mhdf_writePolyConnIDsWithOpt ( hid_t  poly_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  id_list,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 384 of file connectivity.c.

391 {
392  API_BEGIN;
393  mhdf_write_data( table_id, offset, count, hdf_integer_type, id_list, prop, status );
394  API_END;
395 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writePolyConnIndices()

void mhdf_writePolyConnIndices ( hid_t  poly_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  index_list,
mhdf_Status status 
)

Write polygon or polyhedron index data.

Poly (polygon or polyhedron) connectivity is stored as two lists. One list is the concatenation of the the connectivity data for all the polys in the group. The other contains one value per poly where that value is the index of the last entry in the connectivity of the corresponding poly. The ID list for polygons contains global node IDs. The ID list for polyhedra contains the global IDs of faces (either polygons or 2D fixed-connectivity elements.)

This function writes the index list.

Parameters
poly_handleThe handle returned from mhdf_createPolyConnectivity or mhdf_openPolyConnectivity.
offsetThe offset in the table at which to write. The offset is in terms of the integer values in the table, not the count of polys.
countThe size of the integer list to write.
hdf_integer_typeThe type of the integer data in id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
index_listThe index list for the polys.
statusPassed back status of API call.

Definition at line 325 of file connectivity.c.

331 {
332  API_BEGIN;
333  mhdf_write_data( table_id, offset, count, hdf_integer_type, index_list, H5P_DEFAULT, status );
334  API_END;
335 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writePolyConnIndicesWithOpt()

void mhdf_writePolyConnIndicesWithOpt ( hid_t  poly_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  index_list,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 336 of file connectivity.c.

343 {
344  API_BEGIN;
345  mhdf_write_data( table_id, offset, count, hdf_integer_type, index_list, prop, status );
346  API_END;
347 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writeSetData()

void mhdf_writeSetData ( hid_t  set_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  set_data,
mhdf_Status status 
)

Write set contents.

Write data specifying entities contained in sets. The format of this data is a vector of integer values which is the concatenation of the contents list for all the meshsets. The length and format of the data for each set is stored in the set meta table. See mhdf_createSetMeta and mhdf_SET_RANGE_BIT for a description of that data.

Parameters
set_handleThe handle returned from mhdf_createSetData or mhdf_openSetData .
offsetThe position at which to write into the integer vector.
countThe number of values to write into the data vector.
hdf_integer_typeThe type of the integer data in set_data. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
set_dataThe data to write.
statusPassed back status of API call.

Definition at line 680 of file sets.c.

681 {
682  API_BEGIN;
683  mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
684  API_END;
685 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writeSetDataWithOpt()

void mhdf_writeSetDataWithOpt ( hid_t  set_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  set_data,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 686 of file sets.c.

693 {
694  API_BEGIN;
695  mhdf_write_data( table_id, offset, count, type, data, prop, status );
696  API_END;
697 }

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by moab::WriteHDF5::write_set_data().

◆ mhdf_writeSetMeta()

void mhdf_writeSetMeta ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  set_desc_data,
mhdf_Status status 
)

Write list of sets and meta-information about sets.

Write set descriptions. See mhdf_createSetMeta or mhdf Meshset data for a description of the data format.

Parameters
data_handleThe handle returned from mhdf_createSetMeta or mhdf_openSetMeta.
offsetThe offset (set index) to begin writing at.
countThe number of rows (sets, integer triples) to write.
hdf_integer_typeThe type of the integer data in set_desc_data. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
set_desc_dataThe data to write.
statusPassed back status of API call.

Definition at line 386 of file sets.c.

387 {
388  API_BEGIN;
389  mhdf_readwriteSetMeta( table_id, 0, offset, count, type, (void*)data, H5P_DEFAULT, status );
390  API_END;
391 }

References API_BEGIN, API_END, and mhdf_readwriteSetMeta().

◆ mhdf_writeSetMetaWithOpt()

void mhdf_writeSetMetaWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  set_desc_data,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 392 of file sets.c.

399 {
400  API_BEGIN;
401  mhdf_readwriteSetMeta( table_id, 0, offset, count, type, (void*)data, prop, status );
402  API_END;
403 }

References API_BEGIN, API_END, and mhdf_readwriteSetMeta().

Referenced by moab::WriteHDF5::write_sets().

◆ mhdf_writeSetParentsChildren()

void mhdf_writeSetParentsChildren ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  id_list,
mhdf_Status status 
)

Write set parent/child list.

Write the list of parent or child IDs for sets. See mhdf_createSetChildren and mhdf_createSetMeta for a description of this data.

Parameters
data_handleThe value returned from mhdf_createSetChildren or mhdf_openSetChildren.
offsetThe offset into the list of global IDs.
countThe number of global IDs to write.
hdf_integer_typeThe type of the integer data in child_id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
id_listThe data to write.
statusPassed back status of API call.

Definition at line 808 of file sets.c.

814 {
815  API_BEGIN;
816  mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
817  API_END;
818 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writeSetParentsChildrenWithOpt()

void mhdf_writeSetParentsChildrenWithOpt ( hid_t  data_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  id_list,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 819 of file sets.c.

826 {
827  API_BEGIN;
828  mhdf_write_data( table_id, offset, count, type, data, prop, status );
829  API_END;
830 }

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by moab::WriteHDF5::write_set_data().

◆ mhdf_writeSparseTagEntities()

void mhdf_writeSparseTagEntities ( hid_t  id_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  id_list,
mhdf_Status status 
)

Write Global ID list for sparse tag data.

Parameters
id_handleThe first handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData.
offsetThe offset at which to begin writing.
countThe number of global IDs to write.
hdf_integer_typeThe type of the integer data in id_list. Typically H5T_NATIVE_INT or N5T_NATIVE_LONG as defined in H5Tpublic.h. The HDF class of this type object must be H5T_INTEGER
id_listThe list of global IDs to write.
statusPassed back status of API call.

Definition at line 1589 of file tags.c.

1595 {
1596  API_BEGIN;
1597  mhdf_write_data( table_id, offset, count, int_type, id_list, H5P_DEFAULT, status );
1598  API_END;
1599 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writeSparseTagEntitiesWithOpt()

void mhdf_writeSparseTagEntitiesWithOpt ( hid_t  id_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  id_list,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 1600 of file tags.c.

1607 {
1608  API_BEGIN;
1609  mhdf_write_data( table_id, offset, count, int_type, id_list, io_prop, status );
1610  API_END;
1611 }

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by moab::WriteHDF5::write_sparse_ids().

◆ mhdf_writeSparseTagIndices()

void mhdf_writeSparseTagIndices ( hid_t  tag_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  end_indices,
mhdf_Status status 
)

Write sparse tag end indices for variable-length tag data.

Write sparse tag end indices for variable-length tag data. Each value in the list is the last index (zero-based) into the tag data for the corresponding entity.

Parameters
tag_handlehandle to the data object to write to.
offsetThe offset into the table at which to begin writting
countThe number of values to write.
hdf_integer_typeThe type of the values pointed to by end_indices (must be an integer type).
end_indicesThe values to store in the table.
statusOutput: API result.

Definition at line 1636 of file tags.c.

1642 {
1643  API_BEGIN;
1644  mhdf_write_data( table_id, offset, count, int_type, indices, H5P_DEFAULT, status );
1645  API_END;
1646 }

References API_BEGIN, API_END, and mhdf_write_data().

◆ mhdf_writeSparseTagIndicesWithOpt()

void mhdf_writeSparseTagIndicesWithOpt ( hid_t  tag_handle,
long  offset,
long  count,
hid_t  hdf_integer_type,
const void *  end_indices,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 1647 of file tags.c.

1654 {
1655  API_BEGIN;
1656  mhdf_write_data( table_id, offset, count, int_type, indices, io_prop, status );
1657  API_END;
1658 }

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by moab::WriteHDF5::write_var_len_indices().

◆ mhdf_writeTagValues()

void mhdf_writeTagValues ( hid_t  value_handle,
long  offset,
long  count,
hid_t  hdf_tag_data_type,
const void *  tag_data,
mhdf_Status status 
)

Write tag values.

Parameters
value_handleThe second handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData; or the handle returned by mhdf_createDenseTagData or mhdf_openDenseTagData.
offsetThe offset at which to begin writing.
countThe number of tag values to write.
hdf_tag_data_typeThe type of the data in memory.
It must be possible for the HDF library to convert between this type and the type the tag data is stored as.
tag_dataThe list of tag values to write.
statusPassed back status of API call.

Definition at line 1613 of file tags.c.

1619 {
1620  mhdf_writeTagValuesWithOpt( table_id, offset, count, tag_type, tag_data, H5P_DEFAULT, status );
1621 }

References mhdf_writeTagValuesWithOpt().

◆ mhdf_writeTagValuesWithOpt()

void mhdf_writeTagValuesWithOpt ( hid_t  value_handle,
long  offset,
long  count,
hid_t  hdf_tag_data_type,
const void *  tag_data,
hid_t  write_prop,
mhdf_Status status 
)

Definition at line 1623 of file tags.c.

1630 {
1631  API_BEGIN;
1632  mhdf_write_data( table_id, offset, count, tag_type, tag_data, io_prop, status );
1633  API_END;
1634 }

References API_BEGIN, API_END, and mhdf_write_data().

Referenced by mhdf_writeTagValues(), moab::WriteHDF5::write_tag_values(), and moab::WriteHDF5::write_var_len_data().