LoadField.hpp

#ifndef __FIBER_HDF5_LOADFIELD_HPP
#define __FIBER_HDF5_LOADFIELD_HPP
 
 
#include <bundle/Bundle.hpp>
#include <F5/F5F.h>
#include "H5Group.hpp"
#include <cstring>
#include <eagle/PhysicalSpace.hpp>
#include <F5/F5private.h>
#include <F5/F5iterate.h>
 
#include <field/FragmentAttributeNames.hpp>
#include "FileNameInterface.hpp"
#include "PrecisionTransformation.hpp"
 
namespace Fiber
{
 
 
//void readOriginalType( RefPtr< CreativeArrayBase >& cab, F5Path*f );
 
void readGhostSizes( RefPtr< CreativeArrayBase >& cab, F5Path*f, const char*fragmentname = "" );
 
#if 0
template <class T>
void readRange(RefPtr< CreativeArrayBase >& cab, F5Path*f, hid_t F5type, const char*fragmentname = "")
{
T minmax[2];
bool exist = false;
 
        if (strlen(fragmentname) > 0)
//              exist = F5Fget_range( f, fragmentname, minmax );
        else
//              exist = F5Fget_range( f, NULL, minmax );
 
        if (exist)
        {
        MemVector<T> RangeAttrib(2);
                RangeAttrib[0] = minmax[0];
                RangeAttrib[1] = minmax[1];
 
                cab->setAttribute( FIBER_FIELD_COMPONENT_RANGE, RangeAttrib );
        }
}
 
template <class T>
void readBoundingBox(RefPtr< CreativeArrayBase >& cab, F5Path*f, hid_t F5type, const char*fragmentname = "")
{
T minmax[2];
bool exist = false;
 
        if (strlen(fragmentname) > 0)
//              exist = F5Fget_range( f, fragmentname, minmax );
        else
//              exist = F5Fget_range( f, NULL, minmax );
 
        if (exist)
        {
                F5printf(1,"Fragment Range: [%.8f,%.8f,%.8f]-[%.8f,%.8f,%.8f]",
                         minmax[0].x, minmax[0].y, minmax[0].z,
                         minmax[1].x, minmax[1].y, minmax[1].z);
 
        MemVector<Eagle::point3> RangeAttrib(2);
                RangeAttrib[0].x() = minmax[0].x;
                RangeAttrib[0].y() = minmax[0].y;
                RangeAttrib[0].z() = minmax[0].z;
 
                RangeAttrib[1].x() = minmax[1].x;
                RangeAttrib[1].y() = minmax[1].y;
                RangeAttrib[1].z() = minmax[1].z;
 
                cab->setAttribute( FIBER_FIELD_COMPONENT_RANGE, RangeAttrib );
 
                /* Note: ideally want to do
 
                   FragmentedFieldCreator->addInterface( new BoundingBox() );
 
                   but can't do this because class bounding box is part
                   of another library family (ocean/) which is not available in fiber/ .
                 */
        }
 
T minmax_ghost[2];
 
        if (strlen(fragmentname) > 0 && F5Fget_fragment_range_ghost2(f, fragmentname, minmax_ghost) )
        {
                F5printf(1,"Fragment Range Ghost: [%.8f,%.8f,%.8f]-[%.8f,%.8f,%.8f]",
                                minmax_ghost[0].x, minmax_ghost[0].y, minmax_ghost[0].z,
                                minmax_ghost[1].x, minmax_ghost[1].y, minmax_ghost[1].z);
 
        MemVector<Eagle::point3> RangeAttribGhost(2);
                RangeAttribGhost[0].x() = minmax_ghost[0].x;
                RangeAttribGhost[0].y() = minmax_ghost[0].y;
                RangeAttribGhost[0].z() = minmax_ghost[0].z;
 
                RangeAttribGhost[1].x() = minmax_ghost[1].x;
                RangeAttribGhost[1].y() = minmax_ghost[1].y;
                RangeAttribGhost[1].z() = minmax_ghost[1].z;
 
                cab->setAttribute( AttributeNames::Fragment::GhostRange, RangeAttribGhost );
        }
}
#endif
 
 
void readDictionary(const RefPtr< CreativeArrayBase >& cab, F5Path*f, const char*fragmentname = "" );
 
 
template <int Dims>
bool    saveDimensions(MultiIndex<Dims>&dims, F5Path*field, const char*attribute_name, hid_t id)
{
hsize_t extension[FIBER_MAX_RANK];
 
        for(int i=0;i<Dims;i++)
                extension[i] = dims[i];
 
        F5Tpermute_dimensions(field, Dims, extension, extension);
 
        if (F5LAsave_dimensions(id, attribute_name, Dims, extension) != Dims)
                return false;
 
        return true;
}
 
RefPtr<SizeInterface> loadFieldSize(F5Path*field);
 
 
RefPtr<Field> ContiguousField(F5Path*field,
                              const RefPtr<FragmentIDCollection>&theFragmentIDCollection,
                              const char*RepresentationName,
                              const RefPtr<FiberIO::HDF5::FileNameInterface>&RepresentationFilePath,
                              const string&fieldname,
                              Grid&theGrid,
                              const FiberIO::HDF5::PrecisionTransformation&PT,
                              const RefPtr<LoaderProgress>&TheLoaderProgressor,
                              const WeakPtr<StorageTransformations::IOPerformance>&theLoadPerformance);
 
RefPtr<Field> UniformField(F5Path*field,
                           const RefPtr<FragmentIDCollection>&theFragmentIDCollection,
                           const RefPtr<LoaderProgress>&TheLoaderProgressor);
 
 
 
} // Fiber namespace
 
 
#endif // __FIBER_HDF5_LOADFIELD_HPP