added coordinate attribute to H5Block

missing cast on malloc reported by Oliver
1.6.6 release
2012-08-24 18:20:14 +00:00 · 2012-04-04 13:56:00 +00:00 · 2012-02-06 01:24:48 +00:00 · 2012-02-01 15:56:08 +00:00 · 2012-02-01 15:54:52 +00:00 · 2012-01-13 01:01:34 +00:00
45 changed files with 2134 additions and 5029 deletions
@@ -9,9 +9,6 @@
 /NEWS -text
 /README -text
 /autogen.sh -text
-/config.guess -text
-/config.h.in -text
-/config.sub -text
 /configure-crayxt -text
 /configure.ac -text
 /depcomp -text
@@ -19,7 +16,12 @@ doc/Doxyfile -text
 doc/H5X_File_Format.txt -text
 doc/Makefile.am -text
 doc/doxyfooter -text
+examples/core_vfd.c -text
+examples/fields.c -text
+examples/particles.c -text
+examples/simplef.F90 -text
 examples/stridedf.F90 -text
+examples/write_setview.c -text
 /install-sh -text
 /license.txt -text
 /missing -text
@@ -75,6 +77,7 @@ test/H5test.cc -text
 test/H5testF.f -text
 test/H5testFpar.F90 -text
 test/Makefile.am -text
+test/coords.F90 -text
 test/params.h -text
 test/read.c -text
 test/test.c -text
@@ -0,0 +1,13 @@
+/Makefile.in
+/aclocal.m4
+/autom4te.cache
+/build
+/config.h.in
+/configure
+doc/Makefile.in
+/ltmain.sh
+/m4
+src/H5PartF.h
+src/Makefile.in
+test/Makefile.in
+tools/Makefile.in
@@ -8,4 +8,4 @@ John Shalf (NERSC/LBNL)
 Cristina Siegerist (NERSC/LBNL)
 Mark Howison (NERSC/LBNL)

-Please use h5part@lists.psi.ch for communicaion.
+Please use h5part@lists.psi.ch for communication.
@@ -1,5 +1,4 @@
-# Trial by Antino Kim
-# Top level Makefile.am
+ACLOCAL_AMFLAGS=-I m4

 SUBDIRS = \
 	doc \
@@ -1,3 +1,88 @@
+#### H5PART 1.6.6 ############################################################
+
+Fixed typo (Write instead of Read) in the h5bl_3d_read_scalar_field* Fortran
+interface.
+
+Added missing type normalization for int32 type.
+
+Rewrite of h5pAttrib tool.
+
+#### H5PART 1.6.5 ############################################################
+
+Fixed several build errors reported by Iuri Prilepov on Ubuntu 11.04.
+
+#### H5PART 1.6.4 ############################################################
+
+Fixed bug where H5PartSetViewIndices was not setting an empty view when the
+number of elements is 0.
+
+Set a threshold on the HDF5 alignment parameter so that small metadata writes
+are not aligned, which causes large gaps in the file.
+
+#### H5PART 1.6.3 ############################################################
+
+New build system uses libtool and can build shared libraries.
+
+Fixed a bug that incorrectly identifies the number of selected points in a view
+when using H5PartSetViewIndices.
+
+Fixed bug in Fortran test reported by several people, as well as several
+incorrect views set in the C test that were causing segfaults.
+
+Fixed name mismatches in the Fortran interface, and an off-by-one indexing
+problem.
+
+#### H5PART 1.6.2 ############################################################
+
+Removed H5PartSetViewEmpty
+--------------------------
+
+An empty view can now be selected with:
+H5PartSetNumParticles(file, 0);
+
+Bug Fixes to Attribute Calls in Fortran API
+-------------------------------------------
+
+Fixed a problem where attribute values were reverting to zero.
+
+#### H5PART 1.6.1 ############################################################
+
+Chunking in the H5Part API
+--------------------------
+
+There is now an H5Part equivalent H5PartSetChunkSize to the existing
+H5BlockDefine3DChunkDims call. Both of these calls enable the chunking
+mechanism in the underlying HDF5 layer. Chunking is used in combination
+with the aligned open calls to pad datasets to alignment multiples
+on disk.
+
+All Steps Available on Write
+----------------------------
+
+Previously, existing steps in a file were only accessible in read-only mode.
+Now, all steps are available in all modes, including write-truncate and
+write-append. Thus, it is now possible to overwrite existing data in write
+mode. To help alert the user to this possibility, a warning is issued every
+time an existing dataset is written to. Warnings can be printed by setting
+the verbosity to H5PART_VERB_WARN or higher.
+
+New Throttling Routine
+----------------------
+
+Previously, a throttle factor of N meant that for P processors, the total
+number of P writes were divided into N batches of P/N writes.
+
+To better accommodate round-robin lustre striping, the new policy is to
+execute P/N batches of N writes. Thus, matching N to the number of stripes
+results in the desirable 1-1 matching of writers to stripes.
+
+Other Fixes
+-----------
+
+* The configure script should correctly detect PGI compilers now.
+* There was a small memory leak in the Fortran file open calls.
+* There was a compile error with HDF5 1.6.x due to a missing assignment.
+
 #### H5PART 1.6 ##############################################################

 Updated Documentation
@@ -122,7 +207,7 @@ calls.
 Previously, a user could overrun internal buffers for dataset names. Now, a
 fixed limit of 64 chars is imposed. Dataset names that are longer than this are
 truncated and a warning is printed. We expect that most users are using
-short canoncical names like x, px, id, etc.
+short canonical names like x, px, id, etc.

 Changes to Existing API
 -----------------------
@@ -1,46 +1,48 @@
 #!/bin/sh
 # Run this to generate all the initial makefiles, etc.

+ACLOCAL_FLAGS="-I m4 $ACLOCAL_FLAGS"
+LIBTOOLIZE_FLAGS="--force $LIBTOOLIZE_FLAGS"
+AUTOMAKE_FLAGS="--add-missing --copy --foreign $AUTOMAKE_FLAGS"
+
+LIBTOOLIZE=`which libtoolize`
+if [ "$LIBTOOLIZE" = "" ]; then
+        LIBTOOLIZE=`which glibtoolize`
+fi
+if [ "$LIBTOOLIZE" = "" ]; then
+        echo "libtoolize not found" 1>&2
+        exit 1
+fi
+
 echo "+ making misc files ..."
 touch NEWS README AUTHORS ChangeLog
 echo
-echo
+$LIBTOOLIZE $LIBTOOLIZE_FLAGS || {
+	echo "libtoolize failed"
+	exit 1
+}
 echo
 echo "+ running aclocal ..."
 aclocal $ACLOCAL_FLAGS || {
-  echo
-  echo "aclocal failed - check that all needed development files are present on system"
-  exit 1
+	echo "aclocal failed - check that all needed development files are present on system"
+	exit 1
 }
 echo
-echo
-echo
-echo
 echo "+ running autoheader ... "
 autoheader || {
-  echo
-  echo "autoheader failed"
-  exit 1
+	echo "autoheader failed"
+	exit 1
 }
 echo
-echo
-echo
 echo "+ running autoconf ... "
 autoconf || {
-  echo
-  echo "autoconf failed"
-  exit 1
+	echo "autoconf failed"
+	exit 1
 }
 echo
-echo
-echo
 echo "+ running automake ... "
-automake -a -c --foreign || {
-  echo
-  echo "automake failed"
-  exit 1
+automake $AUTOMAKE_FLAGS || {
+	echo "automake failed"
+	exit 1
 }
-echo
-echo
-echo

@@ -1,99 +0,0 @@
-/* config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#undef HAVE_INTTYPES_H
-
-/* Define to 1 if you have the <memory.h> header file. */
-#undef HAVE_MEMORY_H
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#undef HAVE_STDINT_H
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#undef HAVE_STDLIB_H
-
-/* Define to 1 if you have the <strings.h> header file. */
-#undef HAVE_STRINGS_H
-
-/* Define to 1 if you have the <string.h> header file. */
-#undef HAVE_STRING_H
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#undef HAVE_SYS_STAT_H
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#undef HAVE_SYS_TYPES_H
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#undef HAVE_UNISTD_H
-
-/* "" */
-#undef MY_BUILD_CPU
-
-/* "" */
-#undef MY_BUILD_OS
-
-/* "" */
-#undef MY_BUILD_VENDOR
-
-/* "" */
-#undef MY_GNUNAME
-
-/* "" */
-#undef MY_UNAME
-
-/* Name of package */
-#undef PACKAGE
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
-
-/* Define to 1 if you have the ANSI C header files. */
-#undef STDC_HEADERS
-
-/* Enable extensions on AIX 3, Interix.  */
-#ifndef _ALL_SOURCE
-# undef _ALL_SOURCE
-#endif
-/* Enable GNU extensions on systems that have them.  */
-#ifndef _GNU_SOURCE
-# undef _GNU_SOURCE
-#endif
-/* Enable threading extensions on Solaris.  */
-#ifndef _POSIX_PTHREAD_SEMANTICS
-# undef _POSIX_PTHREAD_SEMANTICS
-#endif
-/* Enable extensions on HP NonStop.  */
-#ifndef _TANDEM_SOURCE
-# undef _TANDEM_SOURCE
-#endif
-/* Enable general extensions on Solaris.  */
-#ifndef __EXTENSIONS__
-# undef __EXTENSIONS__
-#endif
-
-
-/* Version number of package */
-#undef VERSION
-
-/* Define to 1 if on MINIX. */
-#undef _MINIX
-
-/* Define to 2 if the system does not provide POSIX.1 features except with
-   this defined. */
-#undef _POSIX_1_SOURCE
-
-/* Define to 1 if you need to in order for `stat' and other things to work. */
-#undef _POSIX_SOURCE
@@ -1,18 +1,20 @@
 #!/bin/sh

+F90=gfortran
+
 ./configure \
        $@ \
        --enable-parallel \
        --enable-fortran \
        --enable-tools \
-        CC=cc CXX=CC FC=pgf90 \
+        CC=cc CXX=CC FC=$F90 \
        MPICC=cc MPICXX=CC MPIFC=ftn
-sed -e 's/pgf90/ftn/g' <Makefile > newMakefile
+sed -e 's/$F90/ftn/g' <Makefile > newMakefile
 mv newMakefile Makefile
-sed -e 's/pgf90/ftn/g' <src/Makefile > newMakefile
+sed -e 's/$F90/ftn/g' <src/Makefile > newMakefile
 mv newMakefile src/Makefile
-sed -e 's/pgf90/ftn/g' <test/Makefile > newMakefile
+sed -e 's/$F90/ftn/g' <test/Makefile > newMakefile
 mv newMakefile test/Makefile
-sed -e 's/pgf90/ftn/g' <tools/Makefile > newMakefile
+sed -e 's/$F90/ftn/g' <tools/Makefile > newMakefile
 mv newMakefile tools/Makefile

@@ -1,18 +1,24 @@
 # Every configure script must call AC_INIT before doing anything else.
 # AC_INIT (package, version, [bug-report], [tarname])
-AC_INIT([H5Part], [1.6.0], [h5part@lists.psi.ch], H5Part)
-
+AC_INIT([H5Part], [1.6.6], [h5part@lists.psi.ch], H5Part)

 # Ensure that a recent enough version of Autoconf is being used. 
 # If the version of Autoconf being used to create configure is earlier than version, 
 # print an error message to the standard error output and do not create configure.
-#AC_PREREQ(2.59)
-
+AC_PREREQ(2.59)

 # should be called right after AC_INIT.
 # configure scripts can create a C header file containing `#define' directives. 
 # The AC_CONFIG_HEADERS macro selects this kind of output.
-AC_CONFIG_HEADER(config.h)
+AC_CONFIG_HEADERS(config.h)
+
+AC_CONFIG_MACRO_DIR([m4])
+
+# AM_INIT_AUTOMAKE is required to use autoconf with automake
+AM_INIT_AUTOMAKE
+
+BUILD_LIBS='libH5Part'
+BUILD_TESTS='test'

 ###############################################################################
 ################# --enable-xxx and --with-xxx Argument ########################
@@ -21,32 +27,20 @@ AC_CONFIG_HEADER(config.h)
 AC_ARG_ENABLE(
 	[debug],
 	[AC_HELP_STRING([--enable-debug],
-	[Compile with debug support [default=no]])],
+	[Compile with debug flags [default=no]])],
 	[USE_DEBUG=$enableval])

-AC_ARG_ENABLE(
-	[shared],
-	[AC_HELP_STRING([--enable-shared],
-	[Compile with shared library support [default=no]])],
-	[USE_SHARED=$enableval])
-
-AC_ARG_ENABLE(
-	[64],
-	[AC_HELP_STRING([--enable-64],
-	[Compile using 64-bit flags [default=no]])],
-	[USE_64=$enableval])
-
 AC_ARG_ENABLE(
 	[fortran],
-        [AC_HELP_STRING([--enable-fortran],
+	[AC_HELP_STRING([--enable-fortran],
 	[Compile the Fortran interface [default=no]])],
-        [USE_FORTRAN=$enableval])
+	[USE_FORTRAN=$enableval])

 AC_ARG_ENABLE(
 	[parallel],
-        [AC_HELP_STRING([--enable-parallel],
+	[AC_HELP_STRING([--enable-parallel],
 	[Compile the MPI/IO interface [default=no]])],
-        [USE_PARALLEL=$enableval])
+	[USE_PARALLEL=$enableval])

 AC_ARG_ENABLE(
 	[tools],
@@ -55,35 +49,11 @@ AC_ARG_ENABLE(
        [USE_TOOLS=$enableval])

 AC_ARG_WITH(
-	[mpipath],
-	[AC_HELP_STRING([--with-mpipath],
-	[path to MPI installation [default=""]])],
-        [MPIPATH=$withval], [MPIPATH=""])
-
-AC_ARG_WITH(
-	[hdf5path],
-	[AC_HELP_STRING([--with-hdf5path],
+	[hdf5],
+	[AC_HELP_STRING([--with-hdf5],
 	[path to HDF5 installation [default=""]])],
 	[HDF5PATH=$withval], [HDF5PATH=""])

-###############################################################################
-################# A SIMPLE WORK AROUND TO USE ENV. VARS #######################
-###############################################################################
-
-SAVE_CC=$CC
-SAVE_CXX=$CXX
-SAVE_FC=$FC
-SAVE_MPICC=$MPICC
-SAVE_MPICXX=$MPICXX
-SAVE_MPIFC=$MPIFC
-SAVE_MPILIB=$MPILIB
-SAVE_MPIINC=$MPIINC
-SAVE_CFLAGS=$CFLAGS
-SAVE_FFLAGS=$FFLAGS
-SAVE_MPIROOT=$MPIROOT
-SAVE_HDF5ROOT=$HDF5ROOT
-SAVE_LDFLAGS=$LDFLAGS
-
 ###############################################################################
 ############### PATH SERACH FUNCTION - to be used later... ####################
 ###############################################################################
@@ -96,35 +66,26 @@ SAVE_LDFLAGS=$LDFLAGS
 #   @enddesc
 #@@*/

-PATH_Search()
-{
-  eval  $1=""
-  if test $# -lt 4 ; then
-    h5part_basedir=""
-  else
-    h5part_basedir="$4/"
-  fi
-  for h5part_place in $2
-    do
-      echo -n "looking in $h5part_place ... $ac_c" #1>&6
-      if test -r "$h5part_basedir$h5part_place/$3" ; then
-        echo "$ac_t"" found" #1>&6
-        eval $1="$h5part_place"
-        break
-      fi
-      if test -d "$h5part_basedir$h5part_place/$3" ; then
-        echo "$ac_t"" found" #1>&6
-        eval $1="$h5part_place"
-        break
-      fi
-      echo "$ac_t"" no" #1>&6
-    done
-
-  return
+PATH_Search() {
+	eval  $1=""
+	if test $# -lt 4 ; then
+		h5part_basedir=""
+	else
+		h5part_basedir="$4/"
+	fi
+	for h5part_place in $2; do
+		AC_MSG_CHECKING([looking in $h5part_place ... ])
+		if test -r "$h5part_basedir$h5part_place/$3" ; then
+			AC_MSG_RESULT([found])
+			eval $1="$h5part_place"
+			break
+		fi
+		AC_MSG_RESULT([no])
+	done
+	return
 }


-
 ###############################################################################
 ############# MISC SETTINGS INCLUDING C & C++ COMPILER SETTING ################
 ###############################################################################
@@ -132,82 +93,37 @@ PATH_Search()
 # individual parts host_cpu, host_vendor, and host_os.
 AC_CANONICAL_HOST

+AC_PROG_MAKE_SET

-uname=`uname -s`
-if test $uname = "AIX"; then
-  AC_MSG_CHECKING([if system is AIX])
-  AC_MSG_RESULT([OK])
-
-  # If on AIX, define _ALL_SOURCE. Allows the use of some BSD functions. 
-  # Should be called before any macros that run the C compiler.
-  AC_AIX
-fi
-
-
-# DAVINCI SPECIFIC!!!
-if test `uname -n` = "davinci"; then
-   echo "DAVINCI SPECIFIC TESTING FOR STDC++ LIBRARY!"
-   PATH_Search STDCXX_CHECK '/usr/lib64 /usr/lib' libstdc++.a
-
-   # if STDCXX_CHECK is set...
-   if test "$STDCXX_CHECK" = "/usr/lib64"; then
-      echo "STDCXX setting ..."
-      echo "STDCXX_CHECK = $STDCXX_CHECK ..."
-      STDCXX="-L/usr/lib64 -lstdc++"
-      echo "STDCXX =  $STDCXX ..."
-   elif test "$STDCXX_CHECK" = "/usr/lib"; then
-      echo "STDCXX setting ..."
-      echo "STDCXX_CHECK = $STDCXX_CHECK ..."
-      STDCXX="-L/usr/lib -lstdc++"
-      echo "STDCXX =  $STDCXX ..."
-   fi 
-fi
-
-
-# Determine a C compiler to use. 
+# Determine a C/C++ compiler to use. 
 # If CC is not already set in the environment, check for gcc and cc, then
 # for other C compilers. 
 # Set output variable CC to the name of the compiler found.
-AC_PROG_CC(pathcc icc cc_r gcc cc)
+if test "x$USE_PARALLEL" = "xyes"; then
+   	CCOMPILERS="mpicc cc"
+   	CXXCOMPILERS="mpic++ mpicxx CC"
+else
+	CCOMPILERS="pgcc pathcc icc gcc cc_r cc"
+   	CXXCOMPILERS="pgCC pathCC icpc g++"
+fi

-# AC_PROG_CC doesn't pick up cc_r in Bassi. The following AC_PATH_PROGS
-# is the fix.
-AC_PATH_PROGS([BAS_CC], [cc_r], [], [$PATH])
-
-# if BAS_CC not empty
-if test -n "$BAS_CC"; then
-  echo "CC setting for Bassi ..."
-  CC=$BAS_CC
-  echo "CC =  $CC ..."
-fi 
-
-
-# Determine a C++ compiler to use. 
-# Check if the environment variable CXX or CCC (in that order) is set; 
-# if so, then set output variable CXX to its value.
-# Otherwise, if the macro is invoked without an argument, 
-# then search for a C++ compiler under the likely names (first g++ and c++
-# then other names). 
-# If none of those checks succeed, then as a last resort set CXX to g++.
-AC_PROG_CXX(pathCC icc cc_r g++ gcc cc)
+AC_PROG_CC($CCOMPILERS)

+# Only need C++ for some of the tools
+#if test "x$USE_TOOLS" = "xyes"; then
+	AC_PROG_CXX($CXXCOMPILERS)
+#fi

 # Set output variable INSTALL to the path of a BSD-compatible install program,
 # if one is found in the current PATH. 
 # Otherwise, set INSTALL to `dir/install-sh -c`
 AC_PROG_INSTALL

-
-# AM_INIT_AUTOMAKE is required to use autoconf with automake
-AM_INIT_AUTOMAKE()
-
-
-AC_PROG_RANLIB
+AC_PROG_AWK

 # Default prefix for bindir, etc... (eg >> ./build/bin)
 AC_PREFIX_DEFAULT(`pwd`/build)

-
 # AC_DEFINE_UNQUOTED (variable, value, [description])
 # Define the C preprocessor variable variable to value
 # Use this macro instead of AC_DEFINE when variable or value is a shell variable. 
@@ -218,7 +134,6 @@ AC_DEFINE_UNQUOTED(MY_GNUNAME, "${host_cpu}-${host_vendor}-${host_os}", "")
 AC_DEFINE_UNQUOTED(MY_UNAME, "$uname", "")


-
 ###############################################################################
 ######################## CONFIGURE LINE OPTIONS ###############################
 ###############################################################################
@@ -228,215 +143,92 @@ AC_MSG_CHECKING([if debug is enabled])
 if test "X$USE_DEBUG" = "Xyes"; then
    AC_MSG_RESULT([yes])
    CFLAGS="$CFLAGS -g"
+    CXXFLAGS="$CXXFLAGS -g"
+    FFLAGS="$FFLAGS -g"
 else
    AC_MSG_RESULT([no])
 fi

-# shared library
-AC_MSG_CHECKING([if shared libraries are enabled])
-
-if test "X$USE_SHARED" = "Xyes"; then
-    AC_MSG_RESULT([yes])
-    CFLAGS="$CFLAGS -fPIC"
-    FFLAGS="$FFLAGS -fPIC"
-else
-    AC_MSG_RESULT([no])
-fi
-
-###################### 64-bit compilation enabled #############################
-AC_MSG_CHECKING([if 64-bit compilation is enabled])
-
-
-# If --enable-64 is set in the configure line
-if test "X$USE_64" = "Xyes"; then
-    AC_MSG_RESULT([yes])
-    if test $uname = "AIX"; then
-        CFLAGS="$CFLAGS -q64"
-        FFLAGS="$FFLAGS -q64"
-    fi
-
-    if test $uname = "IRIX64"; then
-        CFLAGS="$CFLAGS -64"
-        FFLAGS="$FFLAGS -64 -fPIC -fno-second-underscore"
-    fi
-else
-    AC_MSG_RESULT([no])
-fi
-
-
 ############################ fortran enabled ##################################
 AC_MSG_CHECKING([if fortran interface enabled])
 if test "X$USE_FORTRAN" = "Xyes"; then
-    AC_MSG_RESULT([yes])
+	AC_MSG_RESULT([yes])
+	LIB_FORTRAN="libH5PartF.la"
+        BUILD_LIBS="$BUILD_LIBS libH5PartF"
+	BUILD_TESTS="$BUILD_TESTS testf"

-    AC_PROG_FC(ifort xlf_r pathf90 g95 g90 ftn gfortran)
-    if test -z "$FC" ; then
-        AC_MSG_ERROR([Cannot find a fortran compiler!!!])
-        exit 1
-    fi
+	if test "X$USE_PARALLEL" = "Xyes"; then
+		AC_PROG_FC(mpif90 mpif77 ftn)
+	else
+		AC_PROG_FC(pgf90 pathf90 ifort ftn xlf_r g95 g90 gfortran)
+	fi

-    if test ! $uname = "AIX"; then
-        FFLAGS="${FFLAGS} -fPIC"
-    fi
+	if test -z "$FC" ; then
+		AC_MSG_ERROR([Cannot find a Fortran compiler!])
+		exit 1
+	fi

-    if test $FC = "g90"; then
-	FFLAGS="${FFLAGS} -fno-second-underscore"
-    fi
+	if test $FC = "g90"; then
+		FFLAGS="${FFLAGS} -fno-second-underscore"
+	fi

-    if test $FC = "g95"; then
-	FFLAGS="${FFLAGS} -fno-second-underscore"
-    fi
+	if test $FC = "g95"; then
+		FFLAGS="${FFLAGS} -fno-second-underscore"
+	fi

-    if test $FC = "gfortran"; then
-        FFLAGS="${FFLAGS} -DHAVE_GFORTRAN"
-    fi
+	AC_MSG_CHECKING([symbol convention in object files])
+	`cd src && rm -f TestUnderscore.o TestUnderscoreC.o TestUnderscore`
+	`cd src && ${FC} ${FFLAGS} -c TestUnderscore.f`
+	`cd src && ${CC} ${CFLAGS} -c TestUnderscoreC.c`
+	`cd src && ${FC} ${FFLAGS} -o TestUnderscore TestUnderscore.o TestUnderscoreC.o`

-    AC_MSG_CHECKING([symbol convention in object files])
-    `cd src && rm -f TestUnderscore.o TestUnderscoreC.o TestUnderscore`
-    `cd src && ${FC} ${FFLAGS} -c TestUnderscore.f`
-    `cd src && ${CC} ${CFLAGS} -c TestUnderscoreC.c`
-    `cd src && ${FC} ${FFLAGS} -o TestUnderscore TestUnderscore.o TestUnderscoreC.o -lc`
+	if test -f src/TestUnderscore ; then
+		UNDERSCORE_H=Underscore.h
+		`cd src && ./TestUnderscore > Underscore.h`
+		AC_MSG_RESULT([ok])
+	else
+		AC_MSG_RESULT([nok])
+		AC_MSG_ERROR([Cannot determine the symbon convention for Fortran object files!])
+		exit 1
+	fi

-    if test -f src/TestUnderscore ; then
-        UNDERSCORE_H=Underscore.h
-        `cd src && ./TestUnderscore > Underscore.h`
-        AC_MSG_RESULT([ok])
-    else
-        AC_MSG_RESULT([nok])
-        AC_MSG_ERROR([Cannot build fortran executables!!!])
-        exit 1
-    fi
 else
-    AC_MSG_RESULT([no])
+	AC_MSG_RESULT([no])
 fi


+# Disable shared libraries by default: can be enabled with --enable-shared
+LT_INIT([disable-shared])
+AC_PROG_LIBTOOL
+
+
 ######################## parallel interface enabled ###########################
 AC_MSG_CHECKING([if parallel interface enabled])
 if test "X$USE_PARALLEL" = "Xyes"; then
-    AC_MSG_RESULT([yes])
+	AC_MSG_RESULT([yes])

-    CFLAGS="${CFLAGS} -DPARALLEL_IO -DH5_HAVE_PARALLEL -DMPICH_IGNORE_CXX_SEEK"
+	CFLAGS="${CFLAGS} -DPARALLEL_IO -DMPICH_IGNORE_CXX_SEEK"
+	CXXFLAGS="${CXXFLAGS} -DPARALLEL_IO -DMPICH_IGNORE_CXX_SEEK"
+	FFLAGS="${FFLAGS} -DPARALLEL_IO"

-    AC_MSG_CHECKING([if we can compile MPI code without setting flags])
-    AC_TRY_LINK([#include "mpi.h"], [
-        MPI_Comm comm;
-	int n;
-	MPI_Comm_size( comm, &n ); ], 
-	[echo 'yes'; r='yes'], [echo "no"; r='no'] )
+	AC_MSG_CHECKING([if we can compile MPI code without setting flags])
+	AC_TRY_LINK([#include "mpi.h"], [
+		MPI_Comm comm;
+		int n;
+		MPI_Comm_size( comm, &n ); ], 
+		[AC_MSG_RESULT([yes]); r='yes'], [AC_MSG_RESULT([no]); r='no'] )

-    if test "X$r" = "Xno"; then
-        AC_PATH_PROGS([MPICC], [mpicc mpcc_r], [], [$PATH])
-        AC_PATH_PROGS([MPICXX], [mpicxx mpcc_r], [], [$PATH])
-        if test -z "$MPICC" -o -z "$MPICXX"; then 
-            AC_MSG_CHECKING([for MPI root ])
-            AC_MSG_RESULT([])
-            if test -n "$MPIROOT"; then
-                P=${MPIROOT}
-            elif test -n "$MPIHOME"; then
-                P=${MPIHOME}
-            elif test -n "$MPIPATH"; then
-                P=${MPIPATH}
-            else
-                P=''
-                P="$P /usr"
-                P="$P /usr/local"
-                P="$P /usr/local/mpi"
-                P="$P /usr/local/packages/mpi"
-                P="$P /usr/local/mpich2"
-                P="$P /usr/local/mpich"
-                P="$P /opt/xt-mpt/default/mpich2-64/P2"
-            fi
-            PATH_Search MPIROOT "$P" include/mpi.h
-            if test ! -n "$MPIROOT"; then
-		AC_MSG_ERROR([Cannot determine MPI root!!!])
-                exit 1
-            fi
-
-	    if test -e "${MPIROOT}/bin/mpicc"; then
-	       MPICC=${MPIROOT}/bin/mpicc
-	    fi
-
-	    if test -e "${MPIROOT}/bin/mpicxx"; then
-	       MPICXX=${MPIROOT}/bin/mpicxx
-	    fi
+	if test "X$r" = "Xno"; then
+		AC_MSG_ERROR([MPI wrapper can't compile or link MPI program! Please set the INCLUDE and LIBS variables manually.])
+		exit 1
 	fi

-        if test -z "$MPICC" -o -z "$MPICXX"; then 
-            MPIINC="${MPIINC} -I${MPIROOT}/include"
-            FFLAGS="${FFLAGS} -I${MPIROOT}/include"
-            AC_MSG_CHECKING([for name of MPI lib ])
-            if test -e ${MPIROOT}/lib/libmpi.a; then
-                MPILIB="-L${MPIROOT}/lib -lmpi"
-            elif test -e ${MPIROOT}/lib/libmpi.so; then
-                MPILIB="-L${MPIROOT}/lib -lmpi"
-            elif test -e ${MPIROOT}/lib/libmpich.a; then
-                MPILIB="-L${MPIROOT}/lib -lmpich"
-            elif test -e ${MPIROOT}/lib/libmpich.so; then
-                MPILIB="-L${MPIROOT}/lib -lmpich"
-            else
-                AC_MSG_RESULT([not found])
-                exit 1
-            fi
-            AC_MSG_RESULT([${MPILIB}])
-	fi
-
-        if test -n "$MPICC"; then
-	    CC=${MPICC}
-        fi 
-  
-        if test -n "$MPICXX"; then
-	    CXX=${MPICXX}
-        fi
-    fi
-
-    H5P_LIB_NAME="-lpH5Part"
-    MTARGET="libpH5Part.a"
-    TTARGET="test"
-
-
-    # parallel + fortran
-    if test "X$USE_FORTRAN" = "Xyes"; then
-        AC_PATH_PROGS([MPIFC], [mpxlf_r mpif90], [], [$PATH])
-
-        FFLAGS="${FFLAGS} -DPARALLEL_IO"
-
-	if test -z "${MPIFC}" ; then
-	    if test -e "${MPIROOT}/bin/mpif90"; then
-	       MPIFC=${MPIROOT}/bin/mpif90
-	    fi
-	fi
- 
-        # if MPIFC empty
-        if test ! -n "$MPIFC"; then
-            AC_MSG_CHECKING([ No MPIFC detected. Setting MPIFC to FC.])
-            MPIFC=$FC
-            echo "MPIFC =  $MPIFC ..."
-        fi 
-
-	if test -n "$MPIFC"; then
-	    FC=${MPIFC}
-	fi
- 
-        H5P_LIB_NAME="-lpH5PartF"
-        MTARGET="${MTARGET} libpH5PartF.a"
-        TTARGET="${TTARGET} testf"
-    fi
-
 else  # --enable-parallel=no
-    AC_MSG_RESULT([no])
-
-    H5P_LIB_NAME="-lH5Part"
-    MTARGET="libH5Part.a"
-    TTARGET="test"
-
-    if test "X$USE_FORTRAN" = "Xyes"; then
-        H5P_LIB_NAME="-lH5PartF"
-        MTARGET="${MTARGET} libH5PartF.a"
-        TTARGET="${TTARGET} testf"
-    fi
+	AC_MSG_RESULT([no])
 fi

+
+######################## tools enabled ###########################
 AC_MSG_CHECKING([whether tools are enabled])
 if test "X$USE_TOOLS" = "Xyes"; then
    AC_MSG_RESULT([yes])
@@ -449,171 +241,96 @@ else
    AC_MSG_RESULT([no])
 fi

+
 ###############################################################################
 ######################### PATH CHECKING & SETTING #############################
 ###############################################################################

 AC_MSG_CHECKING([for HDF5 root ])
 AC_MSG_RESULT([])
-if test -n "${HDF5ROOT}"; then
-    P=${HDF5ROOT}
+if test -n "${HDF5PATH}" ; then
+	P=${HDF5PATH}
+elif test -n "${HDF5ROOT}"; then
+	P=${HDF5ROOT}
 elif test -n "${HDF5HOME}" ; then
-    P=${HDF5HOME}
-elif test -n "${HDF5PATH}" ; then
-    P=${HDF5PATH}
+	P=${HDF5HOME}
+elif test -n "${HDF5_DIR}" ; then
+	P=${HDF5_DIR}
 else
-    P=''
-    P="$P /usr"
-    P="$P /usr/local"
-    P="$P /usr/local/hdf5"
-    P="$P /usr/local/packages/hdf5"
-    P="$P /apps/hdf5"
-
-    if test "X$USE_PARALLEL" = "Xyes"; then
-        P="$P /usr/local/phdf5"
-        P="$P /usr/local/hdf5/hdf5_par"
-        if test "X$USE_64" = "Xyes"; then
-            P="$P /usr/common/usg/hdf5/64/default/parallel"
-        else
-            P="$P /usr/common/usg/hdf5/32/default/parallel"
-        fi
-    else
-        P="$P /usr/local/hdf5/hdf5_serial"
-        if test "X$USE_64" = "Xyes"; then
-            P="$P /usr/common/usg/hdf5/64/default/serial"
-        else
-            P="$P /usr/common/usg/hdf5/32/default/serial"
-        fi
-    fi
+	P=''
+	P="$P /usr"
+	P="$P /usr/local"
+	P="$P /usr/local/hdf5"
+	P="$P /usr/local/packages/hdf5"
+	P="$P /apps/hdf5"
+	P="$P /opt/hdf5"
 fi
 PATH_Search HDF5ROOT "$P" include/hdf5.h
 if test -z "$HDF5ROOT"; then
-    AC_MSG_ERROR([Cannot determine HDF5 root!!!])
-    exit 1
+	AC_MSG_ERROR([Cannot find an HDF5 library!])
+	exit 1
 fi

+INCLUDES="$INCLUDES -I$HDF5ROOT/include"
+LDFLAGS="$LDFLAGS -L$HDF5ROOT/lib"
+LIBS="$LIBS -lhdf5"
+
 AC_MSG_CHECKING([if we need to link to libsz ])
 if test -n "$HDF5ROOT"; then
-    if test -f $HDF5ROOT/lib/libsz.a; then
-	AC_MSG_RESULT([yes])
-        SZLIB="-L$HDF5ROOT/lib/ -lsz"
-    else
-	AC_MSG_RESULT([no])
-        SZLIB=""
-    fi
+	if test -f $HDF5ROOT/lib/libsz.a; then
+		AC_MSG_RESULT([yes])
+		LDFLAGS="$LDFLAGS -L$HDF5ROOT/lib"
+                LIBS="$LIBS -lsz"
+	else
+		AC_MSG_RESULT([no])
+	fi
 fi

-AC_MSG_CHECKING([for static zlib root ])
-echo
-PATH_Search ZLIBROOT '/apps/zlib' lib/libz.a
-if test -n "$ZLIBROOT"; then
-    LDFLAGS="$LDFLAGS -L$ZLIBROOT/lib"
-fi
-
-FCFLAGS=${FFLAGS}
-CXXFLAGS=${CFLAGS}
+LIBS="$LIBS -lz -lm"


-###############################################################################
-#################### MISC SETTINGS - path, flags, etc #########################
-###############################################################################
+# Checks for header files.
+AC_CHECK_HEADERS([fcntl.h stdlib.h string.h unistd.h])

-H5P_LIB_LOC=`pwd`/src
+# Checks for typedefs, structures, and compiler characteristics.
+AC_HEADER_STDBOOL
+AC_TYPE_INT64_T
+AC_TYPE_SIZE_T
+AC_TYPE_SSIZE_T

-###############################################################################
-################# A SIMPLE WORK AROUND TO USE ENV. VARS #######################
-###############################################################################
-
-#if there was an external input for the variable...
-if test -n "$SAVE_CC"; then
-CC=$SAVE_CC
-fi
-
-if test -n "$SAVE_CXX"; then
-CXX=$SAVE_CXX
-fi
-
-if test -n "$SAVE_FC"; then
-FC=$SAVE_FC
-fi
-
-if test -n "$SAVE_MPICC"; then
-MPICC=$SAVE_MPICC
-fi
-
-if test -n "$SAVE_MPICXX"; then
-MPICXX=$SAVE_MPICXX
-fi
-
-if test -n "$SAVE_MPIFC"; then
-MPIFC=$SAVE_MPIFC
-fi
-
-if test -n "$SAVE_MPILIB"; then
-MPILIB=$SAVE_MPILIB
-fi
-
-if test -n "$SAVE_MPIINC"; then
-MPIINC=$SAVE_MPIINC
-fi
-
-if test -n "$SAVE_CFLAGS"; then
-CFLAGS="$SAVE_CFLAGS ${CFLAGS}"
-fi
-
-if test -n "$SAVE_FFLAGS"; then
-FFLAGS=$SAVE_FFLAGS
-fi
-
-if test -n "$SAVE_MPIROOT"; then
-MPIROOT=$SAVE_MPIROOT
-fi
-
-if test -n "$SAVE_HDF5ROOT"; then
-HDF5ROOT=$SAVE_HDF5ROOT
-fi
-
-if test -n "$SAVE_LDFLAGS"; then
-LDFLAGS=$SAVE_LDFLAGS
-fi
+# Checks for library functions.
+AC_FUNC_MALLOC
+AC_CHECK_FUNCS([memset pow strchr strdup])

 ###############################################################################
 ############## EXPORTING VARIABLES & CREATING OUTPUT FILES ####################
 ###############################################################################
 # AC_SUBST (variable, [value])
-# Create an output variable from a shell variable. 
-# Make AC_OUTPUT substitute the variable variable into output files (typically one or more `Makefile's). 
-# This means that AC_OUTPUT will replace instances of `@variable@' in input files with the value that 
-# the shell variable variable has when AC_OUTPUT is called. 
-# This value of variable should not contain literal newlines.
-# If value is given, in addition assign it to variable. 
-AC_SUBST(MPIROOT)
-AC_SUBST(HDF5ROOT)
-AC_SUBST(MPIINC)
-AC_SUBST(MPILIB)
-AC_SUBST(MPICC)
-AC_SUBST(MPICXX)
-AC_SUBST(MPIFC)
-AC_SUBST(MTARGET)
-AC_SUBST(TTARGET)
-AC_SUBST(SZLIB)
+# Create an output variable from a shell variable.  Make AC_OUTPUT substitute
+# the variable variable into output files (typically one or more `Makefile's).
+# This means that AC_OUTPUT will replace instances of `@variable@' in input
+# files with the value that the shell variable variable has when AC_OUTPUT is
+# called.  This value of variable should not contain literal newlines.  If
+# value is given, in addition assign it to variable. 
 AC_SUBST(CFLAGS)
+AC_SUBST(CXXFLAGS)
 AC_SUBST(FFLAGS)
-AC_SUBST(STDCXX)
-AC_SUBST(H5P_LIB_LOC)
-AC_SUBST(H5P_LIB_NAME)
-AC_SUBST(UNDERSCORE_H)
-AC_SUBST(BUILD_TOOLS)
+AC_SUBST(INCLUDES)
 AC_SUBST(LDFLAGS)
+AC_SUBST(LIBS)
+AC_SUBST(UNDERSCORE_H)
+AC_SUBST(LIB_FORTRAN)
+AC_SUBST(BUILD_TESTS)
+AC_SUBST(BUILD_TOOLS)

 # Make AC_OUTPUT create each `file' by copying an input file (by default `file.in'),
 # substituting the output variable values.
 AC_CONFIG_FILES([
-Makefile
-doc/Makefile
-src/Makefile
-test/Makefile
-tools/Makefile
+	Makefile
+	src/Makefile
+	doc/Makefile
+	test/Makefile
+	tools/Makefile
 ])

 AC_OUTPUT
@@ -621,27 +338,23 @@ AC_OUTPUT
 ###############################################################################
 ########################## PRINTING SUMMARY ###################################
 ###############################################################################
-echo
-echo
-echo "Summary for `(hostname || uname -n) 2>/dev/null | sed 1q`:"
-echo
-echo "Host OS:             $host_os"
-echo "Host CPU:            $host_cpu"
-echo "Host vendor:         $host_vendor"
-echo "Build libraries:     $MTARGET"
-echo "Build test programs: $TTARGET"
-echo "Build tools:         $BUILD_TOOLS"
-echo "CC =                 $CC"
-echo "CXX =                $CXX"
-echo "FC =                 $FC"
-echo "MPICC =              $MPICC"
-echo "MPICXX =             $MPICXX"
-echo "MPIFC =              $MPIFC"
-echo "CFLAGS =             $CFLAGS"
-echo "FFLAGS =             $FFLAGS"
-echo "MPILIB =             $MPILIB"
-echo "MPIINC =             $MPIINC"
-echo "MPIROOT =            $MPIROOT"
-echo "HDF5ROOT =           $HDF5ROOT"
-echo "LDFLAGS =            $LDFLAGS"
-echo
+AC_MSG_RESULT([ ])
+AC_MSG_RESULT([Summary:])
+AC_MSG_RESULT([ ])
+AC_MSG_RESULT([Host OS:             $host_os])
+AC_MSG_RESULT([Host CPU:            $host_cpu])
+AC_MSG_RESULT([Host vendor:         $host_vendor])
+AC_MSG_RESULT([Build libraries:     $BUILD_LIBS])
+AC_MSG_RESULT([Build test programs: $BUILD_TESTS])
+AC_MSG_RESULT([Build tools:         $BUILD_TOOLS])
+AC_MSG_RESULT([CC =                 $CC])
+AC_MSG_RESULT([CXX =                $CXX])
+AC_MSG_RESULT([FC =                 $FC])
+AC_MSG_RESULT([CFLAGS =             $CFLAGS])
+AC_MSG_RESULT([CXXFLAGS =           $CXXFLAGS])
+AC_MSG_RESULT([FFLAGS =             $FFLAGS])
+AC_MSG_RESULT([INCLUDES =           $INCLUDES])
+AC_MSG_RESULT([LDFLAGS =            $LDFLAGS])
+AC_MSG_RESULT([LIBS =               $LIBS])
+AC_MSG_RESULT([HDF5ROOT =           $HDF5ROOT])
+AC_MSG_RESULT([ ])
@@ -4,7 +4,7 @@
 # Project related configuration options
 #---------------------------------------------------------------------------
 PROJECT_NAME           = H5Part
-PROJECT_NUMBER         = 1.6.0
+PROJECT_NUMBER         = 1.6.6
 OUTPUT_DIRECTORY       = ./ReferencePages
 CREATE_SUBDIRS         = NO
 OUTPUT_LANGUAGE        = English
@@ -0,0 +1,51 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <mpi.h>
+#include <H5Part.h>
+
+#define DATASIZE 32
+
+int main(int argc, char** argv)
+{
+    int i, rank, nprocs;
+    h5part_int32_t data[DATASIZE];
+    h5part_int64_t stat;
+    H5PartFile *file;
+
+    // initialize MPI
+    MPI_Init (&argc, &argv);
+    MPI_Comm_rank (MPI_COMM_WORLD, &rank);
+    MPI_Comm_size (MPI_COMM_WORLD, &nprocs);
+
+    H5PartSetVerbosityLevel(H5PART_VERB_DEBUG);
+
+    char filename[8];
+    sprintf (filename, "%d.h5", rank);
+
+    file = H5PartOpenFileParallel(
+            filename,
+            H5PART_WRITE | H5PART_VFD_CORE,
+            MPI_COMM_SELF);
+    assert (file != NULL);
+
+    stat = H5PartSetStep(file, 0);
+    assert (stat == H5PART_SUCCESS);
+
+    stat = H5PartSetNumParticles(file, DATASIZE);
+    assert (stat == H5PART_SUCCESS);
+
+    // create fake data
+    for (i=0; i<DATASIZE; i++) {
+        data[i] = i + rank * DATASIZE;
+    }
+
+    // write the data
+    stat = H5PartWriteDataInt32(file, "data", data);
+    assert (stat == H5PART_SUCCESS);
+
+    H5PartCloseFile(file);
+
+    MPI_Finalize();
+    return EXIT_SUCCESS;
+}
+
@@ -0,0 +1,45 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <mpi.h>
+#include <H5Part.h>
+
+#define XSIZE 8
+#define YSIZE 8
+#define ZSIZE 8
+#define DATASIZE XSIZE*YSIZE*ZSIZE
+#define H5OpenFileParallel H5PartOpenFileParallel
+#define H5SetStep H5PartSetStep
+#define H5Block3dSetLayout H5BlockDefine3DFieldLayout
+#define H5CloseFile H5PartCloseFile
+
+int main(int argc, char** argv)
+{
+    int rank, nprocs;
+    h5part_float64_t ex[DATASIZE];
+    h5part_float64_t ey[DATASIZE];
+    h5part_float64_t ez[DATASIZE];
+    h5part_float64_t q[DATASIZE];
+    h5part_int64_t nparticles = DATASIZE;
+    H5PartFile *file;
+
+    // initialize MPI
+    MPI_Init (&argc, &argv);
+    MPI_Comm_rank (MPI_COMM_WORLD, &rank);
+    MPI_Comm_size (MPI_COMM_WORLD, &nprocs);
+
+    H5PartSetVerbosityLevel(H5PART_VERB_DEBUG);
+
+    file = H5OpenFileParallel("fields.h5", H5PART_WRITE, MPI_COMM_WORLD);
+    H5SetStep(file, 0);
+    H5Block3dSetLayout(file,
+            rank*XSIZE, (rank+1)*XSIZE - 1,
+            0, YSIZE - 1,
+            0, ZSIZE - 1);
+    H5Block3dWriteScalarFieldFloat64(file, "Q", q);
+    H5Block3dWrite3dVectorFieldFloat64(file, "E", ex, ez, ey);
+    H5CloseFile(file);
+
+    MPI_Finalize();
+    return EXIT_SUCCESS;
+}
+
@@ -0,0 +1,41 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <mpi.h>
+#include <H5Part.h>
+
+#define DATASIZE 32
+
+int main(int argc, char** argv)
+{
+    int rank, nprocs;
+    h5part_float64_t x[DATASIZE];
+    h5part_float64_t y[DATASIZE];
+    h5part_float64_t z[DATASIZE];
+    h5part_float64_t px[DATASIZE];
+    h5part_float64_t py[DATASIZE];
+    h5part_float64_t pz[DATASIZE];
+    h5part_int64_t nparticles = DATASIZE;
+    H5PartFile *file;
+
+    // initialize MPI
+    MPI_Init (&argc, &argv);
+    MPI_Comm_rank (MPI_COMM_WORLD, &rank);
+    MPI_Comm_size (MPI_COMM_WORLD, &nprocs);
+
+    H5PartSetVerbosityLevel(H5PART_VERB_DEBUG);
+
+    file = H5PartOpenFileParallel("particles.h5", H5PART_WRITE, MPI_COMM_WORLD);
+    H5PartSetStep(file, 0);
+    H5PartSetNumParticles(file, nparticles);
+    H5PartWriteDataFloat64(file, "x", x);
+    H5PartWriteDataFloat64(file, "y", y);
+    H5PartWriteDataFloat64(file, "z", z);
+    H5PartWriteDataFloat64(file, "px", px);
+    H5PartWriteDataFloat64(file, "py", py);
+    H5PartWriteDataFloat64(file, "pz", pz);
+    H5PartCloseFile(file);
+
+    MPI_Finalize();
+    return EXIT_SUCCESS;
+}
+
@@ -0,0 +1,56 @@
+program H5PartTest
+  implicit none
+
+  include 'mpif.h'
+  include 'H5PartF.h'
+
+  integer :: comm, rank, ierr
+  integer*8 :: file_id, status, npoints, i
+  real*8, allocatable :: particles(:)
+  integer*8, allocatable :: id(:)
+  real*8 :: r8val
+  integer*8 :: i8val
+
+  comm = MPI_COMM_WORLD
+  call mpi_init(ierr)
+  call mpi_comm_rank(comm, rank, ierr)
+
+  ! open the a file for parallel writing
+  file_id = h5pt_set_verbosity_level(5)
+  file_id = h5pt_openw_par('test.h5', comm)
+
+  ! in the Fortran API, time steps start at 1
+  status = h5pt_setstep(file_id, 1_8)
+
+  ! write an attribute to the file
+  status = h5pt_writefileattrib_string(file_id, 'desc', 'This is a test.')
+
+  r8val = 0.5
+  i8val = 1
+  status = h5pt_writefileattrib_r8(file_id, 'double', r8val, i8val)
+
+  ! create fake data
+  npoints = 99
+  allocate(particles(npoints), id(npoints))
+  do i=1,npoints
+    particles(i) = real(i+npoints*rank)
+    id(i) = i+npoints*rank
+  enddo
+
+  ! set the size of the 1D array
+  status = h5pt_setnpoints(file_id, npoints)
+
+  ! write the particles
+  status = h5pt_writedata_r8(file_id, "x",  particles)
+
+  ! write the ids
+  status = h5pt_writedata_i8(file_id, "id", id)
+
+  ! close the file
+  status = h5pt_close(file_id)
+
+  deallocate(particles, id)
+
+  call mpi_finalize(ierr)
+
+end program H5PartTest
@@ -0,0 +1,57 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <mpi.h>
+#include <H5Part.h>
+
+#define DATASIZE 32
+#define ITERS 4
+
+int main(int argc, char** argv)
+{
+    int i, rank, nprocs;
+    h5part_int32_t data[ITERS*DATASIZE];
+    h5part_int64_t stat;
+    h5part_int64_t offset;
+    H5PartFile *file;
+
+    // initialize MPI
+    MPI_Init (&argc, &argv);
+    MPI_Comm_rank (MPI_COMM_WORLD, &rank);
+    MPI_Comm_size (MPI_COMM_WORLD, &nprocs);
+
+    H5PartSetVerbosityLevel(H5PART_VERB_DEBUG);
+
+    file = H5PartOpenFileParallel("test.h5", H5PART_WRITE, MPI_COMM_WORLD);
+    assert (file != NULL);
+
+    stat = H5PartSetStep(file, 0);
+    assert (stat == H5PART_SUCCESS);
+
+    stat = H5PartSetNumParticles(file, ITERS*DATASIZE);
+    assert (stat == H5PART_SUCCESS);
+
+    // create fake data
+    for (i=0; i<ITERS*DATASIZE; i++) {
+        data[i] = i + rank * ITERS * DATASIZE;
+    }
+
+    offset = rank * ITERS * DATASIZE;
+
+    // iterate over arrays
+    for (i=0; i<ITERS; i++) {
+        // set the "view" to select a subset of the dataset
+        stat = H5PartSetView(file,
+                offset + i*DATASIZE,
+                offset + (i+1)*DATASIZE - 1);
+        assert (stat == H5PART_SUCCESS);
+        // write the data
+        stat = H5PartWriteDataInt32(file, "data", data + i*DATASIZE);
+        assert (stat == H5PART_SUCCESS);
+    }
+
+    H5PartCloseFile(file);
+
+    MPI_Finalize();
+    return EXIT_SUCCESS;
+}
+
@@ -269,17 +269,16 @@ static h5part_int64_t
 _allgather (
 	const H5PartFile *f		/*!< IN: file handle */
 	) {
-	struct H5BlockPartition *partition = &f->block->user_layout[f->myproc];
 	struct H5BlockPartition *layout = f->block->user_layout;

 	MPI_Datatype    partition_m;
 	size_t n = sizeof (struct H5BlockPartition) / sizeof (h5part_int64_t);

 	MPI_Type_contiguous ( n, MPI_LONG_LONG, &partition_m );
-	  MPI_Type_commit ( &partition_m );
+	MPI_Type_commit ( &partition_m );

-	MPI_Allgather ( partition, 1, partition_m, layout, 1, partition_m,
-			f->comm );
+	MPI_Allgather ( MPI_IN_PLACE, 0, MPI_DATATYPE_NULL,
+			layout, 1, partition_m, f->comm );

 	return H5PART_SUCCESS;
 }
@@ -721,8 +720,13 @@ _release_hyperslab (
 /*!
  \ingroup h5block_model

-  Define the field layout given the dense index space at the actual
-  time step.
+  Defines the partition of the field that this processor owns, using
+  Fortran ordering: the fastest moving index is \c i.
+
+  This routine uses an MPI_Allgather, so at large concurrency it should
+  be called as infrequently as possible. For instance, if several timesteps
+  use the same field dimensions, set the layout only once before the
+  first timestep.

  \return \c H5PART_SUCCESS on success<br>
  \c H5PART_ERR_MPI<br>
@@ -1186,6 +1190,11 @@ _H5Block_read_data (
 	herr = _H5Block_select_hyperslab_for_reading ( f, dataset_id );
 	if ( herr < 0 ) return herr;

+#ifdef PARALLEL_IO
+	herr = _H5Part_start_throttle ( f );
+	if ( herr < 0 ) return herr;
+#endif
+
 	herr = H5Dread ( 
 		dataset_id,
 		type,
@@ -1195,6 +1204,11 @@ _H5Block_read_data (
 		data );
 	if ( herr < 0 ) return HANDLE_H5D_READ_ERR ( name, f->timestep );

+#ifdef PARALLEL_IO
+	herr = _H5Part_end_throttle ( f );
+	if ( herr < 0 ) return herr;
+#endif
+
 	herr = H5Dclose ( dataset_id );
 	if ( herr < 0 ) return HANDLE_H5D_CLOSE_ERR;

@@ -1443,6 +1457,11 @@ _H5Block_write_data (
 		);
 	if ( dataset < 0 ) return HANDLE_H5D_CREATE_ERR ( name, f->timestep );

+#ifdef PARALLEL_IO
+	herr = _H5Part_start_throttle ( f );
+	if ( herr < 0 ) return herr;
+#endif
+
 	herr = H5Dwrite ( 
 		dataset,
 		type,
@@ -1452,6 +1471,11 @@ _H5Block_write_data (
 		data );
 	if ( herr < 0 ) return HANDLE_H5D_WRITE_ERR ( name, f->timestep );

+#ifdef PARALLEL_IO
+	herr = _H5Part_end_throttle ( f );
+	if ( herr < 0 ) return herr;
+#endif
+
 	herr = H5Dclose ( dataset );
 	if ( herr < 0 ) return HANDLE_H5D_CLOSE_ERR;

@@ -1985,6 +2009,250 @@ H5Block3dSetFieldSpacing (
 		3 );
 }

+/*!
+  \ingroup h5block_attrib
+
+  Get the explicit list of X coordinates for field \c field_name in the current
+  time step. The coordinates are read into the 1D array \c coords which has
+  length \c coords_len.
+
+  By convention, the \c coords array should have the same length as the X
+  dimension of the field, and a warning will be printed if they differ.
+
+
+  \return \c H5PART_SUCCESS or error code
+*/
+h5part_int64_t
+H5Block3dGetFieldXCoords(
+	H5PartFile *f,				/*!< IN: file handle */
+	const char *field_name,			/*!< IN: field name */
+	h5part_float64_t *coords,		/*!< OUT: X coordinates */
+	const h5part_int64_t coords_len		/*!< IN: length of coordinates */
+	) {
+
+	SET_FNAME ( "H5BlockGetFieldXCoords" );
+	BLOCK_INIT ( f );
+	CHECK_TIMEGROUP( f );
+	CHECK_LAYOUT( f );
+
+	struct H5BlockStruct *b = f->block;
+
+	if (coords_len != b->i_max + 1)
+	    _H5Part_print_warn( "Coordinate array length (%lld) does not match X dimension (%lld)",
+		    (long long)coords_len, (long long)b->i_max + 1);
+
+	return _read_field_attrib (
+		f,
+		field_name,
+		H5BLOCK_FIELD_XCOORD_NAME,
+		coords );
+}
+
+/*!
+  \ingroup h5block_attrib
+
+  Set an explicit list of X coordinates for field \c field_name in the current
+  time step. The coordinates are a 1D array of floating point values with
+  dimension \c coords_len.
+
+  By convention, the \c coords array should have the same length as the X
+  dimension of the field, and a warning will be printed if not.
+
+  \return \c H5PART_SUCCESS or error code
+*/
+h5part_int64_t
+H5Block3dSetFieldXCoords (
+	H5PartFile *f,				/*!< IN: file handle */
+	const char *field_name,			/*!< IN: field name */
+	const h5part_float64_t *coords,		/*!< IN: X coordinates */
+	const h5part_int64_t coords_len		/*!< IN: number of coordinates */
+	) {
+
+	SET_FNAME ( "H5BlockSetFieldXCoords" );
+	BLOCK_INIT ( f );
+	CHECK_WRITABLE_MODE( f );
+	CHECK_TIMEGROUP( f );
+	CHECK_LAYOUT( f );
+
+	struct H5BlockStruct *b = f->block;
+
+	if (coords_len != b->i_max + 1)
+	    _H5Part_print_warn( "Coordinate array length (%lld) does not match X dimension (%lld)",
+		    (long long)coords_len, (long long)b->i_max + 1);
+
+	return _write_field_attrib (
+		f,
+		field_name,
+		H5BLOCK_FIELD_XCOORD_NAME,
+		(const hid_t)H5PART_FLOAT64, 
+		coords,
+		coords_len
+		 );
+}
+
+/*!
+  \ingroup h5block_attrib
+
+  Get the explicit list of Y coordinates for field \c field_name in the current
+  time step. The coordinates are read into the 1D array \c coords which has
+  length \c coords_len.
+
+  By convention, the \c coords array should have the same length as the Y
+  dimension of the field, and a warning will be printed if they differ.
+
+
+  \return \c H5PART_SUCCESS or error code
+*/
+h5part_int64_t
+H5Block3dGetFieldYCoords(
+	H5PartFile *f,				/*!< IN: file handle */
+	const char *field_name,			/*!< IN: field name */
+	h5part_float64_t *coords,		/*!< OUT: Y coordinates */
+	const h5part_int64_t coords_len		/*!< IN: length of coordinates */
+	) {
+
+	SET_FNAME ( "H5BlockGetFieldYCoords" );
+	BLOCK_INIT ( f );
+	CHECK_TIMEGROUP( f );
+	CHECK_LAYOUT( f );
+
+	struct H5BlockStruct *b = f->block;
+
+	if (coords_len != b->j_max + 1)
+	    _H5Part_print_warn( "Coordinate array length (%lld) does not match Y dimension (%lld)",
+		    (long long)coords_len, (long long)b->j_max + 1);
+
+	return _read_field_attrib (
+		f,
+		field_name,
+		H5BLOCK_FIELD_YCOORD_NAME,
+		coords );
+}
+
+
+/*!
+  \ingroup h5block_attrib
+
+  Set an explicit list of Y coordinates for field \c field_name in the current
+  time step. The coordinates are a 1D array of floating point values with
+  dimension \c coords_len.
+
+  By convention, the \c coords array should have the same length as the Y
+  dimension of the field, and a warning will be printed if not.
+
+  \return \c H5PART_SUCCESS or error code
+*/
+h5part_int64_t
+H5Block3dSetFieldYCoords (
+	H5PartFile *f,				/*!< IN: file handle */
+	const char *field_name,			/*!< IN: field name */
+	const h5part_float64_t *coords,		/*!< IN: Y coordinates */
+	const h5part_int64_t coords_len		/*!< IN: number of coordinates */
+	) {
+
+	SET_FNAME ( "H5BlockSetFieldYCoords" );
+	BLOCK_INIT ( f );
+	CHECK_WRITABLE_MODE( f );
+	CHECK_TIMEGROUP( f );
+	CHECK_LAYOUT( f );
+
+	struct H5BlockStruct *b = f->block;
+
+	if (coords_len != b->j_max + 1)
+	    _H5Part_print_warn( "Coordinate array length (%lld) does not match X dimension (%lld)",
+		    (long long)coords_len, (long long)b->j_max + 1);
+
+	return _write_field_attrib (
+		f,
+		field_name,
+		H5BLOCK_FIELD_YCOORD_NAME,
+		(const hid_t)H5PART_FLOAT64, 
+		coords,
+		coords_len
+		 );
+}
+
+/*!
+  \ingroup h5block_attrib
+
+  Get the explicit list of Z coordinates for field \c field_name in the current
+  time step. The coordinates are read into the 1D array \c coords which has
+  length \c coords_len.
+
+  By convention, the \c coords array should have the same length as the Z
+  dimension of the field, and a warning will be printed if they differ.
+
+
+  \return \c H5PART_SUCCESS or error code
+*/
+h5part_int64_t
+H5Block3dGetFieldZCoords(
+	H5PartFile *f,				/*!< IN: file handle */
+	const char *field_name,			/*!< IN: field name */
+	h5part_float64_t *coords,		/*!< OUT: Z coordinates */
+	const h5part_int64_t coords_len		/*!< IN: length of coordinates */
+	) {
+
+	SET_FNAME ( "H5BlockGetFieldZCoords" );
+	BLOCK_INIT ( f );
+	CHECK_TIMEGROUP( f );
+	CHECK_LAYOUT( f );
+
+	struct H5BlockStruct *b = f->block;
+
+	if (coords_len != b->k_max + 1)
+	    _H5Part_print_warn( "Coordinate array length (%lld) does not match Z dimension (%lld)",
+		    (long long)coords_len, (long long)b->k_max + 1);
+
+	return _read_field_attrib (
+		f,
+		field_name,
+		H5BLOCK_FIELD_ZCOORD_NAME,
+		coords );
+}
+
+/*!
+  \ingroup h5block_attrib
+
+  Set an explicit list of Z coordinates for field \c field_name in the current
+  time step. The coordinates are a 1D array of floating point values with
+  dimension \c coords_len.
+
+  By convention, the \c coords array should have the same length as the Z
+  dimension of the field, and a warning will be printed if not.
+
+  \return \c H5PART_SUCCESS or error code
+*/
+h5part_int64_t
+H5Block3dSetFieldZCoords (
+	H5PartFile *f,				/*!< IN: file handle */
+	const char *field_name,			/*!< IN: field name */
+	const h5part_float64_t *coords,		/*!< IN: Z coordinates */
+	const h5part_int64_t coords_len		/*!< IN: number of coordinates */
+	) {
+
+	SET_FNAME ( "H5BlockSetFieldZCoords" );
+	BLOCK_INIT ( f );
+	CHECK_WRITABLE_MODE( f );
+	CHECK_TIMEGROUP( f );
+	CHECK_LAYOUT( f );
+
+	struct H5BlockStruct *b = f->block;
+
+	if (coords_len != b->k_max + 1)
+	    _H5Part_print_warn( "Coordinate array length (%lld) does not match X dimension (%lld)",
+		    (long long)coords_len, (long long)b->k_max  + 1);
+
+	return _write_field_attrib (
+		f,
+		field_name,
+		H5BLOCK_FIELD_ZCOORD_NAME,
+		(const hid_t)H5PART_FLOAT64, 
+		coords,
+		coords_len
+		 );
+}
+
 /*!
  \ingroup h5block_model

@@ -232,4 +232,69 @@ INTEGER*8 FUNCTION h5bl_3d_set_field_origin ( filehandle, name, x, y, z )
    REAL*8, INTENT(IN) :: z
 END FUNCTION
  
+!> \ingroup h5blockf_attrib
+!! See \ref H5Block3dGetFieldXCoords
+!! \return 0 on success or error code
+!<
+INTEGER*8 FUNCTION h5bl_3d_get_field_xcoords ( filehandle, name, coords )
+    INTEGER*8, INTENT(IN) :: filehandle
+    CHARACTER(LEN=*), INTENT(IN) :: name
+    REAL*8, INTENT(OUT) :: coords(*)
+    INTEGER*8, INTENT(IN) :: coords_len
+END FUNCTION
  
+!> \ingroup h5blockf_attrib
+!! See \ref H5Block3dSetFieldXCoords
+!! \return 0 on success or error code
+!<
+INTEGER*8 FUNCTION h5bl_3d_set_field_xcoords ( filehandle, name, coords )
+    INTEGER*8, INTENT(IN) :: filehandle
+    CHARACTER(LEN=*), INTENT(IN) :: name
+    REAL*8, INTENT(IN) :: coords(*)
+    INTEGER*8, INTENT(IN) :: coords_len
+END FUNCTION
+
+!> \ingroup h5blockf_attrib
+!! See \ref H5Block3dGetFieldYCoords
+!! \return 0 on success or error code
+!<
+INTEGER*8 FUNCTION h5bl_3d_get_field_ycoords ( filehandle, name, coords )
+    INTEGER*8, INTENT(IN) :: filehandle
+    CHARACTER(LEN=*), INTENT(IN) :: name
+    REAL*8, INTENT(OUT) :: coords(*)
+    INTEGER*8, INTENT(IN) :: coords_len
+END FUNCTION
+  
+!> \ingroup h5blockf_attrib
+!! See \ref H5Block3dSetFieldYCoords
+!! \return 0 on success or error code
+!<
+INTEGER*8 FUNCTION h5bl_3d_set_field_ycoords ( filehandle, name, coords )
+    INTEGER*8, INTENT(IN) :: filehandle
+    CHARACTER(LEN=*), INTENT(IN) :: name
+    REAL*8, INTENT(IN) :: coords(*)
+    INTEGER*8, INTENT(IN) :: coords_len
+END FUNCTION
+
+!> \ingroup h5blockf_attrib
+!! See \ref H5Block3dGetFieldZCoords
+!! \return 0 on success or error code
+!<
+INTEGER*8 FUNCTION h5bl_3d_get_field_zcoords ( filehandle, name, coords )
+    INTEGER*8, INTENT(IN) :: filehandle
+    CHARACTER(LEN=*), INTENT(IN) :: name
+    REAL*8, INTENT(OUT) :: coords(*)
+    INTEGER*8, INTENT(IN) :: coords_len
+END FUNCTION
+  
+!> \ingroup h5blockf_attrib
+!! See \ref H5Block3dSetFieldZCoords
+!! \return 0 on success or error code
+!<
+INTEGER*8 FUNCTION h5bl_3d_set_field_zcoords ( filehandle, name, coords )
+    INTEGER*8, INTENT(IN) :: filehandle
+    CHARACTER(LEN=*), INTENT(IN) :: name
+    REAL*8, INTENT(IN) :: coords(*)
+    INTEGER*8, INTENT(IN) :: coords_len
+END FUNCTION
+
@@ -13,6 +13,9 @@ extern "C" {

 #define H5BLOCK_FIELD_ORIGIN_NAME	"__Origin__"
 #define H5BLOCK_FIELD_SPACING_NAME	"__Spacing__"
+#define H5BLOCK_FIELD_XCOORD_NAME	"__X_Coordinates__"
+#define H5BLOCK_FIELD_YCOORD_NAME	"__Y_Coordinates__"
+#define H5BLOCK_FIELD_ZCOORD_NAME	"__Z_Coordinates__"

 /*! 
  Interface for block structured field data.
@@ -138,6 +141,54 @@ H5Block3dSetFieldSpacing (
 	const h5part_float64_t z_spacing
 	);

+h5part_int64_t
+H5Block3dGetFieldXCoords (
+	H5PartFile *f,
+	const char *field_name,
+	h5part_float64_t *coords,
+	const h5part_int64_t coords_len
+	);
+
+h5part_int64_t
+H5Block3dSetFieldXCoords (
+	H5PartFile *f,
+	const char *field_name,
+	const h5part_float64_t *coords,
+	const h5part_int64_t coords_len
+	);
+
+h5part_int64_t
+H5Block3dGetFieldYCoords (
+	H5PartFile *f,
+	const char *field_name,
+	h5part_float64_t *coords,
+	const h5part_int64_t coords_len
+	);
+
+h5part_int64_t
+H5Block3dSetFieldYCoords (
+	H5PartFile *f,
+	const char *field_name,
+	const h5part_float64_t *coords,
+	const h5part_int64_t coords_len
+	);
+
+h5part_int64_t
+H5Block3dGetFieldZCoords (
+	H5PartFile *f,
+	const char *field_name,
+	h5part_float64_t *coords,
+	const h5part_int64_t coords_len
+	);
+
+h5part_int64_t
+H5Block3dSetZCoords (
+	H5PartFile *f,
+	const char *field_name,
+	const h5part_float64_t *coords,
+	const h5part_int64_t coords_len
+	);
+
 h5part_int64_t
 H5BlockWriteFieldAttrib (
 	H5PartFile *f,
@@ -68,6 +68,24 @@
 #define h5bl_3d_get_field_origin F77NAME (				\
 					h5bl_3d_get_field_origin_,	\
 					H5BL_3D_GET_FIELD_origin )
+#define h5bl_3d_get_field_xcoords F77NAME (				\
+					h5bl_3d_get_field_xcoords_,	\
+					H5BL_3D_GET_FIELD_XCOORDS )
+#define h5bl_3d_set_field_xcoords F77NAME (				\
+					h5bl_3d_set_field_xcoords_,	\
+					H5BL_3D_SET_FIELD_XCOORDS )
+#define h5bl_3d_get_field_ycoords F77NAME (				\
+					h5bl_3d_get_field_ycoords_,	\
+					H5BL_3D_GET_FIELD_YCOORDS )
+#define h5bl_3d_set_field_ycoords F77NAME (				\
+					h5bl_3d_set_field_ycoords_,	\
+					H5BL_3D_SET_FIELD_YCOORDS )
+#define h5bl_3d_get_field_zcoords F77NAME (				\
+					h5bl_3d_get_field_zcoords_,	\
+					H5BL_3D_GET_FIELD_ZCOORDS )
+#define h5bl_3d_set_field_zcoords F77NAME (				\
+					h5bl_3d_set_field_zcoords_,	\
+					H5BL_3D_SET_FIELD_ZCOORDS )
 #endif

 h5part_int64_t
@@ -365,7 +383,7 @@ h5bl_has_fielddata (
 }

 h5part_int64_t
-h5b_3d_get_field_spacing (
+h5bl_3d_get_field_spacing (
 	h5part_int64_t *f,
 	const char *field_name,
 	h5part_float64_t *x,
@@ -386,7 +404,7 @@ h5b_3d_get_field_spacing (
 }

 h5part_int64_t
-h5b_3d_set_field_spacing (
+h5bl_3d_set_field_spacing (
 	h5part_int64_t *f,
 	const char *field_name,
 	const h5part_float64_t *x,
@@ -407,7 +425,7 @@ h5b_3d_set_field_spacing (
 }

 h5part_int64_t
-h5b_3d_get_field_origin (
+h5bl_3d_get_field_origin (
 	h5part_int64_t *f,
 	const char *field_name,
 	h5part_float64_t *x,
@@ -428,7 +446,7 @@ h5b_3d_get_field_origin (
 }

 h5part_int64_t
-h5b_3d_set_field_origin (
+h5bl_3d_set_field_origin (
 	h5part_int64_t *f,
 	const char *field_name,
 	const h5part_float64_t *x,
@@ -447,3 +465,123 @@ h5b_3d_set_field_origin (
 	free ( field_name2 );
 	return herr;
 }
+
+h5part_int64_t
+h5bl_3d_set_field_xcoords (
+	h5part_int64_t *f,
+	const char *field_name,
+	const h5part_float64_t *coords,
+	const h5part_int64_t *coords_len,
+	const int l_field_name
+	) {
+
+	H5PartFile *filehandle = (H5PartFile*)(size_t)*f;
+
+	char *field_name2 =  _H5Part_strdupfor2c ( field_name, l_field_name );
+
+	h5part_int64_t herr = H5Block3dSetFieldXCoords (
+		filehandle, field_name2, coords, *coords_len );
+
+	free ( field_name2 );
+	return herr;
+}
+
+h5part_int64_t
+h5bl_3d_get_field_xcoords (
+	h5part_int64_t *f,
+	const char *field_name,
+	h5part_float64_t *coords,
+	const h5part_int64_t *coords_len,
+	const int l_field_name
+	) {
+
+	H5PartFile *filehandle = (H5PartFile*)(size_t)*f;
+
+	char *field_name2 =  _H5Part_strdupfor2c ( field_name, l_field_name );
+
+	h5part_int64_t herr = H5Block3dGetFieldXCoords (
+		filehandle, field_name2, coords, *coords_len );
+
+	free ( field_name2 );
+	return herr;
+}
+
+h5part_int64_t
+h5bl_3d_set_field_ycoords (
+	h5part_int64_t *f,
+	const char *field_name,
+	const h5part_float64_t *coords,
+	const h5part_int64_t *coords_len,
+	const int l_field_name
+	) {
+
+	H5PartFile *filehandle = (H5PartFile*)(size_t)*f;
+
+	char *field_name2 =  _H5Part_strdupfor2c ( field_name, l_field_name );
+
+	h5part_int64_t herr = H5Block3dSetFieldYCoords (
+		filehandle, field_name2, coords, *coords_len );
+
+	free ( field_name2 );
+	return herr;
+}
+
+h5part_int64_t
+h5bl_3d_get_field_ycoords (
+	h5part_int64_t *f,
+	const char *field_name,
+	h5part_float64_t *coords,
+	const h5part_int64_t *coords_len,
+	const int l_field_name
+	) {
+
+	H5PartFile *filehandle = (H5PartFile*)(size_t)*f;
+
+	char *field_name2 =  _H5Part_strdupfor2c ( field_name, l_field_name );
+
+	h5part_int64_t herr = H5Block3dGetFieldYCoords (
+		filehandle, field_name2, coords, *coords_len );
+
+	free ( field_name2 );
+	return herr;
+}
+
+h5part_int64_t
+h5bl_3d_set_field_zcoords (
+	h5part_int64_t *f,
+	const char *field_name,
+	const h5part_float64_t *coords,
+	const h5part_int64_t *coords_len,
+	const int l_field_name
+	) {
+
+	H5PartFile *filehandle = (H5PartFile*)(size_t)*f;
+
+	char *field_name2 =  _H5Part_strdupfor2c ( field_name, l_field_name );
+
+	h5part_int64_t herr = H5Block3dSetFieldZCoords (
+		filehandle, field_name2, coords, *coords_len );
+
+	free ( field_name2 );
+	return herr;
+}
+
+h5part_int64_t
+h5bl_3d_get_field_zcoords (
+	h5part_int64_t *f,
+	const char *field_name,
+	h5part_float64_t *coords,
+	const h5part_int64_t *coords_len,
+	const int l_field_name
+	) {
+
+	H5PartFile *filehandle = (H5PartFile*)(size_t)*f;
+
+	char *field_name2 =  _H5Part_strdupfor2c ( field_name, l_field_name );
+
+	h5part_int64_t herr = H5Block3dGetFieldZCoords (
+		filehandle, field_name2, coords, *coords_len );
+
+	free ( field_name2 );
+	return herr;
+}
@@ -57,7 +57,7 @@ h5bl_3d_read_scalar_field_r8 (

 	char *field_name2 =  _H5Part_strdupfor2c ( field_name,  l_field_name );

-	h5part_int64_t herr = H5Block3dWriteScalarFieldFloat64 (
+	h5part_int64_t herr = H5Block3dReadScalarFieldFloat64 (
 		filehandle, field_name2, data );

 	free ( field_name2 );
@@ -161,7 +161,7 @@ h5bl_3d_read_scalar_field_r4 (

 	char *field_name2 =  _H5Part_strdupfor2c ( field_name,  l_field_name );

-	h5part_int64_t herr = H5Block3dWriteScalarFieldFloat32 (
+	h5part_int64_t herr = H5Block3dReadScalarFieldFloat32 (
 		filehandle, field_name2, data );

 	free ( field_name2 );
@@ -265,7 +265,7 @@ h5bl_3d_read_scalar_field_i8 (

 	char *field_name2 =  _H5Part_strdupfor2c ( field_name,  l_field_name );

-	h5part_int64_t herr = H5Block3dWriteScalarFieldInt64 (
+	h5part_int64_t herr = H5Block3dReadScalarFieldInt64 (
 		filehandle, field_name2, data );

 	free ( field_name2 );
@@ -369,7 +369,7 @@ h5bl_3d_read_scalar_field_i4 (

 	char *field_name2 =  _H5Part_strdupfor2c ( field_name,  l_field_name );

-	h5part_int64_t herr = H5Block3dWriteScalarFieldInt32 (
+	h5part_int64_t herr = H5Block3dReadScalarFieldInt32 (
 		filehandle, field_name2, data );

 	free ( field_name2 );
@@ -567,10 +567,10 @@ _halo_exchange_buffers (
 	ibufsize = (int)bufsize;
 	if ( (h5part_int64_t)ibufsize != bufsize ) return HANDLE_MPI_INT64_ERR;

-	send_buffer = malloc ( bufsize );
+	send_buffer = (char*) malloc ( bufsize );
 	if ( send_buffer == NULL ) return HANDLE_H5PART_NOMEM_ERR;

-	recv_buffer = malloc ( bufsize );
+	recv_buffer = (char*) malloc ( bufsize );
 	if ( recv_buffer == NULL ) return HANDLE_H5PART_NOMEM_ERR;

 	/* forward */
@@ -10,8 +10,11 @@
 #include "H5MultiBlockErrors.h"
 #include "H5MultiBlockPrivate.h"

+#ifdef PARALLEL_IO
+
+
 /*!
-  \ingroup h5multiblock_write
+  \ingroup h5multiblock_data

  Write a multiblock field \c name from the buffer starting at \c data
  to the current time-step using the defined block decomposition and dimensions.
@@ -39,7 +42,7 @@ H5MultiBlock3dWriteFieldFloat64 (
 }

 /*!
-  \ingroup h5multiblock_read
+  \ingroup h5multiblock_data

  Allocate a buffer to hold a block from a multiblock field and place the
  pointer in \c data, then read the block into the buffer. Uses the block
@@ -68,7 +71,7 @@ H5MultiBlock3dReadFieldFloat64 (
 }

 /*!
-  \ingroup h5multiblock_write
+  \ingroup h5multiblock_data

  Write a multiblock field \c name from the buffer starting at \c data
  to the current time-step using the defined block decomposition and dimensions.
@@ -96,7 +99,7 @@ H5MultiBlock3dWriteFieldFloat32 (
 }

 /*!
-  \ingroup h5multiblock_read
+  \ingroup h5multiblock_data

  Allocate a buffer to hold a block from a multiblock field and place the
  pointer in \c data, then read the block into the buffer. Uses the block
@@ -125,7 +128,7 @@ H5MultiBlock3dReadFieldFloat32 (
 }

 /*!
-  \ingroup h5multiblock_write
+  \ingroup h5multiblock_data

  Write a multiblock field \c name from the buffer starting at \c data
  to the current time-step using the defined block decomposition and dimensions.
@@ -153,7 +156,7 @@ H5MultiBlock3dWriteFieldInt64 (
 }

 /*!
-  \ingroup h5multiblock_read
+  \ingroup h5multiblock_data

  Allocate a buffer to hold a block from a multiblock field and place the
  pointer in \c data, then read the block into the buffer. Uses the block
@@ -182,7 +185,7 @@ H5MultiBlock3dReadFieldInt64 (
 }

 /*!
-  \ingroup h5multiblock_write
+  \ingroup h5multiblock_data

  Write a multiblock field \c name from the buffer starting at \c data
  to the current time-step using the defined block decomposition and dimensions.
@@ -210,7 +213,7 @@ H5MultiBlock3dWriteFieldInt32 (
 }

 /*!
-  \ingroup h5multiblock_read
+  \ingroup h5multiblock_data

  Allocate a buffer to hold a block from a multiblock field and place the
  pointer in \c data, then read the block into the buffer. Uses the block
@@ -237,3 +240,5 @@ H5MultiBlock3dReadFieldInt32 (

 	return H5PART_SUCCESS;
 }
+
+#endif // PARALLEL_IO
@@ -108,17 +108,33 @@ END FUNCTION
 !> \ingroup h5partf_open
 !! Opens a parallel file for reading and specifies an HDF5 alignment.
 !! See \ref H5PartOpenFileParallelAlign
+!!
+!! Flags are specified as a comma separated string that can include:
+!!
+!! - \c fs_lustre - enable optimizations for the Lustre file system
+!! - \c vfd_mpiposix - use the HDF5 MPI-POSIX virtual file driver
+!! - \c vfd_mpio_ind - use MPI-IO in indepedent mode
+!!
+!! See \ref H5PartOpenFileParallelAlign
 !! \return 0 on success or error code
 !<
-INTEGER*8 FUNCTION h5pt_openr_par_align ( filename, mpi_communicator, align )
+INTEGER*8 FUNCTION h5pt_openr_par_align ( filename, mpi_communicator, align, flags )
    CHARACTER(LEN=*), INTENT(IN) :: filename    !< the filename to open for reading
    INTEGER, INTENT(IN) :: mpi_communicator     !< the MPI_Communicator used by the program
    INTEGER*8, INTENT(IN) :: align              !< alignment value in bytes
+    CHARACTER(LEN=*), INTENT(IN) :: flags       !< additional flags
 END FUNCTION

 !> \ingroup h5partf_open
 !! Opens a parallel file for writing in truncate mode and specifies
 !! an HDF5 alignment.
+!!
+!! Flags are specified as a comma separated string that can include:
+!!
+!! - \c fs_lustre - enable optimizations for the Lustre file system
+!! - \c vfd_mpiposix - use the HDF5 MPI-POSIX virtual file driver
+!! - \c vfd_mpio_ind - use MPI-IO in indepedent mode
+!!
 !! See \ref H5PartOpenFileParallelAlign
 !! \return 0 on success or error code
 !<
@@ -132,6 +148,13 @@ END FUNCTION
 !> \ingroup h5partf_open
 !! Opens a parallel file for writing in append mode and specifies
 !! an HDF5 alignment.
+!!
+!! Flags are specified as a comma separated string that can include:
+!!
+!! - \c fs_lustre - enable optimizations for the Lustre file system
+!! - \c vfd_mpiposix - use the HDF5 MPI-POSIX virtual file driver
+!! - \c vfd_mpio_ind - use MPI-IO in indepedent mode
+!!
 !! See \ref H5PartOpenFileParallelAlign
 !! \return 0 on success or error code
 !<
@@ -16,10 +16,10 @@ extern "C" {
 #include "H5MultiBlock.h"
 #endif

-#define H5PART_VER_STRING	"1.6.0"
+#define H5PART_VER_STRING	"1.6.6"
 #define H5PART_VER_MAJOR	1
 #define H5PART_VER_MINOR	6
-#define H5PART_VER_RELEASE	0
+#define H5PART_VER_RELEASE	6

 /* error values */
 #define H5PART_SUCCESS		0
@@ -42,6 +42,7 @@ extern "C" {
 #define H5PART_VFD_MPIPOSIX	0x08
 #define H5PART_FS_LUSTRE	0x10
 #define H5PART_VFD_MPIIO_IND	0x20
+#define H5PART_VFD_CORE		0x40

 /* verbosity level flags */
 #define H5PART_VERB_NONE	0
@@ -99,6 +100,10 @@ H5PartCloseFile (
 	H5PartFile *f
 	);

+h5part_int64_t
+H5PartFileIsValid (
+	H5PartFile *f
+	);

 /*============== File Writing Functions ==================== */
 h5part_int64_t
@@ -121,6 +126,12 @@ H5PartSetNumParticlesStrided (
 	const h5part_int64_t stride		/*!< [in] Stride (e.g. number of fields in the particle array) */
 	);

+h5part_int64_t
+H5PartSetChunkSize (
+	H5PartFile *f,
+	const h5part_int64_t size
+	);
+
 h5part_int64_t
 H5PartWriteDataFloat64 (
 	H5PartFile *f,
@@ -23,7 +23,7 @@ h5pt_writefileattrib_r8 (
 	h5part_int64_t *f,
 	const char *name,
 	const h5part_float64_t *data,
-	const h5part_float64_t *nelem,
+	const h5part_int64_t *nelem,
 	const int l_name
 	) {

@@ -39,9 +39,9 @@ h5pt_writefileattrib_r8 (
 }

 #if ! defined(F77_NO_UNDERSCORE)
-#define h5pt_writefileattrib_r8 F77NAME ( \
-	h5pt_writefileattrib_r8_, \
-	H5PT_WRITEFILEATTRIB_R8 )
+#define h5pt_readfileattrib_r8 F77NAME ( \
+	h5pt_readfileattrib_r8_, \
+	H5PT_READFILEATTRIB_R8 )
 #endif

 h5part_int64_t
@@ -74,7 +74,7 @@ h5pt_writefileattrib_r4 (
 	h5part_int64_t *f,
 	const char *name,
 	const h5part_float32_t *data,
-	const h5part_float32_t *nelem,
+	const h5part_int64_t *nelem,
 	const int l_name
 	) {

@@ -90,9 +90,9 @@ h5pt_writefileattrib_r4 (
 }

 #if ! defined(F77_NO_UNDERSCORE)
-#define h5pt_writefileattrib_r4 F77NAME ( \
-	h5pt_writefileattrib_r4_, \
-	H5PT_WRITEFILEATTRIB_R4 )
+#define h5pt_readfileattrib_r4 F77NAME ( \
+	h5pt_readfileattrib_r4_, \
+	H5PT_READFILEATTRIB_R4 )
 #endif

 h5part_int64_t
@@ -141,9 +141,9 @@ h5pt_writefileattrib_i8 (
 }

 #if ! defined(F77_NO_UNDERSCORE)
-#define h5pt_writefileattrib_i8 F77NAME ( \
-	h5pt_writefileattrib_i8_, \
-	H5PT_WRITEFILEATTRIB_I8 )
+#define h5pt_readfileattrib_i8 F77NAME ( \
+	h5pt_readfileattrib_i8_, \
+	H5PT_READFILEATTRIB_I8 )
 #endif

 h5part_int64_t
@@ -176,7 +176,7 @@ h5pt_writefileattrib_i4 (
 	h5part_int64_t *f,
 	const char *name,
 	const h5part_int32_t *data,
-	const h5part_int32_t *nelem,
+	const h5part_int64_t *nelem,
 	const int l_name
 	) {

@@ -192,9 +192,9 @@ h5pt_writefileattrib_i4 (
 }

 #if ! defined(F77_NO_UNDERSCORE)
-#define h5pt_writefileattrib_i4 F77NAME ( \
-	h5pt_writefileattrib_i4_, \
-	H5PT_WRITEFILEATTRIB_I4 )
+#define h5pt_readfileattrib_i4 F77NAME ( \
+	h5pt_readfileattrib_i4_, \
+	H5PT_READFILEATTRIB_I4 )
 #endif

 h5part_int64_t
@@ -227,7 +227,7 @@ h5pt_writestepattrib_r8 (
 	h5part_int64_t *f,
 	const char *name,
 	const h5part_float64_t *data,
-	const h5part_float64_t *nelem,
+	const h5part_int64_t *nelem,
 	const int l_name
 	) {

@@ -243,9 +243,9 @@ h5pt_writestepattrib_r8 (
 }

 #if ! defined(F77_NO_UNDERSCORE)
-#define h5pt_writestepattrib_r8 F77NAME ( \
-	h5pt_writestepattrib_r8_, \
-	H5PT_WRITESTEPATTRIB_R8 )
+#define h5pt_readstepattrib_r8 F77NAME ( \
+	h5pt_readstepattrib_r8_, \
+	H5PT_READSTEPATTRIB_R8 )
 #endif

 h5part_int64_t
@@ -278,7 +278,7 @@ h5pt_writestepattrib_r4 (
 	h5part_int64_t *f,
 	const char *name,
 	const h5part_float32_t *data,
-	const h5part_float32_t *nelem,
+	const h5part_int64_t *nelem,
 	const int l_name
 	) {

@@ -294,9 +294,9 @@ h5pt_writestepattrib_r4 (
 }

 #if ! defined(F77_NO_UNDERSCORE)
-#define h5pt_writestepattrib_r4 F77NAME ( \
-	h5pt_writestepattrib_r4_, \
-	H5PT_WRITESTEPATTRIB_R4 )
+#define h5pt_readstepattrib_r4 F77NAME ( \
+	h5pt_readstepattrib_r4_, \
+	H5PT_READSTEPATTRIB_R4 )
 #endif

 h5part_int64_t
@@ -345,9 +345,9 @@ h5pt_writestepattrib_i8 (
 }

 #if ! defined(F77_NO_UNDERSCORE)
-#define h5pt_writestepattrib_i8 F77NAME ( \
-	h5pt_writestepattrib_i8_, \
-	H5PT_WRITESTEPATTRIB_I8 )
+#define h5pt_readstepattrib_i8 F77NAME ( \
+	h5pt_readstepattrib_i8_, \
+	H5PT_READSTEPATTRIB_I8 )
 #endif

 h5part_int64_t
@@ -380,7 +380,7 @@ h5pt_writestepattrib_i4 (
 	h5part_int64_t *f,
 	const char *name,
 	const h5part_int32_t *data,
-	const h5part_int32_t *nelem,
+	const h5part_int64_t *nelem,
 	const int l_name
 	) {

@@ -396,9 +396,9 @@ h5pt_writestepattrib_i4 (
 }

 #if ! defined(F77_NO_UNDERSCORE)
-#define h5pt_writestepattrib_i4 F77NAME ( \
-	h5pt_writestepattrib_i4_, \
-	H5PT_WRITESTEPATTRIB_I4 )
+#define h5pt_readstepattrib_i4 F77NAME ( \
+	h5pt_readstepattrib_i4_, \
+	H5PT_READSTEPATTRIB_I4 )
 #endif

 h5part_int64_t
@@ -197,6 +197,10 @@ _H5Part_flagsfor2c (
 	while ( flags != NULL ) {
 		if ( strcmp ( flags, "vfd_mpiposix" ) == 0 )
 				fbits |= H5PART_VFD_MPIPOSIX;
+		else if ( strcmp ( flags, "vfd_core" ) == 0 )
+				fbits |= H5PART_VFD_CORE;
+		else if ( strcmp ( flags, "vfd_mpio_ind" ) == 0 )
+				fbits |= H5PART_VFD_MPIIO_IND;
 		else if ( strcmp ( flags, "fs_lustre" ) == 0 )
 		    		fbits |= H5PART_FS_LUSTRE;
 		flags = strtok ( NULL, "," );
@@ -351,16 +355,22 @@ h5pt_openr_par_align (
 	const char *file_name,
 	MPI_Fint *fcomm,
 	const h5part_int64_t *align,
-	const int l_file_name
+	const char *flags,
+	const int l_file_name,
+	const int l_flags
 	) {

 	MPI_Comm ccomm = MPI_Comm_f2c (*fcomm);
 	char *file_name2 = _H5Part_strdupfor2c ( file_name, l_file_name );
+	char *flags2 = _H5Part_strdupfor2c ( flags, l_flags );
+
+	char fbits = H5PART_READ | _H5Part_flagsfor2c ( flags2 );

 	H5PartFile* f = H5PartOpenFileParallelAlign (
-		file_name2, H5PART_READ, ccomm, *align );
+		file_name2, fbits, ccomm, *align );

 	free ( file_name2 );
+	free ( flags2 );
 	return (h5part_int64_t)(size_t)f; 
 }

@@ -384,6 +394,7 @@ h5pt_openw_par_align (
 		file_name2, fbits, ccomm, *align );

 	free ( file_name2 );
+	free ( flags2 );
 	return (h5part_int64_t)(size_t)f; 
 }

@@ -407,6 +418,7 @@ h5pt_opena_par_align (
 		file_name2, fbits, ccomm, *align );

 	free ( file_name2 );
+	free ( flags2 );
 	return (h5part_int64_t)(size_t)f;
 }
 #endif
@@ -611,7 +623,7 @@ h5pt_setview (

 	H5PartFile *filehandle = (H5PartFile*)(size_t)*f;

-	return H5PartSetView ( filehandle, *start, *end );
+	return H5PartSetView ( filehandle, (*start)-1, (*end)-1 );
 }

 h5part_int64_t
@@ -2,12 +2,17 @@
 #define __H5PART_PRIVATE_H

 #if H5_VERS_MAJOR == 1 && H5_VERS_MINOR == 6
+#define H5PART_USE_HDF5_16
 #define H5_USE_16_API
 #endif

+#if H5_VERS_MAJOR == 1 && H5_VERS_MINOR >= 8
+#define H5PART_HAVE_HDF5_18
+#endif
+
 #define H5PART_GROUPNAME_STEP	"Step"

-#define H5PART_BTREE_IK 10000
+#define H5PART_SET_STEP_READ_ONLY 0

 h5part_int64_t
 _H5Part_file_is_valid (
@@ -111,6 +116,24 @@ _H5Part_write_attrib (
 	const hsize_t attrib_nelem
 	);

+h5part_int64_t
+_H5Part_write_file_attrib (
+	H5PartFile *f,
+	const char *name,
+	const hid_t type,
+	const void *value,
+	const hsize_t nelem
+	);
+
+h5part_int64_t
+_H5Part_write_step_attrib (
+	H5PartFile *f,
+	const char *name,
+	const hid_t type,
+	const void *value,
+	const hsize_t nelem
+	);
+
 h5part_int64_t
 _H5Part_get_attrib_info (
 	hid_t id,
@@ -167,12 +190,6 @@ _H5Part_get_err_handle (
 	void
 	);

-void
-_H5Part_vprint_error (
-	const char *fmt,
-	va_list ap
-	);
-
 void
 _H5Part_print_error (
 	const char *fmt,
@@ -182,12 +199,6 @@ __attribute__ ((format (printf, 1, 2)))
 #endif
 ;

-void
-_H5Part_vprint_warn (
-	const char *fmt,
-	va_list ap
-	);
-
 void
 _H5Part_print_warn (
 	const char *fmt,
@@ -198,12 +209,6 @@ __attribute__ ((format (printf, 1, 2)))
 #endif
 ;

-void
-_H5Part_vprint_info (
-	const char *fmt,
-	va_list ap
-	);
-
 void
 _H5Part_print_info (
 	const char *fmt,
@@ -214,12 +219,6 @@ __attribute__ ((format (printf, 1, 2)))
 #endif
 ;

-void
-_H5Part_vprint_debug (
-	const char *fmt,
-	va_list ap
-	);
-
 void
 _H5Part_print_debug (
 	const char *fmt,
@@ -230,12 +229,6 @@ __attribute__ ((format (printf, 1, 2)))
 #endif
 ;

-void
-_H5Part_vprint_debug_detail (
-	const char *fmt,
-	va_list ap
-	);
-
 void
 _H5Part_print_debug_detail (
 	const char *fmt,
@@ -19,7 +19,7 @@ __attribute__ ((format (printf, 3, 4)))
 #endif
 ;

-#ifndef MPI_INCLUDED
+#ifndef PARALLEL_IO
 typedef unsigned long		MPI_Comm;
 #endif

@@ -50,8 +50,9 @@ struct H5PartFile {
 	hid_t timegroup;
 	hid_t shape;
 	hid_t xfer_prop;
-	hid_t create_prop;
 	hid_t access_prop;
+	hid_t dcreate_prop;
+	hid_t fcreate_prop;

 	/* the dataspace on disk for the current view */
 	hid_t diskshape;
@@ -2,8 +2,6 @@

 OBJEXT=o

-INCLUDES = -I@HDF5ROOT@/include @MPIINC@
-
 EXTRA_HEADERS = 	H5PartPrivate.h \
 			H5BlockPrivate.h \
 			H5MultiBlockPrivate.h \
@@ -25,10 +23,10 @@ EXTRA_DIST =		TestUnderscoreC.c \
 nodist_include_HEADERS = H5PartF.h @UNDERSCORE_H@

 # What to build... Will be determined by configure script.
-lib_LIBRARIES = @MTARGET@
+lib_LTLIBRARIES = libH5Part.la @LIB_FORTRAN@

 # Listing of all possible targets that I may build.
-EXTRA_LIBRARIES = libH5Part.a libH5PartF.a
+EXTRA_LTLIBRARIES = libH5PartF.la

 # Header files that I wish to install in $(prefix)/include
 include_HEADERS = 	H5Part.h \
@@ -47,27 +45,28 @@ include_HEADERS = 	H5Part.h \
 			@UNDERSCORE_H@

 # Listing of sources
-libH5Part_a_SOURCES =	H5Part.c \
+libH5Part_la_SOURCES =	H5Part.c \
 			H5PartAttrib.c \
 			H5Block.c \
 			H5BlockReadWrite.c \
 			H5MultiBlock.c \
 			H5MultiBlockReadWrite.c

-libH5PartF_a_SOURCES =	$(libH5Part_a_SOURCES) \
+libH5Part_la_LDFLAGS = -version-info 0:0:0
+
+libH5PartF_la_SOURCES =	H5Part.c \
+			H5PartAttrib.c \
+			H5Block.c \
+			H5BlockReadWrite.c \
+			H5MultiBlock.c \
+			H5MultiBlockReadWrite.c \
 			H5PartF.c \
 			H5PartAttribF.c \
 			H5BlockF.c \
 			H5BlockReadWriteF.c

+libH5PartF_la_LDFLAGS = -version-info 0:0:0 -rpath '$(libdir)'
+
 H5PartF.h: H5Part.f90 H5PartAttrib.f90 H5Block.f90 H5BlockReadWrite.f90
 	awk '/INTEGER\*8 FUNCTION/{print "\t" $$1 " " $$3}' $^ >$@

-libpH5Part.a: libH5Part.a
-	$(RM) $@
-	ln -s $^ $@
-
-libpH5PartF.a: libH5PartF.a
-	$(RM) $@
-	ln -s $^ $@
-
@@ -113,7 +113,7 @@ h5pt_write#LEVELLC#attrib_#TYPE_F90_ABV# (
 	h5part_int64_t *f,
 	const char *name,
 	const h5part_#TYPE_H5P#_t *data,
-	const h5part_#TYPE_H5P#_t *nelem,
+	const h5part_int64_t *nelem,
 	const int l_name
 	) {

@@ -143,9 +143,9 @@ END FUNCTION

 read_attr_fc = """
 #if ! defined(F77_NO_UNDERSCORE)
-#define h5pt_write#LEVELLC#attrib_#TYPE_F90_ABV# F77NAME ( \\
-	h5pt_write#LEVELLC#attrib_#TYPE_F90_ABV#_, \\
-	H5PT_WRITE#LEVELUC#ATTRIB_#TYPE_F90_ABVC# )
+#define h5pt_read#LEVELLC#attrib_#TYPE_F90_ABV# F77NAME ( \\
+	h5pt_read#LEVELLC#attrib_#TYPE_F90_ABV#_, \\
+	H5PT_READ#LEVELUC#ATTRIB_#TYPE_F90_ABVC# )
 #endif

 h5part_int64_t
@@ -214,7 +214,7 @@ h5bl_#DIM#d_read_scalar_field_#TYPE_F90_ABV# (

 	char *field_name2 =  _H5Part_strdupfor2c ( field_name,  l_field_name );

-	h5part_int64_t herr = H5Block#DIM#dWriteScalarField#TYPE_ABV# (
+	h5part_int64_t herr = H5Block#DIM#dReadScalarField#TYPE_ABV# (
 		filehandle, field_name2, data );

 	free ( field_name2 );
@@ -11,6 +11,13 @@ c_head = """

 #include "H5MultiBlockErrors.h"
 #include "H5MultiBlockPrivate.h"
+
+#ifdef PARALLEL_IO
+
+"""
+
+c_tail = """
+#endif // PARALLEL_IO
 """

 h_head = """
@@ -237,6 +244,7 @@ def write_calls():
 #	fcfile.write(create_call(read_fc,type,dim));
 #	fifile.write(create_call(write_fi,type,dim));
 #	fifile.write(create_call(read_fi,type,dim));
+  cfile.write(c_tail)
  cfile.close()
  hfile.write(h_tail)
  hfile.close()
@@ -2,15 +2,12 @@

 OBJEXT=o

-HDFLIB = -L@HDF5ROOT@/lib -lhdf5 -lz @SZLIB@
-LIBS = -L@H5P_LIB_LOC@ @H5P_LIB_NAME@ $(HDFLIB) -lm
+INCLUDES = -I../src @INCLUDES@

-INCLUDES = -I@H5P_LIB_LOC@ -I@HDF5ROOT@/include @MPIINC@
-
-noinst_PROGRAMS = @TTARGET@
+noinst_PROGRAMS = @BUILD_TESTS@

 TESTS_ENVIRONMENT = env LD_LIBRARY_PATH=@HDF5ROOT@/lib:$(LD_LIBRARY_PATH)
-TESTS = @TTARGET@
+TESTS = @BUILD_TESTS@

 EXTRA_PROGRAMS = test testf

@@ -20,9 +17,11 @@ test_SOURCES =	test.c \
 		read.c \
 		testframe.h \
 		params.h
+test_LDADD   =  ../src/libH5Part.la

 testf_SOURCES = testf.F90
+testf_LDADD   =  ../src/libH5PartF.la

-clean: clean-am
-	rm -f *.h5
+clean-local:
+	$(RM) -f *.h5

@@ -0,0 +1,97 @@
+program H5BlockCoordsTest
+  implicit none
+
+#ifdef PARALLEL_IO
+  include 'mpif.h'
+#endif
+  include 'H5PartF.h'
+
+#ifdef PARALLEL_IO
+  integer :: ierr, comm
+#endif
+  integer*8 :: file_id, status, i
+  real*8, allocatable :: r8buf(:,:,:), r8buf3(:,:,:,:), coords(:)
+  real*8 :: x, y, z
+
+#ifdef PARALLEL_IO
+  call MPI_INIT(ierr)
+  comm = MPI_COMM_WORLD
+#endif
+
+  ! this enables level 4 ("debug") messages to be
+  ! printed by the H5Part library
+  ! (4_8 is the literal for an integer*8 with value 4)
+  status = h5pt_set_verbosity_level (4_8)
+
+  ! open the a file called 'test.h5' in parallel for writing
+#ifdef PARALLEL_IO
+  file_id = h5pt_openw_par_align ('test.h5', comm, 1048576_8, "vfd_mpiposix")
+#else
+  file_id = h5pt_openw_align ('test.h5', 1048576_8, "vfd_mpiposix")
+#endif
+
+  status = h5bl_define3dlayout(file_id, 1_8, 30_8, 1_8, 30_8, 1_8, 30_8)
+
+  ! in the Fortran API, steps start at 1
+  status = h5pt_setstep (file_id, 1_8)
+
+  ! create fake data
+  allocate(r8buf(30,30,30))
+  allocate(r8buf3(30,30,30,3))
+  allocate(coords(30))
+  x = 1.0
+  y = 2.0
+  z = 3.0
+
+  ! write the data
+  status = h5bl_3d_write_scalar_field_r8(file_id, "x", r8buf(1,1,1))
+  status = h5bl_3d_set_field_origin(file_id, "x", x, y, z)
+  status = h5bl_3d_set_field_spacing(file_id, "x", x, y, z)
+
+  status = h5bl_3d_write_3dvector_field_r8(file_id, "v", r8buf3(1,1,1,1), r8buf3(1,1,1,2), r8buf3(1,1,1,3))
+  status = h5bl_3d_set_field_origin(file_id, "v", x, y, z)
+  status = h5bl_3d_set_field_spacing(file_id, "v", x, y, z)
+
+  ! create fake coordinates
+  do i = 1, 30
+    coords(i) = 3*i
+  enddo
+  status = h5bl_3d_set_field_xcoords(file_id, "v", coords, 30_8)
+  do i = 1, 30
+    coords(i) = 3*i + 1
+  enddo
+  status = h5bl_3d_set_field_ycoords(file_id, "v", coords, 30_8)
+  do i = 1, 30
+    coords(i) = 3*i + 2
+  enddo
+  status = h5bl_3d_set_field_zcoords(file_id, "v", coords, 30_8)
+
+  ! read fake coordinates
+  do i = 1, 30
+    coords(i) = -1
+  enddo
+  status = h5bl_3d_get_field_xcoords(file_id, "v", coords, 30_8)
+  write(*, *) coords
+  !write(*, "I3") ( coords(i), i=1, 30 )
+  do i = 1, 30
+    coords(i) = -1
+  enddo
+  status = h5bl_3d_get_field_ycoords(file_id, "v", coords, 30_8)
+  write(*, *) coords
+  !write(*, "I3") ( coords(i), i=1, 30 )
+  do i = 1, 30
+    coords(i) = -1
+  enddo
+  status = h5bl_3d_get_field_zcoords(file_id, "v", coords, 30_8)
+  write(*, *) coords
+  !write(*, "I3") ( coords(i), i=1, 30 )
+
+  ! close the file
+  status = h5pt_close (file_id)
+
+#ifdef PARALLEL_IO
+  call MPI_FINALIZE(ierr)
+#endif
+
+end program H5BlockCoordsTest
+
@@ -1,3 +1,4 @@
+#include <string.h>
 #include <H5Part.h>

 #include "testframe.h"
@@ -175,10 +176,6 @@ test_read_data64(H5PartFile *file, int nparticles, int step)
 		status = H5PartSetView(file, start, end);
 		RETURN(status, H5PART_SUCCESS, "H5PartSetView");

-		status = H5PartReadDataFloat64(file, "x", x);
-		RETURN(status, H5PART_SUCCESS, "H5PartReadDataFloat64");
-		FVALUE(x[rank], (double)(start+rank+nparticles*t), "x data");
-
 		val = H5PartGetView(file, &start, &end);
 		IVALUE(val, nprocs*nparticles-start, "particle count");
 		IVALUE(start, rank, "view start");
@@ -187,51 +184,60 @@ test_read_data64(H5PartFile *file, int nparticles, int step)
 		status = H5PartSetView(file, -1, -1);
 		RETURN(status, H5PART_SUCCESS, "H5PartSetView");

+		status = H5PartSetView(file, 0, nparticles-1);
+		RETURN(status, H5PART_SUCCESS, "H5PartSetView");
+
+		val = H5PartGetNumParticles(file);
+		IVALUE(val, nparticles, "particle count");
+
 		status = H5PartReadDataFloat64(file, "x", x);
 		RETURN(status, H5PART_SUCCESS, "H5PartReadDataFloat64");
 		IVALUE(x[rank], (double)(rank+nparticles*t), "x data");

+		status = H5PartResetView(file);
+		RETURN(status, H5PART_SUCCESS, "H5PartResetView");
+
+		val = H5PartGetNumParticles(file);
+		IVALUE(val, nprocs*nparticles, "particle count");
+
 		indices[0] = rank*2 + 0;
 		indices[1] = rank*2 + 3;
 		indices[2] = rank*2 + 9;
 		indices[3] = rank*2 + 7;

-		status = H5PartSetViewIndices(file, indices, -1);
-		RETURN(status, H5PART_SUCCESS, "H5PartSetViewIndices");
-
-		status = H5PartReadDataFloat64(file, "x", x);
-		RETURN(status, H5PART_SUCCESS, "H5PartReadDataFloat64");
-		FVALUE(x[2*rank], (double)(2*rank+nparticles*t), "x data");
-
-		status = H5PartResetView(file);
-		RETURN(status, H5PART_SUCCESS, "H5PartResetView");
-
 		status = H5PartSetViewIndices(file, indices, 4);
 		RETURN(status, H5PART_SUCCESS, "H5PartSetViewIndices");

 		val = H5PartGetNumParticles(file);
 		IVALUE(val, 4, "particle count");

-		status = H5PartReadDataFloat64(file, "x", x);
+		double x2[4];
+		status = H5PartReadDataFloat64(file, "x", x2);
 		RETURN(status, H5PART_SUCCESS, "H5PartReadDataFloat64");
-		FVALUE(x[2], (double)(rank*2+9+nparticles*t), "x data");
+		FVALUE(x2[0], (double)(2*rank+0+nparticles*t), "x data");
+		FVALUE(x2[1], (double)(2*rank+3+nparticles*t), "x data");
+		FVALUE(x2[2], (double)(2*rank+9+nparticles*t), "x data");
+		FVALUE(x2[3], (double)(2*rank+7+nparticles*t), "x data");

-		val = H5PartGetNumParticles(file);
-		IVALUE(val, 4, "particle count");
-
-		status = H5PartSetViewIndices(file, NULL, 4);
+		status = H5PartSetViewIndices(file, indices, -1);
 		RETURN(status, H5PART_SUCCESS, "H5PartSetViewIndices");

-		status = H5PartReadDataFloat64(file, "x", x);
-		RETURN(status, H5PART_SUCCESS, "H5PartReadDataFloat64");
+		val = H5PartGetNumParticles(file);
+		IVALUE(val, nprocs*nparticles, "particle count");

 		status = H5PartSetCanonicalView(file);
 		RETURN(status, H5PART_SUCCESS, "H5PartSetCanonicalView");

+		val = H5PartGetNumParticles(file);
+		IVALUE(val, nparticles, "particle count");
+
                status = H5PartReadParticleStep (
                        file, t, x, y, z, px, py, pz, id);
 		RETURN(status, H5PART_SUCCESS, "H5PartReadParticleStep");

+		status = H5PartSetViewIndices(file, NULL, 4);
+		RETURN(status, H5PART_SUCCESS, "H5PartSetViewIndices");
+
 		for (i=0; i<nparticles; i++)
 		{
 			FVALUE(x[i] , 0.0 + (double)(i+nparticles*t), " x data");
@@ -509,7 +515,7 @@ void test_read4(void)
 	status = H5PartSetStep(file2, NTIMESTEPS);
 	RETURN(status, H5PART_SUCCESS, "H5PartSetStep");

-	test_read_data64(file2, NPARTICLES, NTIMESTEPS);
+	test_read_data64(file2, NPARTICLES, NTIMESTEPS-2);

 	status = H5PartCloseFile(file1);
 	RETURN(status, H5PART_SUCCESS, "H5PartCloseFile");
@@ -23,9 +23,10 @@ int main(int argc, char **argv)
 	int procs;
 	MPI_Comm_size(MPI_COMM_WORLD, &procs);
 	if (procs > MAX_MPI_TASKS) {
-		fprintf(stderr, "ERROR: please use <= %d MPI tasks for the test.",
+		fprintf(stderr,
+			"ERROR: please use <= %d MPI tasks for the test.\n",
 			MAX_MPI_TASKS);
-		MPI_Abort(MPI_COMM_WORLD, -1);
+                exit(EXIT_FAILURE);
 	}
 #endif

@@ -62,9 +63,10 @@ int main(int argc, char **argv)
        //    TestCleanup();

 #ifdef PARALLEL_IO
-	return MPI_Finalize();
-#else
-	return GetTestNumErrs();
+	TestPrintf ("reached end\n");
+        fflush(stdout);
+        MPI_Finalize();
 #endif
+	return GetTestNumErrs();
 }

@@ -7,9 +7,9 @@ program H5PartTest
  include 'H5PartF.h'

 #ifdef PARALLEL_IO
-  integer :: comm, ierr, i
-  integer*8 :: file_id, status, npoints
+  integer :: comm, ierr
 #endif
+  integer*8 :: file_id, status, npoints, i
  real*8, allocatable :: x(:),y(:),z(:),px(:),py(:),pz(:)
  integer*8, allocatable :: id(:)

@@ -18,10 +18,10 @@ program H5PartTest
  comm = MPI_COMM_WORLD
 #endif

-  ! this enables level 3 ("info") messages to be
+  ! this enables level 4 ("debug") messages to be
  ! printed by the H5Part library
-  ! (3_8 is the literal for an integer*8 with value 3)
-  status = h5pt_set_verbosity_level (3_8)
+  ! (4_8 is the literal for an integer*8 with value 4)
+  status = h5pt_set_verbosity_level (4_8)

  ! open the a file called 'test.h5' in parallel for writing
 #ifdef PARALLEL_IO
@@ -31,6 +31,7 @@
 #include <string.h>
 #include <H5Part.h>
 #include "testframe.h"
+#include "../src/H5PartPrivate.h"

 /*
 * Definitions for the testing structure.
@@ -535,7 +536,7 @@ TestPrintf(const char *format, ...)
    int nproc;
    MPI_Comm_rank(MPI_COMM_WORLD, &nproc);
    if ( nproc == 0 || VERBOSE_HI ) {
-	char *format2 = malloc(strlen(format)+8);
+	char *format2 = (char*)malloc(strlen(format)+8);
 	sprintf(format2, "[%d] %s", nproc, format);
 	va_start(arglist, format);
 	ret_value = vprintf(format2, arglist);
@@ -569,7 +570,7 @@ TestErrPrintf(const char *format, ...)
    int nproc;
    MPI_Comm_rank(MPI_COMM_WORLD, &nproc);
    if ( nproc == 0 || VERBOSE_HI ) {
-	char *format2 = malloc(strlen(format)+8);
+	char *format2 = (char*)malloc(strlen(format)+8);
 	sprintf(format2, "[%d] %s", nproc, format);
 	va_start(arglist, format);
 	ret_value = vfprintf(stderr, format2, arglist);
@@ -652,6 +653,7 @@ test_is_valid(H5PartFile *file)
 void
 test_open_objects(H5PartFile *file, int max_objects)
 {
+#ifndef H5_USE_16_API
 	ssize_t nopen = H5Fget_obj_count(file->file, H5F_OBJ_ALL);
 	if (nopen > max_objects)
 	{
@@ -659,7 +661,7 @@ test_open_objects(H5PartFile *file, int max_objects)
 				"at line %4d in %s\n", nopen, max_objects,
 				(int)__LINE__, __FILE__ );

-		hid_t *list = malloc(sizeof(hid_t)*nopen);
+		hid_t *list = (hid_t)malloc(sizeof(hid_t)*nopen);
 		H5Fget_obj_ids(file->file, H5F_OBJ_ALL, nopen, list);

                H5O_info_t info;
@@ -682,5 +684,6 @@ test_open_objects(H5PartFile *file, int max_objects)
 		}
 		free(list);
 	}
+#endif
 }

@@ -6,6 +6,8 @@
 #ifndef _H5PART_TESTFRAME_H_
 #define _H5PART_TESTFRAME_H_

+#include <string.h>
+
 #ifdef PARALLEL_IO
 #define OPEN(file,mode) \
    H5PartOpenFileParallel(file,mode,MPI_COMM_WORLD)
@@ -65,7 +65,7 @@ static void
 test_write_data64(H5PartFile *file, int nparticles, int step)
 {
 	int i,t;
-	h5part_int64_t status;
+	h5part_int64_t status, val;

 	double *x,*y,*z;
 	double *px,*py,*pz;
@@ -108,10 +108,12 @@ test_write_data64(H5PartFile *file, int nparticles, int step)
 			id[i] = i + nparticles*t;
 		}

+		val = H5PartHasStep(file, t);
+
 		status = H5PartSetStep(file, t);
 		RETURN(status, H5PART_SUCCESS, "H5PartSetStep");

-		test_write_step_attribs(file, t);
+		if (val == 0) test_write_step_attribs(file, t);

 		status = H5PartSetNumParticles(file, nparticles);
 		RETURN(status, H5PART_SUCCESS, "H5PartSetNumParticles");
@@ -198,7 +200,7 @@ static void
 test_write_data32(H5PartFile *file, int nparticles, int step)
 {
 	int i,t;
-	h5part_int32_t status;
+	h5part_int32_t status, val;
 	int rank, nprocs;

 	float *x,*y,*z;
@@ -244,8 +246,11 @@ test_write_data32(H5PartFile *file, int nparticles, int step)
 			id[i] = i + nparticles*t;
 		}

-		status = H5PartSetStep(file, t);
-		RETURN(status, H5PART_SUCCESS, "H5PartSetStep");
+		val = H5PartHasStep(file, t);
+		if (val == 0) {
+			status = H5PartSetStep(file, t);
+			RETURN(status, H5PART_SUCCESS, "H5PartSetStep");
+		}

 		/* test a two-part write using views */
 		status = H5PartSetView(file,
@@ -370,8 +375,6 @@ void test_write1(void)
 	test_write_data32(file1, NPARTICLES, 1);
 	test_write_file_attribs(file1, 0);

-	_H5Part_close_hdf_ids(file1);
-	test_open_objects(file1, 1);
 	status = H5PartCloseFile(file1);
 	RETURN(status, H5PART_SUCCESS, "H5PartCloseFile");
 }
@@ -405,10 +408,10 @@ void test_write3(void)
 	h5part_int64_t status;

 	TEST(	"Opening file once, write-truncate, lustre filesyste, "
-		"MPI-POSIX VFD, 64KB alignment");
+		"MPI-POSIX VFD, 1KB alignment");
 	file1 = OPENALIGN(FILENAME,
 		H5PART_WRITE | H5PART_VFD_MPIPOSIX | H5PART_FS_LUSTRE,
-		65536);
+		1024);
 	test_is_valid(file1);

 	TEST("Redefining step name");
@@ -430,14 +433,14 @@ void test_write4(void)
 	h5part_int64_t status;

 	TEST(	"Opening file twice, write-append + read-only, "
-		"lustre filesystem, MPI-IO Independent VFD, 64K alignment");
+		"lustre filesystem, MPI-IO Independent VFD, 1K alignment");
 	file1 = OPENALIGN(FILENAME,
 		H5PART_APPEND | H5PART_VFD_MPIIO_IND | H5PART_FS_LUSTRE,
-		65536);
+		1024);
 	test_is_valid(file1);
 	file2 = OPENALIGN(FILENAME,
 		H5PART_READ | H5PART_VFD_MPIIO_IND | H5PART_FS_LUSTRE,
-		65536);
+		1024);
 	test_is_valid(file2);

 	TEST("Redefining step name");
@@ -447,7 +450,10 @@ void test_write4(void)
 	status = H5PartDefineStepName(file2, LONGNAME, 16);
 	RETURN(status, H5PART_SUCCESS, "H5PartDefineStepName");

-	test_write_data64(file1, NPARTICLES, NTIMESTEPS);
+	status = H5PartSetChunkSize(file1, NPARTICLES);
+	RETURN(status, H5PART_SUCCESS, "H5PartSetChunkSize");
+
+	test_write_data64(file1, NPARTICLES, NTIMESTEPS-2);
 	test_write_file_attribs(file1, 1);

 	status = H5PartCloseFile(file1);
@@ -2,10 +2,7 @@

 OBJEXT=o

-HDFLIB = -L@HDF5ROOT@/lib -lhdf5 -lz @SZLIB@
-LIBS = -L@H5P_LIB_LOC@ @H5P_LIB_NAME@ $(HDFLIB) -lm @STDCXX@
-
-INCLUDES = -I@H5P_LIB_LOC@ -I@HDF5ROOT@/include @MPIINC@
+INCLUDES = -I../src @INCLUDES@

 # What to build... make install will place these files in the $(prefix)/bin directory.
 bin_PROGRAMS = @BUILD_TOOLS@
@@ -19,8 +16,17 @@ EXTRA_PROGRAMS =	h5pAttrib \

 # Listing of sources
 h5pAttrib_SOURCES =	h5pAttrib.cc
-h5pToGNUplot_SOURCES =	h5pToGNUplot.cc
-homdynToH5p_SOURCES =	homdynToH5p.cc
-H5PartBench_SOURCES =	H5PartBench.c
-H5BlockBench_SOURCES =	H5BlockBench.c
+h5pAttrib_LDADD   =  ../src/libH5Part.la
+
+h5pToGNUplot_SOURCES =	h5pToGNUplot.cc
+h5pToGNUplot_LDADD   =  ../src/libH5Part.la
+
+homdynToH5p_SOURCES =	homdynToH5p.cc
+homdynToH5p_LDADD   =  ../src/libH5Part.la
+
+H5PartBench_SOURCES =	H5PartBench.c
+H5PartBench_LDADD   =  ../src/libH5Part.la
+
+H5BlockBench_SOURCES =	H5BlockBench.c
+H5BlockBench_LDADD   =  ../src/libH5Part.la
Author	SHA1	Message	Date
Marc Howison	e8e2f62f37	added coordinate attribute to H5Block	2012-08-24 18:20:14 +00:00
Marc Howison	23045a3fb3	missing cast on malloc reported by Oliver	2012-04-04 13:56:00 +00:00
Marc Howison	9490449189	1.6.6 release	2012-02-06 01:24:48 +00:00
gsell	258200afe6	normalization of INT32 data added; format warnings fixed; unused var's removed	2012-02-01 15:56:08 +00:00
gsell	d7406a63bd	rewrite of most parts; handling of INT32 data added	2012-02-01 15:54:52 +00:00
Marc Howison	d2f0eb194a	had Write instead of Read functions in the implementation of h5bl_3d_read_scalar_field_*	2012-01-13 01:01:34 +00:00
Marc Howison	f58f435a65	fixed missing flags parameter in h5pt_openr_par_align; updated version for 1.6.6 release	2011-11-06 13:07:49 +00:00
Marc Howison	8c6d7f7f54	added MPI_IN_PLACE for Allgather in H5Block with aliased buffers (generated an error in Cray MPT 5.2)	2011-10-30 17:42:32 +00:00
Marc Howison	1f647fc513	1.6.5 release: Fixed several build errors reported by Iuri Prilepov on Ubuntu 11.04.	2011-09-23 14:47:11 +00:00
Marc Howison	1bda4e3c70	H5Part 1.6.4 release	2011-09-03 16:42:21 +00:00
gsell	819ddc4704	work around to use env.vars removed	2011-08-15 14:08:08 +00:00
gsell	3894452bc9	target 'clean' replaced with 'clean-local'	2011-08-15 13:27:48 +00:00
gsell	58be7a8318	ignore property edited	2011-08-15 10:15:29 +00:00
gsell	9a06157427	config.{guess,sub} removed from repo	2011-08-15 10:11:37 +00:00
gsell	a44e2b6a05	missing H5P_DEFAULT added to H5Gopen() if 1.8 API is used	2011-08-15 10:08:58 +00:00
gsell	ac8d16c0b6	libtoolize must be called first, use try 'glibtoolize' if 'libtoolize dosn't exists	2011-08-15 09:36:43 +00:00
gsell	6c944f2b16	meaningless comment removed	2011-08-15 09:34:15 +00:00
Marc Howison	b1aa655b22	1.6.3 release	2011-07-25 14:09:43 +00:00
Marc Howison	efb1e39233	more fixes to the new libtool build system	2011-07-19 01:31:21 +00:00
Marc Howison	5b611ab155	new build system for both H5hut and H5Part; preparing 1.6.3 release of H5Part	2011-07-16 18:30:25 +00:00
Marc Howison	66449ee44d	fixed mismatched function names and uncorrected indices in Fortran API; incorporated bug report for Fortran test	2011-02-01 16:36:00 +00:00
Marc Howison	d368a60202	bug fixes in Fortran API for 1.6.2	2010-07-28 21:44:48 +00:00
Marc Howison	6b4b556ff1	removed H5PartSetViewEmpty and enabled 0 as input to H5PartSetNumParticles	2010-06-29 16:39:29 +00:00
Marc Howison	0857443617	fixed spelling errors in NEWS	2010-06-11 17:48:42 +00:00
Marc Howison	e3b93e4383	removed redundant VFD code in _H5Part_open and added an option for CORE VFD	2010-05-13 17:54:38 +00:00
Marc Howison	3e99a8ccfa	fixed autoconf issue with PGI compilers and #define issue with OpenMPI	2010-05-03 20:04:34 +00:00
Marc Howison	bb41cc3288	added documentation for file open flags; added flags to h5pt_openr_par_align(); added H5PartSetViewEmpty() and h5pt_setview_empty() calls for creating empty hyperslab selections (previously kludge was to use H5PartSetViewIndices with a null list); fixed memory leak with file open flags in the Fortran interface; fixed missing statement in 1.6.x logic for _H5Part_have_group()	2010-04-29 16:17:51 +00:00
Marc Howison	cf1368291d	fixed the H5PART_HAVE_HDF5_18 logic to work with the 1.9 snapshot; fixed broken test in _H5Part_have_group in the codepath for HDF5 1.6	2010-03-23 22:18:40 +00:00
Marc Howison	698b5e0c76	removed config.h.in	2010-03-11 23:04:27 +00:00
Marc Howison	ea40b3272e	fixes to lustre optimizations	2010-03-11 23:00:43 +00:00
Marc Howison	90f8506628	changed print functions to only print from proc 0 in parallel mode, except for 'debug detail' level which prints from all procs	2010-02-23 19:45:43 +00:00
Marc Howison	a7727635a7	reverted the rename of xfer_prop because it is used in OPAL	2010-02-22 21:18:37 +00:00
Marc Howison	66476adf6a	removed overloaded use of H5_USE_16_API so that it can be used with HDF 1.85 without invoking the HDF5 1.6 codepath in places	2010-02-22 18:35:37 +00:00
Marc Howison	1c4c62192d	added chunking for H5Part; had to remove open object test because out-of-order file handle / property list closes were causing errors	2010-02-18 21:08:03 +00:00
Marc Howison	fb660f8459	changed throttling routine; removed read-only restriction for setting step to existing steps; revised NEWS	2010-02-18 18:56:39 +00:00
Marc Howison	20bff7f87c	fixes for HDF5 1.6.x	2010-02-17 03:19:20 +00:00
Marc Howison	64c2b96f27	incorporated fixes from Gunther for 1.6.0 release	2010-02-16 18:46:57 +00:00