public void H5DflushTestSWMR2()
{
hsize_t[] dims = { 6, 6 };
hsize_t[] maxdims = { 6, H5S.UNLIMITED };
hsize_t[] chunk_dims = { 2, 5 };
int[] cbuf = new int[36];
hid_t dsp = H5S.create_simple(2, dims, maxdims);
Assert.IsTrue(dsp >= 0);
hid_t dcpl = H5P.create(H5P.DATASET_CREATE);
Assert.IsTrue(dcpl >= 0);
Assert.IsTrue(H5P.set_chunk(dcpl, 2, chunk_dims) >= 0);
hid_t dst = H5D.create(m_v3_test_file_swmr, "dset",
H5T.NATIVE_INT, dsp, H5P.DEFAULT, dcpl);
Assert.IsTrue(dst >= 0);
GCHandle hnd = GCHandle.Alloc(cbuf, GCHandleType.Pinned);
Assert.IsTrue(H5D.write(dst, H5T.NATIVE_INT, H5S.ALL, H5S.ALL,
H5P.DEFAULT, hnd.AddrOfPinnedObject()) >= 0);
hnd.Free();
Assert.IsTrue(H5D.flush(dst) >= 0);
Assert.IsTrue(H5D.close(dst) >= 0);
Assert.IsTrue(H5P.close(dcpl) >= 0);
Assert.IsTrue(H5S.close(dsp) >= 0);
}
public static void WriteDataSet(hid_t hid, string dataSetName, hsize_t[] offset, hsize_t[] count, hid_t typeId, Array data)
{
if (string.IsNullOrEmpty(dataSetName))
{
throw new ArgumentException("dataSetName");
}
if (!DataSetExists(hid, "dataSetName"))
{
throw new HDF5Exception("Data set \"{0}\" doesn't exist.", dataSetName);
}
var dataSet = H5D.open(hid, dataSetName);
if (dataSet < 0)
{
throw new HDF5Exception("Failed to open data set \"{0}\".", dataSetName);
}
try
{
WriteDataSet(dataSet, offset, count, typeId, data);
}
finally
{
H5D.close(dataSet);
}
}
public void H5Dcreate_anonTest2()
{
hsize_t[] dims = { 10, 10, 10 };
hsize_t[] max_dims = { H5S.UNLIMITED, H5S.UNLIMITED, H5S.UNLIMITED };
hid_t space = H5S.create_simple(3, dims, max_dims);
hid_t dcpl = H5P.create(H5P.DATASET_CREATE);
Assert.IsTrue(dcpl >= 0);
hsize_t[] chunk = { 64, 64, 64 };
Assert.IsTrue(H5P.set_chunk(dcpl, 3, chunk) >= 0);
Assert.IsTrue(H5P.set_deflate(dcpl, 9) >= 0);
hid_t dset = H5D.create_anon(m_v0_test_file, H5T.IEEE_F32BE,
space, dcpl);
Assert.IsTrue(dset >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
dset = H5D.create_anon(m_v2_test_file, H5T.IEEE_F32BE,
space, dcpl);
Assert.IsTrue(dset >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
Assert.IsTrue(H5P.close(dcpl) >= 0);
Assert.IsTrue(H5S.close(space) >= 0);
}
/// <summary>
/// Dispose function as suggested in the stackoverflow discussion below
/// See: http://stackoverflow.com/questions/538060/proper-use-of-the-idisposable-interface/538238#538238
/// </summary>
/// <param name="itIsSafeToAlsoFreeManagedObjects"></param>
protected virtual void Dispose(bool itIsSafeToAlsoFreeManagedObjects)
{
if (!Hdf5Utils.GetRealName(GroupId, Datasetname, string.Empty).valid)
{
Hdf5Utils.LogInfo?.Invoke("Dataset does not exist.");
return;
}
if (_datasetId >= 0)
{
H5D.close(_datasetId);
}
if (_propId >= 0)
{
H5P.close(_propId);
}
if (_spaceId >= 0)
{
H5S.close(_spaceId);
}
if (itIsSafeToAlsoFreeManagedObjects)
{
}
}
public static int WriteDataset <T>(int groupId, string name, T[,] dset) where T : struct
{
ulong[] dims = new ulong[] { (ulong)dset.GetLength(0), (ulong)dset.GetLength(1) };
ulong[] maxDims = null;
var spaceId = H5S.create_simple(2, dims, maxDims);
var datatype = GetDatatype(typeof(T));
var typeId = H5T.copy(datatype);
if (datatype == H5T.C_S1)
{
H5T.set_size(datatype, new IntPtr(2));
//var wdata = Encoding.ASCII.GetBytes((char[,]) dset);
}
name = ToHdf5Name(name);
var datasetId = H5D.create(groupId, name, datatype, spaceId);
GCHandle hnd = GCHandle.Alloc(dset, GCHandleType.Pinned);
var result = H5D.write(datasetId, datatype, H5S.ALL, H5S.ALL, H5P.DEFAULT,
hnd.AddrOfPinnedObject());
hnd.Free();
H5D.close(datasetId);
H5S.close(spaceId);
H5T.close(typeId);
return(result);
}
public static double[,] ReadFieldData2D(string file, string dataSet)
{
H5FileId fileId = H5F.open(file, H5F.OpenMode.ACC_RDONLY);
H5DataSetId fDataSetId = H5D.open(fileId, dataSet);
H5DataTypeId fDataTypeId = H5D.getType(fDataSetId);
long[] dims = H5S.getSimpleExtentDims(H5D.getSpace(fDataSetId)).ToArray();
double[,] data = new double[dims[0], dims[1]];
H5D.read(fDataSetId, fDataTypeId, new H5Array <double>(data));
double[,] fieldValues = new double[dims[1], dims[0]];
for (int i = 0; i < dims[1]; i++)
{
for (int j = 0; j < dims[0]; j++)
{
fieldValues[i, j] = (double)data[j, i];
}
}
H5T.close(fDataTypeId);
H5D.close(fDataSetId);
H5F.close(fileId);
return(fieldValues);
}
public void H5Dget_typeTest1()
{
hsize_t[] dims = { 1024, 2048 };
hid_t space = H5S.create_simple(3, dims, null);
hid_t dset = H5D.create(m_v0_test_file, "dset", H5T.STD_I16LE,
space);
Assert.IsTrue(dset >= 0);
hid_t type = H5D.get_type(dset);
Assert.IsTrue(type >= 0);
Assert.IsTrue(H5T.equal(type, H5T.STD_I16LE) > 0);
Assert.IsTrue(H5T.close(type) >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
dset = H5D.create(m_v2_test_file, "dset", H5T.STD_I16LE,
space);
Assert.IsTrue(dset >= 0);
type = H5D.get_type(dset);
Assert.IsTrue(type >= 0);
Assert.IsTrue(H5T.equal(type, H5T.STD_I16LE) > 0);
Assert.IsTrue(H5T.close(type) >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
Assert.IsTrue(H5S.close(space) >= 0);
}
protected override void CloseId(long id)
{
if (H5I.is_valid(id) > 0)
{
H5D.close(id);
}
}
public static int WriteDatasetFromArray <T>(hid_t groupId, string name, Array dset, string datasetName = null) //where T : struct
{
int rank = dset.Rank;
ulong[] dims = Enumerable.Range(0, rank).Select(i => { return((ulong)dset.GetLength(i)); }).ToArray();
ulong[] maxDims = null;
var spaceId = H5S.create_simple(rank, dims, maxDims);
var datatype = GetDatatype(typeof(T));
var typeId = H5T.copy(datatype);
if (datatype == H5T.C_S1)
{
H5T.set_size(datatype, new IntPtr(2));
}
var datasetId = H5D.create(groupId, name, datatype, spaceId);
GCHandle hnd = GCHandle.Alloc(dset, GCHandleType.Pinned);
var result = H5D.write(datasetId, datatype, H5S.ALL, H5S.ALL, H5P.DEFAULT,
hnd.AddrOfPinnedObject());
hnd.Free();
H5D.close(datasetId);
H5S.close(spaceId);
H5T.close(typeId);
return(result);
}
private void Write(H5GroupId parent, string name, IEnumerable <IMeasurement> measurements)
{
H5DataSpaceId spaceId = H5S.create_simple(1, new long[1] {
(long)measurements.Count()
});
// Set compression options for dataset
H5PropertyListId dataSetPropertyList = H5P.create(H5P.PropertyListClass.DATASET_CREATE);
H5P.setDeflate(dataSetPropertyList, NumericDataCompression);
H5P.setChunk(dataSetPropertyList, new long[] { (long)measurements.Count() });
H5DataSetId dataSetId = H5D.create(parent,
name,
measurement_t,
spaceId,
new H5PropertyListId(H5P.Template.DEFAULT),
dataSetPropertyList,
new H5PropertyListId(H5P.Template.DEFAULT));
MeasurementT[] ms = new MeasurementT[measurements.Count()];
int ilmCount = 0;
foreach (IMeasurement m in measurements)
{
MeasurementT mt = Convert(m);
ms[ilmCount++] = mt;
}
H5D.write <MeasurementT>(dataSetId, measurement_t, new H5Array <MeasurementT>(ms));
H5D.close(dataSetId);
H5S.close(spaceId);
}
public void H5DOappendTestSWMR2()
{
hsize_t[] dims = { 0 };
hsize_t[] maxdims = { H5S.UNLIMITED };
hsize_t[] chunk_dims = { 10 };
uint[] cbuf = { 123, 456, 789 };
hid_t dsp = H5S.create_simple(1, dims, maxdims);
Assert.IsTrue(dsp >= 0);
hid_t dcpl = H5P.create(H5P.DATASET_CREATE);
Assert.IsTrue(dcpl >= 0);
Assert.IsTrue(H5P.set_chunk(dcpl, 1, chunk_dims) >= 0);
hid_t dst = H5D.create(m_v3_test_file_no_swmr, "dset1",
H5T.NATIVE_UINT, dsp, H5P.DEFAULT, dcpl, H5P.DEFAULT);
Assert.IsTrue(dst >= 0);
GCHandle hnd = GCHandle.Alloc(cbuf, GCHandleType.Pinned);
Assert.IsTrue(
H5DO.append(dst, H5P.DEFAULT, 0, new IntPtr(3),
H5T.NATIVE_UINT, hnd.AddrOfPinnedObject()) >= 0);
hnd.Free();
Assert.IsTrue(H5D.close(dst) >= 0);
Assert.IsTrue(H5P.close(dcpl) >= 0);
Assert.IsTrue(H5S.close(dsp) >= 0);
}
public static double[][] ReadMesh(string fileName)
{
double[][] meshes = new double[3][];
string[] meshNames = { "x", "y", "z" };
H5FileId fileId = H5F.open(fileName, H5F.OpenMode.ACC_RDONLY);
for (int i = 0; i < meshNames.Length; i++)
{
H5DataSetId dsId = H5D.open(fileId, "/Mesh/" + meshNames[i]);
H5DataTypeId dtId = H5D.getType(dsId);
if (!H5T.equal(dtId, H5T.copy(H5T.H5Type.NATIVE_FLOAT)))
{
Console.WriteLine("Error: Invalid dataset type, expected {0}", H5T.H5Type.NATIVE_FLOAT);
}
float[] mesh = new float[H5D.getStorageSize(dsId) / H5T.getSize(dtId)];
H5D.read(dsId, dtId, new H5Array <float>(mesh));
meshes[i] = mesh.Select(x => (double)x * 1000.0).ToArray(); // m -> mm
H5D.close(dsId);
H5T.close(dtId);
}
H5F.close(fileId);
return(meshes);
}
public static int WritePrimitiveAttribute <T>(hid_t groupId, string name, Array attributes, string datasetName = null) //where T : struct
{
var tmpId = groupId;
if (!string.IsNullOrWhiteSpace(datasetName))
{
var datasetId = H5D.open(groupId, datasetName);
if (datasetId > 0)
{
groupId = datasetId;
}
}
int rank = attributes.Rank;
ulong[] dims = Enumerable.Range(0, rank).Select(i =>
{ return((ulong)attributes.GetLength(i)); }).ToArray();
ulong[] maxDims = null;
var spaceId = H5S.create_simple(rank, dims, maxDims);
var datatype = GetDatatype(typeof(T));
var typeId = H5T.copy(datatype);
var attributeId = H5A.create(groupId, name, datatype, spaceId);
GCHandle hnd = GCHandle.Alloc(attributes, GCHandleType.Pinned);
var result = H5A.write(attributeId, datatype, hnd.AddrOfPinnedObject());
hnd.Free();
H5A.close(attributeId);
H5S.close(spaceId);
H5T.close(typeId);
if (tmpId != groupId)
{
H5D.close(groupId);
}
return(result);
}
public void H5Pget_virtual_vspaceTestVDS1()
{
hid_t vds = H5D.open(m_vds_class_file, "VDS");
Assert.IsTrue(vds >= 0);
hid_t dcpl = H5D.get_create_plist(vds);
Assert.IsTrue(dcpl >= 0);
IntPtr count = IntPtr.Zero;
Assert.IsTrue(H5P.get_virtual_count(dcpl, ref count) >= 0);
Assert.IsTrue(3 == count.ToInt32());
for (int i = 0; i < count.ToInt32(); ++i)
{
size_t index = new size_t(i);
hid_t vspace = H5P.get_virtual_vspace(dcpl, index);
Assert.IsTrue(vspace >= 0);
Assert.IsTrue(H5S.is_regular_hyperslab(vspace) > 0);
Assert.IsTrue(H5S.close(vspace) >= 0);
}
Assert.IsTrue(H5P.close(dcpl) >= 0);
Assert.IsTrue(H5D.close(vds) >= 0);
}
// information: https://www.hdfgroup.org/ftp/HDF5/examples/examples-by-api/hdf5-examples/1_8/C/H5T/h5ex_t_cmpd.c
//or: https://www.hdfgroup.org/HDF5/doc/UG/HDF5_Users_Guide-Responsive%20HTML5/index.html#t=HDF5_Users_Guide%2FDatatypes%2FHDF5_Datatypes.htm%3Frhtocid%3Dtoc6.5%23TOC_6_8_Complex_Combinationsbc-22
public static int WriteCompounds <T>(hid_t groupId, string name, IEnumerable <T> list) //where T : struct
{
Type type = typeof(T);
var size = Marshal.SizeOf(type);
var cnt = list.Count();
var typeId = create_type(type);
var log10 = (int)Math.Log10(cnt);
ulong pow = (ulong)Math.Pow(10, log10);
ulong c_s = Math.Min(1000, pow);
ulong[] chunk_size = new ulong[] { c_s };
ulong[] dims = new ulong[] { (ulong)cnt };
long dcpl = 0;
if (list.Count() == 0 || log10 == 0)
{
}
else
{
dcpl = create_property(chunk_size);
}
// Create dataspace. Setting maximum size to NULL sets the maximum
// size to be the current size.
var spaceId = H5S.create_simple(dims.Length, dims, null);
// Create the dataset and write the compound data to it.
var datasetId = H5D.create(groupId, name, typeId, spaceId, H5P.DEFAULT, dcpl);
IntPtr p = Marshal.AllocHGlobal(size * (int)dims[0]);
var ms = new MemoryStream();
BinaryWriter writer = new BinaryWriter(ms);
foreach (var strct in list)
{
writer.Write(getBytes(strct));
}
var bytes = ms.ToArray();
GCHandle hnd = GCHandle.Alloc(bytes, GCHandleType.Pinned);
var statusId = H5D.write(datasetId, typeId, spaceId, H5S.ALL,
H5P.DEFAULT, hnd.AddrOfPinnedObject());
hnd.Free();
/*
* Close and release resources.
*/
H5D.close(datasetId);
H5S.close(spaceId);
H5T.close(typeId);
H5P.close(dcpl);
Marshal.FreeHGlobal(p);
return(statusId);
}
public void H5Pget_virtual_dsetnameTestVDS1()
{
hid_t vds = H5D.open(m_vds_class_file, "VDS");
Assert.IsTrue(vds >= 0);
hid_t dcpl = H5D.get_create_plist(vds);
Assert.IsTrue(dcpl >= 0);
IntPtr count = IntPtr.Zero;
Assert.IsTrue(H5P.get_virtual_count(dcpl, ref count) >= 0);
Assert.IsTrue(3 == count.ToInt32());
string[] names = { "A", "B", "C" };
for (int i = 0; i < count.ToInt32(); ++i)
{
size_t index = new ssize_t(i);
ssize_t len = H5P.get_virtual_filename(dcpl, index, null,
IntPtr.Zero);
Assert.IsTrue(len.ToInt32() > 0);
StringBuilder name = new StringBuilder(len.ToInt32() + 1);
len = H5P.get_virtual_dsetname(dcpl, index, name, len + 1);
Assert.IsTrue(len.ToInt32() > 0);
Assert.IsTrue(name.ToString() == names[i]);
}
Assert.IsTrue(H5P.close(dcpl) >= 0);
Assert.IsTrue(H5D.close(vds) >= 0);
}
public void H5Dget_storage_sizeTest1()
{
hsize_t[] dims = { 1024, 2048 };
hid_t space = H5S.create_simple(2, dims, null);
hid_t dcpl = H5P.create(H5P.DATASET_CREATE);
Assert.IsTrue(dcpl >= 0);
Assert.IsTrue(
H5P.set_alloc_time(dcpl, H5D.alloc_time_t.EARLY) >= 0);
hid_t dset = H5D.create(m_v0_test_file, "dset", H5T.STD_I16LE,
space, H5P.DEFAULT, dcpl);
Assert.IsTrue(dset >= 0);
Assert.IsTrue(H5D.get_storage_size(dset) == 4194304);
Assert.IsTrue(H5D.close(dset) >= 0);
dset = H5D.create(m_v2_test_file, "dset", H5T.STD_I16LE,
space, H5P.DEFAULT, dcpl);
Assert.IsTrue(dset >= 0);
Assert.IsTrue(H5D.get_storage_size(dset) == 4194304);
Assert.IsTrue(H5D.close(dset) >= 0);
Assert.IsTrue(H5P.close(dcpl) >= 0);
Assert.IsTrue(H5S.close(space) >= 0);
}
public void Cleanup()
{
file_.Close();
H5D.close(dataSet_);
H5F.close(h5file_);
}
/// <summary>
/// 写数据集属性
/// </summary>
public void WriteDatasetAttribute(string datasetName, string attrName, string value)
{
H5DataSetId datasetId = H5D.open(_fileId, datasetName);
H5DataTypeId typeId = H5T.copy(H5T.H5Type.C_S1);
H5DataSpaceId spaceId = H5S.create(H5S.H5SClass.SCALAR);
H5T.setSize(typeId, value.Length);
H5AttributeId attrId = H5A.create(datasetId, attrName, typeId, spaceId);
if (value != "")
{
H5Array <byte> buffer = new H5Array <byte>(Encoding.Default.GetBytes(value));
H5A.write(attrId, typeId, buffer);
}
if (typeId != null)
{
H5T.close(typeId);
}
if (spaceId != null)
{
H5S.close(spaceId);
}
if (attrId != null)
{
H5A.close(attrId);
}
if (datasetId != null)
{
H5D.close(datasetId);
}
}
public void H5DwriteTest1()
{
string utf8string
= "Γαζέες καὶ μυρτιὲς δὲν θὰ βρῶ πιὰ στὸ χρυσαφὶ ξέφωτο";
byte[] wdata = Encoding.UTF8.GetBytes(utf8string);
hid_t dtype = H5T.create(H5T.class_t.STRING,
new IntPtr(wdata.Length));
Assert.IsTrue(H5T.set_cset(dtype, H5T.cset_t.UTF8) >= 0);
Assert.IsTrue(H5T.set_strpad(dtype, H5T.str_t.SPACEPAD) >= 0);
hid_t dset_v0 = H5D.create(m_v0_test_file, "dset", dtype,
m_space_scalar);
Assert.IsTrue(dset_v0 >= 0);
hid_t dset_v2 = H5D.create(m_v2_test_file, "dset", dtype,
m_space_scalar);
Assert.IsTrue(dset_v2 >= 0);
GCHandle hnd = GCHandle.Alloc(wdata, GCHandleType.Pinned);
Assert.IsTrue(H5D.write(dset_v0, dtype, H5S.ALL,
H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject()) >= 0);
Assert.IsTrue(H5D.write(dset_v2, dtype, H5S.ALL,
H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject()) >= 0);
hnd.Free();
Assert.IsTrue(H5T.close(dtype) >= 0);
Assert.IsTrue(H5D.close(dset_v2) >= 0);
Assert.IsTrue(H5D.close(dset_v0) >= 0);
}
public void H5Dget_spaceTest1()
{
hsize_t[] dims = { 1024, 2048 };
hid_t space = H5S.create_simple(3, dims, null);
hid_t dset = H5D.create(m_v0_test_file, "dset", H5T.STD_I16LE,
space);
Assert.IsTrue(dset >= 0);
hid_t space1 = H5D.get_space(dset);
Assert.IsTrue(space1 >= 0);
Assert.IsTrue(H5S.extent_equal(space, space1) > 0);
Assert.IsTrue(H5S.close(space1) >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
dset = H5D.create(m_v2_test_file, "dset", H5T.STD_I16LE,
space);
Assert.IsTrue(dset >= 0);
space1 = H5D.get_space(dset);
Assert.IsTrue(space1 >= 0);
Assert.IsTrue(H5S.extent_equal(space, space1) > 0);
Assert.IsTrue(H5S.close(space1) >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
Assert.IsTrue(H5S.close(space) >= 0);
}
public static unsafe void AddSomeLinks(long fileId)
{
long res;
var groupId = H5G.create(fileId, "simple");
var groupId_sub = H5G.create(groupId, "sub");
// datasets
var dataspaceId1 = H5S.create_simple(1, new ulong[] { 1 }, new ulong[] { 1 });
var datasetId1 = H5D.create(fileId, "D", H5T.NATIVE_INT8, dataspaceId1);
var data1 = new byte[] { 1 };
fixed(void *ptr = data1)
{
res = H5D.write(datasetId1, H5T.NATIVE_INT8, dataspaceId1, dataspaceId1, 0, new IntPtr(ptr));
}
res = H5D.close(datasetId1);
res = H5S.close(dataspaceId1);
var dataspaceId2 = H5S.create_simple(1, new ulong[] { 1 }, new ulong[] { 1 });
var datasetId2 = H5D.create(groupId, "D1", H5T.NATIVE_INT8, dataspaceId2);
res = H5D.close(datasetId2);
res = H5S.close(dataspaceId2);
var dataspaceId3 = H5S.create_simple(1, new ulong[] { 1 }, new ulong[] { 1 });
var datasetId3 = H5D.create(groupId_sub, "D1.1", H5T.NATIVE_INT8, dataspaceId3);
res = H5D.close(datasetId3);
res = H5S.close(dataspaceId3);
res = H5G.close(groupId);
res = H5G.close(groupId_sub);
}
public static double ReadAttribute(string file, string dataSetOrGroup, string attribute)
{
double attr = Double.NaN;
try
{
H5FileId fileId = H5F.open(file, H5F.OpenMode.ACC_RDONLY);
H5ObjectInfo objectInfo = H5O.getInfoByName(fileId, dataSetOrGroup);
H5GroupId groupId = null;
H5DataSetId dataSetId = null;
H5AttributeId attrId;
if (objectInfo.objectType == H5ObjectType.GROUP)
{
groupId = H5G.open(fileId, dataSetOrGroup);
attrId = H5A.open(groupId, attribute);
}
else
{
dataSetId = H5D.open(fileId, dataSetOrGroup);
attrId = H5A.open(dataSetId, attribute);
}
H5DataTypeId attrTypeId = H5A.getType(attrId);
double[] dAttrs = new double[] { };
if (H5T.equal(attrTypeId, H5T.copy(H5T.H5Type.NATIVE_FLOAT)))
{
float[] fAttrs = new float[H5S.getSimpleExtentNPoints(H5A.getSpace(attrId))];
H5A.read(attrId, attrTypeId, new H5Array <float>(fAttrs));
dAttrs = (from f in fAttrs select(double) f).ToArray();
}
else if (H5T.equal(attrTypeId, H5T.copy(H5T.H5Type.NATIVE_DOUBLE)))
{
dAttrs = new double[H5S.getSimpleExtentNPoints(H5A.getSpace(attrId))];
H5A.read(attrId, attrTypeId, new H5Array <double>(dAttrs));
}
H5T.close(attrTypeId);
H5A.close(attrId);
if (groupId != null)
{
H5G.close(groupId);
}
if (dataSetId != null)
{
H5D.close(dataSetId);
}
H5F.close(fileId);
return((double)dAttrs[0]);
}
catch (HDFException e)
{
Console.WriteLine("Error: Unhandled HDF5 exception");
Console.WriteLine(e.Message);
}
return(attr);
}
public void H5RcreateTest4()
{
byte[] path =
Encoding.UTF8.GetBytes(String.Join("/", m_utf8strings));
// make room for the trailling \0
byte[] name = new byte[path.Length + 1];
Array.Copy(path, name, path.Length);
hsize_t[] dims = new hsize_t[] { 10, 20 };
hid_t space = H5S.create_simple(2, dims, null);
Assert.IsTrue(space >= 0);
hid_t dset = H5D.create(m_v2_test_file, name, H5T.STD_I32LE, space,
m_lcpl_utf8);
Assert.IsTrue(dset >= 0);
hsize_t[] start = { 5, 10 };
hsize_t[] count = { 1, 1 };
hsize_t[] block = { 2, 4 };
Assert.IsTrue(
H5S.select_hyperslab(space, H5S.seloper_t.SET, start, null,
count, block) >= 0);
byte[] refer = new byte[H5R.DSET_REG_REF_BUF_SIZE];
GCHandle hnd = GCHandle.Alloc(refer, GCHandleType.Pinned);
Assert.IsTrue(
H5R.create(hnd.AddrOfPinnedObject(), m_v2_test_file, name,
H5R.type_t.DATASET_REGION, space) >= 0);
ssize_t size = H5R.get_name(m_v2_test_file,
H5R.type_t.DATASET_REGION, hnd.AddrOfPinnedObject(),
(byte[])null, IntPtr.Zero);
Assert.IsTrue(size.ToInt32() == name.Length);
byte[] buf = new byte[size.ToInt32() + 1];
size = H5R.get_name(m_v2_test_file, H5R.type_t.DATASET_REGION,
hnd.AddrOfPinnedObject(), buf, new IntPtr(buf.Length));
Assert.IsTrue(size.ToInt32() == name.Length);
// we need to account for the leading "/", which was not included
// in path
for (int i = 0; i < name.Length; ++i)
{
Assert.IsTrue(name[i] == buf[i + 1]);
}
hid_t sel = H5R.get_region(dset, H5R.type_t.DATASET_REGION,
hnd.AddrOfPinnedObject());
Assert.IsTrue(sel >= 0);
hnd.Free();
Assert.IsTrue(H5S.extent_equal(space, sel) > 0);
Assert.IsTrue(H5S.get_select_hyper_nblocks(space)
== H5S.get_select_hyper_nblocks(sel));
Assert.IsTrue(H5S.close(sel) >= 0);
Assert.IsTrue(H5D.close(dset) >= 0);
Assert.IsTrue(H5S.close(space) >= 0);
}
public static (int success, hid_t CreatedgroupId) WriteStringAttributes(hid_t groupId, string name, IEnumerable <string> strs, string datasetName = null)
{
hid_t tmpId = groupId;
if (!string.IsNullOrWhiteSpace(datasetName))
{
hid_t datasetId = H5D.open(groupId, datasetName);
if (datasetId > 0)
{
groupId = datasetId;
}
}
// create UTF-8 encoded attributes
hid_t datatype = H5T.create(H5T.class_t.STRING, H5T.VARIABLE);
H5T.set_cset(datatype, H5T.cset_t.UTF8);
H5T.set_strpad(datatype, H5T.str_t.SPACEPAD);
int strSz = strs.Count();
hid_t spaceId = H5S.create_simple(1,
new ulong[] { (ulong)strSz }, null);
var attributeId = H5A.create(groupId, name, datatype, spaceId);
GCHandle[] hnds = new GCHandle[strSz];
IntPtr[] wdata = new IntPtr[strSz];
int cntr = 0;
foreach (string str in strs)
{
hnds[cntr] = GCHandle.Alloc(
Encoding.UTF8.GetBytes(str),
GCHandleType.Pinned);
wdata[cntr] = hnds[cntr].AddrOfPinnedObject();
cntr++;
}
var hnd = GCHandle.Alloc(wdata, GCHandleType.Pinned);
var result = H5A.write(attributeId, datatype, hnd.AddrOfPinnedObject());
hnd.Free();
for (int i = 0; i < strSz; ++i)
{
hnds[i].Free();
}
H5A.close(attributeId);
H5S.close(spaceId);
H5T.close(datatype);
if (tmpId != groupId)
{
H5D.close(groupId);
}
return(result, attributeId);
}
private static void WriteFile(string filePath)
{
var file = H5F.create(filePath, H5F.CreateMode.ACC_TRUNC);
var group = H5G.create(file, "/group");
H5G.close(group);
const int RANK = 2;
const int DIM0 = 3;
const int DIM1 = 4;
var dims = new long[RANK] {
DIM0, DIM1
};
var dataSpace = H5S.create_simple(RANK, dims);
var dataSet = H5D.create(file, "/group/dataset", H5T.H5Type.NATIVE_INT, dataSpace);
H5S.close(dataSpace);
var data = new int[DIM0, DIM1]
{
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }
};
H5D.write(dataSet, new H5DataTypeId(H5T.H5Type.NATIVE_INT), new H5Array <int>(data));
var dataType = new H5DataTypeId(H5T.H5Type.NATIVE_INT);
dataSpace = H5S.create(H5S.H5SClass.SCALAR);
var integerAttribute = H5A.create(dataSet, "int", dataType, dataSpace);
H5A.write(integerAttribute, dataType, new H5Array <int>(new int[1] {
42
}));
H5A.close(integerAttribute);
H5S.close(dataSpace);
//H5T.close(dataType); // Read-only.
var str = "Hello, world!";
var strBytes = Encoding.ASCII.GetBytes(str);
// There is a H5T.get_cset, but there does not seem to be a way of setting the character encoding, i.e. set_cset.
dataType = H5T.copy(H5T.H5Type.C_S1);
H5T.setSize(dataType, strBytes.Length);
dataSpace = H5S.create(H5S.H5SClass.SCALAR);
var stringAttribute = H5A.create(dataSet, "string", dataType, dataSpace);
H5A.write(stringAttribute, dataType, new H5Array <byte>(strBytes));
H5A.close(stringAttribute);
H5S.close(dataSpace);
H5T.close(dataType);
H5D.close(dataSet);
H5F.close(file);
}
public Dictionary <string, string> TryReadDataTable(string datasetName)
{
Dictionary <string, string> result = null;
var subDsDic = ds.GetSubDatasets();
if (subDsDic.Count > 0)
{
H5ID h5FileId = H5F.open(fileName, H5F.ACC_RDONLY);
H5ID datasetId = H5D.open(h5FileId, datasetName);
H5ID typeId = H5D.get_type(datasetId);
H5ID spaceId = H5D.get_space(datasetId);
if (H5T.get_class(typeId) == H5T.class_t.COMPOUND)
{
int numCount = H5T.get_nmembers(typeId);
var size = H5T.get_size(typeId);
byte[] buffer = new byte[size.ToInt32()];
GCHandle hnd = GCHandle.Alloc(buffer, GCHandleType.Pinned);
int ndims = H5S.get_simple_extent_ndims(spaceId);
if (ndims == 1)
{
result = new Dictionary <string, string>();
H5D.read(datasetId, typeId, H5S.ALL, H5S.ALL, H5P.DEFAULT, hnd.AddrOfPinnedObject());
for (uint i = 0; i < numCount; i++)
{
string name = Marshal.PtrToStringAnsi(H5T.get_member_name(typeId, i));
int offset = H5T.get_member_offset(typeId, i).ToInt32();
H5ID subTypeId = H5T.get_member_type(typeId, i);
H5T.class_t typeClass = H5T.get_member_class(typeId, i);
string value = ReadBuffer(buffer, offset, typeClass, subTypeId);
result.Add(name, value);
H5T.close(subTypeId);
}
}
hnd.Free();
}
if (spaceId != 0)
{
H5S.close(spaceId);
}
if (typeId != 0)
{
H5T.close(typeId);
}
if (datasetId != 0)
{
H5D.close(datasetId);
}
if (h5FileId != 0)
{
H5F.close(h5FileId);
}
}
return(result);
}
public void H5DrefreshTestSWMR1()
{
hid_t dst = H5D.open(m_v3_class_file, "int6x6");
Assert.IsTrue(dst >= 0);
Assert.IsTrue(H5D.refresh(dst) >= 0);
Assert.IsTrue(H5D.close(dst) >= 0);
}
public static Hdf5Dataset CreateDataset(
Hdf5Identifier _fileId,
Hdf5Path _parentPath,
string _name,
Hdf5DataTypes _datatype,
int _numberOfDimensions,
List <Hdf5DimensionProperty> _properties)
{
Hdf5Path path = _parentPath.Append(_name);
UInt64[] dimensionSize = new UInt64[_numberOfDimensions];
UInt64[] maxSize = null; // new UInt64[_numberOfDimensions];
int i = 0;
foreach (var property in _properties)
{
dimensionSize[i] = property.CurrentSize;
//if (property.MaximumSize == UInt64.MaxValue)
//{
// maxSize[i] = H5S.UNLIMITED;
//}
//else
//{
// maxSize[i] = property.MaximumSize;
//}
i++;
}
Hdf5Identifier dataspaceId = H5S.create_simple(_numberOfDimensions, dimensionSize, maxSize).ToId();
//TODO handle string datasets
Hdf5Identifier typeId = H5T.copy(TypeHelper.GetNativeType(_datatype).Value).ToId();
var status = H5T.set_order(typeId.Value, H5T.order_t.LE);
Hdf5Identifier datasetId = H5D.create(_fileId.Value, path.FullPath, typeId.Value, dataspaceId.Value).ToId();
Hdf5Dataset dataset = null;
if (datasetId.Value > 0)
{
dataset = new Hdf5Dataset(_fileId, datasetId, path.FullPath)
{
DataType = TypeHelper.GetDataTypeFromDataset(datasetId),
Dataspace = DataspaceHelper.GetDataspace(datasetId)
};
H5D.close(datasetId.Value);
}
H5T.close(typeId.Value);
FileHelper.FlushToFile(_fileId);
return(dataset);
}
static void test_file_open()
{
try
{
// Output message about test being performed.
Console.Write("Testing file opening I/O");
// First ensure the file does not exist
File.Delete(FILE2);
// Try opening a non-existent file. This should fail.
try
{
H5FileId non_exist_file = H5F.open(FILE2, H5F.OpenMode.ACC_RDWR);
// should fail, but didn't, print out the error message.
Console.WriteLine("\ntest_file_open: Attempting to open a non-existent file.");
nerrors++;
}
catch (H5FopenException) { } // does nothing, it should fail
// Open the file.
H5FileId fileId = H5F.open(FILE1, H5F.OpenMode.ACC_RDWR);
// Create dataspace for the dataset in the file.
hssize_t[] dims = { 20 };
H5DataSpaceId dspace = H5S.create_simple(RANK, dims);
// Create a group.
H5GroupId groupId = H5G.create(fileId, GROUP_NAME);
// Create a dataset using file as location.
H5DataSetId dset1Id = H5D.create(fileId, DSET1_NAME, H5T.H5Type.NATIVE_INT, dspace);
// Create a dataset using group as location.
H5DataSetId dset2Id = H5D.create(groupId, DSET2_NAME, H5T.H5Type.NATIVE_SHORT, dspace);
// Close objects and files.
H5D.close(dset1Id);
H5D.close(dset2Id);
H5S.close(dspace);
H5G.close(groupId);
H5F.close(fileId);
Console.WriteLine("\t\t\t\tPASSED");
}
catch (HDFException anyHDF5E)
{
Console.WriteLine(anyHDF5E.Message);
nerrors++;
}
catch (System.Exception sysE)
{
Console.WriteLine(sysE.TargetSite);
Console.WriteLine(sysE.Message);
nerrors++;
}
} // test_file_open
