F5F.h

/*
//
// $Id: F5F.h,v 1.42 2008/03/19 21:21:43 werner Exp $
//
*/

#ifndef __F5F_H
#define __F5F_H

#include <F5/F5L.h>
#include <F5/F5Bchart.h>
#include <F5/F5Path.h>

#ifdef  __cplusplus
extern "C"
{
#endif

F5_API int F5Fset_metric_unit_description(F5Path*f, const char*unit);
        
F5_API int F5Fis_group(const F5Path*);

F5_API int F5LTset_dataspace(F5Path*f, int rank, hsize_t*dims);

F5_API int F5LTexpand_dataspace(F5Path*f, int rank, hsize_t*dims);

F5_API int F5Fexpand_dataspace(F5Path*fpath, int rank, hsize_t*Dims);

F5_API hid_t F5file_type(F5Path*fpath, hid_t fieldtype);


F5_API void F5close(F5Path*f);
F5_API void F5closep(F5Path**f);

F5_API int F5Fopen(F5Path*f, const char*fieldname);

F5_API F5Path*F5FopenMostRecentSlice(hid_t File_id, double*t,
                                     const char*gridname,
                                     const char*fieldname,
                                     const char*coordinate_system); 
        
F5_API void F5Fclose(F5Path*f);

F5_API hid_t F5Fgrab(F5Path*f);
        

F5_API hid_t F5Fget_type(F5Path*f);

F5_API hid_t F5Tget_space(F5Path*f);

F5_API hsize_t*F5Tpermute_dimensions(F5Path*fpath,
                                     int rank,
                                     hsize_t*target_dims,
                                     const hsize_t*source_dims);        

F5_API int F5Tget_extent(F5Path*f, hsize_t*dims, int maxDims);

F5_API int F5Tget_index_depth(F5Path*f, int*result);

F5_API int F5LTget_skeleton_dimensionality(hid_t Top_hid);

F5_API int F5Tget_refinement_level(F5Path*f, hsize_t*dims, int maxDims);

F5_API int F5Fget_range(F5Path*f, void*min, void*max, hid_t memtype_id);

F5_API int F5Fset_range(F5Path*f, const void*min, const void*max);

F5_API int F5Fset_fragment_range(F5Path*f, const char*fragment_name, const void*min, const void*max);
F5_API int F5Fget_fragment_range(F5Path*f, const char*fragment_name, void*min, void*max, hid_t mem_type_id);
        
F5_API int F5Fget_average(F5Path*f,       void*avg); 
F5_API int F5Fset_average(F5Path*f, const void*avg);

F5_API int F5Fget_deviation(F5Path*f,       void*dev); 
F5_API int F5Fset_deviation(F5Path*f, const void*dev);

F5_API int F5Fcreate(F5Path*fpath, const char*fieldname, int dimension, hsize_t*dims,
                     hid_t fieldtype, hid_t property_id);

enum F5ErrorCode_type
{
        F5_SUCCESS       = 0,

        F5ERROR_INVALID_FPATH = -1,

        F5ERROR_INCONSISTENT_DATASPACE = -2,

        F5ERROR_ALREADY_EXISTS = -10,
        
        F5ERROR_COMPOUND_EXPECTED     = -30,
        F5ERROR_COMPONENTMAP_EXPECTED = -31,
        F5ERROR_COMPONENTMAP_INVALID  = -32,
        
        F5ERROR_NONSPECIFIED = -100
};

typedef enum F5ErrorCode_type F5ErrorCode;

F5_API const char*F5Fwhatsup(F5ErrorCode);


F5_API F5ErrorCode F5Fwrite(F5Path*fpath, const char*fieldname,
                            int dimension, hsize_t*dims,
                            hid_t fieldtype, hid_t memtype, const void * dataPtr,
                            hid_t property_id);

F5_API F5ErrorCode F5FwriteIMAGE(F5Path*fpath, const char*fieldname,
                                 int dimension, hsize_t*dims,
                                 hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                 hid_t property_id);
        
F5_API F5ErrorCode F5Fwrite_1D(F5Path*fpath, const char*fieldname,
                               hsize_t nElements, hid_t fieldtype, hid_t memtype,
                               const void *dataPtr, hid_t property_id);

F5_API int F5Fwrites(F5Path*fpath, const char*fieldname,
                     int dimension, hsize_t*dims,
                     hid_t fieldtype, hid_t memtype, const void ** dataPtr,
                     hid_t property_id);

F5_API F5ErrorCode F5FwriteX(F5Path*fpath, const char*fieldname,
                             int rank, const hsize_t dims[],
                             hid_t fieldtype, hid_t memtype, 
                             const void *const dataPtr[], const int polynom_order[],
                             const int component_map[],
                             hid_t property_id);


F5_API void F5FevalX(double*result, int Mrank, const int index[],
                     int components, const double*const polynomials[], const int polynom_order[],
                     const int component_map[]);
        

F5_API int F5Fwrite_linear(F5Path*fpath, const char*fieldname,
                           int dimension, hsize_t*dims,
                           hid_t fieldtype, const void * base, const void*delta);


F5_API int F5Fwrite_fraction(F5Path*fpath, const char*fieldname,
                             int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                             hid_t fieldtype, hid_t memtype, const void * dataPtr,
                             const hsize_t*datastart,
                             const hsize_t*start_border, const hsize_t*end_border,
                             const char*fraction_name, hid_t property_id);
        
F5_API int F5FSwrite_fraction(F5Path*fpath, const char*fieldname,
                              int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                              hid_t fieldtype, hid_t memtype, const void *const* dataPtr,
                              const hsize_t*datastart, 
                              const hsize_t*start_border, const hsize_t*end_border,
                              const char*fraction_name, hid_t property_id,
                              int AllowFullCoverage);

F5_API int F5Fwrite_linear_fraction(F5Path*fpath, const char*fieldname,
                                    int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                                    hid_t fieldtype, const void * base, const void*delta,
                                    const hsize_t*datastart, 
                                    const char*fraction_name);
F5_API ArrayType F5Fget_field_enum(const F5Path*fpath, const char*fieldname,
                                   int*major_version, int*minor_version, int*release_version);
        
F5_API int F5Fis_linear(F5Path*fpath, const char*fieldname);

F5_API int F5Fis_fragmented(F5Path*fpath, const char*fieldname);
F5_API int F5Fis_separatedcompound(F5Path*fpath, const char*fieldname);

F5_API int F5Fread_linear(F5Path*fpath,
                          hsize_t*dims,
                          hid_t fieldtype, void * base, void*delta);

F5_API int F5Fread_linearo(F5Path*fpath, const char*fieldname,
                          hsize_t*dims,
                          hid_t fieldtype, void * base, void*delta);

        
#ifdef  __cplusplus
}    /* extern "C" */

/* Experimental optional header-only C++ interface */
#ifdef  ENABLE_F5_CPLUSPLUS
namespace F5
{

class   Path
{
        struct  pcnt
        {
                int     refs;
                F5Path*fpath;
        };

        pcnt*p;

public:
        F5Path*fpath()
        {
                if (p) return p->fpath;
                return 0;
        }

        Path()
        : p(0)
        {}

        Path(const Path&P)
        : p(P.p)
        {
                if (p) p->refs++;
        }

        ~Path()
        {
                if (!p) return;
                p->refs--;
                if (p->refs<1)
                        F5close(p->fpath);
        }
};

struct  Timeslice : Path
{};

struct  Grid : Timeslice
{};

struct  Topology : Grid
{
        hid_t   get_space()
        {
                return F5Tget_space(fpath());
        }
};

struct  Field;

struct  Representation : Topology
{
        Field open(const char*fieldname);

        int write(const char*fieldname,
                     int dimension, hsize_t*dims,
                     hid_t fieldtype, hid_t memtype, const void * dataPtr,
                     hid_t property_id = F5P_DEFAULT)
        {
                return F5Fwrite(fpath(), fieldname,
                                dimension, dims,
                                fieldtype, memtype, dataPtr,
                                property_id);
        }
        
        int write1D(const char*fieldname,
                    hsize_t nElements, hid_t fieldtype, hid_t memtype,
                    const void *dataPtr, hid_t property_id = F5P_DEFAULT)
        {
                return F5Fwrite1D(fpath(), fieldname,
                              nElements, fieldtype, memtype,
                              dataPtr, property_id);
        }

        int writes(const char*fieldname,
                                int dimension, hsize_t*dims,
                                hid_t fieldtype, hid_t memtype, const void ** dataPtr,
                                hid_t property_id)
        {
                return F5Fwrites(fpath(), fieldname,
                                dimension, dims,
                                fieldtype, memtype, dataPtr,
                                property_id);
        }

        int write_linear(const char*fieldname,
                                   int dimension, hsize_t*dims,
                                   hid_t fieldtype, const void * base, const void*delta)
        {
                return F5Fwrite_linear(fpath(), fieldname,
                                   dimension, dims,
                                   fieldtype, base, delta);

        }

        int write_fraction(const char*fieldname,
                                     int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                                     hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                     const hsize_t*datastart, 
                                     const hsize_t*start_border, const hsize_t*end_border,
                                     const char*fraction_name, hid_t property_id)
        {
                return F5Fwrite_fraction(fpath(), fieldname,
                                     rank, full_dims, fragment_dims,
                                     fieldtype, memtype, dataPtr,
                                     datastart, 
                                     start_border, end_border,
                                     fraction_name, property_id);
        }

        int Swrite_fraction(const char*fieldname,
                                      int rank, const hsize_t*full_dims, const hsize_t*fragment_dims,
                                      hid_t fieldtype, hid_t memtype, const void ** dataPtr,
                                      const hsize_t*datastart, 
                                      const hsize_t*start_border, const hsize_t*end_border,
                                      const char*fraction_name, hid_t property_id)
        {

                return F5FSwrite_fraction(fpath(), fieldname,
                                      rank, full_dims, fragment_dims,
                                      fieldtype, memtype, dataPtr,
                                      datastart, 
                                      start_border, end_border,
                                      fraction_name, hid_t property_id);
        }

        int write_linear_fraction(const char*fieldname,
                                            int rank, const hsize_t*dims, const hsize_t*fragment_dims,
                                            hid_t fieldtype, const void * base, const void*delta,
                                            const hsize_t*datastart, 
                                            const char*fraction_name)
        {
                return F5Fwrite_linear_fraction(fpath(), fieldname,
                                            rank, dims, fragment_dims,
                                            fieldtype, base, delta,
                                            datastart, 
                                            fraction_name);
        }
};

struct  Field : Representation
{
        hid_t get_type() const
        {
                return F5Fget_type(fpath());
        }
};


inline  Field Representation::open(const char*fieldname)
{
        F5Fopen(fpath(), fieldname);
        return Field(*this);
}


}
#endif /* ENABLE_F5_CPLUSPLUS */

#endif

#endif  /* __F5F_H */