LoadFragment.hpp

#ifndef __FIBER_FIBERIO_HDF5_FRAGMENTLOADER_HPP
#define __FIBER_FIBERIO_HDF5_FRAGMENTLOADER_HPP
 
#include <fiber/grid/Skeleton.hpp>
#include <memcore/Loader.hpp>
#include <F5/F5Path.h>
#include <F5/F5Path.h>
#include <fiber/bundle/StorageTransformations.hpp>
#include "H++/H5FileAccess.hpp"
#include "H++/H5Group.hpp"
 
#include "PrecisionTransformation.hpp"
#include "LoadGrid.hpp"
 
namespace Fiber
{
namespace FiberIO
{
namespace HDF5
{
 
using namespace Fiber;
using namespace MemCore;
 
 
class   FragmentLoader : public PrecisionTransformation
{
public:
        GridLoader&myGridLoader;
 
        RefPtr<Skeleton>        mySkeleton;
        RefPtr<Field>           MyField;
        RefPtr<H5Group>         myFieldGroup;
 
        RefPtr<LoaderProgress>  LP;
        WeakPtr<StorageTransformations::IOPerformance> LoadPerformance;
        string                  path_info;
        int                     GroupEntries = 0;
 
        hid_t   type_class_id = -1;
 
        using FragmentNames_t = std::vector<string>;
 
        RefPtr<H5GroupAccess>   GroupAccess;
        RefPtr<H5DatasetAccess> DatasetAccess;
        RefPtr<H5FileAccess>    myVFD;
 
        std::unordered_set<std::string> IgnoreAttributesOnLoad;
 
        FragmentLoader(GridLoader&theGridLoader,
                       const RefPtr<Skeleton>&theContainingSkeleton,
                       const RefPtr<Representation>&theRepresentation,
                       const RefPtr<Field>&CurrentField,
                       const string&FieldNameInFile,
                       const RefPtr<H5Group>&theFieldGroup,
                       const RefPtr<LoaderProgress>&lp,
                       const WeakPtr<StorageTransformations::IOPerformance>&LoadPerformance,
                       const RefPtr<FiberTypeBase>&TheFiberType,
                       const string&the_path_info);
 
        ~FragmentLoader();
 
        bool    getFragmentNames(FragmentNames_t&, F5Path*field);
 
        virtual herr_t apply(F5Path*field, const char*fragmentname) = 0;
 
public:
        herr_t  iterate(F5Path*field);
 
        herr_t  loadContiguousFragment(F5Path*field,
                                       const char*fragmentname,
                                       const WeakPtr<Fiber::Skeleton>&theRepresentationTarget);
 
//      herr_t  loadCompoundFragment(F5Path*field, const char*fragmentname);
 
        herr_t  loadUniformFragment(F5Path*field, const char*fragmentname);
 
        bool    loadViaFragmentCache(const RefPtr<H5Group>&);
};
 
struct  ContiguousFragmentLoader : FragmentLoader
{
        MemCore::WeakPtr<Fiber::Skeleton>       myRepresentationTarget;
//      int     Current = 0;
        int     NumberOfFields = 0, CurrentFieldNumber = 0;
 
        ContiguousFragmentLoader(GridLoader&theGridLoader,
                                 const RefPtr<Skeleton>&theContainingSkeleton,
                                 const RefPtr<Representation>&theRepresentation,
                                 const RefPtr<Field>&CurrentField,
                                 const string&FieldNameInFile,
                                 const RefPtr<H5Group>&theFieldGroup,
                                 const RefPtr<LoaderProgress>&lp,
                                 const WeakPtr<StorageTransformations::IOPerformance>&LoadPerformance,
                                 const RefPtr<FiberTypeBase>&TheFiberType,
                                 const string&the_path_info,
                                 const WeakPtr<Fiber::Skeleton>&theRepresentationTarget,
                                 F5Path*field,
                                 int NumberOfFields, int CurrentFieldNumber);
 
        ~ContiguousFragmentLoader();
 
        bool    loadAllFragments(F5Path*field);
 
        herr_t  apply(F5Path*field, const char*fragmentname) override;
};
 
#if     0
struct  CompoundFragmentLoader : FragmentLoader
{
        int     Current = 0;
 
        CompoundFragmentLoader(const RefPtr<Skeleton>&theContainingSkeleton,
                               const RefPtr<Representation>&theRepresentation,
                               const RefPtr<Field>&CurrentField,
                               const string&FieldNameInFile,
                               const RefPtr<H5Group>&theFieldGroup,
                               const RefPtr<LoaderProgress>&lp,
                               const RefPtr<FiberTypeBase>&TheFiberType,
                               const string&the_path_info)
        : FragmentLoader( theContainingSkeleton, theRepresentation, CurrentField,
                          FieldNameInFile,
                          theFieldGroup, lp, TheFiberType, the_path_info)
        {}
 
        herr_t apply(F5Path*field, const char*fragmentname)
        {
                if (LP) LP->progress(fragmentname, Current++, GroupEntries);
                return loadCompoundFragment(field, fragmentname);
        }
};
#endif
 
struct  UniformFragmentLoader : FragmentLoader
{
        size_t  NumberOfFragments = 1;
        size_t  CurrentFragment   = 0;
 
        UniformFragmentLoader(GridLoader&theGridLoader,
                              const RefPtr<Skeleton>&theContainingSkeleton,
                              const RefPtr<Representation>&theRepresentation,
                              const RefPtr<Field>&CurrentField,
                              const string&FieldNameInFile,
                              const RefPtr<H5Group>&theFieldGroup,
                              const RefPtr<LoaderProgress>&lp,
                              const WeakPtr<StorageTransformations::IOPerformance>&LoadPerformance,
                              const RefPtr<FiberTypeBase>&TheFiberType,
                              const string&the_path_info)
        : FragmentLoader( theGridLoader, theContainingSkeleton, theRepresentation,
                          CurrentField, FieldNameInFile,
                          theFieldGroup, lp, LoadPerformance,
                          TheFiberType, the_path_info)
        {
                NumberOfFragments = theFieldGroup->NumberOfEntries();
        }
 
        herr_t apply(F5Path*field, const char*fragmentname)
        {
                if (LP)
                {
                        LP->progress( "Loading uniform fragment " + path_info + "[" + fragmentname + "]",
                                      CurrentFragment, NumberOfFragments);
                }
                CurrentFragment++;
                return loadUniformFragment(field, fragmentname);
        }
};
 
}
}
}
 
#endif // __FIBER_FIBERIO_HDF5_FRAGMENTLOADER