bool loadStackHDF5( const char* fileName, Image4DSimple& img )
{
#ifdef USE_HDF5
H5::Exception::dontPrint();
H5::H5File file( fileName, H5F_ACC_RDONLY );
for ( size_t i = 0; i < file.getObjCount(); i++ )
{
H5std_string name = file.getObjnameByIdx( i );
if ( name == "Channels" )
{
H5::Group channels = file.openGroup( name );
// Grab the attributes
H5::Attribute attr = channels.openAttribute( "width" );
H5::DataType type = attr.getDataType();
long width, height;
attr.read( type, &width );
attr.close();
attr = channels.openAttribute( "height" );
attr.read( type, &height );
attr.close();
int num_channels = 0;
// Count the number of channels
for ( size_t obj = 0; obj < channels.getNumObjs(); obj++ )
if ( channels.getObjTypeByIdx( obj ) == H5G_DATASET )
num_channels++;
int channel_idx = 0;
for ( size_t obj = 0; obj < channels.getNumObjs(); obj++ )
{
if ( channels.getObjTypeByIdx( obj ) == H5G_DATASET )
{
H5std_string ds_name = channels.getObjnameByIdx( obj );
H5::DataSet data = channels.openDataSet( ds_name );
uint8_t* buffer = new uint8_t[ data.getStorageSize() ];
data.read( buffer, data.getDataType() );
QByteArray qbarray( ( const char* )buffer, data.getStorageSize() );
data.close();
if ( !loadIndexedStackFFMpeg( &qbarray, img, channel_idx++, num_channels,
width, height ) )
{
v3d_msg( "Error happened in HDF file reading. Stop. \n", false );
return false;
}
delete [] buffer;
}
}
}
}
#endif
return true;
}
inline typename boost::enable_if<is_multi_array<T>, T>::type
read_attribute(H5::H5Object const& object, std::string const& name)
{
typedef typename T::element value_type;
enum { rank = T::dimensionality };
H5::Attribute attr;
try {
H5XX_NO_AUTO_PRINT(H5::AttributeIException);
attr = object.openAttribute(name);
}
catch (H5::AttributeIException const&) {
throw;
}
H5::DataSpace ds(attr.getSpace());
if (!has_rank<rank>(attr)) {
throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace");
}
hsize_t dim[rank];
ds.getSimpleExtentDims(dim);
boost::array<size_t, rank> shape;
std::copy(dim, dim + rank, shape.begin());
boost::multi_array<value_type, rank> value(shape);
attr.read(ctype<value_type>::hid(), value.origin());
return value;
}
inline typename boost::enable_if<boost::is_same<T, std::string>, T>::type
read_attribute(H5::H5Object const& object, std::string const& name)
{
H5::Attribute attr;
try {
H5XX_NO_AUTO_PRINT(H5::AttributeIException);
attr = object.openAttribute(name);
}
catch (H5::AttributeIException const&) {
throw;
}
if (!has_scalar_space(attr)) {
throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace");
}
H5::DataType tid = attr.getDataType();
std::string value;
if (!tid.isVariableStr()) {
// read fixed-size string, allocate space in advance and let the HDF5
// library take care about NULLTERM and NULLPAD strings
value.resize(tid.getSize(), std::string::value_type());
attr.read(tid, &*value.begin());
}
else {
// read variable-length string, memory will be allocated by HDF5 C
// library and must be freed by us
char *c_str;
if (H5Aread(attr.getId(), tid.getId(), &c_str) < 0) {
throw H5::AttributeIException("Attribute::read", "H5Aread failed");
}
value = c_str; // copy '\0'-terminated string
free(c_str);
}
return value;
}
inline typename boost::enable_if<boost::mpl::and_<
is_vector<T>, boost::is_fundamental<typename T::value_type>
>, T>::type
read_attribute(H5::H5Object const& object, std::string const& name)
{
typedef typename T::value_type value_type;
H5::Attribute attr;
try {
H5XX_NO_AUTO_PRINT(H5::AttributeIException);
attr = object.openAttribute(name);
}
catch (H5::AttributeIException const&) {
throw;
}
H5::DataSpace ds(attr.getSpace());
if (!ds.isSimple()) {
throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace");
}
size_t size = ds.getSimpleExtentNpoints();
std::vector<value_type> value(size);
attr.read(ctype<value_type>::hid(), &*value.begin());
return value;
}
OXSXDataSet
DataSetIO::LoadDataSet(const std::string& filename_){
// Get Data Set
H5::H5File file(filename_, H5F_ACC_RDONLY);
H5::DataSet dataSet = file.openDataSet("observations");
// read meta information
unsigned nObs = 0;
H5::Attribute nameAtt = dataSet.openAttribute("observed_quantities");
H5::Attribute countAtt = dataSet.openAttribute("n_observables");
H5std_string strreadbuf("");
nameAtt.read(nameAtt.getDataType(), strreadbuf);
countAtt.read(countAtt.getDataType(), &nObs);
// Read data out as 1D array
hsize_t nData = 0;
dataSet.getSpace().getSimpleExtentDims(&nData, NULL);
size_t nEntries = nData/nObs;
std::vector<double> flatData(nData, 0);
dataSet.read(&flatData.at(0), H5::PredType::NATIVE_DOUBLE);
assert(nData%nObs == 0); // logic error in writing file (this class!) if assert fails.
// Assemble into an OXSX data set
OXSXDataSet oxsxDataSet;
// Set the variable names
oxsxDataSet.SetObservableNames(UnpackString(strreadbuf, fDelimiter));
// then the data
std::vector<double> oneEventObs(nObs, 0);
for(size_t i = 0; i < nEntries; i++){
for(size_t j = 0; j < nObs; j++)
oneEventObs[j] = flatData.at(i * nObs + j);
oxsxDataSet.AddEntry(EventData(oneEventObs));
}
return oxsxDataSet;
}
bool ossim_hdf5::getGroupAttributeValue( H5::H5File* file,
const std::string& group,
const std::string& key,
std::string& value )
{
static const char MODULE[] = "ossim_hdf5::getGroupAttributeValue";
bool result = false;
if ( file )
{
try // HDF5 library throws exceptions so wrap with try{}catch...
{
// Open the root group:
H5::Group* h5Group = new H5::Group( file->openGroup( group ) );
// Lookw for key:
H5::Attribute attr = h5Group->openAttribute( key );
std::string name = attr.getName();
H5::DataType type = attr.getDataType();
H5T_class_t typeClass = attr.getTypeClass();
if ( ( name == key ) && ( typeClass == H5T_STRING ) )
{
attr.read( type, value );
result = true;
}
// Cleanup:
attr.close();
h5Group->close();
delete h5Group;
h5Group = 0;
}
catch( const H5::Exception& e )
{
if (traceDebug())
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " WARNING: Caught exception!\n"
<< e.getDetailMsg() << std::endl;
}
}
catch( ... )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " WARNING: Caught unknown exception!" << std::endl;
}
}
return result;
} // End: ossim_hdf5::getGroupAttributeValue
std::string read_string_attr(H5::H5File &f, H5::Group &group, const char *name)
{
std::string strreadbuf ("");
H5::Attribute attr = group.openAttribute(name);
H5::StrType strdatatype(H5::PredType::C_S1, attr.getStorageSize());
attr.read(strdatatype, strreadbuf);
return strreadbuf;
}
void ReadAttrib(const std::string& name, T& value, const H5::DataType& dType){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
//access the built-in root group and create a new attribute for it.
H5::Group rootGroup = file_->openGroup("/");
H5::Attribute attrib = rootGroup.openAttribute(name);
//write the value to the attribute and close
attrib.read(dType,reinterpret_cast<void*>(&value));
attrib.close();
}
void Bundle2::loadParameters(H5::H5File& file) {
H5::Group root = file.openGroup("/");
// Checking version
unsigned int fileVersion;
H5::Attribute attr = root.openAttribute("version");
attr.read(H5::PredType::NATIVE_UINT, &fileVersion);
attr.close();
if(fileVersion != version_) throw std::runtime_error("Incompatible bundle version!");
// Reading number of cameras
hsize_t count;
H5::Group frame0Group = root.openGroup("POI/Frame 0000");
attr = frame0Group.openAttribute("count");
attr.read(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
frame0Group.close();
numCameras_ = count;
// Reading parameters
unsigned char r2;
attr = root.openAttribute("reduce2");
attr.read(H5::PredType::NATIVE_UCHAR, &r2);
attr.close();
parameters_.reduce2 = (r2 == 1);
attr = root.openAttribute("xROI");
attr.read(H5::PredType::NATIVE_UINT, ¶meters_.xROI);
attr.close();
attr = root.openAttribute("yROI");
attr.read(H5::PredType::NATIVE_UINT, ¶meters_.yROI);
attr.close();
root.close();
}
bool ossim_hdf5::getDatasetAttributeValue( H5::H5File* file,
const std::string& objectName,
const std::string& key,
std::string& value )
{
static const char MODULE[] = "ossim_hdf5::getDatasetAttributeValue";
bool result = false;
if ( file )
{
try // HDF5 library throws exceptions so wrap with try{}catch...
{
// Open the dataset:
H5::DataSet dataset = file->openDataSet( objectName );
// Lookw for key:
H5::Attribute attr = dataset.openAttribute( key );
std::string name = attr.getName();
H5::DataType type = attr.getDataType();
H5T_class_t typeClass = attr.getTypeClass();
if ( ( name == key ) && ( typeClass == H5T_STRING ) )
{
attr.read( type, value );
result = true;
}
// Cleanup:
attr.close();
dataset.close();
}
catch( const H5::Exception& e )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " WARNING: Caught exception!\n"
<< e.getDetailMsg() << std::endl;
}
catch( ... )
{
ossimNotify(ossimNotifyLevel_WARN)
<< MODULE << " WARNING: Caught unknown exception!" << std::endl;
}
}
return result;
} // End: ossim_hdf5::getDatasetAttributeValue
void ReadTAttrib(const int& tableNum, const std::string& name,
T& value, const H5::DataType& dType){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
//std::cout << "attribute read name = " << name << std::endl;
std::string tNum = Num2Table(tableNum);
//open data set and read attribute "name"
dSet_ = file_->openDataSet(tNum);
H5::Attribute attrib = dSet_.openAttribute(name);
//write the value to the attribute and close
attrib.read(dType,reinterpret_cast<void*>(&value));
attrib.close();
}
const std::string ReadStrAttrib(const std::string& name){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
std::string value;
value.resize( STRING_ATTRIB_SIZE );
H5::StrType strType(0, STRING_ATTRIB_SIZE );
//access the built-in root group and create a new attribute for it.
H5::Group rootGroup = file_->openGroup("/");
H5::Attribute attrib = rootGroup.openAttribute(name);
//write the value to the attribute and close
attrib.read(strType,value);
attrib.close();
return value;
}
inline typename boost::enable_if<boost::is_fundamental<T>, T>::type
read_attribute(H5::H5Object const& object, std::string const& name)
{
H5::Attribute attr;
try {
H5XX_NO_AUTO_PRINT(H5::AttributeIException);
attr = object.openAttribute(name);
}
catch (H5::AttributeIException const&) {
throw;
}
if (!has_scalar_space(attr)) {
throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace");
}
T value;
attr.read(ctype<T>::hid(), &value);
return value;
}
size_t H5Signal::clock_size(void)
/*-----------------------------*/
{
try {
H5::Attribute attr = dataset.openAttribute("clock") ;
hobj_ref_t ref ;
attr.read(H5::PredType::STD_REF_OBJ, &ref) ;
attr.close() ;
H5::DataSet clk(H5Rdereference(H5Iget_file_id(dataset.getId()), H5R_OBJECT, &ref)) ;
H5::DataSpace cspace = clk.getSpace() ;
int cdims = cspace.getSimpleExtentNdims() ;
hsize_t cshape[cdims] ;
cspace.getSimpleExtentDims(cshape) ;
return cshape[0] ;
}
catch (H5::AttributeIException e) { }
return -1 ;
}
inline typename boost::enable_if<boost::mpl::and_<
is_vector<T>
, boost::is_same<typename T::value_type, std::string>
>, T>::type
read_attribute(H5::H5Object const& object, std::string const& name)
{
H5::Attribute attr;
try {
H5XX_NO_AUTO_PRINT(H5::AttributeIException);
attr = object.openAttribute(name);
}
catch (H5::AttributeIException const&) {
throw;
}
H5::DataSpace ds(attr.getSpace());
if (!ds.isSimple()) {
throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace");
}
size_t size = ds.getSimpleExtentNpoints();
H5::DataType tid = attr.getDataType();
if (tid.isVariableStr()) {
throw error("reading non-scalar attribute of variable-length strings not supported");
}
size_t str_len = tid.getSize();
// read to contiguous buffer and copy to std::vector
std::vector<char> buffer(str_len * size);
attr.read(tid, &*buffer.begin());
T value;
value.reserve(size);
char const* s = buffer.data();
for (size_t i = 0; i < size; ++i, s += str_len) {
size_t len = strnlen(s, str_len); // strings of str_len size are not '\0'-terminated
value.push_back(std::string(s, len)); // copy len bytes from buffer
}
return value;
}
const std::string ReadTStrAttrib(const int& tableNum, const std::string& name){
//attributes are clunky in HDF5++ implementation - this is a workaround
//template is required to pass the proper value type
std::string tNum = Num2Table(tableNum);
std::string value;
value.resize( STRING_ATTRIB_SIZE );
//std::cout << "attribute string read name = " << tNum << std::endl;
H5::StrType strType(0, STRING_ATTRIB_SIZE );
dSet_ = file_->openDataSet(tNum);
H5::Attribute attrib = dSet_.openAttribute(name);
//write the value to the attribute and close
attrib.read(strType,value);
attrib.close();
return value;
}
/// Return the attribute name of obj, and "" if the attribute does not exist.
inline std::string read_string_attribute (H5::H5Object const * obj, std::string name ) {
std::string value ="";
H5::Attribute attr;
if (H5LTfind_attribute(obj -> getId(), name.c_str() )==0) return value;// not present
// can not find how to get the size with hl. Using full interface
//herr_t err2 = H5LTget_attribute_string(gr.getId(), x.c_str(), name.c_str() , &(buf.front()) ) ;
//value.append( &(buf.front()) );
try { attr= obj->openAttribute(name.c_str());}
catch (H5::AttributeIException) { return value;}
try {
H5::DataSpace dataspace = attr.getSpace();
int rank = dataspace.getSimpleExtentNdims();
if (rank != 0) TRIQS_RUNTIME_ERROR << "Reading a string attribute and got rank !=0";
size_t size = attr.getStorageSize();
H5::StrType strdatatype(H5::PredType::C_S1, size+1);
std::vector<char> buf(size+1, 0x00);
attr.read(strdatatype, (void *)(&buf[0]));
value.append( &(buf.front()) );
}
TRIQS_ARRAYS_H5_CATCH_EXCEPTION;
return value;
}
inline typename boost::enable_if<boost::mpl::and_<is_array<T>, boost::is_fundamental<typename T::value_type> >, T>::type
read_attribute(H5::H5Object const& object, std::string const& name)
{
typedef typename T::value_type value_type;
enum { size = T::static_size };
H5::Attribute attr;
try {
H5XX_NO_AUTO_PRINT(H5::AttributeIException);
attr = object.openAttribute(name);
}
catch (H5::AttributeIException const&) {
throw;
}
if (!has_extent<T>(attr)) {
throw H5::AttributeIException("H5::attribute::as", "incompatible dataspace");
}
T value;
attr.read(ctype<value_type>::hid(), &*value.begin());
return value;
}
Bundle2::Bundle2(const boost::filesystem::path& fileName, bool loadGeometry):
version_(BUNDLE_VERSION), poiFirstFrame_(0) {
// Opening file
H5::H5File bundleFile;
bundleFile.openFile(fileName.string(), H5F_ACC_RDONLY);
loadParameters(bundleFile);
// Loading POI
H5::Group poiGroup = bundleFile.openGroup("/POI");
hsize_t count;
H5::Attribute attr = poiGroup.openAttribute("count");
attr.read(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
for(size_t frame = 0; frame < count; ++frame) {
cout.flush();
const std::string frameGroupName = boost::str(boost::format("Frame %1$04d") % frame);
H5::Group frameGroup = poiGroup.openGroup(frameGroupName);
addPOIFrame();
for(size_t camera = 0; camera < numCameras_; ++camera)
poi_[poi_.size() - 1][camera].load(frameGroup, camera);
frameGroup.close();
}
poiGroup.close();
// Loading frames
H5::Group bundleGroup = bundleFile.openGroup("/Bundle");
H5::Group framesGroup = bundleGroup.openGroup("Frames");
attr = framesGroup.openAttribute("count");
attr.read(H5::PredType::NATIVE_HSIZE, &count);
attr.close();
for(size_t frame = 0; frame < count; ++frame) {
Frame* f = new Frame(framesGroup, frame, numCameras_);
frames_.push_back(f);
}
framesGroup.close();
// Loading tracks
H5::DataSet tracksDataset = bundleGroup.openDataSet("Tracks");
hsize_t tracksDim[2];
H5::DataSpace tracksDS = tracksDataset.getSpace();
tracksDS.getSimpleExtentDims(tracksDim);
tracksDS.close();
for(size_t i = 0; i < tracksDim[0]; ++i) {
size_t j = addTrack();
tracks_[j]->load(tracksDataset, frames_, i);
}
tracksDataset.close();
bundleGroup.close();
if(loadGeometry && checkGeometry_(bundleFile)) loadGeometry_(bundleFile);
bundleFile.close();
}
H5RandomReader::H5RandomReader(const std::string fileName, const std::string groupPath) throw (InvalidFileException) {
try {
file.openFile(fileName, H5F_ACC_RDONLY);}
catch ( H5::FileIException ) {
throw InvalidFileException("Cannot acces file");}
try {
group = file.openGroup(groupPath);}
catch ( H5::GroupIException ) {
file.close();
throw InvalidFileException("Cannot access group");}
/*
* extract timeline. This is also necessary to get the nbSteps.
*/
try {
timeline = group.openDataSet("timeline");
nSteps = timeline.getSpace().getSimpleExtentNpoints();}
catch ( H5::DataSetIException error ) {
//error.printError();
group.close();
file.close();
throw InvalidFileException("Cannot access timeline dataset");}
if (logging::info)
std::cerr << "Opened group \"" << fileName << groupPath << "\" which has " << nSteps << " steps.\n";
/*
* extract objects names in the xpGroup
*/
std::vector<std::string> names;
H5Literate(group.getId(), H5_INDEX_NAME, H5_ITER_INC, NULL, iterInGroup, &names);
/*
* extract data from object in xpGroup
* these data can be of 3 types: matrix, translate or wrench
* each data are saved in related map
*/
for (unsigned int i=0; i<names.size(); i++){ //TODO: skip timeline
H5::DataSet dSet = group.openDataSet(names[i]);
if (H5Aexists(dSet.getId(), "ArborisViewerType")) {
H5::Attribute att = dSet.openAttribute("ArborisViewerType");
std::string type;
att.read(att.getDataType(), type);
if (type == "matrix"){
H5::DataSpace dSpace = dSet.getSpace();
bool dimension_ok = false;
if (dSpace.getSimpleExtentNdims()==3) {
hsize_t dims[3];
dSpace.getSimpleExtentDims (dims);
if (dims[0] == nSteps && dims[1] == 4 && dims[2] == 4)
dimension_ok = true;}
if (dimension_ok)
matrices[names[i]] = dSet;
else {
if (logging::warning)
std::cerr << "Skipping dataset \"" << names[i] << "\" which has wrong dimensions. I was expecting (" << nSteps << ",4,4).\n";
dSet.close();}}
else if (type == "translate"){
H5::DataSpace dSpace = dSet.getSpace();
bool dimension_ok = false;
if (dSpace.getSimpleExtentNdims()==2) {
hsize_t dims[2];
dSpace.getSimpleExtentDims (dims);
if (dims[0] == nSteps && dims[1] == 3)
dimension_ok = true;}
if (dimension_ok)
translates[names[i]] = dSet;
else {
if (logging::warning)
std::cerr << "Skipping dataset \"" << names[i] << "\" which has wrong dimensions. I was expecting (" << nSteps << ",3).\n";
dSet.close();}}
else if (type == "wrench") {
H5::DataSpace dSpace = dSet.getSpace();
bool dimension_ok = false;
if (dSpace.getSimpleExtentNdims()==2) {
hsize_t dims[2];
dSpace.getSimpleExtentDims (dims);
if (dims[0] == nSteps && dims[1] == 6)
dimension_ok = true;}
if (dimension_ok)
wrenches[names[i]] = dSet;
else {
if (logging::warning)
std::cerr << "Skipping dataset \"" << names[i] << "\" which as wrong dimensions. I was expecting (" << nSteps << ",6).\n";
dSet.close();}}
else {
if (logging::warning)
std::cerr << "Skipping dataset \"" << names[i] << "\" whose ArborisViewerType attribute as unknown value \"" << type << "\".\n";
dSet.close();}
att.close();
}
else {
if (logging::info)
std::cerr << "Skipping dataset \"" << names[i] << "\" which has no ArborisViewerType attribute.\n";
dSet.close();
}
}
};
void DataSet::readAttr(const H5::Attribute &attr, H5::DataType mem_type, const NDSize &size, std::string *data) {
StringWriter writer(size, data);
attr.read(mem_type, *writer);
writer.finish();
H5::DataSet::vlenReclaim(*writer, mem_type, attr.getSpace()); //recycle space?
}
void DataSet::readAttr(const H5::Attribute &attr, H5::DataType mem_type, const NDSize &size, void *data) {
attr.read(mem_type, data);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(DISABLED_HDFTests, BasicFileRead)
{
std::string file_path = "D:/ResInsight/SourSim/PKMUNK_NOV_TEST_SS.sourpre.00001";
try
{
H5::Exception::dontPrint(); // Turn off auto-printing of failures to handle the errors appropriately
H5::H5File file(file_path.c_str(), H5F_ACC_RDONLY);
{
H5::Group timestep = file.openGroup("Timestep_00001");
H5::Attribute attr = timestep.openAttribute("timestep");
double timestep_value = 0.0;
H5::DataType type = attr.getDataType();
attr.read(type, ×tep_value);
//std::cout << "Timestep value " << timestep_value << std::endl;
EXPECT_NEAR(timestep_value, 1.0, 1e-1);
}
{
// Group size is not an attribute!
H5::Group GridFunctions = file.openGroup("Timestep_00001/GridParts/GridPart_00000/GridFunctions");
hsize_t group_size = GridFunctions.getNumObjs();
//std::cout << "GridFunctions group_size " << group_size << std::endl;
EXPECT_EQ(size_t(20), group_size);
/* for (hsize_t i = 0; i < group_size; i++)
{
// H5std_string node_name = GridFunctions.getObjnameByIdx(i); // crashes on VS2017 due to lib/heap/runtime differences to HDF5 VS2015 lib
std::string node_name;
node_name.resize(1024);
ssize_t slen = GridFunctions.getObjnameByIdx(i, &node_name[0], 1023);
node_name.resize(slen + 1);
std::cout << "GridFunctions sub-node name " << node_name << std::endl;
}
*/
std::string first_subnode(1024, '\0');
ssize_t slen = GridFunctions.getObjnameByIdx(0, &first_subnode[0], 1023);
first_subnode.resize(slen + 1);
EXPECT_TRUE(first_subnode.compare(0, slen, "GridFunction_00002") == 0);
}
{
H5::Group GridFunction_00002 = file.openGroup("Timestep_00001/GridParts/GridPart_00000/GridFunctions/GridFunction_00002");
H5::Attribute attr = GridFunction_00002.openAttribute("limits_max");
double limits_max = 0.0;
H5::DataType type = attr.getDataType();
attr.read(type, &limits_max);
// std::cout << "limits_max " << limits_max << std::endl;
EXPECT_NEAR(limits_max, 0.3970204292629652, 1e-10);
}
{
H5::Group GridFunction_00002 = file.openGroup("Timestep_00001/GridParts/GridPart_00000/GridFunctions/GridFunction_00002");
H5::DataSet dataset = H5::DataSet(GridFunction_00002.openDataSet("values"));
hsize_t dims[2];
H5::DataSpace dataspace = dataset.getSpace();
dataspace.getSimpleExtentDims(dims, nullptr);
std::vector<double> values;
values.resize(dims[0]);
dataset.read(values.data(), H5::PredType::NATIVE_DOUBLE);
/* for (hsize_t i = 0; i < dims[0]; i++)
{
std::cout << "value " << i << " " << values[i] << std::endl;
}
*/
EXPECT_NEAR(values[0], 0.32356910366452146, 1e-10);
EXPECT_NEAR(values[dims[0] - 1], 0.12200070891582514, 1e-10);
}
} // end of try block
catch (H5::FileIException error) // catch failure caused by the H5File operations
{
std::cout << error.getCDetailMsg();
}
catch (H5::DataSetIException error) // catch failure caused by the DataSet operations
{
std::cout << error.getCDetailMsg();
}
catch (H5::DataSpaceIException error) // catch failure caused by the DataSpace operations
{
std::cout << error.getCDetailMsg();
}
catch (H5::DataTypeIException error) // catch failure caused by the DataSpace operations
{
std::cout << error.getCDetailMsg();
}
}
bool TStellarData::load(const std::string& fname, const std::string& group, const std::string& dset,
double err_floor, double default_EBV) {
H5::H5File *file = H5Utils::openFile(fname);
if(file == NULL) { return false; }
H5::Group *gp = H5Utils::openGroup(file, group);
if(gp == NULL) {
delete file;
return false;
}
H5::DataSet dataset = gp->openDataSet(dset);
/*
* Photometry
*/
// Datatype
hsize_t nbands = NBANDS;
H5::ArrayType f4arr(H5::PredType::NATIVE_FLOAT, 1, &nbands);
H5::ArrayType u4arr(H5::PredType::NATIVE_UINT32, 1, &nbands);
H5::CompType dtype(sizeof(TFileData));
dtype.insertMember("obj_id", HOFFSET(TFileData, obj_id), H5::PredType::NATIVE_UINT64);
dtype.insertMember("l", HOFFSET(TFileData, l), H5::PredType::NATIVE_DOUBLE);
dtype.insertMember("b", HOFFSET(TFileData, b), H5::PredType::NATIVE_DOUBLE);
dtype.insertMember("mag", HOFFSET(TFileData, mag), f4arr);
dtype.insertMember("err", HOFFSET(TFileData, err), f4arr);
dtype.insertMember("maglimit", HOFFSET(TFileData, maglimit), f4arr);
dtype.insertMember("nDet", HOFFSET(TFileData, N_det), u4arr);
dtype.insertMember("EBV", HOFFSET(TFileData, EBV), H5::PredType::NATIVE_FLOAT);
// Dataspace
hsize_t length;
H5::DataSpace dataspace = dataset.getSpace();
dataspace.getSimpleExtentDims(&length);
// Read in dataset
TFileData* data_buf = new TFileData[length];
dataset.read(data_buf, dtype);
//std::cerr << "# Read in dimensions." << std::endl;
// Fix magnitude limits
for(int n=0; n<nbands; n++) {
float tmp;
float maglim_replacement = 25.;
// Find the 95th percentile of valid magnitude limits
std::vector<float> maglimit;
for(hsize_t i=0; i<length; i++) {
tmp = data_buf[i].maglimit[n];
if((tmp > 10.) && (tmp < 40.) && (!isnan(tmp))) {
maglimit.push_back(tmp);
}
}
//std::sort(maglimit.begin(), maglimit.end());
if(maglimit.size() != 0) {
maglim_replacement = percentile(maglimit, 95.);
}
// Replace missing magnitude limits with the 95th percentile magnitude limit
for(hsize_t i=0; i<length; i++) {
tmp = data_buf[i].maglimit[n];
if(!((tmp > 10.) && (tmp < 40.)) || isnan(tmp)) {
//std::cout << i << ", " << n << ": " << tmp << std::endl;
data_buf[i].maglimit[n] = maglim_replacement;
}
}
}
//int n_filtered = 0;
//int n_M_dwarfs = 0;
TMagnitudes mag_tmp;
for(size_t i=0; i<length; i++) {
mag_tmp.set(data_buf[i], err_floor);
star.push_back(mag_tmp);
//int n_informative = 0;
// Remove g-band
//mag_tmp.m[0] = 0.;
//mag_tmp.err[0] = 1.e10;
//double g_err = mag_tmp.err[0];
//mag_tmp.err[0] = sqrt(g_err*g_err + 0.1*0.1);
// Filter bright end
// TODO: Put this into query_lsd.py
/*for(int j=0; j<NBANDS; j++) {
if((mag_tmp.err[j] < 1.e9) && (mag_tmp.m[j] < 14.)) {
mag_tmp.err[j] = 1.e10;
mag_tmp.m[j] = 0.;
}
if(mag_tmp.err[j] < 1.e9) {
n_informative++;
}
}*/
// Filter M dwarfs based on color cut
//bool M_dwarf = false;
/*bool M_dwarf = true;
double A_g = 3.172;
double A_r = 2.271;
double A_i = 1.682;
if(mag_tmp.m[0] - A_g / (A_g - A_r) * (mag_tmp.m[0] - mag_tmp.m[1] - 1.2) > 20.) {
M_dwarf = false;
} else if(mag_tmp.m[1] - mag_tmp.m[2] - (A_r - A_i) / (A_g - A_r) * (mag_tmp.m[0] - mag_tmp.m[1]) < 0.) {
M_dwarf = false;
} else {
n_M_dwarfs++;
}
*/
/*if(n_informative >= 4) { //&& (!M_dwarf)) {
star.push_back(mag_tmp);
} else {
n_filtered++;
}*/
}
//std::cerr << "# of stars filtered: " << n_filtered << std::endl;
//std::cerr << "# of M dwarfs: " << n_M_dwarfs << std::endl;
/*
* Attributes
*/
H5::Attribute att = dataset.openAttribute("healpix_index");
H5::DataType att_dtype = H5::PredType::NATIVE_UINT64;
att.read(att_dtype, reinterpret_cast<void*>(&healpix_index));
att = dataset.openAttribute("nested");
att_dtype = H5::PredType::NATIVE_UCHAR;
att.read(att_dtype, reinterpret_cast<void*>(&nested));
att = dataset.openAttribute("nside");
att_dtype = H5::PredType::NATIVE_UINT32;
att.read(att_dtype, reinterpret_cast<void*>(&nside));
att = dataset.openAttribute("l");
att_dtype = H5::PredType::NATIVE_DOUBLE;
att.read(att_dtype, reinterpret_cast<void*>(&l));
att = dataset.openAttribute("b");
att_dtype = H5::PredType::NATIVE_DOUBLE;
att.read(att_dtype, reinterpret_cast<void*>(&b));
att = dataset.openAttribute("EBV");
att_dtype = H5::PredType::NATIVE_DOUBLE;
att.read(att_dtype, reinterpret_cast<void*>(&EBV));
// TEST: Force l, b to anticenter
//l = 180.;
//b = 0.;
if((EBV <= 0.) || (EBV > default_EBV) || isnan(EBV)) { EBV = default_EBV; }
delete[] data_buf;
delete gp;
delete file;
return true;
}
void ossim_hdf5::printAttribute( const H5::Attribute& attr,
const std::string& prefix,
std::ostream& out )
{
std::string name = attr.getName();
H5::DataType type = attr.getDataType();
H5T_class_t typeClass = attr.getTypeClass();
size_t size = type.getSize();
std::string value; // Initialized below.
if ( ( typeClass == H5T_INTEGER ) || ( typeClass == H5T_FLOAT ) )
{
H5::IntType intType = attr.getIntType();
ossimScalarType scalar = ossim_hdf5::getScalarType( intType.getId() );
ossimByteOrder order = ossim_hdf5::getByteOrder( &attr );
ossimEndian* endian = 0;
if ( ( size > 1 ) && ( order != ossim::byteOrder() ) )
{
endian = new ossimEndian(); // If set used as flag to byte swap.
}
if ( typeClass == H5T_INTEGER )
{
switch ( scalar )
{
case OSSIM_UINT8:
{
if ( size == 1 )
{
ossim_uint8 i;
attr.read( type, (void*)&i );
value = ossimString::toString( ossim_int32(i) ).string();
}
break;
}
case OSSIM_SINT8:
{
if ( size == 1 )
{
ossim_sint8 i;
attr.read( type, (void*)&i );
value = ossimString::toString( ossim_int32(i) ).string();
}
break;
}
case OSSIM_UINT16:
{
if ( size == 2 )
{
ossim_uint16 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_SINT16:
{
if ( size == 2 )
{
ossim_sint16 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_UINT32:
{
if ( size == 4 )
{
ossim_uint32 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_SINT32:
{
if ( size == 4 )
{
ossim_sint32 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_UINT64:
{
if ( size == 8 )
{
ossim_uint64 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
case OSSIM_SINT64:
{
if ( size == 8 )
{
ossim_sint32 i;
attr.read( type, (void*)&i );
if ( endian )
{
endian->swap( i );
}
value = ossimString::toString( i ).string();
}
break;
}
default:
break;
}
}
else if ( typeClass == H5T_FLOAT )
{
if ( scalar == OSSIM_FLOAT32 )
{
if ( size == 4 )
{
ossim_float32 f;
attr.read( type, (void*)&f );
if ( endian )
{
endian->swap( f );
}
value = ossimString::toString( f ).string();
}
}
if ( scalar == OSSIM_FLOAT64 )
{
if ( size == 8 )
{
ossim_float64 f;
attr.read( type, (void*)&f );
if ( endian )
{
endian->swap( f );
}
value = ossimString::toString( f ).string();
}
}
}
if ( endian )
{
delete endian;
endian = 0;
}
}
else if ( typeClass == H5T_STRING )
{
attr.read( type, value );
}
else
{
ossimNotify(ossimNotifyLevel_DEBUG)
<< "ossimH5Util::printAttribute WARN: Unhandled type class: " << typeClass
<< std::endl;
}
out << prefix << "." << name << ": " << value << std::endl;
} // End: ossim_hdf5::printAttribute
