LoadField.hpp

#ifndef __FIBER_HDF5_LOADFIELD_HPP
#define __FIBER_HDF5_LOADFIELD_HPP


#include <bundle/Bundle.hpp>
#include <F5/F5F.h>

namespace Fiber
{

template <int Dims>
bool getDimensions(MultiIndex<Dims>&dims, F5Path*field, const char*attribute_name, hid_t id)
{
hsize_t extension[FIBER_MAX_RANK]; 
        if (!F5LAget_dimensions(id, attribute_name, extension) == Dims)
                return false;

        F5Tpermute_dimensions(field, Dims, extension, extension); 

        for(int i=0;i<Dims;i++)
                dims[i] += extension[i]; 

        return true;
}


template <int N>
struct GetFragmentInterfaces
{
static void setup(RefPtr<FragmentID>&FID, hsize_t dims[FIBER_MAX_RANK], F5Path*field, hid_t frag_id)
        {
        MultiIndex<N>   FragmentSize;
                for(int i=0; i<N; i++)
                        FragmentSize[i] = dims[i];

                FID->addInterface( new SizeInterface( FragmentSize ) ); 

        RefPtr<FragmentLocation<N> > F3 = new FragmentLocation<N>(); 
                if (getDimensions( F3->Offset      , field, FIBER_FRAGMENT_OFFSET_ATTRIBUTE         , frag_id )
                    ||
                    getDimensions( F3->OverlapStart, field, FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, frag_id )
                    ||
                    getDimensions( F3->OverlapEnd  , field, FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE  , frag_id )
                   )
                {
/*
                                        printf("Offset: %d %d %d\n", F3->Offset[0], F3->Offset[1], F3->Offset[2] ); 

                                char buf[1024];
                                        sprintf(buf, "Offset: %d %d %d\n", F3->Offset[0], F3->Offset[1], F3->Offset[2] ); 
                                        FID->name += buf;
                                        printf("FID name is now %s\n", FID->Name().c_str() );
*/
                        FID->addInterface( F3 );
                }
        }
};


RefPtr<SizeInterface> getFieldSize(F5Path*field);

RefPtr<Field> ContiguousField(F5Path*field, 
                              const RefPtr<FiberTypeBase>&MyFiberType, 
                              const RefPtr<LoaderProgress>&TheLoaderProgressor);

RefPtr<Field> UniformField(F5Path*field, const RefPtr<LoaderProgress>&TheLoaderProgressor);

herr_t  loadFragment(F5Path*field, const char*fragmentname,
                     const RefPtr<FiberTypeBase>   &MyFiberType,
                     FragmentIDContainer           &FIDC,
                     const RefPtr<Field>           &MyField,
                     const RefPtr<LoaderProgress>  &LP,
                     const string                  &path_info);

herr_t  loadCompoundFragment(F5Path*field, const char*fragmentname,
                             const RefPtr<FiberTypeBase>   &MyFiberType,
                             FragmentIDContainer          &FIDC,
                             const RefPtr<Field>          &MyField,
                             const RefPtr<LoaderProgress> &LP,
                             const string                 &path_info);

herr_t  loadUniformFragment(F5Path*field, const char*fragmentname,
                            FragmentIDContainer&FIDC,
                            const RefPtr<Field>   &MyField,
                            const RefPtr<LoaderProgress> &LP,
                            const string                  &path_info);



herr_t  LoadRepresentationField(F5Path*field, Grid&MyGrid, Representation&Rep, const char*fieldname,
                                const RefPtr<LoaderProgress>&TheLoaderProgressor);


} // Fiber namespace


#endif // __FIBER_HDF5_LOADFIELD_HPP