#include "F5Bchart.h"
#include "F5F.h"
#include "F5X.h"
#include "F5defs.h"
#include "F5types.h"
#include "F5A.h"
#include "F5private.h"
#include "F5coordinates.h"
#include "F5T.h"
#include <string.h>
#include <stdlib.h>
#include <assert.h>

Macros
#define	new(type, size)
#define	delete(ptr)
#define	true 1
#define	false 0
#define	SAVE_MEMORDER_WITH_TYPE
#define	FIBER_HDF5_ANONYMOUS_TYPENAME "F5::TypeName%04u"

Functions
const int *	F5B_fortran_permute_vector ()
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)
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)
void	F5B_init_tangential_types (F5_ChartPrecisionTypes IDs, const char coordnames[], int dimension, hid_t coord_type)
void	F5Bchart_add_tangential_types (F5_ChartPrecisionTypes IDs, const char coordnames[], int dimension, hid_t coord_type)
int	F5B_inject_precision_type (F5_ChartPrecisionTypes *IDs, hid_t type_id)
ChartDomain_IDs *	F5B_new_global_float_chart (const char coordnames[], int dimension, const char name, const int perm_vector[FIBER_MAX_RANK])
ChartDomain_IDs *	F5B_new_global_int_chart (const char coordnames[], int dimension, const char name, const int perm_vector[FIBER_MAX_RANK])
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)
ChartDomain_IDs *	F5B_new_global_fragment_neighbour_domain (const char coordnames[], int dimension, const char name, const int perm_vector[], int cell_dimensionality)
ChartDomain_IDs *	F5B_new_global_fractional_domain (const char coordnames[], int dimension, const char name, const int perm_vector[], int cell_dimensionality)
void	F5Binsert_tensor_type (ChartDomain_IDs This, F5Ttensor_t T)
void	F5B_delete_tangential_types (F5_ChartPrecisionTypes *ID)
void	F5B_delete_global_chart (ChartDomain_IDs *ID)
void	F5Bchart_read_tangential_types (F5_ChartPrecisionTypes *H5Types, hid_t location)
ChartDomain_IDs *	F5B_read_global_chart (hid_t ChartsID, const char *name)
ChartDomain_IDs *	F5B_read_chart_domain (hid_t ChartDomainLocationID, const char *DefaultChartName)
ChartDomain_IDs *	F5B_save_global_chart (const ChartDomain_IDs *MemoryIDs, hid_t Domain_hid)
ChartDomain_IDs *	F5Bcopy_chart_domain (const ChartDomain_IDs *srcIDs)
void	F5T_save_perm_vector (hid_t location, int rank, int perm_vector[])
int	F5Bget_chart_dims (const ChartDomain_IDs *IDs)
F5_ChartPrecisionTypes *	F5Bget_precision_by_size (ChartDomain_IDs *CD, int TypeSize)
F5_ChartPrecisionTypes *	F5Bget_precision_by_type (ChartDomain_IDs *CD, hid_t type_id)
hid_t	F5file_type (F5Path *fpath, hid_t fieldtype)

Macro Definition Documentation

◆ delete

#define delete ( ptr )

Value:

if (ptr) free(ptr)

free

free(name)

Definition at line 30 of file F5Bchart.c.

◆ false

#define false 0

Definition at line 33 of file F5Bchart.c.

◆ FIBER_HDF5_ANONYMOUS_TYPENAME

#define FIBER_HDF5_ANONYMOUS_TYPENAME "F5::TypeName%04u"

Referenced by F5file_type().

◆ new

#define new	(		type,
			size )

Value:

(type*)calloc(size, sizeof(type))

Definition at line 29 of file F5Bchart.c.

◆ SAVE_MEMORDER_WITH_TYPE

#define SAVE_MEMORDER_WITH_TYPE

Definition at line 671 of file F5Bchart.c.

◆ true

#define true 1

Definition at line 32 of file F5Bchart.c.

Function Documentation

◆ F5B_delete_global_chart()

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

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

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

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

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

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 )

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

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.

◆ F5B_new_global_fractional_domain()

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

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

Definition at line 551 of file F5Bchart.c.

{
ChartDomain_IDs*IDs = F5B_new_global_domain(coordnames,
                                            dimension,
                                            name,
                                            perm_vector,
                                            cell_dimensionality,
                                            H5T_NATIVE_CHAR,
                                            H5T_NATIVE_CHAR);
/*
        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 F5B_new_global_domain(), and name.

Referenced by F5B_new_global_fragname().

◆ F5B_new_global_int_chart()

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

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

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

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

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

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

void F5Bchart_add_tangential_types	(	F5_ChartPrecisionTypes *	IDs,
		const char *	coordnames[],
		int	dimension,
		hid_t	coord_type )

Adds tangential types (vector, covector, metric) to a given chart domain. These types are derived from the specified coord_type.

Todo

Get dimension and coordnames from the chart domain's points.

CALL this function for various numerical precisions

Definition at line 326 of file F5Bchart.c.

{
size_t  Tsize = H5Tget_size(coord_type);
        IDs->Vector_hid_t = H5Tcreate(H5T_COMPOUND, dimension*Tsize );
        // F5printf(40, "F5B_add_tangential_types, IDs->Vector_hid_t = %lli\n", IDs->Vector_hid_t);
        {int i;
        for(i=0; i<dimension; i++)
        {
        char    buf[_FIBER_MAX_COORDNAME_LENGTH+2] = "D";
                strcat(buf, coordnames[i]);
                H5Tinsert(IDs->Vector_hid_t, buf, i*Tsize, coord_type);
        }
        }
 
        IDs->Covector_hid_t = H5Tcreate(H5T_COMPOUND, dimension*Tsize );
        {int i;
        for(i=0; i<dimension; i++)
        {
        char    buf[_FIBER_MAX_COORDNAME_LENGTH+2] = "d";
                strcat(buf, coordnames[i]);
                H5Tinsert(IDs->Covector_hid_t, buf, i*Tsize, coord_type);
        }
        }
#if 0
        /* needs revision: do permutation without repetition -> ( 2
                                                                  D )   */
        IDs->Bivector_hid_t = H5Tcreate(H5T_COMPOUND, dimension*dimension*Tsize );
        {int i, j;
        for(i=0; i<dimension; i++)
        for(j=i; j<dimension; j++)
        {
        int     L = i*dimension + j;
        char    buf[_FIBER_MAX_COORDNAME_LENGTH+2] = "D";
                strcat(buf, coordnames[i]);
                strcat(buf, coordnames[j]);
 
                H5Tinsert(IDs->Bivector_hid_t, buf, L*Tsize, coord_type);
        }
        }
#endif
        if (dimension == 3)
        {
        IDs->Bivector_hid_t = H5Tcreate(H5T_COMPOUND, dimension*Tsize );
 
        {
        char    buf[_FIBER_MAX_COORDNAME_LENGTH+2] = "D";
                strcat(buf, coordnames[1]);
                strcat(buf, "^D");
                strcat(buf, coordnames[2]);
 
                H5Tinsert(IDs->Bivector_hid_t, buf, 0*Tsize, coord_type);
        }
 
        {
        char    buf[_FIBER_MAX_COORDNAME_LENGTH+2] = "D";
                strcat(buf, coordnames[2]);
                strcat(buf, "^D");
                strcat(buf, coordnames[0]);
 
                H5Tinsert(IDs->Bivector_hid_t, buf, 1*Tsize, coord_type);
        }
 
        {
        char    buf[_FIBER_MAX_COORDNAME_LENGTH+2] = "D";
                strcat(buf, coordnames[0]);
                strcat(buf, "^D");
                strcat(buf, coordnames[1]);
 
                H5Tinsert(IDs->Bivector_hid_t, buf, 2*Tsize, coord_type);
        }
 
        }
        IDs->Bicovector_hid_t = H5Tcreate(H5T_COMPOUND, dimension*dimension*Tsize );
        {int i, j;
        for(i=0; i<dimension; i++)
        for(j=i; j<dimension; j++)
        {
        int     L = i*dimension + j;
        char    buf[_FIBER_MAX_COORDNAME_LENGTH+2] = "d";
                strcat(buf, coordnames[i]);
                strcat(buf, coordnames[j]);
 
                H5Tinsert(IDs->Bicovector_hid_t, buf, L*Tsize, coord_type);
        }
        }
 
        IDs->Metric_hid_t = H5Tcreate(H5T_COMPOUND, dimension*(dimension+1)/2*Tsize );
        {int i, j, ni, nj;
        int     indices[FIBER_MAX_RANK*FIBER_MAX_RANK];
        int     I = 0; /* the linear index */
 
                for(ni=0, i=0; i<dimension; i++ )
                {
                        for(nj=0, j=0; j<i; j++ )
                        {
                                indices[ni+j] = indices[nj+i] = I++;
                                nj += dimension;
                        }
                        indices[ni+i] = I++;
                        ni += dimension;
                }
 
 
        for(i=0; i<dimension; i++)
        for(j=i; j<dimension; j++)
        {
        int     L = i*dimension + j,
                idx = indices[ L ];
        char    buf[_FIBER_MAX_COORDNAME_LENGTH+2] = "g";
                strcat(buf, coordnames[i]);
                strcat(buf, coordnames[j]);
 
                H5Tinsert(IDs->Metric_hid_t, buf, idx*Tsize, coord_type);
        }
        }
 
        IDs->Cometric_hid_t = H5Tcreate(H5T_COMPOUND, dimension*(dimension+1)/2*Tsize );
        {int i, j, ni, nj;
        int     indices[FIBER_MAX_RANK*FIBER_MAX_RANK];
        int     I = 0; /* the linear index */
 
                for(ni=0, i=0; i<dimension; i++ )
                {
                        for(nj=0, j=0; j<i; j++ )
                        {
                                indices[ni+j] = indices[nj+i] = I++;
                                nj += dimension;
                        }
                        indices[ni+i] = I++;
                        ni += dimension;
                }
 
 
        for(i=0; i<dimension; i++)
        for(j=i; j<dimension; j++)
        {
        int     L = i*dimension + j,
                idx = indices[ L ];
        char    buf[_FIBER_MAX_COORDNAME_LENGTH+2] = "G";
                strcat(buf, coordnames[i]);
                strcat(buf, coordnames[j]);
 
                H5Tinsert(IDs->Cometric_hid_t, buf, idx*Tsize, coord_type);
        }
        }
}

References _FIBER_MAX_COORDNAME_LENGTH, _F5_ChartPrecisionTypes::Bicovector_hid_t, _F5_ChartPrecisionTypes::Bivector_hid_t, _F5_ChartPrecisionTypes::Cometric_hid_t, _F5_ChartPrecisionTypes::Covector_hid_t, FIBER_MAX_RANK, _F5_ChartPrecisionTypes::Metric_hid_t, and _F5_ChartPrecisionTypes::Vector_hid_t.

Referenced by F5B_new_global_float_chart(), F5B_new_global_int_chart(), and F5B_new_global_int_domain().

◆ F5Bchart_read_tangential_types()

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
}

Referenced by F5B_read_chart_domain().

◆ F5Bcopy_chart_domain()

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

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

◆ F5Binsert_tensor_type()

void F5Binsert_tensor_type	(	ChartDomain_IDs *	This,
		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.

◆ F5file_type()

hid_t F5file_type	(	F5Path *	fpath,
		hid_t	fieldtype )

In F5, types are saved to the file to store certain information about datasets. The insufficiency in HDF5 is that a certain type can be saved to one file only, but not to many files, like a dataset. When a type is saved to a file, it becomes a "named type" - in contrast to "transient" types, which are not bound to a file. Only named types may carry attributes, transient types may not contain attributes.

Type attributes are used to describe properties of a type, in particular its tensorial properties, which is beyond the raw native type definition of e.g. float and dimension. We cannot store this information with a transient type, but must do it by our own ;-( .

Generic support would be desireable, but is not implemented right now. For now, only a limited set of pre-defined low-tensorial data types is hard-coded. By knowing this hard-coded type, also the tensorial type information is written into the file when saving the data type. Admittedly, this is not pretty, and a future revision will provide a more dynamically mechanism here.

The functionality is as follows:

Given a transient HDF5 type, return a named type that is suitable for the current file. The file ID's will be filled with the named data types.

@Note The file which is contained in fpath will be changed by this operation, because a new type might be created and saved into the file, so the fpath parameter cannot be const.

@Note This function currently only knows aboout point, vector and predefined tensor types in the ChartId. It is NOT fully generic. If it cannot convert some field type into a file type, it returns the transient type, i.e. we don't get a named type in this case.

Definition at line 941 of file F5Bchart.c.

{
        if (!fpath || !fpath->myChart)
        {
                F5printf(20, "F5file_type: No chart given, returning memory type.");
                return fieldtype;
        }
 
        F5printf(40, "F5file_type(%p, %d): chart=%p", fpath, (int) fieldtype, fpath->myChart );
 
        switch( H5Tget_class( fieldtype) )
        {
        default:
                F5printf(20, "F5file_type query for unknown type (could be a native one).");
                return fieldtype;
 
        case H5T_INTEGER:
        case H5T_FLOAT:
        case H5T_STRING:
                F5printf(20, "F5file_type query for integer/float/string type (could be a native one).");
                return fieldtype;
 
        case H5T_BITFIELD:
        case H5T_OPAQUE:
        case H5T_REFERENCE:
        case H5T_ENUM:
        case H5T_VLEN:
        case H5T_ARRAY:
                F5printf(20, "F5file_type query for unsupported type (could be a native one).");
                return fieldtype;
 
        case H5T_COMPOUND:
                ;
        }
 
/*
  The following code is executed once we know the fieldtype is a compound type.
 */
 
        {
        hid_t   FirstCompoundType = H5Tget_member_type( fieldtype, 0);
        int     CompoundPrecision = H5Tget_size( FirstCompoundType );
 
        F5_ChartPrecisionTypes*IN   = F5Bget_precision_by_size(fpath->myChart, CompoundPrecision),
                              *OUT  = F5Bget_precision_by_size(fpath->FileIDs, CompoundPrecision);
 
                H5Tclose( FirstCompoundType );
 
                F5printf(20, "F5file_type query for compound type, precision %d.\n", CompoundPrecision);
 
                assert(IN);
                assert(OUT);
                assert( fpath->myChart );
                assert( fpath->FileIDs );
 
                if (F5Tequal(fieldtype, IN->Point_hid_t) )
                {
                        F5printf(20, "F5file_type query for point type.\n");
                        if (OUT->Point_hid_t<1)
                        {
                                F5printf(0, "F5file_type(): Possible internal error, point type not found in file!");
 
                                OUT->Point_hid_t = F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_POINT_TYPE, CompoundPrecision,
                                                                          IN->Point_hid_t, 0,0, 0);
                                {
                                int cd = fpath->myChart->cell_dimensionality;
                                        printf("CELL Dimensionality: %d\n", cd);
                                        F5Asave_ints(OUT->Point_hid_t,  FIBER_HDF5_CELLDIMENSIONALITY, &cd, 1);
                                }
 
#ifdef  SAVE_MEMORDER_WITH_TYPE
                                F5T_save_perm_vector(OUT->Point_hid_t,
                                                     H5Tget_nmembers( OUT->Point_hid_t ),
                                                     fpath->FileIDs->perm_vector);
#endif
                        }
                        return OUT->Point_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Vector_hid_t) )
                {
                        F5printf(20, "F5file_type query for vector type %d", (int) IN->Vector_hid_t );
                        if (OUT->Vector_hid_t<1)
                        {
                        int     covariance[] = {1}; /* Tangential vectors have one upper index */
                                OUT->Vector_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_VECTOR_TYPE, CompoundPrecision,
                                                               IN->Vector_hid_t, 1, covariance, 1);
                        }
                        return OUT->Vector_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Covector_hid_t) )
                {
                        F5printf(20, "F5file_type query for covector type.\n");
                        if (OUT->Covector_hid_t<1)
                        {
                        int     covariance[] = {-1}; /* Co-vectors have one lower index */
                                OUT->Covector_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_COVECTOR_TYPE, CompoundPrecision,
                                                               IN->Covector_hid_t, 1, covariance, 1);
                        }
                        return OUT->Covector_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Bivector_hid_t) )
                {
                        F5printf(20, "F5file_type query for bivector type.\n");
                        if (OUT->Bivector_hid_t<1)
                        {
                        int     covariance[] = {1,1}; /* bivectors have two upper indices */
                                OUT->Bivector_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_BIVECTOR_TYPE, CompoundPrecision,
                                                               IN->Bivector_hid_t, 2, covariance, 2);
                        }
                        return OUT->Bivector_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Bicovector_hid_t) )
                {
                        F5printf(20, "F5file_type query for bicovector type.\n");
                        if (OUT->Bivector_hid_t<1)
                        {
                        int     covariance[] = {-1,-1}; /* bicovectors have two lower indices */
                                OUT->Bicovector_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_BICOVECTOR_TYPE, CompoundPrecision,
                                                               IN->Bicovector_hid_t, 2, covariance, 2);
                        }
                        return OUT->Bicovector_hid_t;
                }
 
                else if (F5Tequal(fieldtype, IN->Metric_hid_t) )
                {
                        F5printf(20, "F5file_type query for metric type.\n");
                        if (OUT->Metric_hid_t<1)
                        {
                                /* g_\mu\nu */
                        int     covariance[] = {-1, -1}; /* Metric tensors have two lower indices */
                                OUT->Metric_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_METRIC_TYPE, CompoundPrecision,
                                                               IN->Metric_hid_t, 2, covariance, 0);
                        }
                        return OUT->Metric_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Cometric_hid_t) )
                {
                        F5printf(20, "F5file_type query for cometric type.\n");
                        if (OUT->Cometric_hid_t<1)
                        {
                                /* g^\mu\nu */
                        int     covariance[] = {1, 1}; /* Cometric tensors have two upper indices */
                                OUT->Cometric_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_COMETRIC_TYPE, CompoundPrecision,
                                                               IN->Cometric_hid_t, 2, covariance, 0);
                        }
                        return OUT->Cometric_hid_t;
                }
 
 
                F5printf(2, __FILE__ ": Warning: F5file_type() query could not identify file type.\n");
                {
                int     TypeMembers = H5Tget_nmembers( fieldtype );
                const   char*MultiplicityCategory;
                hid_t   MultiplicityCategory_id;
                        switch(TypeMembers)
                        {
                        case 1: MultiplicityCategory = "Chart-free compound types with one member"; break;
                        case 2: MultiplicityCategory = "Chart-free compound types with two members"; break;
                        case 3: MultiplicityCategory = "Chart-free compound types with three members"; break;
                        case 4: MultiplicityCategory = "Chart-free compound types with four members"; break;
                        default:MultiplicityCategory = "Chart-free compound types with many members"; break;
                        }
                        MultiplicityCategory_id = F5Gappend(fpath->GlobalChart_hid, MultiplicityCategory);
 
                        {
#define FIBER_HDF5_ANONYMOUS_TYPENAME "F5::TypeName%04u"
                        char    type_name[1024];
                        unsigned nthType = 0;
                                for(;nthType<10000;nthType++)
                                {
                                hid_t   type_id;
                                        sprintf(type_name, FIBER_HDF5_ANONYMOUS_TYPENAME, nthType);
                                        type_id = F5Tappend(MultiplicityCategory_id, type_name, fieldtype);
 
                                        if (type_id>0)
                                        {
                                                /*
                                                  Inject This type to the chart file identifiers
                                                  for the output file, for mere cleanup upon file
                                                  closing. Otherwise This type ID will NOT be associated
                                                  with the respective chart.
                                                 */
                                                F5B_inject_precision_type(OUT, type_id);
                                                H5Gclose(MultiplicityCategory_id);
                                                return type_id;
                                        }
                                }
                                puts("F5file_type: Creating anonymous type name failed!");
                                H5Gclose(MultiplicityCategory_id);
                                return fieldtype;
                        }
                }
        }
}

References _F5_ChartPrecisionTypes::Bicovector_hid_t, _F5_ChartPrecisionTypes::Bivector_hid_t, ChartDomain_IDs::cell_dimensionality, _F5_ChartPrecisionTypes::Cometric_hid_t, _F5_ChartPrecisionTypes::Covector_hid_t, F5Asave_ints(), F5B_inject_precision_type(), F5Bget_precision_by_size(), F5Gappend(), F5printf, F5T_save_perm_vector(), F5Tappend(), F5Tmake_precise_tensor(), FIBER_HDF5_ANONYMOUS_TYPENAME, FIBER_HDF5_CELLDIMENSIONALITY, FIBER_HDF5_CHART_BICOVECTOR_TYPE, FIBER_HDF5_CHART_BIVECTOR_TYPE, FIBER_HDF5_CHART_COMETRIC_TYPE, FIBER_HDF5_CHART_COVECTOR_TYPE, FIBER_HDF5_CHART_METRIC_TYPE, FIBER_HDF5_CHART_POINT_TYPE, FIBER_HDF5_CHART_VECTOR_TYPE, F5Path::FileIDs, F5Path::GlobalChart_hid, H5Gclose, H5Tclose(), _F5_ChartPrecisionTypes::Metric_hid_t, F5Path::myChart, ChartDomain_IDs::perm_vector, _F5_ChartPrecisionTypes::Point_hid_t, and _F5_ChartPrecisionTypes::Vector_hid_t.

Referenced by F5Fcreate(), F5FSwrite_fraction(), F5Fwrite_1D(), F5Fwrite_flexible(), F5Fwrite_fraction(), F5Fwrite_fraction_external(), F5Fwrite_fractionS(), F5Fwrite_linear(), F5Fwrite_linear_fraction(), F5FwriteIMAGE(), F5Fwrites(), F5FwriteX(), F5Rcreate_uniform_sparse(), F5write_particle_cartesian3Dv(), F5write_particle_cartesian3DvU(), and F5write_particle_double_cartesian3Dv().

◆ F5T_save_perm_vector()

void F5T_save_perm_vector	(	hid_t	location,
		int	rank,
		int	perm_vector[] )

Definition at line 879 of file F5Bchart.c.

{
        if (!perm_vector)
        {
                puts("F5T_save_perm_vector()");
                return;
        }
 
        /* Save the memory layout ordering attribute */
        /* Possible optimization: Save only if perm_vector is not FORTRAN ordering */
        {
        hsize_t Tdims = rank;
        hid_t   index_ds = H5Screate_simple(1, &Tdims, &Tdims ) ;
        hid_t   Rank_id = F5Acreate(location, FIBER_HDF5_CHART_MEMLAYOUT, H5T_NATIVE_INT, index_ds, 0);
                H5Awrite(Rank_id, H5T_NATIVE_INT, perm_vector );
                H5Aclose(Rank_id);
                H5Sclose(index_ds);
        }
}

References F5Acreate(), and FIBER_HDF5_CHART_MEMLAYOUT.

Referenced by F5B_save_global_chart(), and F5file_type().

Macros

Functions

Macro Definition Documentation

◆ delete

◆ false

◆ FIBER_HDF5_ANONYMOUS_TYPENAME

◆ new

◆ SAVE_MEMORDER_WITH_TYPE

◆ true

Function Documentation

◆ F5B_delete_global_chart()

◆ F5B_delete_tangential_types()

◆ F5B_fortran_permute_vector()

◆ F5B_init_tangential_types()

◆ F5B_inject_precision_type()

◆ F5B_new_global_domain()

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

◆ F5B_permute_dimensions()

◆ F5B_read_chart_domain()

◆ F5B_read_global_chart()

◆ F5B_save_global_chart()

◆ F5Bchart_add_tangential_types()

◆ F5Bchart_read_tangential_types()

◆ F5Bcopy_chart_domain()

◆ F5Bget_chart_dims()

◆ F5Bget_precision_by_size()

◆ F5Bget_precision_by_type()

◆ F5Binsert_tensor_type()

◆ F5file_type()

◆ F5T_save_perm_vector()