Field3DFileHDF5.h
Go to the documentation of this file.
//----------------------------------------------------------------------------//
/*
* Copyright (c) 2009 Sony Pictures Imageworks Inc
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution. Neither the name of Sony Pictures Imageworks nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior written
* permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
*/
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
#ifndef _INCLUDED_Field3D_Field3DFileHDF5_H_
#define _INCLUDED_Field3D_Field3DFileHDF5_H_
//----------------------------------------------------------------------------//
#include <list>
#include <string>
#include <vector>
#include <hdf5.h>
#include <boost/intrusive_ptr.hpp>
#include "EmptyField.h"
#include "Field.h"
#include "FieldCache.h"
#include "FieldMetadata.h"
#include "ClassFactory.h"
#include "Hdf5Util.h"
//----------------------------------------------------------------------------//
#include "ns.h"
FIELD3D_NAMESPACE_OPEN
//----------------------------------------------------------------------------//
// Function Declarations
//----------------------------------------------------------------------------//
// \{
template <class Data_T>
typename Field<Data_T>::Ptr
readField(const std::string &className, hid_t layerGroup,
const std::string &filename, const std::string &layerPath);
FIELD3D_API bool writeField(hid_t layerGroup, FieldBase::Ptr field);
FIELD3D_API FieldMapping::Ptr readFieldMapping(hid_t mappingGroup);
FIELD3D_API bool writeFieldMapping(hid_t mappingGroup,
FieldMapping::Ptr mapping);
//----------------------------------------------------------------------------//
// Layer
//----------------------------------------------------------------------------//
namespace FileHDF5 {
class Layer
{
public:
std::string name;
std::string parent;
};
} // namespace FileHDF5
//----------------------------------------------------------------------------//
// Partition
//----------------------------------------------------------------------------//
namespace FileHDF5 {
class FIELD3D_API Partition : public RefBase
{
public:
typedef std::vector<Layer> ScalarLayerList;
typedef std::vector<Layer> VectorLayerList;
typedef boost::intrusive_ptr<Partition> Ptr;
typedef boost::intrusive_ptr<const Partition> CPtr;
// RTTI replacement ----------------------------------------------------------
typedef Partition class_type;
DEFINE_FIELD_RTTI_CONCRETE_CLASS;
static const char *staticClassType()
{
return "Partition";
}
// Ctors, dtor ---------------------------------------------------------------
Partition()
: RefBase()
{ }
// From RefBase --------------------------------------------------------------
virtual std::string className() const;
// Main methods --------------------------------------------------------------
void addScalarLayer(const FileHDF5::Layer &layer);
void addVectorLayer(const FileHDF5::Layer &layer);
const FileHDF5::Layer* scalarLayer(const std::string &name) const;
const FileHDF5::Layer* vectorLayer(const std::string &name) const;
void getScalarLayerNames(std::vector<std::string> &names) const;
void getVectorLayerNames(std::vector<std::string> &names) const;
// Public data members -------------------------------------------------------
std::string name;
FieldMapping::Ptr mapping;
private:
// Private data members ------------------------------------------------------
ScalarLayerList m_scalarLayers;
VectorLayerList m_vectorLayers;
// Typedefs ------------------------------------------------------------------
typedef RefBase base;
};
} // namespace FileHDF5
//----------------------------------------------------------------------------//
// Field3DFileHDF5Base
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
class FIELD3D_API Field3DFileHDF5Base : public MetadataCallback
{
public:
friend class Field3DInputFile;
friend class Field3DOutputFile;
// Structs -------------------------------------------------------------------
struct LayerInfo
{
std::string name;
std::string parentName;
int components;
LayerInfo(std::string par, std::string nm, int cpt)
: name(nm), parentName(par), components(cpt)
{ /* Empty */ }
};
// Typedefs ------------------------------------------------------------------
typedef std::map<std::string, std::string> GroupMembershipMap;
// Ctor, dtor ----------------------------------------------------------------
Field3DFileHDF5Base();
virtual ~Field3DFileHDF5Base() = 0;
// Main methods --------------------------------------------------------------
void clear();
bool close();
void getPartitionNames(std::vector<std::string> &names) const;
void getScalarLayerNames(std::vector<std::string> &names,
const std::string &partitionName) const;
void getVectorLayerNames(std::vector<std::string> &names,
const std::string &partitionName) const;
FileHDF5::Partition::Ptr getPartition(const std::string &partitionName) const
{ return partition(partitionName); }
std::string intPartitionName(const std::string &partitionName,
const std::string &layerName,
FieldRes::Ptr field);
std::string removeUniqueId(const std::string &partitionName) const;
void addGroupMembership(const GroupMembershipMap &groupMembers);
// Access to metadata --------------------------------------------------------
FieldMetadata& metadata()
{ return m_metadata; }
const FieldMetadata& metadata() const
{ return m_metadata; }
virtual void metadataHasChanged(const std::string &/* name */)
{ /* Empty */ }
// Debug ---------------------------------------------------------------------
void printHierarchy() const;
protected:
// Internal typedefs ---------------------------------------------------------
typedef std::vector<FileHDF5::Partition::Ptr> PartitionList;
typedef std::map<std::string, int> PartitionCountMap;
// Convenience methods -------------------------------------------------------
void closeInternal();
FileHDF5::Partition::Ptr partition(const std::string &partitionName);
FileHDF5::Partition::Ptr partition(const std::string &partitionName) const;
void getIntPartitionNames(std::vector<std::string> &names) const;
void getIntScalarLayerNames(std::vector<std::string> &names,
const std::string &intPartitionName) const;
void getIntVectorLayerNames(std::vector<std::string> &names,
const std::string &intPartitionName) const;
int numIntPartitions(const std::string &partitionName) const;
std::string makeIntPartitionName(const std::string &partitionsName,
int i) const;
// Data members --------------------------------------------------------------
std::vector<LayerInfo> m_layerInfo;
hid_t m_file;
PartitionList m_partitions;
std::vector<std::string> m_partitionNames;
PartitionCountMap m_partitionCount;
GroupMembershipMap m_groupMembership;
FieldMetadata m_metadata;
private:
// Private member functions --------------------------------------------------
Field3DFileHDF5Base(const Field3DFileHDF5Base&);
void operator =(const Field3DFileHDF5Base&);
};
//----------------------------------------------------------------------------//
// Field3DInputFileHDF5
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
class FIELD3D_API Field3DInputFileHDF5 : public Field3DFileHDF5Base
{
public:
friend class Field3DInputFile;
friend class Field3DOutputFile;
// Ctors, dtor ---------------------------------------------------------------
Field3DInputFileHDF5();
virtual ~Field3DInputFileHDF5();
// Main interface ------------------------------------------------------------
template <class Data_T>
typename Field<Data_T>::Vec
readScalarLayers(const std::string &layerName = std::string("")) const;
template <class Data_T>
typename Field<Data_T>::Vec
readScalarLayers(const std::string &partitionName,
const std::string &layerName) const;
template <class Data_T>
typename Field<FIELD3D_VEC3_T<Data_T> >::Vec
readVectorLayers(const std::string &layerName = std::string("")) const;
template <class Data_T>
typename Field<FIELD3D_VEC3_T<Data_T> >::Vec
readVectorLayers(const std::string &partitionName,
const std::string &layerName) const;
template <template <typename T> class Field_T, class Data_T>
typename Field_T<Data_T>::Vec
readScalarLayersAs(const std::string &layerName = std::string("")) const
{
typedef typename Field<Data_T>::Vec FieldList;
typedef typename Field_T<Data_T>::Vec TypedFieldList;
// First, read the layers as-is
FieldList originals;
originals = readScalarLayers<Data_T>(layerName);
// Loop over fields, converting if needed
TypedFieldList output;
typename FieldList::iterator i = originals.begin();
for (; i != originals.end(); ++i) {
typename Field_T<Data_T>::Ptr targetField;
targetField = field_dynamic_cast<Field_T<Data_T> >(*i);
if (targetField) {
output.push_back(targetField);
} else {
typename Field_T<Data_T>::Ptr newTarget(new Field_T<Data_T>);
newTarget->name = (*i)->name;
newTarget->attribute = (*i)->attribute;
newTarget->copyMetadata(**i);
newTarget->copyFrom(*i);
output.push_back(newTarget);
}
}
return output;
}
template <template <typename T> class Field_T, class Data_T>
typename Field_T<Data_T>::Vec
readScalarLayersAs(const std::string &partitionName,
const std::string &layerName) const
{
typedef typename Field<Data_T>::Vec FieldList;
typedef typename Field_T<Data_T>::Vec TypedFieldList;
// First, read the layers as-is
FieldList originals;
originals = readScalarLayers<Data_T>(partitionName, layerName);
// Loop over fields, converting if needed
TypedFieldList output;
typename FieldList::iterator i = originals.begin();
for (; i != originals.end(); ++i) {
typename Field_T<Data_T>::Ptr targetField;
targetField = field_dynamic_cast<Field_T<Data_T> >(*i);
if (targetField) {
output.push_back(targetField);
} else {
typename Field_T<Data_T>::Ptr newTarget(new Field_T<Data_T>);
newTarget->name = (*i)->name;
newTarget->attribute = (*i)->attribute;
newTarget->copyMetadata(**i);
newTarget->copyFrom(*i);
output.push_back(newTarget);
}
}
return output;
}
template <template <typename T> class Field_T, class Data_T>
typename Field_T<FIELD3D_VEC3_T<Data_T> >::Vec
readVectorLayersAs(const std::string &layerName = std::string("")) const
{
typedef Field_T<FIELD3D_VEC3_T<Data_T> > TypedVField;
typedef typename Field<FIELD3D_VEC3_T<Data_T> >::Vec FieldList;
typedef typename Field_T<FIELD3D_VEC3_T<Data_T> >::Vec TypedFieldList;
// First, read the layers as-is
FieldList originals;
originals = readVectorLayers<Data_T>(layerName);
// Loop over fields, converting if needed
TypedFieldList output;
typename FieldList::iterator i = originals.begin();
for (; i != originals.end(); ++i) {
typename TypedVField::Ptr targetField;
targetField = field_dynamic_cast<TypedVField>(*i);
if (targetField) {
output.push_back(targetField);
} else {
typename TypedVField::Ptr newTarget(new TypedVField);
newTarget->name = (*i)->name;
newTarget->attribute = (*i)->attribute;
newTarget->copyMetadata(**i);
newTarget->copyFrom(*i);
output.push_back(newTarget);
}
}
return output;
}
template <template <typename T> class Field_T, class Data_T>
typename Field_T<FIELD3D_VEC3_T<Data_T> >::Vec
readVectorLayersAs(const std::string &partitionName,
const std::string &layerName) const
{
typedef Field_T<FIELD3D_VEC3_T<Data_T> > TypedVField;
typedef typename Field<FIELD3D_VEC3_T<Data_T> >::Vec FieldList;
typedef typename Field_T<FIELD3D_VEC3_T<Data_T> >::Vec TypedFieldList;
// First, read the layers as-is
FieldList originals;
originals = readVectorLayers<Data_T>(partitionName, layerName);
// Loop over fields, converting if needed
TypedFieldList output;
typename FieldList::iterator i = originals.begin();
for (; i != originals.end(); ++i) {
typename TypedVField::Ptr targetField;
targetField = field_dynamic_cast<TypedVField>(*i);
if (targetField) {
output.push_back(targetField);
} else {
typename TypedVField::Ptr newTarget(new TypedVField);
newTarget->name = (*i)->name;
newTarget->attribute = (*i)->attribute;
newTarget->copyMetadata(**i);
newTarget->copyFrom(*i);
output.push_back(newTarget);
}
}
return output;
}
template <class Data_T>
typename EmptyField<Data_T>::Vec
readProxyLayer(const std::string &partitionName,
const std::string &layerName,
bool isVectorLayer) const;
template <class Data_T>
typename EmptyField<Data_T>::Ptr
readProxyLayer(hid_t location, const std::string &name,
const std::string &attribute,
FieldMapping::Ptr mapping) const;
template <class Data_T>
typename EmptyField<Data_T>::Vec
readProxyScalarLayers(const std::string &name = std::string("")) const;
template <class Data_T>
typename EmptyField<Data_T>::Vec
readProxyVectorLayers(const std::string &name = std::string("")) const;
// File IO ---
bool open(const std::string &filename);
// Callback convenience methods ----------------------------------------------
herr_t parsePartition(hid_t loc_id, const std::string partitionName);
herr_t parseLayer(hid_t loc_id, const std::string &partitionName,
const std::string &layerName);
// Convenience methods -------------------------------------------------------
bool readGroupMembership(GroupMembershipMap &gpMembershipMap);
private:
// Convenience methods -------------------------------------------------------
template <class Data_T>
typename Field<Data_T>::Ptr
readScalarLayer(const std::string &intPartitionName,
const std::string &layerName) const;
template <class Data_T>
typename Field<FIELD3D_VEC3_T<Data_T> >::Ptr
readVectorLayer(const std::string &intPartitionName,
const std::string &layerName) const;
template <class Data_T>
typename Field<Data_T>::Ptr
readLayer(const std::string &intPartitionName,
const std::string &layerName,
bool isVectorLayer) const;
bool readPartitionAndLayerInfo();
bool readMetadata(hid_t metadata_id, FieldBase::Ptr field) const;
bool readMetadata(hid_t metadata_id);
// Data members --------------------------------------------------------------
std::string m_filename;
};
//----------------------------------------------------------------------------//
// Utility functions
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
// Field3DOutputFileHDF5
//----------------------------------------------------------------------------//
//----------------------------------------------------------------------------//
class FIELD3D_API Field3DOutputFileHDF5 : public Field3DFileHDF5Base
{
public:
friend class Field3DInputFile;
friend class Field3DOutputFile;
// Enums ---------------------------------------------------------------------
enum CreateMode {
OverwriteMode,
FailOnExisting
};
// Ctors, dtor ---------------------------------------------------------------
Field3DOutputFileHDF5();
virtual ~Field3DOutputFileHDF5();
// Main interface ------------------------------------------------------------
template <class Data_T>
bool writeScalarLayer(const std::string &layerName,
typename Field<Data_T>::Ptr layer)
{ return writeScalarLayer<Data_T>(layerName, std::string("default"), layer); }
template <class Data_T>
bool writeVectorLayer(const std::string &layerName,
typename Field<FIELD3D_VEC3_T<Data_T> >::Ptr layer)
{ return writeVectorLayer<Data_T>(layerName, std::string("default"), layer); }
template <class Data_T>
bool writeScalarLayer(const std::string &partitionName,
const std::string &layerName,
typename Field<Data_T>::Ptr layer);
template <class Data_T>
bool writeScalarLayer(typename Field<Data_T>::Ptr layer);
template <class Data_T>
bool writeVectorLayer(const std::string &partitionName,
const std::string &layerName,
typename Field<FIELD3D_VEC3_T<Data_T> >::Ptr layer);
template <class Data_T>
bool writeVectorLayer(typename Field<FIELD3D_VEC3_T<Data_T> >::Ptr layer);
bool create(const std::string &filename, CreateMode cm = OverwriteMode);
bool writeGlobalMetadata();
bool writeGroupMembership();
std::string incrementPartitionName(std::string &pname);
template <class Data_T>
FileHDF5::Partition::Ptr
createNewPartition(const std::string &partitionName,
const std::string &layerName,
typename Field<Data_T>::Ptr field);
private:
// Convenience methods -------------------------------------------------------
bool writeMapping(hid_t partitionLocation, FieldMapping::Ptr mapping);
template <class Data_T>
bool writeLayer(const std::string &partitionName,
const std::string &layerName,
bool isVectorLayer,
typename Field<Data_T>::Ptr layer);
bool writeMetadata(hid_t metadataGroup, FieldBase::Ptr layer);
bool writeMetadata(hid_t metadataGroup);
};
//----------------------------------------------------------------------------//
// Field3DInputFileHDF5-related callback functions
//----------------------------------------------------------------------------//
namespace InputFileHDF5 {
struct ParseLayersInfo
{
Field3DInputFileHDF5 *file;
std::string partitionName;
};
FIELD3D_API herr_t parsePartitions(hid_t loc_id, const char *partitionName,
const H5L_info_t *linfo, void *opdata);
FIELD3D_API herr_t parseLayers(hid_t loc_id, const char *partitionName,
const H5L_info_t *linfo, void *opdata);
} // namespace InputFileHDF5
//----------------------------------------------------------------------------//
// Field3DInputFileHDF5
//----------------------------------------------------------------------------//
template <class Data_T>
typename Field<Data_T>::Vec
Field3DInputFileHDF5::readScalarLayers(const std::string &name) const
{
using namespace std;
typedef typename Field<Data_T>::Ptr FieldPtr;
typedef typename Field<Data_T>::Vec FieldList;
FieldList ret;
std::vector<std::string> parts;
getIntPartitionNames(parts);
for (vector<string>::iterator p = parts.begin(); p != parts.end(); ++p) {
std::vector<std::string> layers;
getIntScalarLayerNames(layers, *p);
for (vector<string>::iterator l = layers.begin(); l != layers.end(); ++l) {
// Only read if it matches the name
if ((name.length() == 0) || (*l == name)) {
FieldPtr mf = readScalarLayer<Data_T>(*p, *l);
if (mf) {
ret.push_back(mf);
}
}
}
}
return ret;
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename Field<Data_T>::Vec
Field3DInputFileHDF5::readScalarLayers(const std::string &partitionName,
const std::string &layerName) const
{
using namespace std;
typedef typename Field<Data_T>::Ptr FieldPtr;
typedef typename Field<Data_T>::Vec FieldList;
FieldList ret;
if ((layerName.length() == 0) || (partitionName.length() == 0))
return ret;
std::vector<std::string> parts;
getIntPartitionNames(parts);
for (vector<string>::iterator p = parts.begin(); p != parts.end(); ++p) {
std::vector<std::string> layers;
getIntScalarLayerNames(layers, *p);
if (removeUniqueId(*p) == partitionName) {
for (vector<string>::iterator l = layers.begin();
l != layers.end(); ++l) {
// Only read if it matches the name
if (*l == layerName) {
FieldPtr mf = readScalarLayer<Data_T>(*p, *l);
if (mf)
ret.push_back(mf);
}
}
}
}
return ret;
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename Field<FIELD3D_VEC3_T<Data_T> >::Vec
Field3DInputFileHDF5::readVectorLayers(const std::string &name) const
{
using namespace std;
typedef typename Field<FIELD3D_VEC3_T<Data_T> >::Ptr FieldPtr;
typedef typename Field<FIELD3D_VEC3_T<Data_T> >::Vec FieldList;
FieldList ret;
std::vector<std::string> parts;
getIntPartitionNames(parts);
for (vector<string>::iterator p = parts.begin(); p != parts.end(); ++p) {
std::vector<std::string> layers;
getIntVectorLayerNames(layers, *p);
for (vector<string>::iterator l = layers.begin(); l != layers.end(); ++l) {
// Only read if it matches the name
if ((name.length() == 0) || (*l == name)) {
FieldPtr mf = readVectorLayer<Data_T>(*p, *l);
if (mf)
ret.push_back(mf);
}
}
}
return ret;
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename Field<FIELD3D_VEC3_T<Data_T> >::Vec
Field3DInputFileHDF5::readVectorLayers(const std::string &partitionName,
const std::string &layerName) const
{
using namespace std;
typedef typename Field<FIELD3D_VEC3_T<Data_T> >::Ptr FieldPtr;
typedef typename Field<FIELD3D_VEC3_T<Data_T> >::Vec FieldList;
FieldList ret;
if ((layerName.length() == 0) || (partitionName.length() == 0))
return ret;
std::vector<std::string> parts;
getIntPartitionNames(parts);
for (vector<string>::iterator p = parts.begin(); p != parts.end(); ++p) {
std::vector<std::string> layers;
getIntVectorLayerNames(layers, *p);
if (removeUniqueId(*p) == partitionName) {
for (vector<string>::iterator l = layers.begin();
l != layers.end(); ++l) {
// Only read if it matches the name
if (*l == layerName) {
FieldPtr mf = readVectorLayer<Data_T>(*p, *l);
if (mf)
ret.push_back(mf);
}
}
}
}
return ret;
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename Field<Data_T>::Ptr
Field3DInputFileHDF5::readLayer(const std::string &intPartitionName,
const std::string &layerName,
bool isVectorLayer) const
{
using namespace boost;
using namespace std;
using namespace Hdf5Util;
typedef typename Field<Data_T>::Ptr FieldPtr;
// Instantiate a null pointer for easier code reading
FieldPtr nullPtr;
GlobalLock lock(g_hdf5Mutex);
// Find the partition
FileHDF5::Partition::Ptr part = partition(intPartitionName);
if (!part) {
Msg::print(Msg::SevWarning, "Couldn't find partition: " + intPartitionName);
return nullPtr;
}
// Find the layer in the partition
const FileHDF5::Layer *l;
if (isVectorLayer)
l = part->vectorLayer(layerName);
else
l = part->scalarLayer(layerName);
if (!l) {
Msg::print(Msg::SevWarning, "Couldn't find layer: " + layerName );
return nullPtr;
}
// Open the layer group
string layerPath = l->parent + "/" + l->name;
H5ScopedGopen layerGroup(m_file, layerPath.c_str());
if (layerGroup.id() < 0) {
Msg::print(Msg::SevWarning, "Couldn't find layer group " + layerName
+ " in .f3d file ");
return nullPtr;
}
// Get the class name
string className;
if (!readAttribute(layerGroup.id(), "class_name", className)) {
Msg::print(Msg::SevWarning, "Couldn't find class_name attrib in layer " +
layerName);
return nullPtr;
}
// Check the cache
FieldCache<Data_T> &cache = FieldCache<Data_T>::singleton();
FieldPtr cachedField = cache.getCachedField(m_filename, layerPath);
if (cachedField) {
return cachedField;
}
// Construct the field and load the data
// Unlock the g_hdf5Mutex while calling readField() so that other threads
// have a chance to pre-empt loading in between (prevents deadlocks with
// sparse reader)
lock.unlock();
typename Field<Data_T>::Ptr field;
field = readField<Data_T>(className, layerGroup.id(), m_filename, layerPath);
if (!field) {
#if 0 // This isn't really an error
Msg::print(Msg::SevWarning, "Couldn't read the layer data of layer: "
+ layerName);
#endif
return nullPtr;
}
// Now we need to use Hdf5 again, so re-aquire the lock.
lock.lock();
// read the metadata
string metadataPath = layerPath + "/metadata";
H5ScopedGopen metadataGroup(m_file, metadataPath.c_str());
if (metadataGroup.id() > 0) {
readMetadata(metadataGroup.id(), field);
}
// Set the name of the field so it's possible to re-create the file
field->name = removeUniqueId(intPartitionName);
field->attribute = layerName;
field->setMapping(part->mapping);
// Cache the field for future use
if (field) {
cache.cacheField(field, m_filename, layerPath);
}
return field;
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename EmptyField<Data_T>::Vec
Field3DInputFileHDF5::readProxyLayer(const std::string &partitionName,
const std::string &layerName,
bool isVectorLayer) const
{
using namespace boost;
using namespace std;
using namespace Hdf5Util;
GlobalLock lock(g_hdf5Mutex);
// Instantiate a null pointer for easier code reading
typename EmptyField<Data_T>::Vec emptyList, output;
if ((layerName.length() == 0) || (partitionName.length() == 0))
return emptyList;
std::vector<std::string> parts, layers;
getIntPartitionNames(parts);
bool foundPartition = false;
for (vector<string>::iterator p = parts.begin(); p != parts.end(); ++p) {
if (removeUniqueId(*p) == partitionName) {
foundPartition = true;
if (isVectorLayer) {
getIntVectorLayerNames(layers, *p);
} else {
getIntScalarLayerNames(layers, *p);
}
for (vector<string>::iterator l = layers.begin();
l != layers.end(); ++l) {
if (*l == layerName) {
// Find the partition
FileHDF5::Partition::Ptr part = partition(*p);
if (!part) {
Msg::print(Msg::SevWarning, "Couldn't find partition: " + *p);
return emptyList;
}
// Find the layer
const FileHDF5::Layer *layer;
if (isVectorLayer)
layer = part->vectorLayer(layerName);
else
layer = part->scalarLayer(layerName);
if (!layer) {
Msg::print(Msg::SevWarning, "Couldn't find layer: " + layerName);
return emptyList;
}
// Open the layer group
string layerPath = layer->parent + "/" + layer->name;
H5ScopedGopen layerGroup(m_file, layerPath.c_str());
if (layerGroup.id() < 0) {
Msg::print(Msg::SevWarning, "Couldn't find layer group "
+ layerName + " in .f3d file ");
return emptyList;
}
// Make the proxy representation
typename EmptyField<Data_T>::Ptr field =
readProxyLayer<Data_T>(layerGroup, partitionName, layerName,
part->mapping);
// Read MIPField's number of mip levels
int numLevels = 0;
H5ScopedGopen mipGroup(layerGroup, "mip_levels");
if (mipGroup.id() >= 0)
readAttribute(mipGroup, "levels", 1, numLevels);
field->metadata().setIntMetadata("mip_levels", numLevels);
// Add field to output
output.push_back(field);
}
}
}
}
if (!foundPartition) {
Msg::print(Msg::SevWarning, "Couldn't find partition: " + partitionName);
return emptyList;
}
return output;
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename EmptyField<Data_T>::Ptr
Field3DInputFileHDF5::readProxyLayer(hid_t location,
const std::string &name,
const std::string &attribute,
FieldMapping::Ptr mapping) const
{
using namespace boost;
using namespace std;
using namespace Hdf5Util;
typename EmptyField<Data_T>::Ptr null;
GlobalLock lock(g_hdf5Mutex);
// Read the extents and data window
Box3i extents, dataW;
if (!readAttribute(location, "extents", 6, extents.min.x)) {
return null;
}
if (!readAttribute(location, "data_window", 6, dataW.min.x)) {
return null;
}
// Construct the field and load the data
typename EmptyField<Data_T>::Ptr field(new EmptyField<Data_T>);
field->setSize(extents, dataW);
// Read the metadata
H5ScopedGopen metadataGroup(location, "metadata");
if (metadataGroup.id() > 0) {
readMetadata(metadataGroup.id(), field);
}
// Set field properties
field->name = name;
field->attribute = attribute;
field->setMapping(mapping);
return field;
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename EmptyField<Data_T>::Vec
Field3DInputFileHDF5::readProxyScalarLayers(const std::string &name) const
{
using namespace std;
typedef typename EmptyField<Data_T>::Ptr FieldPtr;
typedef std::vector<FieldPtr> FieldList;
FieldList ret;
std::vector<std::string> parts;
getPartitionNames(parts);
for (vector<string>::iterator p = parts.begin(); p != parts.end(); ++p) {
std::vector<std::string> layers;
getScalarLayerNames(layers, *p);
for (vector<string>::iterator l = layers.begin(); l != layers.end(); ++l) {
// Only read if it matches the name
if ((name.length() == 0) || (*l == name)) {
FieldList f = readProxyLayer<Data_T>(*p, *l, false);
for (typename FieldList::iterator i = f.begin(); i != f.end(); ++i) {
if (*i) {
ret.push_back(*i);
}
}
}
}
}
return ret;
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename EmptyField<Data_T>::Vec
Field3DInputFileHDF5::readProxyVectorLayers(const std::string &name) const
{
using namespace std;
typedef typename EmptyField<Data_T>::Ptr FieldPtr;
typedef std::vector<FieldPtr> FieldList;
FieldList ret;
std::vector<std::string> parts;
getPartitionNames(parts);
for (vector<string>::iterator p = parts.begin(); p != parts.end(); ++p) {
std::vector<std::string> layers;
getVectorLayerNames(layers, *p);
for (vector<string>::iterator l = layers.begin(); l != layers.end(); ++l) {
// Only read if it matches the name
if ((name.length() == 0) || (*l == name)) {
FieldList f = readProxyLayer<Data_T>(*p, *l, true);
for (typename FieldList::iterator i = f.begin(); i != f.end(); ++i) {
if (*i) {
ret.push_back(*i);
}
}
}
}
}
return ret;
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename Field<Data_T>::Ptr
Field3DInputFileHDF5::readScalarLayer(const std::string &intPartitionName,
const std::string &layerName) const
{
return readLayer<Data_T>(intPartitionName, layerName, false);
}
//----------------------------------------------------------------------------//
template <class Data_T>
typename Field<FIELD3D_VEC3_T<Data_T> >::Ptr
Field3DInputFileHDF5::readVectorLayer(const std::string &intPartitionName,
const std::string &layerName) const
{
return readLayer<FIELD3D_VEC3_T<Data_T> >(intPartitionName, layerName, true);
}
//----------------------------------------------------------------------------//
// Field3DOutputFileHDF5
//----------------------------------------------------------------------------//
template <class Data_T>
FileHDF5::Partition::Ptr
Field3DOutputFileHDF5::createNewPartition(const std::string &partitionName,
const std::string & /* layerName */,
typename Field<Data_T>::Ptr field)
{
using namespace Hdf5Util;
using namespace Exc;
GlobalLock lock(g_hdf5Mutex);
FileHDF5::Partition::Ptr newPart(new FileHDF5::Partition);
newPart->name = partitionName;
H5ScopedGcreate partGroup(m_file, newPart->name.c_str());
if (partGroup.id() < 0) {
Msg::print(Msg::SevWarning,
"Error creating partition: " + newPart->name);
return FileHDF5::Partition::Ptr();
}
m_partitions.push_back(newPart);
// Pick up new pointer
FileHDF5::Partition::Ptr part = partition(partitionName);
// Add mapping group to the partition
try {
if (!writeMapping(partGroup.id(), field->mapping())) {
Msg::print(Msg::SevWarning,
"writeMapping returned false for an unknown reason ");
return FileHDF5::Partition::Ptr();
}
}
catch (WriteMappingException &e) {
Msg::print(Msg::SevWarning, "Couldn't write mapping for partition: "
+ partitionName);
return FileHDF5::Partition::Ptr();
}
catch (...) {
Msg::print(Msg::SevWarning,
"Unknown error when writing mapping for partition: "
+ partitionName);
return FileHDF5::Partition::Ptr();
}
// Set the mapping of the partition. Since all layers share their
// partition's mapping, we can just pick this first one. All subsequent
// additions to the same partition are checked to have the same mapping
part->mapping = field->mapping();
// Tag node as partition
// Create a version attribute on the root node
if (!writeAttribute(partGroup.id(), "is_field3d_partition", "1")) {
Msg::print(Msg::SevWarning, "Adding partition string.");
return FileHDF5::Partition::Ptr();
}
return part;
}
//----------------------------------------------------------------------------//
template <class Data_T>
bool
Field3DOutputFileHDF5::writeLayer(const std::string &userPartitionName,
const std::string &layerName,
bool isVectorLayer,
typename Field<Data_T>::Ptr field)
{
using namespace std;
using namespace Exc;
using namespace Hdf5Util;
GlobalLock lock(g_hdf5Mutex);
if (!field) {
Msg::print(Msg::SevWarning,
"Called writeLayer with null pointer. Ignoring...");
return false;
}
if (m_file < 0) {
Msg::print(Msg::SevWarning,
"Attempting to write layer without opening file first. ");
return false;
}
string partitionName = intPartitionName(userPartitionName, layerName, field);
// See if the partition already exists or if we need to make it ---
FileHDF5::Partition::Ptr part = partition(partitionName);
if (!part) {
part = createNewPartition<Data_T>(partitionName,layerName,field);
if (!part)
return false;
} else {
if (!field->mapping()) {
Msg::print(Msg::SevWarning,
"Couldn't add layer \"" + layerName + "\" to partition \""
+ partitionName + "\" because the layer's mapping is null.");
return false;
}
// If the partition already existed, we need to make sure that the layer
// doesn't also exist
if (!isVectorLayer) {
if (part->scalarLayer(layerName)) {
//need to create a new partition and then add the layer to that
std::string newPartitionName = incrementPartitionName(partitionName);
part = createNewPartition<Data_T>(newPartitionName,layerName,field);
if (!part)
return false;
}
} else {
if (part->vectorLayer(layerName)) {
//need to create a new partition and then add the layer to that
std::string newPartitionName = incrementPartitionName(partitionName);
part = createNewPartition<Data_T>(newPartitionName,layerName,field);
if (!part)
return false;
}
}
}
if (!part->mapping) {
Msg::print(Msg::SevWarning, "Severe error - partition mapping is null: "
+ partitionName);
return false;
}
// Check that the mapping matches what's already in the Partition
if (!field->mapping()->isIdentical(part->mapping)) {
Msg::print(Msg::SevWarning, "Couldn't add layer \"" + layerName
+ "\" to partition \"" + partitionName
+ "\" because mapping doesn't match");
return false;
}
// Open the partition
H5ScopedGopen partGroup(m_file, part->name.c_str(), H5P_DEFAULT);
// Build a Layer object ---
FileHDF5::Layer layer;
layer.name = layerName;
layer.parent = partitionName;
// Add Layer to file ---
H5ScopedGcreate layerGroup(partGroup.id(), layerName.c_str(),
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
if (layerGroup.id() < 0) {
Msg::print(Msg::SevWarning, "Error creating layer: " + layerName);
return false;
}
// Tag as layer
if (!writeAttribute(layerGroup.id(), "class_type", "field3d_layer")) {
Msg::print(Msg::SevWarning, "Error adding layer string.");
return false;
}
// Add metadata group and write it out
H5ScopedGcreate metadataGroup(layerGroup.id(), "metadata");
if (metadataGroup.id() < 0) {
Msg::print(Msg::SevWarning, "Error creating group: metadata");
return false;
}
if (!writeMetadata(metadataGroup.id(), field)) {
Msg::print(Msg::SevWarning, "Error writing metadata.");
return false;
}
if (!writeField(layerGroup.id(), field)) {
Msg::print(Msg::SevWarning, "Error writing layer: " + layer.name);
return false;
}
// Add layer to partition ---
if (isVectorLayer)
part->addVectorLayer(layer);
else
part->addScalarLayer(layer);
return true;
}
//----------------------------------------------------------------------------//
template <class Data_T>
bool
Field3DOutputFileHDF5::writeScalarLayer(const std::string &partitionName,
const std::string &layerName,
typename Field<Data_T>::Ptr field)
{
return writeLayer<Data_T>(partitionName, layerName, false, field);
}
//----------------------------------------------------------------------------//
template <class Data_T>
bool
Field3DOutputFileHDF5::writeScalarLayer(typename Field<Data_T>::Ptr layer)
{
if (layer->name.size() == 0) {
Msg::print(Msg::SevWarning, "Field3DOutputFileHDF5::writeScalarLayer: "
"Tried to write a scalar layer with no name");
return false;
}
if (layer->attribute.size() == 0) {
Msg::print(Msg::SevWarning, "Field3DOutputFileHDF5::writeScalarLayer: "
"Tried to write a scalar layer with no attribute name");
return false;
}
return writeScalarLayer<Data_T>(layer->name, layer->attribute, layer);
}
//----------------------------------------------------------------------------//
template <class Data_T>
bool
Field3DOutputFileHDF5::
writeVectorLayer(const std::string &partitionName,
const std::string &layerName,
typename Field<FIELD3D_VEC3_T<Data_T> >::Ptr field)
{
return writeLayer<FIELD3D_VEC3_T<Data_T> >(partitionName, layerName,
true, field);
}
//----------------------------------------------------------------------------//
template <class Data_T>
bool
Field3DOutputFileHDF5::writeVectorLayer
(typename Field<FIELD3D_VEC3_T<Data_T> >::Ptr layer)
{
if (layer->name.size() == 0) {
Msg::print(Msg::SevWarning, "Field3DOutputFileHDF5::writeVectorLayer: "
"Tried to write a vector layer with no name");
return false;
}
if (layer->attribute.size() == 0) {
Msg::print(Msg::SevWarning, "Field3DOutputFileHDF5::writeVectorLayer: "
"Tried to write a vector layer with no attribute name");
return false;
}
return writeVectorLayer<Data_T>(layer->name, layer->attribute, layer);
}
//----------------------------------------------------------------------------//
// Template Function Implementations
//----------------------------------------------------------------------------//
template <class Data_T>
typename Field<Data_T>::Ptr
readField(const std::string &className, hid_t layerGroup,
const std::string &filename, const std::string &layerPath)
{
ClassFactory &factory = ClassFactory::singleton();
typedef typename Field<Data_T>::Ptr FieldPtr;
FieldIO::Ptr io = factory.createFieldIO(className);
if (!io) {
Msg::print(Msg::SevWarning, "Unable to find class type: " +
className);
return FieldPtr();
}
DataTypeEnum typeEnum = DataTypeTraits<Data_T>::typeEnum();
FieldBase::Ptr field = io->read(layerGroup, filename, layerPath, typeEnum);
if (!field) {
// We don't need to print a message, because it could just be that
// a layer of the specified data type and name couldn't be found
return FieldPtr();
}
FieldPtr result = field_dynamic_cast<Field<Data_T> >(field);
if (result)
return result;
return FieldPtr();
}
//----------------------------------------------------------------------------//
FIELD3D_NAMESPACE_HEADER_CLOSE
//----------------------------------------------------------------------------//
#endif
ClassFactory.h
Contains the ClassFactory class for registering Field3D classes.
EmptyField.h
Contains the EmptyField class.
readField
Field< Data_T >::Ptr readField(const std::string &className, hid_t layerGroup, const std::string &filename, const std::string &layerPath)
This function creates a FieldIO instance based on className which then reads the field data from laye...
Definition Field3DFileHDF5.h:1644
writeField
FIELD3D_API bool writeField(hid_t layerGroup, FieldBase::Ptr field)
This function creates a FieldIO instance based on field->className() which then writes the field data...
Definition Field3DFileHDF5.cpp:1589
writeFieldMapping
FIELD3D_API bool writeFieldMapping(hid_t mappingGroup, FieldMapping::Ptr mapping)
This function creates a FieldMappingIO instance based on mapping->className() which then writes Field...
Definition Field3DFileHDF5.cpp:1645
readFieldMapping
FIELD3D_API FieldMapping::Ptr readFieldMapping(hid_t mappingGroup)
This function creates a FieldMappingIO instance based on className read from mappingGroup location wh...
Definition Field3DFileHDF5.cpp:1613
FieldCache.h
Contains the FieldCache class.
FieldMetadata.h
Basic container for metedata.
Field.h
Contains Field, WritableField and ResizableField classes.
Hdf5Util.h
Contains various utility functions for Hdf5.
g_hdf5Mutex
FIELD3D_NAMESPACE_OPEN FIELD3D_API boost::recursive_mutex g_hdf5Mutex
Definition Hdf5Util.cpp:67
GlobalLock
boost::recursive_mutex::scoped_lock GlobalLock
Definition Hdf5Util.h:78
FIELD3D_VEC3_T
#define FIELD3D_VEC3_T
Definition SpiMathLib.h:88
Box3i
Imath::Box3i Box3i
Definition SpiMathLib.h:77
DataTypeEnum
DataTypeEnum
Definition Traits.h:108
ClassFactory
Definition ClassFactory.h:72
ClassFactory::createFieldIO
FieldIO::Ptr createFieldIO(const std::string &className) const
Instances an IO object by name.
Definition ClassFactory.cpp:165
ClassFactory::singleton
static ClassFactory & singleton()
}
Definition ClassFactory.cpp:278
Ptr
EmptyField::Ptr
boost::intrusive_ptr< EmptyField > Ptr
Definition EmptyField.h:93
EmptyField::Vec
std::vector< Ptr > Vec
Definition EmptyField.h:94
Field3DFileHDF5Base::PartitionCountMap
std::map< std::string, int > PartitionCountMap
Definition Field3DFileHDF5.h:347
Field3DFileHDF5Base::Field3DFileHDF5Base
Field3DFileHDF5Base()
Definition Field3DFileHDF5.cpp:290
Field3DFileHDF5Base::m_partitionNames
std::vector< std::string > m_partitionNames
This stores partition names.
Definition Field3DFileHDF5.h:394
Field3DFileHDF5Base::m_partitions
PartitionList m_partitions
Vector of partitions.
Definition Field3DFileHDF5.h:392
Field3DFileHDF5Base::makeIntPartitionName
std::string makeIntPartitionName(const std::string &partitionsName, int i) const
Makes an internal partition name given the external partition name. Effectively just tacks on ....
Definition Field3DFileHDF5.cpp:542
Field3DFileHDF5Base::getVectorLayerNames
void getVectorLayerNames(std::vector< std::string > &names, const std::string &partitionName) const
Gets the names of all the vector layers in a given partition.
Definition Field3DFileHDF5.cpp:421
Field3DFileHDF5Base::metadataHasChanged
virtual void metadataHasChanged(const std::string &)
This function should implemented by concrete classes to get the callback when metadata changes.
Definition Field3DFileHDF5.h:330
Field3DFileHDF5Base::Field3DFileHDF5Base
Field3DFileHDF5Base(const Field3DFileHDF5Base &)
Field3DFileHDF5Base::getPartitionNames
void getPartitionNames(std::vector< std::string > &names) const
Gets the names of all the partitions in the file.
Definition Field3DFileHDF5.cpp:386
Field3DFileHDF5Base::close
bool close()
Closes the file. No need to call this unless you specifically want to close the file early....
Definition Field3DFileHDF5.cpp:496
Field3DFileHDF5Base::getIntVectorLayerNames
void getIntVectorLayerNames(std::vector< std::string > &names, const std::string &intPartitionName) const
Gets the names of all the vector layers in a given partition, but assumes that partition name is the ...
Definition Field3DFileHDF5.cpp:470
Field3DFileHDF5Base::Field3DInputFile
friend class Field3DInputFile
Definition Field3DFileHDF5.h:240
Field3DFileHDF5Base::m_groupMembership
GroupMembershipMap m_groupMembership
Keeps track of group membership for each layer of partition name. The key is the "group" and the valu...
Definition Field3DFileHDF5.h:403
Field3DFileHDF5Base::m_file
hid_t m_file
The hdf5 id of the current file. Will be -1 if no file is open.
Definition Field3DFileHDF5.h:390
Field3DFileHDF5Base::Field3DOutputFile
friend class Field3DOutputFile
Definition Field3DFileHDF5.h:241
Field3DFileHDF5Base::getIntScalarLayerNames
void getIntScalarLayerNames(std::vector< std::string > &names, const std::string &intPartitionName) const
Gets the names of all the scalar layers in a given partition, but assumes that partition name is the ...
Definition Field3DFileHDF5.cpp:452
Field3DFileHDF5Base::closeInternal
void closeInternal()
Closes the file if open.
Definition Field3DFileHDF5.cpp:505
Field3DFileHDF5Base::PartitionList
std::vector< FileHDF5::Partition::Ptr > PartitionList
Definition Field3DFileHDF5.h:346
Field3DFileHDF5Base::intPartitionName
std::string intPartitionName(const std::string &partitionName, const std::string &layerName, FieldRes::Ptr field)
Returns a unique partition name given the requested name. This ensures that partitions with matching ...
Definition Field3DFileHDF5.cpp:316
Field3DFileHDF5Base::partition
FileHDF5::Partition::Ptr partition(const std::string &partitionName) const
Returns a pointer to the given partition.
Field3DFileHDF5Base::metadata
FieldMetadata & metadata()
accessor to the m_metadata class
Definition Field3DFileHDF5.h:321
Field3DFileHDF5Base::getScalarLayerNames
void getScalarLayerNames(std::vector< std::string > &names, const std::string &partitionName) const
Gets the names of all the scalar layers in a given partition.
Definition Field3DFileHDF5.cpp:403
Field3DFileHDF5Base::m_layerInfo
std::vector< LayerInfo > m_layerInfo
This stores layer info.
Definition Field3DFileHDF5.h:387
Field3DFileHDF5Base::numIntPartitions
int numIntPartitions(const std::string &partitionName) const
Returns the number of internal partitions for a given partition name.
Definition Field3DFileHDF5.cpp:521
Field3DFileHDF5Base::metadata
const FieldMetadata & metadata() const
Read only access to the m_metadata class.
Definition Field3DFileHDF5.h:325
Field3DFileHDF5Base::removeUniqueId
std::string removeUniqueId(const std::string &partitionName) const
Strips any unique identifiers from the partition name and returns the original name.
Definition Field3DFileHDF5.cpp:373
Field3DFileHDF5Base::partition
FileHDF5::Partition::Ptr partition(const std::string &partitionName)
Returns a pointer to the given partition.
Field3DFileHDF5Base::m_partitionCount
PartitionCountMap m_partitionCount
Contains a counter for each partition name. This is used to keep multiple fields with the same name u...
Definition Field3DFileHDF5.h:398
Field3DFileHDF5Base::getIntPartitionNames
void getIntPartitionNames(std::vector< std::string > &names) const
Gets the names of all the -internal- partitions in the file.
Definition Field3DFileHDF5.cpp:439
Field3DFileHDF5Base::m_metadata
FieldMetadata m_metadata
metadata
Definition Field3DFileHDF5.h:406
Field3DFileHDF5Base::clear
void clear()
Clear the data structures and close the file.
Definition Field3DFileHDF5.cpp:487
Field3DFileHDF5Base::getPartition
FileHDF5::Partition::Ptr getPartition(const std::string &partitionName) const
Returns a pointer to the given partition.
Definition Field3DFileHDF5.h:294
Field3DFileHDF5Base::GroupMembershipMap
std::map< std::string, std::string > GroupMembershipMap
Definition Field3DFileHDF5.h:257
Field3DInputFileHDF5
Provides reading of .f3d (internally, hdf5) files.
Definition Field3DFileHDF5.h:438
Field3DInputFileHDF5::m_filename
std::string m_filename
Filename, only to be set by open().
Definition Field3DFileHDF5.h:736
Field3DInputFileHDF5::readVectorLayersAs
Field_T< FIELD3D_VEC3_T< Data_T > >::Vec readVectorLayersAs(const std::string &layerName=std::string("")) const
Retrieves a layers for all partitions. Converts it to the given template type if needed.
Definition Field3DFileHDF5.h:560
Field3DInputFileHDF5::readMetadata
bool readMetadata(hid_t metadata_id, FieldBase::Ptr field) const
Read metadata for this layer.
Definition Field3DFileHDF5.cpp:837
Field3DInputFileHDF5::readScalarLayersAs
Field_T< Data_T >::Vec readScalarLayersAs(const std::string &partitionName, const std::string &layerName) const
Retrieves a layers given their and its parent partition's name. Converts it to the given template typ...
Definition Field3DFileHDF5.h:525
Field3DInputFileHDF5::readProxyLayer
EmptyField< Data_T >::Vec readProxyLayer(const std::string &partitionName, const std::string &layerName, bool isVectorLayer) const
Retrieves a proxy version (EmptyField) of each layer .
Definition Field3DFileHDF5.h:1157
Field3DInputFileHDF5::Field3DInputFile
friend class Field3DInputFile
Definition Field3DFileHDF5.h:441
Field3DInputFileHDF5::Field3DOutputFile
friend class Field3DOutputFile
Definition Field3DFileHDF5.h:442
Field3DInputFileHDF5::readProxyVectorLayers
EmptyField< Data_T >::Vec readProxyVectorLayers(const std::string &name=std::string("")) const
Retrieves a proxy version (EmptyField) of each vector layer.
Definition Field3DFileHDF5.h:1324
Field3DInputFileHDF5::readScalarLayer
Field< Data_T >::Ptr readScalarLayer(const std::string &intPartitionName, const std::string &layerName) const
Retrieves a single layer given its and its parent partition's name. Maintains the on-disk data types.
Definition Field3DFileHDF5.h:1359
Field3DInputFileHDF5::readScalarLayers
Field< Data_T >::Vec readScalarLayers(const std::string &layerName=std::string("")) const
Retrieves all the layers of scalar type and maintains their on-disk data types.
Definition Field3DFileHDF5.h:910
Field3DInputFileHDF5::readScalarLayersAs
Field_T< Data_T >::Vec readScalarLayersAs(const std::string &layerName=std::string("")) const
Retrieves all layers for all partitions. Converts it to the given template type if needed.
Definition Field3DFileHDF5.h:491
Field3DInputFileHDF5::readVectorLayers
Field< FIELD3D_VEC3_T< Data_T > >::Vec readVectorLayers(const std::string &layerName=std::string("")) const
Retrieves all the layers of vector type and maintains their on-disk data types.
Definition Field3DFileHDF5.h:981
Field3DInputFileHDF5::Field3DInputFileHDF5
Field3DInputFileHDF5()
Definition Field3DFileHDF5.cpp:572
Field3DInputFileHDF5::readVectorLayer
Field< FIELD3D_VEC3_T< Data_T > >::Ptr readVectorLayer(const std::string &intPartitionName, const std::string &layerName) const
Retrieves a single layer given its and its parent partition's name. Maintains the on-disk data types.
Definition Field3DFileHDF5.h:1369
Field3DInputFileHDF5::readProxyScalarLayers
EmptyField< Data_T >::Vec readProxyScalarLayers(const std::string &name=std::string("")) const
Retrieves a proxy version (EmptyField) of each scalar layer.
Definition Field3DFileHDF5.h:1289
Field3DInputFileHDF5::readVectorLayersAs
Field_T< FIELD3D_VEC3_T< Data_T > >::Vec readVectorLayersAs(const std::string &partitionName, const std::string &layerName) const
Retrieves a layers given their and its parent partition's name. Converts it to the given template typ...
Definition Field3DFileHDF5.h:595
Field3DInputFileHDF5::readLayer
Field< Data_T >::Ptr readLayer(const std::string &intPartitionName, const std::string &layerName, bool isVectorLayer) const
This call does the actual reading of a layer. Notice that it expects a unique -internal- partition na...
Definition Field3DFileHDF5.h:1052
Field3DOutputFileHDF5
Provides writing of .f3d (internally, hdf5) files.
Definition Field3DFileHDF5.h:765
Field3DOutputFileHDF5::createNewPartition
FileHDF5::Partition::Ptr createNewPartition(const std::string &partitionName, const std::string &layerName, typename Field< Data_T >::Ptr field)
create newPartition given the input config
Definition Field3DFileHDF5.h:1381
Field3DOutputFileHDF5::CreateMode
CreateMode
Definition Field3DFileHDF5.h:773
Field3DOutputFileHDF5::OverwriteMode
@ OverwriteMode
Definition Field3DFileHDF5.h:774
Field3DOutputFileHDF5::FailOnExisting
@ FailOnExisting
Definition Field3DFileHDF5.h:775
Field3DOutputFileHDF5::Field3DInputFile
friend class Field3DInputFile
Definition Field3DFileHDF5.h:768
Field3DOutputFileHDF5::Field3DOutputFile
friend class Field3DOutputFile
Definition Field3DFileHDF5.h:769
Field3DOutputFileHDF5::writeVectorLayer
bool writeVectorLayer(const std::string &layerName, typename Field< FIELD3D_VEC3_T< Data_T > >::Ptr layer)
Writes a vector layer to the "Default" partition.
Definition Field3DFileHDF5.h:801
Field3DOutputFileHDF5::writeMapping
bool writeMapping(hid_t partitionLocation, FieldMapping::Ptr mapping)
Writes the mapping to the given hdf5 node. Mappings are assumed to be light-weight enough to be store...
Definition Field3DFileHDF5.cpp:1297
Field3DOutputFileHDF5::writeMetadata
bool writeMetadata(hid_t metadataGroup, FieldBase::Ptr layer)
Writes metadata for this layer.
Definition Field3DFileHDF5.cpp:1320
Field3DOutputFileHDF5::writeLayer
bool writeLayer(const std::string &partitionName, const std::string &layerName, bool isVectorLayer, typename Field< Data_T >::Ptr layer)
Performs the actual writing of the layer to disk.
Definition Field3DFileHDF5.h:1447
Field3DOutputFileHDF5::Field3DOutputFileHDF5
Field3DOutputFileHDF5()
Definition Field3DFileHDF5.cpp:1223
Field3DOutputFileHDF5::writeScalarLayer
bool writeScalarLayer(const std::string &layerName, typename Field< Data_T >::Ptr layer)
Writes a scalar layer to the "Default" partition.
Definition Field3DFileHDF5.h:795
Field3DOutputFileHDF5::incrementPartitionName
std::string incrementPartitionName(std::string &pname)
increment the partition or make it zero if there's not an integer suffix
Definition Field3DFileHDF5.cpp:1546
FieldBase::Ptr
boost::intrusive_ptr< FieldBase > Ptr
Definition Field.h:97
FieldBase::metadata
FieldMetadata & metadata()
accessor to the m_metadata class
Definition Field.h:155
FieldBase::attribute
std::string attribute
Optional name of the attribute the field represents.
Definition Field.h:173
FieldBase::name
std::string name
Optional name of the field.
Definition Field.h:171
FieldCache
Definition FieldCache.h:81
FieldCache::cacheField
void cacheField(FieldPtr field, const std::string &filename, const std::string &layerPath)
Adds the given field to the cache.
Definition FieldCache.h:169
FieldCache::singleton
static FieldCache & singleton()
Returns a reference to the FieldCache singleton.
Definition FieldCache.h:135
FieldCache::getCachedField
FieldPtr getCachedField(const std::string &filename, const std::string &layerPath)
Checks the cache for a previously loaded field.
Definition FieldCache.h:148
FieldIO::Ptr
boost::intrusive_ptr< FieldIO > Ptr
Definition FieldIO.h:91
FieldMapping::Ptr
boost::intrusive_ptr< FieldMapping > Ptr
Definition FieldMapping.h:92
FieldMetadata
Definition FieldMetadata.h:85
FieldMetadata::setIntMetadata
void setIntMetadata(const std::string &name, const int val)
Set the a int value for the given metadata name.
Definition FieldMetadata.cpp:91
FieldRes::setMapping
void setMapping(FieldMapping::Ptr mapping)
Sets the field's mapping.
Definition Field.h:347
FieldRes::Ptr
boost::intrusive_ptr< FieldRes > Ptr
Definition Field.h:213
FieldRes::mapping
FieldMapping::Ptr mapping()
Returns a pointer to the mapping.
Definition Field.h:263
Field
Definition Field.h:390
Field::Vec
std::vector< Ptr > Vec
This is a convenience typedef for the list that Field3DInputFile::readScalarLayers() and Field3DInput...
Definition Field.h:403
Field::Ptr
boost::intrusive_ptr< Field > Ptr
Definition Field.h:395
FileHDF5::Layer
Definition Field3DFileHDF5.h:121
FileHDF5::Layer::parent
std::string parent
The name of the parent partition. We need this in order to open its group.
Definition Field3DFileHDF5.h:127
FileHDF5::Layer::name
std::string name
The name of the layer (always available).
Definition Field3DFileHDF5.h:124
FileHDF5::Partition
Definition Field3DFileHDF5.h:146
FileHDF5::Partition::class_type
Partition class_type
Definition Field3DFileHDF5.h:157
FileHDF5::Partition::Ptr
boost::intrusive_ptr< Partition > Ptr
Definition Field3DFileHDF5.h:152
FileHDF5::Partition::CPtr
boost::intrusive_ptr< const Partition > CPtr
Definition Field3DFileHDF5.h:153
FileHDF5::Partition::Partition
Partition()
Ctor.
Definition Field3DFileHDF5.h:168
FileHDF5::Partition::VectorLayerList
std::vector< Layer > VectorLayerList
Definition Field3DFileHDF5.h:150
FileHDF5::Partition::name
std::string name
Name of the partition.
Definition Field3DFileHDF5.h:201
FileHDF5::Partition::DEFINE_FIELD_RTTI_CONCRETE_CLASS
DEFINE_FIELD_RTTI_CONCRETE_CLASS
Definition Field3DFileHDF5.h:158
FileHDF5::Partition::base
RefBase base
Convenience typedef for referring to base class.
Definition Field3DFileHDF5.h:217
FileHDF5::Partition::m_vectorLayers
VectorLayerList m_vectorLayers
The vector-valued layers belonging to this partition.
Definition Field3DFileHDF5.h:212
FileHDF5::Partition::staticClassType
static const char * staticClassType()
Definition Field3DFileHDF5.h:160
FileHDF5::Partition::mapping
FieldMapping::Ptr mapping
Pointer to the mapping object.
Definition Field3DFileHDF5.h:203
FileHDF5::Partition::ScalarLayerList
std::vector< Layer > ScalarLayerList
Definition Field3DFileHDF5.h:149
FileHDF5::Partition::m_scalarLayers
ScalarLayerList m_scalarLayers
The scalar-valued layers belonging to this partition.
Definition Field3DFileHDF5.h:210
Hdf5Util::H5Base::id
hid_t id() const
Query the hid_t value.
Definition Hdf5Util.h:100
Hdf5Util::H5ScopedGcreate
Scoped object - creates a group on creation and closes it on destruction.
Definition Hdf5Util.h:166
Hdf5Util::H5ScopedGopen
Scoped object - opens a group on creation and closes it on destruction.
Definition Hdf5Util.h:195
MetadataCallback
Definition FieldMetadata.h:71
RefBase::operator=
RefBase & operator=(const RefBase &)
Assignment operator.
Definition RefCount.h:134
RefBase::RefBase
RefBase()
Definition RefCount.h:120
ResizableField::setSize
void setSize(const V3i &size)
Resizes the object.
Definition Field.h:913
field_dynamic_cast
Field_T::Ptr field_dynamic_cast(RefBase::Ptr field)
Dynamic cast that uses string-comparison in order to be safe even after an object crosses a shared li...
Definition RefCount.h:256
Hdf5Util::readAttribute
FIELD3D_API bool readAttribute(hid_t location, const std::string &attrName, std::string &value)
Reads a string attribute.
Hdf5Util::writeAttribute
FIELD3D_API bool writeAttribute(hid_t location, const std::string &attrName, const std::string &value)
Writes a string attribute.
Exc
Namespace for Exception objects.
Definition Exception.h:57
FIELD3D_NAMESPACE_OPEN
Definition FieldMapping.cpp:74
FileHDF5
Namespace for file I/O specifics.
Definition Field3DFileHDF5.h:111
Hdf5Util
Contains utility functions and classes for Hdf5 files.
Definition Hdf5Util.h:86
InputFileHDF5
Namespace for file input specifics.
Definition Field3DFileHDF5.h:879
InputFileHDF5::parsePartitions
FIELD3D_API herr_t parsePartitions(hid_t loc_id, const char *partitionName, const H5L_info_t *linfo, void *opdata)
Gets called from readPartitionAndLayerInfo to check each group found under the root of the file....
Definition Field3DFileHDF5.cpp:1130
InputFileHDF5::parseLayers
FIELD3D_API herr_t parseLayers(hid_t loc_id, const char *partitionName, const H5L_info_t *linfo, void *opdata)
Gets called from readPartitionAndLayerInfo to check each group found under the root of the file....
Definition Field3DFileHDF5.cpp:1170
Msg::SevWarning
@ SevWarning
Definition Log.h:68
Msg::print
FIELD3D_API void print(Severity severity, const std::string &message)
Sends the string to the assigned output, prefixing the message with the severity.
Definition Log.cpp:70
ns.h
FIELD3D_API
#define FIELD3D_API
Definition ns.h:77
FIELD3D_NAMESPACE_HEADER_CLOSE
#define FIELD3D_NAMESPACE_HEADER_CLOSE
Definition ns.h:58
DataTypeTraits::typeEnum
static DataTypeEnum typeEnum()
Field3DFileHDF5Base::LayerInfo::name
std::string name
Definition Field3DFileHDF5.h:247
Field3DFileHDF5Base::LayerInfo::components
int components
Definition Field3DFileHDF5.h:249
Field3DFileHDF5Base::LayerInfo::LayerInfo
LayerInfo(std::string par, std::string nm, int cpt)
Definition Field3DFileHDF5.h:250
Field3DFileHDF5Base::LayerInfo::parentName
std::string parentName
Definition Field3DFileHDF5.h:248
Vec
InputFileHDF5::ParseLayersInfo
struct used to pass the class and partition info back to the parseLayers() callback
Definition Field3DFileHDF5.h:885
InputFileHDF5::ParseLayersInfo::file
Field3DInputFileHDF5 * file
Definition Field3DFileHDF5.h:886
InputFileHDF5::ParseLayersInfo::partitionName
std::string partitionName
Definition Field3DFileHDF5.h:887