public static void main(final String[] args) {

try {

int[] libversion = {0, 0, 0};

H5.H5get_libversion(libversion);

System.out.println(libversion[0]+"."+libversion[1]+"."+libversion[2]);

} catch (Exception ex) {ex.printStackTrace();}

//try { testObjReadData("g:\\temp\\dset.h5", "dset"); } catch (Exception ex) {ex.printStackTrace();}

//try { testH5FileGet("g:\\temp\\dset.h5", "/dset/"); } catch (Exception ex) {ex.printStackTrace();}

//try { test3DHDF4("g:\\temp\\hdf3d.hdf", "3dint"); } catch (Exception ex) {ex.printStackTrace();}

try { testH5DataType("G:\\temp\\H5Datatype.h5"); } catch (Exception ex) {ex.printStackTrace();}

}

public static void testRefData(String fname, String dname)throws Exception

{

int size = 10;

long dims[] = {size};

long[] maxdims = {HDF5Constants.H5S_UNLIMITED};

byte[][] ref_buf = new byte[2][8];

float data[] = new float[size];

for (int i=0; i<size; i++)

data[i] = i;

H5File file = new H5File(fname, H5File.CREATE);

file.open();

// create a ref dataset

Group grp = file.createGroup("grp", null);

Dataset ds = file.createScalarDS("dset", grp, new H5Datatype(Datatype.CLASS_FLOAT, -1, -1, -1), dims, maxdims, null, 0, data);

ref_buf[0] = H5.H5Rcreate(file.getFID(), grp.getFullName(), HDF5Constants.H5R_OBJECT, -1);

ref_buf[1] = H5.H5Rcreate(file.getFID(), ds.getFullName(), HDF5Constants.H5R_OBJECT, -1);

ds = file.createScalarDS(dname, null, new H5Datatype(Datatype.CLASS_REFERENCE, -1, -1, -1), new long[] {2}, null, null, 0, ref_buf);

// create ref attributes

Datatype attr_dtype = file.createDatatype( Datatype.CLASS_REFERENCE, Datatype.NATIVE, Datatype.NATIVE, Datatype.NATIVE);

Attribute attr = new Attribute("ref", attr_dtype, new long[] {1});

attr.setValue(ds.getFullName());

file.writeAttribute(ds, attr, false);

attr = new Attribute("refs", attr_dtype, new long[] {2});

attr.setValue(ref_buf);

ds.writeMetadata(attr);

file.close();

// open the file and the dataset with refs

file.open();

ds = (H5ScalarDS)file.get(dname);

long[] refs = (long[])ds.getData();

// use low level API function, H5.H5Rget_name

String[] name = {""};;

for (int i=0; i<refs.length; i++) {

H5.H5Rget_name(file.getFID(), HDF5Constants.H5R_OBJECT, HDFNativeData.longToByte(refs[i]), name, 32);

System.out.println(name[0]);

}

// if file.open() was called, search objects in memory by high level function, findObject()

long[] oid = new long[1];

for (int i=0; i<refs.length; i++) {

oid[0] = refs[i];

HObject obj = FileFormat.findObject(file, oid);

System.out.println(obj.getFullName());

}

file.close();

}

private static void testH5VlenAttr( String fname) throws Exception

{

FileFormat fileFormat = FileFormat.getFileFormat(FileFormat.FILE_TYPE_HDF5);

if (fileFormat == null)

{

System.err.println("Cannot find HDF5 FileFormat.");

return;

}

H5File testFile = (H5File)fileFormat.create(fname);

if (testFile == null)

{

System.err.println("Failed to create file:"+fname);

return;

}

testFile.open();

Group root = (Group)((javax.swing.tree.DefaultMutableTreeNode)testFile.getRootNode()).getUserObject();

String[] data = {"abc de fghi jk lmn op qrst uvw xyz\n0 12 345 6 789"};

long[] data_dims = {1};

Datatype dtype = testFile.createDatatype(

Datatype.CLASS_STRING, data[0].length(),

Datatype.NATIVE, Datatype.NATIVE);

Dataset dataset = testFile.createScalarDS

("text", root, dtype, data_dims, null, null, 0, data);

long[] attr_dims = {3};

String[] attr_value = {"a", "ab", "abc"};

Datatype attr_dtype = testFile.createDatatype(

Datatype.CLASS_STRING, 5,

Datatype.NATIVE, Datatype.NATIVE);

Attribute attr = new Attribute("foo", attr_dtype, attr_dims);

//byte[] bvalue = Dataset.stringToByte(attr_value, 5);

attr.setValue(attr_value);

dataset.writeMetadata(attr);

testFile.close();

// read attributes back

testFile = (H5File)fileFormat.open(fname, FileFormat.READ);

if (testFile == null)

{

System.err.println("Failed to open file:"+fname);

return;

}

testFile.open();

root = (Group)((javax.swing.tree.DefaultMutableTreeNode)testFile.getRootNode()).getUserObject();

dataset = (Dataset)root.getMemberList().get(0);

List attrList = dataset.getMetadata();

attr = (Attribute)attrList.get(0);

String[] value = (String [])attr.getValue();

testFile.close();

}

/**

private static void createNestedcompound(String fname, String dname) throws Exception

{

int DIM1 = 50;

long[] dims = {DIM1};

int cmpSize = 20;

int fid=-1, did=-1, tid = -1, tid_nested=-1, sid=-1;

int indexData[] = new int[DIM1];

double lonData[] = new double[DIM1];

double latData[] = new double[DIM1];

for (int i=0; i<DIM1; i++) {

indexData[i] = i;

lonData[i] = 5200.1+i;

latData[i] = 10.2+i;

}

fid = H5.H5Fcreate(fname, HDF5Constants.H5F_ACC_TRUNC, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT);

sid = H5.H5Screate_simple(1, dims, null);

tid_nested = H5.H5Tcreate(HDF5Constants.H5T_COMPOUND, 16);

H5.H5Tinsert(tid_nested, "Lon", 0, HDF5Constants.H5T_NATIVE_DOUBLE);

H5.H5Tinsert(tid_nested, "Lat", 8, HDF5Constants.H5T_NATIVE_DOUBLE);

tid = H5.H5Tcreate(HDF5Constants.H5T_COMPOUND, cmpSize);

H5.H5Tinsert(tid, "index", 0, HDF5Constants.H5T_NATIVE_INT32);

H5.H5Tinsert(tid, "location", 4, tid_nested);

did = H5.H5Dcreate(fid, dname, tid, sid, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT);

// write the first field "index"

int tid_tmp = H5.H5Tcreate(HDF5Constants.H5T_COMPOUND, 4);

H5.H5Tinsert(tid_tmp, "index", 0, HDF5Constants.H5T_NATIVE_INT32);

H5.H5Dwrite(did, tid_tmp, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, indexData);

H5.H5Tclose(tid_tmp);

// write the first field of the nested compound, "location"->"Lon"

tid_tmp = H5.H5Tcreate(HDF5Constants.H5T_COMPOUND, 8);

H5.H5Tinsert(tid_tmp, "Lon", 0, HDF5Constants.H5T_NATIVE_DOUBLE);

int tid_tmp_nested = H5.H5Tcreate(HDF5Constants.H5T_COMPOUND, 8);

H5.H5Tinsert(tid_tmp_nested, "location", 0, tid_tmp);

H5.H5Dwrite(did, tid_tmp_nested, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, lonData);

H5.H5Tclose(tid_tmp_nested);

H5.H5Tclose(tid_tmp);

// write the second field of the nested compound, "location"->"Lat"

tid_tmp = H5.H5Tcreate(HDF5Constants.H5T_COMPOUND, 8);

H5.H5Tinsert(tid_tmp, "Lat", 0, HDF5Constants.H5T_NATIVE_DOUBLE);

tid_tmp_nested = H5.H5Tcreate(HDF5Constants.H5T_COMPOUND, 8);

H5.H5Tinsert(tid_tmp_nested, "location", 0, tid_tmp);

H5.H5Dwrite(did, tid_tmp_nested, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, latData);

H5.H5Tclose(tid_tmp_nested);

H5.H5Tclose(tid_tmp);

H5.H5Tclose(tid);

H5.H5Tclose(tid_nested);

H5.H5Sclose(sid);

H5.H5Dclose(did);

H5.H5Fclose(fid);

}

public static void testExtendData(String fname, String dname, int size, int newSize)throws Exception

{

long dims[] = {size};

long[] maxdims = {HDF5Constants.H5S_UNLIMITED};

long newDims[] = {newSize};

int extended = newSize - size;

if (extended<=0)

return; // nothing to extended

float data[] = new float[size];

for (int i=0; i<size; i++)

data[i] = i;

float extendedData[] = new float[extended];

for (int i=0; i<extended; i++)

extendedData[i] = size+i;

H5File file = new H5File(fname, H5File.CREATE);

file.open();

file.createScalarDS(dname, null, new H5Datatype(Datatype.CLASS_FLOAT, -1, -1, -1), dims, maxdims, null, 0, data);

file.close();

// reopen the file

file.open();

H5ScalarDS ds = (H5ScalarDS)file.get(dname);

ds.init();

ds.extend(newDims);

long [] start = ds.getStartDims();

long [] count = ds.getSelectedDims();

start[0] = size;

count[0] = extended;

ds.write(extendedData);

file.close();

}

private static final void testH5DeleteDS(String fname) throws Exception

{

String dname = "strs";

int nloops=1000, rank=1, strLen=1, fid=-1, tid=-1, sid=-1, did=-1;

String[] strData = { "1", "2", "3", "4" };

long[] dims = { strData.length };

byte[] byteData = new byte[strData.length*strLen];

for (int i=0; i<strData.length; i++)

System.arraycopy(strData[i].getBytes(), 0, byteData, i*strLen, strLen);

fid = H5.H5Fcreate(fname, HDF5Constants.H5F_ACC_TRUNC, HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT);

tid = H5.H5Tcopy(HDF5Constants.H5T_C_S1);

H5.H5Tset_size(tid, 1);

sid = H5.H5Screate_simple(rank, dims, null);

did = H5.H5Dcreate(fid, dname, tid, sid, HDF5Constants.H5P_DEFAULT);

H5.H5Dwrite(did, tid, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, byteData);

H5.H5Dclose(did);

H5.H5Fclose(fid);

for (int loop=0; loop<nloops; loop++) {

fid = H5.H5Fopen(fname, HDF5Constants.H5F_ACC_RDWR, HDF5Constants.H5P_DEFAULT);

H5.H5Ldelete( fid, dname, HDF5Constants.H5P_DEFAULT);

strLen = loop+1;

H5.H5Tset_size(tid, strLen);

for (int i=0; i<strData.length; i++) {

strData[i] = "";

for (int j=0; j<=loop; j++) {

strData[i] += (i+1);

}

}

byteData = new byte[strData.length*strLen];

for (int i=0; i<strData.length; i++) {

System.arraycopy(strData[i].getBytes(), 0, byteData, i*strLen, strLen);

}

did = H5.H5Dcreate(fid, dname, tid, sid, HDF5Constants.H5P_DEFAULT);

H5.H5Dwrite(did, tid, HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, byteData);

H5.H5Dclose(did);

H5.H5Fclose(fid);

}

H5.H5Sclose(sid);

H5.H5Tclose(tid);

}

private static final void testH5TconvertStr() throws Exception

{

String[] strs = {"a1234","b1234"};

int srcLen=5, dstLen=10, srcId=-1, dstId=-1, dimSize=strs.length;

byte[] buf = new byte[dimSize*dstLen];

for (int i=0; i<dimSize; i++)

System.arraycopy(strs[i].getBytes(), 0, buf, i*srcLen, 5);

for (int i=0; i<dimSize; i++)

System.out.println(new String(buf, i*srcLen, srcLen));

srcId = H5.H5Tcopy(HDF5Constants.H5T_C_S1);

H5.H5Tset_size(srcId, srcLen);

dstId = H5.H5Tcopy(HDF5Constants.H5T_C_S1);

H5.H5Tset_size(dstId, dstLen);

H5.H5Tconvert(srcId, dstId, dimSize, buf, null, HDF5Constants.H5P_DEFAULT);

H5.H5Tclose(srcId);

H5.H5Tclose(dstId);

for (int i=0; i<dimSize; i++) {

String str = new String(buf, i*dstLen, dstLen);

System.out.println(str);

System.out.println(str.startsWith(strs[i]));

}

}

private static final void testCreateVlenStr(String fname) throws Exception

{

String dname = "DS1";

int file_id=-1, type_id=-1, dataspace_id =-1, dataset_id = -1;

String[] strData = { "Parting", "is such", "sweet", "sorrow." };

int rank = 1;

long[] dims = { strData.length };

// Create a new file using default properties.

try {

file_id = H5.H5Fcreate(fname, HDF5Constants.H5F_ACC_TRUNC,

HDF5Constants.H5P_DEFAULT, HDF5Constants.H5P_DEFAULT);

}

catch (Exception e) {

e.printStackTrace();

}

try {

type_id = H5.H5Tcopy(HDF5Constants.H5T_C_S1);

H5.H5Tset_size(type_id, HDF5Constants.H5T_VARIABLE);

}

catch (Exception e) {

e.printStackTrace();

}

// Create dataspace. Setting maximum size to NULL sets the maximum

// size to be the current size.

try {

dataspace_id = H5.H5Screate_simple(rank, dims, null);

}

catch (Exception e) {

e.printStackTrace();

}

// Create the dataset and write the string data to it.

try {

if ((file_id >= 0) && (type_id >= 0) && (dataspace_id >= 0))

dataset_id = H5.H5Dcreate(file_id, dname, type_id,

dataspace_id, HDF5Constants.H5P_DEFAULT);

}

catch (Exception e) {

e.printStackTrace();

}

// Write the data to the dataset.

try {

if ((dataset_id >= 0) && (type_id >= 0))

H5.H5DwriteString(dataset_id, type_id, HDF5Constants.H5S_ALL,

HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, strData);

}

catch (Exception e) {

e.printStackTrace();

}

// Write the data to the dataset.

try {

if ((dataset_id >= 0) && (type_id >= 0)) {

String[] buf = new String[strData.length];

H5.H5Dread(dataset_id, H5.H5Dget_type(dataset_id), HDF5Constants.H5S_ALL,

HDF5Constants.H5S_ALL, HDF5Constants.H5P_DEFAULT, buf);

for (int i =0; i<strData.length; i++)

System.out.println(buf[i]);

}

}

catch (Exception e) {

e.printStackTrace();

}

// End access to the dataset and release resources used by it.

try {

if (dataset_id >= 0)

H5.H5Dclose(dataset_id);

}

catch (Exception e) {

e.printStackTrace();

}

// Terminate access to the data space.

try {

if (dataspace_id >= 0)

H5.H5Sclose(dataspace_id);

}

catch (Exception e) {

e.printStackTrace();

}

// Terminate access to the file type.

try {

if (type_id >= 0)

H5.H5Tclose(type_id);

}

catch (Exception e) {

e.printStackTrace();

}

// Close the file.

try {

if (file_id >= 0)

H5.H5Fclose(file_id);

}

catch (Exception e) {

e.printStackTrace();

}

}

private static void testUpdateAttr(String fname) throws Exception

{

int data[] = {1,2,3,4,5,6};

long[] dims = {data.length};

String dname = "/dset";

// create a new file and a new dataset

H5File file = new H5File(fname, FileFormat.CREATE);

Datatype dtype = file.createDatatype(Datatype.CLASS_INTEGER, 4, Datatype.NATIVE, Datatype.NATIVE);

Dataset dataset = file.createScalarDS (dname, null, dtype, dims, null, null, 0, data);

// create and write an attribute to the dataset

long[] attrDims = {2};

int[] attrValue = {0, 10000};

Attribute attr = new Attribute("range", dtype, attrDims);

attr.setValue(attrValue); // set the attribute value

dataset.writeMetadata(attr);

// close the file

file.close();

// open the file with read and write access

file = new H5File(fname, FileFormat.WRITE);

// retrieve the dataset and attribute

dataset = (Dataset)file.get(dname);

attr = (Attribute)dataset.getMetadata().get(0);

// change the attribute value

if (attr!=null) {

attrValue[0] = 100;

attr.setValue(attrValue);

dataset.writeMetadata(attr);

}

// close file resource

file.close();

}

public static void test1DExtendStrings(String fname) throws Exception {

//row count of my dataset

int rowCount = 5;

//max string length

int maxStringLength = 5;

//buffer of test data to write

String[] data = {"12345","12345","12345","12345","12345"};

byte[][] buffer = new byte[5][5];

for(int i=0; i<data.length; i++){

buffer[i] = data[i].getBytes();

}

//create my file

File file = new File("fname");

int fileId = H5.H5Fcreate(file.getAbsolutePath(),

HDF5Constants.H5F_ACC_TRUNC, HDF5Constants.H5P_DEFAULT,

HDF5Constants.H5P_DEFAULT);

int RANK = 1;

long[] dataset_dims = { rowCount };

long[] max_dims = { HDF5Constants.H5S_UNLIMITED };

long[] chunk_dims = { rowCount };

int strtypeId = H5.H5Tcopy(HDF5Constants.H5T_C_S1);

H5.H5Tset_size(strtypeId, maxStringLength);

int memtypeId = H5.H5Tcopy(HDF5Constants.H5T_C_S1);

H5.H5Tset_size(memtypeId, maxStringLength);

int dataspaceId = H5.H5Screate_simple(RANK, dataset_dims, max_dims);

int memspaceId = H5.H5Screate_simple(RANK, chunk_dims, chunk_dims);

int dcplId = H5.H5Pcreate(HDF5Constants.H5P_DATASET_CREATE);

H5.H5Pset_deflate(dcplId, 9);

H5.H5Pset_chunk(dcplId, 1, chunk_dims);

int datasetId = H5.H5Dcreate(fileId, "/ds0",

strtypeId, dataspaceId, dcplId);

long[] hyperslab_dims = { rowCount};

memspaceId = H5.H5Screate_simple(1, hyperslab_dims, hyperslab_dims);

H5.H5Sselect_hyperslab(dataspaceId, HDF5Constants.H5S_SELECT_SET,

new long[] { 0 }, new long[] { 1 },

new long[] { rowCount }, new long[] { 1});

H5.H5Dwrite(datasetId, memtypeId, memspaceId,

dataspaceId, HDF5Constants.H5P_DEFAULT, buffer);

H5.H5Sclose(memspaceId);

H5.H5Sclose(dataspaceId);

H5.H5Tclose(strtypeId);

H5.H5Tclose(memtypeId);

H5.H5Dclose(datasetId);

H5.H5Fclose(fileId);

}

private static void testH5Core(final String filename) throws Exception {

int fapl_id = H5.H5Pcreate(HDF5Constants.H5P_FILE_ACCESS);

H5.H5Pset_fapl_core(fapl_id, 1024, true);

}

private static void testH5IO(final String filename) throws Exception {

int SIZE = 10*1024*1024;

int fid = -1, did = -1, sid = -1, rank = 1;

long[] dims = { SIZE };

float[] buf = new float[SIZE];

try {

fid = H5.H5Fopen(filename, HDF5Constants.H5F_ACC_RDWR,

HDF5Constants.H5P_DEFAULT);

did = H5.H5Dopen(fid, "test");

long t0 = System.currentTimeMillis();

H5.H5Dread_float(did, HDF5Constants.H5T_NATIVE_FLOAT,

HDF5Constants.H5S_ALL, HDF5Constants.H5S_ALL,

HDF5Constants.H5P_DEFAULT, buf);

System.out.println(buf[SIZE-1]);

long t1 = System.currentTimeMillis();

System.out.println("Time on reading (40MB): " + (t1 - t0));

} finally {

try {

H5.H5Sclose(sid);

} catch (HDF5Exception ex) {

}

try {

H5.H5Dclose(did);

} catch (HDF5Exception ex) {

}

try {

H5.H5Fclose(fid);

} catch (HDF5Exception ex) {

}

}

}

public static void convertByte2Long() throws Exception {

long[] la = {1000000000000000001L, 1000000000000000002L, 1000000000000000003L};

byte[] ba = HDFNativeData.longToByte(0, la.length, la);

if (ba.length != la.length*8) {

System.out.println ("Failed to convert from byte[] to long[]");

return ;

}

long[] la2 = HDFNativeData.byteToLong(ba);

for (int i=0; i<la.length; i++) {

if (la[i] != la2[i]) {

System.out.println ("Failed to convert from long[] to byte[]");

return;

}

}

System.out.println ("OK: convert from byte[] to long[].");

}

public static void processa8apis() throws Exception {

String[] newAPIs = new String[200];

String[] allAPIs = new String[500];

int nNew=0, nAll=0, idx=0, idx2=0;

BufferedReader in_all18 = new BufferedReader(new FileReader("G:\\Projects\\Java\\1.8Support\\hdf5_1_8.txt"));

BufferedReader in_new18 = new BufferedReader(new FileReader("G:\\Projects\\Java\\1.8Support\\hdf5_1_8_new.txt"));

PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("G:\\Projects\\Java\\1.8Support\\hdf5_1_8_processed.txt")));

String line = in_new18.readLine();

while (line != null) {

line = line.trim();

if (line !=null && line.length()>0) {

idx = line.indexOf(' ');

idx2 = line.indexOf('(');

newAPIs[nNew++] = line.substring(idx+1, idx2+1);

}

line = in_new18.readLine();

}

idx = 0;

for (int i=0; i<nNew; i++) {

line = newAPIs[i];

if (line==null || line.length()<=0)

continue;

for (int j=i+1; j<nNew; j++) {

if (line.equals(newAPIs[j])) {

idx++;

newAPIs[j] = null;

}

}

}

System.out.println("No. of new APIs = "+(nNew - idx));

for (int i=0; i<nNew; i++)

System.out.println(newAPIs[i]);

line = in_all18.readLine();

while (line != null) {

line = line.trim();

if (line !=null && line.length()>0)

allAPIs[nAll++] = line;

line = in_all18.readLine();

}

// make sure no repeated elements

int isNew, isFunc;

String apiName, newName;

for(int i=0; i<nAll; i++) {

idx = allAPIs[i].indexOf(' ');

apiName = allAPIs[i].substring(idx+1);

isNew = isFunc = 0;

for (int j=0; j<nNew; j++) {

if (newAPIs[j] == null || newAPIs[j].length()<=0)

continue;

if (apiName.startsWith(newAPIs[j]) ||

apiName.startsWith("*"+newAPIs[j])) {

isNew = 1;

break;

}

}

if (allAPIs[i].indexOf("func")>0 || allAPIs[i].indexOf("*op_data")>0)

isFunc = 1;

line = isFunc+ "\t"+ isNew+ "\t"+ allAPIs[i].substring(0, idx) + "\t" +apiName;

out.println(line);

}

in_new18.close();

in_all18.close();

out.close();

}

public static void readTextFile(String fname) throws Exception {

BufferedReader in = new BufferedReader(new FileReader(fname));

String line = in.readLine();

StringTokenizer st = new StringTokenizer(line, ",") ;

int n = st.countTokens();

PrintWriter out

= new PrintWriter(new BufferedWriter(new FileWriter(fname+".out")));

while(st.hasMoreTokens()) {

out.print(st.nextToken());

out.println();

}

in.close();

out.close();

}

public static void writeDatatype() throws Exception{

String fname = "g:\\temp\\t1.h5";

long[] dims0D = {1};

// retrieve an instance of H5File

FileFormat fileFormat = FileFormat

.getFileFormat(FileFormat.FILE_TYPE_HDF5);

if (fileFormat == null) {

System.err.println("Cannot find HDF5 FileFormat.");

return;

}

// create a new file with a given file name.

H5File testFile = (H5File) fileFormat.create(fname);

if (testFile == null) {

System.err.println("Failed to create file:" + fname);

return;

}

// open the file and retrieve the root group

testFile.open();

H5Group root = (H5Group)

((javax.swing.tree.DefaultMutableTreeNode) testFile

.getRootNode()).getUserObject();

/** add an Attribute */

Datatype attrType = testFile.createDatatype(

Datatype.CLASS_INTEGER, 4, Datatype.NATIVE,

Datatype.NATIVE);

Attribute attr = new Attribute("attribut int", attrType,dims0D);

int[] attrValue = {15}; // attribute value

attr.setValue(attrValue); // set the attribute value

root.writeMetadata(attr);