F5surface.c

Go to the documentation of this file.

#include "F5surface.h"
#include "F5B.h"
#include "F5R.h"
#include "F5X.h"
#include "F5defs.h"
#include "F5Bchart.h"
#include "F5private.h"
 
void    F5closeVC( F5Vertices_and_Connectivity_t*VC )
{
        if (VC)
        {
                F5Fclose( VC->Vertices );
                VC->Vertices = NULL;
 
                F5Fclose( VC->Cells );
                VC->Cells = NULL;
        }
}
 
 
 
F5Path*F5write_triangular_surface(hid_t file_id, double time,
                                 const char*name,
                                 const F5_vec3_point_t*Coords, int nCoords,
                                 const F5_triangle_t*Triangles, int nTriangles)
{
        return  F5Cwrite_triangular_surface(file_id, time,
                                            name,
                                            Coords, nCoords,
                                            Triangles, nTriangles,
                                            FIBER_HDF5_DEFAULT_CHART);
}
 
F5Vertices_and_Connectivity_t
        F5write_triangular_surface_vc(hid_t file_id, double time,
                                      const char*name,
                                      const F5_vec3_point_t*Coords, int nCoords,
                                      const F5_triangle_t*Triangles, int nTriangles)
{
        return  F5Cwrite_triangular_surface_vc(file_id, time,
                                               name,
                                               Coords, nCoords,
                                               Triangles, nTriangles,
                                               FIBER_HDF5_DEFAULT_CHART);
}
 
 
F5Path*F5Cwrite_triangular_surface(hid_t File_id, double time,
                                   const char*gridname,
                                   const F5_vec3_point_t*Coords, int nCoords,
                                   const F5_triangle_t*Triangles, int nTriangles,
                                   const char*coordinate_system)
 
{
F5Vertices_and_Connectivity_t
        VC = F5Cwrite_triangular_surface_vc(File_id, time,
                                            gridname,
                                            Coords, nCoords,
                                            Triangles, nTriangles,
                                            coordinate_system);
 
        F5Fclose( VC.Cells );
 
        return  VC.Vertices;
}
 
F5Vertices_and_Connectivity_t
        F5Cwrite_triangular_surface_vc(hid_t File_id, double time,
                                       const char*gridname,
                                       const F5_vec3_point_t*Coords, int nCoords,
                                       const F5_triangle_t*Triangles, int nTriangles,
                                       const char*coordinate_system)
 
{
F5Vertices_and_Connectivity_t VC;
 
        VC.Cells = 0;
        VC.Vertices = F5Rcreate_cartesian_nD(File_id, time, gridname, 2, coordinate_system);
        if (!VC.Vertices)
                return VC;
 
        /* write points for the Triangles */
        F5Fwrite_1D(VC.Vertices, FIBER_HDF5_POSITIONS_STRING, nCoords,
                    VC.Vertices->FileIDs->SinglePrecision.Point_hid_t, F5T_COORD3_FLOAT,
                    Coords, F5P_DEFAULT);
 
        VC.Cells = F5Rcreate_triangles_as_vertices_topology(File_id, time, gridname);
 
        F5Fwrite_1D(VC.Cells, FIBER_HDF5_POSITIONS_STRING, nTriangles,
                    F5T_TRIANGLE32, F5T_TRIANGLE32,
                    Triangles, F5P_DEFAULT);
 
        return  VC;
}
 
 
 
 
F5Path*F5Flink_triangular_surface(F5Path*target, double time,
                                  const char*gridname,
                                  const F5_vec3_point_t*Coords, int nCoords,
                                  const F5_triangle_t*Triangles, int nTriangles,
                                  const char*coordinate_system)
 
{
F5Path*Cells=0;
F5Path*Vertices = F5Rcreate_cartesian_nD(target->File_hid, time, gridname, 2, coordinate_system);
        if (!Vertices)
                return Vertices;
 
        if (!Coords)
        {
                H5Glink2( target->Representation_hid,  FIBER_HDF5_POSITIONS_STRING,
                          H5G_LINK_HARD,
                          Vertices->Representation_hid,  FIBER_HDF5_POSITIONS_STRING );
        }
        else
        {
                /* write points for the Triangles */
                F5Fwrite_1D(Vertices, FIBER_HDF5_POSITIONS_STRING, nCoords,
                            Vertices->FileIDs->SinglePrecision.Point_hid_t, F5T_COORD3_FLOAT,
                            Coords, F5P_DEFAULT);
        }
 
        Cells = F5Rcreate_triangles_as_vertices_topology(target->File_hid, time, gridname);
 
        if (!Triangles)
        {
                /* TODO: check for errors here! The target ID might not
                   exist at all, and this might indicate that the target
                   is not a triangular surface at all, and that we must not
                   do what we're doing here anyway!! */
 
        hid_t Connectivity = H5Gopen2( target->Grid_hid, FIBER_HDF5_FACES, H5P_DEFAULT );
        hid_t AsVertices = H5Gopen2( Connectivity, FIBER_HDF5_POINTS, H5P_DEFAULT );
                H5Glink2( AsVertices,  FIBER_HDF5_POSITIONS_STRING,
                          H5G_LINK_HARD,
                          Cells->Representation_hid,  FIBER_HDF5_POSITIONS_STRING );
        }
        else
        {
                F5Fwrite_1D(Cells, FIBER_HDF5_POSITIONS_STRING, nTriangles,
                           F5T_TRIANGLE32, F5T_TRIANGLE32,
                           Triangles, F5P_DEFAULT);
        }
 
        F5Fclose( Cells );
 
        return Vertices;
}
 
 
void F5write_regular_surface(hid_t file_id, double time,
                                 const char*name,
                                 const F5_vec3_point_t*Coords, int Xdims, int Ydims
                                 )
{
        F5Cwrite_regular_surface(file_id, time,
                                 name,
                                 Coords, Xdims, Ydims,
                                 FIBER_HDF5_DEFAULT_CHART);
 
}
 
 
void F5Cwrite_regular_surface(hid_t File_id, double time,
                              const char*gridname,
                              const F5_vec3_point_t*Coords, int Xdims, int Ydims,
                              const char*coordinate_system)
{
F5Path*f = F5Rcreate_cartesian_nD(File_id, time, gridname, 2, coordinate_system);
 
        /* write the data into the dataset */
        {
        /* write points for the regular
           TODO: --- Use F5Fwrite() here ---!!
         */
 
        hsize_t dims[2];
                dims[0] = Ydims;  /* (or vice versa, check!) */
                dims[1] = Xdims;
        {
        hid_t coord_ds = H5Screate_simple(2, dims, NULL);
        hid_t creator_hid = H5Pcreate(H5P_DATASET_CREATE);
        hid_t   id = F5Dappend(f->Representation_hid, FIBER_HDF5_POSITIONS_STRING,
                               f->FileIDs->SinglePrecision.Point_hid_t, coord_ds, creator_hid);
                H5Dwrite(id, f->FileIDs->SinglePrecision.Point_hid_t, H5S_ALL, H5S_ALL, H5P_DEFAULT, Coords);
                H5Dclose(id);
                H5Sclose(coord_ds);
                H5Pclose(creator_hid);
        }}
 
        F5I_add_field(f, FIBER_HDF5_POSITIONS_STRING);
 
        F5close(f);
}