connectivity.c

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */

#include <H5Tpublic.h>
#include <H5Dpublic.h>
#include <H5Gpublic.h>
#include <H5Ppublic.h>
#include "mhdf.h"
#include "util.h"
#include "file-handle.h"
#include "status.h"
#include "names-and-paths.h"

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 )
{
    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;
}

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 )
{
    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;
}

hid_t mhdf_openConnectivitySimple( mhdf_FileHandle file_handle, const char* elem_handle, mhdf_Status* status )
{
    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;
}

void mhdf_writeConnectivity( hid_t table_id,
                             long offset,
                             long count,
                             hid_t hdf_integer_type,
                             const void* nodes,
                             mhdf_Status* status )
{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, hdf_integer_type, nodes, H5P_DEFAULT, status );
    API_END;
}
void mhdf_writeConnectivityWithOpt( hid_t table_id,
                                    long offset,
                                    long count,
                                    hid_t hdf_integer_type,
                                    const void* nodes,
                                    hid_t prop,
                                    mhdf_Status* status )
{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, hdf_integer_type, nodes, prop, status );
    API_END;
}

void mhdf_readConnectivity( hid_t table_id,
                            long offset,
                            long count,
                            hid_t hdf_integer_type,
                            void* nodes,
                            mhdf_Status* status )
{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, hdf_integer_type, nodes, H5P_DEFAULT, status );
    API_END;
}
void mhdf_readConnectivityWithOpt( hid_t table_id,
                                   long offset,
                                   long count,
                                   hid_t hdf_integer_type,
                                   void* nodes,
                                   hid_t prop,
                                   mhdf_Status* status )
{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, hdf_integer_type, nodes, prop, status );
    API_END;
}

void mhdf_createPolyConnectivity( mhdf_FileHandle file_handle,
                                  const char* elem_type,
                                  long num_poly,
                                  long data_list_length,
                                  long* first_id_out,
                                  hid_t handles_out[2],
                                  mhdf_Status* status )
{
    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 );
}

void mhdf_openPolyConnectivity( mhdf_FileHandle file_handle,
                                const char* element_handle,
                                long* num_poly_out,
                                long* data_list_length_out,
                                long* first_poly_id_out,
                                hid_t handles_out[2],
                                mhdf_Status* status )
{
    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 );
}

void mhdf_writePolyConnIndices( hid_t table_id,
                                long offset,
                                long count,
                                hid_t hdf_integer_type,
                                const void* index_list,
                                mhdf_Status* status )
{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, hdf_integer_type, index_list, H5P_DEFAULT, status );
    API_END;
}
void mhdf_writePolyConnIndicesWithOpt( hid_t table_id,
                                       long offset,
                                       long count,
                                       hid_t hdf_integer_type,
                                       const void* index_list,
                                       hid_t prop,
                                       mhdf_Status* status )
{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, hdf_integer_type, index_list, prop, status );
    API_END;
}

void mhdf_readPolyConnIndices( hid_t table_id,
                               long offset,
                               long count,
                               hid_t hdf_integer_type,
                               void* index_list,
                               mhdf_Status* status )
{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, hdf_integer_type, index_list, H5P_DEFAULT, status );
    API_END;
}
void mhdf_readPolyConnIndicesWithOpt( hid_t table_id,
                                      long offset,
                                      long count,
                                      hid_t hdf_integer_type,
                                      void* index_list,
                                      hid_t prop,
                                      mhdf_Status* status )
{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, hdf_integer_type, index_list, prop, status );
    API_END;
}

void mhdf_writePolyConnIDs( hid_t table_id,
                            long offset,
                            long count,
                            hid_t hdf_integer_type,
                            const void* id_list,
                            mhdf_Status* status )
{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, hdf_integer_type, id_list, H5P_DEFAULT, status );
    API_END;
}
void mhdf_writePolyConnIDsWithOpt( hid_t table_id,
                                   long offset,
                                   long count,
                                   hid_t hdf_integer_type,
                                   const void* id_list,
                                   hid_t prop,
                                   mhdf_Status* status )
{
    API_BEGIN;
    mhdf_write_data( table_id, offset, count, hdf_integer_type, id_list, prop, status );
    API_END;
}

void mhdf_readPolyConnIDs( hid_t table_id,
                           long offset,
                           long count,
                           hid_t hdf_integer_type,
                           void* id_list,
                           mhdf_Status* status )
{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, hdf_integer_type, id_list, H5P_DEFAULT, status );
    API_END;
}
void mhdf_readPolyConnIDsWithOpt( hid_t table_id,
                                  long offset,
                                  long count,
                                  hid_t hdf_integer_type,
                                  void* id_list,
                                  hid_t prop,
                                  mhdf_Status* status )
{
    API_BEGIN;
    mhdf_read_data( table_id, offset, count, hdf_integer_type, id_list, prop, status );
    API_END;
}