F5Bchart.h File Reference

#include "hdf5inc.h"
#include "F5defs.h"
#include "F5types.h"
#include "F5WinDLLApi.h"

Go to the source code of this file.

Data Structures
struct	_F5_ChartPrecisionTypes
struct	ChartDomain_IDs

Macros
#define	F5_FORTRAN_ORDER   ((int*)(0))
#define	F5_C_ORDER   ((int*)(-1))

Typedefs
typedef struct _F5_ChartPrecisionTypes	F5_ChartPrecisionTypes
typedef ChartDomain_IDs *(*	new_global_chart_f) ()

Enumerations
enum	{ F5ChartPrecisionMaxNumberOfFileTypes = 32 }

Functions
F5_API void	F5B_init_tangential_types (F5_ChartPrecisionTypes *H5Types, const char *coordnames[], int dimension, hid_t coord_type)
F5_API void	F5Bt_add_tangential_types (F5_ChartPrecisionTypes *H5Types, const char *coordnames[], int dimension, hid_t coord_type)
F5_API int	F5B_inject_precision_type (F5_ChartPrecisionTypes *IDs, hid_t type_id)
F5_API void	F5B_delete_tangential_types (F5_ChartPrecisionTypes *IDs)
F5_API void	F5Bchart_read_tangential_types (F5_ChartPrecisionTypes *H5Types, hid_t location)
F5_API void	F5Binsert_tensor_type (ChartDomain_IDs *CD, F5Ttensor_t *)
F5_API F5Ttensor_t *	F5Bget_tensor_type_byname (ChartDomain_IDs *CD, const char *name)
F5_API F5_ChartPrecisionTypes *	F5Bget_precision_by_size (ChartDomain_IDs *CD, int TypeSize)
F5_API F5_ChartPrecisionTypes *	F5Bget_precision_by_type (ChartDomain_IDs *CD, hid_t type_id)
F5_API ChartDomain_IDs *	F5B_new_global_domain (const char *coordnames[], int dimension, const char *name, const int perm_vector[], int cell_dimensionality, hid_t SinglePrecisionType, hid_t DoublePrecisionType)
F5_API ChartDomain_IDs *	F5B_new_global_float_chart (const char *coordnames[], int dimension, const char *name, const int perm_vector[FIBER_MAX_RANK])
F5_API ChartDomain_IDs *	F5B_new_global_int_chart (const char *coordnames[], int dimension, const char *name, const int perm_vector[FIBER_MAX_RANK])
F5_API ChartDomain_IDs *	F5B_new_global_int_domain (const char *coordnames[], int dimension, const char *name, const int perm_vector[FIBER_MAX_RANK], int cell_dimensionality)
F5_API ChartDomain_IDs *	F5B_new_global_fractional_domain (const char *coordnames[], int dimension, const char *name, const int perm_vector[], int cell_dimensionality)
F5_API ChartDomain_IDs *	F5Bcopy_chart_domain (const ChartDomain_IDs *IDs)
F5_API int	F5Bget_chart_dims (const ChartDomain_IDs *IDs)
F5_API hsize_t *	F5B_permute_dimensions (hsize_t *target_dims, int rank, const hsize_t *source_dims, int perm_vector[FIBER_MAX_RANK], int perm_vector_size)
F5_API const int *	F5B_fortran_permute_vector ()
F5_API void	F5B_delete_global_chart (ChartDomain_IDs *ID)
F5_API void	F5Bincrement_domain_refs (ChartDomain_IDs *ChartDomain)
F5_API ChartDomain_IDs *	F5B_save_global_chart (const ChartDomain_IDs *IDs, hid_t Domain_hid)
F5_API ChartDomain_IDs *	F5B_read_global_chart (hid_t ChartsID, const char *name)
F5_API ChartDomain_IDs *	F5B_read_chart_domain (hid_t ChartDomainLocationID, const char *DefaultChartName)
F5_API ChartDomain_IDs *	F5B_new_global_cartesian_chart3D ()

Macro Definition Documentation

F5_C_ORDER

#define F5_C_ORDER   ((int*)(-1))

Definition at line 268 of file F5Bchart.h.

Referenced by F5B_new_global_domain(), and F5B_permute_dimensions().

F5_FORTRAN_ORDER

#define F5_FORTRAN_ORDER   ((int*)(0))

Definition at line 267 of file F5Bchart.h.

Referenced by F5B_new_global_axial_chart2D(), F5B_new_global_cartesian_chart1D(), F5B_new_global_cartesian_chart2D(), F5B_new_global_cartesian_chart3D(), F5B_new_global_cartesian_chart4D(), F5B_new_global_color_chart_rgba_int(), F5B_new_global_color_chart_rgba_real(), F5B_new_global_cylindrical_chart3D(), F5B_new_global_domain(), F5B_new_global_edge_cells(), F5B_new_global_fragname(), F5B_new_global_hexahedral_cells(), F5B_new_global_polar_chart2D(), F5B_new_global_polar_chart3D(), F5B_new_global_polar_chart4D(), F5B_new_global_quad_cells(), F5B_new_global_spherical_chart1D(), F5B_new_global_spherical_chart2D(), F5B_new_global_t_polar2_chart3D(), F5B_new_global_tetrahedral_cells(), F5B_new_global_texture_chart2D(), F5B_new_global_texture_chart3D(), F5B_new_global_time_chart1D(), F5B_new_global_triangle_cells(), F5B_new_global_triangle_cells_ijk(), F5B_new_integer_regular_domain3D(), F5B_new_rational_regular_domain3D(), and old_F5B_new_global_tetrahedral_cells().

Typedef Documentation

F5_ChartPrecisionTypes

typedef struct _F5_ChartPrecisionTypes F5_ChartPrecisionTypes

Definition at line 71 of file F5Bchart.h.

new_global_chart_f

typedef ChartDomain_IDs *(* new_global_chart_f) ()

Prototype of a function creating a new class of coordinate systems. (Chart domain constructor).

Definition at line 183 of file F5Bchart.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
F5ChartPrecisionMaxNumberOfFileTypes	number of additional file types in ChartPrecisions

Definition at line 19 of file F5Bchart.h.

{
        /** number of additional file types in ChartPrecisions */
        F5ChartPrecisionMaxNumberOfFileTypes = 32
};

Function Documentation

F5B_delete_global_chart()

F5_API void F5B_delete_global_chart

(

ChartDomain_IDs *

ID

)

Free the memory resources that are associated with a certain coordinate system.

Definition at line 632 of file F5Bchart.c.

{
        if (ID && --ID->refs == 0)
        {
                free( (void*)ID->domain_name);
                F5B_delete_tangential_types( &ID->OneBytePrecision );
                F5B_delete_tangential_types( &ID->HalfPrecision );
                F5B_delete_tangential_types( &ID->SinglePrecision );
                F5B_delete_tangential_types( &ID->DoublePrecision );
                F5B_delete_tangential_types( &ID->ExtendedPrecision );
                free(ID);
        }
}

References ChartDomain_IDs::domain_name, ChartDomain_IDs::DoublePrecision, ChartDomain_IDs::ExtendedPrecision, F5B_delete_tangential_types(), free(), ChartDomain_IDs::HalfPrecision, ChartDomain_IDs::OneBytePrecision, ChartDomain_IDs::refs, and ChartDomain_IDs::SinglePrecision.

Referenced by F5Bcoordinate_cleanup(), and F5close().

F5B_delete_tangential_types()

F5_API void F5B_delete_tangential_types

(

F5_ChartPrecisionTypes *

IDs

)

Destructor for F5_ChartPrecisionTypes.

Definition at line 610 of file F5Bchart.c.

{
int     i;
        assert(ID);
 
        F5Tclose(ID->Point_hid_t);
        F5Tclose(ID->Vector_hid_t);
        F5Tclose(ID->Covector_hid_t);
        F5Tclose(ID->Bivector_hid_t);
        F5Tclose(ID->Bicovector_hid_t);
        F5Tclose(ID->Pseudoscalar_hid_t);
        F5Tclose(ID->Pseudocoscalar_hid_t);
 
        F5Tclose(ID->Metric_hid_t);
        F5Tclose(ID->Cometric_hid_t);
 
        for(i=0; i<F5ChartPrecisionMaxNumberOfFileTypes; i++)
        {
                F5Tclose( ID->AdditionalFileTypes[ i ] );
        }
}

References _F5_ChartPrecisionTypes::AdditionalFileTypes, _F5_ChartPrecisionTypes::Bicovector_hid_t, _F5_ChartPrecisionTypes::Bivector_hid_t, _F5_ChartPrecisionTypes::Cometric_hid_t, _F5_ChartPrecisionTypes::Covector_hid_t, F5ChartPrecisionMaxNumberOfFileTypes, F5Tclose(), _F5_ChartPrecisionTypes::Metric_hid_t, _F5_ChartPrecisionTypes::Point_hid_t, _F5_ChartPrecisionTypes::Pseudocoscalar_hid_t, _F5_ChartPrecisionTypes::Pseudoscalar_hid_t, and _F5_ChartPrecisionTypes::Vector_hid_t.

Referenced by F5B_delete_global_chart().

F5B_fortran_permute_vector()

F5_API const int * F5B_fortran_permute_vector

(

)

Return a (static) permutation vector for fortran memory layout. It always has FIBER_MAX_RANK entries, i.e. is of the form { FIBER_MAX_RANK-1, FIBER_MAX_RANK-2, ..., 2,1,0 }

Definition at line 36 of file F5Bchart.c.

{
static  int vals[FIBER_MAX_RANK];
static  int init = 0;
        if (!init)
        {
        int     i;
                for(i=0; i< FIBER_MAX_RANK; i++)
                {
                        vals[i] = FIBER_MAX_RANK - 1 - i;
                }
 
                init = 1;
        }
 
        return vals;
}

References FIBER_MAX_RANK.

F5B_init_tangential_types()

F5_API void F5B_init_tangential_types	(	F5_ChartPrecisionTypes *	H5Types,
		const char *	coordnames[],
		int	dimension,
		hid_t	coord_type )

Initializes the Poind_hit_t with some newly constructed transient HDF5 type while setting all other entries to 0.

Definition at line 290 of file F5Bchart.c.

{
size_t  Tsize = H5Tget_size(coord_type);
int     i;
 
        IDs->Point_hid_t = H5Tcreate(H5T_COMPOUND, dimension*Tsize );
        // F5printf(40, "F5B_init_tangential_types, IDs->Point_hid_t = %lli\n", IDs->Point_hid_t);
        for(i=0; i<dimension; i++)
        {
                H5Tinsert(IDs->Point_hid_t, coordnames[i], i*Tsize, coord_type);
        }
        // F5printf(40, "F5B_init_tangential_types, IDs->Point_hid_t = %lli         inserted hid_t %lli\n", IDs->Point_hid_t, coord_type);
        IDs->Vector_hid_t       = 0;
        IDs->Covector_hid_t     = 0;
        IDs->Bivector_hid_t     = 0;
        IDs->Bicovector_hid_t   = 0;
 
        IDs->Pseudoscalar_hid_t   = 0;
        IDs->Pseudocoscalar_hid_t = 0;
 
        IDs->Metric_hid_t       = 0;
        IDs->Cometric_hid_t     = 0;
 
        for(i=0; i<F5ChartPrecisionMaxNumberOfFileTypes; i++)
                IDs->AdditionalFileTypes[ i ] = 0;
}

References _F5_ChartPrecisionTypes::AdditionalFileTypes, _F5_ChartPrecisionTypes::Bicovector_hid_t, _F5_ChartPrecisionTypes::Bivector_hid_t, _F5_ChartPrecisionTypes::Cometric_hid_t, _F5_ChartPrecisionTypes::Covector_hid_t, F5ChartPrecisionMaxNumberOfFileTypes, _F5_ChartPrecisionTypes::Metric_hid_t, _F5_ChartPrecisionTypes::Point_hid_t, _F5_ChartPrecisionTypes::Pseudocoscalar_hid_t, _F5_ChartPrecisionTypes::Pseudoscalar_hid_t, and _F5_ChartPrecisionTypes::Vector_hid_t.

Referenced by F5B_new_global_domain().

F5B_inject_precision_type()

F5_API int F5B_inject_precision_type	(	F5_ChartPrecisionTypes *	IDs,
		hid_t	type_id )

Add a type ID to the additional file types, ready to be deleted by F5B_delete_tangential_types(F5_ChartPrecisionTypes*IDs);

Definition at line 477 of file F5Bchart.c.

{
int     i;
 
        for(i=0; i<F5ChartPrecisionMaxNumberOfFileTypes; i++)
        {
                if (!IDs->AdditionalFileTypes[ i ])
                {
                        IDs->AdditionalFileTypes[ i ] = type_id;
                        return 1;
                }
        }
        return 0;
}

References _F5_ChartPrecisionTypes::AdditionalFileTypes, and F5ChartPrecisionMaxNumberOfFileTypes.

Referenced by F5file_type().

F5B_new_global_cartesian_chart3D()

F5_API ChartDomain_IDs * F5B_new_global_cartesian_chart3D

(

)

Definition at line 84 of file F5coordinates.c.

{
const char*coordnames[] = {"x", "y", "z" };
        return F5B_new_global_float_chart(coordnames, 3, FIBER_HDF5_CARTESIAN_CHART_DOMAIN, F5_FORTRAN_ORDER);
}

References F5_FORTRAN_ORDER, F5B_new_global_float_chart(), and FIBER_HDF5_CARTESIAN_CHART_DOMAIN.

Referenced by F5Rcreate_coordinate_topology().

F5B_new_global_domain()

F5_API ChartDomain_IDs * F5B_new_global_domain	(	const char *	coordnames[],
		int	dimension,
		const char *	name,
		const int	perm_vector[],
		int	cell_dimensionality,
		hid_t	SinglePrecisionType,
		hid_t	DoublePrecisionType )

Construct a new domain type. A domain type specifies how points from one topology are mapped onto another one. It is a subset of a chart, in that it defines the basic mapping from points onto another, but no tangential types like vectors. @TODO Add complementary cleanup function.

Creates a new chart domain object that holds just a "point" type, but no tangential types.

Definition at line 212 of file F5Bchart.c.

{
ChartDomain_IDs *IDs = (ChartDomain_IDs*)malloc(sizeof(ChartDomain_IDs));
int     i;
        memset (IDs, 0, sizeof (ChartDomain_IDs));
 
        IDs->domain_name = strdup(name);
 
        IDs->refs = 1;
        IDs->cell_dimensionality = cell_dimensionality;
 
        F5printf(40, "F5B_new_global_domain(,dims=%d,,name=%s,perm_vector=%p,cell_dims=%d)\n",
                 dimension, name, perm_vector, cell_dimensionality);
 
        if (perm_vector == F5_FORTRAN_ORDER)
        {
                for(i = 0; i<cell_dimensionality; i++)
                {
                        IDs->perm_vector[i] = cell_dimensionality - 1 - i;
                }
        }
        else if (perm_vector == F5_C_ORDER)
        {
                for(i = 0; i<cell_dimensionality; i++)
                {
                        IDs->perm_vector[i] = i;
                }
        }
        else
        {
                for(i = 0; i<cell_dimensionality; i++)
                {
                        IDs->perm_vector[i] = perm_vector[i];
                }
        }
 
        /*
          Set unused dimensions to -1
         */
        if (IDs->perm_vector)
        for(i = cell_dimensionality; i<FIBER_MAX_RANK; i++)
        {
                IDs->perm_vector[i] = -1;
        }
 
        F5B_init_tangential_types(&IDs->SinglePrecision,
                                  coordnames,
                                  dimension,
                                  SinglePrecisionType);
 
        F5B_init_tangential_types(&IDs->DoublePrecision,
                                  coordnames,
                                  dimension,
                                  DoublePrecisionType);
 
        IDs->TensorTypes = NULL;
        /*
        IDs->Point_hid_t = H5Tcreate(H5T_COMPOUND, dimension*Tsize );
        for(i=0; i<dimension; i++)
        {
                H5Tinsert(IDs->Point_hid_t, coordnames[i], i*Tsize, coord_type);
        }
 
        IDs->Vector_hid_t       = -1;
        IDs->Covector_hid_t     = -1;
        IDs->Metric_hid_t       = -1;
        IDs->Bilinearform_hid_t = -1;
        IDs->TensorTypes = NULL;
        */
        return IDs;
}

References ChartDomain_IDs::cell_dimensionality, ChartDomain_IDs::domain_name, ChartDomain_IDs::DoublePrecision, F5_C_ORDER, F5_FORTRAN_ORDER, F5B_init_tangential_types(), F5printf, FIBER_MAX_RANK, name, ChartDomain_IDs::perm_vector, ChartDomain_IDs::refs, ChartDomain_IDs::SinglePrecision, and ChartDomain_IDs::TensorTypes.

Referenced by F5B_new_global_float_chart(), F5B_new_global_fractional_domain(), F5B_new_global_fragment_neighbour_domain(), F5B_new_global_int_chart(), F5B_new_global_int_domain(), and F5Bcopy_chart_domain().

F5B_new_global_float_chart()

F5_API ChartDomain_IDs * F5B_new_global_float_chart	(	const char *	coordnames[],
		int	dimension,
		const char *	name,
		const int	perm_vector[FIBER_MAX_RANK] )

Construct a new coordinate type.

Parameters

coordnames	Array of names for each coordinate.
dimension	Dimensionality of this coordinate system.
name	Some naming for all instances of this coordinate systems.

Todo

Reorder argument list. @TODO Add complementary cleanup function.

Creates a chart with floating point types.

Only the creation of homogeneous coordinates is supported through this interface.

Definition at line 496 of file F5Bchart.c.

{
ChartDomain_IDs*IDs = F5B_new_global_domain(coordnames,
                                            dimension,
                                            name,
                                            perm_vector,
                                            dimension,
                                            H5T_NATIVE_FLOAT, H5T_NATIVE_DOUBLE);
 
        F5Bchart_add_tangential_types(&IDs->SinglePrecision, coordnames, dimension, H5T_NATIVE_FLOAT);
        F5Bchart_add_tangential_types(&IDs->DoublePrecision, coordnames, dimension, H5T_NATIVE_DOUBLE);
 
        return IDs;
}

References ChartDomain_IDs::DoublePrecision, F5B_new_global_domain(), F5Bchart_add_tangential_types(), FIBER_MAX_RANK, name, and ChartDomain_IDs::SinglePrecision.

Referenced by F5B_new_global_axial_chart2D(), F5B_new_global_cartesian_chart1D(), F5B_new_global_cartesian_chart2D(), F5B_new_global_cartesian_chart3D(), F5B_new_global_cartesian_chart4D(), F5B_new_global_color_chart_rgba_real(), F5B_new_global_cylindrical_chart3D(), F5B_new_global_polar_chart2D(), F5B_new_global_polar_chart3D(), F5B_new_global_polar_chart4D(), F5B_new_global_spherical_chart1D(), F5B_new_global_spherical_chart2D(), F5B_new_global_t_polar2_chart3D(), F5B_new_global_texture_chart2D(), F5B_new_global_texture_chart3D(), and F5B_new_global_time_chart1D().

F5B_new_global_fractional_domain()

F5_API ChartDomain_IDs * F5B_new_global_fractional_domain	(	const char *	coordnames[],
		int	dimension,
		const char *	name,
		const int	perm_vector[],
		int	cell_dimensionality )

Definition at line 571 of file F5Bchart.c.

{
ChartDomain_IDs*IDs = F5B_new_global_domain(coordnames,
                                            dimension,
                                            name,
                                            perm_vector,
                                            cell_dimensionality,
                                            F5T_INT_FRACTION32,
                                            F5T_INT_FRACTION64);
        return IDs;
}

References F5B_new_global_domain(), F5T_INT_FRACTION32, F5T_INT_FRACTION64, and name.

Referenced by F5B_new_rational_regular_domain3D().

F5B_new_global_int_chart()

F5_API ChartDomain_IDs * F5B_new_global_int_chart	(	const char *	coordnames[],
		int	dimension,
		const char *	name,
		const int	perm_vector[FIBER_MAX_RANK] )

Definition at line 514 of file F5Bchart.c.

{
 
ChartDomain_IDs*IDs = F5B_new_global_domain(coordnames, dimension, name, perm_vector, dimension,
                                     H5T_NATIVE_INT32, H5T_NATIVE_INT64);
 
        F5Bchart_add_tangential_types(&IDs->SinglePrecision, coordnames, dimension, H5T_NATIVE_INT8);
        F5Bchart_add_tangential_types(&IDs->DoublePrecision, coordnames, dimension, H5T_NATIVE_INT16);
 
        return IDs;
}

References ChartDomain_IDs::DoublePrecision, F5B_new_global_domain(), F5Bchart_add_tangential_types(), FIBER_MAX_RANK, name, and ChartDomain_IDs::SinglePrecision.

Referenced by F5B_new_global_color_chart_rgba_int().

F5B_new_global_int_domain()

F5_API ChartDomain_IDs * F5B_new_global_int_domain	(	const char *	coordnames[],
		int	dimension,
		const char *	name,
		const int	perm_vector[FIBER_MAX_RANK],
		int	cell_dimensionality )

Create a domain with positions in n-dimensional integer coordinates, where 32bit and 64bit are available ( H5T_NATIVE_B32 and H5T_NATIVE_B64 in HDF5.)

Definition at line 529 of file F5Bchart.c.

{
ChartDomain_IDs*IDs = F5B_new_global_domain(coordnames,
                                            dimension,
                                            name,
                                            perm_vector,
                                            cell_dimensionality,
                                            H5T_NATIVE_INT32,
                                            H5T_NATIVE_INT64);
 
        F5Bchart_add_tangential_types(&IDs->OneBytePrecision,coordnames, dimension, H5T_NATIVE_INT8 );
        F5Bchart_add_tangential_types(&IDs->HalfPrecision,   coordnames, dimension, H5T_NATIVE_INT16);
        F5Bchart_add_tangential_types(&IDs->SinglePrecision, coordnames, dimension, H5T_NATIVE_INT32);
        F5Bchart_add_tangential_types(&IDs->DoublePrecision, coordnames, dimension, H5T_NATIVE_INT64);
 
        return IDs;
}

References ChartDomain_IDs::DoublePrecision, F5B_new_global_domain(), F5Bchart_add_tangential_types(), FIBER_MAX_RANK, ChartDomain_IDs::HalfPrecision, name, ChartDomain_IDs::OneBytePrecision, and ChartDomain_IDs::SinglePrecision.

Referenced by F5B_new_global_edge_cells(), F5B_new_global_hexahedral_cells(), F5B_new_global_quad_cells(), F5B_new_global_tetrahedral_cells(), F5B_new_global_triangle_cells(), F5B_new_global_triangle_cells_ijk(), F5B_new_integer_regular_domain3D(), and old_F5B_new_global_tetrahedral_cells().

F5B_permute_dimensions()

F5_API hsize_t * F5B_permute_dimensions	(	hsize_t *	target_dims,
		int	rank,
		const hsize_t *	source_dims,
		int	perm_vector[FIBER_MAX_RANK],
		int	perm_vector_size )

Permute a given dimensions array according to the given permutation vector.

Parameters

source_dims	The source dimensions.
target_dims	The target dimensions array, may be identical to the source dimensions array.

Returns

A pointer to the target dimensions array.

Parameters

perm_vector

The permutation vector, may be F5_FORTRAN_ORDER, F5_C_ORDER or an explicity integer array specifying an arbitrary reodering of indices.

See also

F5B_fortran_permute_vector()

Todo

Make the define F5_FORTRAN_ORDER identical to the return value of F5B_fortran_permute_vector(). This is a possible optimization, currently there are two equivalent ways of specifying FORTRAN ordering.

Definition at line 72 of file F5Bchart.c.

{
hsize_t tmp[FIBER_MAX_RANK];
hsize_t* dst;
 
        if (!source_dims)
        {
        int     i;
                for(i=0; i< rank; i++)
                        target_dims[i] = 0;
                F5printf(10, "F5B_permute_dimensions(): No source dimensions provided!");
                return NULL;
        }
 
        if (perm_vector == F5_C_ORDER)
        {
        int     i;
                F5printf(50, "F5B_permute_dimensions(): C order permutation vector!");
                if (target_dims == source_dims)
                        return target_dims;
 
                for(i=0; i< rank; i++)
                        target_dims[i] = source_dims[i];
 
                return target_dims;
        }
 
        if (target_dims == source_dims)
        {
                if (rank<2)
                {
                        F5printf(40, "F5B_permute_dimensions(): no permutation for 1D!");
                        /* no permutation possible for 1D data... */
                        return target_dims;
                }
                dst = tmp;
        }
        else
                dst = target_dims;
 
/*      if (perm_vector == F5_FORTRAN_ORDER) */
        if (is_fortran_permutation(perm_vector, perm_vector_size) )
        {
        int     i;
                F5printf(40, "F5B_permute_dimensions(): FORTRAN order permutation vector!");
                for(i=0; i< rank; i++)
                        dst[i] = source_dims[rank-1-i];
        }
        else if (rank>1) /* only then it makes sense to copy stuff */
        {
        int     i;
        int     cdims = perm_vector_size,
                   cd = rank - cdims;
 
                assert(perm_vector);
                F5printf(50, "F5B_permute_dimensions(): generic order permutation vector of size %d, data are size %d", cdims, rank);
/*
                for(i=0; i< cdims; i++)
                {
                int     pv = perm_vector[i];
                        F5printf(10, " perm_vector[%d] = %d", i, pv );
                }
                for(i=0; i< rank; i++)
                {
                int     pv = source_dims[i];
                        F5printf(10, " source_dims[%d] = %d", i, pv );
                }
*/
 
                if (rank > cdims)
                {
                        F5printf(50, "F5B_permute_dimensions(): permutation on %d-higher dimensional subspace!", cd);
                        assert( cd == 1 && "higher dimensional subspaces not supported yet!");
 
                        for(i=0; i<cd; i++)
                        {
/*                      int     pv = perm_vector[i+cd]; */
                                /*
                                  Assume FORTRAN convention on subspace dimensions,
                                  but should actually make use of the perm_vector here
                                  as well within the subspace.
                                  If the dimension exceeds the dimension of the subspace,
                                  then things become interesting what to do then...
                                 */
                        int     pv = rank-1-i;
                                assert(  pv < rank );
                                dst[i] = source_dims[ pv ];
                        }
                        for(; i<rank; i++)
                        {
                        int     pv = perm_vector[i-cd];
                                assert(  pv >= 0 );
                                assert(  pv < rank );
                                dst[i] = source_dims[ pv ];
/*                              F5printf(0, " MAP from %d => %d value %d", pv, i, dst[i] ); */
                        }
/*
                        for(i=0; i<rank; i++)
                        {
                        int     pv = dst[i];
                                F5printf(0, " target_dims[%d] = %d", i, pv );
                        }
*/
                }
                else for(i=0; i< rank; i++)
                {
                int     pv = perm_vector[i-cd];
                /*      F5printf(41, " perm_vector[%d] = %d\n", i-cd, pv );  */
                /*      printf(" perm_vector[%d] = %d (rank=%d, cdims=%d, cd=%d)\n", i-cd, pv, rank, cdims, cd );*/
                        assert(  pv >= 0 );
                        assert(  pv < rank );
                        dst[i] = source_dims[ pv ];
                }
        }
        else if (rank==1)
        {
                target_dims[0] = source_dims[0];
                F5printf(50, "~F5B_permute_dimensions() 1D");
                return target_dims;
        }
 
        if (dst != target_dims)
        {
        int     i;
                F5printf(50, "F5B_permute_dimensions(): Copy back permutation vector!");
                for(i=0; i< rank; i++)
                        target_dims[i] = dst[i];
        }
        F5printf(50, "~F5B_permute_dimensions()");
        return target_dims;
}

References F5_C_ORDER, F5printf, and FIBER_MAX_RANK.

Referenced by F5Fcreate(), and F5Tpermute_dimensions().

F5B_read_chart_domain()

F5_API ChartDomain_IDs * F5B_read_chart_domain	(	hid_t	ChartDomainLocationID,
		const char *	DefaultChartName )

Todo

Make failsafe if a type definition does not exist.

Add support for dynamically defined types.

Definition at line 720 of file F5Bchart.c.

{
int     Tdims;
hid_t   perm_id,  precision_group;
ChartDomain_IDs*FileID = 0;
 
        FileID = (ChartDomain_IDs*)malloc(sizeof(ChartDomain_IDs));
        memset (FileID, 0, sizeof (ChartDomain_IDs));
 
        FileID->refs = 1;
 
        precision_group = F5Gtry_to_open(ChartDomainLocationID, FIBER_HDF5_CHART_SINGLE_PRECISION);
        if (precision_group>0)
        {
                F5Bchart_read_tangential_types( &FileID->SinglePrecision, precision_group);
                H5Gclose(precision_group);
                precision_group = H5Gopen2(ChartDomainLocationID, FIBER_HDF5_CHART_DOUBLE_PRECISION, H5P_DEFAULT);
                F5Bchart_read_tangential_types( &FileID->DoublePrecision, precision_group);
                H5Gclose(precision_group);
        }
        else
        {
                F5Bchart_read_tangential_types( &FileID->SinglePrecision, ChartDomainLocationID );
                F5Bchart_read_tangential_types( &FileID->DoublePrecision, ChartDomainLocationID );
        }
 
        {
        hid_t   Point_hid_t = FileID->SinglePrecision.Point_hid_t;
                if (Point_hid_t<0)
                {
                        F5printf(0, "F5B_read_chart_domain() Invalid single precision point type!\n");
                }
                else
                {
                char*buf = (char*)malloc(256);
                        if (!F5Aget_string( Point_hid_t, FIBER_HDF5_CHART_DOMAIN, buf, 256 ) )
                        {
                                free(buf);
                                FileID->domain_name = strdup(DefaultChartName);
                        }
                        else
                                FileID->domain_name = buf;
                }
 
                Tdims = H5Tget_nmembers( Point_hid_t );
 
 
/*#ifdef        SAVE_MEMORDER_WITH_TYPE*/
                perm_id = F5Atry_to_open(Point_hid_t, FIBER_HDF5_CHART_MEMLAYOUT);
/*
#else
        perm_id = F5Atry_to_open(location, FIBER_HDF5_CHART_MEMLAYOUT);
#endif
*/
        }
 
        if (perm_id>0)
        {
                assert(FileID->perm_vector);
                F_H5Aread(perm_id, H5T_NATIVE_INT, FileID->perm_vector, FIBER_HDF5_CHART_MEMLAYOUT);
                H5Aclose(perm_id);
        }
        else /* NO MEMLAYOUT attribute: Default is a FORTRAN permutation vector */
        {
        int i;
                assert(FileID->perm_vector);
                for(i=0; i<Tdims; i++)
                        FileID->perm_vector[i] = Tdims - 1 - i;
        }
 
        F5printf(200, "~F5B_read_chart_domain(,%s) DONE\n", DefaultChartName);
 
        return FileID;
}

References ChartDomain_IDs::domain_name, ChartDomain_IDs::DoublePrecision, F5Aget_string(), F5Atry_to_open(), F5Bchart_read_tangential_types(), F5Gtry_to_open(), F5printf, F_H5Aread(), FIBER_HDF5_CHART_DOMAIN, FIBER_HDF5_CHART_DOUBLE_PRECISION, FIBER_HDF5_CHART_MEMLAYOUT, FIBER_HDF5_CHART_SINGLE_PRECISION, free(), H5Gclose, ChartDomain_IDs::perm_vector, _F5_ChartPrecisionTypes::Point_hid_t, ChartDomain_IDs::refs, and ChartDomain_IDs::SinglePrecision.

Referenced by F5B_read_global_chart().

F5B_read_global_chart()

F5_API ChartDomain_IDs * F5B_read_global_chart	(	hid_t	ChartsID,
		const char *	name )

Definition at line 696 of file F5Bchart.c.

{
hid_t   location;
ChartDomain_IDs*FileID = 0;
 
        F5printf(200, "F5B_read_global_chart(,%s)\n", name);
 
        location = H5Gopen2(ChartsID, name, H5P_DEFAULT);
        if (location<0)
        {
                F5printf(0, "F5B_read_global_chart(,%s) FAILED\n", name);
                return 0;
        }
 
        FileID = F5B_read_chart_domain(location, name);
        H5Gclose(location);
 
        return FileID;
}

References F5B_read_chart_domain(), F5printf, H5Gclose, and name.

Referenced by F5FB_read_global_chart().

F5B_save_global_chart()

F5_API ChartDomain_IDs * F5B_save_global_chart	(	const ChartDomain_IDs *	MemoryIDs,
		hid_t	Domain_hid )

Create File ID's from MemoryID's.

Todo

Possible optimization: Save only if perm_vector is not FORTRAN ordering .

Definition at line 801 of file F5Bchart.c.

{
int     i;
ChartDomain_IDs*FileID = (ChartDomain_IDs*)malloc(sizeof(ChartDomain_IDs));
        memset (FileID, 0, sizeof (ChartDomain_IDs));
 
        FileID->refs = 1;
        for(i=0; i<FIBER_MAX_RANK; i++)
                FileID->perm_vector[i] = MemoryIDs->perm_vector[i];
 
        FileID->domain_name = strdup(MemoryIDs->domain_name);
        FileID->cell_dimensionality = MemoryIDs->cell_dimensionality;
 
        /* Save the memory layout ordering attribute */
        /* Possible optimization: Save only if perm_vector is not FORTRAN ordering */
 
        {
        hid_t   SinglePrecisionTypes = H5Gcreate2(Domain_hid, FIBER_HDF5_CHART_SINGLE_PRECISION,
                                                  H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
 
                FileID->SinglePrecision.Point_hid_t = F5Tsave_tensor(SinglePrecisionTypes, MemoryIDs->domain_name,
                                                                     FIBER_HDF5_CHART_POINT_TYPE, MemoryIDs->SinglePrecision.Point_hid_t, 0,0, 0);
 
                H5Gclose( SinglePrecisionTypes );
        }
        {
        hid_t   DoublePrecisionTypes = H5Gcreate2(Domain_hid, FIBER_HDF5_CHART_DOUBLE_PRECISION,
                                                  H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
 
                FileID->DoublePrecision.Point_hid_t = F5Tsave_tensor(DoublePrecisionTypes, MemoryIDs->domain_name,
                                                                     FIBER_HDF5_CHART_POINT_TYPE, MemoryIDs->DoublePrecision.Point_hid_t, 0,0, 0);
 
                H5Gclose( DoublePrecisionTypes );
        }
 
        /* by default, link to single precision type */
        H5Lcreate_soft( FIBER_HDF5_CHART_SINGLE_PRECISION "/" FIBER_HDF5_CHART_POINT_TYPE,
                        Domain_hid, FIBER_HDF5_CHART_POINT_TYPE, H5P_DEFAULT, H5P_DEFAULT );
 
        {
        int     cd = FileID->cell_dimensionality;
                F5Asave_ints(FileID->SinglePrecision.Point_hid_t, FIBER_HDF5_CELLDIMENSIONALITY, &cd, 1);
                F5Asave_ints(FileID->DoublePrecision.Point_hid_t, FIBER_HDF5_CELLDIMENSIONALITY, &cd, 1);
        }
 
        F5T_save_perm_vector(FileID->SinglePrecision.Point_hid_t, H5Tget_nmembers( FileID->SinglePrecision.Point_hid_t ), FileID->perm_vector);
        F5T_save_perm_vector(FileID->DoublePrecision.Point_hid_t, H5Tget_nmembers( FileID->DoublePrecision.Point_hid_t ), FileID->perm_vector);
        return FileID;
}

References ChartDomain_IDs::cell_dimensionality, ChartDomain_IDs::domain_name, ChartDomain_IDs::DoublePrecision, F5Asave_ints(), F5T_save_perm_vector(), F5Tsave_tensor(), FIBER_HDF5_CELLDIMENSIONALITY, FIBER_HDF5_CHART_DOUBLE_PRECISION, FIBER_HDF5_CHART_POINT_TYPE, FIBER_HDF5_CHART_SINGLE_PRECISION, FIBER_MAX_RANK, H5Gclose, ChartDomain_IDs::perm_vector, _F5_ChartPrecisionTypes::Point_hid_t, ChartDomain_IDs::refs, and ChartDomain_IDs::SinglePrecision.

Referenced by F5LTcreateV().

F5Bchart_read_tangential_types()

F5_API void F5Bchart_read_tangential_types	(	F5_ChartPrecisionTypes *	H5Types,
		hid_t	location )

Definition at line 674 of file F5Bchart.c.

{
        assert( H5Types );
 
        H5Types->Point_hid_t            = H5Topen2( location,  FIBER_HDF5_CHART_POINT_TYPE, H5P_DEFAULT);
 
        H5E_BEGIN_TRY
        H5Types->Vector_hid_t           = H5Topen2( location, FIBER_HDF5_CHART_VECTOR_TYPE, H5P_DEFAULT);
        H5Types->Covector_hid_t         = H5Topen2( location, FIBER_HDF5_CHART_COVECTOR_TYPE, H5P_DEFAULT);
 
        H5Types->Bivector_hid_t         = H5Topen2( location, FIBER_HDF5_CHART_BIVECTOR_TYPE, H5P_DEFAULT);
        H5Types->Bicovector_hid_t       = H5Topen2( location, FIBER_HDF5_CHART_BICOVECTOR_TYPE, H5P_DEFAULT);
 
        H5Types->Pseudoscalar_hid_t     = H5Topen2( location, FIBER_HDF5_CHART_PSEUDOSCALAR_TYPE, H5P_DEFAULT);
        H5Types->Pseudocoscalar_hid_t   = H5Topen2( location, FIBER_HDF5_CHART_PSEUDOCOSCALAR_TYPE, H5P_DEFAULT);
 
        H5Types->Metric_hid_t           = H5Topen2( location, FIBER_HDF5_CHART_METRIC_TYPE, H5P_DEFAULT);
        H5Types->Cometric_hid_t         = H5Topen2( location, FIBER_HDF5_CHART_METRIC_TYPE, H5P_DEFAULT);
        H5E_END_TRY
}

References _F5_ChartPrecisionTypes::Bicovector_hid_t, _F5_ChartPrecisionTypes::Bivector_hid_t, _F5_ChartPrecisionTypes::Cometric_hid_t, _F5_ChartPrecisionTypes::Covector_hid_t, FIBER_HDF5_CHART_BICOVECTOR_TYPE, FIBER_HDF5_CHART_BIVECTOR_TYPE, FIBER_HDF5_CHART_COVECTOR_TYPE, FIBER_HDF5_CHART_METRIC_TYPE, FIBER_HDF5_CHART_POINT_TYPE, FIBER_HDF5_CHART_PSEUDOCOSCALAR_TYPE, FIBER_HDF5_CHART_PSEUDOSCALAR_TYPE, FIBER_HDF5_CHART_VECTOR_TYPE, _F5_ChartPrecisionTypes::Metric_hid_t, _F5_ChartPrecisionTypes::Point_hid_t, _F5_ChartPrecisionTypes::Pseudocoscalar_hid_t, _F5_ChartPrecisionTypes::Pseudoscalar_hid_t, and _F5_ChartPrecisionTypes::Vector_hid_t.

Referenced by F5B_read_chart_domain().

F5Bcopy_chart_domain()

F5_API ChartDomain_IDs * F5Bcopy_chart_domain

(

const ChartDomain_IDs *

IDs

)

Make a copy of a coordinate domain. All types are created from the existing information as if it were created from scratch. This function may be used to convert named data types into transient types. This is e.g. useful when reading a file. @TODO Add complementary cleanup function.

Definition at line 851 of file F5Bchart.c.

{
int     i;
const char*coordnames[FIBER_MAX_RANK];
        assert( srcIDs );
        {
        int     dimension = H5Tget_nmembers( srcIDs->SinglePrecision.Point_hid_t );
/*hid_t coord_type = H5Tget_member_type( srcIDs->SinglePrecision.Point_hid_t, 0 ); */
        ChartDomain_IDs*newID;
        const char**cn = coordnames;
 
                for(i=0; i<dimension; i++)
                        coordnames[i] = H5Tget_member_name( srcIDs->SinglePrecision.Point_hid_t, i );
 
/*      newID = F5B_new_global_chart(cn, dimension, coord_type, srcIDs->domain_name, srcIDs->perm_vector, srcIDs->cell_dimensionality); */
                newID = F5B_new_global_domain(cn, dimension, srcIDs->domain_name, srcIDs->perm_vector, srcIDs->cell_dimensionality,
                                              H5Tget_member_type( srcIDs->SinglePrecision.Point_hid_t, 0 ),
                                              H5Tget_member_type( srcIDs->DoublePrecision.Point_hid_t, 0 )
                        );
 
                for(i=0; i<dimension; i++)
                        H5free_memory( (char*)(coordnames[i]) );
 
                return newID;
        }
}

References ChartDomain_IDs::cell_dimensionality, ChartDomain_IDs::domain_name, ChartDomain_IDs::DoublePrecision, F5B_new_global_domain(), FIBER_MAX_RANK, ChartDomain_IDs::perm_vector, _F5_ChartPrecisionTypes::Point_hid_t, and ChartDomain_IDs::SinglePrecision.

F5Bget_chart_dims()

F5_API int F5Bget_chart_dims

(

const ChartDomain_IDs *

IDs

)

Get the dimensionality of this chart. This information is taken from the number of elements of the associated point type.

Definition at line 899 of file F5Bchart.c.

{
        if (!IDs)
                return -1;
 
        return H5Tget_nmembers(IDs->SinglePrecision.Point_hid_t);
}

References _F5_ChartPrecisionTypes::Point_hid_t, and ChartDomain_IDs::SinglePrecision.

Referenced by F5Fcreate(), and F5Tpermute_dimensions().

F5Bget_precision_by_size()

F5_API F5_ChartPrecisionTypes * F5Bget_precision_by_size	(	ChartDomain_IDs *	CD,
		int	TypeSize )

Given the size of some type in byte, yield the appropriate precision type structur from a chart domain. The function will fail if the TypeSize is anything but 1,2,4,8 or 16.

Definition at line 916 of file F5Bchart.c.

{
        if (!CD) return 0;
 
        switch(TypeSize)
        {
        case 1:   return &CD->OneBytePrecision;
        case 2:   return &CD->HalfPrecision;
        case 4:   return &CD->SinglePrecision;
        case 8:   return &CD->DoublePrecision;
        case 16:  return &CD->ExtendedPrecision;
        default:  return 0;
        }
}

References ChartDomain_IDs::DoublePrecision, ChartDomain_IDs::ExtendedPrecision, ChartDomain_IDs::HalfPrecision, ChartDomain_IDs::OneBytePrecision, and ChartDomain_IDs::SinglePrecision.

Referenced by F5Bget_precision_by_type(), and F5file_type().

F5Bget_precision_by_type()

F5_API F5_ChartPrecisionTypes * F5Bget_precision_by_type	(	ChartDomain_IDs *	CD,
		hid_t	type_id )

Given some compound type, yield the precision type corresponding to the compound type's first member. The function will fail if the provided type is not a compound type.

Definition at line 931 of file F5Bchart.c.

{
hid_t   FirstCompoundType = H5Tget_member_type( type_id, 0);
int     CompoundSize = H5Tget_size( FirstCompoundType );
        H5Tclose( FirstCompoundType );
 
        return F5Bget_precision_by_size(CD, CompoundSize);
}

References F5Bget_precision_by_size(), and H5Tclose().

F5Bget_tensor_type_byname()

F5_API F5Ttensor_t * F5Bget_tensor_type_byname	(	ChartDomain_IDs *	CD,
		const char *	name )

References F5_API, and name.

F5Bincrement_domain_refs()

F5_API void F5Bincrement_domain_refs

(

ChartDomain_IDs *

ChartDomain

)

Definition at line 68 of file F5B.c.

{
        if (ChartDomain)
                ChartDomain->refs++;
}

References ChartDomain_IDs::refs.

F5Binsert_tensor_type()

F5_API void F5Binsert_tensor_type	(	ChartDomain_IDs *	CD,
		F5Ttensor_t *	T )

Definition at line 588 of file F5Bchart.c.

{
        assert(This);
        if (!This->TensorTypes)
        {
                This->TensorTypes = new(F5Ttensor_t*, 2);
                This->TensorTypes[0] = T;
                This->TensorTypes[1] = NULL;
        }
        else
        {
        int     i;
                for(i=0; This->TensorTypes[i]; i++)
                        ;
 
                This->TensorTypes = (F5Ttensor_t**)realloc(This->TensorTypes, i+1*sizeof(F5Ttensor_t*));
                This->TensorTypes[i  ] = T;
                This->TensorTypes[i+1] = NULL;
        }
}

References ChartDomain_IDs::TensorTypes.

F5Bt_add_tangential_types()

F5_API void F5Bt_add_tangential_types	(	F5_ChartPrecisionTypes *	H5Types,
		const char *	coordnames[],
		int	dimension,
		hid_t	coord_type )

References F5_API.