#include "moab/mhdf_public.h"

Include dependency graph for mhdf.h:

This graph shows which files directly or indirectly include 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_handle	File in which to create the element type.
elem_handle	The 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_type	An index into the list of named element types passed to mhdf_createFile .
status	Passed back status of API call.

Definition at line 507 of file file.c.

 {
     FileHandle* file_ptr = (FileHandle*)file_handle;
     hid_t group_id, tag_id, enum_id;
     char *path, *ptr;
     size_t name_len;
     herr_t rval;
     API_BEGIN;
  
     if( !mhdf_check_valid_file( file_ptr, status ) ) return;
  
     name_len = mhdf_name_to_path( name, NULL, 0 );
     name_len += strlen( ELEMENT_GROUP ) + 1;
     path = (char*)mhdf_malloc( name_len, status );
     if( !path ) return;
  
     strcpy( path, ELEMENT_GROUP );
     ptr = path + strlen( ELEMENT_GROUP );
     if( !mhdf_path_to_name( name, ptr ) )
     {
         mhdf_setFail( status, "Invalid character string in internal file path: \"%s\"\n", name );
         return;
     }
  
 #if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
     group_id = H5Gcreate2( file_ptr->hdf_handle, path, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
 #else
     group_id     = H5Gcreate( file_ptr->hdf_handle, path, 3 );
 #endif
     if( group_id < 0 )
     {
         mhdf_setFail( status, "Creation of \"%s\" group failed.\n", path );
         free( path );
         return;
     }
     free( path );
  
 #if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
     tag_id = H5Gcreate2( group_id, DENSE_TAG_SUBGROUP, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
 #else
     tag_id       = H5Gcreate( group_id, DENSE_TAG_SUBGROUP, 0 );
 #endif
     if( tag_id < 0 )
     {
         H5Gclose( group_id );
         mhdf_setFail( status, "Creation of tag subgroup failed.\n" );
         return;
     }
     H5Gclose( tag_id );
  
     enum_id = get_elem_type_enum( file_ptr, status );
     if( enum_id < 0 )
     {
         H5Gclose( group_id );
         return;
     }
  
     rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super( enum_id ), 1, &elem_type, NULL, H5P_DEFAULT );
     if( rval < 0 )
     {
         H5Gclose( group_id );
         H5Tclose( enum_id );
         mhdf_setFail( status, "Internal error converting to enum type." );
         return;
     }
  
     rval = mhdf_create_scalar_attrib( group_id, ELEM_TYPE_ATTRIB, enum_id, &elem_type, status );
     H5Tclose( enum_id );
     if( rval < 0 )
     {
         H5Gclose( group_id );
         return;
     }
  
     H5Gclose( group_id );
     mhdf_setOkay( status );
     API_END;
 }

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.

 {
     FileHandle* file_ptr;
     int result;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     /* Check for open handles.  HDF5 will not actually close the
        file until all handles are closed. */
     result = H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ALL );
     if( result != 1 )
     {
         mhdf_setFail( status,
                       "Cannot close file with open handles: "
                       "%d file, %d data, %d group, %d type, %d attr\n",
                       H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_FILE ) - 1,
                       H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATASET ),
                       H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_GROUP ),
                       H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATATYPE ),
                       H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ATTR ) );
         return result - 1;
     }
  
     API_END_H( 0 );
     return 0;
 }

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

file	The file the object pointed to by the passed data handled exists int.
handle	The data object to close.
status	Passed back status of API call.

Definition at line 470 of file file.c.

 {
     FileHandle* file_ptr;
     herr_t rval = -1;
  
     file_ptr = (FileHandle*)( file );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return;
  
     switch( H5Iget_type( handle ) )
     {
         case H5I_GROUP:
             rval = H5Gclose( handle );
             break;
         case H5I_DATATYPE:
             rval = H5Tclose( handle );
             break;
         case H5I_DATASPACE:
             rval = H5Sclose( handle );
             break;
         case H5I_DATASET:
             rval = H5Dclose( handle );
             break;
         default:
             rval = -1;
     }
  
     if( rval < 0 )
     {
         mhdf_setFail( status, "H5Xclose failed.  Invalid handle?\n" );
     }
     else
     {
         file_ptr->open_handle_count--;
         mhdf_setOkay( status );
     }
 }

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

◆ 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_handle	The file.
elem_handle	The element group (or the result of `mhdf_node_type_handle` for nodes) for which the adjacency data is to be specified.
adj_list_size	The total number of integer values contained in the adjacency data for the specified element group.
status	Passed back status of API call.

Returns: The HDF5 handle to the connectivity data.

Definition at line 61 of file adjacency.c.

 {
     FileHandle* file_ptr;
     hid_t elem_id, table_id;
     hsize_t dim = (hsize_t)adj_list_size;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( adj_list_size < 1 )
     {
         mhdf_setFail( status, "Invalid argument.\n" );
         return -1;
     }
  
     if( elem_handle == mhdf_node_type_handle() )
     {
         table_id = mhdf_create_table( file_ptr->hdf_handle, NODE_ADJCY_PATH, file_ptr->id_type, 1, &dim, status );
     }
     else
     {
         elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
         if( elem_id < 0 ) return -1;
  
         table_id = mhdf_create_table( elem_id, ADJACENCY_NAME, file_ptr->id_type, 1, &dim, status );
         H5Gclose( elem_id );
     }
  
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
elem_handle	The element group.
num_nodes_per_elem	The number of nodes in the connectivity data for each element.
num_elements	The number of elements to be written to the table.
first_elem_id_out	Elements 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.
status	Passed 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.

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.

 {
     FileHandle* file_ptr;
     hid_t elem_id, table_id;
     hsize_t dims[2];
     long first_id;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( nodes_per_elem <= 0 || count < 0 || !first_id_out )
     {
         mhdf_setFail( status, "Invalid argument." );
         return -1;
     }
  
     elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
     if( elem_id < 0 ) return -1;
  
     dims[0]  = (hsize_t)count;
     dims[1]  = (hsize_t)nodes_per_elem;
     table_id = mhdf_create_table( elem_id, CONNECTIVITY_NAME, file_ptr->id_type, 2, dims, status );
     H5Gclose( elem_id );
     if( table_id < 0 ) return -1;
  
     first_id = file_ptr->max_id + 1;
     if( !mhdf_create_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status ) )
     {
         H5Dclose( table_id );
         return -1;
     }
  
     *first_id_out = first_id;
     file_ptr->max_id += count;
     if( !mhdf_write_max_id( file_ptr, status ) )
     {
         H5Dclose( table_id );
         return -1;
     }
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
  
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
tag_name	The tag.
elem_group	The element group handle, or the return value of mhdf_node_type_handle or mhdf_set_type_handle for nodes or sets respectively.
num_values	The 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.
status	Passed back status of API call.

Returns: Handle to data object in file.

Definition at line 1268 of file tags.c.

 {
     char* path;
     hid_t elem_id, data_id, type_id;
     FileHandle* file_ptr;
     size_t name_len, path_len, dir_len;
     hsize_t size;
     API_BEGIN;
  
     file_ptr = (FileHandle*)file_handle;
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( type_handle == mhdf_node_type_handle() )
     {
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
         elem_id = H5Gopen2( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
 #else
         elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
 #endif
         if( elem_id < 0 ) mhdf_setFail( status, "Could not open node group." );
     }
     else if( type_handle == mhdf_set_type_handle() )
     {
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
         elem_id = H5Gopen2( file_ptr->hdf_handle, SET_GROUP, H5P_DEFAULT );
 #else
         elem_id = H5Gopen( file_ptr->hdf_handle, SET_GROUP );
 #endif
         if( elem_id < 0 ) mhdf_setFail( status, "Could not open set group." );
     }
     else
     {
         elem_id = mhdf_elem_group_from_handle( file_ptr, type_handle, status );
     }
     if( elem_id < 0 ) return -1;
  
     dir_len  = strlen( DENSE_TAG_SUBGROUP );
     name_len = mhdf_name_to_path( tag_name, NULL, 0 );
     path_len = dir_len + name_len + 1;
     path     = (char*)mhdf_malloc( path_len, status );
     if( NULL == path )
     {
         H5Gclose( elem_id );
         return -1;
     }
     strcpy( path, DENSE_TAG_SUBGROUP );
     mhdf_name_to_path( tag_name, path + dir_len, name_len + 1 );
  
     type_id = get_tag_type( file_ptr, path + dir_len, status );
     if( type_id < 0 )
     {
         H5Gclose( elem_id );
         return -1;
     }
  
     size    = (hsize_t)num_values;
     data_id = mhdf_create_table( elem_id, path, type_id, 1, &size, status );
     free( path );
     H5Gclose( elem_id );
     H5Tclose( type_id );
  
     if( data_id > 0 ) mhdf_setOkay( status );
  
     API_END_H( 1 );
     return data_id;
 }

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_handle	The file.
dimension	Number of coordinate values per node.
num_nodes	The number of nodes the table will contain.
first_node_id_out	Nodes 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.
status	Passed back status of API call.

Returns: An HDF5 handle to the coordinate table.

Definition at line 72 of file nodes.c.

 {
     FileHandle* file_ptr = (FileHandle*)file_handle;
     hid_t table_id;
     hsize_t dims[2];
     long first_id;
     API_BEGIN;
  
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( dimension < 1 )
     {
         mhdf_setFail( status, "Invalid argument: dimension = %d.", dimension );
         return -1;
     }
  
     dims[0]  = (hsize_t)num_nodes;
     dims[1]  = (hsize_t)dimension;
     table_id = mhdf_create_table( file_ptr->hdf_handle, NODE_COORD_PATH, H5T_NATIVE_DOUBLE, 2, dims, status );
     if( table_id < 0 ) return -1;
  
     first_id = file_ptr->max_id + 1;
     if( !mhdf_create_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status ) )
     {
         H5Dclose( table_id );
         return -1;
     }
  
     *first_id_out = first_id;
     file_ptr->max_id += num_nodes;
     if( !mhdf_write_max_id( file_ptr, status ) )
     {
         H5Dclose( table_id );
         return -1;
     }
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
  
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file to write.
elem_handle	The element group.
num_poly	The total number number of polygons or polyhedra to be written in the table.
data_list_length	The 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_out	Elements 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_out	The handles for the index list and connectivity list, respectively.
status	Passed back status of API call.

Definition at line 187 of file connectivity.c.

 {
     FileHandle* file_ptr;
     hid_t elem_id, index_id, conn_id;
     hsize_t dim;
     long first_id;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return;
  
     if( num_poly <= 0 || data_list_length <= 0 || !first_id_out )
     {
         mhdf_setFail( status, "Invalid argument." );
         return;
     }
  
     if( data_list_length < 3 * num_poly )
     {
         /* Could check agains 4*num_poly, but allow degenerate polys
            (1 for count plus 2 dim-1 defining entities, where > 2
             defining entities is a normal poly, 2 defining entities
             is a degenerate poly and 1 defning entity is not valid.)
         */
  
         mhdf_setFail( status,
                       "Invalid polygon data:  data length of %ld is "
                       "insufficient for %ld poly(gons/hedra).\n",
                       data_list_length, num_poly );
         return;
     }
  
     elem_id = mhdf_elem_group_from_handle( file_ptr, elem_type, status );
     if( elem_id < 0 ) return;
  
     dim      = (hsize_t)num_poly;
     index_id = mhdf_create_table( elem_id, POLY_INDEX_NAME, MHDF_INDEX_TYPE, 1, &dim, status );
     if( index_id < 0 )
     {
         H5Gclose( elem_id );
         return;
     }
  
     dim     = (hsize_t)data_list_length;
     conn_id = mhdf_create_table( elem_id, CONNECTIVITY_NAME, file_ptr->id_type, 1, &dim, status );
     H5Gclose( elem_id );
     if( conn_id < 0 )
     {
         H5Dclose( index_id );
         return;
     }
  
     first_id = file_ptr->max_id + 1;
     if( !mhdf_create_scalar_attrib( conn_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status ) )
     {
         H5Dclose( index_id );
         H5Dclose( conn_id );
         return;
     }
  
     *first_id_out = first_id;
     file_ptr->max_id += num_poly;
     if( !mhdf_write_max_id( file_ptr, status ) )
     {
         H5Dclose( index_id );
         H5Dclose( conn_id );
         return;
     }
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
     handles_out[0] = index_id;
     handles_out[1] = conn_id;
     API_END_H( 2 );
 }

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_handle	The file
child_list_size	The total length of the data (the sum of the number of children for each set.)
status	Passed back status of API call.

Returns: A handle to the data object in the file.

Definition at line 718 of file sets.c.

 {
     FileHandle* file_ptr;
     hid_t table_id;
     hsize_t dim = (hsize_t)child_list_size;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( child_list_size < 1 )
     {
         mhdf_setFail( status, "Invalid argument.\n" );
         return -1;
     }
  
     table_id = mhdf_create_table( file_ptr->hdf_handle, SET_CHILD_PATH, file_ptr->id_type, 1, &dim, status );
  
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
data_list_size	The total length (number of integer values) to be written for all the sets.
status	Passed back status of API call.

Returns: A handle to the table.

Definition at line 635 of file sets.c.

 {
     FileHandle* file_ptr;
     hid_t table_id;
     hsize_t dim = (hsize_t)data_list_size;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( data_list_size < 1 )
     {
         mhdf_setFail( status, "Invalid argument.\n" );
         return -1;
     }
  
     table_id = mhdf_create_table( file_ptr->hdf_handle, SET_DATA_PATH, file_ptr->id_type, 1, &dim, status );
  
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
num_sets	The number of sets in the table.
first_set_id_out	The 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.
status	Passed back status of API call.

Returns: The handle to the set meta-data table.

Definition at line 109 of file sets.c.

 {
     FileHandle* file_ptr = (FileHandle*)file;
     hid_t table_id;
     hsize_t dims[2];
     long first_id;
     API_BEGIN;
  
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     dims[0]  = (hsize_t)num_sets;
     dims[1]  = (hsize_t)4;
     table_id = mhdf_create_table( file_ptr->hdf_handle, SET_META_PATH, MHDF_INDEX_TYPE, 2, dims, status );
     if( table_id < 0 ) return -1;
  
     first_id = file_ptr->max_id + 1;
     if( !mhdf_create_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status ) )
     {
         H5Dclose( table_id );
         return -1;
     }
  
     *first_id_out = first_id;
     file_ptr->max_id += num_sets;
     if( !mhdf_write_max_id( file_ptr, status ) )
     {
         H5Dclose( table_id );
         return -1;
     }
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
  
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file
parent_list_size	The total length of the data (the sum of the number of parents for each set.)
status	Passed back status of API call.

Returns: A handle to the data object in the file.

Definition at line 763 of file sets.c.

 {
     FileHandle* file_ptr;
     hid_t table_id;
     hsize_t dim = (hsize_t)parent_list_size;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( parent_list_size < 1 )
     {
         mhdf_setFail( status, "Invalid argument.\n" );
         return -1;
     }
  
     table_id = mhdf_create_table( file_ptr->hdf_handle, SET_PARENT_PATH, file_ptr->id_type, 1, &dim, status );
  
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
tag_name	The tag.
num_values	The number of tag values to be written.
entities_and_values_out	The handles to the file objects. The first is the vector of global IDs. The second is the list of corresponding tag values.
status	Passed back status of API call.

Definition at line 1402 of file tags.c.

 {
     hid_t tag_id, index_id, data_id, type_id, id_type;
     hsize_t count = (hsize_t)num_values;
     API_BEGIN;
  
     tag_id = get_tag( file_handle, tag_name, &id_type, status );
     if( tag_id < 0 ) return;
  
 #if defined( H5Topen_vers ) && H5Topen_vers > 1
     type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
 #else
     type_id = H5Topen( tag_id, TAG_TYPE_NAME );
 #endif
     if( type_id < 0 )
     {
         H5Gclose( tag_id );
         mhdf_setFail( status, "Failed to get type object for tag \"%s\".", tag_name );
         return;
     }
  
     index_id = mhdf_create_table( tag_id, SPARSE_ENTITY_NAME, id_type, 1, &count, status );
     if( index_id < 0 )
     {
         H5Gclose( tag_id );
         H5Tclose( type_id );
         return;
     }
  
     data_id = mhdf_create_table( tag_id, SPARSE_VALUES_NAME, type_id, 1, &count, status );
     H5Tclose( type_id );
     H5Gclose( tag_id );
     if( data_id < 0 )
     {
         H5Dclose( index_id );
         return;
     }
  
     handles_out[0] = index_id;
     handles_out[1] = data_id;
     mhdf_setOkay( status );
     API_END_H( 2 );
 }

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_handle	The file
tag_name	The tag name
tag_type	The tag type.
size	If 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.
storage	MOAB storage type (dense, sparse, etc.)
default_value	Default value for tag, or NULL if none.
global_value	Global value for tag, or NULL if none.
hdf_type	If non-zero, assumed to be a user-specified type for opaque data. Ignored if tag_type is not mhdf_OPAQUE.
hdf_base_type	Ignored 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.

 {
     hid_t tag_id;
     API_BEGIN;
     tag_id = create_tag_common( file_handle, tag_name, tag_type, size, storage, default_value, 1, global_value, 1,
                                 hdf_type, hdf_base_type, status );
     if( tag_id >= 0 ) H5Gclose( tag_id );
     API_END;
 }

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_handle	The file
tag_name	The tag name
tag_type	The tag type.
storage	MOAB storage type (dense, sparse, etc.)
default_value	Default value for tag, or NULL if none.
default_value_length	Length of default value.
global_value	Global value for tag, or NULL if none.
global_value_length	Length of global value.
hdf_type	If non-zero, assumed to be a user-specified type for opaque data. Ignored if tag_type is not mhdf_OPAQUE.
hdf_base_type	Ignored 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.

 {
     hid_t tag_id;
     int one = 1;
  
     API_BEGIN;
     tag_id = create_tag_common( file_handle, tag_name, tag_type, -1, storage, default_value, default_value_length,
                                 global_value, global_value_length, hdf_type, hdf_base_type, status );
     if( tag_id >= 0 )
     {
         mhdf_create_scalar_attrib( tag_id, TAG_VARLEN_ATTRIB, H5T_NATIVE_INT, &one, status );
         H5Gclose( tag_id );
     }
     API_END;
 }

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_handle	The file.
tag_name	The tag.
num_entities	The number of entities for which tag values are to be stored
num_values	The total number of scalar values to be written (the total number of bytes of data for all tags for opaque data.)
entities_and_values_out	The 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.
status	Passed back status of API call.

Definition at line 1450 of file tags.c.

 {
     hid_t tag_id, index_id, data_id, type_id, offset_id, id_type;
     hsize_t count = (hsize_t)num_entities;
     API_BEGIN;
  
     tag_id = get_tag( file_handle, tag_name, &id_type, status );
     if( tag_id < 0 ) return;
  
 #if defined( H5Topen_vers ) && H5Topen_vers > 1
     type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
 #else
     type_id = H5Topen( tag_id, TAG_TYPE_NAME );
 #endif
     if( type_id < 0 )
     {
         H5Gclose( tag_id );
         mhdf_setFail( status, "Failed to get type object for tag \"%s\".", tag_name );
         return;
     }
  
     index_id = mhdf_create_table( tag_id, SPARSE_ENTITY_NAME, id_type, 1, &count, status );
     if( index_id < 0 )
     {
         H5Gclose( tag_id );
         H5Tclose( type_id );
         return;
     }
  
     offset_id = mhdf_create_table( tag_id, TAG_VAR_INDICES, MHDF_INDEX_TYPE, 1, &count, status );
     if( index_id < 0 )
     {
         H5Dclose( offset_id );
         H5Gclose( tag_id );
         H5Tclose( type_id );
         return;
     }
  
     count   = (hsize_t)num_values;
     data_id = mhdf_create_table( tag_id, SPARSE_VALUES_NAME, type_id, 1, &count, status );
     H5Tclose( type_id );
     H5Gclose( tag_id );
     if( data_id < 0 )
     {
         H5Dclose( offset_id );
         H5Dclose( index_id );
         return;
     }
  
     handles_out[0] = index_id;
     handles_out[1] = data_id;
     handles_out[2] = offset_id;
     mhdf_setOkay( status );
     API_END_H( 3 );
 }

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_handle	The file.
count_out	Memory location at which to store the length of the returned array.
status	Passed 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.

 {
     hsize_t count, length, i;
     char** buffer;
     char* current;
     hid_t group_id;
     herr_t rval;
     ssize_t rlen = 0;
     size_t remaining;
     FileHandle* file_ptr = (FileHandle*)file_handle;
     if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
  
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
     group_id = H5Gopen2( file_ptr->hdf_handle, ELEMENT_GROUP, H5P_DEFAULT );
 #else
     group_id     = H5Gopen( file_ptr->hdf_handle, ELEMENT_GROUP );
 #endif
     if( group_id < 0 )
     {
         mhdf_setFail( status, "Invalid file -- element group does not exist." );
         return NULL;
     }
  
     rval = H5Gget_num_objs( group_id, &count );
     if( rval < 0 )
     {
         H5Gclose( group_id );
         mhdf_setFail( status, "Internal error calling H5Gget_num_objs." );
         return NULL;
     }
     *count_out = count;
  
     for( i = 0; i < count; ++i )
     {
         rlen += H5Gget_objname_by_idx( group_id, i, NULL, 0 ) + 1;
     }
  
     length = count * sizeof( char* ) + rlen;
     buffer = (char**)mhdf_malloc( length, status );
     if( !buffer )
     {
         H5Gclose( group_id );
         return NULL;
     }
     current   = (char*)( buffer + count );
     remaining = rlen;
  
     for( i = 0; i < count; ++i )
     {
         buffer[i] = current;
         rlen      = H5Gget_objname_by_idx( group_id, i, current, remaining ) + 1;
         if( rlen < 0 )
         {
             H5Gclose( group_id );
             free( buffer );
             mhdf_setFail( status, "Internal error calling H5Gget_objname_by_idx." );
             return NULL;
         }
  
         mhdf_path_to_name( current, current );
         remaining -= rlen;
         current += rlen;
     }
  
     H5Gclose( group_id );
     mhdf_setOkay( status );
     return buffer;
 }

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_handle	The file.
type_index	The type index. Corresponds to indices into the element type list passed to mhdf_createFile.
buffer	The buffer into which to copy the name.
buffer_size	The length of `buffer`.
status	Passed back status of API call.

Definition at line 368 of file file.c.

 {
     FileHandle* file_ptr;
     herr_t rval;
     hid_t enum_id;
     API_BEGIN;
  
     if( type_index > 255 )
     {
         mhdf_setFail( status, "Type index out of bounds." );
         return;
     }
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return;
  
     enum_id = get_elem_type_enum( file_ptr, status );
     if( enum_id < 0 ) return;
  
     rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super( enum_id ), 1, &type_index, NULL, H5P_DEFAULT );
     if( rval < 0 )
     {
         H5Tclose( enum_id );
         mhdf_setFail( status, "Internal error converting to enum type." );
         return;
     }
  
     rval = H5Tenum_nameof( enum_id, &type_index, buffer, buf_size );
     H5Tclose( enum_id );
     if( rval < 0 )
         mhdf_setFail( status, "H5Tenum_nameof failed.  Invalid type index?" );
     else
         mhdf_setOkay( status );
  
     API_END;
 }

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_handle	The file.
elem_handle	One of the group names passed back from mhdf_getElemHandles
buffer	A buffer to copy the name into.
buf_len	The length of `buffer`.
status	Passed back status of API call.

Definition at line 655 of file file.c.

 {
     FileHandle* file_ptr;
     hid_t elem_id, type_id, attr_id;
     char bytes[16];
     herr_t rval;
     API_BEGIN;
  
     if( NULL == buffer || buf_len < 2 )
     {
         mhdf_setFail( status, "invalid input" );
         return;
     }
     buffer[0] = '\0';
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return;
  
     elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
     if( elem_id < 0 ) return;
  
     attr_id = H5Aopen_name( elem_id, ELEM_TYPE_ATTRIB );
     H5Gclose( elem_id );
     if( attr_id < 0 )
     {
         mhdf_setFail( status, "Missing element type attribute.  Invalid file." );
         return;
     }
  
     type_id = H5Aget_type( attr_id );
     assert( type_id > 0 );
  
     rval = H5Aread( attr_id, type_id, bytes );
     H5Aclose( attr_id );
     if( rval < 0 )
     {
         H5Tclose( type_id );
         mhdf_setFail( status, "Failed to read element type attribute.  Invalid file." );
         return;
     }
  
     rval = H5Tenum_nameof( type_id, bytes, buffer, buf_len );
     H5Tclose( type_id );
     if( rval < 0 )
     {
         mhdf_setFail( status, "Invalid datatype for element type attribute.  Invalid file." );
         return;
     }
  
     mhdf_setOkay( status );
     API_END;
     return;
 }

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_type	The type to convert.
size	The desired size in bytes.
status	Passed 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.

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.

 {
     H5T_sign_t sgn;
     H5T_class_t cls;
     hid_t tmp_id, type_id;
  
     mhdf_setOkay( status );
  
     cls = H5Tget_class( input_type );
     switch( cls )
     {
         case H5T_FLOAT:
             switch( size )
             {
                 case 4:
                     return H5T_NATIVE_FLOAT;
                 case 8:
                     return H5T_NATIVE_DOUBLE;
                 case 16:
                     return H5T_NATIVE_LDOUBLE;
                 default:
                     mhdf_setFail( status, "Invalid size for floating point type: %d", size );
                     return -1;
             }
  
         case H5T_INTEGER:
             sgn = H5Tget_sign( input_type );
             if( H5T_SGN_ERROR == sgn )
             {
                 mhdf_setFail( status, "Internall errror calling H5Tget_sign." );
                 return -1;
             }
             if( sizeof( char ) == size )
                 return sgn == H5T_SGN_NONE ? H5T_NATIVE_UCHAR : H5T_NATIVE_SCHAR;
             else if( sizeof( short ) == size )
                 return sgn == H5T_SGN_NONE ? H5T_NATIVE_USHORT : H5T_NATIVE_SHORT;
             else if( sizeof( int ) == size )
                 return sgn == H5T_SGN_NONE ? H5T_NATIVE_UINT : H5T_NATIVE_INT;
             else if( sizeof( long ) == size )
                 return sgn == H5T_SGN_NONE ? H5T_NATIVE_ULONG : H5T_NATIVE_LONG;
             else if( (int)H5Tget_size( H5T_NATIVE_LLONG ) == size )
                 return sgn == H5T_SGN_NONE ? H5T_NATIVE_ULLONG : H5T_NATIVE_LLONG;
  
             mhdf_setFail( status, "Invalid size for integer type: %d", size );
             return -1;
  
         case H5T_ENUM:
             tmp_id = H5Tget_super( input_type );
             if( tmp_id < 0 )
             {
                 mhdf_setFail( status, "Internal error calling H5Tget_super." );
                 return -1;
             }
             type_id = mhdf_getNativeType( tmp_id, size, status );
             H5Tclose( tmp_id );
             return type_id;
  
         case H5T_TIME:
         case H5T_OPAQUE:
         case H5T_REFERENCE:
             mhdf_setFail( status, "Unsupported type class." );
             return -1;
  
         case H5T_COMPOUND:
         case H5T_VLEN:
         case H5T_ARRAY:
         case H5T_STRING:
             mhdf_setFail( status, "Only atomic types are supported." );
             return -1;
  
         default:
             mhdf_setFail( status, "Internal error calling H5Tget_class.  Bad handle?" );
             return -1;
     }
 }

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.

 {
     FileHandle* file_ptr = (FileHandle*)file;
     API_BEGIN;
  
     mhdf_setOkay( status );
     if( mhdf_check_valid_file( file_ptr, status ) ) *start_id_out = file_ptr->max_id + 1;
  
     API_END;
 }

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_handle	The file.
status	Passed back status of API call.

Returns: The number of tags.

Definition at line 615 of file tags.c.

 {
     hid_t group_id;
     hsize_t result;
     FileHandle* file_ptr;
     API_BEGIN;
  
     /* Validate input */
  
     file_ptr = (FileHandle*)file_handle;
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
         /* Open the tags group */
  
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
     group_id = H5Gopen2( file_ptr->hdf_handle, TAG_GROUP, H5P_DEFAULT );
 #else
     group_id = H5Gopen( file_ptr->hdf_handle, TAG_GROUP );
 #endif
     if( group_id < 0 )
     {
         mhdf_setFail( status, "H5Gopen(\"%s\") failed", TAG_GROUP );
         return -1;
     }
  
     /* Get number of objects in tags group */
  
     if( H5Gget_num_objs( group_id, &result ) < 0 )
     {
         mhdf_setFail( status, "Internal failure calling H5Gget_num_objs." );
         H5Gclose( group_id );
         return -1;
     }
  
     H5Gclose( group_id );
     mhdf_setOkay( status );
     API_END;
     return (int)result;
 }

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.

 {
     FileHandle* file_ptr;
     hid_t result;
     char* path;
     API_BEGIN;
  
     /* Validate input */
  
     file_ptr = (FileHandle*)file_handle;
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( !tag_name || !*tag_name )
     {
         mhdf_setFail( status, "Invalid tag name" );
         return -1;
     }
  
     /* Create path string for tag object */
  
     path = mhdf_name_to_path_copy( tag_name, status );
     if( !path )
     {
         return -1;
     }
  
     result = get_tag_type( file_ptr, path, status );
  
     free( path );
     API_END;
     return result;
 }

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_handle	The file.
tag_name	The name of the tag to retrieve the data for.
class_out	The TSTT class of the tag data.
size_out	Depends 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_out	The value of the TSTT enum for storage (dense, sparse, etc.)
have_default_out	Non-zero if file contains a default value for the tag. Length of default value if variable-lenth tag.
have_global_out	Non-zero if the file contains a global/mesh value for the tag.
have_sparse_out	Non-zero if the file contains a sparse data table for this tag.

Definition at line 806 of file tags.c.

 {
     hid_t tag_id, type_id, super_id;
     int i, rval, is_handle;
     hsize_t size, sup_size;
     unsigned int idx;
     int rank, var_data;
     hsize_t dims[H5S_MAX_RANK];
     int perm[H5S_MAX_RANK];
     H5T_class_t class_tmp;
  
     API_BEGIN;
  
     /* Validate input */
     if( NULL == tag_name || NULL == class_out || NULL == size_out || NULL == tstt_storage_out ||
         NULL == have_default_out || NULL == have_global_out || NULL == have_sparse_out )
     {
         mhdf_setFail( status, "Invalid input." );
         return;
     }
  
     /* Get group for tag */
     tag_id = get_tag( file_handle, tag_name, NULL, status );
     if( tag_id < 0 ) return;
  
     /* Check for sparse data */
     rval = mhdf_is_in_group( tag_id, SPARSE_ENTITY_NAME, status );
     if( rval < 0 )
     {
         H5Gclose( tag_id );
         return;
     }
     *have_sparse_out = rval ? 1 : 0;
  
     /* Check for variable-length tag data */
     rval = mhdf_find_attribute( tag_id, TAG_VARLEN_ATTRIB, &idx, status );
     if( rval < 0 )
     {
         H5Gclose( tag_id );
         return;
     }
     var_data = rval ? 1 : 0;
  
     /* Check if have default value for tag */
     rval = mhdf_find_attribute( tag_id, TAG_DEFAULT_ATTRIB, &idx, status );
     if( rval < 0 )
     {
         H5Gclose( tag_id );
         return;
     }
     if( !rval )
         *have_default_out = 0;
     else if( !var_data )
         *have_default_out = 1;
     else
     {
         /* *have_default_out = get_attrib_array_length_index( tag_id, index ); */
         *have_default_out = get_attrib_array_length_name( tag_id, TAG_DEFAULT_ATTRIB );
         if( *have_default_out < 0 )
         {
             mhdf_setFail( status, "Error checking length of default value for tag: %s\n", tag_name );
             H5Gclose( tag_id );
             return;
         }
     }
  
     /* Check if have global value for tag */
     rval = mhdf_find_attribute( tag_id, TAG_GLOBAL_ATTRIB, &idx, status );
     if( rval < 0 )
     {
         H5Gclose( tag_id );
         return;
     }
     if( !rval )
         *have_global_out = 0;
     else if( !var_data )
         *have_global_out = 1;
     else
     {
         /* *have_global_out = get_attrib_array_length_index( tag_id, index ); */
         *have_global_out = get_attrib_array_length_name( tag_id, TAG_GLOBAL_ATTRIB );
         if( *have_global_out < 0 )
         {
             mhdf_setFail( status, "Error checking length of global value for tag: %s\n", tag_name );
             H5Gclose( tag_id );
             return;
         }
     }
  
     /* Get TSTT tag class */
     rval = mhdf_read_scalar_attrib( tag_id, TAG_TYPE_ATTRIB, H5T_NATIVE_INT, tstt_storage_out, status );
     if( rval < 1 )
     {
         H5Gclose( tag_id );
         return;
     }
  
     /* Check if tag is storing entity handles */
     rval = mhdf_find_attribute( tag_id, TAG_HANDLE_TYPE_ATTRIB, &idx, status );
     if( rval < 0 )
     {
         H5Gclose( tag_id );
         return;
     }
     is_handle = rval;
  
     /* Get tag type */
 #if defined( H5Topen_vers ) && H5Topen_vers > 1
     type_id = H5Topen2( tag_id, TAG_TYPE_NAME, H5P_DEFAULT );
 #else
     type_id = H5Topen( tag_id, TAG_TYPE_NAME );
 #endif
     if( type_id < 0 )
     {
         H5Gclose( tag_id );
         mhdf_setFail( status, "Failed to get type object for tag \"%s\".", tag_name );
         return;
     }
  
     class_tmp = H5Tget_class( type_id );
     if( class_tmp < 0 )
     {
         mhdf_setFail( status, "H5Tget_class failed." );
         H5Gclose( tag_id );
         H5Tclose( type_id );
         return;
     }
  
     size = H5Tget_size( type_id );
     if( size <= 0 )
     {
         mhdf_setFail( status, "H5Tget_size failed." );
         H5Gclose( tag_id );
         H5Tclose( type_id );
         return;
     }
  
     switch( class_tmp )
     {
         case H5T_INTEGER:
             *class_out = ( size == 1 ) ? mhdf_BOOLEAN : mhdf_INTEGER;
             *size_out  = 1;
             break;
  
         case H5T_FLOAT:
             *class_out = mhdf_FLOAT;
             *size_out  = 1;
             break;
  
         case H5T_BITFIELD:
             *class_out = mhdf_BITFIELD;
             *size_out  = H5Tget_precision( type_id );
             if( *size_out <= 0 )
             {
                 mhdf_setFail( status, "H5Tget_precision failed." );
                 H5Gclose( tag_id );
                 H5Tclose( type_id );
                 return;
             }
             break;
  
         default:
         case H5T_OPAQUE:
             *class_out = mhdf_OPAQUE;
             *size_out  = size;
             break;
  
         case H5T_ARRAY:
  
 #if defined( H5Tget_array_dims_vers ) && H5Tget_array_dims_vers > 1
             (void)perm; /* suppress warning */
             rank = H5Tget_array_dims2( type_id, dims );
 #else
             rank      = H5Tget_array_dims( type_id, dims, perm );
 #endif
             if( rank <= 0 )
             {
                 mhdf_setFail( status, "H5Tget_size failed." );
                 H5Gclose( tag_id );
                 H5Tclose( type_id );
                 return;
             }
             for( i = 1; i < rank; ++i )
                 dims[0] *= dims[i];
  
             super_id = H5Tget_super( type_id );
             if( super_id < 0 )
             {
                 mhdf_setFail( status, "H5Tget_super failed" );
                 H5Gclose( tag_id );
                 H5Tclose( type_id );
                 return;
             }
  
             class_tmp = H5Tget_class( super_id );
             if( class_tmp < 0 )
             {
                 mhdf_setFail( status, "H5Tget_class failed." );
                 H5Gclose( tag_id );
                 H5Tclose( type_id );
                 H5Tclose( super_id );
                 return;
             }
  
             sup_size = H5Tget_size( super_id );
             H5Tclose( super_id );
             if( sup_size <= 0 )
             {
                 mhdf_setFail( status, "H5Tget_size failed." );
                 H5Gclose( tag_id );
                 H5Tclose( type_id );
                 return;
             }
  
             switch( class_tmp )
             {
                 case H5T_INTEGER:
                     *class_out = ( sup_size == 1 ) ? mhdf_BOOLEAN : mhdf_INTEGER;
                     *size_out  = dims[0];
                     break;
  
                 case H5T_FLOAT:
                     *class_out = mhdf_FLOAT;
                     *size_out  = dims[0];
                     break;
  
                 default:
                     *class_out = mhdf_OPAQUE;
                     *size_out  = size;
                     break;
             }
  
             break;
     }
     H5Tclose( type_id );
     H5Gclose( tag_id );
  
     if( is_handle )
     {
         if( *class_out != mhdf_INTEGER )
         {
             mhdf_setFail( status, "Non-integer tag marked as handle type." );
             return;
         }
         *class_out = mhdf_ENTITY_ID;
     }
  
     if( var_data )
     {
         if( *size_out != 1 || *class_out == mhdf_BITFIELD )
         {
             mhdf_setFail( status, "Invalid or unexpected variable-length tag data" );
             return;
         }
         *size_out = -1;
     }
  
     mhdf_setOkay( status );
     API_END;
 }

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_handle	The file.
num_names_out	The length of the returned array of strings.
status	Passed 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.

 {
     hid_t group_id;
     FileHandle* file_ptr;
     hsize_t count, idx;
     char* name;
     char** result;
     ssize_t size;
     API_BEGIN;
  
     /* Validate input */
  
     file_ptr = (FileHandle*)file_handle;
     if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
  
         /* Open the tags group */
  
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
     group_id = H5Gopen2( file_ptr->hdf_handle, TAG_GROUP, H5P_DEFAULT );
 #else
     group_id = H5Gopen( file_ptr->hdf_handle, TAG_GROUP );
 #endif
     if( group_id < 0 )
     {
         mhdf_setFail( status, "H5Gopen(\"%s\") failed", TAG_GROUP );
         return NULL;
     }
  
     /* Get number of objects in tags group */
  
     if( H5Gget_num_objs( group_id, &count ) < 0 )
     {
         mhdf_setFail( status, "Internal failure calling H5Gget_num_objs." );
         H5Gclose( group_id );
         return NULL;
     }
  
     /* No tags? */
  
     *num_names_out = (int)count;
     if( count == 0 )
     {
         H5Gclose( group_id );
         mhdf_setOkay( status );
         return NULL;
     }
  
     /* Allocate string array */
  
     result = (char**)mhdf_malloc( sizeof( char* ) * count, status );
     if( NULL == result )
     {
         H5Gclose( group_id );
         return NULL;
     }
  
     /* Get names */
  
     for( idx = 0; idx < count; ++idx )
     {
         size = H5Gget_objname_by_idx( group_id, idx, NULL, 0 );
         if( size < 1 || NULL == ( name = (char*)mhdf_malloc( size + 1, status ) ) )
         {
             while( ( --idx ) > 0 )
                 free( result[idx] );
             free( result );
             H5Gclose( group_id );
             mhdf_setFail( status, "Internal failure calling H5Gget_objname_by_idx." );
             return NULL;
         }
  
         H5Gget_objname_by_idx( group_id, idx, name, size + 1 );
         if( !mhdf_path_to_name( name, name ) )
         {
             mhdf_setFail( status, "Invalid character string in internal file path: \"%s\"\n", name );
             return NULL;
         }
         result[idx] = name;
     }
  
     H5Gclose( group_id );
     mhdf_setOkay( status );
     API_END;
     return result;
 }

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_handle	The file.
tag_name	The tag name.
output_data_type	The 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_value	Memory location at which to write the default value of the tag.
global_value	If the tag has a global value, the memory location at which to write that value.
status	Passed back status of API call.

Definition at line 1135 of file tags.c.

 {
     hid_t tag_id;
     int rval, var_data;
     unsigned int idx;
     API_BEGIN;
  
     /* check args */
     if( NULL == tag_name || !*tag_name )
     {
         mhdf_setFail( status, "Invalid input." );
         return;
     }
  
     /* Get the tag group */
     tag_id = get_tag( file_handle, tag_name, NULL, status );
     if( tag_id < 0 ) return;
  
     /* Check for variable-length tag data */
     rval = mhdf_find_attribute( tag_id, TAG_VARLEN_ATTRIB, &idx, status );
     if( rval < 0 )
     {
         H5Gclose( tag_id );
         return;
     }
     var_data = rval ? 1 : 0;
  
     /* Read default value if present */
     rval = read_tag_attrib_data( tag_id, TAG_DEFAULT_ATTRIB, output_data_type, default_value, var_data, status );
     if( !rval )
     {
         H5Gclose( tag_id );
         return;
     }
  
     /* Read mesh value if present */
     rval = read_tag_attrib_data( tag_id, TAG_GLOBAL_ATTRIB, output_data_type, global_value, var_data, status );
     if( !rval )
     {
         H5Gclose( tag_id );
         return;
     }
  
     H5Gclose( tag_id );
     mhdf_setOkay( status );
     API_END;
 }

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

file	The file.
elem_handle	A handle to an element group.
status	Passed back status of API call.

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

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.

 {
     FileHandle* file_ptr;
     hid_t elem_id;
     int result;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( elem_group == mhdf_node_type_handle() )
     {
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
         elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
 #else
         elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
 #endif
         if( elem_id < 0 )
         {
             mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.\n", NODE_GROUP );
             return -1;
         }
     }
     else
     {
         elem_id = mhdf_elem_group_from_handle( file_ptr, elem_group, status );
         if( elem_id < 0 ) return -1;
     }
  
     result = mhdf_is_in_group( elem_id, ADJACENCY_NAME, status );
     H5Gclose( elem_id );
     mhdf_setOkay( status );
     API_END;
     return result;
 }

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_handle	The file.
tag_name	The tag.
elem_group	The element group handle, or the return value of mhdf_node_type_handle or mhdf_set_type_handle for nodes or sets respectively.
status	Passed back status of API call.

Returns: Non-zero if file contains specified data. Zero otherwise.

Definition at line 1188 of file tags.c.

 {
     char* path;
     hid_t elem_id, group_id;
     FileHandle* file_ptr;
     int rval = 0;
     API_BEGIN;
  
     file_ptr = (FileHandle*)file_handle;
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( type_handle == mhdf_node_type_handle() )
     {
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
         elem_id = H5Gopen2( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
 #else
         elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
 #endif
         if( elem_id < 0 ) mhdf_setFail( status, "Could not open node group." );
     }
     else if( type_handle == mhdf_set_type_handle() )
     {
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
         elem_id = H5Gopen2( file_ptr->hdf_handle, SET_GROUP, H5P_DEFAULT );
 #else
         elem_id = H5Gopen( file_ptr->hdf_handle, SET_GROUP );
 #endif
         if( elem_id < 0 ) mhdf_setFail( status, "Could not open set group." );
     }
     else
     {
         elem_id = mhdf_elem_group_from_handle( file_ptr, type_handle, status );
     }
     if( elem_id < 0 ) return -1;
  
     rval = mhdf_is_in_group( elem_id, TAG_GROUP_NAME, status );
     if( rval < 0 )
     {
         H5Gclose( elem_id );
         return -1;
     }
     else if( rval == 0 )
     {
         H5Gclose( elem_id );
         mhdf_setOkay( status );
         return 0;
     }
  
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
     group_id = H5Gopen2( elem_id, DENSE_TAG_SUBGROUP, H5P_DEFAULT );
 #else
     group_id = H5Gopen( elem_id, DENSE_TAG_SUBGROUP );
 #endif
     H5Gclose( elem_id );
     if( group_id < 0 )
     {
         mhdf_setFail( status, "Could not open tag subgroup." );
         return -1;
     }
  
     path = mhdf_name_to_path_copy( tag_name, status );
     if( NULL == path )
     {
         H5Gclose( group_id );
         return -1;
     }
  
     rval = mhdf_is_in_group( group_id, path, status );
     H5Gclose( group_id );
     free( path );
  
     if( rval >= 0 )
     {
         mhdf_setOkay( status );
     }
  
     API_END;
     return rval;
 }

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.

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.

 {
     FileHandle* file_ptr = (FileHandle*)file;
     hid_t root_id, node_id;
     int result;
     API_BEGIN;
  
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
     root_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
 #else
     root_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
 #endif
     if( root_id < 0 )
     {
         mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", ROOT_GROUP );
         return -1;
     }
  
     result = mhdf_is_in_group( root_id, NODE_GROUP_NAME, status );
     if( result < 1 )
     {
         H5Gclose( root_id );
         return result;
     }
  
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
     node_id = H5Gopen2( root_id, NODE_GROUP_NAME, H5P_DEFAULT );
 #else
     node_id = H5Gopen( root_id, NODE_GROUP_NAME );
 #endif
     H5Gclose( root_id );
     if( node_id < 0 )
     {
         mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", NODE_GROUP );
         return -1;
     }
  
     result = mhdf_is_in_group( node_id, NODE_COORD_NAME, status );
     if( result >= 0 ) mhdf_setOkay( status );
     H5Gclose( node_id );
     API_END;
     return result;
 }

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

file	The file.
have_set_data_out	If non-null set to 1 if file contains table of set contents, zero otherwise.
have_set_child_out	If non-null set to 1 if file contains table of set children, zero otherwise.
have_set_parents_out	If non-null set to 1 if file contains table of set parents, zero otherwise.
status	Passed 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.

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.

 {
     FileHandle* file_ptr = (FileHandle*)file;
     hid_t root_id, set_id;
     int result;
     API_BEGIN;
  
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
     root_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
 #else
     root_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
 #endif
     if( root_id < 0 )
     {
         mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", ROOT_GROUP );
         return -1;
     }
  
     result = mhdf_is_in_group( root_id, SET_GROUP_NAME, status );
     if( result < 1 )
     {
         H5Gclose( root_id );
         return result;
     }
  
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
     set_id = H5Gopen2( root_id, SET_GROUP_NAME, H5P_DEFAULT );
 #else
     set_id  = H5Gopen( root_id, SET_GROUP_NAME );
 #endif
     H5Gclose( root_id );
     if( set_id < 0 )
     {
         mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", SET_GROUP );
         return -1;
     }
  
     result = mhdf_is_in_group( set_id, SET_META_NAME, status );
     if( result < 0 )
     {
         H5Gclose( set_id );
         return result;
     }
  
     if( have_data )
     {
         *have_data = mhdf_is_in_group( set_id, SET_DATA_NAME, status );
         if( *have_data < 0 )
         {
             H5Gclose( set_id );
             return *have_data;
         }
     }
  
     if( have_child )
     {
         *have_child = mhdf_is_in_group( set_id, SET_CHILD_NAME, status );
         if( *have_child < 0 )
         {
             H5Gclose( set_id );
             return *have_child;
         }
     }
  
     if( have_parent )
     {
         *have_parent = mhdf_is_in_group( set_id, SET_PARENT_NAME, status );
         if( *have_parent < 0 )
         {
             H5Gclose( set_id );
             return *have_parent;
         }
     }
  
     mhdf_setOkay( status );
     H5Gclose( set_id );
     API_END;
     return result;
 }

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_handle	The file.
elem_handle	The element group.
status	Passed 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.

 {
     FileHandle* file_ptr;
     hid_t elem_id;
     int rval;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
     if( elem_id < 0 ) return -1;
  
     mhdf_setOkay( status );
     rval = mhdf_is_in_group( elem_id, POLY_INDEX_NAME, status );
     H5Gclose( elem_id );
     API_END;
     return rval;
 }

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.

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.

 {
     static const char rval[] = "nodes";
     return rval;
 }

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_handle	The file.
elem_handle	The element group (or the result of `mhdf_node_type_handle` for nodes) for which the adjacency data is to be specified.
adj_list_size	The total number of integer values contained in the adjacency data for the specified element group.
status	Passed back status of API call.

Returns: The HDF5 handle to the connectivity data.

Definition at line 94 of file adjacency.c.

 {
     FileHandle* file_ptr;
     hid_t elem_id, table_id;
     hsize_t dim;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( !adj_list_size_out )
     {
         mhdf_setFail( status, "Invalid argument.\n" );
         return -1;
     }
  
     if( elem_handle == mhdf_node_type_handle() )
     {
         table_id = mhdf_open_table( file_ptr->hdf_handle, NODE_ADJCY_PATH, 1, &dim, status );
     }
     else
     {
         elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
         if( elem_id < 0 ) return -1;
         table_id = mhdf_open_table( elem_id, ADJACENCY_NAME, 1, &dim, status );
         H5Gclose( elem_id );
     }
  
     *adj_list_size_out = (long)dim;
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
elem_handle	The element group.
num_nodes_per_elem_out	Used to pass back the number of nodes in each element.
num_elements_out	Pass back the number of elements in the table.
first_elem_id_out	Elements 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.
status	Passed back status of API call.

Returns: The HDF5 handle to the connectivity data.

Definition at line 78 of file connectivity.c.

 {
     FileHandle* file_ptr;
     hid_t elem_id, table_id;
     hsize_t dims[2];
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( !num_nodes_per_elem_out || !num_elements_out || !first_elem_id_out )
     {
         mhdf_setFail( status, "Invalid argument." );
         return -1;
     }
  
     elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
     if( elem_id < 0 ) return -1;
  
     table_id = mhdf_open_table2( elem_id, CONNECTIVITY_NAME, 2, dims, first_elem_id_out, status );
  
     H5Gclose( elem_id );
     if( table_id < 0 ) return -1;
  
     *num_elements_out       = dims[0];
     *num_nodes_per_elem_out = dims[1];
  
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
     API_END_H( 1 );
     return table_id;
 }

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.

 {
     FileHandle* file_ptr;
     hid_t elem_id, table_id;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
     if( elem_id < 0 ) return -1;
  
     table_id = mhdf_open_table_simple( elem_id, CONNECTIVITY_NAME, status );
  
     H5Gclose( elem_id );
     if( table_id < 0 ) return -1;
  
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
tag_name	The tag.
elem_group	The element group handle, or the return value of mhdf_node_type_handle or mhdf_set_type_handle for nodes or sets respectively.
num_values_out	The number of tag values to be written. Must be The same as the number of elements in the group.
status	Passed back status of API call.

Returns: Handle to data object in file.

Definition at line 1339 of file tags.c.

 {
     char* path;
     hid_t elem_id, data_id;
     FileHandle* file_ptr;
     size_t name_len, path_len, dir_len;
     hsize_t size;
     API_BEGIN;
  
     file_ptr = (FileHandle*)file_handle;
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( type_handle == mhdf_node_type_handle() )
     {
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
         elem_id = H5Gopen2( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
 #else
         elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
 #endif
         if( elem_id < 0 ) mhdf_setFail( status, "Could not open node group." );
     }
     else if( type_handle == mhdf_set_type_handle() )
     {
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
         elem_id = H5Gopen2( file_ptr->hdf_handle, SET_GROUP, H5P_DEFAULT );
 #else
         elem_id = H5Gopen( file_ptr->hdf_handle, SET_GROUP );
 #endif
         if( elem_id < 0 ) mhdf_setFail( status, "Could not open set group." );
     }
     else
     {
         elem_id = mhdf_elem_group_from_handle( file_ptr, type_handle, status );
     }
     if( elem_id < 0 ) return -1;
  
     dir_len  = strlen( DENSE_TAG_SUBGROUP );
     name_len = mhdf_name_to_path( tag_name, NULL, 0 );
     path_len = dir_len + name_len + 1;
     path     = (char*)mhdf_malloc( path_len, status );
     if( NULL == path )
     {
         H5Gclose( elem_id );
         return -1;
     }
     strcpy( path, DENSE_TAG_SUBGROUP );
     mhdf_name_to_path( tag_name, path + dir_len, name_len + 1 );
  
     data_id = mhdf_open_table( elem_id, path, 1, &size, status );
     free( path );
     H5Gclose( elem_id );
     *num_values_out = (long)size;
  
     if( data_id >= 0 ) mhdf_setOkay( status );
  
     API_END_H( 1 );
     return data_id;
 }

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_handle	The file.
dimension_out	Number of coordinate values per node.
num_nodes_out	The number of nodes the table contains.
first_node_id_out	Nodes 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.
status	Passed back status of API call.

Returns: An HDF5 handle to the coordinate table.

Definition at line 118 of file nodes.c.

 {
     FileHandle* file_ptr = (FileHandle*)file_handle;
     hid_t table_id;
     hsize_t dims[2];
     API_BEGIN;
  
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     table_id = mhdf_open_table2( file_ptr->hdf_handle, NODE_COORD_PATH, 2, dims, first_id_out, status );
     if( table_id < 0 ) return -1;
  
     *num_nodes_out = dims[0];
     *dimension_out = dims[1];
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
     API_END_H( 1 );
     return table_id;
 }

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.

 {
     FileHandle* file_ptr = (FileHandle*)file_handle;
     hid_t table_id;
     API_BEGIN;
  
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     table_id = mhdf_open_table_simple( file_ptr->hdf_handle, NODE_COORD_PATH, status );
     if( table_id < 0 ) return -1;
  
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file to write.
elem_handle	The element group.
num_poly_out	The total number number of polygons or polyhedra to be written in the table.
data_list_length_out	The 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_out	Elements 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_out	The handles for the index list and connectivity list, respectively.
status	Passed back status of API call.

Definition at line 268 of file connectivity.c.

 {
     FileHandle* file_ptr;
     hid_t elem_id, table_id, index_id;
     hsize_t row_count;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return;
  
     if( !num_poly_out || !data_list_length_out || !first_poly_id_out )
     {
         mhdf_setFail( status, "Invalid argument." );
         return;
     }
  
     elem_id = mhdf_elem_group_from_handle( file_ptr, element_handle, status );
     if( elem_id < 0 ) return;
  
     index_id = mhdf_open_table( elem_id, POLY_INDEX_NAME, 1, &row_count, status );
     if( index_id < 0 )
     {
         H5Gclose( elem_id );
         return;
     }
     *num_poly_out = (int)row_count;
  
     table_id = mhdf_open_table( elem_id, CONNECTIVITY_NAME, 1, &row_count, status );
  
     H5Gclose( elem_id );
     if( table_id < 0 )
     {
         H5Dclose( index_id );
         return;
     }
     *data_list_length_out = (long)row_count;
  
     if( !mhdf_read_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, first_poly_id_out, status ) )
     {
         H5Dclose( table_id );
         H5Dclose( index_id );
         return;
     }
  
     file_ptr->open_handle_count++;
     handles_out[0] = index_id;
     handles_out[1] = table_id;
     mhdf_setOkay( status );
     API_END_H( 2 );
 }

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_handle	The file
child_list_size	The total length of the data (the sum of the number of children for each set.)
status	Passed back status of API call.

Returns: A handle to the data object in the file.

Definition at line 740 of file sets.c.

 {
     FileHandle* file_ptr;
     hid_t table_id;
     hsize_t dim;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( !child_list_size )
     {
         mhdf_setFail( status, "Invalid argument.\n" );
         return -1;
     }
  
     table_id = mhdf_open_table( file_ptr->hdf_handle, SET_CHILD_PATH, 1, &dim, status );
  
     *child_list_size = (long)dim;
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
data_list_size_out	The length of the table.
status	Passed back status of API call.

Returns: A handle to the table.

Definition at line 657 of file sets.c.

 {
     FileHandle* file_ptr;
     hid_t table_id;
     hsize_t dim;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( !data_list_size_out )
     {
         mhdf_setFail( status, "Invalid argument.\n" );
         return -1;
     }
  
     table_id = mhdf_open_table( file_ptr->hdf_handle, SET_DATA_PATH, 1, &dim, status );
  
     *data_list_size_out = (long)dim;
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
num_sets_out	The number of sets in the table.
first_set_id_out	The global ID that will of the first set in the table. All subsequent sets in the table have sequential global IDs.
status	Passed back status of API call.

Returns: The handle to the set meta-data table.

Definition at line 145 of file sets.c.

 {
     FileHandle* file_ptr = (FileHandle*)file;
     hid_t table_id;
     hsize_t dims[2];
     API_BEGIN;
  
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     table_id = mhdf_open_table2( file_ptr->hdf_handle, SET_META_PATH, 2, dims, first_id_out, status );
     if( table_id < 0 ) return -1;
  
     /* If dims[1] == 3, then old format of table.
      * Deal with it in mhdf_readSetMeta and mhdf_writeSetMeta
      */
     if( dims[1] != 4 && dims[1] != 3 )
     {
         mhdf_setFail( status, "Invalid format for meshset table.\n" );
         H5Dclose( table_id );
         return -1;
     }
  
     *num_sets = dims[0];
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
     API_END_H( 1 );
     return table_id;
 }

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.

 {
     FileHandle* file_ptr = (FileHandle*)file;
     hid_t table_id;
     API_BEGIN;
  
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     table_id = mhdf_open_table_simple( file_ptr->hdf_handle, SET_META_PATH, status );
     if( table_id < 0 ) return -1;
  
     file_ptr->open_handle_count++;
     mhdf_setOkay( status );
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file
parent_list_size	The total length of the data (the sum of the number of parents for each set.)
status	Passed back status of API call.

Returns: A handle to the data object in the file.

Definition at line 785 of file sets.c.

 {
     FileHandle* file_ptr;
     hid_t table_id;
     hsize_t dim;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
  
     if( !parent_list_size )
     {
         mhdf_setFail( status, "Invalid argument.\n" );
         return -1;
     }
  
     table_id = mhdf_open_table( file_ptr->hdf_handle, SET_PARENT_PATH, 1, &dim, status );
  
     *parent_list_size = (long)dim;
     API_END_H( 1 );
     return table_id;
 }

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_handle	The file.
tag_name	The tag.
num_entity_out	The number of entities for which there are tag values.
num_values_out	The 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_out	The 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.
status	Passed back status of API call.

Definition at line 1511 of file tags.c.

 {
     hid_t tag_id, index_id, data_id, offset_id = -1;
     hsize_t num_ent, data_size, num_data;
     int rval;
     unsigned idx;
     API_BEGIN;
  
     tag_id = get_tag( file_handle, tag_name, NULL, status );
     if( tag_id < 0 ) return;
  
     index_id = mhdf_open_table( tag_id, SPARSE_ENTITY_NAME, 1, &num_ent, status );
     if( index_id < 0 )
     {
         H5Gclose( tag_id );
         return;
     }
  
     data_id = mhdf_open_table( tag_id, SPARSE_VALUES_NAME, 1, &data_size, status );
     if( data_id < 0 )
     {
         H5Gclose( tag_id );
         H5Dclose( index_id );
         return;
     }
  
     /* check if tag is variable-lentgth */
     rval = mhdf_find_attribute( tag_id, TAG_VARLEN_ATTRIB, &idx, status );
     if( rval < 0 )
     {
         H5Gclose( tag_id );
         H5Dclose( index_id );
         H5Dclose( data_id );
         return;
     }
  
     /* If variable length... */
     if( rval )
     {
         offset_id = mhdf_open_table( tag_id, TAG_VAR_INDICES, 1, &num_data, status );
         if( offset_id < 0 )
         {
             H5Gclose( tag_id );
             H5Dclose( index_id );
             H5Dclose( data_id );
             return;
         }
     }
     /* Otherwise the number of values is the same as the size of the data table */
     else
     {
         num_data = data_size;
     }
  
     H5Gclose( tag_id );
     if( num_ent != num_data )
     {
         mhdf_setFail( status, "Data length mismatch for sparse tag data -- invalid file." );
         if( offset_id >= 0 ) H5Dclose( offset_id );
         H5Dclose( index_id );
         H5Dclose( data_id );
         return;
     }
     *num_entity_out = (long)num_ent;
     if( num_values_out ) *num_values_out = (long)data_size;
  
     handles_out[0] = index_id;
     handles_out[1] = data_id;
     if( offset_id >= 0 ) handles_out[2] = offset_id;
     mhdf_setOkay( status );
     API_END_H( 2 );
 }

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_handle	Handle returned from `mhdf_createAdjacency` or `mhdf_openAdjacency`.
offset	List 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.
count	Number of integer values to reading.
hdf_integer_type	The 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_out	Pointer to memory at which to write adjacency data.
status	Passed back status of API call.

Definition at line 148 of file adjacency.c.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	Handle returned from `mhdf_createConnectivity` or `mhdf_openConnectivity`.
offset	Table row (element index) at which to start read.
count	Number of rows (number of elements) to read.
hdf_integer_type	The 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_list	Pointer to memory at which to write interleaved connectivity data specified as global node IDs.
status	Passed back status of API call.

Definition at line 163 of file connectivity.c.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, hdf_integer_type, nodes, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, hdf_integer_type, nodes, prop, status );
     API_END;
 }

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

file	The file.
num_records_out	The length of the returned array.
status	Passed back status of API call.

Returns: An array of null-terminates strings.

Definition at line 823 of file file.c.

 {
     FileHandle* file_ptr;
     hid_t data_id, type_id, space_id, group_id;
     hsize_t dim;
     herr_t rval;
     char** array;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
  
         /* check if file contains history data */
 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
     group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
 #else
     group_id     = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
 #endif
     if( group_id < 0 )
     {
         mhdf_setFail( status, "Could not open root group.  Invalid file." );
         return NULL;
     }
  
     rval = mhdf_is_in_group( group_id, HISTORY_NAME, status );
     if( rval < 1 )
     {
         H5Gclose( group_id );
         *num_strings = 0;
         if( 0 == rval ) mhdf_setOkay( status );
         return NULL;
     }
  
 #if defined( H5Dopen_vers ) && H5Dopen_vers > 1
     data_id = H5Dopen2( group_id, HISTORY_NAME, H5P_DEFAULT );
 #else
     data_id      = H5Dopen( group_id, HISTORY_NAME );
 #endif
     H5Gclose( group_id );
     if( data_id < 0 )
     {
         mhdf_setFail( status, "Failed to open \"%s\".", HISTORY_PATH );
         return NULL;
     }
  
     space_id = H5Dget_space( data_id );
     if( space_id < 0 )
     {
         H5Dclose( data_id );
         mhdf_setFail( status, "Internal error calling H5Dget_space." );
         return NULL;
     }
  
     if( 1 != H5Sget_simple_extent_ndims( space_id ) || 1 != H5Sget_simple_extent_dims( space_id, &dim, NULL ) )
     {
         H5Dclose( data_id );
         mhdf_setFail( status, "Invalid dimension for \"%s\".", HISTORY_PATH );
         return NULL;
     }
     H5Sclose( space_id );
  
     if( 0 == dim )
     {
         H5Dclose( data_id );
         *num_strings = 0;
         mhdf_setOkay( status );
         return NULL;
     }
  
     array = (char**)mhdf_malloc( dim * sizeof( char* ), status );
     if( !array )
     {
         H5Dclose( data_id );
         return NULL;
     }
  
     type_id = H5Tcopy( H5T_C_S1 );
     if( type_id < 0 || H5Tset_size( type_id, H5T_VARIABLE ) < 0 )
     {
         H5Dclose( data_id );
         if( type_id >= 0 ) H5Tclose( type_id );
         mhdf_setFail( status, "Could not create variable length string type." );
         free( array );
         return NULL;
     }
  
     rval = H5Dread( data_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, array );
     H5Tclose( type_id );
     H5Dclose( data_id );
     if( rval < 0 )
     {
         free( array );
         mhdf_setFail( status, "H5Dread failed." );
         return NULL;
     }
  
     *num_strings = dim;
     mhdf_setOkay( status );
     API_END;
     return array;
 }

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_handle	Handle returned from `mhdf_createNodeCoords` or `mhdf_openNodeCoords`.
offset	Table row (node index) at which to start reading.
count	Number of rows (number of nodes) to read.
dimension	The coordinate to read (0->x, 1->y, ...)
coords	Buffer in which to write node coordinate data.
status	Passed back status of API call.

Definition at line 219 of file nodes.c.

 {
     API_BEGIN;
     mhdf_read_column( table_id, dimension, offset, count, H5T_NATIVE_DOUBLE, coords, H5P_DEFAULT, status );
     API_END;
 }

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_handle	Handle returned from `mhdf_createNodeCoords` or `mhdf_openNodeCoords`.
offset	Table row (node index) at which to start reading.
count	Number of rows (number of nodes) to read.
coordinates	Buffer in which to write node coordinate data.
status	Passed back status of API call.

Definition at line 177 of file nodes.c.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, H5T_NATIVE_DOUBLE, coords, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, H5T_NATIVE_DOUBLE, coords, prop, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_column( table_id, dimension, offset, count, H5T_NATIVE_DOUBLE, coords, prop, status );
     API_END;
 }

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_handle	The handle returned from `mhdf_createPolyConnectivity` or `mhdf_openPolyConnectivity`.
offset	The 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.
count	The size of the integer list to read.
hdf_integer_type	The 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_list	The memory location at which to write the connectivity data.
status	Passed back status of API call.

Definition at line 397 of file connectivity.c.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, hdf_integer_type, id_list, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, hdf_integer_type, id_list, prop, status );
     API_END;
 }

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_handle	The handle returned from `mhdf_createPolyConnectivity` or `mhdf_openPolyConnectivity`.
offset	The 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.
count	The size of the integer list to read.
hdf_integer_type	The 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_list	The memory location at which to write the indices.
status	Passed back status of API call.

Definition at line 349 of file connectivity.c.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, hdf_integer_type, index_list, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, hdf_integer_type, index_list, prop, status );
     API_END;
 }

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_handle	The handle returned from mdhf_createSetMeta or mhdf_openSetMeta
offset	The offset (set index) at which to begin reading.
count	The number of values (number of sets) to read.
hdf_integer_type	The integer type of the input array 'set_flag_data'.
end_indices_out	Array of indices.
status	Location at which to store status of API call.

Definition at line 592 of file sets.c.

 {
     API_BEGIN;
     mhdf_readSetMetaColumn( table_id, CHILDREN, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_readSetMetaColumn( table_id, CHILDREN, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	The handle returned from mdhf_createSetMeta or mhdf_openSetMeta
offset	The offset (set index) at which to begin reading.
count	The number of values (number of sets) to read.
hdf_integer_type	The integer type of the input array 'set_flag_data'.
end_indices_out	Array of indices.
status	Location at which to store status of API call.

Definition at line 568 of file sets.c.

 {
     API_BEGIN;
     mhdf_readSetMetaColumn( table_id, CONTENT, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_readSetMetaColumn( table_id, CONTENT, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	The handle returned from mhdf_createSetData or mhdf_openSetData .
offset	The position at which to read from the integer vector.
count	The number of values to read from the data vector.
hdf_integer_type	The 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_data	A pointer to memory at which to store the read data.
status	Passed back status of API call.

Definition at line 699 of file sets.c.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	The handle returned from mdhf_createSetMeta or mhdf_openSetMeta
offset	The offset (set index) at which to begin reading.
count	The number of values (number of sets) to read.
hdf_integer_type	The integer type of the input array 'set_flag_data'.
set_flag_data	Array of integers.
status	Location at which to store status of API call.

Definition at line 549 of file sets.c.

 {
     API_BEGIN;
     mhdf_readSetMetaColumn( table_id, FLAGS, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_readSetMetaColumn( table_id, FLAGS, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	The handle returned from mhdf_createSetMeta or mhdf_openSetMeta.
offset	The offset (set index) to begin reading at.
count	The number of rows (sets, integer triples) to read.
hdf_integer_type	The 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
status	Passed back status of API call.
set_desc_data	The memory location at which to write the data.

Definition at line 367 of file sets.c.

 {
     API_BEGIN;
     mhdf_readwriteSetMeta( table_id, 1, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_readwriteSetMeta( table_id, 1, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	The handle returned from mdhf_createSetMeta or mhdf_openSetMeta
offset	The offset (set index) at which to begin reading.
count	The number of values (number of sets) to read.
hdf_integer_type	The integer type of the input array 'set_flag_data'.
end_indices_out	Array of indices.
status	Location at which to store status of API call.

Definition at line 611 of file sets.c.

 {
     API_BEGIN;
     mhdf_readSetMetaColumn( table_id, PARENTS, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_readSetMetaColumn( table_id, PARENTS, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	The value returned from mhdf_createSetChildren or mhdf_openSetChildren.
offset	The offset into the list of global IDs.
count	The number of global IDs to read.
hdf_integer_type	The 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_list	Pointer to memory in which to the read data.
status	Passed back status of API call.

Definition at line 832 of file sets.c.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	The first handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData.
offset	The offset at which to begin reading.
count	The number of global IDs to read.
hdf_integer_type	The 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_list	The memory location at which to store the global IDs.
status	Passed back status of API call.

Definition at line 1660 of file tags.c.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, int_type, id_list, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, int_type, id_list, io_prop, status );
     API_END;
 }

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_handle	handle to the data object to read from.
offset	The offset into the table at which to begin reading
count	The number of values to read.
hdf_integer_type	The type of the values pointed to by end_indices (must be an integer type).
end_indices	Memory in which to store the data read from the table.
status	Output: API result.

Definition at line 1701 of file tags.c.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, int_type, indices, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, int_type, indices, io_prop, status );
     API_END;
 }

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_handle	The second handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData; or the handle returned by mhdf_createDenseTagData or mhdf_openDenseTagData.
offset	The offset at which to begin reading.
count	The number of tag values to read.
hdf_type	The 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.
memory	Memory location at which to store tag values.
status	Passed back status of API call.

Definition at line 1684 of file tags.c.

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

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.

 {
     API_BEGIN;
     mhdf_read_data( table_id, offset, count, tag_type, tag_data, io_prop, status );
     API_END;
 }

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.

 {
     static const char rval[] = "sets";
     return rval;
 }

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_handle	Handle returned from `mhdf_createAdjacency` or `mhdf_openAdjacency`.
offset	List 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.
count	Number of integer values to write.
hdf_integer_type	The 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_data	Adjacency data to write.
status	Passed back status of API call.

Definition at line 128 of file adjacency.c.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	Handle returned from `mhdf_createConnectivity` or `mhdf_openConnectivity`.
offset	Table row (element index) at which to start writing.
count	Number of rows (number of elements) to write.
hdf_integer_type	The 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_list	Interleaved connectivity data specified as global node IDs.
status	Passed back status of API call.

Definition at line 139 of file connectivity.c.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, hdf_integer_type, nodes, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, hdf_integer_type, nodes, prop, status );
     API_END;
 }

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

file	The file.
strings	An array of null-terminated strings.
num_strings	The length of `strings`
status	Passed back status of API call.

Definition at line 768 of file file.c.

 {
     FileHandle* file_ptr;
     hid_t data_id, type_id, space_id;
     hsize_t dim = (hsize_t)num_strings;
     herr_t rval;
     API_BEGIN;
  
     file_ptr = (FileHandle*)( file_handle );
     if( !mhdf_check_valid_file( file_ptr, status ) ) return;
  
     type_id = H5Tcopy( H5T_C_S1 );
     if( type_id < 0 || H5Tset_size( type_id, H5T_VARIABLE ) < 0 )
     {
         if( type_id >= 0 ) H5Tclose( type_id );
         mhdf_setFail( status, "Could not create variable length string type." );
         return;
     }
  
     space_id = H5Screate_simple( 1, &dim, NULL );
     if( space_id < 0 )
     {
         H5Tclose( type_id );
         mhdf_setFail( status, "H5Screate_simple failed." );
         return;
     }
  
 #if defined( H5Dcreate_vers ) && H5Dcreate_vers > 1
     data_id =
         H5Dcreate2( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
 #else
     data_id      = H5Dcreate( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT );
 #endif
     H5Sclose( space_id );
     if( data_id < 0 )
     {
         H5Tclose( type_id );
         mhdf_setFail( status, "Failed to create \"%s\".", HISTORY_PATH );
         return;
     }
  
     rval = H5Dwrite( data_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, strings );
     H5Dclose( data_id );
     H5Tclose( type_id );
     if( rval < 0 )
     {
         H5Gunlink( file_ptr->hdf_handle, HISTORY_PATH );
         mhdf_setFail( status, "Failed to write history data." );
         return;
     }
  
     mhdf_setOkay( status );
     API_END;
 }

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_handle	Handle returned from `mhdf_createNodeCoords` or `mhdf_openNodeCoords`.
offset	Table row (node index) at which to start writing.
count	Number of rows (number of nodes) to write.
dimension	The coordinate to write (0->x, 1->y, ...)
coords	Coordinate list.
status	Passed back status of API call.

Definition at line 195 of file nodes.c.

 {
     API_BEGIN;
     mhdf_write_column( table_id, dimension, offset, count, H5T_NATIVE_DOUBLE, coords, H5P_DEFAULT, status );
     API_END;
 }

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_handle	Handle returned from `mhdf_createNodeCoords` or `mhdf_openNodeCoords`.
offset	Table row (node index) at which to start writing.
count	Number of rows (number of nodes) to write.
coords	Interleaved node coordinate data.
status	Passed back status of API call.

Definition at line 159 of file nodes.c.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, H5T_NATIVE_DOUBLE, coords, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, H5T_NATIVE_DOUBLE, coords, prop, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_column( table_id, dimension, offset, count, H5T_NATIVE_DOUBLE, coords, prop, status );
     API_END;
 }

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_handle	The handle returned from `mhdf_createPolyConnectivity` or `mhdf_openPolyConnectivity`.
offset	The 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.
count	The size of the integer list to write.
hdf_integer_type	The 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_list	The count/global ID list specifying the connectivity of the polys.
status	Passed back status of API call.

Definition at line 373 of file connectivity.c.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, hdf_integer_type, id_list, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, hdf_integer_type, id_list, prop, status );
     API_END;
 }

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_handle	The handle returned from `mhdf_createPolyConnectivity` or `mhdf_openPolyConnectivity`.
offset	The 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.
count	The size of the integer list to write.
hdf_integer_type	The 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_list	The index list for the polys.
status	Passed back status of API call.

Definition at line 325 of file connectivity.c.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, hdf_integer_type, index_list, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, hdf_integer_type, index_list, prop, status );
     API_END;
 }

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_handle	The handle returned from mhdf_createSetData or mhdf_openSetData .
offset	The position at which to write into the integer vector.
count	The number of values to write into the data vector.
hdf_integer_type	The 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_data	The data to write.
status	Passed back status of API call.

Definition at line 680 of file sets.c.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	The handle returned from mhdf_createSetMeta or mhdf_openSetMeta.
offset	The offset (set index) to begin writing at.
count	The number of rows (sets, integer triples) to write.
hdf_integer_type	The 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_data	The data to write.
status	Passed back status of API call.

Definition at line 386 of file sets.c.

 {
     API_BEGIN;
     mhdf_readwriteSetMeta( table_id, 0, offset, count, type, (void*)data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_readwriteSetMeta( table_id, 0, offset, count, type, (void*)data, prop, status );
     API_END;
 }

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_handle	The value returned from mhdf_createSetChildren or mhdf_openSetChildren.
offset	The offset into the list of global IDs.
count	The number of global IDs to write.
hdf_integer_type	The 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_list	The data to write.
status	Passed back status of API call.

Definition at line 808 of file sets.c.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, type, data, prop, status );
     API_END;
 }

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_handle	The first handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData.
offset	The offset at which to begin writing.
count	The number of global IDs to write.
hdf_integer_type	The 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_list	The list of global IDs to write.
status	Passed back status of API call.

Definition at line 1589 of file tags.c.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, int_type, id_list, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, int_type, id_list, io_prop, status );
     API_END;
 }

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_handle	handle to the data object to write to.
offset	The offset into the table at which to begin writting
count	The number of values to write.
hdf_integer_type	The type of the values pointed to by end_indices (must be an integer type).
end_indices	The values to store in the table.
status	Output: API result.

Definition at line 1636 of file tags.c.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, int_type, indices, H5P_DEFAULT, status );
     API_END;
 }

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, int_type, indices, io_prop, status );
     API_END;
 }

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_handle	The second handle passed back from either mhdf_createSparseTagData or mhdf_openSparseTagData; or the handle returned by mhdf_createDenseTagData or mhdf_openDenseTagData.
offset	The offset at which to begin writing.
count	The number of tag values to write.
hdf_tag_data_type	The 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_data	The list of tag values to write.
status	Passed back status of API call.

Definition at line 1613 of file tags.c.

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

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.

 {
     API_BEGIN;
     mhdf_write_data( table_id, offset, count, tag_type, tag_data, io_prop, status );
     API_END;
 }

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().

Macros

Functions

Macro Definition Documentation

◆ mhdf_BIT_TYPE

◆ mhdf_DENSE_TYPE

◆ MHDF_INDEX_TYPE

◆ mhdf_MESH_TYPE

◆ mhdf_SET_ORDER_BIT

◆ mhdf_SET_OWNER_BIT

◆ mhdf_SET_RANGE_BIT

◆ mhdf_SET_UNIQUE_BIT

◆ mhdf_SPARSE_TYPE

Function Documentation

◆ mhdf_addElement()

◆ mhdf_checkOpenHandles()

◆ mhdf_closeData()

◆ mhdf_createAdjacency()

◆ mhdf_createConnectivity()

◆ mhdf_createDenseTagData()

◆ mhdf_createNodeCoords()

◆ mhdf_createPolyConnectivity()

◆ mhdf_createSetChildren()

◆ mhdf_createSetData()

◆ mhdf_createSetMeta()

◆ mhdf_createSetParents()

◆ mhdf_createSparseTagData()

◆ mhdf_createTag()

◆ mhdf_createVarLenTag()

◆ mhdf_createVarLenTagData()

◆ mhdf_getElemHandles()

◆ mhdf_getElemName()

◆ mhdf_getElemTypeName()

◆ mhdf_getNativeType()

◆ mhdf_getNextStartId()

◆ mhdf_getNumberTags()

◆ mhdf_getTagDataType()

◆ mhdf_getTagInfo()

◆ mhdf_getTagNames()

◆ mhdf_getTagValues()

◆ mhdf_haveAdjacency()

◆ mhdf_haveDenseTag()

◆ mhdf_haveNodes()

◆ mhdf_haveSets()

◆ mhdf_isPolyElement()

◆ mhdf_node_type_handle()

◆ mhdf_openAdjacency()

◆ mhdf_openConnectivity()

◆ mhdf_openConnectivitySimple()

◆ mhdf_openDenseTagData()

◆ mhdf_openNodeCoords()

◆ mhdf_openNodeCoordsSimple()

◆ mhdf_openPolyConnectivity()

◆ mhdf_openSetChildren()

◆ mhdf_openSetData()

◆ mhdf_openSetMeta()

◆ mhdf_openSetMetaSimple()

◆ mhdf_openSetParents()

◆ mhdf_openSparseTagData()

◆ mhdf_readAdjacency()

◆ mhdf_readAdjacencyWithOpt()

◆ mhdf_readConnectivity()

◆ mhdf_readConnectivityWithOpt()

◆ mhdf_readHistory()

◆ mhdf_readNodeCoord()

◆ mhdf_readNodeCoords()

◆ mhdf_readNodeCoordsWithOpt()

◆ mhdf_readNodeCoordWithOpt()

◆ mhdf_readPolyConnIDs()

◆ mhdf_readPolyConnIDsWithOpt()

◆ mhdf_readPolyConnIndices()

◆ mhdf_readPolyConnIndicesWithOpt()

◆ mhdf_readSetChildEndIndices()

◆ mhdf_readSetChildEndIndicesWithOpt()

◆ mhdf_readSetContentEndIndices()

◆ mhdf_readSetContentEndIndicesWithOpt()

◆ mhdf_readSetData()

◆ mhdf_readSetDataWithOpt()

◆ mhdf_readSetFlags()

◆ mhdf_readSetFlagsWithOpt()

◆ mhdf_readSetMeta()