F5LT.c

Go to the documentation of this file.

#include "F5L.h"
#include "F5B.h"
#include "F5X.h"
#include "F5T.h"
#include "F5A.h"
#include "F5defs.h"
#include "F5private.h"
#include "F5coordinates.h"
/* #if defined(__APPLE__) && defined(__MACH__) && defined(__POWERPC__) */
#include <stdlib.h>
/* #else */
/* #include <malloc.h> */
/* #endif */
 
#include <assert.h>
#include <string.h>
 
extern ChartDomain_IDs*F5FB_read_global_chart(F5Path*f);
 
 
int     F5LTget_index_depth(hid_t Top_hid)
{
int     IndexDepth = 0;
 
        if (F5Aget_ints(Top_hid, FIBER_HDF5_INDEXDEPTH_ATTRIB, &IndexDepth, 1) <= 0)
        {
                F5printf(5," *Warning* F5LTget_index_depth() could not find index depth attribute!");
                return F5_INVALID_INDEX_DEPTH;
        }
 
        return IndexDepth;
}
 
int     F5LTget_skeleton_dimensionality(hid_t Top_hid)
{
int     result = FIBER_HDF5_INVALID_SKELETON_DIMENSIONALITY;
        if (F5Aget_ints(Top_hid, FIBER_HDF5_SKELETON_DIMENSIONALITY_ATTRIB, &result, 1) <= 0)
                F5printf(5," *Warning* F5LTget_F5LTget_skeleton_dimensionality() could not find skeleton dimensionality,setting unknown -1");
 
        return result;
}
 
int     F5LTset_dataspace(F5Path*f, int rank, hsize_t*dims)
{
hsize_t current_dims[FIBER_MAX_RANK];
int     current_rank, Mrank = -1;
 
        if (!f)
        {
                return 0;
        }
 
        F5printf(30, "F5LTset_dataspace(,rank=%d,)", rank);
 
        F5Aget_ints( f->Topology_hid, FIBER_HDF5_RANK_ATTRIBUTE, &Mrank, 1);
        if (Mrank<0)
        {
                F5printf(30, "F5LTset_dataspace(,%d,): INVALID FILE: RANK attribute is not integer - cannot set dataspace!", rank);
                return 0;
        }
 
        if (Mrank>=1)
        {
                if (Mrank != rank)
                {
                        if (rank==4)
                                F5printf(0, "F5LTset_dataspace(,%d,): Dimensions %dx%dx%dx%d incompatible with RANK attribute %d - inconsistent dataspace!",
                                         rank, (int)dims[0],(int)dims[1],(int)dims[2],(int)dims[3],
                                         Mrank);
                        else
                                F5printf(0, "F5LTset_dataspace(,%d,): Dimensions incompatible with RANK attribute %d - inconsistent dataspace!", rank, Mrank);
 
                        return 0;
                }
        }
 
        current_rank = F5LAget_dimensions(f->Topology_hid,
                                          FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE,
                                          current_dims);
 
        if (current_rank>0)
        {
        int     i;
                if (rank != current_rank)
                {
                        puts("F5LTset_dataspace(): Set DATAPACE: Inconsistent rank with DATASPACE_DIMENSIONS!");
                        return 0;
                }
 
                for(i=0; i<rank; i++)
                {
                        if (current_dims[i] != dims[i])
                        {
                                F5printf(5, "F5LTset_dataspace(,rank=%d,): new dimensions[%d] is %d, but already set to %d in the file as  %dx%dx%dx%d - aborting.",
                                         rank,              i, (int)(current_dims[i]), (int)(dims[i]),
                                         rank>0?(int)dims[0]:1, rank>1?(int)dims[1]:1, rank>2?(int)dims[2]:1, rank>3?(int)dims[3]:1);
                                return 0;
                        }
                }
                F5printf(5, "F5LTset_dataspace(,rank=%d,): dimensions are ok.", rank);
                return 1;
        }
        {int i;
        for(i=0; i<rank; i++)
        {
                if (dims[i] < 1)
                {
                        F5printf(10, "F5LTset_dataspace(,rank=%d,): do NOT set new topology dimensions, because dims[%d]=%d\n", rank, i, (int)dims[i] );
                        return 0;
                }
        }
        }
 
        F5LAsave_dimensions(f->Topology_hid, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, rank, dims);
        F5printf(30, "F5LTset_dataspace(,rank=%d,): set new dimensions to skeleton as %dx%dx%dx%d.", rank,
                 rank>0?(int)dims[0]:1, rank>1?(int)dims[1]:1, rank>2?(int)dims[2]:1, rank>3?(int)dims[3]:1);
        return 1;
}
 
int     F5LTexpand_dataspace(F5Path*f, int rank, hsize_t*dims)
{
hsize_t current_dims[FIBER_MAX_RANK];
int     current_rank, Mrank;
int     i;
 
        F5printf(30, "F5LTexpand_dataspace(,%d,)", rank);
        if (!f)
                return 1;
 
        F5Aget_ints( f->Topology_hid, FIBER_HDF5_RANK_ATTRIBUTE, &Mrank, 1);
        if (Mrank<0)
        {
                F5printf(30, "F5LTexpand_dataspace(,%d,): INVALID FILE: RANK attribute is not integer - cannot set dataspace!", rank);
                return 0;
        }
        if (Mrank>=0)
        {
                if (Mrank != rank)
                {
                        F5printf(30, "F5LTexpand_dataspace(,%d,): Dimensions incompatible with RANK attribute %d - inconsistent dataspace!", rank, Mrank);
                        puts("Set DATAPACE: Inconsistent rank!");
                        return 0;
                }
        }
 
        current_rank = F5LAget_dimensions(f->Topology_hid,
                                          FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE,
                                          current_dims);
 
        if (current_rank>0)
        {
                if (rank != current_rank)
                {
                        puts("Set DATAPACE: Inconsistent rank!");
                        return 0;
                }
 
                for(i=0; i<rank; i++)
                {
                        if (current_dims[i] < dims[i])
                                current_dims[i] = dims[i];
                }
        }
        else
                for(i=0; i<rank; i++)
                        current_dims[i] = dims[i];
 
        F5LAsave_dimensions(f->Topology_hid, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, rank, current_dims);
        F5printf(30, "F5LTexpand_dataspace(,rank=%d,): expand dimensions of topology.", rank);
 
        for(i=0; i<rank; i++)
                dims[i] = current_dims[i];
 
        return 1;
}
 
 
 
hid_t   F5LTmake_enum_type(F5Path*fpath)
{
        if (!fpath) return 0;
        if (fpath->field_enum_type_hid<=0)
        {
                assert(fpath->ContentsGroup_hid);
                F5printf(30, " F5LTmake_enum_type() - save type.");
                fpath->field_enum_type_hid = F5Tsave_F5field_enum(fpath->ContentsGroup_hid);
                F5printf(30, " F5LTmake_enum_type() - DONE saving type.");
        }
        return fpath->field_enum_type_hid;
}
 
int     F5LTget_maximal_grid_refinement(hid_t ContentsGroup_id,
                                        const char*gridname,
                                        hsize_t*refinement)
{
hid_t   GridsTable     ;
hid_t   GridInfo       ;
int     Dims;
 
        if (!gridname || !refinement) return 0;
        GridsTable = F5Gappend(ContentsGroup_id, FIBER_CONTENT_GRIDS);
        GridInfo   = F5Gappend(GridsTable, gridname);
 
        Dims = F5LAget_dimensions(GridInfo, FIBER_HDF5_REFINEMENT_INFO, refinement );
 
        H5Gclose(GridsTable);
        H5Gclose(GridInfo);
        return Dims;
}
 
int     F5LTget_maximal_skeleton_refinement(hid_t ContentsGroup_id,
                                            const char*gridname,
                                            hsize_t*refinement,
                                            int IndexDepth,
                                            int Dimensionality)
{
hid_t   GridsTable     ;
hid_t   GridInfo       ;
int     Dims;
char    RefinementAttributeName[1024] = FIBER_HDF5_REFINEMENT_INFO;
 
        if (!gridname || !refinement) return 0;
        GridsTable = F5Gappend(ContentsGroup_id, FIBER_CONTENT_GRIDS);
        GridInfo   = F5Gappend(GridsTable, gridname);
 
        if (IndexDepth!=0) // if not vertices
        {
                snprintf(RefinementAttributeName, sizeof(RefinementAttributeName),
                         FIBER_HDF5_REFINEMENT_INFO "<%d>[%d]", IndexDepth, Dimensionality);
        }
 
        Dims = F5LAget_dimensions(GridInfo, RefinementAttributeName, refinement );
 
        H5Gclose(GridsTable);
        H5Gclose(GridInfo);
        return Dims;
}
 
 
int     F5LTset_maximal_grid_refinement(hid_t ContentsGroup_id,
                                        const char*gridname,
                                        int     IndexDepth,
                                        int     Dimensionality,
                                        const hsize_t*refinement)
{
hid_t   GridsTable     ;
hid_t   GridInfo       ;
hsize_t CurrentRefinement[ FIBER_MAX_RANK ];
int     CurrentDimensionality, i;
int     AllFine = 0;
char    RefinementAttributeName[1024] = FIBER_HDF5_REFINEMENT_INFO;
 
        F5printf(30, "int F5LTset_maximal_grid_refinement(F5Path*fpath,%s, %d, %p)\n", gridname, Dimensionality, refinement);
 
        if (!gridname)
        {
                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, Dimensionality, refinement); - NO GRIDNAME");
                return AllFine;
        }
        if (!refinement)
        {
                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, Dimensionality, refinement); - NO REFINEMENT");
                return AllFine;
        }
 
        GridsTable = F5Gappend(ContentsGroup_id, FIBER_CONTENT_GRIDS);
        GridInfo   = F5Gappend(GridsTable, gridname);
 
        if (IndexDepth!=0) // if not vertices
        {
                snprintf(RefinementAttributeName, sizeof(RefinementAttributeName),
                         FIBER_HDF5_REFINEMENT_INFO "<%d>[%d]", IndexDepth, Dimensionality);
        }
 
        CurrentDimensionality = F5LAget_dimensions(GridInfo, RefinementAttributeName, CurrentRefinement );
 
        if (CurrentDimensionality<1)
        {
                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, Dimensionality, refinement); - SAVE NEW %d",
                         (int)refinement[0] );
 
                F5LAsave_dimensions(GridInfo,  RefinementAttributeName, Dimensionality, refinement);
                AllFine = 1;
        }
        else
        {
                if (CurrentDimensionality==Dimensionality)
                {
                int     UpdateRefinement = 0;
 
                        for(i=0; i<CurrentDimensionality; i++)
                        {
                                if (CurrentRefinement[i] < refinement[i] )
                                {
                                        UpdateRefinement = 1;
                                        CurrentRefinement[i] = refinement[i];
                                }
                        }
 
                        if (UpdateRefinement)
                        {
                                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, Dimensionality, refinement); - UPDATE to %d",
                                         (int)CurrentRefinement[0] );
                                F5LAsave_dimensions(GridInfo,  RefinementAttributeName, Dimensionality, CurrentRefinement);
                        }
                        else
                        {
                                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname,   Dimensionality, refinement); - NO UPDATE REQUIRED for %d",
                                         (int)CurrentRefinement[0] );
                        }
                        AllFine = 1;
                }
                else
                {
                        F5printf(0, "int F5LTset_maximal_grid_refinement(F5Path*fpath,%s, %dD, []): New refinement dimensions do not match stored ones (stored: %dD) - NOT UPDATED\n",
                                 gridname, Dimensionality, CurrentDimensionality );
                }
        }
 
        H5Gclose(GridsTable);
        H5Gclose(GridInfo);
        return AllFine;
}
 
/*
  Create a Topology group on the lowest level,
  i.e. create an HDF5 group with some attributes.
 */
hid_t   F5LTcreate_topology(hid_t Grid_hid,
                            const char*TopologyName,
                            int IndexDepth,
                            int SkeletonDimensionality,
                            int DataspaceDimensionality,
                            const hsize_t*refinement)
{
        if (Grid_hid<=0)
        {
                F5printf(0, "F5LTcreate_topology() - invalid Grid HDF5 ID, file not open?");
                return -1;
        }
 
hid_t   Topology_hid = F5Gappend(Grid_hid,  TopologyName) ;
/*hid_t attr_id;
hid_t   space_id = H5Screate(H5S_SCALAR);
herr_t  status;
*/
        if (Topology_hid<0)
                return -2;
 
        assert(Topology_hid>0);
 
        F5printf(30, "F5LTcreate_topology(%s)<depth=%d>, rank=%d (using dataspace of rank %d)",
                 TopologyName, IndexDepth, SkeletonDimensionality, DataspaceDimensionality);
/*      printf( "F5LTcreate_topology(%s)<depth=%d>, rank=%d (using dataspace of rank %d)",
                 TopologyName, IndexDepth, SkeletonDimensionality, DataspaceDimensionality);
*/
 
        if (!F5Astore_integer(Topology_hid, FIBER_HDF5_INDEXDEPTH_ATTRIB, IndexDepth) )
        {
                F5printf(50, "Tried to re-create topology %s, ignored\n", TopologyName);
                puts("CANNOT save index depth");
                return Topology_hid;
        }
 
        if (!F5Astore_integer(Topology_hid, FIBER_HDF5_SKELETON_DIMENSIONALITY_ATTRIB, SkeletonDimensionality) )
        {
                F5printf(50, "Can't save dimensionality in %s, ignored\n", TopologyName);
                puts("CANNOT save dimensionality");
                return Topology_hid;
        }
 
        /* Dimensionality information  */
        if (DataspaceDimensionality>0)
        {
                if (!F5Asave_ints( Topology_hid, FIBER_HDF5_RANK_ATTRIBUTE, &DataspaceDimensionality, 1) )
                {
                        F5printf(3, "F5LTcreate_topology(%s)<depth=%d>, rank=%dD: CANNOT SAVE RANK - aborted, more info with F5_VERBOSITY=10 to 50"
                                 , TopologyName, IndexDepth, DataspaceDimensionality);
                        H5Gclose( Topology_hid );
                        return -1;
                }
        }
 
        if( SkeletonDimensionality > 0 && refinement )
        {
                if (1 != F5LAsave_dimensions(Topology_hid,  FIBER_HDF5_REFINEMENT_INFO, SkeletonDimensionality, refinement))
                {
                        F5printf(3, "F5LTcreate_topology(%s)<depth=%d>, rank=%dD: CANNOT SAVE REFINEMENT - aborted", TopologyName, IndexDepth, DataspaceDimensionality);
                        H5Gclose( Topology_hid );
                        return -1;
                }
        }
 
        F5printf(30, "~F5LTcreate_topology(%s)<depth=%d>, %dD", TopologyName, IndexDepth, DataspaceDimensionality);
        return Topology_hid;
}
 
/* F5B_new_global_cartesian_chart4D() */
 
/**\ingroup F5L
 The central F5Path constructor for write access:
 Creates the basic F5 structures in the file and sets up an
 F5Path object for subsequent use.
 Basically, all the information contained in an F5Path object can
 be created from the given parameters, however, some complexity
 arises when modifying some file that already has some structure.
 In such a case, it must re-use any found structures in a consistent
 way, especcially it has to use named types instead of intrinsic ones.
 */
F5Path* F5LTcreateV(hid_t File_id, const double*time,
                    const char*gridname,
                    ChartDomain_IDs*ChartDomain,
                    ChartDomain_IDs*coord_creator(void*udata),
                    void*udata,
                    const char*coordinate_system,
                    const char*TopologyName,
                    int IndexDepth, int SkeletonDimensionality,
                    int Dimensionality,
                    const hsize_t*refinement)
{
F5Path* f = NULL;
        if (File_id<0)
        {
                F5printf(1, "F5LTcreateV(): Invalid File!");
                return NULL;
        }
 
        F5printf(30, "**F5LTcreateV(grid=`%s', topology=`%s')<%d>, Repr=%dD, [%s] %s %s",
                 gridname, TopologyName, IndexDepth, Dimensionality, coordinate_system,
                 ChartDomain?" Chart Domain given":"No chart Domain",
                 coord_creator?" Coordinate Creator available":" No Coordinate Creator" );
 
        if (!gridname || !gridname[0])
        {
                return NULL;
        }
 
        /*
          Should this be relaxed to allow zero dimensionality or negative?
          What would this mean for refinements?
 
          YES - because we need zero dimensionality to identify particle sets.
         */
        if (Dimensionality<0)
        {
                F5printf(0, "**F5LTcreateV(grid=`%s', topology=`%s')<%d>, %dD, [%s] - CANNOT create skeleton entry because dimensionality is lesser than zero!",
                         gridname, TopologyName, IndexDepth, Dimensionality, coordinate_system);
                return NULL;
        }
 
        F5printf_indent++;
 
        /* Create an empty F5Path structure */
        f = newF5Path(File_id);
 
        assert(coordinate_system);
 
        /* Initialize contents property */
        f->ContentsGroup_hid = F5I_create_contents(File_id);
        assert(f->ContentsGroup_hid>0);
        F5printf(40, "F5LTcreateV():  Contents group is %d\n", (int)(f->ContentsGroup_hid) );
 
        f->field_enum_type_hid = 0;
 
        /* Prepare time slice group:
           /T=1.0/
        */
        /** @todo Extend slice group creation to parameter spaces */
        f->Slice_hid   = F5Bappend_slice(File_id, time);
        assert(f->Slice_hid>0);
 
/* create the neccessary groups for appending the data to the dataset */
 
        F5printf(30, "F5LTcreate(): append gridname `%s'\n", gridname);
        /*     /T=1.0/Gridname/            */
        f->Grid_hid             = F5Gappend(f->Slice_hid,  gridname);
        /*     /T=1.0/Gridname/Charts/     */
        f->Charts_hid           = F5Gappend(f->Grid_hid,  FIBER_HDF5_CHARTS_PER_GRID);
 
        /* register grid for reverse indexing ("on which time steps does this grid exist"?)
           @todo Extend grid registration to parameter spaces.
         */
        F5I_add_grid(f, gridname, time);
 
        /*  register the given coordinate system per grid
             /T=1.0/Gridname/Charts/Cartesian/
            This is required such that we know which coordinate system exist
            on this grid at all, therefore allowing a reading facility to request
            a coordinate representation in one of those coordinate systems. It makes
            no sense to request a representation in a coordinate system that is not
            listed with a grid, because there will be no transformation information
            available at all for this coordinate system. On the other hand, the
            information which charts are possible cannot be stored with each
            representation, because it is totally valid for a topology group to
            have no representation in a transformable grid. Instead, this
            transformation information is usually stored with the charts per grid
            and may be employed for all topology groups - for procedural transformation.
            In the case of numerical transformation rules, the transformation
            matrices have to be stored explicitely with each topology.
            Examples:
            /T=1.0/Gridname/Charts/CartesianChart/
            /T=1.0/Gridname/Charts/PolarChart/
            /T=1.0/Gridname/Points/PolarChart/Positions/
            allows to request
            /T=1.0/Gridname/Points/CartesianChart/Positions/
            although there is not yet such a representation in the file.
            In this case, the intrinsic polar->cartesian coordinate transformation
            rule is used. If there is an entry
            /T=1.0/Gridname/Charts/PolarChart/CartesianChart/
            then this group may contain more specific information on how to transform
            from polar to cartesian coordinates, e.g. specifying some angle of the
            polar axis, some offset of the polar coordinate origin, some mapping of
            the angles etc.
        */
        if (ChartDomain) // only add true coordinate systems to the list of charts
                f->Chart_hid = F5Gappend(f->Charts_hid, coordinate_system) ;
        else
                f->Chart_hid = 0;
 
        /* Create a topology group under for the certain grid:
             /T=1.0/Gridname/TopologyName
        */
        f->Topology_hid         = F5LTcreate_topology(f->Grid_hid,
                                                      TopologyName,
                                                      IndexDepth, SkeletonDimensionality,
                                                      Dimensionality,
                                                      refinement);
 
        if (f->Topology_hid<0)
        {
                F5printf(0, "**F5LTcreateV(grid=`%s', topology=`%s')<%d>, %dD, [%s] Could not create Skeleton, different dataspace properties found in file, use F5_VERBOSITY=3 for more details.",
                         gridname, TopologyName, IndexDepth, Dimensionality, coordinate_system);
                H5Gclose(f->Slice_hid );
                H5Gclose(f->Grid_hid );
                H5Gclose(f->Charts_hid );
                if (f->Chart_hid) H5Gclose(f->Chart_hid );
                deleteF5Path(f);
                return NULL;
        }
 
        F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, IndexDepth, SkeletonDimensionality, refinement);
 
        assert(coordinate_system);
        /* Create a representation group under for the certain grid:
             /T=1.0/Gridname/TopologyName/RepresentationName
        */
        f->Representation_hid   = F5Gappend(f->Topology_hid,  coordinate_system);
 
        /* preparing chart */
        f->GlobalChart_hid = F5Gappend(File_id, FIBER_HDF5_GLOBAL_CHARTS) ;
 
        /**
        @param ChartDomain
           If a chartdomain is given, i.e. it is used already or stems from
           another file opening, then we reuse this chart domain, otherwise
           a new one will be created. The ChartDomain describes all types
           of the fields in the respective representation group as they
           are transient in memory. It will become the F5Path's `myChart'
           member. Specifying the ChartDomain is optional: if it is not
           given, then the coord_creator() callback function will be
           used to create a new coordinate object.
 
           Note that F5LTcreateV() is more general in this respect than
           F5LTcreate() and F5LTcreateT(): Via the callback function, it
           allows to create an arbitrary subset of types for the chart domain,
           whereas F5LTcreate() always assumes that the representation domain
           is a coordinate system and creates the point, vector, covector
           and subsequent types for the tangential space. F5LTcreateT(),
           in contrast, does not create any tangential types (they are set
           to -1 in the ChartDomain), but only the point type, thus is
           more suitable for topological representations (cells referring
           to points, points to refined points, ...).
        */
        if (ChartDomain)
        {
                F5printf(31, " increment chart domain references");
                f->myChart = ChartDomain;
                f->myChart->refs++;
        }
        else if (coord_creator)
        {
                assert(udata);
                F5printf(31, " using new coordinate creator");
                f->myChart = coord_creator(udata);
 
                if (f->myChart)
                {
                        f->Chart_hid = F5Gappend(f->Charts_hid, coordinate_system);
                        F5printf(31, " append %s\n", coordinate_system);
                }
                else
                        F5printf(0, " no chart created, coordinate_system is %s", coordinate_system);
        }
        else
        {
                F5printf(1, "F5 On Grid [%s] creating a Topological Skeleton [%s] without coordinates and no chart domain [%s], this might be a relative representation.",
                         gridname, TopologyName,  coordinate_system);
                f->myChart = 0;
        }
 
        if (f->myChart && f->Chart_hid)
        {
        hid_t   Domain_hid;
        hid_t   GlobalChartAnchor_hid;
 
        char    chart_anchor[1024] = "/" FIBER_HDF5_GLOBAL_CHARTS "/";
                strcat(chart_anchor, f->myChart->domain_name);
                strcat(chart_anchor,"/");
                strcat(chart_anchor, coordinate_system);
 
        /* Creates an entry in the "global charts" group for all cartesian charts,
           this is the place to store the named types of cartesian charts.
 
 
        NOTE: This coordinate/chart reference stuff is planned to be replaced by shared
              types. This revision will work without links.
        */
                Domain_hid = F5Gtry_to_open(f->GlobalChart_hid, f->myChart->domain_name);
                if (Domain_hid>0)
                {
                        f->FileIDs = F5FB_read_global_chart(f);
 
                        if (coordinate_system && F5Gexist(Domain_hid, coordinate_system) )
                        {
                                F5printf(10,"F5LTcreate(): Coordinate system %s already exists in domain %s, read global chart ID's...",
                                         coordinate_system, f->myChart->domain_name);
 
                                /* still link from the local chart to the global chart */
                                F5Glink(f->Chart_hid, H5G_LINK_SOFT, chart_anchor, FIBER_HDF5_CHART_TO_GLOBALCHART_REF ) ;
                                H5Gclose(Domain_hid);
                                F5printf(10,"~F5LTcreate() got data from file.");
                                F5printf_indent--;
                                return f;
                        }
                }
                else
                {
                        F5printf(10,"F5LTcreate(): Coordinate domain not found, creating file entry.");
 
                        /* Create an entry in the group of all (cartesian) charts for this specific coordinate system */
                        Domain_hid = H5Gcreate2(f->GlobalChart_hid, f->myChart->domain_name,
                                                H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
                        /* save relevant information (named HDF5 types) for cartesian charts */
                        f->FileIDs = F5B_save_global_chart(f->myChart, Domain_hid);
 
                        F5printf(10,"F5LTcreate(): Coordinate domain not found, creating file entry. Done!");
                }
                GlobalChartAnchor_hid = H5Gcreate2(Domain_hid, coordinate_system,
                                                   H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
                H5Gclose(Domain_hid);
 
                /* TODO: Check if these links already exist, if they are consistent,
                   and create them ONLY if they are required to make new.
                */
 
                /* a link from the local chart to the global chart */
                F5Glink(f->Chart_hid, H5G_LINK_SOFT, chart_anchor, FIBER_HDF5_CHART_TO_GLOBALCHART_REF ) ;
 
                strcpy(chart_anchor, "/" FIBER_HDF5_GLOBAL_CHARTS "/");
                strcat(chart_anchor, f->myChart->domain_name);
 
                H5E_BEGIN_TRY
                /* a link from the global chart to the coordinate type (cartesian coordinates) */
                F5Glink(GlobalChartAnchor_hid, H5G_LINK_HARD,
                        chart_anchor,
                        FIBER_HDF5_GLOBALCHART_COORDINATES );
                H5E_END_TRY
 
                H5Gclose(GlobalChartAnchor_hid);
        }
        else
        {
                F5printf(1, "F5 Creating a Topological %d-dimensional Skeleton of Index Depth=%d, "
                         "Info - No chart used for %s, seems to be a relative representation in [%s]"
                         , Dimensionality, IndexDepth
                         , TopologyName, coordinate_system);
        }
 
        if (f)  F5LTmake_enum_type(f);
 
        F5printf(30, "~F5LTcreate(%s)<%d>, %dD, [%s]", TopologyName, IndexDepth, Dimensionality, coordinate_system);
 
        F5printf_indent--;
 
        return f;
}
 
 
 
static  ChartDomain_IDs*coord_domain_creator(void*udata)
{
ChartDomain_IDs* (*coord_creator)() = (ChartDomain_IDs*(*)() )udata;
        assert( coord_creator );
        return coord_creator();
}
 
 
 
/**\ingroup F5L
  Create a Topology of the given name with a representation in
  the certain coordinate system.
  If the ChartDomain has not been set yet, then
  the types in the newly created chart domain (F5Path->myChart) will
  contain valid types for the Points and tangential types,
  as they are created by the specified coord_creator().
  Note that the coord_create() specifies the \em type of the
  coordinate system, while the coordinate_system parameter specifies
  the actual object that is of this respective type.
 */
F5Path* F5LTcreate(hid_t File_id, const double*time,
                   const char*gridname,
                   ChartDomain_IDs*ChartDomain,
                   ChartDomain_IDs*coord_creator(),
                   const char*coordinate_system,
                   const char*TopologyName,
                   int IndexDepth, int SkeletonDimensionality,
                   int Dimensionality,
                   const hsize_t*refinement)
{
ChartDomain_IDs*(*TheCoordCreator)(void*) = 0;
/*ChartDomain_IDs*TheCoordCreator = 0; */
 
        F5printf(30,"F5LTcreate(%s)\n", TopologyName);
 
        if (coord_creator)
                TheCoordCreator = coord_domain_creator; /* local function that calls coord_creator() */
 
        return F5LTcreateV(File_id, time, gridname,
                           ChartDomain,
                           TheCoordCreator,     /* local function that calls coord_creator() */
                           (void*)coord_creator,                /* user data */
                           coordinate_system,
                           TopologyName,
                           IndexDepth, SkeletonDimensionality,
                           Dimensionality,
                           refinement);
}