Merge libfdf:ag into libfdf:master

[Alberto Garcia]

Decouple MPI from fdf.
For an example of usage in Siesta, see the psml-fdf branch.

I did not merge Nick's fix-filedebug branch yet, but most of the changes are no longer
needed as multi-node logging is now done by client programs (we can still advise users
on this).

Note also that I have not yet included the 'broadcast_fdf_struct' routine template anywhere
in the library (it is in the Siesta branch referenced above). What is the best place to put it?

This merge request is thus work-in-progress, to clean the building system of MPI issues, etc, and
to streamline things. I bumped the version to 0.2.0.

[Yann Pouillon (pouillon)]

This is a welcome change, since it will make the use of LibFDF easier and simplify its maintenance.

If I understand well, I should remove MPI support from the build system once you're done with the merge, right?

review: Approve

[Nick Papior (nickpapior)]

Looks great! I have some minor things, mainly naming convention fdf_* rather than *_fdf_*.

Also some very minor things for consistency, character(len=1) rather than character? (completely optional)

Otherwise approved!

review: Needs Fixing

diff --git a/README.md b/README.md
index a350e4b..9d49622 100644
--- a/README.md
+++ b/README.md
@@ -6,14 +6,15 @@ for Electronic Structure Calculations.
 
 LibFDF is the official implementation of the FDF Specifications.
 
-The LibFDF package, designed by Alberto Garcia and Jose Soler, has been
-reimplemented by Raul de la Cruz (Barcelona Supercomputer Center) in 2007.
+The LibFDF package, designed by Alberto Garcia and Jose Soler, was
+reimplemented by Raul de la Cruz (Barcelona Supercomputer Center) in 2007
+to make it memory-side instead of file-oriented.
+
+The MPI-enabled library is now being turned into a single-node smaller
+library with the basic functionality. MPI operation will be delegated
+to the client code, which will just have to coordinate the broadcast
+of the internal data structure containing the fdf data.
 
-The library is memory-side instead of file-oriented, and works better
-and faster than before. Supports MPI executions (outputs have
-different names for each node), Cluster mode (at least one node only
-has access to the input file) and Blocking mode (reading phase is
-split in several steps for huge execution in shared-filesystems).
 
 We request that the copyright notices in the code be kept if the package
 is eventually used as part of another program.
diff --git a/configure.ac b/configure.ac
index 23307c5..a45483c 100644
--- a/configure.ac
+++ b/configure.ac
@@ -12,7 +12,7 @@ configuring-libfdf.md file.])
 
 # Init Autoconf
 AC_PREREQ([2.69])
-AC_INIT([LibFDF], [0.1.1],
+AC_INIT([LibFDF], [0.2.1],
   [https://bugs.launchpad.net/libfdf],
   [libfdf],
   [https://launchpad.net/libfdf])
diff --git a/doc/fdf.Standard b/doc/fdf.Standard
index f0cbc72..98703fd 100644
--- a/doc/fdf.Standard
+++ b/doc/fdf.Standard
@@ -68,12 +68,6 @@ Label   < Filename   # Comments
 
 By default, all the fdf requests are logged, printing the final value
 extracted (if it is the default value, it is identified as such).
-In MPI operation, only the master node does the logging, unless the
-"output-level" is set to a value >= 2. This can be done directly in
-the fdf file:
-
-fdf-output 2  # Turn on logging for all nodes
-fdf-output 0  # Turn off logging completely
 
 No debugging is done, unless the "debug-level" is set to a value greater
 than zero. The most meaningful way to use this feature is to set the
@@ -82,14 +76,3 @@ achieved by calling the routine fdf_setdebug with the appropriate level
 and file name *before* the call to fdf_init.  This gives full control
 over the behavior.  
 
-Alternatively, if the library is compiled with the pre-processor symbol
-FDF_DEBUG defined, it will set the debug level to 2 (exhaustive) for all
-nodes in the system. (It will also set the output level to 2 (all nodes)).
-
-If the debugging level (>=2) is only specified in the fdf file itself,
-the library will provide a print-out of the final data structure generated
-(in all nodes).
-
-fdf-debug 2
-
-
diff --git a/src/fdf.F90 b/src/fdf.F90
index 475ec12..eef0cd7 100644
--- a/src/fdf.F90
+++ b/src/fdf.F90
@@ -26,6 +26,7 @@
 !       do while(fdf_bline(bfdf, pline))
 !         (process line 'integers|reals|values|names ...')
 !       enddo
+!       call fdf_bclose(bfdf)
 !     endif
 !
 ! The subroutine 'fdf_block' returns in 'bfdf' a structure used
@@ -35,6 +36,9 @@
 ! line, non-comment line from the block, unless there are no more
 ! lines, in which case it returns .FALSE. and 'pline' is undefined.
 !
+! Routine fdf_bclose runs the remaining lines in the block and ensures
+! the log may be used as input in subsequent entries.
+!
 ! Routine 'backspace' moves the internal pointer of 'block_fdf'
 ! structure to the previous line returned.
 !
@@ -58,37 +62,6 @@
 !       thread-safe because each thread keeps its relative information
 !       about the search/query that the caller program requests.
 !
-!    2) MPI-aware: For MPI executions, FDF library renames output/debugging
-!       or log files to prevent overlaps of these files in a
-!       shared/parallel filesystem.
-!
-!       This option is enabled with the HAVE_MPI macro, and superseded by
-!       the HAVE_CLUSTER_IO and HAVE_BLOCKING_IO macros.
-!
-!    3) Cluster filesystem: It is able to read the input FDF file from a
-!       non-shared filesystem and broadcast the information to the rest
-!       of the nodes in the execution.
-!
-!       The implementation is as follows: the first node in the MPI rank
-!       that is the owner of the input FDF file, process the file and
-!       send it to the rest of the nodes in the MPI communicator.
-!
-!       This option is enabled with HAVE_CLUSTER_IO macro. This option cannot be
-!       used if HAVE_BLOCKING_IO macro is enabled.
-!
-!    4) Blocking reading: For huge executions (> 1.000 nodes) this option
-!       is useful for shared/parallel filesystems where reading the same
-!       file by several nodes could be a problem (collapsing system).
-!
-!       The implementation is as follows: reading phase is done in blocking
-!       pattern of size FDF_BLOCKSIZE nodes (configurable through the
-!       FDF_BLOCKSIZE environment variable).
-!       This means that the number of steps needed is STEPS =
-!          #NODES / FDF_BLOCKSIZE.
-!
-!       This option is enabled with HAVE_BLOCKING_IO macro. This option
-!       cannot be used if HAVE_CLUSTER_IO macro is enabled.
-!
 ! Alberto Garcia, 1996-2007
 ! Raul de la Cruz (BSC), September 2007
 !
@@ -122,14 +95,14 @@ MODULE fdf
 
 ! User callable routines in FDF library
 
-! Start, stop and check parallelism in FDF system
-  public :: fdf_init, fdf_shutdown, fdf_parallel
+! Start, stop FDF system
+  public :: fdf_init, fdf_shutdown
 
 ! Reading label functions
   public :: fdf_get
   public :: fdf_integer, fdf_single, fdf_double
   public :: fdf_string, fdf_boolean
-  public :: fdf_physical, fdf_isphysical, fdf_convfac
+  public :: fdf_physical, fdf_convfac
 
   ! Lists
   public :: fdf_islist, fdf_islinteger, fdf_islreal
@@ -139,7 +112,7 @@ MODULE fdf
   public :: fdf_getline
 
 ! Test if label is defined
-  public :: fdf_defined
+  public :: fdf_defined, fdf_isphysical, fdf_isblock
 
 ! Allow to overwrite things in the FDF
   public :: fdf_overwrite, fdf_removelabel, fdf_addline
@@ -148,13 +121,14 @@ MODULE fdf
   public :: fdf_deprecated, fdf_obsolete
 
 ! %block reading (processing each line)
-  public :: fdf_block, fdf_bline, fdf_bbackspace, fdf_brewind
+  public :: fdf_block, fdf_block_linecount
+  public :: fdf_bline, fdf_bbackspace, fdf_brewind, fdf_bclose
   public :: fdf_bnintegers, fdf_bnreals, fdf_bnvalues, fdf_bnnames, fdf_bntokens
   public :: fdf_bintegers, fdf_breals, fdf_bvalues, fdf_bnames, fdf_btokens
   public :: fdf_bboolean, fdf_bphysical
   public :: fdf_bnlists, fdf_bnilists, fdf_bnrlists, fdf_bnvlists
   public :: fdf_bilists, fdf_brlists, fdf_bvlists
-
+  
 ! Match, search over blocks, and destroy block structure
   public :: fdf_bmatch, fdf_bsearch, fdf_substring_search
 
@@ -174,21 +148,8 @@ MODULE fdf
 ! Destroy dynamic list of FDF structure (called in fdf_shutdown)
   private :: fdf_destroy, fdf_destroy_dl
 
-! MPI init/finalize functions
-#ifdef HAVE_MPI
-  private :: fdf_mpi_init, fdf_mpi_finalize
-#endif
-
-! Reading functions for HAVE_CLUSTER_IO and HAVE_BLOCKING_IO configuration
-#ifdef HAVE_CLUSTER_IO
-  private :: setup_fdf_cluster, broadcast_fdf_struct
-#endif
-#ifdef HAVE_BLOCKING_IO
-  private :: fdf_readblocking
-#endif
-
 ! Debugging functions, level and prints debugging info
-  private :: fdf_printfdf
+  public :: fdf_printfdf
 
 ! Finds a label in the FDF herarchy
   private :: fdf_locate
@@ -300,37 +261,36 @@ MODULE fdf
   integer(ip), private            :: fdf_in(maxdepth)
   integer(ip), private            :: fdf_out, fdf_err, fdf_log
 
-! MPI variables (id, number of MPI tasks)
-#ifdef HAVE_MPI
-  logical, private                :: mpiflag
-  integer(ip), private            :: rank, ntasks
-#endif
-
 ! Structure for searching inside fdf blocks
   type, public :: block_fdf
     character(len=MAX_LENGTH) :: label
-    type(line_dlist), pointer :: mark
+    type(line_dlist), pointer :: mark => null()
   end type block_fdf
 
 ! Dynamic list for parsed_line structures
   type, public :: line_dlist
     character(len=MAX_LENGTH)  :: str
-    type(parsed_line), pointer :: pline
-    type(line_dlist), pointer  :: next
-    type(line_dlist), pointer  :: prev
+    type(parsed_line), pointer :: pline => null()
+    !
+    type(line_dlist), pointer  :: next => null()
+    type(line_dlist), pointer  :: prev => null()
   end type line_dlist
 
 ! FDF data structure (first and last lines)
   type, private :: fdf_file
     integer(ip)               :: nlines
-    type(line_dlist), pointer :: first
-    type(line_dlist), pointer :: last
+    type(line_dlist), pointer :: first => null()
+    type(line_dlist), pointer :: last => null()
   end type fdf_file
 
 ! Input FDF file
-  type(fdf_file), pointer, private :: file_in
+  type(fdf_file), private :: file_in 
 
+! Export the following to enable serialization by clients of the library
 
+  public :: fdf_serialize_struct
+  public :: fdf_recreate_struct
+  public :: fdf_set_started
 
 ! Define by default all the others inherit module entities as privated
 ! avoiding redefinitions of entities in several module files with same name
@@ -339,7 +299,7 @@ MODULE fdf
   private
 
 
-  CONTAINS
+CONTAINS
 
 !
 !   Initialization for fdf.
@@ -365,9 +325,6 @@ MODULE fdf
                  THIS_FILE, __LINE__, fdf_err)
       endif
 
-#ifdef HAVE_MPI
-      call fdf_mpi_init()
-#endif
       call fdf_initdata()
 
       call io_geterr(fdf_err)
@@ -377,20 +334,10 @@ MODULE fdf
                            fileInput, fileOutput, unitInput )
       filedebug = trim(fileout) // ".debug"
 
-#ifdef FDF_DEBUG
-      ! To monitor the parsing and the build-up of the
-      ! fdf data structures in all nodes
-      call fdf_setdebug(2,filedebug)
-      call fdf_setoutput(2,fileout)   ! All nodes print output
-#endif
-
-!!      call fdf_set_output_file(fileout)
-
       call fdf_input(filein)
 
       fdf_started = .TRUE.
 
-#ifndef FDF_DEBUG
       ! Flags within the fdf file itself.
 
       ! At this point only the final fdf data structure will be shown,
@@ -401,19 +348,14 @@ MODULE fdf
       ! The default is to have output only in the master node
       output_level = fdf_get('fdf-output', 1)
       call fdf_setoutput(output_level,fileout)
-#endif
 
-      if (fdf_debug2) call fdf_printfdf()
+      if (debug_level >= 2) call fdf_printfdf()
 
-#ifdef HAVE_MPI
-      call fdf_mpi_finalize()
-#endif
 !$OMP END SINGLE
       RETURN
 !------------------------------------------------------------------------- END
       END SUBROUTINE fdf_init
 
-
       SUBROUTINE set_file_names( fileIn, fileOut, &
                                  optFileIn, optFileOut, unitIn )
       ! If present, copies input arguments optFileIn/Out to fileIn/Out.
@@ -433,14 +375,10 @@ MODULE fdf
 
       integer:: count, ierr, iostat, iu, iuIn
       logical:: named, opened
-      character(len=300) line
+      character(len=MAX_LENGTH*2) line
       character(len=maxFileNameLength) fileName
 
 !------------------------------------------------------------------------- BEGIN
-#ifdef HAVE_MPI
-      if (rank==0) then
-#endif
-
       ! Find a job-specific number
       call system_clock( count )
       count = mod(count,100000)
@@ -507,83 +445,11 @@ MODULE fdf
         endif ! (fileName=='stdin')
 
       endif ! (present(optFileIn))
-
-#ifdef HAVE_MPI
-      endif ! (rank==0)
-#endif
 !--------------------------------------------------------------------------- END
       END SUBROUTINE set_file_names
 
 !
-!   Initialize MPI subsystem if the application calling/using FDF
-!   library is not running with MPI enabled.
-!
-#ifdef HAVE_MPI
-    SUBROUTINE fdf_mpi_init()
-      use mpi_siesta
-      implicit none
-!--------------------------------------------------------------- Local Variables
-      integer(ip) :: ierr
-
-!------------------------------------------------------------------------- BEGIN
-      call MPI_Initialized(mpiflag, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: fdf_mpi_init', 'Error initializing MPI system.' // &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-      if (.not. mpiflag) then
-        call MPI_Init(ierr)
-        if (ierr .ne. MPI_SUCCESS) then
-          call die('FDF module: fdf_mpi_init', 'Error initializing MPI system.' // &
-                   'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-        endif
-      endif
-
-      call MPI_Comm_Rank(MPI_COMM_WORLD, rank, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: fdf_mpi_init', 'Error getting MPI comm rank.' // &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc= ierr)
-      endif
-
-      call MPI_Comm_Size(MPI_COMM_WORLD, ntasks, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: fdf_mpi_init', 'Error getting MPI comm size.' // &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-      RETURN
-!--------------------------------------------------------------------------- END
-    END SUBROUTINE fdf_mpi_init
-#endif
-
-!
-!   Finalize MPI subsystem if the application calling/using FDF
-!   library is not running with MPI enabled.
-!
-#ifdef HAVE_MPI
-    SUBROUTINE fdf_mpi_finalize()
-      use mpi_siesta
-      implicit none
-!--------------------------------------------------------------- Local Variables
-      integer(ip)   :: ierr
-
-!------------------------------------------------------------------------- BEGIN
-      if (.not. mpiflag) then
-        call MPI_Finalize(ierr)
-        if (ierr .ne. MPI_SUCCESS) then
-          call die('FDF module: fdf_mpi_finalize', 'Error finalizing MPI system.' // &
-                   'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-        endif
-      endif
-
-      RETURN
-!--------------------------------------------------------------------------- END
-    END SUBROUTINE fdf_mpi_finalize
-#endif
-
-!
-!   Reads the input file depending on the configuration of the system:
-!   Shared Filesystem, Cluster Filesystem or Blocking input access
+!   Reads the input file
 !
     SUBROUTINE fdf_input(filein)
       implicit none
@@ -591,14 +457,8 @@ MODULE fdf
       character(*)  :: filein
 
 !------------------------------------------------------------------------- BEGIN
-#ifdef HAVE_CLUSTER_IO
-!!      call fdf_readcluster(filein)
-      call setup_fdf_cluster(filein)
-#elif defined(HAVE_BLOCKING_IO)
-      call fdf_readblocking(filein)
-#else
+
       call fdf_read(filein)
-#endif
 
       if (fdf_output) write(fdf_out,'(a,a,a,i3)') '#FDF module: Opened ', filein,   &
                                   ' for input. Unit:', fdf_in(1)
@@ -607,235 +467,6 @@ MODULE fdf
 !--------------------------------------------------------------------------- END
     END SUBROUTINE fdf_input
 
-!
-!   Reading code for Cluster Architecture, where the filesystem
-!   is not shared along all the nodes in the system.
-!
-#ifdef HAVE_CLUSTER_IO
-    SUBROUTINE fdf_readcluster(filein)
-      use mpi_siesta
-      implicit none
-!--------------------------------------------------------------- Input Variables
-      character(*)  :: filein
-
-!--------------------------------------------------------------- Local Variables
-      character(80)  :: msg
-      character(256) :: fileinTmp
-      integer(ip)    :: ierr, texist_send, texist_recv
-#ifdef SOPHISTICATED_SEARCH
-      logical        :: file_exist
-#endif
-!------------------------------------------------------------------------- BEGIN
-!     Tests if the running node has the input file:
-!       If found: texist_send = rank
-!       Else    : texist_send = error_code (ntasks + 1)
-
-#ifdef SOPHISTICATED_SEARCH
-      INQUIRE(file=filein, exist=file_exist)
-      if (file_exist) then
-        texist_send = rank
-      else
-        texist_send = ntasks + 1
-      endif
-
-      call MPI_AllReduce(texist_send, texist_recv, 1, MPI_INTEGER,      &
-                         MPI_MIN, MPI_COMM_WORLD, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: fdf_readcluster', 'Error in MPI_AllReduce (task_exist).' //  &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-#else
-!
-!     Simplify: Assume node 0 has the file
-!
-      texist_recv = 0
-#endif
-
-!     The node owner of the input file send the data to the other ones
-!     if none node has an input file with such name abort the application
-      if (texist_recv .eq. ntasks + 1) then
-        write(msg,*) 'No node found in the cluster with ',              &
-                     ' input file ', filein,'. Terminating.'
-        call die('FDF module: fdf_readcluster', msg,                    &
-                 THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      else
-        if (texist_recv .eq. rank) then
-          call fdf_read(filein)
-          call fdf_sendInput()
-!!Debug          call MPI_Barrier( MPI_COMM_WORLD, ierr )
-          if (fdf_output) write(fdf_out,*) '#FDF module: Node', rank, 'reading/sending', &
-                           ' input file ', filein
-        else
-          call fdf_recvInput(texist_recv, filein, fileinTmp)
-!!Debug          call MPI_Barrier( MPI_COMM_WORLD, ierr )
-          call fdf_read(fileinTmp)
-          if (fdf_output) write(fdf_out,*) '#FDF module: Node', rank, 'receiving input', &
-                           ' file from', texist_recv, 'to ', TRIM(fileinTmp)
-        endif
-      endif
-      RETURN
-!--------------------------------------------------------------------------- END
-    END SUBROUTINE fdf_readcluster
-!
-!
-    SUBROUTINE setup_fdf_cluster(filein)
-!
-!     A more efficient alternative to fdf_sendInput/fdf_recvInput
-!     that avoids the creation of scratch files by non-root nodes.
-!
-!     Alberto Garcia, April 2011
-
-      use mpi_siesta
-      implicit none
-!--------------------------------------------------------------- Input Variables
-      character(*), intent(in)  :: filein   ! File name
-
-!--------------------------------------------------------------- Local Variables
-      character(80)  :: msg
-      character(256) :: fileinTmp
-      integer(ip)    :: ierr, texist_send, reading_node
-#ifdef SOPHISTICATED_SEARCH
-      logical        :: file_exist
-#endif
-!------------------------------------------------------------------------- BEGIN
-!     Tests if the running node has the input file:
-!       If found: texist_send = rank
-!       Else    : texist_send = error_code (ntasks + 1)
-
-#ifdef SOPHISTICATED_SEARCH
-      INQUIRE(file=filein, exist=file_exist)
-      if (file_exist) then
-        texist_send = rank
-      else
-        texist_send = ntasks + 1
-      endif
-
-      call MPI_AllReduce(texist_send, reading_node, 1, MPI_INTEGER,      &
-                         MPI_MIN, MPI_COMM_WORLD, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: fdf_readcluster', 'Error in MPI_AllReduce (task_exist).' //  &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-#else
-!
-!     Simplify: Assume node 0 has the file
-!
-      reading_node = 0
-#endif
-
-!     If no node has an input file with such name abort the application
-      if (reading_node .eq. ntasks + 1) then
-         write(msg,*) 'No node found in the cluster with ',              &
-              ' input file ', filein,'. Terminating.'
-         call die('FDF module: fdf_readcluster', msg,                    &
-              THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-!     The root node reads and digests the input file
-!     and sends the serialized fdf_file data structure to the other nodes
-
-      if (rank == reading_node) then
-         call fdf_read(filein)
-      endif
-      call broadcast_fdf_struct(reading_node)		
-
-      RETURN
-!--------------------------------------------------------------------------- END
-    END SUBROUTINE setup_fdf_cluster
-
-!
-!   Broadcast complete fdf structure
-!
-    SUBROUTINE broadcast_fdf_struct(reading_node)
-      use mpi_siesta
-      implicit none
-
-      integer, intent(in)       :: reading_node         ! Node which contains the struct
-
-!--------------------------------------------------------------- Local Variables
-      character, pointer        :: bufferFDF(:) => null()
-      integer(ip)               :: i, j, k, ierr, nlines
-
-!------------------------------------------------------------------------- BEGIN
-
-      if (rank == reading_node) then
-         nlines = file_in%nlines
-      endif
-
-      call MPI_Bcast(nlines, 1,                                 &
-                     MPI_INTEGER, reading_node, MPI_COMM_WORLD, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: broadcast_fdf', 'Error Broadcasting nlines.' // &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-      ALLOCATE(bufferFDF(nlines*SERIALIZED_LENGTH), stat=ierr)
-      if (ierr .ne. 0) then
-        call die('FDF module: broadcast_fdf', 'Error allocating bufferFDF', &
-                 THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-      if (rank == reading_node) then
-         call serialize_fdf_struct(bufferFDF)
-      endif
-
-      call MPI_Bcast(bufferFDF, size(bufferFDF),              &
-                     MPI_CHARACTER, reading_node, MPI_COMM_WORLD, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: broadcast_fdf', 'Error Broadcasting bufferFDF.' // &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-      if (rank /= reading_node) then
-         call recreate_fdf_struct(nlines,bufferFDF)
-      endif
-
-      DEALLOCATE(bufferFDF)
-
-      RETURN
-!--------------------------------------------------------------------------- END
-    END SUBROUTINE broadcast_fdf_struct
-#endif
-!
-!   Reading code for Blocking read. The reading of the input file is
-!   splitted in several steps of size BLOCKSIZE. The number of steps
-!   needed to read the file in all the nodes depends on the total nodes,
-!   being ntasks/HAVE_BLOCKING_IOSIZE.
-!
-!   With this method we can avoid a colapse of a global parallel filesystem
-!   if the execution of the application runs over a huge amount of nodes.
-!
-#ifdef HAVE_BLOCKING_IO
-    SUBROUTINE fdf_readblocking(filein)
-      use mpi_siesta
-      implicit none
-!--------------------------------------------------------------- Input Variables
-      character(*) :: filein
-
-!--------------------------------------------------------------- Local Variables
-      integer(ip)  :: i, ierr
-
-!------------------------------------------------------------------------- BEGIN
-
-      do i= 0, ntasks-1, FDF_BLOCKSIZE
-        if ((rank .ge. i) .and. (rank .le. i+FDF_BLOCKSIZE-1)) then
-          call fdf_read(filein)
-          if (fdf_output) write(fdf_out,*) '#FDF module: Task', rank, 'reading input', &
-                           ' file ', filein, ' in step', (i/FDF_BLOCKSIZE)+1
-        endif
-
-        call MPI_Barrier(MPI_COMM_WORLD, ierr)
-        if (ierr .ne. MPI_SUCCESS) then
-          call die('FDF module: fdf_readblocking', 'Error in MPI_Barrier (fdf_read).' //    &
-                   'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-        endif
-      enddo
-
-      RETURN
-!--------------------------------------------------------------------------- END
-    END SUBROUTINE fdf_readblocking
-#endif
-
-!
 !   Read an input file (and include files) and builds memory
 !   structure that will contain the data and will help in searching
 !
@@ -1431,12 +1062,6 @@ MODULE fdf
 !------------------------------------------------------------------------- BEGIN
       ndepth = 0
 
-      ALLOCATE(file_in, stat=ierr)
-      if (ierr .ne. 0) then
-        call die('FDF module: fdf_initdata', 'Error allocating file_in', &
-                 THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
       file_in%nlines = 0
       NULLIFY(file_in%first)
       NULLIFY(file_in%last)
@@ -1498,7 +1123,7 @@ MODULE fdf
          endif
 
          ! To circumvent the first/last line in the fdf-file
-         ! we have to check for the existance of the
+         ! we have to check for the existence of the
          ! first/last mark being the one removed.
          ! That special case *must* correct the first/last
          ! tokens.
@@ -1554,7 +1179,7 @@ MODULE fdf
       type(parsed_line), pointer :: pline
 
 !--------------------------------------------------------------- Local Variables
-      integer                    :: i, ierr
+      integer(ip)                :: i, ierr
       type(line_dlist), pointer  :: mark
 
 !------------------------------------------------------------------------- BEGIN
@@ -1670,45 +1295,8 @@ MODULE fdf
 !----------------------------------------------------- BEGIN
       call io_assign(fdf_out)
 
-#ifdef HAVE_MPI
-      if (rank /= 0) then
-         fileouttmp = "/tmp/" // trim(fileout) // "." // i2s(rank)
-      else
-         fileouttmp = fileout
-      endif
-#else
-      fileouttmp = fileout
-#endif
-
-#ifdef FDF_DEBUG
-      !
-      !     If debugging, all the nodes use named log files
-      !
-      open( unit=fdf_out, file=TRIM(fileouttmp), form='formatted', &
+      open( unit=fdf_out, file=TRIM(fileout), form='formatted', &
            access='sequential', status='replace' )
-#else
-      !
-      !     Only the master node opens a named log file in the current dir.
-      !     Non-master nodes use a scratch file.
-      !     These log files tend to be quite small, so there
-      !     should not be problems such as filling up filesystems.
-      !     ... your mileage might vary. This is a grey area.
-      !     Some compilers allow the user to specify where scratch
-      !     files go.
-      !
-#ifdef HAVE_MPI
-      if (rank /= 0) then
-         open( unit=fdf_out, form='formatted', &
-              access='sequential', status='scratch' )
-      else
-         open( unit=fdf_out, file=TRIM(fileouttmp), form='formatted', &
-              access='sequential', status='replace' )
-      end if
-#else
-      open( unit=fdf_out, file=TRIM(fileouttmp), form='formatted', &
-           access='sequential', status='replace' )
-#endif
-#endif
 
       RETURN
 !--------------------------------------------------------------------------- END
@@ -1739,11 +1327,10 @@ MODULE fdf
     SUBROUTINE fdf_destroy(fdfp)
       implicit none
 !-------------------------------------------------------------- Output Variables
-      type(fdf_file), pointer :: fdfp
+      type(fdf_file) :: fdfp
 
 !------------------------------------------------------------------------- BEGIN
       if (ASSOCIATED(fdfp%first)) call fdf_destroy_dl(fdfp%first)
-      DEALLOCATE(fdfp)
 
       RETURN
 !--------------------------------------------------------------------------- END
@@ -1757,7 +1344,10 @@ MODULE fdf
 !-------------------------------------------------------------- Output Variables
       type(line_dlist), pointer :: dlp
 
-!------------------------------------------------------------------------- BEGIN
+      !! Use for tail recursion later:      type(line_dlist), pointer :: pnext
+
+      !------------------------------------------------------------------------- BEGIN
+      ! This is NOT tail-recursive!!
       if (ASSOCIATED(dlp%next)) call fdf_destroy_dl(dlp%next)
       call destroy(dlp%pline)
       DEALLOCATE(dlp)
@@ -1765,27 +1355,6 @@ MODULE fdf
       RETURN
 !--------------------------------------------------------------------------- END
     END SUBROUTINE fdf_destroy_dl
-
-!
-!   Tells when FDF library has been compiled with parallel
-!   execution support. Depends on HAVE_MPI macro.
-!
-    FUNCTION fdf_parallel()
-      implicit none
-!-------------------------------------------------------------- Output Variables
-      logical      :: fdf_parallel
-
-!------------------------------------------------------------------------- BEGIN
-#ifdef HAVE_MPI
-      fdf_parallel = .TRUE.
-#else
-      fdf_parallel = .FALSE.
-#endif
-
-      RETURN
-!--------------------------------------------------------------------------- END
-    END FUNCTION fdf_parallel
-
 !
 !   Read a line of the 'ndepth' input file, returning .TRUE. if
 !   there are more lines to read from input file, .FALSE. otherwise.
@@ -2093,6 +1662,7 @@ MODULE fdf
             call integerlists(mark%pline,1,ni,list)
          end if
 
+         ! find a way to write out the list anyway
          if (fdf_output) write(fdf_out,'(a,5x,i10)') label, lni
       else
          write(msg,*) 'no list value for ', label
@@ -2813,6 +2383,68 @@ MODULE fdf
     END FUNCTION fdf_locate
 
 !
+!   Returns true or false whether or not the label 'label' is
+!   a block.
+!   I.e. it returns true if the line has the form bl, if not found, or not bl
+!   it returns false.
+!
+    FUNCTION fdf_isblock(label)
+      implicit none
+!--------------------------------------------------------------- Input Variables
+      character(*)                        :: label
+
+!-------------------------------------------------------------- Output Variables
+      logical                             :: fdf_isblock
+
+!--------------------------------------------------------------- Local Variables
+      type(line_dlist), pointer :: mark
+      character(80) :: strlabel
+
+!------------------------------------------------------------------------- BEGIN
+!     Prevents using FDF routines without initialize
+      if (.not. fdf_started) then
+         call die('FDF module: fdf_isblock', 'FDF subsystem not initialized', &
+                 THIS_FILE, __LINE__, fdf_err)
+      endif
+
+      fdf_isblock = .false.
+      
+      mark => file_in%first
+      do while ( associated(mark) )
+
+!!$        if ( match(mark%pline, 'l') ) then
+!!$          strlabel = labels(mark%pline)
+!!$
+!!$          if ( labeleq(strlabel, label, fdf_log) ) then
+!!$            ! fdf has first-encounter acceptance.
+!!$            ! I.e. for an input
+!!$            !   Label_Name 1
+!!$            !   %block Label_Name
+!!$            !     1
+!!$            !   %endblock Label_Name
+!!$            ! the former will be accepted first.
+!!$            exit
+!!$          end if
+
+        if ( match(mark%pline, 'bl') ) then
+          strlabel = blocks(mark%pline)
+          
+          if ( labeleq(strlabel, label, fdf_log) ) then
+            fdf_isblock = .true.
+            exit
+          end if
+        end if
+
+        mark => mark%next
+      end do
+      
+      if (fdf_output) write(fdf_out,'(a,5x,l10)') "#:block? " // label, fdf_isblock
+
+      RETURN
+!--------------------------------------------------------------------------- END
+    END FUNCTION fdf_isblock
+    
+!
 !   Searches for block label in the fdf hierarchy. If it appears returns
 !   .TRUE. and leaves block mark pointer positioned at the first line.
 !   Otherwise, it returns .FALSE. and block mark points to NULL.
@@ -2965,7 +2597,7 @@ MODULE fdf
         if (labeleq(strlabel, bfdf%label, fdf_log)) then
           bfdf%mark => bfdf%mark%prev
 
-          if (fdf_output) write(fdf_out,'(1x,a)') "(Backspace to) " // "|" //  &
+          if (fdf_output) write(fdf_out,'(1x,a)') "#:(Backspace to) " // "|" //  &
                                 TRIM(bfdf%mark%str) // "|"
         endif
 
@@ -2976,14 +2608,14 @@ MODULE fdf
 
         if (labeleq(strlabel, bfdf%label, fdf_log)) then
           fdf_bbackspace = .FALSE.
-          if (fdf_output) write(fdf_out,'(1x,a)') "(Cannot backspace) " // "|" //  &
+          if (fdf_output) write(fdf_out,'(1x,a)') "#:(Cannot backspace) " // "|" //  &
                                 TRIM(bfdf%mark%str) // "|"
         endif
 
       else
 
         bfdf%mark => bfdf%mark%prev
-        if (fdf_output) write(fdf_out,'(1x,a)') "(Backspace to) " // "|" //  &
+        if (fdf_output) write(fdf_out,'(1x,a)') "#:(Backspace to) " // "|" //  &
                                 TRIM(bfdf%mark%str) // "|"
       endif
 
@@ -3028,6 +2660,108 @@ MODULE fdf
     END SUBROUTINE fdf_brewind
 
 !
+!   Closes the opened block by looping the remaining lines of the working line.
+!   This is only needed to complete the fdf-*.log files output for direct
+!   usage later. It does nothing internally.
+!
+    SUBROUTINE fdf_bclose(bfdf)
+      implicit none
+!-------------------------------------------------------------- Output Variables
+      type(block_fdf) :: bfdf
+
+!--------------------------------------------------------------- Local Variables
+      type(parsed_line), pointer :: pline
+      integer(ip) :: i
+      character(80) :: msg
+
+!------------------------------------------------------------------------- BEGIN
+!     Prevents using FDF routines without initialize
+      if (.not. fdf_started) then
+        call die('FDF module: fdf_bclose', 'FDF subsystem not initialized', &
+                 THIS_FILE, __LINE__, fdf_err)
+      endif
+
+      ! Quick return (no need for errors)
+      if ( .not. associated(bfdf%mark) ) return
+
+      ! This should hopefully discourage compilers to optimize the loop away...
+      i = 0
+      do while ( fdf_bline(bfdf, pline) )
+        i = i + fdf_bnvalues(pline)
+      end do
+      write(msg,'(a,i10)') 'Block ', i
+
+      RETURN
+!--------------------------------------------------------------------------- END
+    END SUBROUTINE fdf_bclose
+
+    
+!
+!   Count number of lines with an optional specification.
+!   I.e. this will read through the block and return the number of lines in the
+!   block which matches the morphology (morph)
+!   This may be used to easily digest number of non-empty lines in the block.
+!   Note that a match on the morphology only compares the number of ID's in
+!   morph. I.e. a line with 'vvvil' will match 'vvvi'.
+!
+    FUNCTION fdf_block_linecount(label, morph)
+      implicit none
+!--------------------------------------------------------------- Input Variables
+      character(len=*) :: label
+      character(len=*), optional :: morph
+!-------------------------------------------------------------- Output Variables
+      integer(ip) :: fdf_block_linecount
+      
+!--------------------------------------------------------------- Local Variables
+      type(block_fdf) :: bfdf
+      type(parsed_line), pointer :: pline
+      logical :: orig_fdf_output
+
+!------------------------------------------------------------------------- BEGIN
+!     Prevents using FDF routines without initialize
+      if (.not. fdf_started) then
+        call die('FDF module: fdf_block_linecount', 'FDF subsystem not initialized', &
+                 THIS_FILE, __LINE__, fdf_err)
+      endif
+
+      ! Store the fdf_output variable (suppress writing to log)
+      orig_fdf_output = fdf_output
+      fdf_output = .false.
+
+      ! Find the block and search for morhp
+      fdf_block_linecount = 0
+      if ( fdf_block(label, bfdf) ) then
+
+        do while ( fdf_bline(bfdf, pline) )
+          if ( present(morph) ) then
+            if ( fdf_bmatch(pline, morph) ) then
+              fdf_block_linecount = fdf_block_linecount + 1
+            end if
+          else
+            fdf_block_linecount = fdf_block_linecount + 1
+          end if
+        end do
+
+      end if
+
+      ! Restore output
+      fdf_output = orig_fdf_output
+
+      if ( fdf_output ) then
+        if ( present(morph) ) then
+          write(fdf_out,'(3a,3x,i0)') "#:block-line-count? ", &
+              trim(label), ' ('//trim(morph)//')', fdf_block_linecount
+        else
+          write(fdf_out,'(2a,3x,i0)') "#:block-line-count? ", &
+              trim(label), fdf_block_linecount
+        end if
+      end if
+      
+      RETURN
+!--------------------------------------------------------------------------- END
+    END FUNCTION fdf_block_linecount
+
+!
 !   Check if label is defined
 !
     logical FUNCTION fdf_defined(label)
@@ -3037,18 +2771,16 @@ MODULE fdf
 
 !--------------------------------------------------------------- Local Variables
       type(line_dlist), pointer :: mark
-      type(block_fdf)           :: bfdf
-
 
 !--------------------------------------------------------------------- BEGIN
       ! First, check whether a single label exists:
       fdf_defined = fdf_locate(label, mark)
       if (.not. fdf_defined) then
          ! Check whether there is a block with that label
-         fdf_defined = fdf_block(label,bfdf)
+         fdf_defined = fdf_isblock(label)
       endif
-      if (fdf_defined) then
-         if (fdf_output) write(fdf_out,'(a)') label
+      if ( fdf_output ) then
+        write(fdf_out,'(a,5x,l10)') '#:defined? ' // label, fdf_defined
       endif
 
       RETURN
@@ -3077,30 +2809,11 @@ MODULE fdf
         endif
       else
         if (.not. fdf_output) then
-#ifdef HAVE_MPI
-          if (rank /= 0) then
-             if (level .ge. 2) then
-                fileout = "/tmp/" // trim(fileout) // "." // i2s(rank)
-                call io_assign(fdf_out)
-                open(fdf_out, file=fileout, form='formatted',               &
-                     status='unknown')
-                REWIND(fdf_out)
-                fdf_output = .TRUE.
-             endif
-          else
-             call io_assign(fdf_out)
-             open(fdf_out, file=fileout, form='formatted',               &
-                  status='unknown')
-             REWIND(fdf_out)
-             fdf_output = .TRUE.
-          endif
-#else
           call io_assign(fdf_out)
           open(fdf_out, file=fileout, form='formatted',               &
                status='unknown')
           REWIND(fdf_out)
           fdf_output = .TRUE.
-#endif
         endif
       endif
 !----------------------------------------------------------------------- END
@@ -3127,11 +2840,6 @@ MODULE fdf
       else
         if (.not. fdf_debug) then
           call io_assign(fdf_log)
-#ifdef HAVE_MPI
-          if (rank /= 0) then
-             filedebug = "/tmp/" // trim(filedebug) // "." // i2s(rank)
-          endif
-#endif
           open(fdf_log, file=filedebug, form='formatted',               &
                status='unknown')
           REWIND(fdf_log)
@@ -3162,13 +2870,13 @@ MODULE fdf
 
 !------------------------------------------------------------------------- BEGIN
       if ( fdf_defined(label) ) then
-         if (fdf_output) write(fdf_out,'(a)') "**Warning: FDF symbol '"//trim(label)// &
+         if (fdf_output) write(fdf_out,'(a)') "#**Warning: FDF symbol '"//trim(label)// &
               "' is deprecated."
          if ( fdf_defined(newlabel) ) then
-            if (fdf_output) write(fdf_out,'(a)') "           FDF symbol '"//trim(newlabel)// &
+            if (fdf_output) write(fdf_out,'(a)') "#           FDF symbol '"//trim(newlabel)// &
                  "' will be used instead."
          else
-            if (fdf_output) write(fdf_out,'(a)') "           FDF symbol '"//trim(newlabel)// &
+            if (fdf_output) write(fdf_out,'(a)') "#           FDF symbol '"//trim(newlabel)// &
                  "' replaces '"//trim(label)//"'."
          end if
       end if
@@ -3186,21 +2894,28 @@ MODULE fdf
 
 !------------------------------------------------------------------------- BEGIN
       if ( fdf_defined(label) ) then
-         if (fdf_output) write(fdf_out,'(a)') "**Warning: FDF symbol '"//trim(label)// &
+         if (fdf_output) write(fdf_out,'(a)') "#**Warning: FDF symbol '"//trim(label)// &
               "' is obsolete."
       end if
 
 !--------------------------------------------------------------------------- END
     end subroutine fdf_obsolete
 
-
-    subroutine serialize_fdf_struct(buffer)
-    character, pointer        :: buffer(:)
+!===================== Serialization utilities for clients
+    
+    subroutine fdf_serialize_struct(buffer)
+    character(len=1), intent(inout), allocatable   :: buffer(:)
 
     character(len=SERIALIZED_LENGTH)  bufline
     type(line_dlist), pointer :: mark
-    integer :: i, length, init, final
+    integer(ip) :: i, length, init, final
+
+    integer :: nchars ! total size of serialized content
 
+    if (allocated(buffer)) deallocate(buffer)
+    nchars = file_in%nlines * SERIALIZED_LENGTH
+    allocate(buffer(nchars))
+    
     mark => file_in%first
     do i= 1, file_in%nlines
        call serialize_pline(mark%pline,bufline,length)
@@ -3209,16 +2924,17 @@ MODULE fdf
        call convert_string_to_array_of_chars(bufline,buffer(init:final))
        mark => mark%next
     enddo
-  end subroutine serialize_fdf_struct
+  end subroutine fdf_serialize_struct
 
-    subroutine recreate_fdf_struct(nlines,bufferFDF)
-    character, pointer        :: bufferFDF(:)
-    integer, intent(in)       :: nlines
+    subroutine fdf_recreate_struct(bufferFDF)
+    character(len=1), intent(in)    :: bufferFDF(:)
 
     character(len=SERIALIZED_LENGTH)  bufline
     type(parsed_line), pointer    :: pline
-    integer :: i, init, final
+    integer(ip) :: nlines, i, init, final
 
+    nlines = size(bufferFDF) / SERIALIZED_LENGTH
+    
     do i= 1, nlines
        init  = (i-1)*SERIALIZED_LENGTH+1
        final = (i)*SERIALIZED_LENGTH
@@ -3227,121 +2943,14 @@ MODULE fdf
        call recreate_pline(pline,bufline)
        call fdf_addtoken(pline%line,pline)
     enddo
-    ! print *, "Processed: ", file_in%nlines, " lines."
 
-  end subroutine recreate_fdf_struct
+  end subroutine fdf_recreate_struct
 
-!=================================================================
-!--------- Obsolete routines ----------------
-!
-!   The owner node of the input file sends data file to the
-!   other processes in the MPI communicator.
-!
-#ifdef HAVE_CLUSTER_IO
-    SUBROUTINE fdf_sendInput()
-      use mpi_siesta
-      implicit none
-!--------------------------------------------------------------- Local Variables
-      character, pointer        :: bufferFDF(:) => null()
-      integer(ip)               :: i, j, k, ierr
-      type(line_dlist), pointer :: mark
+      ! To enable client-side setting
+    SUBROUTINE fdf_set_started(status)
+      logical, intent(in) :: status
 
-!------------------------------------------------------------------------- BEGIN
-      ALLOCATE(bufferFDF(file_in%nlines*MAX_LENGTH), stat=ierr)
-      if (ierr .ne. 0) then
-        call die('FDF module: fdf_sendInput', 'Error allocating bufferFDF', &
-                 THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-      mark => file_in%first
-      do i= 1, file_in%nlines*MAX_LENGTH, MAX_LENGTH
-        bufferFDF(i:i+MAX_LENGTH-1) = s2arr(mark%str)
-        mark => mark%next
-      enddo
-
-      call MPI_Bcast(file_in%nlines, 1,                                 &
-                     MPI_INTEGER, rank, MPI_COMM_WORLD, ierr)
-
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: fdf_sendInput', 'Error Broadcasting nlines.' // &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-      call MPI_Bcast(bufferFDF, file_in%nlines*MAX_LENGTH,              &
-                     MPI_CHARACTER, rank, MPI_COMM_WORLD, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: fdf_sendInput', 'Error Broadcasting bufferFDF.' // &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-      DEALLOCATE(bufferFDF)
-
-      RETURN
-!--------------------------------------------------------------------------- END
-    END SUBROUTINE fdf_sendInput
-#endif
-
-!
-!   Remaining nodes recieve the input data file from the owner
-!   of the FDF file inside the cluster.
-!
-#ifdef HAVE_CLUSTER_IO
-    SUBROUTINE fdf_recvInput(root, filein, fileinTmp)
-      use mpi_siesta
-      implicit none
-!--------------------------------------------------------------- Input Variables
-      character(*)       :: filein, fileinTmp
-      integer(ip)        :: root
+      fdf_started = status
+    end SUBROUTINE fdf_set_started
 
-!--------------------------------------------------------------- Local Variables
-      integer(ip)        :: i, j, lun, ierr, nlines
-      character, pointer :: bufferFDF(:) => null()
-      character(len=10)  :: fmt
-!------------------------------------------------------------------------- BEGIN
-      call MPI_Bcast(nlines, 1,                                         &
-                     MPI_INTEGER, root, MPI_COMM_WORLD, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: fdf_recvInput', 'Error Broadcasting nlines.' // &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-      ALLOCATE(bufferFDF(nlines*MAX_LENGTH), stat=ierr)
-      if (ierr .ne. 0) then
-        call die('FDF module: fdf_recvInput', 'Error allocating bufferFDF', &
-                 THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-      call MPI_Bcast(bufferFDF, nlines*MAX_LENGTH,                      &
-                     MPI_CHARACTER, root, MPI_COMM_WORLD, ierr)
-      if (ierr .ne. MPI_SUCCESS) then
-        call die('FDF module: fdf_recvInput', 'Error Broadcasting bufferFDF.' // &
-                 'Terminating.', THIS_FILE, __LINE__, fdf_err, rc=ierr)
-      endif
-
-      call io_assign(lun)
-      fileinTmp = TRIM(filein) // '.' // i2s(rank)
-      open(unit=lun, file=fileinTmp, form='formatted',                  &
-           status='unknown')
-
-      if (MAX_LENGTH.lt.10) then
-        write(fmt,"(a1,I1,a2)") "(", MAX_LENGTH, "a)"
-      else if (MAX_LENGTH.lt.100) then
-        write(fmt,"(a1,I2,a2)") "(", MAX_LENGTH, "a)"
-      else if (MAX_LENGTH.lt.1000) then
-        write(fmt,"(a1,I3,a2)") "(", MAX_LENGTH, "a)"
-      else
-        write(fmt,"(a1,I4,a2)") "(", MAX_LENGTH, "a)"
-      endif
-
-      do i= 1, nlines*MAX_LENGTH, MAX_LENGTH
-        write(lun,fmt) (bufferFDF(j),j=i,i+MAX_LENGTH-1)
-      enddo
-      call io_close(lun)
-
-      DEALLOCATE(bufferFDF)
-
-      RETURN
-!--------------------------------------------------------------------------- END
-    END SUBROUTINE fdf_recvInput
-#endif
 END MODULE fdf
diff --git a/src/utils.F90 b/src/utils.F90
index ee66e11..110ffa2 100644
--- a/src/utils.F90
+++ b/src/utils.F90
@@ -408,12 +408,9 @@ MODULE utils
 
 !
 !   Die routine (Abort/Terminate program)
-!   MPI-awareness (MPI_Abort)
 !
     SUBROUTINE die(routine, msg, file, line, unit, rc, cline)
-#if defined(HAVE_CLUSTER_IO) || defined(HAVE_BLOCKING_IO)
-      use mpi_siesta
-#endif
+
       implicit none
 !--------------------------------------------------------------- Input Variables
       character(len=*), intent(in)           :: routine, msg
@@ -422,10 +419,6 @@ MODULE utils
 
 !--------------------------------------------------------------- Local Variables
       integer(ip)                            :: die_unit
-#if defined(HAVE_CLUSTER_IO) || defined(HAVE_BLOCKING_IO)
-      integer(ip)                            :: ierr, rc2
-#endif
-
 !------------------------------------------------------------------------- BEGIN
       if (PRESENT(unit)) then
         die_unit = unit
@@ -447,17 +440,8 @@ MODULE utils
         write(die_unit,'(a)') 'Stopping Program'
       endif
 
-#if defined(HAVE_CLUSTER_IO) || defined(HAVE_BLOCKING_IO)
-      if (.not. PRESENT(rc)) then
-        rc2 = 0
-      else
-        rc2 = rc
-      endif
-
-      call MPI_Abort(MPI_COMM_WORLD, rc2, ierr)
-#else
+      ! Replace this by a call to a proper handler
       STOP 'Stopping Program'
-#endif
 !--------------------------------------------------------------------------- END
     END SUBROUTINE die