Changeset 4147

Timestamp:

Aug 7, 2019 9:42:31 AM (5 years ago)

Author:

gronemeier

Message:

corrected indentation according to coding standard

Location:

palm/trunk/SOURCE

Files:

• data_output_binary_module.f90 (modified) (12 diffs)
• data_output_module.f90 (modified) (29 diffs)
• data_output_netcdf4_module.f90 (modified) (14 diffs)

palm/trunk/SOURCE/data_output_binary_module.f90

@@ -25 +25 @@
 ! -----------------
 ! $Id$
+! corrected indentation according to coding standard
+!
+! 4141 2019-08-05 12:24:51Z gronemeier
 ! Initial revision
 !
@@ -38 +41 @@
 !> @todo Get iostat value of write statements.
 !--------------------------------------------------------------------------------------------------!
-MODULE data_output_binary_module
-
-   USE kinds
+ MODULE data_output_binary_module
+
+    USE kinds
 
 #if defined( __parallel )
 #if defined( __mpifh )
-   INCLUDE "mpif.h"
+    INCLUDE "mpif.h"
 #else
-   USE MPI
+    USE MPI
 #endif
 #endif
 
-   IMPLICIT NONE
-
-   INTEGER, PARAMETER ::  charlen = 100  !< maximum length of character variables
-
-   CHARACTER(LEN=*), PARAMETER ::  config_file_name = 'BINARY_TO_NETCDF_CONFIG'  !< name of config file
-   CHARACTER(LEN=*), PARAMETER ::  mode_binary = 'binary'                        !< string to select operation mode of module
-   CHARACTER(LEN=*), PARAMETER ::  file_prefix = 'BIN_'                          !< file prefix for binary files
-
-   CHARACTER(LEN=charlen)      ::  file_suffix = ''             !< file suffix added to each file name
-   CHARACTER(LEN=800)          ::  internal_error_message = ''  !< string containing the last error message
-   CHARACTER(LEN=800)          ::  temp_string                  !< dummy string
-
-   INTEGER ::  binary_file_lowest_unit = 1000  !< lowest unit number of all binary files created by this module
-   INTEGER ::  config_file_unit                !< unit number of config file
-   INTEGER ::  debug_output_unit               !< Fortran Unit Number of the debug-output file
-   INTEGER ::  global_id_in_file = -1          !< value of global ID within a file
-   INTEGER ::  master_rank                     !< master rank for tasks to be executed by single PE only
-   INTEGER ::  next_available_unit             !< next unit number available for new file
-   INTEGER ::  output_group_comm               !< MPI communicator addressing all MPI ranks which participate in output
-
-   INTEGER, DIMENSION(:), ALLOCATABLE ::  files_highest_variable_id  !< highest assigned ID of variable or dimension in a file
-
-   LOGICAL ::  binary_open_file_first_call = .TRUE.  !< true if binary_open_file routine was not called yet
-   LOGICAL ::  config_file_open = .FALSE.            !< true if config file is opened and not closed
-   LOGICAL ::  print_debug_output = .FALSE.          !< if true, debug output is printed
-
-   SAVE
-
-   PRIVATE
-
-   INTERFACE binary_init_module
-      MODULE PROCEDURE binary_init_module
-   END INTERFACE binary_init_module
-
-   INTERFACE binary_open_file
-      MODULE PROCEDURE binary_open_file
-   END INTERFACE binary_open_file
-
-   INTERFACE binary_init_dimension
-      MODULE PROCEDURE binary_init_dimension
-   END INTERFACE binary_init_dimension
-
-   INTERFACE binary_init_variable
-      MODULE PROCEDURE binary_init_variable
-   END INTERFACE binary_init_variable
-
-   INTERFACE binary_write_attribute
-      MODULE PROCEDURE binary_write_attribute
-   END INTERFACE binary_write_attribute
-
-   INTERFACE binary_stop_file_header_definition
-      MODULE PROCEDURE binary_stop_file_header_definition
-   END INTERFACE binary_stop_file_header_definition
-
-   INTERFACE binary_write_variable
-      MODULE PROCEDURE binary_write_variable
-   END INTERFACE binary_write_variable
-
-   INTERFACE binary_finalize
-      MODULE PROCEDURE binary_finalize
-   END INTERFACE binary_finalize
-
-   INTERFACE binary_get_error_message
-      MODULE PROCEDURE binary_get_error_message
-   END INTERFACE binary_get_error_message
-
-   PUBLIC &
-      binary_finalize, &
-      binary_get_error_message, &
-      binary_init_dimension, &
-      binary_stop_file_header_definition, &
-      binary_init_module, &
-      binary_init_variable, &
-      binary_open_file, &
-      binary_write_attribute, &
-      binary_write_variable
-
-
-CONTAINS
+    IMPLICIT NONE
+
+    INTEGER, PARAMETER ::  charlen = 100  !< maximum length of character variables
+
+    CHARACTER(LEN=*), PARAMETER ::  config_file_name = 'BINARY_TO_NETCDF_CONFIG'  !< name of config file
+    CHARACTER(LEN=*), PARAMETER ::  mode_binary = 'binary'                        !< string to select operation mode of module
+    CHARACTER(LEN=*), PARAMETER ::  file_prefix = 'BIN_'                          !< file prefix for binary files
+
+    CHARACTER(LEN=charlen)      ::  file_suffix = ''             !< file suffix added to each file name
+    CHARACTER(LEN=800)          ::  internal_error_message = ''  !< string containing the last error message
+    CHARACTER(LEN=800)          ::  temp_string                  !< dummy string
+
+    INTEGER ::  binary_file_lowest_unit = 1000  !< lowest unit number of all binary files created by this module
+    INTEGER ::  config_file_unit                !< unit number of config file
+    INTEGER ::  debug_output_unit               !< Fortran Unit Number of the debug-output file
+    INTEGER ::  global_id_in_file = -1          !< value of global ID within a file
+    INTEGER ::  master_rank                     !< master rank for tasks to be executed by single PE only
+    INTEGER ::  next_available_unit             !< next unit number available for new file
+    INTEGER ::  output_group_comm               !< MPI communicator addressing all MPI ranks which participate in output
+
+    INTEGER, DIMENSION(:), ALLOCATABLE ::  files_highest_variable_id  !< highest assigned ID of variable or dimension in a file
+
+    LOGICAL ::  binary_open_file_first_call = .TRUE.  !< true if binary_open_file routine was not called yet
+    LOGICAL ::  config_file_open = .FALSE.            !< true if config file is opened and not closed
+    LOGICAL ::  print_debug_output = .FALSE.          !< if true, debug output is printed
+
+    SAVE
+
+    PRIVATE
+
+    INTERFACE binary_init_module
+       MODULE PROCEDURE binary_init_module
+    END INTERFACE binary_init_module
+
+    INTERFACE binary_open_file
+       MODULE PROCEDURE binary_open_file
+    END INTERFACE binary_open_file
+
+    INTERFACE binary_init_dimension
+       MODULE PROCEDURE binary_init_dimension
+    END INTERFACE binary_init_dimension
+
+    INTERFACE binary_init_variable
+       MODULE PROCEDURE binary_init_variable
+    END INTERFACE binary_init_variable
+
+    INTERFACE binary_write_attribute
+       MODULE PROCEDURE binary_write_attribute
+    END INTERFACE binary_write_attribute
+
+    INTERFACE binary_stop_file_header_definition
+       MODULE PROCEDURE binary_stop_file_header_definition
+    END INTERFACE binary_stop_file_header_definition
+
+    INTERFACE binary_write_variable
+       MODULE PROCEDURE binary_write_variable
+    END INTERFACE binary_write_variable
+
+    INTERFACE binary_finalize
+       MODULE PROCEDURE binary_finalize
+    END INTERFACE binary_finalize
+
+    INTERFACE binary_get_error_message
+       MODULE PROCEDURE binary_get_error_message
+    END INTERFACE binary_get_error_message
+
+    PUBLIC &
+       binary_finalize, &
+       binary_get_error_message, &
+       binary_init_dimension, &
+       binary_stop_file_header_definition, &
+       binary_init_module, &
+       binary_init_variable, &
+       binary_open_file, &
+       binary_write_attribute, &
+       binary_write_variable
+
+
+ CONTAINS
 
 
@@ -136 +139 @@
 !> Initialize data-output module.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE binary_init_module( file_suffix_of_output_group, mpi_comm_of_output_group, &
-                               master_output_rank,                                    &
-                               program_debug_output_unit, debug_output, dom_global_id )
-
-   CHARACTER(LEN=*), INTENT(IN) ::  file_suffix_of_output_group  !> file-name suffix added to each file;
-                                                                 !> must be unique for each output group
-
-   INTEGER, INTENT(IN) ::  dom_global_id              !< global id within a file defined by DOM
-   INTEGER, INTENT(IN) ::  master_output_rank         !< MPI rank executing tasks which must be executed by a single PE
-   INTEGER, INTENT(IN) ::  mpi_comm_of_output_group   !< MPI communicator specifying the rank group participating in output
-   INTEGER, INTENT(IN) ::  program_debug_output_unit  !< file unit number for debug output
-
-   LOGICAL, INTENT(IN) ::  debug_output  !< if true, debug output is printed
-
-
-   file_suffix = file_suffix_of_output_group
-   output_group_comm = mpi_comm_of_output_group
-   master_rank = master_output_rank
-
-   debug_output_unit = program_debug_output_unit
-   print_debug_output = debug_output
-
-   global_id_in_file = dom_global_id
-
-END SUBROUTINE binary_init_module
+ SUBROUTINE binary_init_module( file_suffix_of_output_group, mpi_comm_of_output_group, &
+                                master_output_rank,                                    &
+                                program_debug_output_unit, debug_output, dom_global_id )
+
+    CHARACTER(LEN=*), INTENT(IN) ::  file_suffix_of_output_group  !> file-name suffix added to each file;
+                                                                  !> must be unique for each output group
+
+    INTEGER, INTENT(IN) ::  dom_global_id              !< global id within a file defined by DOM
+    INTEGER, INTENT(IN) ::  master_output_rank         !< MPI rank executing tasks which must be executed by a single PE
+    INTEGER, INTENT(IN) ::  mpi_comm_of_output_group   !< MPI communicator specifying the rank group participating in output
+    INTEGER, INTENT(IN) ::  program_debug_output_unit  !< file unit number for debug output
+
+    LOGICAL, INTENT(IN) ::  debug_output  !< if true, debug output is printed
+
+
+    file_suffix = file_suffix_of_output_group
+    output_group_comm = mpi_comm_of_output_group
+    master_rank = master_output_rank
+
+    debug_output_unit = program_debug_output_unit
+    print_debug_output = debug_output
+
+    global_id_in_file = dom_global_id
+
+ END SUBROUTINE binary_init_module
 
 !--------------------------------------------------------------------------------------------------!
@@ -167 +170 @@
 !> Open binary file.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE binary_open_file( mode, file_name, file_id, return_value )
-
-   CHARACTER(LEN=charlen)             ::  bin_filename = ''  !< actual name of binary file
-   CHARACTER(LEN=charlen), INTENT(IN) ::  file_name          !< name of file
-   CHARACTER(LEN=7)                   ::  my_rank_char       !< string containing value of my_rank with leading zeros
-   CHARACTER(LEN=*),       INTENT(IN) ::  mode               !< operation mode
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_open_file'  !< name of this routine
-
-   INTEGER, INTENT(OUT) ::  file_id       !< file ID
-   INTEGER              ::  my_rank       !< MPI rank of local processor
-   INTEGER              ::  nranks        !< number of MPI ranks participating in output
-   INTEGER, INTENT(OUT) ::  return_value  !< return value
-
-   INTEGER, DIMENSION(:), ALLOCATABLE ::  files_highest_variable_id_tmp  !< temporary list of given variable IDs in file
-
-   LOGICAL ::  file_exists  !< true if file to be opened already exists
-
-
-   return_value = 0
+ SUBROUTINE binary_open_file( mode, file_name, file_id, return_value )
+
+    CHARACTER(LEN=charlen)             ::  bin_filename = ''  !< actual name of binary file
+    CHARACTER(LEN=charlen), INTENT(IN) ::  file_name          !< name of file
+    CHARACTER(LEN=7)                   ::  my_rank_char       !< string containing value of my_rank with leading zeros
+    CHARACTER(LEN=*),       INTENT(IN) ::  mode               !< operation mode
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_open_file'  !< name of this routine
+
+    INTEGER, INTENT(OUT) ::  file_id       !< file ID
+    INTEGER              ::  my_rank       !< MPI rank of local processor
+    INTEGER              ::  nranks        !< number of MPI ranks participating in output
+    INTEGER, INTENT(OUT) ::  return_value  !< return value
+
+    INTEGER, DIMENSION(:), ALLOCATABLE ::  files_highest_variable_id_tmp  !< temporary list of given variable IDs in file
+
+    LOGICAL ::  file_exists  !< true if file to be opened already exists
+
+
+    return_value = 0
 
 #if defined( __parallel )
-   CALL MPI_COMM_SIZE( output_group_comm, nranks, return_value )
-   IF ( return_value == 0 )  CALL MPI_COMM_RANK( output_group_comm, my_rank, return_value )
-   IF ( return_value == 0 )  THEN
-      WRITE( my_rank_char, '("_",I6.6)' )  my_rank
-   ELSE
-      CALL internal_message( 'error', routine_name // ': MPI error' )
-   ENDIF
+    CALL MPI_COMM_SIZE( output_group_comm, nranks, return_value )
+    IF ( return_value == 0 )  CALL MPI_COMM_RANK( output_group_comm, my_rank, return_value )
+    IF ( return_value == 0 )  THEN
+       WRITE( my_rank_char, '("_",I6.6)' )  my_rank
+    ELSE
+       CALL internal_message( 'error', routine_name // ': MPI error' )
+    ENDIF
 #else
-   nranks = 1
-   my_rank = master_rank
-   WRITE( my_rank_char, '("_",I6.6)' )  my_rank
+    nranks = 1
+    my_rank = master_rank
+    WRITE( my_rank_char, '("_",I6.6)' )  my_rank
 #endif
-
-   !-- Check mode (not required, added for compatibility reasons)
-   IF ( TRIM( mode ) == mode_binary )  CONTINUE
-
-   !-- Open binary config file for combining script
-   IF ( return_value == 0  .AND.  binary_open_file_first_call )  THEN
-
-      binary_open_file_first_call = .FALSE.
-      config_file_unit = binary_file_lowest_unit
-
-      IF ( my_rank == master_rank )  THEN
-
-         !-- Remove any pre-existing file
-         INQUIRE( FILE=TRIM( config_file_name ) // TRIM( file_suffix ), &
-                  EXIST=file_exists )
-
-         IF ( file_exists )  THEN
-            CALL internal_message( 'debug', routine_name //     &
-                                   ': Remove existing file ' // &
-                                   TRIM( config_file_name ) // TRIM( file_suffix ) )
-            !> @note Fortran2008 feature 'EXECUTE_COMMAND_LINE' not yet supported by
-            !>       PGI 18.10 compiler. Hence, non-standard 'SYSTEM' call must be used
-            ! CALL EXECUTE_COMMAND_LINE(                                                &
-            !         COMMAND='rm ' // TRIM( config_file_name ) // TRIM( file_suffix ), &
-            !         WAIT=.TRUE., EXITSTAT=return_value )
-            CALL SYSTEM( 'rm ' // TRIM( config_file_name ) // TRIM( file_suffix ) )
-         ENDIF
-
-         OPEN( config_file_unit, FILE=TRIM( config_file_name ) // TRIM( file_suffix ), &
-               FORM='UNFORMATTED', STATUS='NEW', IOSTAT=return_value )
-
-         IF ( return_value == 0 )  THEN
-
-            config_file_open = .TRUE.
-
-            !-- Write some general information to config file
-            WRITE( config_file_unit )  nranks
-            WRITE( config_file_unit )  master_rank
-            WRITE( config_file_unit )  LEN( file_prefix )
-            WRITE( config_file_unit )  file_prefix
-            WRITE( config_file_unit )  charlen
-            WRITE( config_file_unit )  global_id_in_file
-
-         ELSE
-
-            return_value = 1
-            CALL internal_message( 'error', routine_name // ': could not create config' )
-
-         ENDIF
-
-      ENDIF
-
-      next_available_unit = binary_file_lowest_unit + 1
-
-   ENDIF
-
-   !-- Initialize output file: open, write header, initialize variable/dimension IDs
-   IF ( return_value == 0 )  THEN
-
-      bin_filename = file_prefix // TRIM( file_name ) // TRIM( file_suffix ) // my_rank_char
-
-      !-- Remove any pre-existing file
-      INQUIRE( FILE=TRIM( bin_filename ), EXIST=file_exists )
-
-      IF ( file_exists )  THEN
-         CALL internal_message( 'debug', routine_name // &
-                                ': remove existing file ' // TRIM( bin_filename ) )
-         !> @note Fortran2008 feature 'EXECUTE_COMMAND_LINE' not yet supported by
-         !>       PGI 18.10 compiler. Hence, non-standard 'SYSTEM' call must be used
-         ! CALL EXECUTE_COMMAND_LINE( COMMAND='rm ' // TRIM( bin_filename ), &
-         !                            WAIT=.TRUE., EXITSTAT=return_value )
-         CALL SYSTEM( 'rm ' // TRIM( bin_filename ) )
-      ENDIF
-
-      !-- Open binary file
-      CALL internal_message( 'debug', routine_name // ': open file ' // TRIM( bin_filename ) )
-      OPEN ( next_available_unit, FILE=TRIM( bin_filename ), &
-             FORM='UNFORMATTED', STATUS='NEW', IOSTAT=return_value )
-
-      IF ( return_value == 0 )  THEN
-
-         !-- Add file_name to config file
-         IF ( my_rank == master_rank )  THEN
-            WRITE( config_file_unit )  file_name
-         ENDIF
-
-         !-- Save file ID and increase next file unit number
-         file_id = next_available_unit
-         next_available_unit = next_available_unit + 1
-
-         !-- Write some meta data to file
-         WRITE ( file_id )  charlen
-         WRITE ( file_id )  file_id
-         WRITE ( file_id )  file_name
-
-         !-- Extend file-variable/dimension-ID list by 1 and set it to 0 for new file.
-         IF ( ALLOCATED( files_highest_variable_id ) )  THEN
-            ALLOCATE( files_highest_variable_id_tmp(SIZE( files_highest_variable_id )) )
-            files_highest_variable_id_tmp = files_highest_variable_id
-            DEALLOCATE( files_highest_variable_id )
-            ALLOCATE( files_highest_variable_id(binary_file_lowest_unit+1:file_id) )
-            files_highest_variable_id(:file_id-1) = files_highest_variable_id_tmp
-            DEALLOCATE( files_highest_variable_id_tmp )
-         ELSE
-            ALLOCATE( files_highest_variable_id(binary_file_lowest_unit+1:file_id) )
-         ENDIF
-         files_highest_variable_id(file_id) = 0
-
-      ELSE
-         return_value = 1
-         CALL internal_message( 'error', routine_name // &
-                                ': could not open file "' // TRIM( file_name ) // '"')
-      ENDIF
-
-   ENDIF
-
-END SUBROUTINE binary_open_file
+!
+!-- Check mode (not required, added for compatibility reasons)
+    IF ( TRIM( mode ) == mode_binary )  CONTINUE
+!
+!-- Open binary config file for combining script
+    IF ( return_value == 0  .AND.  binary_open_file_first_call )  THEN
+
+       binary_open_file_first_call = .FALSE.
+       config_file_unit = binary_file_lowest_unit
+
+       IF ( my_rank == master_rank )  THEN
+!
+!--       Remove any pre-existing file
+          INQUIRE( FILE=TRIM( config_file_name ) // TRIM( file_suffix ), &
+                   EXIST=file_exists )
+
+          IF ( file_exists )  THEN
+             CALL internal_message( 'debug', routine_name //     &
+                                    ': Remove existing file ' // &
+                                    TRIM( config_file_name ) // TRIM( file_suffix ) )
+             !> @note Fortran2008 feature 'EXECUTE_COMMAND_LINE' not yet supported by
+             !>       PGI 18.10 compiler. Hence, non-standard 'SYSTEM' call must be used
+             ! CALL EXECUTE_COMMAND_LINE(                                                &
+             !         COMMAND='rm ' // TRIM( config_file_name ) // TRIM( file_suffix ), &
+             !         WAIT=.TRUE., EXITSTAT=return_value )
+             CALL SYSTEM( 'rm ' // TRIM( config_file_name ) // TRIM( file_suffix ) )
+          ENDIF
+
+          OPEN( config_file_unit, FILE=TRIM( config_file_name ) // TRIM( file_suffix ), &
+                FORM='UNFORMATTED', STATUS='NEW', IOSTAT=return_value )
+
+          IF ( return_value == 0 )  THEN
+
+             config_file_open = .TRUE.
+!
+!--          Write some general information to config file
+             WRITE( config_file_unit )  nranks
+             WRITE( config_file_unit )  master_rank
+             WRITE( config_file_unit )  LEN( file_prefix )
+             WRITE( config_file_unit )  file_prefix
+             WRITE( config_file_unit )  charlen
+             WRITE( config_file_unit )  global_id_in_file
+
+          ELSE
+
+             return_value = 1
+             CALL internal_message( 'error', routine_name // ': could not create config' )
+
+          ENDIF
+
+       ENDIF
+
+       next_available_unit = binary_file_lowest_unit + 1
+
+    ENDIF
+!
+!-- Initialize output file: open, write header, initialize variable/dimension IDs
+    IF ( return_value == 0 )  THEN
+
+       bin_filename = file_prefix // TRIM( file_name ) // TRIM( file_suffix ) // my_rank_char
+!
+!--    Remove any pre-existing file
+       INQUIRE( FILE=TRIM( bin_filename ), EXIST=file_exists )
+
+       IF ( file_exists )  THEN
+          CALL internal_message( 'debug', routine_name // &
+                                 ': remove existing file ' // TRIM( bin_filename ) )
+          !> @note Fortran2008 feature 'EXECUTE_COMMAND_LINE' not yet supported by
+          !>       PGI 18.10 compiler. Hence, non-standard 'SYSTEM' call must be used
+          ! CALL EXECUTE_COMMAND_LINE( COMMAND='rm ' // TRIM( bin_filename ), &
+          !                            WAIT=.TRUE., EXITSTAT=return_value )
+          CALL SYSTEM( 'rm ' // TRIM( bin_filename ) )
+       ENDIF
+!
+!--    Open binary file
+       CALL internal_message( 'debug', routine_name // ': open file ' // TRIM( bin_filename ) )
+       OPEN ( next_available_unit, FILE=TRIM( bin_filename ), &
+              FORM='UNFORMATTED', STATUS='NEW', IOSTAT=return_value )
+
+       IF ( return_value == 0 )  THEN
+!
+!--       Add file_name to config file
+          IF ( my_rank == master_rank )  THEN
+             WRITE( config_file_unit )  file_name
+          ENDIF
+!
+!--       Save file ID and increase next file unit number
+          file_id = next_available_unit
+          next_available_unit = next_available_unit + 1
+!
+!--       Write some meta data to file
+          WRITE ( file_id )  charlen
+          WRITE ( file_id )  file_id
+          WRITE ( file_id )  file_name
+!
+!--       Extend file-variable/dimension-ID list by 1 and set it to 0 for new file.
+          IF ( ALLOCATED( files_highest_variable_id ) )  THEN
+             ALLOCATE( files_highest_variable_id_tmp(SIZE( files_highest_variable_id )) )
+             files_highest_variable_id_tmp = files_highest_variable_id
+             DEALLOCATE( files_highest_variable_id )
+             ALLOCATE( files_highest_variable_id(binary_file_lowest_unit+1:file_id) )
+             files_highest_variable_id(:file_id-1) = files_highest_variable_id_tmp
+             DEALLOCATE( files_highest_variable_id_tmp )
+          ELSE
+             ALLOCATE( files_highest_variable_id(binary_file_lowest_unit+1:file_id) )
+          ENDIF
+          files_highest_variable_id(file_id) = 0
+
+       ELSE
+          return_value = 1
+          CALL internal_message( 'error', routine_name // &
+                                 ': could not open file "' // TRIM( file_name ) // '"')
+       ENDIF
+
+    ENDIF
+
+ END SUBROUTINE binary_open_file
 
 !--------------------------------------------------------------------------------------------------!
@@ -324 +327 @@
 !> Write attribute to file.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE binary_write_attribute( file_id, variable_id, attribute_name, &
-              value_char, value_int8, value_int16, value_int32,          &
-              value_real32, value_real64, return_value )
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_write_attribute'  !< name of this routine
-
-   CHARACTER(LEN=charlen), INTENT(IN)           ::  attribute_name        !< name of attribute
-   CHARACTER(LEN=charlen), INTENT(IN), OPTIONAL ::  value_char  !< value of attribute
-   CHARACTER(LEN=charlen)                       ::  attribute_type        !< data type of attribute
-   CHARACTER(LEN=charlen)                       ::  output_string         !< output string
-
-   INTEGER(KIND=1), INTENT(IN), OPTIONAL ::  value_int8   !< value of attribute
-   INTEGER(KIND=2), INTENT(IN), OPTIONAL ::  value_int16  !< value of attribute
-   INTEGER(KIND=4), INTENT(IN), OPTIONAL ::  value_int32  !< value of attribute
-
-   INTEGER, INTENT(IN)  ::  file_id       !< file ID
-   INTEGER, INTENT(IN)  ::  variable_id   !< variable ID
-   INTEGER, INTENT(OUT) ::  return_value  !< return value
-
-   REAL(KIND=4), INTENT(IN), OPTIONAL ::  value_real32  !< value of attribute
-   REAL(KIND=8), INTENT(IN), OPTIONAL ::  value_real64  !< value of attribute
-
-
-   return_value = 0
-
-   CALL internal_message( 'debug', TRIM( routine_name ) // &
-                          ': write attribute ' // TRIM( attribute_name ) )
-
-   !-- Write attribute to file
-   output_string = 'attribute'
-   WRITE( file_id )  output_string
-
-   WRITE( file_id )  variable_id
-   WRITE( file_id )  attribute_name
-
-   IF ( PRESENT( value_char ) )  THEN
-      attribute_type = 'char'
-      WRITE( file_id )  attribute_type
-      WRITE( file_id )  value_char
-   ELSEIF ( PRESENT( value_int8 ) )  THEN
-      attribute_type = 'int8'
-      WRITE( file_id )  attribute_type
-      WRITE( file_id )  value_int8
-   ELSEIF ( PRESENT( value_int16 ) )  THEN
-      attribute_type = 'int16'
-      WRITE( file_id )  attribute_type
-      WRITE( file_id )  value_int16
-   ELSEIF ( PRESENT( value_int32 ) )  THEN
-      attribute_type = 'int32'
-      WRITE( file_id )  attribute_type
-      WRITE( file_id )  value_int32
-   ELSEIF ( PRESENT( value_real32 ) )  THEN
-      attribute_type = 'real32'
-      WRITE( file_id )  attribute_type
-      WRITE( file_id )  value_real32
-   ELSEIF ( PRESENT( value_real64 ) )  THEN
-      attribute_type = 'real64'
-      WRITE( file_id )  attribute_type
-      WRITE( file_id )  value_real64
-   ELSE
-      return_value = 1
-      CALL internal_message( 'error', TRIM( routine_name ) // &
-                             ': no value given for attribute "' // TRIM( attribute_name ) // '"' )
-   ENDIF
-
-END SUBROUTINE binary_write_attribute
+ SUBROUTINE binary_write_attribute( file_id, variable_id, attribute_name, &
+               value_char, value_int8, value_int16, value_int32,          &
+               value_real32, value_real64, return_value )
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_write_attribute'  !< name of this routine
+
+    CHARACTER(LEN=charlen), INTENT(IN)           ::  attribute_name        !< name of attribute
+    CHARACTER(LEN=charlen), INTENT(IN), OPTIONAL ::  value_char  !< value of attribute
+    CHARACTER(LEN=charlen)                       ::  attribute_type        !< data type of attribute
+    CHARACTER(LEN=charlen)                       ::  output_string         !< output string
+
+    INTEGER(KIND=1), INTENT(IN), OPTIONAL ::  value_int8   !< value of attribute
+    INTEGER(KIND=2), INTENT(IN), OPTIONAL ::  value_int16  !< value of attribute
+    INTEGER(KIND=4), INTENT(IN), OPTIONAL ::  value_int32  !< value of attribute
+
+    INTEGER, INTENT(IN)  ::  file_id       !< file ID
+    INTEGER, INTENT(IN)  ::  variable_id   !< variable ID
+    INTEGER, INTENT(OUT) ::  return_value  !< return value
+
+    REAL(KIND=4), INTENT(IN), OPTIONAL ::  value_real32  !< value of attribute
+    REAL(KIND=8), INTENT(IN), OPTIONAL ::  value_real64  !< value of attribute
+
+
+    return_value = 0
+
+    CALL internal_message( 'debug', TRIM( routine_name ) // &
+                           ': write attribute ' // TRIM( attribute_name ) )
+!
+!-- Write attribute to file
+    output_string = 'attribute'
+    WRITE( file_id )  output_string
+
+    WRITE( file_id )  variable_id
+    WRITE( file_id )  attribute_name
+
+    IF ( PRESENT( value_char ) )  THEN
+       attribute_type = 'char'
+       WRITE( file_id )  attribute_type
+       WRITE( file_id )  value_char
+    ELSEIF ( PRESENT( value_int8 ) )  THEN
+       attribute_type = 'int8'
+       WRITE( file_id )  attribute_type
+       WRITE( file_id )  value_int8
+    ELSEIF ( PRESENT( value_int16 ) )  THEN
+       attribute_type = 'int16'
+       WRITE( file_id )  attribute_type
+       WRITE( file_id )  value_int16
+    ELSEIF ( PRESENT( value_int32 ) )  THEN
+       attribute_type = 'int32'
+       WRITE( file_id )  attribute_type
+       WRITE( file_id )  value_int32
+    ELSEIF ( PRESENT( value_real32 ) )  THEN
+       attribute_type = 'real32'
+       WRITE( file_id )  attribute_type
+       WRITE( file_id )  value_real32
+    ELSEIF ( PRESENT( value_real64 ) )  THEN
+       attribute_type = 'real64'
+       WRITE( file_id )  attribute_type
+       WRITE( file_id )  value_real64
+    ELSE
+       return_value = 1
+       CALL internal_message( 'error', TRIM( routine_name ) // &
+                              ': no value given for attribute "' // TRIM( attribute_name ) // '"' )
+    ENDIF
+
+ END SUBROUTINE binary_write_attribute
 
 !--------------------------------------------------------------------------------------------------!
@@ -397 +400 @@
 !> and save dimension values to be later written to file.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE binary_init_dimension( mode, file_id, dimension_id, variable_id, &
-              dimension_name, dimension_type, dimension_length, return_value )
-
-   CHARACTER(LEN=charlen), INTENT(IN) ::  dimension_name  !< name of dimension
-   CHARACTER(LEN=charlen), INTENT(IN) ::  dimension_type  !< data type of dimension
-   CHARACTER(LEN=charlen)             ::  output_string   !< output string
-   CHARACTER(LEN=*),       INTENT(IN) ::  mode            !< operation mode
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_init_dimension'  !< name of this routine
-
-   INTEGER, INTENT(OUT) ::  dimension_id      !< dimension ID
-   INTEGER, INTENT(IN)  ::  dimension_length  !< length of dimension
-   INTEGER, INTENT(IN)  ::  file_id           !< file ID
-   INTEGER, INTENT(OUT) ::  return_value      !< return value
-   INTEGER, INTENT(OUT) ::  variable_id       !< variable ID
-
-
-   return_value = 0
-
-   CALL internal_message( 'debug', routine_name // ': init dimension ' // TRIM( dimension_name ) )
-
-   !-- Check mode (not required, added for compatibility reasons only)
-   IF ( TRIM( mode ) == mode_binary )  CONTINUE
-
-   !-- Assign dimension ID
-   dimension_id = files_highest_variable_id( file_id ) + 1
-   files_highest_variable_id( file_id ) = dimension_id
-
-   !-- Define dimension in file
-   output_string = 'dimension'
-   WRITE( file_id )  output_string
-   WRITE( file_id )  dimension_name
-   WRITE( file_id )  dimension_id
-   WRITE( file_id )  dimension_type
-   WRITE( file_id )  dimension_length
-
-   !-- Define variable associated with dimension
-   CALL binary_init_variable( mode, file_id, variable_id, dimension_name, dimension_type, &
-                              (/ dimension_id /), is_global=.TRUE., return_value=return_value )
-   IF ( return_value /= 0 )  THEN
-      CALL internal_message( 'error', routine_name // &
-                             ': init dimension "' // TRIM( dimension_name ) // '"' )
-   ENDIF
-
-END SUBROUTINE binary_init_dimension
+ SUBROUTINE binary_init_dimension( mode, file_id, dimension_id, variable_id, &
+               dimension_name, dimension_type, dimension_length, return_value )
+
+    CHARACTER(LEN=charlen), INTENT(IN) ::  dimension_name  !< name of dimension
+    CHARACTER(LEN=charlen), INTENT(IN) ::  dimension_type  !< data type of dimension
+    CHARACTER(LEN=charlen)             ::  output_string   !< output string
+    CHARACTER(LEN=*),       INTENT(IN) ::  mode            !< operation mode
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_init_dimension'  !< name of this routine
+
+    INTEGER, INTENT(OUT) ::  dimension_id      !< dimension ID
+    INTEGER, INTENT(IN)  ::  dimension_length  !< length of dimension
+    INTEGER, INTENT(IN)  ::  file_id           !< file ID
+    INTEGER, INTENT(OUT) ::  return_value      !< return value
+    INTEGER, INTENT(OUT) ::  variable_id       !< variable ID
+
+
+    return_value = 0
+
+    CALL internal_message( 'debug', routine_name // ': init dimension ' // TRIM( dimension_name ) )
+!
+!-- Check mode (not required, added for compatibility reasons only)
+    IF ( TRIM( mode ) == mode_binary )  CONTINUE
+!
+!-- Assign dimension ID
+    dimension_id = files_highest_variable_id( file_id ) + 1
+    files_highest_variable_id( file_id ) = dimension_id
+!
+!-- Define dimension in file
+    output_string = 'dimension'
+    WRITE( file_id )  output_string
+    WRITE( file_id )  dimension_name
+    WRITE( file_id )  dimension_id
+    WRITE( file_id )  dimension_type
+    WRITE( file_id )  dimension_length
+!
+!-- Define variable associated with dimension
+    CALL binary_init_variable( mode, file_id, variable_id, dimension_name, dimension_type, &
+                               (/ dimension_id /), is_global=.TRUE., return_value=return_value )
+    IF ( return_value /= 0 )  THEN
+       CALL internal_message( 'error', routine_name // &
+                              ': init dimension "' // TRIM( dimension_name ) // '"' )
+    ENDIF
+
+ END SUBROUTINE binary_init_dimension
 
 !--------------------------------------------------------------------------------------------------!
@@ -448 +451 @@
 !> Initialize variable. Write information of variable into file header.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE binary_init_variable( mode, file_id, variable_id, variable_name, variable_type, &
-                                 dimension_ids, is_global, return_value )
-
-   CHARACTER(LEN=charlen)             ::  output_string   !< output string
-   CHARACTER(LEN=charlen), INTENT(IN) ::  variable_name   !< name of variable
-   CHARACTER(LEN=charlen), INTENT(IN) ::  variable_type   !< data type of variable
-   CHARACTER(LEN=*),       INTENT(IN) ::  mode            !< operation mode
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_init_variable'  !< name of this routine
-
-   INTEGER, INTENT(IN)  ::  file_id       !< file ID
-   INTEGER, INTENT(OUT) ::  variable_id   !< variable ID
-   INTEGER, INTENT(OUT) ::  return_value  !< return value
-
-   INTEGER, DIMENSION(:), INTENT(IN) ::  dimension_ids  !< list of dimension IDs used by variable
-
-   LOGICAL, INTENT(IN)  ::  is_global  !< true if variable is global (same on all PE)
-
-
-   return_value = 0
-
-   CALL internal_message( 'debug', routine_name // ': init variable ' // TRIM( variable_name ) )
-
-   !-- Check mode (not required, added for compatibility reasons only)
-   IF ( TRIM( mode ) == mode_binary )  CONTINUE
-
-   !-- Check if variable is global (not required, added for compatibility reasons only)
-   IF ( is_global )  CONTINUE
-
-   !-- Assign variable ID
-   variable_id = files_highest_variable_id( file_id ) + 1
-   files_highest_variable_id( file_id ) = variable_id
-
-   !-- Write variable information in file
-   output_string = 'variable'
-   WRITE( file_id )  output_string
-   WRITE( file_id )  variable_name
-   WRITE( file_id )  variable_id
-   WRITE( file_id )  variable_type
-   WRITE( file_id )  SIZE( dimension_ids )
-   WRITE( file_id )  dimension_ids
-
-END SUBROUTINE binary_init_variable
+ SUBROUTINE binary_init_variable( mode, file_id, variable_id, variable_name, variable_type, &
+                                  dimension_ids, is_global, return_value )
+
+    CHARACTER(LEN=charlen)             ::  output_string   !< output string
+    CHARACTER(LEN=charlen), INTENT(IN) ::  variable_name   !< name of variable
+    CHARACTER(LEN=charlen), INTENT(IN) ::  variable_type   !< data type of variable
+    CHARACTER(LEN=*),       INTENT(IN) ::  mode            !< operation mode
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_init_variable'  !< name of this routine
+
+    INTEGER, INTENT(IN)  ::  file_id       !< file ID
+    INTEGER, INTENT(OUT) ::  variable_id   !< variable ID
+    INTEGER, INTENT(OUT) ::  return_value  !< return value
+
+    INTEGER, DIMENSION(:), INTENT(IN) ::  dimension_ids  !< list of dimension IDs used by variable
+
+    LOGICAL, INTENT(IN)  ::  is_global  !< true if variable is global (same on all PE)
+
+
+    return_value = 0
+
+    CALL internal_message( 'debug', routine_name // ': init variable ' // TRIM( variable_name ) )
+!
+!-- Check mode (not required, added for compatibility reasons only)
+    IF ( TRIM( mode ) == mode_binary )  CONTINUE
+!
+!-- Check if variable is global (not required, added for compatibility reasons only)
+    IF ( is_global )  CONTINUE
+!
+!-- Assign variable ID
+    variable_id = files_highest_variable_id( file_id ) + 1
+    files_highest_variable_id( file_id ) = variable_id
+!
+!-- Write variable information in file
+    output_string = 'variable'
+    WRITE( file_id )  output_string
+    WRITE( file_id )  variable_name
+    WRITE( file_id )  variable_id
+    WRITE( file_id )  variable_type
+    WRITE( file_id )  SIZE( dimension_ids )
+    WRITE( file_id )  dimension_ids
+
+ END SUBROUTINE binary_init_variable
 
 !--------------------------------------------------------------------------------------------------!
@@ -497 +500 @@
 !> Leave file definition state.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE binary_stop_file_header_definition( file_id, return_value )
-
-   CHARACTER(LEN=charlen) ::  output_string  !< output string
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_stop_file_header_definition'  !< name of this routine
-
-   INTEGER, INTENT(IN)  ::  file_id       !< file ID
-   INTEGER, INTENT(OUT) ::  return_value  !< return value
-
-
-   return_value = 0
-
-   WRITE( temp_string, * ) file_id
-   CALL internal_message( 'debug', routine_name // &
-                          ': finalize file definition (file_id=' // TRIM( temp_string ) // ')' )
-
-   output_string = '*** end file header ***'
-   WRITE( file_id )  output_string
-
-END SUBROUTINE binary_stop_file_header_definition
+ SUBROUTINE binary_stop_file_header_definition( file_id, return_value )
+
+    CHARACTER(LEN=charlen) ::  output_string  !< output string
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_stop_file_header_definition'  !< name of this routine
+
+    INTEGER, INTENT(IN)  ::  file_id       !< file ID
+    INTEGER, INTENT(OUT) ::  return_value  !< return value
+
+
+    return_value = 0
+
+    WRITE( temp_string, * ) file_id
+    CALL internal_message( 'debug', routine_name // &
+                           ': finalize file definition (file_id=' // TRIM( temp_string ) // ')' )
+
+    output_string = '*** end file header ***'
+    WRITE( file_id )  output_string
+
+ END SUBROUTINE binary_stop_file_header_definition
 
 !--------------------------------------------------------------------------------------------------!
@@ -523 +526 @@
 !> Write variable to file.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE binary_write_variable(                                                     &
-              file_id, variable_id, bounds_start, value_counts, bounds_origin,        &
-              is_global,                                                              &
-              values_int8_0d,   values_int8_1d,   values_int8_2d,   values_int8_3d,   &
-              values_int16_0d,  values_int16_1d,  values_int16_2d,  values_int16_3d,  &
-              values_int32_0d,  values_int32_1d,  values_int32_2d,  values_int32_3d,  &
-              values_intwp_0d,  values_intwp_1d,  values_intwp_2d,  values_intwp_3d,  &
-              values_real32_0d, values_real32_1d, values_real32_2d, values_real32_3d, &
-              values_real64_0d, values_real64_1d, values_real64_2d, values_real64_3d, &
-              values_realwp_0d, values_realwp_1d, values_realwp_2d, values_realwp_3d, &
-              return_value )
-
-   CHARACTER(LEN=charlen) ::  output_string  !< output string
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_write_variable'  !< name of this routine
-
-   INTEGER, INTENT(IN)  ::  file_id       !< file ID
-   INTEGER, INTENT(OUT) ::  return_value  !< return value
-   INTEGER, INTENT(IN)  ::  variable_id   !< variable ID
-
-   INTEGER, DIMENSION(:), INTENT(IN) ::  bounds_origin  !< starting index of each dimension
-   INTEGER, DIMENSION(:), INTENT(IN) ::  bounds_start   !< starting index of variable
-   INTEGER, DIMENSION(:), INTENT(IN) ::  value_counts   !< count of values along each dimension to be written
-
-   INTEGER(KIND=1), POINTER,             INTENT(IN), OPTIONAL                   ::  values_int8_0d   !< output variable
-   INTEGER(KIND=2), POINTER,             INTENT(IN), OPTIONAL                   ::  values_int16_0d  !< output variable
-   INTEGER(KIND=4), POINTER,             INTENT(IN), OPTIONAL                   ::  values_int32_0d  !< output variable
-   INTEGER(iwp),    POINTER,             INTENT(IN), OPTIONAL                   ::  values_intwp_0d  !< output variable
-   INTEGER(KIND=1), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int8_1d   !< output variable
-   INTEGER(KIND=2), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int16_1d  !< output variable
-   INTEGER(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int32_1d  !< output variable
-   INTEGER(iwp),    POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_intwp_1d  !< output variable
-   INTEGER(KIND=1), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int8_2d   !< output variable
-   INTEGER(KIND=2), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int16_2d  !< output variable
-   INTEGER(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int32_2d  !< output variable
-   INTEGER(iwp),    POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_intwp_2d  !< output variable
-   INTEGER(KIND=1), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int8_3d   !< output variable
-   INTEGER(KIND=2), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int16_3d  !< output variable
-   INTEGER(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int32_3d  !< output variable
-   INTEGER(iwp),    POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_intwp_3d  !< output variable
-
-   LOGICAL, INTENT(IN) ::  is_global  !< true if variable is global (same on all PE)
-
-   REAL(KIND=4), POINTER,             INTENT(IN), OPTIONAL                   ::  values_real32_0d  !< output variable
-   REAL(KIND=8), POINTER,             INTENT(IN), OPTIONAL                   ::  values_real64_0d  !< output variable
-   REAL(wp),     POINTER,             INTENT(IN), OPTIONAL                   ::  values_realwp_0d  !< output variable
-   REAL(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_real32_1d  !< output variable
-   REAL(KIND=8), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_real64_1d  !< output variable
-   REAL(wp),     POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_realwp_1d  !< output variable
-   REAL(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_real32_2d  !< output variable
-   REAL(KIND=8), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_real64_2d  !< output variable
-   REAL(wp),     POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_realwp_2d  !< output variable
-   REAL(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_real32_3d  !< output variable
-   REAL(KIND=8), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_real64_3d  !< output variable
-   REAL(wp),     POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_realwp_3d  !< output variable
-
-
-   return_value = 0
-
-   WRITE( temp_string, '(": write variable ",I6," into file ",I6)' ) variable_id, file_id
-   CALL internal_message( 'debug', routine_name // TRIM( temp_string ) )
-
-   IF ( is_global )  CONTINUE  ! reqired to prevent compiler warning
-
-   IF ( .NOT. ANY( value_counts == 0 ) )  THEN
-      WRITE( file_id )  variable_id
-      WRITE( file_id )  bounds_start
-      WRITE( file_id )  value_counts
-      WRITE( file_id )  bounds_origin
-      !-- 8bit integer output
-      IF ( PRESENT( values_int8_0d ) )  THEN
-         output_string = 'int8'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int8_0d
-      ELSEIF ( PRESENT( values_int8_1d ) )  THEN
-         output_string = 'int8'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int8_1d
-      ELSEIF ( PRESENT( values_int8_2d ) )  THEN
-         output_string = 'int8'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int8_2d
-      ELSEIF ( PRESENT( values_int8_3d ) )  THEN
-         output_string = 'int8'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int8_3d
-      !-- 16bit integer output
-      ELSEIF ( PRESENT( values_int16_0d ) )  THEN
-         output_string = 'int16'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int16_0d
-      ELSEIF ( PRESENT( values_int16_1d ) )  THEN
-         output_string = 'int16'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int16_1d
-      ELSEIF ( PRESENT( values_int16_2d ) )  THEN
-         output_string = 'int16'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int16_2d
-      ELSEIF ( PRESENT( values_int16_3d ) )  THEN
-         output_string = 'int16'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int16_3d
-      !-- 32bit integer output
-      ELSEIF ( PRESENT( values_int32_0d ) )  THEN
-         output_string = 'int32'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int32_0d
-      ELSEIF ( PRESENT( values_int32_1d ) )  THEN
-         output_string = 'int32'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int32_1d
-      ELSEIF ( PRESENT( values_int32_2d ) )  THEN
-         output_string = 'int32'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int32_2d
-      ELSEIF ( PRESENT( values_int32_3d ) )  THEN
-         output_string = 'int32'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_int32_3d
-      !-- working-precision integer output
-      ELSEIF ( PRESENT( values_intwp_0d ) )  THEN
-         output_string = 'intwp'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_intwp_0d
-      ELSEIF ( PRESENT( values_intwp_1d ) )  THEN
-         output_string = 'intwp'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_intwp_1d
-      ELSEIF ( PRESENT( values_intwp_2d ) )  THEN
-         output_string = 'intwp'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_intwp_2d
-      ELSEIF ( PRESENT( values_intwp_3d ) )  THEN
-         output_string = 'intwp'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_intwp_3d
-      !-- 32bit real output
-      ELSEIF ( PRESENT( values_real32_0d ) )  THEN
-         output_string = 'real32'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_real32_0d
-      ELSEIF ( PRESENT( values_real32_1d ) )  THEN
-         output_string = 'real32'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_real32_1d
-      ELSEIF ( PRESENT( values_real32_2d ) )  THEN
-         output_string = 'real32'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_real32_2d
-      ELSEIF ( PRESENT( values_real32_3d ) )  THEN
-         output_string = 'real32'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_real32_3d
-      !-- 64bit real output
-      ELSEIF ( PRESENT( values_real64_0d ) )  THEN
-         output_string = 'real64'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_real64_0d
-      ELSEIF ( PRESENT( values_real64_1d ) )  THEN
-         output_string = 'real64'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_real64_1d
-      ELSEIF ( PRESENT( values_real64_2d ) )  THEN
-         output_string = 'real64'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_real64_2d
-      ELSEIF ( PRESENT( values_real64_3d ) )  THEN
-         output_string = 'real64'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_real64_3d
-      !-- working-precision real output
-      ELSEIF ( PRESENT( values_realwp_0d ) )  THEN
-         output_string = 'realwp'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_realwp_0d
-      ELSEIF ( PRESENT( values_realwp_1d ) )  THEN
-         output_string = 'realwp'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_realwp_1d
-      ELSEIF ( PRESENT( values_realwp_2d ) )  THEN
-         output_string = 'realwp'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_realwp_2d
-      ELSEIF ( PRESENT( values_realwp_3d ) )  THEN
-         output_string = 'realwp'
-         WRITE( file_id )  output_string
-         WRITE( file_id )  values_realwp_3d
-      ELSE
-         return_value = 1
-         CALL internal_message( 'error', routine_name // ': no values given' )
-      ENDIF
-
-   ENDIF
-
-END SUBROUTINE binary_write_variable
+ SUBROUTINE binary_write_variable(                                                     &
+               file_id, variable_id, bounds_start, value_counts, bounds_origin,        &
+               is_global,                                                              &
+               values_int8_0d,   values_int8_1d,   values_int8_2d,   values_int8_3d,   &
+               values_int16_0d,  values_int16_1d,  values_int16_2d,  values_int16_3d,  &
+               values_int32_0d,  values_int32_1d,  values_int32_2d,  values_int32_3d,  &
+               values_intwp_0d,  values_intwp_1d,  values_intwp_2d,  values_intwp_3d,  &
+               values_real32_0d, values_real32_1d, values_real32_2d, values_real32_3d, &
+               values_real64_0d, values_real64_1d, values_real64_2d, values_real64_3d, &
+               values_realwp_0d, values_realwp_1d, values_realwp_2d, values_realwp_3d, &
+               return_value )
+
+    CHARACTER(LEN=charlen) ::  output_string  !< output string
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_write_variable'  !< name of this routine
+
+    INTEGER, INTENT(IN)  ::  file_id       !< file ID
+    INTEGER, INTENT(OUT) ::  return_value  !< return value
+    INTEGER, INTENT(IN)  ::  variable_id   !< variable ID
+
+    INTEGER, DIMENSION(:), INTENT(IN) ::  bounds_origin  !< starting index of each dimension
+    INTEGER, DIMENSION(:), INTENT(IN) ::  bounds_start   !< starting index of variable
+    INTEGER, DIMENSION(:), INTENT(IN) ::  value_counts   !< count of values along each dimension to be written
+
+    INTEGER(KIND=1), POINTER,             INTENT(IN), OPTIONAL                   ::  values_int8_0d   !< output variable
+    INTEGER(KIND=2), POINTER,             INTENT(IN), OPTIONAL                   ::  values_int16_0d  !< output variable
+    INTEGER(KIND=4), POINTER,             INTENT(IN), OPTIONAL                   ::  values_int32_0d  !< output variable
+    INTEGER(iwp),    POINTER,             INTENT(IN), OPTIONAL                   ::  values_intwp_0d  !< output variable
+    INTEGER(KIND=1), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int8_1d   !< output variable
+    INTEGER(KIND=2), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int16_1d  !< output variable
+    INTEGER(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int32_1d  !< output variable
+    INTEGER(iwp),    POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_intwp_1d  !< output variable
+    INTEGER(KIND=1), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int8_2d   !< output variable
+    INTEGER(KIND=2), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int16_2d  !< output variable
+    INTEGER(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int32_2d  !< output variable
+    INTEGER(iwp),    POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_intwp_2d  !< output variable
+    INTEGER(KIND=1), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int8_3d   !< output variable
+    INTEGER(KIND=2), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int16_3d  !< output variable
+    INTEGER(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int32_3d  !< output variable
+    INTEGER(iwp),    POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_intwp_3d  !< output variable
+
+    LOGICAL, INTENT(IN) ::  is_global  !< true if variable is global (same on all PE)
+
+    REAL(KIND=4), POINTER,             INTENT(IN), OPTIONAL                   ::  values_real32_0d  !< output variable
+    REAL(KIND=8), POINTER,             INTENT(IN), OPTIONAL                   ::  values_real64_0d  !< output variable
+    REAL(wp),     POINTER,             INTENT(IN), OPTIONAL                   ::  values_realwp_0d  !< output variable
+    REAL(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_real32_1d  !< output variable
+    REAL(KIND=8), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_real64_1d  !< output variable
+    REAL(wp),     POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_realwp_1d  !< output variable
+    REAL(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_real32_2d  !< output variable
+    REAL(KIND=8), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_real64_2d  !< output variable
+    REAL(wp),     POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_realwp_2d  !< output variable
+    REAL(KIND=4), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_real32_3d  !< output variable
+    REAL(KIND=8), POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_real64_3d  !< output variable
+    REAL(wp),     POINTER, CONTIGUOUS, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_realwp_3d  !< output variable
+
+
+    return_value = 0
+
+    WRITE( temp_string, '(": write variable ",I6," into file ",I6)' ) variable_id, file_id
+    CALL internal_message( 'debug', routine_name // TRIM( temp_string ) )
+
+    IF ( is_global )  CONTINUE  ! reqired to prevent compiler warning
+
+    IF ( .NOT. ANY( value_counts == 0 ) )  THEN
+       WRITE( file_id )  variable_id
+       WRITE( file_id )  bounds_start
+       WRITE( file_id )  value_counts
+       WRITE( file_id )  bounds_origin
+!
+!--    8bit integer output
+       IF ( PRESENT( values_int8_0d ) )  THEN
+          output_string = 'int8'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int8_0d
+       ELSEIF ( PRESENT( values_int8_1d ) )  THEN
+          output_string = 'int8'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int8_1d
+       ELSEIF ( PRESENT( values_int8_2d ) )  THEN
+          output_string = 'int8'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int8_2d
+       ELSEIF ( PRESENT( values_int8_3d ) )  THEN
+          output_string = 'int8'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int8_3d
+!
+!--    16bit integer output
+       ELSEIF ( PRESENT( values_int16_0d ) )  THEN
+          output_string = 'int16'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int16_0d
+       ELSEIF ( PRESENT( values_int16_1d ) )  THEN
+          output_string = 'int16'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int16_1d
+       ELSEIF ( PRESENT( values_int16_2d ) )  THEN
+          output_string = 'int16'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int16_2d
+       ELSEIF ( PRESENT( values_int16_3d ) )  THEN
+          output_string = 'int16'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int16_3d
+!
+!--    32bit integer output
+       ELSEIF ( PRESENT( values_int32_0d ) )  THEN
+          output_string = 'int32'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int32_0d
+       ELSEIF ( PRESENT( values_int32_1d ) )  THEN
+          output_string = 'int32'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int32_1d
+       ELSEIF ( PRESENT( values_int32_2d ) )  THEN
+          output_string = 'int32'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int32_2d
+       ELSEIF ( PRESENT( values_int32_3d ) )  THEN
+          output_string = 'int32'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_int32_3d
+!
+!--    working-precision integer output
+       ELSEIF ( PRESENT( values_intwp_0d ) )  THEN
+          output_string = 'intwp'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_intwp_0d
+       ELSEIF ( PRESENT( values_intwp_1d ) )  THEN
+          output_string = 'intwp'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_intwp_1d
+       ELSEIF ( PRESENT( values_intwp_2d ) )  THEN
+          output_string = 'intwp'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_intwp_2d
+       ELSEIF ( PRESENT( values_intwp_3d ) )  THEN
+          output_string = 'intwp'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_intwp_3d
+!
+!--    32bit real output
+       ELSEIF ( PRESENT( values_real32_0d ) )  THEN
+          output_string = 'real32'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_real32_0d
+       ELSEIF ( PRESENT( values_real32_1d ) )  THEN
+          output_string = 'real32'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_real32_1d
+       ELSEIF ( PRESENT( values_real32_2d ) )  THEN
+          output_string = 'real32'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_real32_2d
+       ELSEIF ( PRESENT( values_real32_3d ) )  THEN
+          output_string = 'real32'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_real32_3d
+!
+!--    64bit real output
+       ELSEIF ( PRESENT( values_real64_0d ) )  THEN
+          output_string = 'real64'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_real64_0d
+       ELSEIF ( PRESENT( values_real64_1d ) )  THEN
+          output_string = 'real64'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_real64_1d
+       ELSEIF ( PRESENT( values_real64_2d ) )  THEN
+          output_string = 'real64'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_real64_2d
+       ELSEIF ( PRESENT( values_real64_3d ) )  THEN
+          output_string = 'real64'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_real64_3d
+!
+!--    working-precision real output
+       ELSEIF ( PRESENT( values_realwp_0d ) )  THEN
+          output_string = 'realwp'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_realwp_0d
+       ELSEIF ( PRESENT( values_realwp_1d ) )  THEN
+          output_string = 'realwp'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_realwp_1d
+       ELSEIF ( PRESENT( values_realwp_2d ) )  THEN
+          output_string = 'realwp'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_realwp_2d
+       ELSEIF ( PRESENT( values_realwp_3d ) )  THEN
+          output_string = 'realwp'
+          WRITE( file_id )  output_string
+          WRITE( file_id )  values_realwp_3d
+       ELSE
+          return_value = 1
+          CALL internal_message( 'error', routine_name // ': no values given' )
+       ENDIF
+
+    ENDIF
+
+ END SUBROUTINE binary_write_variable
 
 !--------------------------------------------------------------------------------------------------!
@@ -725 +735 @@
 !> Close opened files.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE binary_finalize( file_id, return_value )
-
-   CHARACTER(LEN=charlen) ::  output_string  !< output string
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_finalize'  !< name of this routine
-
-   INTEGER, INTENT(IN)  ::  file_id       !< file ID
-   INTEGER, INTENT(OUT) ::  return_value  !< return value
-
-
-   IF ( config_file_open )  THEN
-
-      output_string = '*** end config file ***'
-      WRITE( config_file_unit )  output_string
-
-      CLOSE( config_file_unit, IOSTAT=return_value )
-
-      IF ( return_value /= 0 )  THEN
-         CALL internal_message( 'error', routine_name // ': cannot close configuration file' )
-      ELSE
-         config_file_open = .FALSE.
-      ENDIF
-
-   ELSE
-
-      return_value = 0
-
-   ENDIF
-
-   IF ( return_value == 0 )  THEN
-
-      WRITE( temp_string, * ) file_id
-      CALL internal_message( 'debug', routine_name // &
-                             ': close file (file_id=' // TRIM( temp_string ) // ')' )
-
-      CLOSE( file_id, IOSTAT=return_value )
-      IF ( return_value /= 0 )  THEN
-         WRITE( temp_string, * ) file_id
-         CALL internal_message( 'error', routine_name // &
-                                ': cannot close file (file_id=' // TRIM( temp_string ) // ')' )
-      ENDIF
-
-   ENDIF
-
-END SUBROUTINE binary_finalize
+ SUBROUTINE binary_finalize( file_id, return_value )
+
+    CHARACTER(LEN=charlen) ::  output_string  !< output string
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'binary_finalize'  !< name of this routine
+
+    INTEGER, INTENT(IN)  ::  file_id       !< file ID
+    INTEGER, INTENT(OUT) ::  return_value  !< return value
+
+
+    IF ( config_file_open )  THEN
+
+       output_string = '*** end config file ***'
+       WRITE( config_file_unit )  output_string
+
+       CLOSE( config_file_unit, IOSTAT=return_value )
+
+       IF ( return_value /= 0 )  THEN
+          CALL internal_message( 'error', routine_name // ': cannot close configuration file' )
+       ELSE
+          config_file_open = .FALSE.
+       ENDIF
+
+    ELSE
+
+       return_value = 0
+
+    ENDIF
+
+    IF ( return_value == 0 )  THEN
+
+       WRITE( temp_string, * ) file_id
+       CALL internal_message( 'debug', routine_name // &
+                              ': close file (file_id=' // TRIM( temp_string ) // ')' )
+
+       CLOSE( file_id, IOSTAT=return_value )
+       IF ( return_value /= 0 )  THEN
+          WRITE( temp_string, * ) file_id
+          CALL internal_message( 'error', routine_name // &
+                                 ': cannot close file (file_id=' // TRIM( temp_string ) // ')' )
+       ENDIF
+
+    ENDIF
+
+ END SUBROUTINE binary_finalize
 
 !--------------------------------------------------------------------------------------------------!
@@ -777 +787 @@
 !> or creating the error message string.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE internal_message( level, string )
-
-   CHARACTER(LEN=*), INTENT(IN) ::  level   !< message importance level
-   CHARACTER(LEN=*), INTENT(IN) ::  string  !< message string
-
-
-   IF ( TRIM( level ) == 'error' )  THEN
-
-      WRITE( internal_error_message, '(A,A)' ) ': ', string
-
-   ELSEIF ( TRIM( level ) == 'debug'  .AND.  print_debug_output )  THEN
-
-      WRITE( debug_output_unit, '(A,A)' ) 'DOM DEBUG: ', string
-      FLUSH( debug_output_unit )
-
-   ENDIF
-
-END SUBROUTINE internal_message
+ SUBROUTINE internal_message( level, string )
+
+    CHARACTER(LEN=*), INTENT(IN) ::  level   !< message importance level
+    CHARACTER(LEN=*), INTENT(IN) ::  string  !< message string
+
+
+    IF ( TRIM( level ) == 'error' )  THEN
+
+       WRITE( internal_error_message, '(A,A)' ) ': ', string
+
+    ELSEIF ( TRIM( level ) == 'debug'  .AND.  print_debug_output )  THEN
+
+       WRITE( debug_output_unit, '(A,A)' ) 'DOM DEBUG: ', string
+       FLUSH( debug_output_unit )
+
+    ENDIF
+
+ END SUBROUTINE internal_message
 
 !--------------------------------------------------------------------------------------------------!
@@ -801 +811 @@
 !> Return the last created error message.
 !--------------------------------------------------------------------------------------------------!
-FUNCTION binary_get_error_message() RESULT( error_message )
-
-   CHARACTER(LEN=800) ::  error_message  !< return error message to main program
-
-
-   error_message = TRIM( internal_error_message )
-   
-   internal_error_message = ''
-
-END FUNCTION binary_get_error_message
-
-END MODULE data_output_binary_module
+ FUNCTION binary_get_error_message() RESULT( error_message )
+
+    CHARACTER(LEN=800) ::  error_message  !< return error message to main program
+
+
+    error_message = TRIM( internal_error_message )
+
+    internal_error_message = ''
+
+ END FUNCTION binary_get_error_message
+
+ END MODULE data_output_binary_module

palm/trunk/SOURCE/data_output_module.f90

@@ -25 +25 @@
 ! -----------------
 ! $Id$
+! corrected indentation according to coding standard
+!
+! 4141 2019-08-05 12:24:51Z gronemeier
 ! Initial revision
 !
@@ -59 +62 @@
 !> @todo Convert variable if type of given values do not fit specified type.
 !--------------------------------------------------------------------------------------------------!
-MODULE data_output_module
-
-   USE kinds
-
-   USE data_output_netcdf4_module, &
-      ONLY: netcdf4_init_dimension, &
-            netcdf4_get_error_message, &
-            netcdf4_stop_file_header_definition, &
-            netcdf4_init_module, &
-            netcdf4_init_variable, &
-            netcdf4_finalize, &
-            netcdf4_open_file, &
-            netcdf4_write_attribute, &
-            netcdf4_write_variable
-
-   USE data_output_binary_module, &
-      ONLY: binary_finalize, &
-            binary_get_error_message, &
-            binary_init_dimension, &
-            binary_stop_file_header_definition, &
-            binary_init_module, &
-            binary_init_variable, &
-            binary_open_file, &
-            binary_write_attribute, &
-            binary_write_variable
-
-   IMPLICIT NONE
-
-   INTEGER, PARAMETER ::  charlen = 100  !< maximum length of character variables
-   INTEGER, PARAMETER ::  no_id = -1     !< default ID if no ID was assigned
-
-   TYPE attribute_type
-      CHARACTER(LEN=charlen) ::  data_type = ''  !< data type
-      CHARACTER(LEN=charlen) ::  name            !< attribute name
-      CHARACTER(LEN=charlen) ::  value_char      !< attribute value if character
-      INTEGER(KIND=1)        ::  value_int8      !< attribute value if 8bit integer
-      INTEGER(KIND=2)        ::  value_int16     !< attribute value if 16bit integer
-      INTEGER(KIND=4)        ::  value_int32     !< attribute value if 32bit integer
-      REAL(KIND=4)           ::  value_real32    !< attribute value if 32bit real
-      REAL(KIND=8)           ::  value_real64    !< attribute value if 64bit real
-   END TYPE attribute_type
-
-   TYPE variable_type
-      CHARACTER(LEN=charlen)                            ::  data_type = ''       !< data type
-      CHARACTER(LEN=charlen)                            ::  name                 !< variable name
-      INTEGER                                           ::  id = no_id           !< id within file
-      LOGICAL                                           ::  is_global = .FALSE.  !< true if global variable
-      CHARACTER(LEN=charlen), DIMENSION(:), ALLOCATABLE ::  dimension_names      !< list of dimension names used by variable
-      INTEGER,                DIMENSION(:), ALLOCATABLE ::  dimension_ids        !< list of dimension ids used by variable
-      TYPE(attribute_type),   DIMENSION(:), ALLOCATABLE ::  attributes           !< list of attributes
-   END TYPE variable_type
-
-   TYPE dimension_type
-      CHARACTER(LEN=charlen)                     ::  data_type = ''        !< data type
-      CHARACTER(LEN=charlen)                     ::  name                  !< dimension name
-      INTEGER                                    ::  id = no_id            !< dimension id within file
-      INTEGER                                    ::  length                !< length of dimension
-      INTEGER                                    ::  length_mask           !< length of masked dimension
-      INTEGER                                    ::  variable_id = no_id   !< associated variable id within file
-      LOGICAL                                    ::  is_masked = .FALSE.   !< true if masked
-      INTEGER,         DIMENSION(2)              ::  bounds                !< lower and upper bound of dimension
-      INTEGER,         DIMENSION(:), ALLOCATABLE ::  masked_indices        !< list of masked indices of dimension
-      INTEGER(KIND=1), DIMENSION(:), ALLOCATABLE ::  masked_values_int8    !< masked dimension values if 16bit integer
-      INTEGER(KIND=2), DIMENSION(:), ALLOCATABLE ::  masked_values_int16   !< masked dimension values if 16bit integer
-      INTEGER(KIND=4), DIMENSION(:), ALLOCATABLE ::  masked_values_int32   !< masked dimension values if 32bit integer
-      INTEGER(iwp),    DIMENSION(:), ALLOCATABLE ::  masked_values_intwp   !< masked dimension values if working-precision int
-      INTEGER(KIND=1), DIMENSION(:), ALLOCATABLE ::  values_int8           !< dimension values if 16bit integer
-      INTEGER(KIND=2), DIMENSION(:), ALLOCATABLE ::  values_int16          !< dimension values if 16bit integer
-      INTEGER(KIND=4), DIMENSION(:), ALLOCATABLE ::  values_int32          !< dimension values if 32bit integer
-      INTEGER(iwp),    DIMENSION(:), ALLOCATABLE ::  values_intwp          !< dimension values if working-precision integer
-      LOGICAL,         DIMENSION(:), ALLOCATABLE ::  mask                  !< mask
-      REAL(KIND=4),    DIMENSION(:), ALLOCATABLE ::  masked_values_real32  !< masked dimension values if 32bit real
-      REAL(KIND=8),    DIMENSION(:), ALLOCATABLE ::  masked_values_real64  !< masked dimension values if 64bit real
-      REAL(wp),        DIMENSION(:), ALLOCATABLE ::  masked_values_realwp  !< masked dimension values if working-precision real
-      REAL(KIND=4),    DIMENSION(:), ALLOCATABLE ::  values_real32         !< dimension values if 32bit real
-      REAL(KIND=8),    DIMENSION(:), ALLOCATABLE ::  values_real64         !< dimension values if 64bit real
-      REAL(wp),        DIMENSION(:), ALLOCATABLE ::  values_realwp         !< dimension values if working-precision real
-      TYPE(attribute_type), DIMENSION(:), ALLOCATABLE ::  attributes       !< list of attributes
-   END TYPE dimension_type
-
-   TYPE file_type
-      CHARACTER(LEN=charlen)                          ::  format = ''        !< file format
-      CHARACTER(LEN=charlen)                          ::  name = ''          !< file name
-      INTEGER                                         ::  id = no_id         !< id of file
-      LOGICAL                                         ::  is_init = .FALSE.  !< true if initialized
-      TYPE(attribute_type), DIMENSION(:), ALLOCATABLE ::  attributes         !< list of attributes
-      TYPE(dimension_type), DIMENSION(:), ALLOCATABLE ::  dimensions         !< list of dimensions
-      TYPE(variable_type),  DIMENSION(:), ALLOCATABLE ::  variables          !< list of variables
-   END TYPE file_type
-
-
-   CHARACTER(LEN=charlen) ::  output_file_suffix = ''      !< file suffix added to each file name
-   CHARACTER(LEN=800)     ::  internal_error_message = ''  !< string containing the last error message
-   CHARACTER(LEN=800)     ::  temp_string                  !< dummy string
-
-   INTEGER ::  debug_output_unit  !< Fortran Unit Number of the debug-output file
-   INTEGER ::  nfiles = 0         !< number of files
-   INTEGER ::  master_rank = 0    !< master rank for tasks to be executed by single PE only
-   INTEGER ::  output_group_comm  !< MPI communicator addressing all MPI ranks which participate in output
-
-   LOGICAL ::  print_debug_output = .FALSE.  !< if true, debug output is printed
-
-   TYPE(file_type), DIMENSION(:), ALLOCATABLE ::  files  !< file list
-
-   SAVE
-
-   PRIVATE
-
-   !> Initialize the data-output module
-   INTERFACE dom_init
-      MODULE PROCEDURE dom_init
-   END INTERFACE dom_init
-
-   !> Add files to database
-   INTERFACE dom_def_file
-      MODULE PROCEDURE dom_def_file
-   END INTERFACE dom_def_file
-
-   !> Add dimensions to database
-   INTERFACE dom_def_dim
-      MODULE PROCEDURE dom_def_dim
-   END INTERFACE dom_def_dim
-
-   !> Add variables to database
-   INTERFACE dom_def_var
-      MODULE PROCEDURE dom_def_var
-   END INTERFACE dom_def_var
-
-   !> Add attributes to database
-   INTERFACE dom_def_att
-      MODULE PROCEDURE dom_def_att_char
-      MODULE PROCEDURE dom_def_att_int8
-      MODULE PROCEDURE dom_def_att_int16
-      MODULE PROCEDURE dom_def_att_int32
-      MODULE PROCEDURE dom_def_att_real32
-      MODULE PROCEDURE dom_def_att_real64
-   END INTERFACE dom_def_att
-
-   !> Prepare for output: evaluate database and create files
-   INTERFACE dom_def_end
-      MODULE PROCEDURE dom_def_end
-   END INTERFACE dom_def_end
-
-   !> Write variables to file
-   INTERFACE dom_write_var
-      MODULE PROCEDURE dom_write_var
-   END INTERFACE dom_write_var
-
-   !> Last actions required for output befor termination
-   INTERFACE dom_finalize_output
-      MODULE PROCEDURE dom_finalize_output
-   END INTERFACE dom_finalize_output
-
-   !> Return error message
-   INTERFACE dom_get_error_message
-      MODULE PROCEDURE dom_get_error_message
-   END INTERFACE dom_get_error_message
-
-   !> Write database to debug output
-   INTERFACE dom_database_debug_output
-      MODULE PROCEDURE dom_database_debug_output
-   END INTERFACE dom_database_debug_output
-
-   PUBLIC &
-      dom_init, &
-      dom_def_file, &
-      dom_def_dim, &
-      dom_def_var, &
-      dom_def_att, &
-      dom_def_end, &
-      dom_write_var, &
-      dom_finalize_output, &
-      dom_get_error_message, &
-      dom_database_debug_output
-
-CONTAINS
+ MODULE data_output_module
+
+    USE kinds
+
+    USE data_output_netcdf4_module, &
+       ONLY: netcdf4_init_dimension, &
+             netcdf4_get_error_message, &
+             netcdf4_stop_file_header_definition, &
+             netcdf4_init_module, &
+             netcdf4_init_variable, &
+             netcdf4_finalize, &
+             netcdf4_open_file, &
+             netcdf4_write_attribute, &
+             netcdf4_write_variable
+
+    USE data_output_binary_module, &
+       ONLY: binary_finalize, &
+             binary_get_error_message, &
+             binary_init_dimension, &
+             binary_stop_file_header_definition, &
+             binary_init_module, &
+             binary_init_variable, &
+             binary_open_file, &
+             binary_write_attribute, &
+             binary_write_variable
+
+    IMPLICIT NONE
+
+    INTEGER, PARAMETER ::  charlen = 100  !< maximum length of character variables
+    INTEGER, PARAMETER ::  no_id = -1     !< default ID if no ID was assigned
+
+    TYPE attribute_type
+       CHARACTER(LEN=charlen) ::  data_type = ''  !< data type
+       CHARACTER(LEN=charlen) ::  name            !< attribute name
+       CHARACTER(LEN=charlen) ::  value_char      !< attribute value if character
+       INTEGER(KIND=1)        ::  value_int8      !< attribute value if 8bit integer
+       INTEGER(KIND=2)        ::  value_int16     !< attribute value if 16bit integer
+       INTEGER(KIND=4)        ::  value_int32     !< attribute value if 32bit integer
+       REAL(KIND=4)           ::  value_real32    !< attribute value if 32bit real
+       REAL(KIND=8)           ::  value_real64    !< attribute value if 64bit real
+    END TYPE attribute_type
+
+    TYPE variable_type
+       CHARACTER(LEN=charlen)                            ::  data_type = ''       !< data type
+       CHARACTER(LEN=charlen)                            ::  name                 !< variable name
+       INTEGER                                           ::  id = no_id           !< id within file
+       LOGICAL                                           ::  is_global = .FALSE.  !< true if global variable
+       CHARACTER(LEN=charlen), DIMENSION(:), ALLOCATABLE ::  dimension_names      !< list of dimension names used by variable
+       INTEGER,                DIMENSION(:), ALLOCATABLE ::  dimension_ids        !< list of dimension ids used by variable
+       TYPE(attribute_type),   DIMENSION(:), ALLOCATABLE ::  attributes           !< list of attributes
+    END TYPE variable_type
+
+    TYPE dimension_type
+       CHARACTER(LEN=charlen)                     ::  data_type = ''        !< data type
+       CHARACTER(LEN=charlen)                     ::  name                  !< dimension name
+       INTEGER                                    ::  id = no_id            !< dimension id within file
+       INTEGER                                    ::  length                !< length of dimension
+       INTEGER                                    ::  length_mask           !< length of masked dimension
+       INTEGER                                    ::  variable_id = no_id   !< associated variable id within file
+       LOGICAL                                    ::  is_masked = .FALSE.   !< true if masked
+       INTEGER,         DIMENSION(2)              ::  bounds                !< lower and upper bound of dimension
+       INTEGER,         DIMENSION(:), ALLOCATABLE ::  masked_indices        !< list of masked indices of dimension
+       INTEGER(KIND=1), DIMENSION(:), ALLOCATABLE ::  masked_values_int8    !< masked dimension values if 16bit integer
+       INTEGER(KIND=2), DIMENSION(:), ALLOCATABLE ::  masked_values_int16   !< masked dimension values if 16bit integer
+       INTEGER(KIND=4), DIMENSION(:), ALLOCATABLE ::  masked_values_int32   !< masked dimension values if 32bit integer
+       INTEGER(iwp),    DIMENSION(:), ALLOCATABLE ::  masked_values_intwp   !< masked dimension values if working-precision int
+       INTEGER(KIND=1), DIMENSION(:), ALLOCATABLE ::  values_int8           !< dimension values if 16bit integer
+       INTEGER(KIND=2), DIMENSION(:), ALLOCATABLE ::  values_int16          !< dimension values if 16bit integer
+       INTEGER(KIND=4), DIMENSION(:), ALLOCATABLE ::  values_int32          !< dimension values if 32bit integer
+       INTEGER(iwp),    DIMENSION(:), ALLOCATABLE ::  values_intwp          !< dimension values if working-precision integer
+       LOGICAL,         DIMENSION(:), ALLOCATABLE ::  mask                  !< mask
+       REAL(KIND=4),    DIMENSION(:), ALLOCATABLE ::  masked_values_real32  !< masked dimension values if 32bit real
+       REAL(KIND=8),    DIMENSION(:), ALLOCATABLE ::  masked_values_real64  !< masked dimension values if 64bit real
+       REAL(wp),        DIMENSION(:), ALLOCATABLE ::  masked_values_realwp  !< masked dimension values if working-precision real
+       REAL(KIND=4),    DIMENSION(:), ALLOCATABLE ::  values_real32         !< dimension values if 32bit real
+       REAL(KIND=8),    DIMENSION(:), ALLOCATABLE ::  values_real64         !< dimension values if 64bit real
+       REAL(wp),        DIMENSION(:), ALLOCATABLE ::  values_realwp         !< dimension values if working-precision real
+       TYPE(attribute_type), DIMENSION(:), ALLOCATABLE ::  attributes       !< list of attributes
+    END TYPE dimension_type
+
+    TYPE file_type
+       CHARACTER(LEN=charlen)                          ::  format = ''        !< file format
+       CHARACTER(LEN=charlen)                          ::  name = ''          !< file name
+       INTEGER                                         ::  id = no_id         !< id of file
+       LOGICAL                                         ::  is_init = .FALSE.  !< true if initialized
+       TYPE(attribute_type), DIMENSION(:), ALLOCATABLE ::  attributes         !< list of attributes
+       TYPE(dimension_type), DIMENSION(:), ALLOCATABLE ::  dimensions         !< list of dimensions
+       TYPE(variable_type),  DIMENSION(:), ALLOCATABLE ::  variables          !< list of variables
+    END TYPE file_type
+
+
+    CHARACTER(LEN=charlen) ::  output_file_suffix = ''      !< file suffix added to each file name
+    CHARACTER(LEN=800)     ::  internal_error_message = ''  !< string containing the last error message
+    CHARACTER(LEN=800)     ::  temp_string                  !< dummy string
+
+    INTEGER ::  debug_output_unit  !< Fortran Unit Number of the debug-output file
+    INTEGER ::  nfiles = 0         !< number of files
+    INTEGER ::  master_rank = 0    !< master rank for tasks to be executed by single PE only
+    INTEGER ::  output_group_comm  !< MPI communicator addressing all MPI ranks which participate in output
+
+    LOGICAL ::  print_debug_output = .FALSE.  !< if true, debug output is printed
+
+    TYPE(file_type), DIMENSION(:), ALLOCATABLE ::  files  !< file list
+
+    SAVE
+
+    PRIVATE
+
+    !> Initialize the data-output module
+    INTERFACE dom_init
+       MODULE PROCEDURE dom_init
+    END INTERFACE dom_init
+
+    !> Add files to database
+    INTERFACE dom_def_file
+       MODULE PROCEDURE dom_def_file
+    END INTERFACE dom_def_file
+
+    !> Add dimensions to database
+    INTERFACE dom_def_dim
+       MODULE PROCEDURE dom_def_dim
+    END INTERFACE dom_def_dim
+
+    !> Add variables to database
+    INTERFACE dom_def_var
+       MODULE PROCEDURE dom_def_var
+    END INTERFACE dom_def_var
+
+    !> Add attributes to database
+    INTERFACE dom_def_att
+       MODULE PROCEDURE dom_def_att_char
+       MODULE PROCEDURE dom_def_att_int8
+       MODULE PROCEDURE dom_def_att_int16
+       MODULE PROCEDURE dom_def_att_int32
+       MODULE PROCEDURE dom_def_att_real32
+       MODULE PROCEDURE dom_def_att_real64
+    END INTERFACE dom_def_att
+
+    !> Prepare for output: evaluate database and create files
+    INTERFACE dom_def_end
+       MODULE PROCEDURE dom_def_end
+    END INTERFACE dom_def_end
+
+    !> Write variables to file
+    INTERFACE dom_write_var
+       MODULE PROCEDURE dom_write_var
+    END INTERFACE dom_write_var
+
+    !> Last actions required for output befor termination
+    INTERFACE dom_finalize_output
+       MODULE PROCEDURE dom_finalize_output
+    END INTERFACE dom_finalize_output
+
+    !> Return error message
+    INTERFACE dom_get_error_message
+       MODULE PROCEDURE dom_get_error_message
+    END INTERFACE dom_get_error_message
+
+    !> Write database to debug output
+    INTERFACE dom_database_debug_output
+       MODULE PROCEDURE dom_database_debug_output
+    END INTERFACE dom_database_debug_output
+
+    PUBLIC &
+       dom_init, &
+       dom_def_file, &
+       dom_def_dim, &
+       dom_def_var, &
+       dom_def_att, &
+       dom_def_end, &
+       dom_write_var, &
+       dom_finalize_output, &
+       dom_get_error_message, &
+       dom_database_debug_output
+
+ CONTAINS
 
 
@@ -247 +250 @@
 !> prevents that multiple groups try to open and write to the same output file.
 !--------------------------------------------------------------------------------------------------!
-SUBROUTINE dom_init( file_suffix_of_output_group, mpi_comm_of_output_group, master_output_rank, &
-                     program_debug_output_unit, debug_output )
-
-   CHARACTER(LEN=*), INTENT(IN), OPTIONAL ::  file_suffix_of_output_group  !< file-name suffix added to each file;
-                                                                           !> must be unique for each output group
-
-   INTEGER, INTENT(IN), OPTIONAL ::  master_output_rank         !< MPI rank executing tasks which must
-                                                                !> be executed by a single PE only
-   INTEGER, INTENT(IN)           ::  mpi_comm_of_output_group   !< MPI communicator specifying the MPI group
-                                                                !> which participate in the output
-   INTEGER, INTENT(IN)           ::  program_debug_output_unit  !< file unit number for debug output
-
-   LOGICAL, INTENT(IN)           ::  debug_output               !< if true, debug output is printed
-
-
-   IF ( PRESENT( file_suffix_of_output_group ) )  output_file_suffix = file_suffix_of_output_group
-   IF ( PRESENT( master_output_rank ) )  master_rank = master_output_rank
-
-   output_group_comm = mpi_comm_of_output_group
-
-   debug_output_unit = program_debug_output_unit
-   print_debug_output = debug_output
-
-   CALL binary_init_module( output_file_suffix, output_group_comm, master_rank, &
-                            debug_output_unit, debug_output, no_id )
-
-   CALL netcdf4_init_module( output_file_suffix, output_group_comm, master_rank, &
-                            debug_output_unit, debug_output, no_id )
-
-END SUBROUTINE dom_init
+ SUBROUTINE dom_init( file_suffix_of_output_group, mpi_comm_of_output_group, master_output_rank, &
+                      program_debug_output_unit, debug_output )
+
+    CHARACTER(LEN=*), INTENT(IN), OPTIONAL ::  file_suffix_of_output_group  !< file-name suffix added to each file;
+                                                                            !> must be unique for each output group
+
+    INTEGER, INTENT(IN), OPTIONAL ::  master_output_rank         !< MPI rank executing tasks which must
+                                                                 !> be executed by a single PE only
+    INTEGER, INTENT(IN)           ::  mpi_comm_of_output_group   !< MPI communicator specifying the MPI group
+                                                                 !> which participate in the output
+    INTEGER, INTENT(IN)           ::  program_debug_output_unit  !< file unit number for debug output
+
+    LOGICAL, INTENT(IN)           ::  debug_output               !< if true, debug output is printed
+
+
+    IF ( PRESENT( file_suffix_of_output_group ) )  output_file_suffix = file_suffix_of_output_group
+    IF ( PRESENT( master_output_rank ) )  master_rank = master_output_rank
+
+    output_group_comm = mpi_comm_of_output_group
+
+    debug_output_unit = program_debug_output_unit
+    print_debug_output = debug_output
+
+    CALL binary_init_module( output_file_suffix, output_group_comm, master_rank, &
+                             debug_output_unit, debug_output, no_id )
+
+    CALL netcdf4_init_module( output_file_suffix, output_group_comm, master_rank, &
+                             debug_output_unit, debug_output, no_id )
+
+ END SUBROUTINE dom_init
 
 !--------------------------------------------------------------------------------------------------!
@@ -285 +288 @@
 !>   status = dom_def_file( 'my_output_file_name', 'binary' )
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_file( file_name, file_format ) RESULT( return_value )
-
-   CHARACTER(LEN=*), INTENT(IN) ::  file_name    !< name of file to be created
-   CHARACTER(LEN=*), INTENT(IN) ::  file_format  !< format of file to be created
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_file'  !< name of this routine
-
-   INTEGER ::  f             !< loop index
-   INTEGER ::  return_value  !< return value
-
-   TYPE(file_type), DIMENSION(:), ALLOCATABLE ::  files_tmp  !< temporary file list
-
-
-   return_value = 0
-
-   CALL internal_message( 'debug', routine_name // ': define file "' // TRIM( file_name ) // '"' )
-
-   !-- Allocate file list or extend it by 1
-   IF ( .NOT. ALLOCATED( files ) ) THEN
-
-      nfiles = 1
-      ALLOCATE( files(nfiles) )
-
-   ELSE
-
-      nfiles = SIZE( files )
-      !-- Check if file already exists
-      DO  f = 1, nfiles
-         IF ( files(f)%name == TRIM( file_name ) )  THEN
-            return_value = 1
-            CALL internal_message( 'error', routine_name // &
-                    ': file "' // TRIM( file_name ) // '" already exists' )
-            EXIT
-         ENDIF
-      ENDDO
-
-      !-- Extend file list
-      IF ( return_value == 0 )  THEN
-         ALLOCATE( files_tmp(nfiles) )
-         files_tmp = files
-         DEALLOCATE( files )
-         nfiles = nfiles + 1
-         ALLOCATE( files(nfiles) )
-         files(:nfiles-1) = files_tmp
-         DEALLOCATE( files_tmp )
-      ENDIF
-
-   ENDIF
-
-   !-- Add new file to database
-   IF ( return_value == 0 )  THEN
-      files(nfiles)%name = TRIM( file_name )
-      files(nfiles)%format = TRIM( file_format )
-   ENDIF
-
-END FUNCTION dom_def_file
+ FUNCTION dom_def_file( file_name, file_format ) RESULT( return_value )
+
+    CHARACTER(LEN=*), INTENT(IN) ::  file_name    !< name of file to be created
+    CHARACTER(LEN=*), INTENT(IN) ::  file_format  !< format of file to be created
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_file'  !< name of this routine
+
+    INTEGER ::  f             !< loop index
+    INTEGER ::  return_value  !< return value
+
+    TYPE(file_type), DIMENSION(:), ALLOCATABLE ::  files_tmp  !< temporary file list
+
+
+    return_value = 0
+
+    CALL internal_message( 'debug', routine_name // ': define file "' // TRIM( file_name ) // '"' )
+!
+!-- Allocate file list or extend it by 1
+    IF ( .NOT. ALLOCATED( files ) ) THEN
+
+       nfiles = 1
+       ALLOCATE( files(nfiles) )
+
+    ELSE
+
+       nfiles = SIZE( files )
+!
+!--    Check if file already exists
+       DO  f = 1, nfiles
+          IF ( files(f)%name == TRIM( file_name ) )  THEN
+             return_value = 1
+             CALL internal_message( 'error', routine_name // &
+                     ': file "' // TRIM( file_name ) // '" already exists' )
+             EXIT
+          ENDIF
+       ENDDO
+!
+!--    Extend file list
+       IF ( return_value == 0 )  THEN
+          ALLOCATE( files_tmp(nfiles) )
+          files_tmp = files
+          DEALLOCATE( files )
+          nfiles = nfiles + 1
+          ALLOCATE( files(nfiles) )
+          files(:nfiles-1) = files_tmp
+          DEALLOCATE( files_tmp )
+       ENDIF
+
+    ENDIF
+!
+!-- Add new file to database
+    IF ( return_value == 0 )  THEN
+       files(nfiles)%name = TRIM( file_name )
+       files(nfiles)%format = TRIM( file_format )
+    ENDIF
+
+ END FUNCTION dom_def_file
 
 !--------------------------------------------------------------------------------------------------!
@@ -370 +374 @@
 !> @todo Convert given values into selected output_type.
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_dim( file_name, dimension_name, output_type, bounds,        &
-                      values_int8, values_int16, values_int32, values_intwp, &
-                      values_real32, values_real64, values_realwp,           &
-                      mask ) RESULT( return_value )
-
-   CHARACTER(LEN=*), INTENT(IN) ::  file_name       !< name of file
-   CHARACTER(LEN=*), INTENT(IN) ::  dimension_name  !< name of dimension
-   CHARACTER(LEN=*), INTENT(IN) ::  output_type     !< data type of dimension variable in output file
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_dim'  !< name of this routine
-
-   INTEGER ::  d             !< loop index
-   INTEGER ::  f             !< loop index
-   INTEGER ::  i             !< loop index
-   INTEGER ::  j             !< loop index
-   INTEGER ::  ndims         !< number of dimensions in file
-   INTEGER ::  return_value  !< return value
-
-   INTEGER,         DIMENSION(:), INTENT(IN)           ::  bounds         !< lower and upper bound of dimension variable
-   INTEGER(KIND=1), DIMENSION(:), INTENT(IN), OPTIONAL ::  values_int8    !< values of dimension
-   INTEGER(KIND=2), DIMENSION(:), INTENT(IN), OPTIONAL ::  values_int16   !< values of dimension
-   INTEGER(KIND=4), DIMENSION(:), INTENT(IN), OPTIONAL ::  values_int32   !< values of dimension
-   INTEGER(iwp),    DIMENSION(:), INTENT(IN), OPTIONAL ::  values_intwp   !< values of dimension
-
-   LOGICAL,         DIMENSION(:), INTENT(IN), OPTIONAL ::  mask           !< mask of dimesion
-
-   REAL(KIND=4),    DIMENSION(:), INTENT(IN), OPTIONAL ::  values_real32  !< values of dimension
-   REAL(KIND=8),    DIMENSION(:), INTENT(IN), OPTIONAL ::  values_real64  !< values of dimension
-   REAL(wp),        DIMENSION(:), INTENT(IN), OPTIONAL ::  values_realwp  !< values of dimension
-
-   TYPE(dimension_type)                            ::  dimension       !< new dimension
-   TYPE(dimension_type), DIMENSION(:), ALLOCATABLE ::  dimensions_tmp  !< temporary dimension list
-
-
-   return_value = 0
-
-   CALL internal_message( 'debug', routine_name //                    &
-                          ': define dimension ' //                    &
-                          '(dimension "' // TRIM( dimension_name ) // &
-                          '", file "' // TRIM( file_name ) // '")' )
-
-   dimension%name      = TRIM( dimension_name )
-   dimension%data_type = TRIM( output_type )
-
-   !-- Check dimension bounds and allocate dimension according to bounds
-   IF ( SIZE( bounds ) == 1 )  THEN
-
-      !-- Dimension has only lower bound, which means it changes its size
-      !-- during simulation.
-      !-- Set length to -1 as indicator.
-      dimension%bounds(:) = bounds(1)
-      dimension%length    = -1
-
-      IF ( PRESENT( mask ) )  THEN
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                      &
-                                ': unlimited dimensions cannot be masked ' // &
-                                '(dimension "' // TRIM( dimension_name ) //   &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-
-   ELSEIF ( SIZE( bounds ) == 2 )  THEN
-
-      dimension%bounds = bounds
-      dimension%length = bounds(2) - bounds(1) + 1
-
-      !-- Save dimension values
-      IF ( PRESENT( values_int8 ) )  THEN
-         ALLOCATE( dimension%values_int8(dimension%bounds(1):dimension%bounds(2)) )
-         IF ( SIZE( values_int8 ) == dimension%length )  THEN
-            dimension%values_int8 = values_int8
-         ELSEIF ( SIZE( values_int8 ) == 1 )  THEN
-            dimension%values_int8(:) = values_int8(1)
-         ELSE
-            return_value = 2
-         ENDIF
-      ELSEIF( PRESENT( values_int16 ) )  THEN
-         ALLOCATE( dimension%values_int16(dimension%bounds(1):dimension%bounds(2)) )
-         IF ( SIZE( values_int16 ) == dimension%length )  THEN
-            dimension%values_int16 = values_int16
-         ELSEIF ( SIZE( values_int16 ) == 1 )  THEN
-            dimension%values_int16(:) = values_int16(1)
-         ELSE
-            return_value = 2
-         ENDIF
-      ELSEIF( PRESENT( values_int32 ) )  THEN
-         ALLOCATE( dimension%values_int32(dimension%bounds(1):dimension%bounds(2)) )
-         IF ( SIZE( values_int32 ) == dimension%length )  THEN
-            dimension%values_int32 = values_int32
-         ELSEIF ( SIZE( values_int32 ) == 1 )  THEN
-            dimension%values_int32(:) = values_int32(1)
-         ELSE
-            return_value = 2
-         ENDIF
-      ELSEIF( PRESENT( values_intwp ) )  THEN
-         ALLOCATE( dimension%values_intwp(dimension%bounds(1):dimension%bounds(2)) )
-         IF ( SIZE( values_intwp ) == dimension%length )  THEN
-            dimension%values_intwp = values_intwp
-         ELSEIF ( SIZE( values_intwp ) == 1 )  THEN
-            dimension%values_intwp(:) = values_intwp(1)
-         ELSE
-            return_value = 2
-         ENDIF
-      ELSEIF( PRESENT( values_real32 ) )  THEN
-         ALLOCATE( dimension%values_real32(dimension%bounds(1):dimension%bounds(2)) )
-         IF ( SIZE( values_real32 ) == dimension%length )  THEN
-            dimension%values_real32 = values_real32
-         ELSEIF ( SIZE( values_real32 ) == 1 )  THEN
-            dimension%values_real32(:) = values_real32(1)
-         ELSE
-            return_value = 2
-         ENDIF
-      ELSEIF( PRESENT( values_real64 ) )  THEN
-         ALLOCATE( dimension%values_real64(dimension%bounds(1):dimension%bounds(2)) )
-         IF ( SIZE( values_real64 ) == dimension%length )  THEN
-            dimension%values_real64 = values_real64
-         ELSEIF ( SIZE( values_real64 ) == 1 )  THEN
-            dimension%values_real64(:) = values_real64(1)
-         ELSE
-            return_value = 2
-         ENDIF
-      ELSEIF( PRESENT( values_realwp ) )  THEN
-         ALLOCATE( dimension%values_realwp(dimension%bounds(1):dimension%bounds(2)) )
-         IF ( SIZE( values_realwp ) == dimension%length )  THEN
-            dimension%values_realwp = values_realwp
-         ELSEIF ( SIZE( values_realwp ) == 1 )  THEN
-            dimension%values_realwp(:) = values_realwp(1)
-         ELSE
-            return_value = 2
-         ENDIF
-      ELSE
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                    &
-                                ': no values given ' //                     &
-                                '(dimension "' // TRIM( dimension_name ) // &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-
-      IF ( return_value == 2 )  THEN
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                               &
-                                ': number of values and given bounds do not match ' // &
-                                '(dimension "' // TRIM( dimension_name ) //            &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-
-      !-- Initialize mask
-      IF ( PRESENT( mask )  .AND.  return_value == 0 )  THEN
-
-         IF ( dimension%length == SIZE( mask ) )  THEN
-
-            IF ( ALL( mask ) )  THEN
-
-               CALL internal_message( 'debug', routine_name //                              &
-                                      ': mask contains only TRUE values. Ignoring mask ' // &
-                                      '(dimension "' // TRIM( dimension_name ) //           &
-                                      '", file "' // TRIM( file_name ) // '")!' )
-
-            ELSE
-
-               dimension%is_masked = .TRUE.
-               dimension%length_mask = COUNT( mask )
-
-               ALLOCATE( dimension%mask(dimension%bounds(1):dimension%bounds(2)) )
-               ALLOCATE( dimension%masked_indices(0:dimension%length_mask-1) )
-
-               dimension%mask = mask
-
-               !-- Save masked positions and masked values
-               IF ( ALLOCATED( dimension%values_int8 ) )  THEN
-
-                  ALLOCATE( dimension%masked_values_int8(0:dimension%length_mask-1) )
-                  j = 0
-                  DO  i = dimension%bounds(1), dimension%bounds(2)
-                     IF ( dimension%mask(i) )  THEN
-                        dimension%masked_values_int8(j) = dimension%values_int8(i)
-                        dimension%masked_indices(j) = i
-                        j = j + 1
-                     ENDIF
-                  ENDDO
-
-               ELSEIF ( ALLOCATED( dimension%values_int16 ) )  THEN
-
-                  ALLOCATE( dimension%masked_values_int16(0:dimension%length_mask-1) )
-                  j = 0
-                  DO  i = dimension%bounds(1), dimension%bounds(2)
-                     IF ( dimension%mask(i) )  THEN
-                        dimension%masked_values_int16(j) = dimension%values_int16(i)
-                        dimension%masked_indices(j) = i
-                        j = j + 1
-                     ENDIF
-                  ENDDO
-
-               ELSEIF ( ALLOCATED( dimension%values_int32 ) )  THEN
-
-                  ALLOCATE( dimension%masked_values_int32(0:dimension%length_mask-1) )
-                  j = 0
-                  DO  i =dimension%bounds(1), dimension%bounds(2)
-                     IF ( dimension%mask(i) )  THEN
-                        dimension%masked_values_int32(j) = dimension%values_int32(i)
-                        dimension%masked_indices(j) = i
-                        j = j + 1
-                     ENDIF
-                  ENDDO
-
-               ELSEIF ( ALLOCATED( dimension%values_intwp ) )  THEN
-
-                  ALLOCATE( dimension%masked_values_intwp(0:dimension%length_mask-1) )
-                  j = 0
-                  DO  i = dimension%bounds(1), dimension%bounds(2)
-                     IF ( dimension%mask(i) )  THEN
-                        dimension%masked_values_intwp(j) = dimension%values_intwp(i)
-                        dimension%masked_indices(j) = i
-                        j = j + 1
-                     ENDIF
-                  ENDDO
-
-               ELSEIF ( ALLOCATED( dimension%values_real32 ) )  THEN
-
-                  ALLOCATE( dimension%masked_values_real32(0:dimension%length_mask-1) )
-                  j = 0
-                  DO  i = dimension%bounds(1), dimension%bounds(2)
-                     IF ( dimension%mask(i) )  THEN
-                        dimension%masked_values_real32(j) = dimension%values_real32(i)
-                        dimension%masked_indices(j) = i
-                        j = j + 1
-                     ENDIF
-                  ENDDO
-
-               ELSEIF ( ALLOCATED(dimension%values_real64) )  THEN
-
-                  ALLOCATE( dimension%masked_values_real64(0:dimension%length_mask-1) )
-                  j = 0
-                  DO  i = dimension%bounds(1), dimension%bounds(2)
-                     IF ( dimension%mask(i) )  THEN
-                        dimension%masked_values_real64(j) = dimension%values_real64(i)
-                        dimension%masked_indices(j) = i
-                        j = j + 1
-                     ENDIF
-                  ENDDO
-
-               ELSEIF ( ALLOCATED(dimension%values_realwp) )  THEN
-
-                  ALLOCATE( dimension%masked_values_realwp(0:dimension%length_mask-1) )
-                  j = 0
-                  DO  i = dimension%bounds(1), dimension%bounds(2)
-                     IF ( dimension%mask(i) )  THEN
-                        dimension%masked_values_realwp(j) = dimension%values_realwp(i)
-                        dimension%masked_indices(j) = i
-                        j = j + 1
-                     ENDIF
-                  ENDDO
-
-               ENDIF
-
-            ENDIF  ! if not all mask = true
-
-         ELSE
-            return_value = 1
-            CALL internal_message( 'error', routine_name //                           &
-                                   ': size of mask and given bounds do not match ' // &
-                                   '(dimension "' // TRIM( dimension_name ) //        &
-                                   '", file "' // TRIM( file_name ) // '")!' )
-         ENDIF
-
-      ENDIF
-
-   ELSE
-
-      return_value = 1
-      CALL internal_message( 'error', routine_name //                                       &
-                             ': at least one but no more than two bounds must be given ' // &
-                             '(dimension "' // TRIM( dimension_name ) //                    &
-                             '", file "' // TRIM( file_name ) // '")!' )
-
-   ENDIF
-
-   !-- Add dimension to database
-   IF ( return_value == 0 )  THEN
-
-      DO  f = 1, nfiles
-
-         IF ( TRIM( file_name ) == files(f)%name )  THEN
-
-            IF ( files(f)%is_init )  THEN
-
-               return_value = 1
-               CALL internal_message( 'error', routine_name //                      &
-                                      ': file already initialized. ' //             &
-                                      'No further dimension definition allowed ' // &
-                                      '(dimension "' // TRIM( dimension_name ) //   &
-                                      '", file "' // TRIM( file_name ) // '")!' )
-               EXIT
-
-            ELSEIF ( .NOT. ALLOCATED( files(f)%dimensions ) )  THEN
-
-               ndims = 1
-               ALLOCATE( files(f)%dimensions(ndims) )
-
-            ELSE
-
-               !-- Check if any variable of the same name as the new dimension is already defined
-               IF ( ALLOCATED( files(f)%variables ) )  THEN
-                  DO  i = 1, SIZE( files(f)%variables )
-                     IF ( files(f)%variables(i)%name == dimension%name )  THEN
-                        return_value = 1
-                        CALL internal_message( 'error', routine_name //                    &
-                                ': file already has a variable of this name defined. ' //  &
-                                'Defining a dimension of the same name is not allowed ' // &
-                                '(dimension "' // TRIM( dimension_name ) //                &
-                                '", file "' // TRIM( file_name ) // '")!' )
-                        EXIT
-                     ENDIF
-                  ENDDO
-               ENDIF
-
-               IF ( return_value == 0 )  THEN
-                  !-- Check if dimension already exists in file
-                  ndims = SIZE( files(f)%dimensions )
-
-                  DO  d = 1, ndims
-                     IF ( files(f)%dimensions(d)%name == dimension%name )  THEN
-                        return_value = 1
-                        CALL internal_message( 'error', routine_name //     &
-                                ': dimension already exists in file ' //    &
-                                '(dimension "' // TRIM( dimension_name ) // &
-                                '", file "' // TRIM( file_name ) // '")!' )
-                        EXIT
-                     ENDIF
-                  ENDDO
-
-                  !-- Extend dimension list
-                  IF ( return_value == 0 )  THEN
-                     ALLOCATE( dimensions_tmp(ndims) )
-                     dimensions_tmp = files(f)%dimensions
-                     DEALLOCATE( files(f)%dimensions )
-                     ndims = ndims + 1
-                     ALLOCATE( files(f)%dimensions(ndims) )
-                     files(f)%dimensions(:ndims-1) = dimensions_tmp
-                     DEALLOCATE( dimensions_tmp )
-                  ENDIF
-               ENDIF
-
-            ENDIF
-
-            !-- Add new dimension to database
-            IF ( return_value == 0 )  files(f)%dimensions(ndims) = dimension
-
-            EXIT
-
-         ENDIF
-      ENDDO
-
-      IF ( f > nfiles )  THEN
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                                     &
-                                ': file not found (dimension "' // TRIM( dimension_name ) // &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-
-   ENDIF
-
-END FUNCTION dom_def_dim
+ FUNCTION dom_def_dim( file_name, dimension_name, output_type, bounds,        &
+                       values_int8, values_int16, values_int32, values_intwp, &
+                       values_real32, values_real64, values_realwp,           &
+                       mask ) RESULT( return_value )
+
+    CHARACTER(LEN=*), INTENT(IN) ::  file_name       !< name of file
+    CHARACTER(LEN=*), INTENT(IN) ::  dimension_name  !< name of dimension
+    CHARACTER(LEN=*), INTENT(IN) ::  output_type     !< data type of dimension variable in output file
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_dim'  !< name of this routine
+
+    INTEGER ::  d             !< loop index
+    INTEGER ::  f             !< loop index
+    INTEGER ::  i             !< loop index
+    INTEGER ::  j             !< loop index
+    INTEGER ::  ndims         !< number of dimensions in file
+    INTEGER ::  return_value  !< return value
+
+    INTEGER,         DIMENSION(:), INTENT(IN)           ::  bounds         !< lower and upper bound of dimension variable
+    INTEGER(KIND=1), DIMENSION(:), INTENT(IN), OPTIONAL ::  values_int8    !< values of dimension
+    INTEGER(KIND=2), DIMENSION(:), INTENT(IN), OPTIONAL ::  values_int16   !< values of dimension
+    INTEGER(KIND=4), DIMENSION(:), INTENT(IN), OPTIONAL ::  values_int32   !< values of dimension
+    INTEGER(iwp),    DIMENSION(:), INTENT(IN), OPTIONAL ::  values_intwp   !< values of dimension
+
+    LOGICAL,         DIMENSION(:), INTENT(IN), OPTIONAL ::  mask           !< mask of dimesion
+
+    REAL(KIND=4),    DIMENSION(:), INTENT(IN), OPTIONAL ::  values_real32  !< values of dimension
+    REAL(KIND=8),    DIMENSION(:), INTENT(IN), OPTIONAL ::  values_real64  !< values of dimension
+    REAL(wp),        DIMENSION(:), INTENT(IN), OPTIONAL ::  values_realwp  !< values of dimension
+
+    TYPE(dimension_type)                            ::  dimension       !< new dimension
+    TYPE(dimension_type), DIMENSION(:), ALLOCATABLE ::  dimensions_tmp  !< temporary dimension list
+
+
+    return_value = 0
+
+    CALL internal_message( 'debug', routine_name //                    &
+                           ': define dimension ' //                    &
+                           '(dimension "' // TRIM( dimension_name ) // &
+                           '", file "' // TRIM( file_name ) // '")' )
+
+    dimension%name      = TRIM( dimension_name )
+    dimension%data_type = TRIM( output_type )
+!
+!-- Check dimension bounds and allocate dimension according to bounds
+    IF ( SIZE( bounds ) == 1 )  THEN
+!
+!--    Dimension has only lower bound, which means it changes its size
+!--    during simulation.
+!--    Set length to -1 as indicator.
+       dimension%bounds(:) = bounds(1)
+       dimension%length    = -1
+
+       IF ( PRESENT( mask ) )  THEN
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                      &
+                                 ': unlimited dimensions cannot be masked ' // &
+                                 '(dimension "' // TRIM( dimension_name ) //   &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+
+    ELSEIF ( SIZE( bounds ) == 2 )  THEN
+
+       dimension%bounds = bounds
+       dimension%length = bounds(2) - bounds(1) + 1
+!
+!--    Save dimension values
+       IF ( PRESENT( values_int8 ) )  THEN
+          ALLOCATE( dimension%values_int8(dimension%bounds(1):dimension%bounds(2)) )
+          IF ( SIZE( values_int8 ) == dimension%length )  THEN
+             dimension%values_int8 = values_int8
+          ELSEIF ( SIZE( values_int8 ) == 1 )  THEN
+             dimension%values_int8(:) = values_int8(1)
+          ELSE
+             return_value = 2
+          ENDIF
+       ELSEIF( PRESENT( values_int16 ) )  THEN
+          ALLOCATE( dimension%values_int16(dimension%bounds(1):dimension%bounds(2)) )
+          IF ( SIZE( values_int16 ) == dimension%length )  THEN
+             dimension%values_int16 = values_int16
+          ELSEIF ( SIZE( values_int16 ) == 1 )  THEN
+             dimension%values_int16(:) = values_int16(1)
+          ELSE
+             return_value = 2
+          ENDIF
+       ELSEIF( PRESENT( values_int32 ) )  THEN
+          ALLOCATE( dimension%values_int32(dimension%bounds(1):dimension%bounds(2)) )
+          IF ( SIZE( values_int32 ) == dimension%length )  THEN
+             dimension%values_int32 = values_int32
+          ELSEIF ( SIZE( values_int32 ) == 1 )  THEN
+             dimension%values_int32(:) = values_int32(1)
+          ELSE
+             return_value = 2
+          ENDIF
+       ELSEIF( PRESENT( values_intwp ) )  THEN
+          ALLOCATE( dimension%values_intwp(dimension%bounds(1):dimension%bounds(2)) )
+          IF ( SIZE( values_intwp ) == dimension%length )  THEN
+             dimension%values_intwp = values_intwp
+          ELSEIF ( SIZE( values_intwp ) == 1 )  THEN
+             dimension%values_intwp(:) = values_intwp(1)
+          ELSE
+             return_value = 2
+          ENDIF
+       ELSEIF( PRESENT( values_real32 ) )  THEN
+          ALLOCATE( dimension%values_real32(dimension%bounds(1):dimension%bounds(2)) )
+          IF ( SIZE( values_real32 ) == dimension%length )  THEN
+             dimension%values_real32 = values_real32
+          ELSEIF ( SIZE( values_real32 ) == 1 )  THEN
+             dimension%values_real32(:) = values_real32(1)
+          ELSE
+             return_value = 2
+          ENDIF
+       ELSEIF( PRESENT( values_real64 ) )  THEN
+          ALLOCATE( dimension%values_real64(dimension%bounds(1):dimension%bounds(2)) )
+          IF ( SIZE( values_real64 ) == dimension%length )  THEN
+             dimension%values_real64 = values_real64
+          ELSEIF ( SIZE( values_real64 ) == 1 )  THEN
+             dimension%values_real64(:) = values_real64(1)
+          ELSE
+             return_value = 2
+          ENDIF
+       ELSEIF( PRESENT( values_realwp ) )  THEN
+          ALLOCATE( dimension%values_realwp(dimension%bounds(1):dimension%bounds(2)) )
+          IF ( SIZE( values_realwp ) == dimension%length )  THEN
+             dimension%values_realwp = values_realwp
+          ELSEIF ( SIZE( values_realwp ) == 1 )  THEN
+             dimension%values_realwp(:) = values_realwp(1)
+          ELSE
+             return_value = 2
+          ENDIF
+       ELSE
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                    &
+                                 ': no values given ' //                     &
+                                 '(dimension "' // TRIM( dimension_name ) // &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+
+       IF ( return_value == 2 )  THEN
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                               &
+                                 ': number of values and given bounds do not match ' // &
+                                 '(dimension "' // TRIM( dimension_name ) //            &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+!
+!--    Initialize mask
+       IF ( PRESENT( mask )  .AND.  return_value == 0 )  THEN
+
+          IF ( dimension%length == SIZE( mask ) )  THEN
+
+             IF ( ALL( mask ) )  THEN
+
+                CALL internal_message( 'debug', routine_name //                              &
+                                       ': mask contains only TRUE values. Ignoring mask ' // &
+                                       '(dimension "' // TRIM( dimension_name ) //           &
+                                       '", file "' // TRIM( file_name ) // '")!' )
+
+             ELSE
+
+                dimension%is_masked = .TRUE.
+                dimension%length_mask = COUNT( mask )
+
+                ALLOCATE( dimension%mask(dimension%bounds(1):dimension%bounds(2)) )
+                ALLOCATE( dimension%masked_indices(0:dimension%length_mask-1) )
+
+                dimension%mask = mask
+!
+!--             Save masked positions and masked values
+                IF ( ALLOCATED( dimension%values_int8 ) )  THEN
+
+                   ALLOCATE( dimension%masked_values_int8(0:dimension%length_mask-1) )
+                   j = 0
+                   DO  i = dimension%bounds(1), dimension%bounds(2)
+                      IF ( dimension%mask(i) )  THEN
+                         dimension%masked_values_int8(j) = dimension%values_int8(i)
+                         dimension%masked_indices(j) = i
+                         j = j + 1
+                      ENDIF
+                   ENDDO
+
+                ELSEIF ( ALLOCATED( dimension%values_int16 ) )  THEN
+
+                   ALLOCATE( dimension%masked_values_int16(0:dimension%length_mask-1) )
+                   j = 0
+                   DO  i = dimension%bounds(1), dimension%bounds(2)
+                      IF ( dimension%mask(i) )  THEN
+                         dimension%masked_values_int16(j) = dimension%values_int16(i)
+                         dimension%masked_indices(j) = i
+                         j = j + 1
+                      ENDIF
+                   ENDDO
+
+                ELSEIF ( ALLOCATED( dimension%values_int32 ) )  THEN
+
+                   ALLOCATE( dimension%masked_values_int32(0:dimension%length_mask-1) )
+                   j = 0
+                   DO  i =dimension%bounds(1), dimension%bounds(2)
+                      IF ( dimension%mask(i) )  THEN
+                         dimension%masked_values_int32(j) = dimension%values_int32(i)
+                         dimension%masked_indices(j) = i
+                         j = j + 1
+                      ENDIF
+                   ENDDO
+
+                ELSEIF ( ALLOCATED( dimension%values_intwp ) )  THEN
+
+                   ALLOCATE( dimension%masked_values_intwp(0:dimension%length_mask-1) )
+                   j = 0
+                   DO  i = dimension%bounds(1), dimension%bounds(2)
+                      IF ( dimension%mask(i) )  THEN
+                         dimension%masked_values_intwp(j) = dimension%values_intwp(i)
+                         dimension%masked_indices(j) = i
+                         j = j + 1
+                      ENDIF
+                   ENDDO
+
+                ELSEIF ( ALLOCATED( dimension%values_real32 ) )  THEN
+
+                   ALLOCATE( dimension%masked_values_real32(0:dimension%length_mask-1) )
+                   j = 0
+                   DO  i = dimension%bounds(1), dimension%bounds(2)
+                      IF ( dimension%mask(i) )  THEN
+                         dimension%masked_values_real32(j) = dimension%values_real32(i)
+                         dimension%masked_indices(j) = i
+                         j = j + 1
+                      ENDIF
+                   ENDDO
+
+                ELSEIF ( ALLOCATED(dimension%values_real64) )  THEN
+
+                   ALLOCATE( dimension%masked_values_real64(0:dimension%length_mask-1) )
+                   j = 0
+                   DO  i = dimension%bounds(1), dimension%bounds(2)
+                      IF ( dimension%mask(i) )  THEN
+                         dimension%masked_values_real64(j) = dimension%values_real64(i)
+                         dimension%masked_indices(j) = i
+                         j = j + 1
+                      ENDIF
+                   ENDDO
+
+                ELSEIF ( ALLOCATED(dimension%values_realwp) )  THEN
+
+                   ALLOCATE( dimension%masked_values_realwp(0:dimension%length_mask-1) )
+                   j = 0
+                   DO  i = dimension%bounds(1), dimension%bounds(2)
+                      IF ( dimension%mask(i) )  THEN
+                         dimension%masked_values_realwp(j) = dimension%values_realwp(i)
+                         dimension%masked_indices(j) = i
+                         j = j + 1
+                      ENDIF
+                   ENDDO
+
+                ENDIF
+
+             ENDIF  ! if not all mask = true
+
+          ELSE
+             return_value = 1
+             CALL internal_message( 'error', routine_name //                           &
+                                    ': size of mask and given bounds do not match ' // &
+                                    '(dimension "' // TRIM( dimension_name ) //        &
+                                    '", file "' // TRIM( file_name ) // '")!' )
+          ENDIF
+
+       ENDIF
+
+    ELSE
+
+       return_value = 1
+       CALL internal_message( 'error', routine_name //                                       &
+                              ': at least one but no more than two bounds must be given ' // &
+                              '(dimension "' // TRIM( dimension_name ) //                    &
+                              '", file "' // TRIM( file_name ) // '")!' )
+
+    ENDIF
+!
+!-- Add dimension to database
+    IF ( return_value == 0 )  THEN
+
+       DO  f = 1, nfiles
+
+          IF ( TRIM( file_name ) == files(f)%name )  THEN
+
+             IF ( files(f)%is_init )  THEN
+
+                return_value = 1
+                CALL internal_message( 'error', routine_name //                      &
+                                       ': file already initialized. ' //             &
+                                       'No further dimension definition allowed ' // &
+                                       '(dimension "' // TRIM( dimension_name ) //   &
+                                       '", file "' // TRIM( file_name ) // '")!' )
+                EXIT
+
+             ELSEIF ( .NOT. ALLOCATED( files(f)%dimensions ) )  THEN
+
+                ndims = 1
+                ALLOCATE( files(f)%dimensions(ndims) )
+
+             ELSE
+!
+!--             Check if any variable of the same name as the new dimension is already defined
+                IF ( ALLOCATED( files(f)%variables ) )  THEN
+                   DO  i = 1, SIZE( files(f)%variables )
+                      IF ( files(f)%variables(i)%name == dimension%name )  THEN
+                         return_value = 1
+                         CALL internal_message( 'error', routine_name //                    &
+                                 ': file already has a variable of this name defined. ' //  &
+                                 'Defining a dimension of the same name is not allowed ' // &
+                                 '(dimension "' // TRIM( dimension_name ) //                &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+                         EXIT
+                      ENDIF
+                   ENDDO
+                ENDIF
+
+                IF ( return_value == 0 )  THEN
+!
+!--                Check if dimension already exists in file
+                   ndims = SIZE( files(f)%dimensions )
+
+                   DO  d = 1, ndims
+                      IF ( files(f)%dimensions(d)%name == dimension%name )  THEN
+                         return_value = 1
+                         CALL internal_message( 'error', routine_name //     &
+                                 ': dimension already exists in file ' //    &
+                                 '(dimension "' // TRIM( dimension_name ) // &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+                         EXIT
+                      ENDIF
+                   ENDDO
+!
+!--                Extend dimension list
+                   IF ( return_value == 0 )  THEN
+                      ALLOCATE( dimensions_tmp(ndims) )
+                      dimensions_tmp = files(f)%dimensions
+                      DEALLOCATE( files(f)%dimensions )
+                      ndims = ndims + 1
+                      ALLOCATE( files(f)%dimensions(ndims) )
+                      files(f)%dimensions(:ndims-1) = dimensions_tmp
+                      DEALLOCATE( dimensions_tmp )
+                   ENDIF
+                ENDIF
+
+             ENDIF
+!
+!--          Add new dimension to database
+             IF ( return_value == 0 )  files(f)%dimensions(ndims) = dimension
+
+             EXIT
+
+          ENDIF
+       ENDDO
+
+       IF ( f > nfiles )  THEN
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                                     &
+                                 ': file not found (dimension "' // TRIM( dimension_name ) // &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+
+    ENDIF
+
+ END FUNCTION dom_def_dim
 
 !--------------------------------------------------------------------------------------------------!
@@ -759 +764 @@
 !>          ALLOCATE( u(<z>,<y>,<x>) )
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_var( file_name, variable_name, dimension_names, output_type, is_global ) &
-            RESULT( return_value )
-
-   CHARACTER(LEN=*), INTENT(IN) ::  file_name      !< name of file
-   CHARACTER(LEN=*), INTENT(IN) ::  variable_name  !< name of variable
-   CHARACTER(LEN=*), INTENT(IN) ::  output_type    !< data type of variable
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_var'  !< name of this routine
-
-   CHARACTER(LEN=*), DIMENSION(:), INTENT(IN) ::  dimension_names  !< list of dimension names
-
-   INTEGER ::  d             !< loop index
-   INTEGER ::  f             !< loop index
-   INTEGER ::  i             !< loop index
-   INTEGER ::  nvars         !< number of variables in file
-   INTEGER ::  return_value  !< return value
-
-   LOGICAL                       ::  found      !< true if requested dimension is defined in file
-   LOGICAL, INTENT(IN), OPTIONAL ::  is_global  !< true if variable is global (same on all PE)
-
-   TYPE(variable_type)                            ::  variable       !< new variable
-   TYPE(variable_type), DIMENSION(:), ALLOCATABLE ::  variables_tmp  !< temporary variable list
-
-
-   return_value = 0
-   found = .FALSE.
-
-   CALL internal_message( 'debug', routine_name //                                     &
-                          ': define variable (variable "' // TRIM( variable_name ) //  &
-                          '", file "' // TRIM( file_name ) // '")' )
-
-   variable%name = TRIM( variable_name )
-
-   ALLOCATE( variable%dimension_names(SIZE( dimension_names )) )
-   ALLOCATE( variable%dimension_ids(SIZE( dimension_names )) )
-
-   variable%dimension_names = dimension_names
-   variable%dimension_ids = -1
-   variable%data_type = TRIM( output_type )
-
-   IF ( PRESENT( is_global ) )  THEN
-      variable%is_global = is_global
-   ELSE
-      variable%is_global = .FALSE.
-   ENDIF
-
-   !-- Add variable to database
-   DO  f = 1, nfiles
-
-      IF ( TRIM( file_name ) == files(f)%name )  THEN
-
-         IF ( files(f)%is_init )  THEN
-
-            return_value = 1
-            CALL internal_message( 'error', routine_name //                                  &
-                    ': file already initialized. No further variable definition allowed ' // &
-                    '(variable "' // TRIM( variable_name ) //                                &
-                    '", file "' // TRIM( file_name ) // '")!' )
-            EXIT
-
-         ELSEIF ( ALLOCATED( files(f)%dimensions ) )  THEN
-
-            !-- Check if any dimension of the same name as the new variable is already defined
-            DO  d = 1, SIZE( files(f)%dimensions )
-               IF ( files(f)%dimensions(d)%name == variable%name )  THEN
-                  return_value = 1
-                  CALL internal_message( 'error', routine_name //                    &
-                          ': file already has a dimension of this name defined. ' // &
-                          'Defining a variable of the same name is not allowed ' //  &
-                          '(variable "' // TRIM( variable_name ) //                  &
-                          '", file "' // TRIM( file_name ) // '")!' )
-                  EXIT
-               ENDIF
-            ENDDO
-
-            !-- Check if dimensions assigned to variable are defined within file
-            IF ( return_value == 0 )  THEN
-               DO  i = 1, SIZE( variable%dimension_names )
-                  found = .FALSE.
-                  DO  d = 1, SIZE( files(f)%dimensions )
-                     IF ( files(f)%dimensions(d)%name == variable%dimension_names(i) )  THEN
-                        found = .TRUE.
-                        EXIT
-                     ENDIF
-                  ENDDO
-                  IF ( .NOT. found )  THEN
-                     return_value = 1
-                     CALL internal_message( 'error', routine_name //                            &
-                             ': required dimension "'//  TRIM( variable%dimension_names(i) ) // &
-                             '" for variable is not defined ' //                                &
-                             '(variable "' // TRIM( variable_name ) //                          &
-                             '", file "' // TRIM( file_name ) // '")!' )
-                     EXIT
-                  ENDIF
-               ENDDO
-            ENDIF
-
-         ELSE
-
-            return_value = 1
-            CALL internal_message( 'error', routine_name //                      &
-                    ': no dimensions defined in file. Cannot define variable '// &
-                    '(variable "' // TRIM( variable_name ) //                    &
-                    '", file "' // TRIM( file_name ) // '")!' )
-
-         ENDIF
-
-         IF ( return_value == 0 )  THEN
-
-            !-- Check if variable already exists
-            IF ( .NOT. ALLOCATED( files(f)%variables ) )  THEN
-
-               nvars = 1
-               ALLOCATE( files(f)%variables(nvars) )
-
-            ELSE
-
-               nvars = SIZE( files(f)%variables )
-               DO  i = 1, nvars
-                  IF ( files(f)%variables(i)%name == variable%name )  THEN
-                     return_value = 1
-                     CALL internal_message( 'error', routine_name //   &
-                             ': variable already exists '//            &
-                             '(variable "' // TRIM( variable_name ) // &
-                             '", file "' // TRIM( file_name ) // '")!' )
-                     EXIT
-                  ENDIF
-               ENDDO
-
-               IF ( return_value == 0 )  THEN
-                  !-- Extend variable list
-                  ALLOCATE( variables_tmp(nvars) )
-                  variables_tmp = files(f)%variables
-                  DEALLOCATE( files(f)%variables )
-                  nvars = nvars + 1
-                  ALLOCATE( files(f)%variables(nvars) )
-                  files(f)%variables(:nvars-1) = variables_tmp
-                  DEALLOCATE( variables_tmp )
-               ENDIF
-
-            ENDIF
-
-            !-- Add new variable to database
-            IF ( return_value == 0 )  files(f)%variables(nvars) = variable
-
-         ENDIF
-
-         EXIT
-
-      ENDIF
-
-   ENDDO
-
-   IF ( f > nfiles )  THEN
-      return_value = 1
-      CALL internal_message( 'error', routine_name //                                   &
-                             ': file not found (variable "' // TRIM( variable_name ) // &
-                             '", file "' // TRIM( file_name ) // '")!' )
-   ENDIF
-
-END FUNCTION dom_def_var
+ FUNCTION dom_def_var( file_name, variable_name, dimension_names, output_type, is_global ) &
+             RESULT( return_value )
+
+    CHARACTER(LEN=*), INTENT(IN) ::  file_name      !< name of file
+    CHARACTER(LEN=*), INTENT(IN) ::  variable_name  !< name of variable
+    CHARACTER(LEN=*), INTENT(IN) ::  output_type    !< data type of variable
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_var'  !< name of this routine
+
+    CHARACTER(LEN=*), DIMENSION(:), INTENT(IN) ::  dimension_names  !< list of dimension names
+
+    INTEGER ::  d             !< loop index
+    INTEGER ::  f             !< loop index
+    INTEGER ::  i             !< loop index
+    INTEGER ::  nvars         !< number of variables in file
+    INTEGER ::  return_value  !< return value
+
+    LOGICAL                       ::  found      !< true if requested dimension is defined in file
+    LOGICAL, INTENT(IN), OPTIONAL ::  is_global  !< true if variable is global (same on all PE)
+
+    TYPE(variable_type)                            ::  variable       !< new variable
+    TYPE(variable_type), DIMENSION(:), ALLOCATABLE ::  variables_tmp  !< temporary variable list
+
+
+    return_value = 0
+    found = .FALSE.
+
+    CALL internal_message( 'debug', routine_name //                                     &
+                           ': define variable (variable "' // TRIM( variable_name ) //  &
+                           '", file "' // TRIM( file_name ) // '")' )
+
+    variable%name = TRIM( variable_name )
+
+    ALLOCATE( variable%dimension_names(SIZE( dimension_names )) )
+    ALLOCATE( variable%dimension_ids(SIZE( dimension_names )) )
+
+    variable%dimension_names = dimension_names
+    variable%dimension_ids = -1
+    variable%data_type = TRIM( output_type )
+
+    IF ( PRESENT( is_global ) )  THEN
+       variable%is_global = is_global
+    ELSE
+       variable%is_global = .FALSE.
+    ENDIF
+!
+!-- Add variable to database
+    DO  f = 1, nfiles
+
+       IF ( TRIM( file_name ) == files(f)%name )  THEN
+
+          IF ( files(f)%is_init )  THEN
+
+             return_value = 1
+             CALL internal_message( 'error', routine_name //                                  &
+                     ': file already initialized. No further variable definition allowed ' // &
+                     '(variable "' // TRIM( variable_name ) //                                &
+                     '", file "' // TRIM( file_name ) // '")!' )
+             EXIT
+
+          ELSEIF ( ALLOCATED( files(f)%dimensions ) )  THEN
+!
+!--          Check if any dimension of the same name as the new variable is already defined
+             DO  d = 1, SIZE( files(f)%dimensions )
+                IF ( files(f)%dimensions(d)%name == variable%name )  THEN
+                   return_value = 1
+                   CALL internal_message( 'error', routine_name //                    &
+                           ': file already has a dimension of this name defined. ' // &
+                           'Defining a variable of the same name is not allowed ' //  &
+                           '(variable "' // TRIM( variable_name ) //                  &
+                           '", file "' // TRIM( file_name ) // '")!' )
+                   EXIT
+                ENDIF
+             ENDDO
+!
+!--          Check if dimensions assigned to variable are defined within file
+             IF ( return_value == 0 )  THEN
+                DO  i = 1, SIZE( variable%dimension_names )
+                   found = .FALSE.
+                   DO  d = 1, SIZE( files(f)%dimensions )
+                      IF ( files(f)%dimensions(d)%name == variable%dimension_names(i) )  THEN
+                         found = .TRUE.
+                         EXIT
+                      ENDIF
+                   ENDDO
+                   IF ( .NOT. found )  THEN
+                      return_value = 1
+                      CALL internal_message( 'error', routine_name //                            &
+                              ': required dimension "'//  TRIM( variable%dimension_names(i) ) // &
+                              '" for variable is not defined ' //                                &
+                              '(variable "' // TRIM( variable_name ) //                          &
+                              '", file "' // TRIM( file_name ) // '")!' )
+                      EXIT
+                   ENDIF
+                ENDDO
+             ENDIF
+
+          ELSE
+
+             return_value = 1
+             CALL internal_message( 'error', routine_name //                      &
+                     ': no dimensions defined in file. Cannot define variable '// &
+                     '(variable "' // TRIM( variable_name ) //                    &
+                     '", file "' // TRIM( file_name ) // '")!' )
+
+          ENDIF
+
+          IF ( return_value == 0 )  THEN
+!
+!--          Check if variable already exists
+             IF ( .NOT. ALLOCATED( files(f)%variables ) )  THEN
+
+                nvars = 1
+                ALLOCATE( files(f)%variables(nvars) )
+
+             ELSE
+
+                nvars = SIZE( files(f)%variables )
+                DO  i = 1, nvars
+                   IF ( files(f)%variables(i)%name == variable%name )  THEN
+                      return_value = 1
+                      CALL internal_message( 'error', routine_name //   &
+                              ': variable already exists '//            &
+                              '(variable "' // TRIM( variable_name ) // &
+                              '", file "' // TRIM( file_name ) // '")!' )
+                      EXIT
+                   ENDIF
+                ENDDO
+
+                IF ( return_value == 0 )  THEN
+!
+!--                Extend variable list
+                   ALLOCATE( variables_tmp(nvars) )
+                   variables_tmp = files(f)%variables
+                   DEALLOCATE( files(f)%variables )
+                   nvars = nvars + 1
+                   ALLOCATE( files(f)%variables(nvars) )
+                   files(f)%variables(:nvars-1) = variables_tmp
+                   DEALLOCATE( variables_tmp )
+                ENDIF
+
+             ENDIF
+!
+!--          Add new variable to database
+             IF ( return_value == 0 )  files(f)%variables(nvars) = variable
+
+          ENDIF
+
+          EXIT
+
+       ENDIF
+
+    ENDDO
+
+    IF ( f > nfiles )  THEN
+       return_value = 1
+       CALL internal_message( 'error', routine_name //                                   &
+                              ': file not found (variable "' // TRIM( variable_name ) // &
+                              '", file "' // TRIM( file_name ) // '")!' )
+    ENDIF
+
+ END FUNCTION dom_def_var
 
 !--------------------------------------------------------------------------------------------------!
@@ -946 +952 @@
 !>                   value=' and this part was appended', append=.TRUE. )
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_att_char( file_name, variable_name, attribute_name, value, append ) &
-            RESULT( return_value )
-
-   CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
-   CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
-   CHARACTER(LEN=*),      INTENT(IN)           ::  value                   !< attribute value
-   CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
-   CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
-
-   ! CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_char'  !< name of routine
-
-   INTEGER ::  return_value  !< return value
-
-   LOGICAL                       ::  append_internal  !< same as 'append'
-   LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
-
-   TYPE(attribute_type) ::  attribute  !< new attribute
-
-
-   return_value = 0
-
-   IF ( PRESENT( append ) )  THEN
-      append_internal = append
-   ELSE
-      append_internal = .FALSE.
-   ENDIF
-
-   attribute%name       = TRIM( attribute_name )
-   attribute%data_type  = 'char'
-   attribute%value_char = TRIM( value )
-
-   IF ( PRESENT( variable_name ) )  THEN
-      variable_name_internal = TRIM( variable_name )
-   ELSE
-      variable_name_internal = ''
-   ENDIF
-
-   return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
-                     variable_name=TRIM( variable_name_internal ),         &
-                     attribute=attribute, append=append_internal )
-
-END FUNCTION dom_def_att_char
+ FUNCTION dom_def_att_char( file_name, variable_name, attribute_name, value, append ) &
+             RESULT( return_value )
+
+    CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
+    CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
+    CHARACTER(LEN=*),      INTENT(IN)           ::  value                   !< attribute value
+    CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
+    CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
+
+    ! CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_char'  !< name of routine
+
+    INTEGER ::  return_value  !< return value
+
+    LOGICAL                       ::  append_internal  !< same as 'append'
+    LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
+
+    TYPE(attribute_type) ::  attribute  !< new attribute
+
+
+    return_value = 0
+
+    IF ( PRESENT( append ) )  THEN
+       append_internal = append
+    ELSE
+       append_internal = .FALSE.
+    ENDIF
+
+    attribute%name       = TRIM( attribute_name )
+    attribute%data_type  = 'char'
+    attribute%value_char = TRIM( value )
+
+    IF ( PRESENT( variable_name ) )  THEN
+       variable_name_internal = TRIM( variable_name )
+    ELSE
+       variable_name_internal = ''
+    ENDIF
+
+    return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
+                      variable_name=TRIM( variable_name_internal ),         &
+                      attribute=attribute, append=append_internal )
+
+ END FUNCTION dom_def_att_char
 
 !--------------------------------------------------------------------------------------------------!
@@ -1008 +1014 @@
 !>                   value=1_1 )
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_att_int8( file_name, variable_name, attribute_name, value, append ) &
-            RESULT( return_value )
-
-   CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
-   CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
-   CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
-   CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_int8'  !< name of routine
-
-   INTEGER(KIND=1), INTENT(IN) ::  value  !< attribute value
-
-   INTEGER ::  return_value  !< return value
-
-   LOGICAL                       ::  append_internal  !< same as 'append'
-   LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
-
-   TYPE(attribute_type) ::  attribute  !< new attribute
-
-
-   return_value = 0
-
-   IF ( PRESENT( variable_name ) )  THEN
-      variable_name_internal = TRIM( variable_name )
-   ELSE
-      variable_name_internal = ''
-   ENDIF
-
-   IF ( PRESENT( append ) )  THEN
-      IF ( append )  THEN
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                             &
-                                ': numeric attribute cannot be appended ' //         &
-                                '(attribute "' // TRIM( attribute_name ) //          &
-                                '", variable "' // TRIM( variable_name_internal ) // &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-   ENDIF
-
-   IF ( return_value == 0 )  THEN
-      append_internal = .FALSE.
-
-      attribute%name       = TRIM( attribute_name )
-      attribute%data_type  = 'int8'
-      attribute%value_int8 = value
-
-      return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
-                        variable_name=TRIM( variable_name_internal ),         &
-                        attribute=attribute, append=append_internal )
-   ENDIF
-
-END FUNCTION dom_def_att_int8
+ FUNCTION dom_def_att_int8( file_name, variable_name, attribute_name, value, append ) &
+             RESULT( return_value )
+
+    CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
+    CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
+    CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
+    CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_int8'  !< name of routine
+
+    INTEGER(KIND=1), INTENT(IN) ::  value  !< attribute value
+
+    INTEGER ::  return_value  !< return value
+
+    LOGICAL                       ::  append_internal  !< same as 'append'
+    LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
+
+    TYPE(attribute_type) ::  attribute  !< new attribute
+
+
+    return_value = 0
+
+    IF ( PRESENT( variable_name ) )  THEN
+       variable_name_internal = TRIM( variable_name )
+    ELSE
+       variable_name_internal = ''
+    ENDIF
+
+    IF ( PRESENT( append ) )  THEN
+       IF ( append )  THEN
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                             &
+                                 ': numeric attribute cannot be appended ' //         &
+                                 '(attribute "' // TRIM( attribute_name ) //          &
+                                 '", variable "' // TRIM( variable_name_internal ) // &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+    ENDIF
+
+    IF ( return_value == 0 )  THEN
+       append_internal = .FALSE.
+
+       attribute%name       = TRIM( attribute_name )
+       attribute%data_type  = 'int8'
+       attribute%value_int8 = value
+
+       return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
+                         variable_name=TRIM( variable_name_internal ),         &
+                         attribute=attribute, append=append_internal )
+    ENDIF
+
+ END FUNCTION dom_def_att_int8
 
 !--------------------------------------------------------------------------------------------------!
@@ -1080 +1086 @@
 !>                   value=1_2 )
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_att_int16( file_name, variable_name, attribute_name, value, append ) &
-            RESULT( return_value )
-
-   CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
-   CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
-   CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
-   CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_int16'  !< name of routine
-
-   INTEGER(KIND=2), INTENT(IN) ::  value  !< attribute value
-
-   INTEGER ::  return_value  !< return value
-
-   LOGICAL                       ::  append_internal  !< same as 'append'
-   LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
-
-   TYPE(attribute_type) ::  attribute  !< new attribute
-
-
-   return_value = 0
-
-   IF ( PRESENT( variable_name ) )  THEN
-      variable_name_internal = TRIM( variable_name )
-   ELSE
-      variable_name_internal = ''
-   ENDIF
-
-   IF ( PRESENT( append ) )  THEN
-      IF ( append )  THEN
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                             &
-                                ': numeric attribute cannot be appended ' //         &
-                                '(attribute "' // TRIM( attribute_name ) //          &
-                                '", variable "' // TRIM( variable_name_internal ) // &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-   ENDIF
-
-   IF ( return_value == 0 )  THEN
-      append_internal = .FALSE.
-
-      attribute%name        = TRIM( attribute_name )
-      attribute%data_type   = 'int16'
-      attribute%value_int16 = value
-
-      return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
-                        variable_name=TRIM( variable_name_internal ),         &
-                        attribute=attribute, append=append_internal )
-   ENDIF
-
-END FUNCTION dom_def_att_int16
+ FUNCTION dom_def_att_int16( file_name, variable_name, attribute_name, value, append ) &
+             RESULT( return_value )
+
+    CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
+    CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
+    CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
+    CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_int16'  !< name of routine
+
+    INTEGER(KIND=2), INTENT(IN) ::  value  !< attribute value
+
+    INTEGER ::  return_value  !< return value
+
+    LOGICAL                       ::  append_internal  !< same as 'append'
+    LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
+
+    TYPE(attribute_type) ::  attribute  !< new attribute
+
+
+    return_value = 0
+
+    IF ( PRESENT( variable_name ) )  THEN
+       variable_name_internal = TRIM( variable_name )
+    ELSE
+       variable_name_internal = ''
+    ENDIF
+
+    IF ( PRESENT( append ) )  THEN
+       IF ( append )  THEN
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                             &
+                                 ': numeric attribute cannot be appended ' //         &
+                                 '(attribute "' // TRIM( attribute_name ) //          &
+                                 '", variable "' // TRIM( variable_name_internal ) // &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+    ENDIF
+
+    IF ( return_value == 0 )  THEN
+       append_internal = .FALSE.
+
+       attribute%name        = TRIM( attribute_name )
+       attribute%data_type   = 'int16'
+       attribute%value_int16 = value
+
+       return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
+                         variable_name=TRIM( variable_name_internal ),         &
+                         attribute=attribute, append=append_internal )
+    ENDIF
+
+ END FUNCTION dom_def_att_int16
 
 !--------------------------------------------------------------------------------------------------!
@@ -1152 +1158 @@
 !>                   value=1_4 )
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_att_int32( file_name, variable_name, attribute_name, value, append ) &
-            RESULT( return_value )
-
-   CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
-   CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
-   CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
-   CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_int32'  !< name of routine
-
-   INTEGER(KIND=4), INTENT(IN) ::  value  !< attribute value
-
-   INTEGER ::  return_value  !< return value
-
-   LOGICAL                       ::  append_internal  !< same as 'append'
-   LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
-
-   TYPE(attribute_type) ::  attribute  !< new attribute
-
-
-   return_value = 0
-
-   IF ( PRESENT( variable_name ) )  THEN
-      variable_name_internal = TRIM( variable_name )
-   ELSE
-      variable_name_internal = ''
-   ENDIF
-
-   IF ( PRESENT( append ) )  THEN
-      IF ( append )  THEN
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                             &
-                                ': numeric attribute cannot be appended ' //         &
-                                '(attribute "' // TRIM( attribute_name ) //          &
-                                '", variable "' // TRIM( variable_name_internal ) // &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-   ENDIF
-
-   IF ( return_value == 0 )  THEN
-      append_internal = .FALSE.
-
-      attribute%name        = TRIM( attribute_name )
-      attribute%data_type   = 'int32'
-      attribute%value_int32 = value
-
-      return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
-                        variable_name=TRIM( variable_name_internal ),         &
-                        attribute=attribute, append=append_internal )
-   ENDIF
-
-END FUNCTION dom_def_att_int32
+ FUNCTION dom_def_att_int32( file_name, variable_name, attribute_name, value, append ) &
+             RESULT( return_value )
+
+    CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
+    CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
+    CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
+    CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_int32'  !< name of routine
+
+    INTEGER(KIND=4), INTENT(IN) ::  value  !< attribute value
+
+    INTEGER ::  return_value  !< return value
+
+    LOGICAL                       ::  append_internal  !< same as 'append'
+    LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
+
+    TYPE(attribute_type) ::  attribute  !< new attribute
+
+
+    return_value = 0
+
+    IF ( PRESENT( variable_name ) )  THEN
+       variable_name_internal = TRIM( variable_name )
+    ELSE
+       variable_name_internal = ''
+    ENDIF
+
+    IF ( PRESENT( append ) )  THEN
+       IF ( append )  THEN
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                             &
+                                 ': numeric attribute cannot be appended ' //         &
+                                 '(attribute "' // TRIM( attribute_name ) //          &
+                                 '", variable "' // TRIM( variable_name_internal ) // &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+    ENDIF
+
+    IF ( return_value == 0 )  THEN
+       append_internal = .FALSE.
+
+       attribute%name        = TRIM( attribute_name )
+       attribute%data_type   = 'int32'
+       attribute%value_int32 = value
+
+       return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
+                         variable_name=TRIM( variable_name_internal ),         &
+                         attribute=attribute, append=append_internal )
+    ENDIF
+
+ END FUNCTION dom_def_att_int32
 
 !--------------------------------------------------------------------------------------------------!
@@ -1224 +1230 @@
 !>                   value=1.0_4 )
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_att_real32( file_name, variable_name, attribute_name, value, append ) &
-            RESULT( return_value )
-
-   CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
-   CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
-   CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
-   CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_real32'  !< name of routine
-
-   INTEGER ::  return_value  !< return value
-
-   LOGICAL                       ::  append_internal  !< same as 'append'
-   LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
-
-   REAL(KIND=4), INTENT(IN) ::  value  !< attribute value
-
-   TYPE(attribute_type) ::  attribute  !< new attribute
-
-
-   return_value = 0
-
-   IF ( PRESENT( variable_name ) )  THEN
-      variable_name_internal = TRIM( variable_name )
-   ELSE
-      variable_name_internal = ''
-   ENDIF
-
-   IF ( PRESENT( append ) )  THEN
-      IF ( append )  THEN
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                             &
-                                ': numeric attribute cannot be appended ' //         &
-                                '(attribute "' // TRIM( attribute_name ) //          &
-                                '", variable "' // TRIM( variable_name_internal ) // &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-   ENDIF
-
-   IF ( return_value == 0 )  THEN
-      append_internal = .FALSE.
-
-      attribute%name         = TRIM( attribute_name )
-      attribute%data_type    = 'real32'
-      attribute%value_real32 = value
-
-      return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
-                        variable_name=TRIM( variable_name_internal ),         &
-                        attribute=attribute, append=append_internal )
-   ENDIF
-
-END FUNCTION dom_def_att_real32
+ FUNCTION dom_def_att_real32( file_name, variable_name, attribute_name, value, append ) &
+             RESULT( return_value )
+
+    CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
+    CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
+    CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
+    CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_real32'  !< name of routine
+
+    INTEGER ::  return_value  !< return value
+
+    LOGICAL                       ::  append_internal  !< same as 'append'
+    LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
+
+    REAL(KIND=4), INTENT(IN) ::  value  !< attribute value
+
+    TYPE(attribute_type) ::  attribute  !< new attribute
+
+
+    return_value = 0
+
+    IF ( PRESENT( variable_name ) )  THEN
+       variable_name_internal = TRIM( variable_name )
+    ELSE
+       variable_name_internal = ''
+    ENDIF
+
+    IF ( PRESENT( append ) )  THEN
+       IF ( append )  THEN
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                             &
+                                 ': numeric attribute cannot be appended ' //         &
+                                 '(attribute "' // TRIM( attribute_name ) //          &
+                                 '", variable "' // TRIM( variable_name_internal ) // &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+    ENDIF
+
+    IF ( return_value == 0 )  THEN
+       append_internal = .FALSE.
+
+       attribute%name         = TRIM( attribute_name )
+       attribute%data_type    = 'real32'
+       attribute%value_real32 = value
+
+       return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
+                         variable_name=TRIM( variable_name_internal ),         &
+                         attribute=attribute, append=append_internal )
+    ENDIF
+
+ END FUNCTION dom_def_att_real32
 
 !--------------------------------------------------------------------------------------------------!
@@ -1296 +1302 @@
 !>                   value=1.0_8 )
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_att_real64( file_name, variable_name, attribute_name, value, append ) &
-            RESULT( return_value )
-
-   CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
-   CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
-   CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
-   CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_real64'  !< name of routine
-
-   INTEGER ::  return_value  !< return value
-
-   LOGICAL                       ::  append_internal  !< same as 'append'
-   LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
-
-   REAL(KIND=8), INTENT(IN) ::  value  !< attribute value
-
-   TYPE(attribute_type) ::  attribute  !< new attribute
-
-
-   return_value = 0
-
-   IF ( PRESENT( variable_name ) )  THEN
-      variable_name_internal = TRIM( variable_name )
-   ELSE
-      variable_name_internal = ''
-   ENDIF
-
-   IF ( PRESENT( append ) )  THEN
-      IF ( append )  THEN
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                             &
-                                ': numeric attribute cannot be appended ' //         &
-                                '(attribute "' // TRIM( attribute_name ) //          &
-                                '", variable "' // TRIM( variable_name_internal ) // &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-   ENDIF
-
-   IF ( return_value == 0 )  THEN
-      append_internal = .FALSE.
-
-      attribute%name         = TRIM( attribute_name )
-      attribute%data_type    = 'real64'
-      attribute%value_real64 = value
-
-      return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
-                        variable_name=TRIM( variable_name_internal ),         &
-                        attribute=attribute, append=append_internal )
-   ENDIF
-
-END FUNCTION dom_def_att_real64
+ FUNCTION dom_def_att_real64( file_name, variable_name, attribute_name, value, append ) &
+             RESULT( return_value )
+
+    CHARACTER(LEN=*),      INTENT(IN)           ::  file_name               !< name of file
+    CHARACTER(LEN=*),      INTENT(IN)           ::  attribute_name          !< name of attribute
+    CHARACTER(LEN=*),      INTENT(IN), OPTIONAL ::  variable_name           !< name of variable
+    CHARACTER(LEN=charlen)                      ::  variable_name_internal  !< internal copy of variable_name
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_att_real64'  !< name of routine
+
+    INTEGER ::  return_value  !< return value
+
+    LOGICAL                       ::  append_internal  !< same as 'append'
+    LOGICAL, INTENT(IN), OPTIONAL ::  append           !< if true, append value to existing value
+
+    REAL(KIND=8), INTENT(IN) ::  value  !< attribute value
+
+    TYPE(attribute_type) ::  attribute  !< new attribute
+
+
+    return_value = 0
+
+    IF ( PRESENT( variable_name ) )  THEN
+       variable_name_internal = TRIM( variable_name )
+    ELSE
+       variable_name_internal = ''
+    ENDIF
+
+    IF ( PRESENT( append ) )  THEN
+       IF ( append )  THEN
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                             &
+                                 ': numeric attribute cannot be appended ' //         &
+                                 '(attribute "' // TRIM( attribute_name ) //          &
+                                 '", variable "' // TRIM( variable_name_internal ) // &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+    ENDIF
+
+    IF ( return_value == 0 )  THEN
+       append_internal = .FALSE.
+
+       attribute%name         = TRIM( attribute_name )
+       attribute%data_type    = 'real64'
+       attribute%value_real64 = value
+
+       return_value = save_attribute_in_database( file_name=TRIM( file_name ), &
+                         variable_name=TRIM( variable_name_internal ),         &
+                         attribute=attribute, append=append_internal )
+    ENDIF
+
+ END FUNCTION dom_def_att_real64
 
 !--------------------------------------------------------------------------------------------------!
@@ -1357 +1363 @@
 !> to the files.
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_def_end() RESULT( return_value )
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_end'  !< name of routine
-
-   INTEGER ::  d             !< loop index
-   INTEGER ::  f             !< loop index
-   INTEGER ::  return_value  !< return value
-
-   INTEGER(KIND=1), DIMENSION(:), ALLOCATABLE, TARGET ::  values_int8           !< target array for dimension values
-   INTEGER(KIND=2), DIMENSION(:), ALLOCATABLE, TARGET ::  values_int16          !< target array for dimension values
-   INTEGER(KIND=4), DIMENSION(:), ALLOCATABLE, TARGET ::  values_int32          !< target array for dimension values
-   INTEGER(iwp),    DIMENSION(:), ALLOCATABLE, TARGET ::  values_intwp          !< target array for dimension values
-   
-   INTEGER(KIND=1), DIMENSION(:), POINTER, CONTIGUOUS ::  values_int8_pointer   !< pointer to target array
-   INTEGER(KIND=2), DIMENSION(:), POINTER, CONTIGUOUS ::  values_int16_pointer  !< pointer to target array
-   INTEGER(KIND=4), DIMENSION(:), POINTER, CONTIGUOUS ::  values_int32_pointer  !< pointer to target array
-   INTEGER(iwp),    DIMENSION(:), POINTER, CONTIGUOUS ::  values_intwp_pointer  !< pointer to target array
-
-   REAL(KIND=4), DIMENSION(:), ALLOCATABLE, TARGET ::  values_real32            !< target array for dimension values
-   REAL(KIND=8), DIMENSION(:), ALLOCATABLE, TARGET ::  values_real64            !< target array for dimension values
-   REAL(wp),     DIMENSION(:), ALLOCATABLE, TARGET ::  values_realwp            !< target array for dimension values
-
-   REAL(KIND=4), DIMENSION(:), POINTER, CONTIGUOUS ::  values_real32_pointer    !< pointer to target array
-   REAL(KIND=8), DIMENSION(:), POINTER, CONTIGUOUS ::  values_real64_pointer    !< pointer to target array
-   REAL(wp),     DIMENSION(:), POINTER, CONTIGUOUS ::  values_realwp_pointer    !< pointer to target array
-
-
-   return_value = 0
-   CALL internal_message( 'debug', routine_name // ': start' )
-
-   !-- Clear database from empty files and unused dimensions
-   IF ( nfiles > 0 )  return_value = cleanup_database()
-
-   IF ( return_value == 0 )  THEN
-      DO  f = 1, nfiles
-
-         !-- Skip initialization if file is already initialized
-         IF ( files(f)%is_init )  CYCLE
-
-         CALL internal_message( 'debug', routine_name // ': initialize file "' // &
-                                TRIM( files(f)%name ) // '"' )
-
-         !-- Open file
-         CALL open_output_file( files(f)%format, files(f)%name, files(f)%id, &
-                                return_value=return_value )
-
-         !-- Initialize file header:
-         !-- define dimensions and variables and write attributes
-         IF ( return_value == 0 )  &
-            CALL init_file_header( files(f), return_value=return_value )
-
-         !-- End file definition
-         IF ( return_value == 0 )  &
-            CALL stop_file_header_definition( files(f)%format, files(f)%id, &
-                                              files(f)%name, return_value )
-
-         IF ( return_value == 0 )  THEN
-
-            !-- Flag file as initialized
-            files(f)%is_init = .TRUE.
-
-            !-- Write dimension values into file
-            DO  d = 1, SIZE( files(f)%dimensions )
-               IF ( ALLOCATED( files(f)%dimensions(d)%values_int8 ) )  THEN
-                  ALLOCATE( values_int8(files(f)%dimensions(d)%bounds(1): &
-                                        files(f)%dimensions(d)%bounds(2)) )
-                  values_int8 = files(f)%dimensions(d)%values_int8
-                  values_int8_pointer => values_int8
-                  return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
-                                    bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
-                                    bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
-                                    values_int8_1d=values_int8_pointer )
-                  DEALLOCATE( values_int8 )
-               ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_int16 ) )  THEN
-                  ALLOCATE( values_int16(files(f)%dimensions(d)%bounds(1): &
+ FUNCTION dom_def_end() RESULT( return_value )
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_def_end'  !< name of routine
+
+    INTEGER ::  d             !< loop index
+    INTEGER ::  f             !< loop index
+    INTEGER ::  return_value  !< return value
+
+    INTEGER(KIND=1), DIMENSION(:), ALLOCATABLE, TARGET ::  values_int8           !< target array for dimension values
+    INTEGER(KIND=2), DIMENSION(:), ALLOCATABLE, TARGET ::  values_int16          !< target array for dimension values
+    INTEGER(KIND=4), DIMENSION(:), ALLOCATABLE, TARGET ::  values_int32          !< target array for dimension values
+    INTEGER(iwp),    DIMENSION(:), ALLOCATABLE, TARGET ::  values_intwp          !< target array for dimension values
+
+    INTEGER(KIND=1), DIMENSION(:), POINTER, CONTIGUOUS ::  values_int8_pointer   !< pointer to target array
+    INTEGER(KIND=2), DIMENSION(:), POINTER, CONTIGUOUS ::  values_int16_pointer  !< pointer to target array
+    INTEGER(KIND=4), DIMENSION(:), POINTER, CONTIGUOUS ::  values_int32_pointer  !< pointer to target array
+    INTEGER(iwp),    DIMENSION(:), POINTER, CONTIGUOUS ::  values_intwp_pointer  !< pointer to target array
+
+    REAL(KIND=4), DIMENSION(:), ALLOCATABLE, TARGET ::  values_real32            !< target array for dimension values
+    REAL(KIND=8), DIMENSION(:), ALLOCATABLE, TARGET ::  values_real64            !< target array for dimension values
+    REAL(wp),     DIMENSION(:), ALLOCATABLE, TARGET ::  values_realwp            !< target array for dimension values
+
+    REAL(KIND=4), DIMENSION(:), POINTER, CONTIGUOUS ::  values_real32_pointer    !< pointer to target array
+    REAL(KIND=8), DIMENSION(:), POINTER, CONTIGUOUS ::  values_real64_pointer    !< pointer to target array
+    REAL(wp),     DIMENSION(:), POINTER, CONTIGUOUS ::  values_realwp_pointer    !< pointer to target array
+
+
+    return_value = 0
+    CALL internal_message( 'debug', routine_name // ': start' )
+!
+!-- Clear database from empty files and unused dimensions
+    IF ( nfiles > 0 )  return_value = cleanup_database()
+
+    IF ( return_value == 0 )  THEN
+       DO  f = 1, nfiles
+!
+!--       Skip initialization if file is already initialized
+          IF ( files(f)%is_init )  CYCLE
+
+          CALL internal_message( 'debug', routine_name // ': initialize file "' // &
+                                 TRIM( files(f)%name ) // '"' )
+!
+!--       Open file
+          CALL open_output_file( files(f)%format, files(f)%name, files(f)%id, &
+                                 return_value=return_value )
+!
+!--       Initialize file header:
+!--       define dimensions and variables and write attributes
+          IF ( return_value == 0 )  &
+             CALL init_file_header( files(f), return_value=return_value )
+!
+!--       End file definition
+          IF ( return_value == 0 )  &
+             CALL stop_file_header_definition( files(f)%format, files(f)%id, &
+                                               files(f)%name, return_value )
+
+          IF ( return_value == 0 )  THEN
+!
+!--          Flag file as initialized
+             files(f)%is_init = .TRUE.
+!
+!--          Write dimension values into file
+             DO  d = 1, SIZE( files(f)%dimensions )
+                IF ( ALLOCATED( files(f)%dimensions(d)%values_int8 ) )  THEN
+                   ALLOCATE( values_int8(files(f)%dimensions(d)%bounds(1): &
                                          files(f)%dimensions(d)%bounds(2)) )
-                  values_int16 = files(f)%dimensions(d)%values_int16
-                  values_int16_pointer => values_int16
-                  return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
-                                    bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
-                                    bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
-                                    values_int16_1d=values_int16_pointer )
-                  DEALLOCATE( values_int16 )
-               ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_int32 ) )  THEN
-                  ALLOCATE( values_int32(files(f)%dimensions(d)%bounds(1): &
-                                         files(f)%dimensions(d)%bounds(2)) )
-                  values_int32 = files(f)%dimensions(d)%values_int32
-                  values_int32_pointer => values_int32
-                  return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
-                                    bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
-                                    bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
-                                    values_int32_1d=values_int32_pointer )
-                  DEALLOCATE( values_int32 )
-               ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_intwp ) )  THEN
-                  ALLOCATE( values_intwp(files(f)%dimensions(d)%bounds(1): &
-                                         files(f)%dimensions(d)%bounds(2)) )
-                  values_intwp = files(f)%dimensions(d)%values_intwp
-                  values_intwp_pointer => values_intwp
-                  return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
-                                    bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
-                                    bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
-                                    values_intwp_1d=values_intwp_pointer )
-                  DEALLOCATE( values_intwp )
-               ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_real32 ) )  THEN
-                  ALLOCATE( values_real32(files(f)%dimensions(d)%bounds(1): &
+                   values_int8 = files(f)%dimensions(d)%values_int8
+                   values_int8_pointer => values_int8
+                   return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
+                                     bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
+                                     bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
+                                     values_int8_1d=values_int8_pointer )
+                   DEALLOCATE( values_int8 )
+                ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_int16 ) )  THEN
+                   ALLOCATE( values_int16(files(f)%dimensions(d)%bounds(1): &
                                           files(f)%dimensions(d)%bounds(2)) )
-                  values_real32 = files(f)%dimensions(d)%values_real32
-                  values_real32_pointer => values_real32
-                  return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
-                                    bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
-                                    bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
-                                    values_real32_1d=values_real32_pointer )
-                  DEALLOCATE( values_real32 )
-               ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_real64 ) )  THEN
-                  ALLOCATE( values_real64(files(f)%dimensions(d)%bounds(1): &
+                   values_int16 = files(f)%dimensions(d)%values_int16
+                   values_int16_pointer => values_int16
+                   return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
+                                     bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
+                                     bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
+                                     values_int16_1d=values_int16_pointer )
+                   DEALLOCATE( values_int16 )
+                ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_int32 ) )  THEN
+                   ALLOCATE( values_int32(files(f)%dimensions(d)%bounds(1): &
                                           files(f)%dimensions(d)%bounds(2)) )
-                  values_real64 = files(f)%dimensions(d)%values_real64
-                  values_real64_pointer => values_real64
-                  return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
-                                    bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
-                                    bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
-                                    values_real64_1d=values_real64_pointer )
-                  DEALLOCATE( values_real64 )
-               ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_realwp ) )  THEN
-                  ALLOCATE( values_realwp(files(f)%dimensions(d)%bounds(1): &
+                   values_int32 = files(f)%dimensions(d)%values_int32
+                   values_int32_pointer => values_int32
+                   return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
+                                     bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
+                                     bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
+                                     values_int32_1d=values_int32_pointer )
+                   DEALLOCATE( values_int32 )
+                ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_intwp ) )  THEN
+                   ALLOCATE( values_intwp(files(f)%dimensions(d)%bounds(1): &
                                           files(f)%dimensions(d)%bounds(2)) )
-                  values_realwp = files(f)%dimensions(d)%values_realwp
-                  values_realwp_pointer => values_realwp
-                  return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
-                                    bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
-                                    bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
-                                    values_realwp_1d=values_realwp_pointer )
-                  DEALLOCATE( values_realwp )
-               ENDIF
-               IF ( return_value /= 0 )  EXIT
-            ENDDO
-
-         ENDIF
-
-         IF ( return_value /= 0 )  EXIT
-
-      ENDDO
-   ENDIF
-
-   CALL internal_message( 'debug', routine_name // ': finished' )
-
-END FUNCTION dom_def_end
+                   values_intwp = files(f)%dimensions(d)%values_intwp
+                   values_intwp_pointer => values_intwp
+                   return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
+                                     bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
+                                     bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
+                                     values_intwp_1d=values_intwp_pointer )
+                   DEALLOCATE( values_intwp )
+                ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_real32 ) )  THEN
+                   ALLOCATE( values_real32(files(f)%dimensions(d)%bounds(1): &
+                                           files(f)%dimensions(d)%bounds(2)) )
+                   values_real32 = files(f)%dimensions(d)%values_real32
+                   values_real32_pointer => values_real32
+                   return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
+                                     bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
+                                     bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
+                                     values_real32_1d=values_real32_pointer )
+                   DEALLOCATE( values_real32 )
+                ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_real64 ) )  THEN
+                   ALLOCATE( values_real64(files(f)%dimensions(d)%bounds(1): &
+                                           files(f)%dimensions(d)%bounds(2)) )
+                   values_real64 = files(f)%dimensions(d)%values_real64
+                   values_real64_pointer => values_real64
+                   return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
+                                     bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
+                                     bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
+                                     values_real64_1d=values_real64_pointer )
+                   DEALLOCATE( values_real64 )
+                ELSEIF ( ALLOCATED( files(f)%dimensions(d)%values_realwp ) )  THEN
+                   ALLOCATE( values_realwp(files(f)%dimensions(d)%bounds(1): &
+                                           files(f)%dimensions(d)%bounds(2)) )
+                   values_realwp = files(f)%dimensions(d)%values_realwp
+                   values_realwp_pointer => values_realwp
+                   return_value = dom_write_var( files(f)%name, files(f)%dimensions(d)%name, &
+                                     bounds_start=(/ files(f)%dimensions(d)%bounds(1) /),    &
+                                     bounds_end  =(/ files(f)%dimensions(d)%bounds(2) /),    &
+                                     values_realwp_1d=values_realwp_pointer )
+                   DEALLOCATE( values_realwp )
+                ENDIF
+                IF ( return_value /= 0 )  EXIT
+             ENDDO
+
+          ENDIF
+
+          IF ( return_value /= 0 )  EXIT
+
+       ENDDO
+    ENDIF
+
+    CALL internal_message( 'debug', routine_name // ': finished' )
+
+ END FUNCTION dom_def_end
 
 !--------------------------------------------------------------------------------------------------!
@@ -1526 +1532 @@
 !>       chosen, the values are written to file as given in the 'dom_write_var' call.
 !--------------------------------------------------------------------------------------------------!
-FUNCTION dom_write_var( file_name, variable_name, bounds_start, bounds_end,         &
-            values_int8_0d,   values_int8_1d,   values_int8_2d,   values_int8_3d,   &
-            values_int16_0d,  values_int16_1d,  values_int16_2d,  values_int16_3d,  &
-            values_int32_0d,  values_int32_1d,  values_int32_2d,  values_int32_3d,  &
-            values_intwp_0d,  values_intwp_1d,  values_intwp_2d,  values_intwp_3d,  &
-            values_real32_0d, values_real32_1d, values_real32_2d, values_real32_3d, &
-            values_real64_0d, values_real64_1d, values_real64_2d, values_real64_3d, &
-            values_realwp_0d, values_realwp_1d, values_realwp_2d, values_realwp_3d  &
-            ) RESULT( return_value )
-
-   CHARACTER(LEN=charlen)            ::  file_format    !< file format chosen for file
-   CHARACTER(LEN=*),      INTENT(IN) ::  file_name      !< name of file
-   CHARACTER(LEN=*),      INTENT(IN) ::  variable_name  !< name of variable
-
-   CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_write_var'  !< name of routine
-
-   INTEGER ::  file_id              !< file ID
-   INTEGER ::  i                    !< loop index
-   INTEGER ::  j                    !< loop index
-   INTEGER ::  k                    !< loop index
-   INTEGER ::  output_return_value  !< return value of a called output routine
-   INTEGER ::  return_value         !< return value
-   INTEGER ::  variable_id          !< variable ID
-
-   INTEGER, DIMENSION(:),   INTENT(IN)  ::  bounds_end             !< end index per dimension of variable
-   INTEGER, DIMENSION(:),   INTENT(IN)  ::  bounds_start           !< start index per dimension of variable
-   INTEGER, DIMENSION(:),   ALLOCATABLE ::  bounds_origin          !< first index of each dimension
-   INTEGER, DIMENSION(:),   ALLOCATABLE ::  bounds_start_internal  !< start index per dim. for output after masking
-   INTEGER, DIMENSION(:),   ALLOCATABLE ::  value_counts           !< count of indices to be written per dimension
-   INTEGER, DIMENSION(:,:), ALLOCATABLE ::  masked_indices         !< list containing all output indices along a dimension
-
-   LOGICAL ::  do_output  !< true if any data lies within given range of masked dimension
-   LOGICAL ::  is_global  !< true if variable is global
-
-   INTEGER(KIND=1), POINTER, INTENT(IN), OPTIONAL                   ::  values_int8_0d             !< output variable
-   INTEGER(KIND=2), POINTER, INTENT(IN), OPTIONAL                   ::  values_int16_0d            !< output variable
-   INTEGER(KIND=4), POINTER, INTENT(IN), OPTIONAL                   ::  values_int32_0d            !< output variable
-   INTEGER(iwp),    POINTER, INTENT(IN), OPTIONAL                   ::  values_intwp_0d            !< output variable
-   INTEGER(KIND=1), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int8_1d             !< output variable
-   INTEGER(KIND=2), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int16_1d            !< output variable
-   INTEGER(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int32_1d            !< output variable
-   INTEGER(iwp),    POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_intwp_1d            !< output variable
-   INTEGER(KIND=1), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int8_2d             !< output variable
-   INTEGER(KIND=2), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int16_2d            !< output variable
-   INTEGER(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int32_2d            !< output variable
-   INTEGER(iwp),    POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_intwp_2d            !< output variable
-   INTEGER(KIND=1), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int8_3d             !< output variable
-   INTEGER(KIND=2), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int16_3d            !< output variable
-   INTEGER(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int32_3d            !< output variable
-   INTEGER(iwp),    POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_intwp_3d            !< output variable
-
-   INTEGER(KIND=1), TARGET, ALLOCATABLE, DIMENSION(:)               ::  values_int8_1d_resorted    !< resorted output variable
-   INTEGER(KIND=2), TARGET, ALLOCATABLE, DIMENSION(:)               ::  values_int16_1d_resorted   !< resorted output variable
-   INTEGER(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:)               ::  values_int32_1d_resorted   !< resorted output variable
-   INTEGER(iwp),    TARGET, ALLOCATABLE, DIMENSION(:)               ::  values_intwp_1d_resorted   !< resorted output variable
-   INTEGER(KIND=1), TARGET, ALLOCATABLE, DIMENSION(:,:)             ::  values_int8_2d_resorted    !< resorted output variable
-   INTEGER(KIND=2), TARGET, ALLOCATABLE, DIMENSION(:,:)             ::  values_int16_2d_resorted   !< resorted output variable
-   INTEGER(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:,:)             ::  values_int32_2d_resorted   !< resorted output variable
-   INTEGER(iwp),    TARGET, ALLOCATABLE, DIMENSION(:,:)             ::  values_intwp_2d_resorted   !< resorted output variable
-   INTEGER(KIND=1), TARGET, ALLOCATABLE, DIMENSION(:,:,:)           ::  values_int8_3d_resorted    !< resorted output variable
-   INTEGER(KIND=2), TARGET, ALLOCATABLE, DIMENSION(:,:,:)           ::  values_int16_3d_resorted   !< resorted output variable
-   INTEGER(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:,:,:)           ::  values_int32_3d_resorted   !< resorted output variable
-   INTEGER(iwp),    TARGET, ALLOCATABLE, DIMENSION(:,:,:)           ::  values_intwp_3d_resorted   !< resorted output variable
-
-   INTEGER(KIND=1), POINTER                                         ::  values_int8_0d_pointer     !< pointer to resortet array
-   INTEGER(KIND=2), POINTER                                         ::  values_int16_0d_pointer    !< pointer to resortet array
-   INTEGER(KIND=4), POINTER                                         ::  values_int32_0d_pointer    !< pointer to resortet array
-   INTEGER(iwp),    POINTER                                         ::  values_intwp_0d_pointer    !< pointer to resortet array
-   INTEGER(KIND=1), POINTER, CONTIGUOUS, DIMENSION(:)               ::  values_int8_1d_pointer     !< pointer to resortet array
-   INTEGER(KIND=2), POINTER, CONTIGUOUS, DIMENSION(:)               ::  values_int16_1d_pointer    !< pointer to resortet array
-   INTEGER(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:)               ::  values_int32_1d_pointer    !< pointer to resortet array
-   INTEGER(iwp),    POINTER, CONTIGUOUS, DIMENSION(:)               ::  values_intwp_1d_pointer    !< pointer to resortet array
-   INTEGER(KIND=1), POINTER, CONTIGUOUS, DIMENSION(:,:)             ::  values_int8_2d_pointer     !< pointer to resortet array
-   INTEGER(KIND=2), POINTER, CONTIGUOUS, DIMENSION(:,:)             ::  values_int16_2d_pointer    !< pointer to resortet array
-   INTEGER(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:,:)             ::  values_int32_2d_pointer    !< pointer to resortet array
-   INTEGER(iwp),    POINTER, CONTIGUOUS, DIMENSION(:,:)             ::  values_intwp_2d_pointer    !< pointer to resortet array
-   INTEGER(KIND=1), POINTER, CONTIGUOUS, DIMENSION(:,:,:)           ::  values_int8_3d_pointer     !< pointer to resortet array
-   INTEGER(KIND=2), POINTER, CONTIGUOUS, DIMENSION(:,:,:)           ::  values_int16_3d_pointer    !< pointer to resortet array
-   INTEGER(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:,:,:)           ::  values_int32_3d_pointer    !< pointer to resortet array
-   INTEGER(iwp),    POINTER, CONTIGUOUS, DIMENSION(:,:,:)           ::  values_intwp_3d_pointer    !< pointer to resortet array
-
-   REAL(KIND=4), POINTER, INTENT(IN), OPTIONAL                      ::  values_real32_0d           !< output variable
-   REAL(KIND=8), POINTER, INTENT(IN), OPTIONAL                      ::  values_real64_0d           !< output variable
-   REAL(wp),     POINTER, INTENT(IN), OPTIONAL                      ::  values_realwp_0d           !< output variable
-   REAL(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)        ::  values_real32_1d           !< output variable
-   REAL(KIND=8), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)        ::  values_real64_1d           !< output variable
-   REAL(wp),     POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)        ::  values_realwp_1d           !< output variable
-   REAL(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)      ::  values_real32_2d           !< output variable
-   REAL(KIND=8), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)      ::  values_real64_2d           !< output variable
-   REAL(wp),     POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)      ::  values_realwp_2d           !< output variable
-   REAL(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:)    ::  values_real32_3d           !< output variable
-   REAL(KIND=8), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:)    ::  values_real64_3d           !< output variable
-   REAL(wp),     POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:)    ::  values_realwp_3d           !< output variable
-
-   REAL(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:)                  ::  values_real32_1d_resorted  !< resorted output variable
-   REAL(KIND=8), TARGET, ALLOCATABLE, DIMENSION(:)                  ::  values_real64_1d_resorted  !< resorted output variable
-   REAL(wp),     TARGET, ALLOCATABLE, DIMENSION(:)                  ::  values_realwp_1d_resorted  !< resorted output variable
-   REAL(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:,:)                ::  values_real32_2d_resorted  !< resorted output variable
-   REAL(KIND=8), TARGET, ALLOCATABLE, DIMENSION(:,:)                ::  values_real64_2d_resorted  !< resorted output variable
-   REAL(wp),     TARGET, ALLOCATABLE, DIMENSION(:,:)                ::  values_realwp_2d_resorted  !< resorted output variable
-   REAL(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:,:,:)              ::  values_real32_3d_resorted  !< resorted output variable
-   REAL(KIND=8), TARGET, ALLOCATABLE, DIMENSION(:,:,:)              ::  values_real64_3d_resorted  !< resorted output variable
-   REAL(wp),     TARGET, ALLOCATABLE, DIMENSION(:,:,:)              ::  values_realwp_3d_resorted  !< resorted output variable
-
-   REAL(KIND=4), POINTER                                            ::  values_real32_0d_pointer   !< pointer to resortet array
-   REAL(KIND=8), POINTER                                            ::  values_real64_0d_pointer   !< pointer to resortet array
-   REAL(wp),     POINTER                                            ::  values_realwp_0d_pointer   !< pointer to resortet array
-   REAL(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:)                  ::  values_real32_1d_pointer   !< pointer to resortet array
-   REAL(KIND=8), POINTER, CONTIGUOUS, DIMENSION(:)                  ::  values_real64_1d_pointer   !< pointer to resortet array
-   REAL(wp),     POINTER, CONTIGUOUS, DIMENSION(:)                  ::  values_realwp_1d_pointer   !< pointer to resortet array
-   REAL(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:,:)                ::  values_real32_2d_pointer   !< pointer to resortet array
-   REAL(KIND=8), POINTER, CONTIGUOUS, DIMENSION(:,:)                ::  values_real64_2d_pointer   !< pointer to resortet array
-   REAL(wp),     POINTER, CONTIGUOUS, DIMENSION(:,:)                ::  values_realwp_2d_pointer   !< pointer to resortet array
-   REAL(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:,:,:)              ::  values_real32_3d_pointer   !< pointer to resortet array
-   REAL(KIND=8), POINTER, CONTIGUOUS, DIMENSION(:,:,:)              ::  values_real64_3d_pointer   !< pointer to resortet array
-   REAL(wp),     POINTER, CONTIGUOUS, DIMENSION(:,:,:)              ::  values_realwp_3d_pointer   !< pointer to resortet array
-
-   TYPE(dimension_type), DIMENSION(:), ALLOCATABLE ::  dimension_list  !< list of used dimensions of variable
-
-
-   return_value = 0
-   output_return_value = 0
-
-   CALL internal_message( 'debug', routine_name // ': write ' // TRIM( variable_name ) // &
-                          ' into file ' // TRIM( file_name ) )
-
-   !-- Search for variable within file
-   CALL find_var_in_file( file_name, variable_name, file_format, file_id, variable_id, &
-                          is_global, dimension_list, return_value=return_value  )
-
-   IF ( return_value == 0 )  THEN
-
-      !-- Check if the correct amount of variable bounds were given
-      IF ( SIZE( bounds_start ) /= SIZE( dimension_list )  .OR.  &
-           SIZE( bounds_end ) /= SIZE( dimension_list ) )  THEN
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                  &
-                                ': number bounds do not match with ' //   &
-                                'number of dimensions of variable ' //    &
-                                '(variable "' // TRIM( variable_name ) // &
-                                '", file "' // TRIM( file_name ) // '")!' )
-      ENDIF
-
-   ENDIF
-
-   IF ( return_value == 0 )  THEN
-
-      !-- Save starting index (lower bounds) of each dimension
-      ALLOCATE( bounds_origin(SIZE( dimension_list )) )
-      ALLOCATE( bounds_start_internal(SIZE( dimension_list )) )
-      ALLOCATE( value_counts(SIZE( dimension_list )) )
-
-      WRITE( temp_string, * ) bounds_start
-      CALL internal_message( 'debug', routine_name //                    &
-                             ': file "' // TRIM( file_name ) //          &
-                             '", variable "' // TRIM( variable_name ) // &
-                             '", bounds_start =' // TRIM( temp_string ) )
-      WRITE( temp_string, * ) bounds_end
-      CALL internal_message( 'debug', routine_name //                    &
-                             ': file "' // TRIM( file_name ) //          &
-                             '", variable "' // TRIM( variable_name ) // &
-                             '", bounds_end =' // TRIM( temp_string ) )
-
-      !-- Get bounds for masking
-      CALL get_masked_indices_and_masked_dimension_bounds( dimension_list,                  &
-              bounds_start, bounds_end, bounds_start_internal, value_counts, bounds_origin, &
-              masked_indices )
-
-      do_output = .NOT. ANY( value_counts == 0 )
-
-      WRITE( temp_string, * ) bounds_start_internal
-      CALL internal_message( 'debug', routine_name //                    &
-                             ': file "' // TRIM( file_name ) //          &
-                             '", variable "' // TRIM( variable_name ) // &
-                             '", bounds_start_internal =' // TRIM( temp_string ) )
-      WRITE( temp_string, * ) value_counts
-      CALL internal_message( 'debug', routine_name //                    &
-                             ': file "' // TRIM( file_name ) //          &
-                             '", variable "' // TRIM( variable_name ) // &
-                             '", value_counts =' // TRIM( temp_string ) )
-
-      !-- Mask and resort variable
-      !-- 8bit integer output
-      IF ( PRESENT( values_int8_0d ) )  THEN
-         values_int8_0d_pointer => values_int8_0d
-      ELSEIF ( PRESENT( values_int8_1d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_int8_1d_resorted(0:value_counts(1)-1) )
-            !$OMP PARALLEL PRIVATE (i)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               values_int8_1d_resorted(i) = values_int8_1d(masked_indices(1,i))
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_int8_1d_resorted(1) )
-            values_int8_1d_resorted = 0_1
-         ENDIF
-         values_int8_1d_pointer => values_int8_1d_resorted
-      ELSEIF ( PRESENT( values_int8_2d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_int8_2d_resorted(0:value_counts(1)-1, &
-                                              0:value_counts(2)-1) )
-            !$OMP PARALLEL PRIVATE (i,j)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  values_int8_2d_resorted(i,j) = values_int8_2d(masked_indices(2,j), &
-                                                                masked_indices(1,i)  )
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_int8_2d_resorted(1,1) )
-            values_int8_2d_resorted = 0_1
-         ENDIF
-         values_int8_2d_pointer => values_int8_2d_resorted
-      ELSEIF ( PRESENT( values_int8_3d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_int8_3d_resorted(0:value_counts(1)-1, &
-                                              0:value_counts(2)-1, &
-                                              0:value_counts(3)-1) )
-            !$OMP PARALLEL PRIVATE (i,j,k)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  DO  k = 0, value_counts(3) - 1
-                     values_int8_3d_resorted(i,j,k) = values_int8_3d(masked_indices(3,k), &
-                                                                     masked_indices(2,j), &
-                                                                     masked_indices(1,i)  )
-                  ENDDO
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_int8_3d_resorted(1,1,1) )
-            values_int8_3d_resorted = 0_1
-         ENDIF
-         values_int8_3d_pointer => values_int8_3d_resorted
-
-      !-- 16bit integer output
-      ELSEIF ( PRESENT( values_int16_0d ) )  THEN
-         values_int16_0d_pointer => values_int16_0d
-      ELSEIF ( PRESENT( values_int16_1d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_int16_1d_resorted(0:value_counts(1)-1) )
-            !$OMP PARALLEL PRIVATE (i)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               values_int16_1d_resorted(i) = values_int16_1d(masked_indices(1,i))
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_int16_1d_resorted(1) )
-            values_int16_1d_resorted = 0_1
-         ENDIF
-         values_int16_1d_pointer => values_int16_1d_resorted
-      ELSEIF ( PRESENT( values_int16_2d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_int16_2d_resorted(0:value_counts(1)-1, &
+ FUNCTION dom_write_var( file_name, variable_name, bounds_start, bounds_end,         &
+             values_int8_0d,   values_int8_1d,   values_int8_2d,   values_int8_3d,   &
+             values_int16_0d,  values_int16_1d,  values_int16_2d,  values_int16_3d,  &
+             values_int32_0d,  values_int32_1d,  values_int32_2d,  values_int32_3d,  &
+             values_intwp_0d,  values_intwp_1d,  values_intwp_2d,  values_intwp_3d,  &
+             values_real32_0d, values_real32_1d, values_real32_2d, values_real32_3d, &
+             values_real64_0d, values_real64_1d, values_real64_2d, values_real64_3d, &
+             values_realwp_0d, values_realwp_1d, values_realwp_2d, values_realwp_3d  &
+             ) RESULT( return_value )
+
+    CHARACTER(LEN=charlen)            ::  file_format    !< file format chosen for file
+    CHARACTER(LEN=*),      INTENT(IN) ::  file_name      !< name of file
+    CHARACTER(LEN=*),      INTENT(IN) ::  variable_name  !< name of variable
+
+    CHARACTER(LEN=*), PARAMETER ::  routine_name = 'dom_write_var'  !< name of routine
+
+    INTEGER ::  file_id              !< file ID
+    INTEGER ::  i                    !< loop index
+    INTEGER ::  j                    !< loop index
+    INTEGER ::  k                    !< loop index
+    INTEGER ::  output_return_value  !< return value of a called output routine
+    INTEGER ::  return_value         !< return value
+    INTEGER ::  variable_id          !< variable ID
+
+    INTEGER, DIMENSION(:),   INTENT(IN)  ::  bounds_end             !< end index per dimension of variable
+    INTEGER, DIMENSION(:),   INTENT(IN)  ::  bounds_start           !< start index per dimension of variable
+    INTEGER, DIMENSION(:),   ALLOCATABLE ::  bounds_origin          !< first index of each dimension
+    INTEGER, DIMENSION(:),   ALLOCATABLE ::  bounds_start_internal  !< start index per dim. for output after masking
+    INTEGER, DIMENSION(:),   ALLOCATABLE ::  value_counts           !< count of indices to be written per dimension
+    INTEGER, DIMENSION(:,:), ALLOCATABLE ::  masked_indices         !< list containing all output indices along a dimension
+
+    LOGICAL ::  do_output  !< true if any data lies within given range of masked dimension
+    LOGICAL ::  is_global  !< true if variable is global
+
+    INTEGER(KIND=1), POINTER, INTENT(IN), OPTIONAL                   ::  values_int8_0d             !< output variable
+    INTEGER(KIND=2), POINTER, INTENT(IN), OPTIONAL                   ::  values_int16_0d            !< output variable
+    INTEGER(KIND=4), POINTER, INTENT(IN), OPTIONAL                   ::  values_int32_0d            !< output variable
+    INTEGER(iwp),    POINTER, INTENT(IN), OPTIONAL                   ::  values_intwp_0d            !< output variable
+    INTEGER(KIND=1), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int8_1d             !< output variable
+    INTEGER(KIND=2), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int16_1d            !< output variable
+    INTEGER(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_int32_1d            !< output variable
+    INTEGER(iwp),    POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)     ::  values_intwp_1d            !< output variable
+    INTEGER(KIND=1), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int8_2d             !< output variable
+    INTEGER(KIND=2), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int16_2d            !< output variable
+    INTEGER(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_int32_2d            !< output variable
+    INTEGER(iwp),    POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)   ::  values_intwp_2d            !< output variable
+    INTEGER(KIND=1), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int8_3d             !< output variable
+    INTEGER(KIND=2), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int16_3d            !< output variable
+    INTEGER(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_int32_3d            !< output variable
+    INTEGER(iwp),    POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:) ::  values_intwp_3d            !< output variable
+
+    INTEGER(KIND=1), TARGET, ALLOCATABLE, DIMENSION(:)               ::  values_int8_1d_resorted    !< resorted output variable
+    INTEGER(KIND=2), TARGET, ALLOCATABLE, DIMENSION(:)               ::  values_int16_1d_resorted   !< resorted output variable
+    INTEGER(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:)               ::  values_int32_1d_resorted   !< resorted output variable
+    INTEGER(iwp),    TARGET, ALLOCATABLE, DIMENSION(:)               ::  values_intwp_1d_resorted   !< resorted output variable
+    INTEGER(KIND=1), TARGET, ALLOCATABLE, DIMENSION(:,:)             ::  values_int8_2d_resorted    !< resorted output variable
+    INTEGER(KIND=2), TARGET, ALLOCATABLE, DIMENSION(:,:)             ::  values_int16_2d_resorted   !< resorted output variable
+    INTEGER(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:,:)             ::  values_int32_2d_resorted   !< resorted output variable
+    INTEGER(iwp),    TARGET, ALLOCATABLE, DIMENSION(:,:)             ::  values_intwp_2d_resorted   !< resorted output variable
+    INTEGER(KIND=1), TARGET, ALLOCATABLE, DIMENSION(:,:,:)           ::  values_int8_3d_resorted    !< resorted output variable
+    INTEGER(KIND=2), TARGET, ALLOCATABLE, DIMENSION(:,:,:)           ::  values_int16_3d_resorted   !< resorted output variable
+    INTEGER(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:,:,:)           ::  values_int32_3d_resorted   !< resorted output variable
+    INTEGER(iwp),    TARGET, ALLOCATABLE, DIMENSION(:,:,:)           ::  values_intwp_3d_resorted   !< resorted output variable
+
+    INTEGER(KIND=1), POINTER                                         ::  values_int8_0d_pointer     !< pointer to resortet array
+    INTEGER(KIND=2), POINTER                                         ::  values_int16_0d_pointer    !< pointer to resortet array
+    INTEGER(KIND=4), POINTER                                         ::  values_int32_0d_pointer    !< pointer to resortet array
+    INTEGER(iwp),    POINTER                                         ::  values_intwp_0d_pointer    !< pointer to resortet array
+    INTEGER(KIND=1), POINTER, CONTIGUOUS, DIMENSION(:)               ::  values_int8_1d_pointer     !< pointer to resortet array
+    INTEGER(KIND=2), POINTER, CONTIGUOUS, DIMENSION(:)               ::  values_int16_1d_pointer    !< pointer to resortet array
+    INTEGER(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:)               ::  values_int32_1d_pointer    !< pointer to resortet array
+    INTEGER(iwp),    POINTER, CONTIGUOUS, DIMENSION(:)               ::  values_intwp_1d_pointer    !< pointer to resortet array
+    INTEGER(KIND=1), POINTER, CONTIGUOUS, DIMENSION(:,:)             ::  values_int8_2d_pointer     !< pointer to resortet array
+    INTEGER(KIND=2), POINTER, CONTIGUOUS, DIMENSION(:,:)             ::  values_int16_2d_pointer    !< pointer to resortet array
+    INTEGER(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:,:)             ::  values_int32_2d_pointer    !< pointer to resortet array
+    INTEGER(iwp),    POINTER, CONTIGUOUS, DIMENSION(:,:)             ::  values_intwp_2d_pointer    !< pointer to resortet array
+    INTEGER(KIND=1), POINTER, CONTIGUOUS, DIMENSION(:,:,:)           ::  values_int8_3d_pointer     !< pointer to resortet array
+    INTEGER(KIND=2), POINTER, CONTIGUOUS, DIMENSION(:,:,:)           ::  values_int16_3d_pointer    !< pointer to resortet array
+    INTEGER(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:,:,:)           ::  values_int32_3d_pointer    !< pointer to resortet array
+    INTEGER(iwp),    POINTER, CONTIGUOUS, DIMENSION(:,:,:)           ::  values_intwp_3d_pointer    !< pointer to resortet array
+
+    REAL(KIND=4), POINTER, INTENT(IN), OPTIONAL                      ::  values_real32_0d           !< output variable
+    REAL(KIND=8), POINTER, INTENT(IN), OPTIONAL                      ::  values_real64_0d           !< output variable
+    REAL(wp),     POINTER, INTENT(IN), OPTIONAL                      ::  values_realwp_0d           !< output variable
+    REAL(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)        ::  values_real32_1d           !< output variable
+    REAL(KIND=8), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)        ::  values_real64_1d           !< output variable
+    REAL(wp),     POINTER, INTENT(IN), OPTIONAL, DIMENSION(:)        ::  values_realwp_1d           !< output variable
+    REAL(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)      ::  values_real32_2d           !< output variable
+    REAL(KIND=8), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)      ::  values_real64_2d           !< output variable
+    REAL(wp),     POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:)      ::  values_realwp_2d           !< output variable
+    REAL(KIND=4), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:)    ::  values_real32_3d           !< output variable
+    REAL(KIND=8), POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:)    ::  values_real64_3d           !< output variable
+    REAL(wp),     POINTER, INTENT(IN), OPTIONAL, DIMENSION(:,:,:)    ::  values_realwp_3d           !< output variable
+
+    REAL(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:)                  ::  values_real32_1d_resorted  !< resorted output variable
+    REAL(KIND=8), TARGET, ALLOCATABLE, DIMENSION(:)                  ::  values_real64_1d_resorted  !< resorted output variable
+    REAL(wp),     TARGET, ALLOCATABLE, DIMENSION(:)                  ::  values_realwp_1d_resorted  !< resorted output variable
+    REAL(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:,:)                ::  values_real32_2d_resorted  !< resorted output variable
+    REAL(KIND=8), TARGET, ALLOCATABLE, DIMENSION(:,:)                ::  values_real64_2d_resorted  !< resorted output variable
+    REAL(wp),     TARGET, ALLOCATABLE, DIMENSION(:,:)                ::  values_realwp_2d_resorted  !< resorted output variable
+    REAL(KIND=4), TARGET, ALLOCATABLE, DIMENSION(:,:,:)              ::  values_real32_3d_resorted  !< resorted output variable
+    REAL(KIND=8), TARGET, ALLOCATABLE, DIMENSION(:,:,:)              ::  values_real64_3d_resorted  !< resorted output variable
+    REAL(wp),     TARGET, ALLOCATABLE, DIMENSION(:,:,:)              ::  values_realwp_3d_resorted  !< resorted output variable
+
+    REAL(KIND=4), POINTER                                            ::  values_real32_0d_pointer   !< pointer to resortet array
+    REAL(KIND=8), POINTER                                            ::  values_real64_0d_pointer   !< pointer to resortet array
+    REAL(wp),     POINTER                                            ::  values_realwp_0d_pointer   !< pointer to resortet array
+    REAL(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:)                  ::  values_real32_1d_pointer   !< pointer to resortet array
+    REAL(KIND=8), POINTER, CONTIGUOUS, DIMENSION(:)                  ::  values_real64_1d_pointer   !< pointer to resortet array
+    REAL(wp),     POINTER, CONTIGUOUS, DIMENSION(:)                  ::  values_realwp_1d_pointer   !< pointer to resortet array
+    REAL(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:,:)                ::  values_real32_2d_pointer   !< pointer to resortet array
+    REAL(KIND=8), POINTER, CONTIGUOUS, DIMENSION(:,:)                ::  values_real64_2d_pointer   !< pointer to resortet array
+    REAL(wp),     POINTER, CONTIGUOUS, DIMENSION(:,:)                ::  values_realwp_2d_pointer   !< pointer to resortet array
+    REAL(KIND=4), POINTER, CONTIGUOUS, DIMENSION(:,:,:)              ::  values_real32_3d_pointer   !< pointer to resortet array
+    REAL(KIND=8), POINTER, CONTIGUOUS, DIMENSION(:,:,:)              ::  values_real64_3d_pointer   !< pointer to resortet array
+    REAL(wp),     POINTER, CONTIGUOUS, DIMENSION(:,:,:)              ::  values_realwp_3d_pointer   !< pointer to resortet array
+
+    TYPE(dimension_type), DIMENSION(:), ALLOCATABLE ::  dimension_list  !< list of used dimensions of variable
+
+
+    return_value = 0
+    output_return_value = 0
+
+    CALL internal_message( 'debug', routine_name // ': write ' // TRIM( variable_name ) // &
+                           ' into file ' // TRIM( file_name ) )
+!
+!-- Search for variable within file
+    CALL find_var_in_file( file_name, variable_name, file_format, file_id, variable_id, &
+                           is_global, dimension_list, return_value=return_value  )
+
+    IF ( return_value == 0 )  THEN
+!
+!--    Check if the correct amount of variable bounds were given
+       IF ( SIZE( bounds_start ) /= SIZE( dimension_list )  .OR.  &
+            SIZE( bounds_end ) /= SIZE( dimension_list ) )  THEN
+          return_value = 1
+          CALL internal_message( 'error', routine_name //                  &
+                                 ': number bounds do not match with ' //   &
+                                 'number of dimensions of variable ' //    &
+                                 '(variable "' // TRIM( variable_name ) // &
+                                 '", file "' // TRIM( file_name ) // '")!' )
+       ENDIF
+
+    ENDIF
+
+    IF ( return_value == 0 )  THEN
+!
+!--    Save starting index (lower bounds) of each dimension
+       ALLOCATE( bounds_origin(SIZE( dimension_list )) )
+       ALLOCATE( bounds_start_internal(SIZE( dimension_list )) )
+       ALLOCATE( value_counts(SIZE( dimension_list )) )
+
+       WRITE( temp_string, * ) bounds_start
+       CALL internal_message( 'debug', routine_name //                    &
+                              ': file "' // TRIM( file_name ) //          &
+                              '", variable "' // TRIM( variable_name ) // &
+                              '", bounds_start =' // TRIM( temp_string ) )
+       WRITE( temp_string, * ) bounds_end
+       CALL internal_message( 'debug', routine_name //                    &
+                              ': file "' // TRIM( file_name ) //          &
+                              '", variable "' // TRIM( variable_name ) // &
+                              '", bounds_end =' // TRIM( temp_string ) )
+!
+!--    Get bounds for masking
+       CALL get_masked_indices_and_masked_dimension_bounds( dimension_list,                  &
+               bounds_start, bounds_end, bounds_start_internal, value_counts, bounds_origin, &
+               masked_indices )
+
+       do_output = .NOT. ANY( value_counts == 0 )
+
+       WRITE( temp_string, * ) bounds_start_internal
+       CALL internal_message( 'debug', routine_name //                    &
+                              ': file "' // TRIM( file_name ) //          &
+                              '", variable "' // TRIM( variable_name ) // &
+                              '", bounds_start_internal =' // TRIM( temp_string ) )
+       WRITE( temp_string, * ) value_counts
+       CALL internal_message( 'debug', routine_name //                    &
+                              ': file "' // TRIM( file_name ) //          &
+                              '", variable "' // TRIM( variable_name ) // &
+                              '", value_counts =' // TRIM( temp_string ) )
+!
+!--    Mask and resort variable
+!--    8bit integer output
+       IF ( PRESENT( values_int8_0d ) )  THEN
+          values_int8_0d_pointer => values_int8_0d
+       ELSEIF ( PRESENT( values_int8_1d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_int8_1d_resorted(0:value_counts(1)-1) )
+             !$OMP PARALLEL PRIVATE (i)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                values_int8_1d_resorted(i) = values_int8_1d(masked_indices(1,i))
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_int8_1d_resorted(1) )
+             values_int8_1d_resorted = 0_1
+          ENDIF
+          values_int8_1d_pointer => values_int8_1d_resorted
+       ELSEIF ( PRESENT( values_int8_2d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_int8_2d_resorted(0:value_counts(1)-1, &
                                                0:value_counts(2)-1) )
-            !$OMP PARALLEL PRIVATE (i,j)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  values_int16_2d_resorted(i,j) = values_int16_2d(masked_indices(2,j), &
-                                                                  masked_indices(1,i))
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_int16_2d_resorted(1,1) )
-            values_int16_2d_resorted = 0_1
-         ENDIF
-         values_int16_2d_pointer => values_int16_2d_resorted
-      ELSEIF ( PRESENT( values_int16_3d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_int16_3d_resorted(0:value_counts(1)-1, &
+             !$OMP PARALLEL PRIVATE (i,j)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                DO  j = 0, value_counts(2) - 1
+                   values_int8_2d_resorted(i,j) = values_int8_2d(masked_indices(2,j), &
+                                                                 masked_indices(1,i)  )
+                ENDDO
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_int8_2d_resorted(1,1) )
+             values_int8_2d_resorted = 0_1
+          ENDIF
+          values_int8_2d_pointer => values_int8_2d_resorted
+       ELSEIF ( PRESENT( values_int8_3d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_int8_3d_resorted(0:value_counts(1)-1, &
                                                0:value_counts(2)-1, &
                                                0:value_counts(3)-1) )
-            !$OMP PARALLEL PRIVATE (i,j,k)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  DO  k = 0, value_counts(3) - 1
-                     values_int16_3d_resorted(i,j,k) = values_int16_3d(masked_indices(3,k), &
-                                                                       masked_indices(2,j), &
-                                                                       masked_indices(1,i)  )
-                  ENDDO
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_int16_3d_resorted(1,1,1) )
-            values_int16_3d_resorted = 0_1
-         ENDIF
-         values_int16_3d_pointer => values_int16_3d_resorted
-
-      !-- 32bit integer output
-      ELSEIF ( PRESENT( values_int32_0d ) )  THEN
-         values_int32_0d_pointer => values_int32_0d
-      ELSEIF ( PRESENT( values_int32_1d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_int32_1d_resorted(0:value_counts(1)-1) )
-            !$OMP PARALLEL PRIVATE (i)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               values_int32_1d_resorted(i) = values_int32_1d(masked_indices(1,i))
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_int32_1d_resorted(1) )
-            values_int32_1d_resorted = 0_1
-         ENDIF
-         values_int32_1d_pointer => values_int32_1d_resorted
-      ELSEIF ( PRESENT( values_int32_2d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_int32_2d_resorted(0:value_counts(1)-1, &
-                                               0:value_counts(2)-1) )
-            !$OMP PARALLEL PRIVATE (i,j)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  values_int32_2d_resorted(i,j) = values_int32_2d(masked_indices(2,j), &
-                                                                  masked_indices(1,i)  )
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_int32_2d_resorted(1,1) )
-            values_int32_2d_resorted = 0_1
-         ENDIF
-         values_int32_2d_pointer => values_int32_2d_resorted
-      ELSEIF ( PRESENT( values_int32_3d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_int32_3d_resorted(0:value_counts(1)-1, &
-                                               0:value_counts(2)-1, &
-                                               0:value_counts(3)-1) )
-            !$OMP PARALLEL PRIVATE (i,j,k)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  DO  k = 0, value_counts(3) - 1
-                     values_int32_3d_resorted(i,j,k) = values_int32_3d(masked_indices(3,k), &
-                                                                       masked_indices(2,j), &
-                                                                       masked_indices(1,i)  )
-                  ENDDO
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_int32_3d_resorted(1,1,1) )
-            values_int32_3d_resorted = 0_1
-         ENDIF
-         values_int32_3d_pointer => values_int32_3d_resorted
-
-      !-- working-precision integer output
-      ELSEIF ( PRESENT( values_intwp_0d ) )  THEN
-         values_intwp_0d_pointer => values_intwp_0d
-      ELSEIF ( PRESENT( values_intwp_1d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_intwp_1d_resorted(0:value_counts(1)-1) )
-            !$OMP PARALLEL PRIVATE (i)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               values_intwp_1d_resorted(i) = values_intwp_1d(masked_indices(1,i))
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_intwp_1d_resorted(1) )
-            values_intwp_1d_resorted = 0_1
-         ENDIF
-         values_intwp_1d_pointer => values_intwp_1d_resorted
-      ELSEIF ( PRESENT( values_intwp_2d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_intwp_2d_resorted(0:value_counts(1)-1, &
-                                               0:value_counts(2)-1) )
-            !$OMP PARALLEL PRIVATE (i,j)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  values_intwp_2d_resorted(i,j) = values_intwp_2d(masked_indices(2,j), &
-                                                                  masked_indices(1,i)  )
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_intwp_2d_resorted(1,1) )
-            values_intwp_2d_resorted = 0_1
-         ENDIF
-         values_intwp_2d_pointer => values_intwp_2d_resorted
-      ELSEIF ( PRESENT( values_intwp_3d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_intwp_3d_resorted(0:value_counts(1)-1, &
-                                               0:value_counts(2)-1, &
-                                               0:value_counts(3)-1) )
-            !$OMP PARALLEL PRIVATE (i,j,k)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  DO  k = 0, value_counts(3) - 1
-                     values_intwp_3d_resorted(i,j,k) = values_intwp_3d(masked_indices(3,k), &
-                                                                       masked_indices(2,j), &
-                                                                       masked_indices(1,i)  )
-                  ENDDO
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_intwp_3d_resorted(1,1,1) )
-            values_intwp_3d_resorted = 0_1
-         ENDIF
-         values_intwp_3d_pointer => values_intwp_3d_resorted
-
-      !-- 32bit real output
-      ELSEIF ( PRESENT( values_real32_0d ) )  THEN
-         values_real32_0d_pointer => values_real32_0d
-      ELSEIF ( PRESENT( values_real32_1d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_real32_1d_resorted(0:value_counts(1)-1) )
-            !$OMP PARALLEL PRIVATE (i)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               values_real32_1d_resorted(i) = values_real32_1d(masked_indices(1,i))
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_real32_1d_resorted(1) )
-            values_real32_1d_resorted = 0_1
-         ENDIF
-         values_real32_1d_pointer => values_real32_1d_resorted
-      ELSEIF ( PRESENT( values_real32_2d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_real32_2d_resorted(0:value_counts(1)-1, &
+             !$OMP PARALLEL PRIVATE (i,j,k)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                DO  j = 0, value_counts(2) - 1
+                   DO  k = 0, value_counts(3) - 1
+                      values_int8_3d_resorted(i,j,k) = values_int8_3d(masked_indices(3,k), &
+                                                                      masked_indices(2,j), &
+                                                                      masked_indices(1,i)  )
+                   ENDDO
+                ENDDO
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_int8_3d_resorted(1,1,1) )
+             values_int8_3d_resorted = 0_1
+          ENDIF
+          values_int8_3d_pointer => values_int8_3d_resorted
+!
+!--    16bit integer output
+       ELSEIF ( PRESENT( values_int16_0d ) )  THEN
+          values_int16_0d_pointer => values_int16_0d
+       ELSEIF ( PRESENT( values_int16_1d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_int16_1d_resorted(0:value_counts(1)-1) )
+             !$OMP PARALLEL PRIVATE (i)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                values_int16_1d_resorted(i) = values_int16_1d(masked_indices(1,i))
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_int16_1d_resorted(1) )
+             values_int16_1d_resorted = 0_1
+          ENDIF
+          values_int16_1d_pointer => values_int16_1d_resorted
+       ELSEIF ( PRESENT( values_int16_2d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_int16_2d_resorted(0:value_counts(1)-1, &
                                                 0:value_counts(2)-1) )
-            !$OMP PARALLEL PRIVATE (i,j)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  values_real32_2d_resorted(i,j) = values_real32_2d(masked_indices(2,j), &
-                                                                    masked_indices(1,i)  )
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_real32_2d_resorted(1,1) )
-            values_real32_2d_resorted = 0_1
-         ENDIF
-         values_real32_2d_pointer => values_real32_2d_resorted
-      ELSEIF ( PRESENT( values_real32_3d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_real32_3d_resorted(0:value_counts(1)-1, &
+             !$OMP PARALLEL PRIVATE (i,j)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                DO  j = 0, value_counts(2) - 1
+                   values_int16_2d_resorted(i,j) = values_int16_2d(masked_indices(2,j), &
+                                                                   masked_indices(1,i))
+                ENDDO
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_int16_2d_resorted(1,1) )
+             values_int16_2d_resorted = 0_1
+          ENDIF
+          values_int16_2d_pointer => values_int16_2d_resorted
+       ELSEIF ( PRESENT( values_int16_3d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_int16_3d_resorted(0:value_counts(1)-1, &
                                                 0:value_counts(2)-1, &
                                                 0:value_counts(3)-1) )
-            !$OMP PARALLEL PRIVATE (i,j,k)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  DO  k = 0, value_counts(3) - 1
-                     values_real32_3d_resorted(i,j,k) = values_real32_3d(masked_indices(3,k), &
-                                                                         masked_indices(2,j), &
-                                                                         masked_indices(1,i)  )
-                  ENDDO
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_real32_3d_resorted(1,1,1) )
-            values_real32_3d_resorted = 0_1
-         ENDIF
-         values_real32_3d_pointer => values_real32_3d_resorted
-
-      !-- 64bit real output
-      ELSEIF ( PRESENT( values_real64_0d ) )  THEN
-         values_real64_0d_pointer => values_real64_0d
-      ELSEIF ( PRESENT( values_real64_1d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_real64_1d_resorted(0:value_counts(1)-1) )
-            !$OMP PARALLEL PRIVATE (i)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               values_real64_1d_resorted(i) = values_real64_1d(masked_indices(1,i))
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_real64_1d_resorted(1) )
-            values_real64_1d_resorted = 0_1
-         ENDIF
-         values_real64_1d_pointer => values_real64_1d_resorted
-      ELSEIF ( PRESENT( values_real64_2d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_real64_2d_resorted(0:value_counts(1)-1, &
+             !$OMP PARALLEL PRIVATE (i,j,k)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                DO  j = 0, value_counts(2) - 1
+                   DO  k = 0, value_counts(3) - 1
+                      values_int16_3d_resorted(i,j,k) = values_int16_3d(masked_indices(3,k), &
+                                                                        masked_indices(2,j), &
+                                                                        masked_indices(1,i)  )
+                   ENDDO
+                ENDDO
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_int16_3d_resorted(1,1,1) )
+             values_int16_3d_resorted = 0_1
+          ENDIF
+          values_int16_3d_pointer => values_int16_3d_resorted
+!
+!--    32bit integer output
+       ELSEIF ( PRESENT( values_int32_0d ) )  THEN
+          values_int32_0d_pointer => values_int32_0d
+       ELSEIF ( PRESENT( values_int32_1d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_int32_1d_resorted(0:value_counts(1)-1) )
+             !$OMP PARALLEL PRIVATE (i)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                values_int32_1d_resorted(i) = values_int32_1d(masked_indices(1,i))
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_int32_1d_resorted(1) )
+             values_int32_1d_resorted = 0_1
+          ENDIF
+          values_int32_1d_pointer => values_int32_1d_resorted
+       ELSEIF ( PRESENT( values_int32_2d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_int32_2d_resorted(0:value_counts(1)-1, &
                                                 0:value_counts(2)-1) )
-            !$OMP PARALLEL PRIVATE (i,j)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  values_real64_2d_resorted(i,j) = values_real64_2d(masked_indices(2,j), &
-                                                                    masked_indices(1,i)  )
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_real64_2d_resorted(1,1) )
-            values_real64_2d_resorted = 0_1
-         ENDIF
-         values_real64_2d_pointer => values_real64_2d_resorted
-      ELSEIF ( PRESENT( values_real64_3d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_real64_3d_resorted(0:value_counts(1)-1, &
+             !$OMP PARALLEL PRIVATE (i,j)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                DO  j = 0, value_counts(2) - 1
+                   values_int32_2d_resorted(i,j) = values_int32_2d(masked_indices(2,j), &
+                                                                   masked_indices(1,i)  )
+                ENDDO
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_int32_2d_resorted(1,1) )
+             values_int32_2d_resorted = 0_1
+          ENDIF
+          values_int32_2d_pointer => values_int32_2d_resorted
+       ELSEIF ( PRESENT( values_int32_3d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_int32_3d_resorted(0:value_counts(1)-1, &
                                                 0:value_counts(2)-1, &
                                                 0:value_counts(3)-1) )
-            !$OMP PARALLEL PRIVATE (i,j,k)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  DO  k = 0, value_counts(3) - 1
-                     values_real64_3d_resorted(i,j,k) = values_real64_3d(masked_indices(3,k), &
-                                                                         masked_indices(2,j), &
-                                                                         masked_indices(1,i)  )
-                  ENDDO
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_real64_3d_resorted(1,1,1) )
-            values_real64_3d_resorted = 0_1
-         ENDIF
-         values_real64_3d_pointer => values_real64_3d_resorted
-
-      !-- working-precision real output
-      ELSEIF ( PRESENT( values_realwp_0d ) )  THEN
-         values_realwp_0d_pointer => values_realwp_0d
-      ELSEIF ( PRESENT( values_realwp_1d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_realwp_1d_resorted(0:value_counts(1)-1) )
-            !$OMP PARALLEL PRIVATE (i)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               values_realwp_1d_resorted(i) = values_realwp_1d(masked_indices(1,i))
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_realwp_1d_resorted(1) )
-            values_realwp_1d_resorted = 0_1
-         ENDIF
-         values_realwp_1d_pointer => values_realwp_1d_resorted
-      ELSEIF ( PRESENT( values_realwp_2d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_realwp_2d_resorted(0:value_counts(1)-1, &
+             !$OMP PARALLEL PRIVATE (i,j,k)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                DO  j = 0, value_counts(2) - 1
+                   DO  k = 0, value_counts(3) - 1
+                      values_int32_3d_resorted(i,j,k) = values_int32_3d(masked_indices(3,k), &
+                                                                        masked_indices(2,j), &
+                                                                        masked_indices(1,i)  )
+                   ENDDO
+                ENDDO
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_int32_3d_resorted(1,1,1) )
+             values_int32_3d_resorted = 0_1
+          ENDIF
+          values_int32_3d_pointer => values_int32_3d_resorted
+!
+!--    working-precision integer output
+       ELSEIF ( PRESENT( values_intwp_0d ) )  THEN
+          values_intwp_0d_pointer => values_intwp_0d
+       ELSEIF ( PRESENT( values_intwp_1d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_intwp_1d_resorted(0:value_counts(1)-1) )
+             !$OMP PARALLEL PRIVATE (i)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                values_intwp_1d_resorted(i) = values_intwp_1d(masked_indices(1,i))
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_intwp_1d_resorted(1) )
+             values_intwp_1d_resorted = 0_1
+          ENDIF
+          values_intwp_1d_pointer => values_intwp_1d_resorted
+       ELSEIF ( PRESENT( values_intwp_2d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_intwp_2d_resorted(0:value_counts(1)-1, &
                                                 0:value_counts(2)-1) )
-            !$OMP PARALLEL PRIVATE (i,j)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  values_realwp_2d_resorted(i,j) = values_realwp_2d(masked_indices(2,j), &
-                                                                    masked_indices(1,i)  )
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_realwp_2d_resorted(1,1) )
-            values_realwp_2d_resorted = 0_1
-         ENDIF
-         values_realwp_2d_pointer => values_realwp_2d_resorted
-      ELSEIF ( PRESENT( values_realwp_3d ) )  THEN
-         IF ( do_output ) THEN
-            ALLOCATE( values_realwp_3d_resorted(0:value_counts(1)-1, &
+             !$OMP PARALLEL PRIVATE (i,j)
+             !$OMP DO
+             DO  i = 0, value_counts(1) - 1
+                DO  j = 0, value_counts(2) - 1
+                   values_intwp_2d_resorted(i,j) = values_intwp_2d(masked_indices(2,j), &
+                                                                   masked_indices(1,i)  )
+                ENDDO
+             ENDDO
+             !$OMP END PARALLEL
+          ELSE
+             ALLOCATE( values_intwp_2d_resorted(1,1) )
+             values_intwp_2d_resorted = 0_1
+          ENDIF
+          values_intwp_2d_pointer => values_intwp_2d_resorted
+       ELSEIF ( PRESENT( values_intwp_3d ) )  THEN
+          IF ( do_output ) THEN
+             ALLOCATE( values_intwp_3d_resorted(0:value_counts(1)-1, &
                                                 0:value_counts(2)-1, &
                                                 0:value_counts(3)-1) )
-            !$OMP PARALLEL PRIVATE (i,j,k)
-            !$OMP DO
-            DO  i = 0, value_counts(1) - 1
-               DO  j = 0, value_counts(2) - 1
-                  DO  k = 0, value_counts(3) - 1
-                     values_realwp_3d_resorted(i,j,k) = values_realwp_3d(masked_indices(3,k), &
-                                                                         masked_indices(2,j), &
-                                                                         masked_indices(1,i)  )
-                  ENDDO
-               ENDDO
-            ENDDO
-            !$OMP END PARALLEL
-         ELSE
-            ALLOCATE( values_realwp_3d_resorted(1,1,1) )
-            values_realwp_3d_resorted = 0_1
-         ENDIF
-         values_realwp_3d_pointer => values_realwp_3d_resorted
-
-      ELSE
-         return_value = 1
-         CALL internal_message( 'error', routine_name //                  &
-                                ': no output values given ' //            &
-                                '(variable "' // TRIM( variable_name ) // &
-                                '", file "' // TRIM( file_name ) // '")!'  )
-      ENDIF
-
-      DEALLOCATE( masked_indices )
-
-   ENDIF  ! Check for error
-
-   IF ( return_value == 0 )  THEN
-
-      !-- Write variable into file
-      SELECT CASE ( TRIM( file_format ) )
-
-         CASE ( 'binary' )
-            !-- 8bit integer output
-            IF ( PRESENT( values_int8_0d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int8_0d=values_int8_0d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int8_1d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int8_1d=values_int8_1d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int8_2d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int8_2d=values_int8_2d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int8_3d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int8_3d=values_int8_3d_pointer, return_value=output_return_value )
-            !-- 16bit integer output
-            ELSEIF ( PRESENT( values_int16_0d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int16_0d=values_int16_0d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int16_1d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int16_1d=values_int16_1d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int16_2d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int16_2d=values_int16_2d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int16_3d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int16_3d=values_int16_3d_pointer, return_value=output_return_value )
-            !-- 32bit integer output
-            ELSEIF ( PRESENT( values_int32_0d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int32_0d=values_int32_0d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int32_1d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int32_1d=values_int32_1d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int32_2d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int32_2d=values_int32_2d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int32_3d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int32_3d=values_int32_3d_pointer, return_value=output_return_value )
-            !-- working-precision integer output
-            ELSEIF ( PRESENT( values_intwp_0d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_intwp_0d=values_intwp_0d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_intwp_1d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_intwp_1d=values_intwp_1d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_intwp_2d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_intwp_2d=values_intwp_2d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_intwp_3d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_intwp_3d=values_intwp_3d_pointer, return_value=output_return_value )
-            !-- 32bit real output
-            ELSEIF ( PRESENT( values_real32_0d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_real32_0d=values_real32_0d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_real32_1d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_real32_1d=values_real32_1d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_real32_2d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_real32_2d=values_real32_2d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_real32_3d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_real32_3d=values_real32_3d_pointer, return_value=output_return_value )
-            !-- 64bit real output
-            ELSEIF ( PRESENT( values_real64_0d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_real64_0d=values_real64_0d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_real64_1d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_real64_1d=values_real64_1d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_real64_2d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_real64_2d=values_real64_2d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_real64_3d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_real64_3d=values_real64_3d_pointer, return_value=output_return_value )
-            !-- working-precision real output
-            ELSEIF ( PRESENT( values_realwp_0d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_realwp_0d=values_realwp_0d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_realwp_1d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_realwp_1d=values_realwp_1d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_realwp_2d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_realwp_2d=values_realwp_2d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_realwp_3d ) )  THEN
-               CALL binary_write_variable( file_id, variable_id,                      &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_realwp_3d=values_realwp_3d_pointer, return_value=output_return_value )
-            ELSE
-               return_value = 1
-               CALL internal_message( 'error', routine_name //                          &
-                                      ': output_type not supported by file format "' // &
-                                      TRIM( file_format ) // '" ' //                    &
-                                      '(variable "' // TRIM( variable_name ) //         &
-                                      '", file "' // TRIM( file_name ) // '")!' )
-            ENDIF
-
-         CASE ( 'netcdf4-parallel', 'netcdf4-serial' )
-            !-- 8bit integer output
-            IF ( PRESENT( values_int8_0d ) )  THEN
-               CALL netcdf4_write_variable( file_id, variable_id,                     &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int8_0d=values_int8_0d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int8_1d ) )  THEN
-               CALL netcdf4_write_variable( file_id, variable_id,                     &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int8_1d=values_int8_1d_pointer, return_value=output_return_value )
-            ELSEIF ( PRESENT( values_int8_2d ) )  THEN
-               CALL netcdf4_write_variable( file_id, variable_id,                     &
-                       bounds_start_internal, value_counts, bounds_origin, is_global, &
-                       values_int8_2d=values_int8_2d_pointer, return_value=output_return_value )