//-----------------------------------------------------------------------------
int MGL_EXPORT mgl_datac_read_hdf(HADT d,const char *fname,const char *data)
{
hid_t hf,hd,hs;
hsize_t dims[4];
long rank, res = H5Fis_hdf5(fname);
if(res<=0) { return false; }
hf = H5Fopen(fname, H5F_ACC_RDONLY, H5P_DEFAULT);
if(hf<0) return false;
hd = H5Dopen(hf,data);
if(hd<0) return false;
hs = H5Dget_space(hd);
rank = H5Sget_simple_extent_ndims(hs);
if(rank>0 && rank<=3)
{
H5Sget_simple_extent_dims(hs,dims,0);
if(rank==2) { dims[2]=dims[0]; dims[0]=dims[1]=1; }
else if(rank==3) { dims[2]=dims[1]; dims[1]=dims[0]; dims[0]=1; }
// else if(rank>3) continue;
mgl_datac_create(d,dims[2],dims[1],dims[0]);
#if MGL_USE_DOUBLE
H5Dread(hd, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, d->a);
#else
H5Dread(hd, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, d->a);
#endif
}
H5Sclose(hs); H5Dclose(hd); H5Fclose(hf); return true;
}
/*--- Implementations of local functions --------------------------------*/
static void
local_handleFilenameChange(gridReader_t reader)
{
assert(reader != NULL);
assert(reader->type == GRIDIO_TYPE_HDF5);
const char *fileName = filename_getFullName(reader->fileName);
int res = H5Fis_hdf5(fileName);
if (res <= 0) {
if (res == 0) {
fprintf(stderr, "ERROR: %s does not seem to be an HDF5 file.\n",
fileName);
} else {
fprintf(stderr,
"ERROR: Failed to check whether %s is a HDF5 file.\n",
fileName);
}
diediedie(EXIT_FAILURE);
}
hid_t file = H5Fopen(fileName, H5F_ACC_RDONLY, H5P_DEFAULT);
if (file < 0) {
fprintf(stderr, "ERROR: Could not open %s for reading.\n", fileName);
diediedie(EXIT_FAILURE);
}
gridReaderHDF5_setH5File((gridReaderHDF5_t)reader, file);
}
void MGL_EXPORT mgl_datac_save_hdf(HCDT dat,const char *fname,const char *data,int rewrite)
{
const mglDataC *d = dynamic_cast<const mglDataC *>(dat); // NOTE: only for mglDataC
if(!d) { mgl_data_save_hdf(dat,fname,data,rewrite); return; }
hid_t hf,hd,hs;
hsize_t dims[4];
long rank = 3, res;
H5Eset_auto(0,0);
res=H5Fis_hdf5(fname);
if(res>0 && !rewrite) hf = H5Fopen(fname, H5F_ACC_RDWR, H5P_DEFAULT);
else hf = H5Fcreate(fname, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
if(hf<0) return;
if(d->nz==1 && d->ny == 1) { rank=2; dims[0]=d->nx; dims[1]=2; }
else if(d->nz==1) { rank=3; dims[0]=d->ny; dims[1]=d->nx; dims[2]=2; }
else { rank=4; dims[0]=d->nz; dims[1]=d->ny; dims[2]=d->nx; dims[3]=2; }
hs = H5Screate_simple(rank, dims, 0);
#if MGL_USE_DOUBLE
hid_t mem_type_id = H5T_NATIVE_DOUBLE;
#else
hid_t mem_type_id = H5T_NATIVE_FLOAT;
#endif
hd = H5Dcreate(hf, data, mem_type_id, hs, H5P_DEFAULT);
H5Dwrite(hd, mem_type_id, hs, hs, H5P_DEFAULT, d->a);
H5Dclose(hd); H5Sclose(hs); H5Fclose(hf);
}
/****if* H5Ff/h5fis_hdf5_c
* NAME
* h5fis_hdf5_c
* PURPOSE
* Call H5Fis_hdf5 to determone if the file is an HDF5 file
* INPUTS
* name - name of the file
* namelen - name length
* OUTPUTS
* flag - 0 if file is not HDF5 file , positive if a file
* is an HDF5 file, and negative on failure.
* RETURNS
* 0 on success, -1 on failure
* AUTHOR
* Elena Pourmal
* Tuesday, August 3, 1999
* HISTORY
*
* SOURCE
*/
int_f
nh5fis_hdf5_c (_fcd name, int_f *namelen, int_f *flag)
/******/
{
int ret_value = -1;
char *c_name;
int_f c_namelen;
htri_t status;
/*
* Convert FORTRAN name to C name
*/
c_namelen = *namelen;
c_name = (char *)HD5f2cstring(name, (size_t)c_namelen);
if (c_name == NULL) return ret_value;
/*
* Call H5Fopen function.
*/
status = H5Fis_hdf5(c_name);
*flag = (int_f)status;
if (status >= 0) ret_value = 0;
HDfree(c_name);
return ret_value;
}
/**
* Open the HDF5 file.
* @param [in] FileName
* @param [in] Flags - flags for the HDF5 runtime
* @throw ios:failure if error happened
*
*/
void THDF5_File::Open(const char * FileName, unsigned int Flags){
if (IsOpened()) {
char ErrorMessage[256];
sprintf(ErrorMessage,HDF5_ERR_FMT_FileCannotReopen,FileName);
throw ios::failure(ErrorMessage);
};
this->FileName = FileName;
if (H5Fis_hdf5(FileName) == 0){
char ErrorMessage[256];
sprintf(ErrorMessage,HDF5_ERR_FMT_NotHDF5File,FileName);
throw ios::failure(ErrorMessage);
}
HDF5_FileId = H5Fopen( FileName, Flags, H5P_DEFAULT );
if (HDF5_FileId < 0) {
char ErrorMessage[256];
sprintf(ErrorMessage,HDF5_ERR_FMT_FileNotOpened,FileName);
throw ios::failure(ErrorMessage);
}
}// end of Open
static VALUE
rb_H5Fis_hdf5 (VALUE mod, VALUE v_name)
{
htri_t status;
status = H5Fis_hdf5(StringValuePtr(v_name));
if ( status < 0 )
rb_hdf5_raise("can't check file format is HDF5");
return ( status > 0 ) ? Qtrue : Qfalse;
}
/**
* Format detection.
* If the file is opened for read mode, HDF5's internal formast detection
* will be used. Otherwise, the function will look for a file extension match.
*/
static unsigned hdf5_is_fmt(const char* path, const char* mode)
{ char isr,isw,*e,**ext;
char **exts;
parse_mode_string(mode,&isr,&isw);
if(isr)
{ if(access(path,R_OK)==-1) return 0;
return H5Fis_hdf5(path)>0; // prints a bunch of error text -.-
}
e=(char*)strrchr(path,'.');
exts=(isw)?(char**)g_writeable_exts:(char**)g_readable_exts;
for(ext=exts;*ext;++ext)
if(strcmp(e,*ext)==0) return 1;
return 0;
}
int HDF5Dataset::Identify( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Is it an HDF5 file? */
/* -------------------------------------------------------------------- */
static const char achSignature[] = "\211HDF\r\n\032\n";
if( poOpenInfo->pabyHeader )
{
if( memcmp(poOpenInfo->pabyHeader,achSignature,8) == 0 )
{
/* The tests to avoid opening KEA and BAG drivers are not */
/* necessary when drivers are built in the core lib, as they */
/* are registered after HDF5, but in the case of plugins, we */
/* cannot do assumptions about the registration order */
/* Avoid opening kea files if the kea driver is available */
if( EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "KEA") &&
GDALGetDriverByName("KEA") != NULL )
{
return FALSE;
}
/* Avoid opening kea files if the bag driver is available */
if( EQUAL(CPLGetExtension(poOpenInfo->pszFilename), "BAG") &&
GDALGetDriverByName("BAG") != NULL )
{
return FALSE;
}
return TRUE;
}
if( memcmp(poOpenInfo->pabyHeader,"<HDF_UserBlock>",15) == 0)
{
if( H5Fis_hdf5(poOpenInfo->pszFilename) )
return TRUE;
}
}
return FALSE;
}
void pyne::Material::from_hdf5(std::string filename, std::string datapath, int row, int protocol) {
// Turn off annoying HDF5 errors
herr_t status;
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
// Check that the file is there
if (!pyne::file_exists(filename))
throw pyne::FileNotFound(filename);
// Check to see if the file is in HDF5 format.
bool ish5 = H5Fis_hdf5(filename.c_str());
if (!ish5)
throw h5wrap::FileNotHDF5(filename);
//Set file access properties so it closes cleanly
hid_t fapl;
fapl = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fclose_degree(fapl,H5F_CLOSE_STRONG);
// Open the database
hid_t db = H5Fopen(filename.c_str(), H5F_ACC_RDONLY, fapl);
bool datapath_exists = h5wrap::path_exists(db, datapath);
if (!datapath_exists)
throw h5wrap::PathNotFound(filename, datapath);
// Clear current content
comp.clear();
// Load via various protocols
if (protocol == 0)
_load_comp_protocol0(db, datapath, row);
else if (protocol == 1)
_load_comp_protocol1(db, datapath, row);
else
throw pyne::MaterialProtocolError();
// Close the database
status = H5Fclose(db);
// Renomalize the composition, just to be safe.
norm_comp();
};
int HDF5Dataset::Identify( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Is it an HDF5 file? */
/* -------------------------------------------------------------------- */
static const char achSignature[] = "\211HDF\r\n\032\n";
if( poOpenInfo->pabyHeader )
{
if( memcmp(poOpenInfo->pabyHeader,achSignature,8) == 0 )
return TRUE;
if( memcmp(poOpenInfo->pabyHeader,"<HDF_UserBlock>",15) == 0)
{
if( H5Fis_hdf5(poOpenInfo->pszFilename) )
return TRUE;
}
}
return FALSE;
}
//-*****************************************************************************
ArImpl::ArImpl( const std::string &iFileName,
AbcA::ReadArraySampleCachePtr iCache )
: m_fileName( iFileName )
, m_file( -1 )
, m_readArraySampleCache( iCache )
{
// OPEN THE FILE!
htri_t exi = H5Fis_hdf5( m_fileName.c_str() );
ABCA_ASSERT( exi == 1, "Nonexistent File: " << m_fileName );
m_file = H5Fopen( m_fileName.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT );
ABCA_ASSERT( m_file >= 0,
"Could not open file: " << m_fileName );
// get the version using HDF5 native calls
int version = -INT_MAX;
if (H5Aexists(m_file, "abc_version"))
{
H5LTget_attribute_int(m_file, ".", "abc_version", &version);
}
ABCA_ASSERT(version == ALEMBIC_HDF5_FILE_VERSION,
"Unsupported file version detected.");
// if it isn't there, it's pre 1.0
int fileVersion = 9999;
if (H5Aexists( m_file, "abc_release_version" ))
{
H5LTget_attribute_int( m_file, ".", "abc_release_version",
&fileVersion);
}
m_archiveVersion = fileVersion;
// Read the top object
m_top = new TopOrImpl( *this, m_file );
ReadTimeSamples( m_file, m_timeSamples );
}
/*--------------------------------------------------------------------------*/
int isHDF5File(const char* _pstFilename)
{
int iRet = 0;
char *pathdest = getPathFilename(_pstFilename);
char *currentpath = NULL;
char *filename = getFilenameWithExtension(_pstFilename);
int ierr = 0;
/* TO DO : remove when HDF5 will be fixed ... */
/* HDF5 does not manage no ANSI characters */
/* UGLY workaround :( */
/* We split path, move in this path, open file */
/* and return in previous place */
/* see BUG 6440 */
currentpath = scigetcwd(&ierr);
//prevent error msg to change directory to ""
if (strcmp(pathdest, "") != 0)
{
scichdir(pathdest);
}
FREE(pathdest);
iRet = H5Fis_hdf5(filename);
if (iRet == 0)
{
HDF5ErrorCleanup();
}
FREE(filename);
scichdir(currentpath);
FREE(currentpath);
return iRet > 0 ? 1 : 0;
}
void H5File::init(const hid_t fapl)
{
bool opened = false;
#if !defined(__HDF5ERROR_PRINT__)
H5Eset_auto(H5E_DEFAULT, 0, 0);
#endif
if (filename.empty())
{
throw H5Exception(__LINE__, __FILE__, _("Invalid hdf5 file: empty filename."));
}
switch (flags)
{
case RDONLY:
if (!FileExist(const_cast<char *>(filename.c_str())) || H5Fis_hdf5(filename.c_str()) <= 0)
{
throw H5Exception(__LINE__, __FILE__, _("Invalid hdf5 file: %s."), filename.c_str());
}
file = H5Fopen(filename.c_str(), H5F_ACC_RDONLY, fapl);
if (file < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot open the given hdf5 file: %s."), filename.c_str());
}
opened = true;
break;
case RDWR:
if (!FileExist(const_cast<char *>(filename.c_str())) || H5Fis_hdf5(filename.c_str()) <= 0)
{
throw H5Exception(__LINE__, __FILE__, _("Invalid hdf5 file: %s."), filename.c_str());
}
file = H5Fopen(filename.c_str(), H5F_ACC_RDWR, fapl);
if (file < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot open the given hdf5 file: %s."), filename.c_str());
}
opened = true;
break;
case TRUNC:
file = H5Fcreate(filename.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
if (file < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create the given hdf5 file: %s."), filename.c_str());
}
break;
case EXCL:
file = H5Fcreate(filename.c_str(), H5F_ACC_EXCL, H5P_DEFAULT, fapl);
if (file < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create the given hdf5 file: %s."), filename.c_str());
}
break;
case APPEND:
if (FileExist(const_cast<char *>(filename.c_str())))
{
if (H5Fis_hdf5(filename.c_str()) > 0)
{
file = H5Fopen(filename.c_str(), H5F_ACC_RDWR, fapl);
if (file < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot open the given hdf5 file: %s."), filename.c_str());
}
opened = true;
}
else
{
struct stat stat_buf;
int rc = stat(filename.c_str(), &stat_buf);
if (!rc && stat_buf.st_size == 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot open the file: %s, an empty file with the same name already exists."), filename.c_str());
}
throw H5Exception(__LINE__, __FILE__, _("Cannot append the file (not HDF5): %s."), filename.c_str());
}
}
else
{
file = H5Fcreate(filename.c_str(), H5F_ACC_EXCL, H5P_DEFAULT, fapl);
if (file < 0)
{
throw H5Exception(__LINE__, __FILE__, _("Cannot create the given hdf5 file: %s."), filename.c_str());
}
}
break;
default:
throw H5Exception(__LINE__, __FILE__, _("Invalid flag."));
}
if (opened && path != "/" && H5Lexists(file, path.c_str(), H5P_DEFAULT) <= 0)
{
H5Fclose(file);
throw H5Exception(__LINE__, __FILE__, _("Invalid path: %s"), path.c_str());
}
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: HDF5 user block unjammer
*
* Return: Success: 0
* Failure: 1
*
* Programmer:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main(int argc, const char *argv[])
{
void *edata;
H5E_auto2_t func;
hid_t ifile = -1;
hid_t plist = -1;
off_t fsize;
hsize_t usize;
htri_t testval;
herr_t status;
int res;
h5_stat_t sbuf;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable error reporting */
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
if(EXIT_FAILURE == parse_command_line(argc, argv))
goto done;
if (input_file == NULL) {
/* no user block */
error_msg("missing arguemnt for HDF5 file input.\n");
help_ref_msg(stderr);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
testval = H5Fis_hdf5(input_file);
if (testval <= 0) {
error_msg("Input HDF5 file \"%s\" is not HDF\n", input_file);
help_ref_msg (stderr);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
ifile = H5Fopen(input_file, H5F_ACC_RDONLY , H5P_DEFAULT);
if (ifile < 0) {
error_msg("Can't open input HDF5 file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
plist = H5Fget_create_plist(ifile);
if (plist < 0) {
error_msg("Can't get file creation plist for file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
status = H5Pget_userblock(plist, & usize);
if (status < 0) {
error_msg("Can't get user block for file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
status = H5Pclose(plist);
HDassert(status >= 0);
status = H5Fclose(ifile);
HDassert(status >= 0);
if (usize == 0) {
/* no user block to remove: message? */
error_msg("\"%s\" has no user block: no change to file\n", input_file);
h5tools_setstatus(EXIT_SUCCESS);
goto done;
}
res = HDfstat(HDfileno(rawinstream), &sbuf);
if(res < 0) {
error_msg("Can't stat file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
fsize = sbuf.st_size;
if (do_delete && (ub_file != NULL)) {
error_msg("??\"%s\"\n", ub_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
if (output_file == NULL) {
error_msg("unable to open output HDF5 file \"%s\"\n", input_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
/* copy from 0 to 'usize - 1' into ufid */
if (!do_delete) {
if(copy_to_file(rawinstream, rawoutstream, 0, (ssize_t) usize) < 0) {
error_msg("unable to copy user block to output file \"%s\"\n", ub_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
}
/* copy from usize to end of file into h5fid,
* starting at end of user block if present */
if(copy_to_file(rawinstream, rawdatastream, (ssize_t) usize, (ssize_t)(fsize - (ssize_t)usize)) < 0) {
error_msg("unable to copy hdf5 data to output file \"%s\"\n", output_file);
h5tools_setstatus(EXIT_FAILURE);
goto done;
}
done:
if(input_file)
HDfree(input_file);
if(output_file)
HDfree(output_file);
if(ub_file) {
HDfree(ub_file);
}
h5tools_close();
return h5tools_getstatus();
}
GDALDataset *HDF5ImageDataset::Open( GDALOpenInfo * poOpenInfo )
{
int i;
HDF5ImageDataset *poDS;
char szFilename[2048];
if(!EQUALN( poOpenInfo->pszFilename, "HDF5:", 5 ) ||
strlen(poOpenInfo->pszFilename) > sizeof(szFilename) - 3 )
return NULL;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The HDF5ImageDataset driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
poDS = new HDF5ImageDataset();
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
/* printf("poOpenInfo->pszFilename %s\n",poOpenInfo->pszFilename); */
char **papszName =
CSLTokenizeString2( poOpenInfo->pszFilename,
":", CSLT_HONOURSTRINGS|CSLT_PRESERVEESCAPES );
if( !((CSLCount(papszName) == 3) || (CSLCount(papszName) == 4)) )
{
CSLDestroy(papszName);
delete poDS;
return NULL;
}
poDS->SetDescription( poOpenInfo->pszFilename );
/* -------------------------------------------------------------------- */
/* Check for drive name in windows HDF5:"D:\... */
/* -------------------------------------------------------------------- */
strcpy(szFilename, papszName[1]);
if( strlen(papszName[1]) == 1 && papszName[3] != NULL )
{
strcat(szFilename, ":");
strcat(szFilename, papszName[2]);
poDS->SetSubdatasetName( papszName[3] );
}
else
poDS->SetSubdatasetName( papszName[2] );
CSLDestroy(papszName);
papszName = NULL;
if( !H5Fis_hdf5(szFilename) ) {
delete poDS;
return NULL;
}
poDS->SetPhysicalFilename( szFilename );
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
poDS->hHDF5 = H5Fopen(szFilename,
H5F_ACC_RDONLY,
H5P_DEFAULT );
if( poDS->hHDF5 < 0 )
{
delete poDS;
return NULL;
}
poDS->hGroupID = H5Gopen( poDS->hHDF5, "/" );
if( poDS->hGroupID < 0 )
{
poDS->bIsHDFEOS=false;
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* THIS IS AN HDF5 FILE */
/* -------------------------------------------------------------------- */
poDS->bIsHDFEOS=TRUE;
poDS->ReadGlobalAttributes( FALSE );
/* -------------------------------------------------------------------- */
/* Create HDF5 Data Hierarchy in a link list */
/* -------------------------------------------------------------------- */
poDS->poH5Objects =
poDS->HDF5FindDatasetObjectsbyPath( poDS->poH5RootGroup,
(char *)poDS->GetSubdatasetName() );
if( poDS->poH5Objects == NULL ) {
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Retrieve HDF5 data information */
/* -------------------------------------------------------------------- */
poDS->dataset_id = H5Dopen( poDS->hHDF5,poDS->poH5Objects->pszPath );
poDS->dataspace_id = H5Dget_space( poDS->dataset_id );
poDS->ndims = H5Sget_simple_extent_ndims( poDS->dataspace_id );
poDS->dims = (hsize_t*)CPLCalloc( poDS->ndims, sizeof(hsize_t) );
poDS->maxdims = (hsize_t*)CPLCalloc( poDS->ndims, sizeof(hsize_t) );
poDS->dimensions = H5Sget_simple_extent_dims( poDS->dataspace_id,
poDS->dims,
poDS->maxdims );
poDS->datatype = H5Dget_type( poDS->dataset_id );
poDS->clas = H5Tget_class( poDS->datatype );
poDS->size = H5Tget_size( poDS->datatype );
poDS->address = H5Dget_offset( poDS->dataset_id );
poDS->native = H5Tget_native_type( poDS->datatype, H5T_DIR_ASCEND );
poDS->nRasterYSize=(int)poDS->dims[poDS->ndims-2]; // Y
poDS->nRasterXSize=(int)poDS->dims[poDS->ndims-1]; // X alway last
poDS->nBands=1;
if( poDS->ndims == 3 ) poDS->nBands=(int) poDS->dims[0];
for( i = 1; i <= poDS->nBands; i++ ) {
HDF5ImageRasterBand *poBand =
new HDF5ImageRasterBand( poDS, i,
poDS->GetDataType( poDS->native ) );
poDS->SetBand( i, poBand );
if( poBand->bNoDataSet )
poBand->SetNoDataValue( 255 );
}
poDS->CreateProjections( );
poDS->SetMetadata( poDS->papszMetadata );
/* -------------------------------------------------------------------- */
/* Setup/check for pam .aux.xml. */
/* -------------------------------------------------------------------- */
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Setup overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, ":::VIRTUAL:::" );
return( poDS );
}
bool
avtGTCFileFormat::Initialize()
{
const char *mName = "avtGTCFileFormat::Initialize: ";
if(initialized)
return true;
// Init HDF5 and turn off error message printing.
H5open();
H5Eset_auto( NULL, NULL );
bool err = false;
// Check for a valid GTC file
if( H5Fis_hdf5( GetFilename() ) < 0 )
EXCEPTION1( InvalidFilesException, GetFilename() );
if ((fileHandle = H5Fopen(GetFilename(), H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
EXCEPTION1( InvalidFilesException, GetFilename() );
if ((particleHandle = H5Dopen(fileHandle, "particle_data")) < 0)
{
H5Fclose(fileHandle);
EXCEPTION1( InvalidFilesException, GetFilename() );
}
// At this point consider the file to truly be a GTC file. If
// some other file NonCompliantExceptions will be thrown.
// Continue as normal reporting NonCompliantExceptions
//Check variable's size.
hid_t dataspace = H5Dget_space(particleHandle);
hsize_t dims[3];
hid_t sid = H5Dget_space(particleHandle);
int ndims = H5Sget_simple_extent_dims(dataspace, dims, NULL);
if(ndims < 0 || ndims > 2)
{
debug4 << mName << "Could not determine number of dimensions" << endl;
H5Sclose(sid);
H5Dclose(particleHandle);
H5Fclose(fileHandle);
EXCEPTION1( InvalidVariableException, "GTC Dataset Extents - Dataset 'particle_data' has an invalid extents");
}
debug4 << mName << "Determining variable size" << endl;
int val = H5Sget_simple_extent_dims(sid, dims, NULL);
if(val < 0 || dims[1] < 3)
{
debug4 << mName << "Could not determine variable size" << endl;
H5Sclose(sid);
H5Dclose(particleHandle);
H5Fclose(fileHandle);
EXCEPTION1( InvalidVariableException, "GTC Dataset Extents - Dataset 'particle_data' has an insufficient number of variables");
}
H5Sclose(dataspace);
debug4 << mName << "variable size (" << dims[0] << ", " << dims[1] << ")" << endl;
nTotalPoints = dims[0];
nVars = dims[1];
#ifdef PARALLEL
nProcs = PAR_Size();
rank = PAR_Rank();
nPoints = nTotalPoints / nProcs;
int remainder = nTotalPoints % nProcs;
startOffset = rank * nPoints;
if ( rank < remainder )
startOffset += rank;
else
startOffset += remainder;
if ( rank < remainder )
nPoints++;
#else
nPoints = nTotalPoints;
startOffset = 0;
#endif
initialized = true;
return initialized;
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: HDF5 user block jammer
*
* Return: Success: 0
* Failure: 1
*
* Programmer:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (int argc, const char *argv[])
{
int ufid = -1;
int h5fid = -1;
int ofid = -1;
void *edata;
H5E_auto2_t func;
hid_t ifile = -1;
hid_t plist = -1;
herr_t status;
htri_t testval;
hsize_t usize;
hsize_t h5fsize;
hsize_t startub;
hsize_t where;
hsize_t newubsize;
off_t fsize;
h5_stat_t sbuf;
h5_stat_t sbuf2;
int res;
h5tools_setprogname(PROGRAMNAME);
h5tools_setstatus(EXIT_SUCCESS);
/* Disable error reporting */
H5Eget_auto2(H5E_DEFAULT, &func, &edata);
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
/* Initialize h5tools lib */
h5tools_init();
parse_command_line (argc, argv);
if (ub_file == NULL) {
/* no user block */
error_msg("missing arguemnt for -u <user_file>.\n");
help_ref_msg(stderr);
leave (EXIT_FAILURE);
}
testval = H5Fis_hdf5 (ub_file);
if (testval > 0) {
error_msg("-u <user_file> cannot be HDF5 file, but it appears to be an HDF5 file.\n");
help_ref_msg(stderr);
leave (EXIT_FAILURE);
}
if (input_file == NULL) {
error_msg("missing arguemnt for -i <HDF5 file>.\n");
help_ref_msg(stderr);
leave (EXIT_FAILURE);
}
testval = H5Fis_hdf5 (input_file);
if (testval <= 0) {
error_msg("Input HDF5 file \"%s\" is not HDF5 format.\n", input_file);
help_ref_msg(stderr);
leave (EXIT_FAILURE);
}
ifile = H5Fopen (input_file, H5F_ACC_RDONLY, H5P_DEFAULT);
if (ifile < 0) {
error_msg("Can't open input HDF5 file \"%s\"\n", input_file);
leave (EXIT_FAILURE);
}
plist = H5Fget_create_plist (ifile);
if (plist < 0) {
error_msg("Can't get file creation plist for file \"%s\"\n", input_file);
H5Fclose(ifile);
leave (EXIT_FAILURE);
}
status = H5Pget_userblock (plist, &usize);
if (status < 0) {
error_msg("Can't get user block for file \"%s\"\n", input_file);
H5Pclose(plist);
H5Fclose(ifile);
leave (EXIT_FAILURE);
}
H5Pclose(plist);
H5Fclose(ifile);
ufid = HDopen(ub_file, O_RDONLY, 0);
if(ufid < 0) {
error_msg("unable to open user block file \"%s\"\n", ub_file);
leave (EXIT_FAILURE);
}
res = HDfstat(ufid, &sbuf);
if(res < 0) {
error_msg("Can't stat file \"%s\"\n", ub_file);
HDclose (ufid);
leave (EXIT_FAILURE);
}
fsize = (off_t)sbuf.st_size;
h5fid = HDopen(input_file, O_RDONLY, 0);
if(h5fid < 0) {
error_msg("unable to open HDF5 file for read \"%s\"\n", input_file);
HDclose (ufid);
leave (EXIT_FAILURE);
}
res = HDfstat(h5fid, &sbuf2);
if(res < 0) {
error_msg("Can't stat file \"%s\"\n", input_file);
HDclose (h5fid);
HDclose (ufid);
leave (EXIT_FAILURE);
}
h5fsize = (hsize_t)sbuf2.st_size;
if (output_file == NULL) {
ofid = HDopen (input_file, O_WRONLY, 0);
if (ofid < 0) {
error_msg("unable to open output file \"%s\"\n", output_file);
HDclose (h5fid);
HDclose (ufid);
leave (EXIT_FAILURE);
}
}
else {
ofid = HDopen (output_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (ofid < 0) {
error_msg("unable to create output file \"%s\"\n", output_file);
HDclose (h5fid);
HDclose (ufid);
leave (EXIT_FAILURE);
}
}
newubsize = compute_user_block_size ((hsize_t) fsize);
startub = usize;
if (usize > 0) {
if (do_clobber == TRUE) {
/* where is max of the current size or the new UB */
if (usize > newubsize) {
newubsize = usize;
}
startub = 0; /*blast the old */
}
else {
/* add new ub to current ublock, pad to new offset */
newubsize += usize;
newubsize = compute_user_block_size ((hsize_t) newubsize);
}
}
/* copy the HDF5 from starting at usize to starting at newubsize:
* makes room at 'from' for new ub */
/* if no current ub, usize is 0 */
copy_some_to_file (h5fid, ofid, usize, newubsize, (ssize_t) (h5fsize - usize));
/* copy the old ub to the beginning of the new file */
if (!do_clobber) {
where = copy_some_to_file (h5fid, ofid, (hsize_t) 0, (hsize_t) 0, (ssize_t) usize);
}
/* copy the new ub to the end of the ub */
where = copy_some_to_file (ufid, ofid, (hsize_t) 0, startub, (ssize_t) - 1);
/* pad the ub */
where = write_pad (ofid, where);
if(ub_file)
HDfree (ub_file);
if(input_file)
HDfree (input_file);
if(output_file)
HDfree (output_file);
if(ufid >= 0)
HDclose (ufid);
if(h5fid >= 0)
HDclose (h5fid);
if(ofid >= 0)
HDclose (ofid);
return h5tools_getstatus();
}
mhdf_FileHandle
mhdf_openFileWithOpt( const char* filename,
int writable,
unsigned long* max_id_out,
hid_t id_type,
hid_t access_prop,
mhdf_Status* status )
{
FileHandle* file_ptr;
unsigned int flags;
hid_t group_id;
int check_is_hdf5 = 1;
#ifdef HDF5_PARALLEL
herr_t err;
MPI_Comm comm;
MPI_Info info;
#endif
API_BEGIN;
/* Check if file is HDF5 */
/* Don't do this because it can't handle MPI-IO driver code that
passes options via prefixes on the file name. */
#ifdef HDF5_PARALLEL
if (access_prop != H5P_DEFAULT) {
err = H5Pget_fapl_mpio( access_prop, &comm, &info );
if (err >= 0) {
check_is_hdf5 = 0;
/* MPI Documentation is inconsistent with regards to whether
or not the above call dup's these, but my testing with 1.8.3
indicates that at least for that version they are not.
MPI_Comm_free(&comm);
MPI_Info_free(&info); */
}
}
#endif
if (check_is_hdf5 && H5Fis_hdf5( filename ) <= 0) {
mhdf_setFail( status, "%s: File is not HDF5", filename );
return NULL;
}
/* Create struct to hold working data */
file_ptr = mhdf_alloc_FileHandle( 0, id_type, status );
if (!file_ptr) {
mhdf_setFail( status, "Memory allocation failed" );
return NULL;
}
/* Create the file */
flags = writable ? H5F_ACC_RDWR : H5F_ACC_RDONLY;
file_ptr->hdf_handle = H5Fopen( filename, flags, access_prop );
if (file_ptr->hdf_handle < 0)
{
mhdf_setFail( status, "Failed to open file \"%s\"", filename );
free( file_ptr );
return NULL;
}
/* Check for TSTT data in file */
#if defined(H5Gopen_vers) && H5Gopen_vers > 1
group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
#else
group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
#endif
if (group_id < 0)
{
mhdf_setFail( status, "Invalid file \"%s\"\n", filename );
H5Fclose( file_ptr->hdf_handle );
free( file_ptr );
return NULL;
}
H5Gclose( group_id );
/* Get max id */
if (!scan_for_max_id( file_ptr, status ))
{
H5Fclose( file_ptr->hdf_handle );
mhdf_setFail( status, "Internal error reading file" );
free( file_ptr );
return NULL;
}
if (max_id_out)
*max_id_out = file_ptr->max_id;
mhdf_setOkay( status );
API_END_H(1);
return file_ptr;
}
htri_t arma_H5Fis_hdf5(const char* name)
{
return H5Fis_hdf5(name);
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: HDF5 user block jammer
*
* Return: Success: 0
* Failure: 1
*
* Programmer:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (int argc, const char *argv[])
{
int ufid;
int h5fid;
int ofid;
void *edata;
H5E_auto_t func;
hid_t ifile;
hid_t plist;
herr_t status;
htri_t testval;
hsize_t usize;
hsize_t h5fsize;
hsize_t startub;
hsize_t where;
hsize_t newubsize;
off_t fsize;
struct stat sbuf;
struct stat sbuf2;
int res;
/* Disable error reporting */
H5Eget_auto (&func, &edata);
H5Eset_auto (NULL, NULL);
parse_command_line (argc, argv);
if (ub_file == NULL)
{
/* no user block */
error_msg (progname, "no user block file name\n");
usage (progname);
exit (EXIT_FAILURE);
}
if (input_file == NULL)
{
/* no user block */
error_msg (progname, "no HDF5 file\n");
usage (progname);
exit (EXIT_FAILURE);
}
testval = H5Fis_hdf5 (input_file);
if (testval <= 0)
{
error_msg (progname, "Input HDF5 file is not HDF \"%s\"\n", input_file);
exit (EXIT_FAILURE);
}
ifile = H5Fopen (input_file, H5F_ACC_RDONLY, H5P_DEFAULT);
if (ifile < 0)
{
error_msg (progname, "Can't open input HDF5 file \"%s\"\n", input_file);
exit (EXIT_FAILURE);
}
plist = H5Fget_create_plist (ifile);
if (plist < 0)
{
error_msg (progname, "Can't get file creation plist for file \"%s\"\n",
input_file);
exit (EXIT_FAILURE);
}
status = H5Pget_userblock (plist, &usize);
if (status < 0)
{
error_msg (progname, "Can't get user block for file \"%s\"\n",
input_file);
exit (EXIT_FAILURE);
}
H5Pclose (plist);
H5Fclose (ifile);
ufid = HDopen (ub_file, O_RDONLY, 0);
if (ufid < 0)
{
error_msg (progname, "unable to open user block file \"%s\"\n",
ub_file);
exit (EXIT_FAILURE);
}
res = stat (ub_file, &sbuf);
if (res < 0)
{
error_msg (progname, "Can't stat file \"%s\"\n", ub_file);
exit (EXIT_FAILURE);
}
fsize = sbuf.st_size;
h5fid = HDopen (input_file, O_RDONLY, 0);
if (h5fid < 0)
{
error_msg (progname, "unable to open HDF5 file for read \"%s\"\n",
input_file);
exit (EXIT_FAILURE);
}
res = stat (input_file, &sbuf2);
if (res < 0)
{
error_msg (progname, "Can't stat file \"%s\"\n", input_file);
exit (EXIT_FAILURE);
}
h5fsize = sbuf2.st_size;
if (output_file == NULL)
{
ofid = HDopen (input_file, O_WRONLY, 0);
if (ofid < 0)
{
error_msg (progname, "unable to open output file \"%s\"\n",
output_file);
exit (EXIT_FAILURE);
}
}
else
{
ofid = HDopen (output_file, O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (ofid < 0)
{
error_msg (progname, "unable to create output file \"%s\"\n",
output_file);
exit (EXIT_FAILURE);
}
}
newubsize = compute_user_block_size ((hsize_t) fsize);
startub = usize;
if (usize > 0)
{
if (do_clobber == TRUE)
{
/* where is max of the current size or the new UB */
if (usize > newubsize)
{
newubsize = usize;
}
startub = 0; /*blast the old */
}
else
{
/* add new ub to current ublock, pad to new offset */
newubsize += usize;
newubsize = compute_user_block_size ((hsize_t) newubsize);
}
}
/* copy the HDF5 from starting at usize to starting at newubsize:
* makes room at 'from' for new ub */
/* if no current ub, usize is 0 */
copy_some_to_file (h5fid, ofid, usize, newubsize,
(ssize_t) (h5fsize - usize));
/* copy the old ub to the beginning of the new file */
if (!do_clobber)
{
where =
copy_some_to_file (h5fid, ofid, (hsize_t) 0, (hsize_t) 0,
(ssize_t) usize);
}
/* copy the new ub to the end of the ub */
where = copy_some_to_file (ufid, ofid, (hsize_t) 0, startub, (ssize_t) - 1);
/* pad the ub */
where = write_pad (ofid, where);
HDclose (ufid);
HDclose (h5fid);
HDclose (ofid);
return d_status;
}
//-*****************************************************************************
ArImpl::ArImpl( const std::string &iFileName,
AbcA::ReadArraySampleCachePtr iCache,
const bool iCacheHierarchy )
: m_fileName( iFileName )
, m_file( -1 )
, m_readArraySampleCache( iCache )
{
// OPEN THE FILE!
htri_t exi = H5Fis_hdf5( m_fileName.c_str() );
ABCA_ASSERT( exi == 1, "Nonexistent or not an Alembic file: "
<< m_fileName );
m_file = H5Fopen( m_fileName.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT );
ABCA_ASSERT( m_file >= 0,
"Could not open file: " << m_fileName );
// get the version using HDF5 native calls
int version = -INT_MAX;
if (H5Aexists(m_file, "abc_version"))
{
size_t numRead = 0;
ReadSmallArray(m_file, "abc_version", H5T_STD_I32LE, H5T_NATIVE_INT32,
1, numRead, &version);
}
ABCA_ASSERT(version >= -8 && version <= ALEMBIC_HDF5_FILE_VERSION,
"Unsupported file version detected: " << version);
// if it isn't there, it's pre 1.0
int fileVersion = 9999;
if (H5Aexists( m_file, "abc_release_version" ))
{
size_t numRead = 0;
ReadSmallArray( m_file, "abc_release_version", H5T_STD_I32LE,
H5T_NATIVE_INT32, 1, numRead, &fileVersion );
}
m_archiveVersion = fileVersion;
HDF5HierarchyReader reader( m_file, m_H5H, iCacheHierarchy );
H5Node node = m_H5H.createNode( m_file );
H5Node abcRoot = OpenGroup( node, "ABC" );
AbcA::MetaData metaData;
ReadMetaData( abcRoot, ".prop.meta", metaData );
m_header.reset( new AbcA::ObjectHeader( "ABC", "/", metaData ) );
m_data.reset( new OrData( m_header, node, m_archiveVersion ) );
CloseObject( abcRoot );
ReadTimeSamples( m_file, m_timeSamples );
if ( H5Aexists( m_file, "abc_max_samples" ) )
{
hid_t aid = H5Aopen( m_file, "abc_max_samples", H5P_DEFAULT );
if ( aid < 0 )
{
return;
}
AttrCloser attrCloser( aid );
// figure out how big it is
hid_t sid = H5Aget_space( aid );
if ( sid < 0 )
{
return;
}
DspaceCloser dspaceCloser( sid );
hssize_t numPoints = H5Sget_simple_extent_npoints( sid );
if ( numPoints < 1 )
{
return;
}
m_maxSamples.resize( numPoints );
// do the read
H5Aread( aid, H5T_NATIVE_LLONG, &( m_maxSamples.front() ) );
}
}
GDALDataset *HDF5ImageDataset::Open( GDALOpenInfo * poOpenInfo )
{
if(!STARTS_WITH_CI(poOpenInfo->pszFilename, "HDF5:") )
return NULL;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The HDF5ImageDataset driver does not support update access "
" to existing datasets.\n" );
return NULL;
}
HDF5ImageDataset *poDS = new HDF5ImageDataset();
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
/* printf("poOpenInfo->pszFilename %s\n",poOpenInfo->pszFilename); */
char **papszName =
CSLTokenizeString2( poOpenInfo->pszFilename,
":", CSLT_HONOURSTRINGS|CSLT_PRESERVEESCAPES );
if( !((CSLCount(papszName) == 3) || (CSLCount(papszName) == 4)) )
{
CSLDestroy(papszName);
delete poDS;
return NULL;
}
poDS->SetDescription( poOpenInfo->pszFilename );
/* -------------------------------------------------------------------- */
/* Check for drive name in windows HDF5:"D:\... */
/* -------------------------------------------------------------------- */
CPLString osSubdatasetName;
CPLString osFilename(papszName[1]);
if( strlen(papszName[1]) == 1 && papszName[3] != NULL )
{
osFilename += ":";
osFilename += papszName[2];
osSubdatasetName = papszName[3];
}
else
osSubdatasetName = papszName[2];
poDS->SetSubdatasetName( osSubdatasetName );
CSLDestroy(papszName);
papszName = NULL;
if( !H5Fis_hdf5(osFilename) ) {
delete poDS;
return NULL;
}
poDS->SetPhysicalFilename( osFilename );
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
poDS->hHDF5 = H5Fopen(osFilename,
H5F_ACC_RDONLY,
H5P_DEFAULT );
if( poDS->hHDF5 < 0 )
{
delete poDS;
return NULL;
}
poDS->hGroupID = H5Gopen( poDS->hHDF5, "/" );
if( poDS->hGroupID < 0 )
{
poDS->bIsHDFEOS=false;
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* THIS IS AN HDF5 FILE */
/* -------------------------------------------------------------------- */
poDS->bIsHDFEOS=TRUE;
poDS->ReadGlobalAttributes( FALSE );
/* -------------------------------------------------------------------- */
/* Create HDF5 Data Hierarchy in a link list */
/* -------------------------------------------------------------------- */
poDS->poH5Objects =
poDS->HDF5FindDatasetObjectsbyPath( poDS->poH5RootGroup,
osSubdatasetName );
if( poDS->poH5Objects == NULL ) {
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Retrieve HDF5 data information */
/* -------------------------------------------------------------------- */
poDS->dataset_id = H5Dopen( poDS->hHDF5,poDS->poH5Objects->pszPath );
poDS->dataspace_id = H5Dget_space( poDS->dataset_id );
poDS->ndims = H5Sget_simple_extent_ndims( poDS->dataspace_id );
if( poDS->ndims < 0 )
{
delete poDS;
return NULL;
}
poDS->dims = (hsize_t*)CPLCalloc( poDS->ndims, sizeof(hsize_t) );
poDS->maxdims = (hsize_t*)CPLCalloc( poDS->ndims, sizeof(hsize_t) );
poDS->dimensions = H5Sget_simple_extent_dims( poDS->dataspace_id,
poDS->dims,
poDS->maxdims );
poDS->datatype = H5Dget_type( poDS->dataset_id );
poDS->class_ = H5Tget_class( poDS->datatype );
poDS->size = H5Tget_size( poDS->datatype );
poDS->address = H5Dget_offset( poDS->dataset_id );
poDS->native = H5Tget_native_type( poDS->datatype, H5T_DIR_ASCEND );
// CSK code in IdentifyProductType() and CreateProjections()
// uses dataset metadata.
poDS->SetMetadata( poDS->papszMetadata );
// Check if the hdf5 is a well known product type
poDS->IdentifyProductType();
poDS->nRasterYSize=static_cast<int>(poDS->dims[poDS->GetYIndex()]); // nRows
poDS->nRasterXSize=static_cast<int>(poDS->dims[poDS->GetXIndex()]); // nCols
if( poDS->IsComplexCSKL1A() )
{
poDS->nBands=(int) poDS->dims[2]; // nBands
}
else if( poDS->ndims == 3 )
{
poDS->nBands=(int) poDS->dims[0];
}
else
{
poDS->nBands=1;
}
for( int i = 1; i <= poDS->nBands; i++ ) {
HDF5ImageRasterBand * const poBand =
new HDF5ImageRasterBand( poDS, i,
poDS->GetDataType( poDS->native ) );
poDS->SetBand( i, poBand );
if( poBand->bNoDataSet )
poBand->SetNoDataValue( 255 );
}
poDS->CreateProjections( );
/* -------------------------------------------------------------------- */
/* Setup/check for pam .aux.xml. */
/* -------------------------------------------------------------------- */
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Setup overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, ":::VIRTUAL:::" );
return poDS;
}
void pyne::Material::write_hdf5(std::string filename, std::string datapath,
std::string nucpath, float row, int chunksize) {
int row_num = (int) row;
// Turn off annoying HDF5 errors
H5Eset_auto2(H5E_DEFAULT, NULL, NULL);
//Set file access properties so it closes cleanly
hid_t fapl;
fapl = H5Pcreate(H5P_FILE_ACCESS);
H5Pset_fclose_degree(fapl,H5F_CLOSE_STRONG);
// Create new/open datafile.
hid_t db;
if (pyne::file_exists(filename)) {
bool ish5 = H5Fis_hdf5(filename.c_str());
if (!ish5)
throw h5wrap::FileNotHDF5(filename);
db = H5Fopen(filename.c_str(), H5F_ACC_RDWR, fapl);
}
else
db = H5Fcreate(filename.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
//
// Read in nuclist if available, write it out if not
//
bool nucpath_exists = h5wrap::path_exists(db, nucpath);
std::vector<int> nuclides;
int nuc_size;
hsize_t nuc_dims[1];
if (nucpath_exists) {
nuclides = h5wrap::h5_array_to_cpp_vector_1d<int>(db, nucpath, H5T_NATIVE_INT);
nuc_size = nuclides.size();
nuc_dims[0] = nuc_size;
} else {
nuclides = std::vector<int>();
for (pyne::comp_iter i = comp.begin(); i != comp.end(); i++)
nuclides.push_back(i->first);
nuc_size = nuclides.size();
// Create the data if it doesn't exist
int nuc_data [nuc_size];
for (int n = 0; n != nuc_size; n++)
nuc_data[n] = nuclides[n];
nuc_dims[0] = nuc_size;
hid_t nuc_space = H5Screate_simple(1, nuc_dims, NULL);
hid_t nuc_set = H5Dcreate2(db, nucpath.c_str(), H5T_NATIVE_INT, nuc_space,
H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
H5Dwrite(nuc_set, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, nuc_data);
H5Fflush(db, H5F_SCOPE_GLOBAL);
};
//
// Write out the data itself to the file
//
hid_t data_set, data_space, data_hyperslab;
int data_rank = 1;
hsize_t data_dims[1] = {1};
hsize_t data_max_dims[1] = {H5S_UNLIMITED};
hsize_t data_offset[1] = {0};
size_t material_struct_size = sizeof(pyne::material_struct) + sizeof(double)*nuc_size;
hid_t desc = H5Tcreate(H5T_COMPOUND, material_struct_size);
hid_t comp_values_array_type = H5Tarray_create2(H5T_NATIVE_DOUBLE, 1, nuc_dims);
// make the data table type
H5Tinsert(desc, "mass", HOFFSET(pyne::material_struct, mass), H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "density", HOFFSET(pyne::material_struct, density),
H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "atoms_per_molecule", HOFFSET(pyne::material_struct, atoms_per_mol),
H5T_NATIVE_DOUBLE);
H5Tinsert(desc, "comp", HOFFSET(pyne::material_struct, comp),
comp_values_array_type);
material_struct * mat_data = new material_struct[material_struct_size];
(*mat_data).mass = mass;
(*mat_data).density = density;
(*mat_data).atoms_per_mol = atoms_per_molecule;
for (int n = 0; n != nuc_size; n++) {
if (0 < comp.count(nuclides[n]))
(*mat_data).comp[n] = comp[nuclides[n]];
else
(*mat_data).comp[n] = 0.0;
};
// get / make the data set
bool datapath_exists = h5wrap::path_exists(db, datapath);
if (datapath_exists) {
data_set = H5Dopen2(db, datapath.c_str(), H5P_DEFAULT);
data_space = H5Dget_space(data_set);
data_rank = H5Sget_simple_extent_dims(data_space, data_dims, data_max_dims);
// Determine the row size.
if (std::signbit(row))
row_num = data_dims[0] + row; // careful, row is negative
if (data_dims[0] <= row_num) {
// row == -0, extend to data set so that we can append, or
// row_num is larger than current dimension, resize to accomodate.
data_dims[0] = row_num + 1;
H5Dset_extent(data_set, data_dims);
}
data_offset[0] = row_num;
} else {
// Get full space
data_space = H5Screate_simple(1, data_dims, data_max_dims);
// Make data set properties to enable chunking
hid_t data_set_params = H5Pcreate(H5P_DATASET_CREATE);
hsize_t chunk_dims[1] ={chunksize};
H5Pset_chunk(data_set_params, 1, chunk_dims);
H5Pset_deflate(data_set_params, 1);
material_struct * data_fill_value = new material_struct[material_struct_size];
(*data_fill_value).mass = -1.0;
(*data_fill_value).density= -1.0;
(*data_fill_value).atoms_per_mol = -1.0;
for (int n = 0; n != nuc_size; n++)
(*data_fill_value).comp[n] = 0.0;
H5Pset_fill_value(data_set_params, desc, &data_fill_value);
// Create the data set
data_set = H5Dcreate2(db, datapath.c_str(), desc, data_space, H5P_DEFAULT,
data_set_params, H5P_DEFAULT);
H5Dset_extent(data_set, data_dims);
// Add attribute pointing to nuc path
hid_t nuc_attr_type = H5Tcopy(H5T_C_S1);
H5Tset_size(nuc_attr_type, nucpath.length());
hid_t nuc_attr_space = H5Screate(H5S_SCALAR);
hid_t nuc_attr = H5Acreate2(data_set, "nucpath", nuc_attr_type, nuc_attr_space,
H5P_DEFAULT, H5P_DEFAULT);
H5Awrite(nuc_attr, nuc_attr_type, nucpath.c_str());
H5Fflush(db, H5F_SCOPE_GLOBAL);
// Remember to de-allocate
delete[] data_fill_value;
};
// Get the data hyperslab
data_hyperslab = H5Dget_space(data_set);
hsize_t data_count[1] = {1};
H5Sselect_hyperslab(data_hyperslab, H5S_SELECT_SET, data_offset, NULL, data_count, NULL);
// Get a memory space for writing
hid_t mem_space = H5Screate_simple(1, data_count, data_max_dims);
// Write the row...
H5Dwrite(data_set, desc, mem_space, data_hyperslab, H5P_DEFAULT, mat_data);
// Close out the Dataset
H5Fflush(db, H5F_SCOPE_GLOBAL);
H5Dclose(data_set);
H5Sclose(data_space);
H5Tclose(desc);
//
// Write out the metadata to the file
//
std::string attrpath = datapath + "_metadata";
hid_t metadatapace, attrtype, metadataet, metadatalab, attrmemspace;
int attrrank;
attrtype = H5Tvlen_create(H5T_NATIVE_CHAR);
// get / make the data set
bool attrpath_exists = h5wrap::path_exists(db, attrpath);
if (attrpath_exists) {
metadataet = H5Dopen2(db, attrpath.c_str(), H5P_DEFAULT);
metadatapace = H5Dget_space(metadataet);
attrrank = H5Sget_simple_extent_dims(metadatapace, data_dims, data_max_dims);
if (data_dims[0] <= row_num) {
// row == -0, extend to data set so that we can append, or
// row_num is larger than current dimension, resize to accomodate.
data_dims[0] = row_num + 1;
H5Dset_extent(metadataet, data_dims);
}
data_offset[0] = row_num;
} else {
hid_t metadataetparams;
hsize_t attrchunkdims [1];
// Make data set properties to enable chunking
metadataetparams = H5Pcreate(H5P_DATASET_CREATE);
attrchunkdims[0] = chunksize;
H5Pset_chunk(metadataetparams, 1, attrchunkdims);
H5Pset_deflate(metadataetparams, 1);
hvl_t attrfillvalue [1];
attrfillvalue[0].len = 3;
attrfillvalue[0].p = (char *) "{}\n";
H5Pset_fill_value(metadataetparams, attrtype, &attrfillvalue);
// make dataset
metadatapace = H5Screate_simple(1, data_dims, data_max_dims);
metadataet = H5Dcreate2(db, attrpath.c_str(), attrtype, metadatapace,
H5P_DEFAULT, metadataetparams, H5P_DEFAULT);
H5Dset_extent(metadataet, data_dims);
};
// set the attr string
hvl_t attrdata [1];
Json::FastWriter writer;
std::string metadatatr = writer.write(metadata);
attrdata[0].p = (char *) metadatatr.c_str();
attrdata[0].len = metadatatr.length();
// write the attr
metadatalab = H5Dget_space(metadataet);
H5Sselect_hyperslab(metadatalab, H5S_SELECT_SET, data_offset, NULL, data_count, NULL);
attrmemspace = H5Screate_simple(1, data_count, data_max_dims);
H5Dwrite(metadataet, attrtype, attrmemspace, metadatalab, H5P_DEFAULT, attrdata);
// close attr data objects
H5Fflush(db, H5F_SCOPE_GLOBAL);
H5Dclose(metadataet);
H5Sclose(metadatapace);
H5Tclose(attrtype);
// Close out the HDF5 file
H5Fclose(db);
// Remember the milk!
// ...by which I mean to deallocate
delete[] mat_data;
};
int HDF5Dataset::Identify( GDALOpenInfo * poOpenInfo )
{
// Is it an HDF5 file?
constexpr char achSignature[] = "\211HDF\r\n\032\n";
if( !poOpenInfo->pabyHeader )
return FALSE;
if( memcmp(poOpenInfo->pabyHeader, achSignature, 8) == 0 )
{
CPLString osExt(CPLGetExtension(poOpenInfo->pszFilename));
// The tests to avoid opening KEA and BAG drivers are not
// necessary when drivers are built in the core lib, as they
// are registered after HDF5, but in the case of plugins, we
// cannot do assumptions about the registration order.
// Avoid opening kea files if the kea driver is available.
if( EQUAL(osExt, "KEA") && GDALGetDriverByName("KEA") != nullptr )
{
return FALSE;
}
// Avoid opening BAG files if the bag driver is available.
if( EQUAL(osExt, "BAG") && GDALGetDriverByName("BAG") != nullptr )
{
return FALSE;
}
// Avoid opening NC files if the netCDF driver is available and
// they are recognized by it.
if( (EQUAL(osExt, "NC") ||
EQUAL(osExt, "CDF") ||
EQUAL(osExt, "NC4")) &&
GDALGetDriverByName("netCDF") != nullptr )
{
const char *const apszAllowedDriver[] = { "netCDF", nullptr };
CPLPushErrorHandler(CPLQuietErrorHandler);
GDALDatasetH hDS = GDALOpenEx(poOpenInfo->pszFilename,
GDAL_OF_RASTER | GDAL_OF_VECTOR,
apszAllowedDriver, nullptr, nullptr);
CPLPopErrorHandler();
if( hDS )
{
GDALClose(hDS);
return FALSE;
}
}
return TRUE;
}
if( memcmp(poOpenInfo->pabyHeader, "<HDF_UserBlock>", 15) == 0)
{
if( H5Fis_hdf5(poOpenInfo->pszFilename) )
return TRUE;
}
return FALSE;
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: HDF5 user block unjammer
*
* Return: Success: 0
* Failure: 1
*
* Programmer:
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (int argc, const char *argv[])
{
char *ifname;
void *edata;
H5E_auto_t func;
hid_t ifile;
hsize_t usize;
htri_t testval;
herr_t status;
hid_t plist;
/* Disable error reporting */
H5Eget_auto(&func, &edata);
H5Eset_auto(NULL, NULL);
parse_command_line (argc, argv);
if (argc <= (opt_ind))
{
error_msg (progname, "missing file name\n");
usage (progname);
return (EXIT_FAILURE);
}
ifname = strdup (argv[opt_ind]);
testval = H5Fis_hdf5 (ifname);
if (testval <= 0)
{
error_msg (progname, "Input HDF5 file is not HDF \"%s\"\n", ifname);
return (EXIT_FAILURE);
}
ifile = H5Fopen (ifname, H5F_ACC_RDONLY, H5P_DEFAULT);
if (ifile < 0)
{
error_msg (progname, "Can't open input HDF5 file \"%s\"\n", ifname);
return (EXIT_FAILURE);
}
plist = H5Fget_create_plist (ifile);
if (plist < 0)
{
error_msg (progname, "Can't get file creation plist for file \"%s\"\n",
ifname);
return (EXIT_FAILURE);
}
status = H5Pget_userblock (plist, &usize);
if (status < 0)
{
error_msg (progname, "Can't get user block for file \"%s\"\n", ifname);
return (EXIT_FAILURE);
}
printf ("%ld\n", (long) usize);
H5Pclose (plist);
H5Fclose (ifile);
return (EXIT_SUCCESS);
}
