diff --git a/openmc/particle_restart.py b/openmc/particle_restart.py
index d664de1aee..5ae534dbd9 100644
--- a/openmc/particle_restart.py
+++ b/openmc/particle_restart.py
@@ -40,13 +40,8 @@ class Particle(object):
     """
 
     def __init__(self, filename):
-        if filename.endswith('.h5'):
-            import h5py
-            self._f = h5py.File(filename, 'r')
-            self._hdf5 = True
-        else:
-            self._f = open(filename, 'rb')
-            self._hdf5 = False
+        import h5py
+        self._f = h5py.File(filename, 'r')
 
         # Read all metadata
         self._read_data()
@@ -74,36 +69,17 @@ class Particle(object):
         self.xyz = self._get_double(3, path='xyz')
         self.uvw = self._get_double(3, path='uvw')
 
-    def _get_data(self, n, typeCode, size):
-        return list(struct.unpack('={0}{1}'.format(n, typeCode),
-                                  self._f.read(n*size)))
-
     def _get_int(self, n=1, path=None):
-        if self._hdf5:
-            return [int(v) for v in self._f[path].value]
-        else:
-            return [int(v) for v in self._get_data(n, 'i', 4)]
+        return [int(v) for v in self._f[path].value]
 
     def _get_long(self, n=1, path=None):
-        if self._hdf5:
-            return [int(v) for v in self._f[path].value]
-        else:
-            return [int(v) for v in self._get_data(n, 'q', 8)]
+        return [int(v) for v in self._f[path].value]
 
     def _get_float(self, n=1, path=None):
-        if self._hdf5:
-            return [float(v) for v in self._f[path].value]
-        else:
-            return [float(v) for v in self._get_data(n, 'f', 4)]
+        return [float(v) for v in self._f[path].value]
 
     def _get_double(self, n=1, path=None):
-        if self._hdf5:
-            return [float(v) for v in self._f[path].value]
-        else:
-            return [float(v) for v in self._get_data(n, 'd', 8)]
+        return [float(v) for v in self._f[path].value]
 
     def _get_string(self, n=1, path=None):
-        if self._hdf5:
-            return str(self._f[path].value)
-        else:
-            return str(self._get_data(n, 's', 1)[0])
+        return str(self._f[path].value)
diff --git a/openmc/statepoint.py b/openmc/statepoint.py
index 6a4713e91d..673b41e178 100644
--- a/openmc/statepoint.py
+++ b/openmc/statepoint.py
@@ -92,13 +92,8 @@ class StatePoint(object):
     """
 
     def __init__(self, filename):
-        if filename.endswith('.h5'):
-            import h5py
-            self._f = h5py.File(filename, 'r')
-            self._hdf5 = True
-        else:
-            self._f = open(filename, 'rb')
-            self._hdf5 = False
+        import h5py
+        self._f = h5py.File(filename, 'r')
 
         # Set flags for what data has been read
         self._results = False
@@ -171,12 +166,9 @@ class StatePoint(object):
             raise Exception('Statepoint Revision is not consistent.')
 
         # Read OpenMC version
-        if self._hdf5:
-            self._version = [self._get_int(path='version_major')[0],
-                             self._get_int(path='version_minor')[0],
-                             self._get_int(path='version_release')[0]]
-        else:
-            self._version = self._get_int(3)
+        self._version = [self._get_int(path='version_major')[0],
+                         self._get_int(path='version_minor')[0],
+                         self._get_int(path='version_release')[0]]
 
         # Read date and time
         self._date_and_time = self._get_string(19, path='date_and_time')
@@ -473,13 +465,8 @@ class StatePoint(object):
         # Read global Tallies
         n_global_tallies = self._get_int(path='n_global_tallies')[0]
 
-        if self._hdf5:
-            data = self._f['global_tallies'].value
-            self._global_tallies = np.column_stack((data['sum'], data['sum_sq']))
-
-        else:
-            self._global_tallies = np.array(self._get_double(2*n_global_tallies))
-            self._global_tallies.shape = (n_global_tallies, 2)
+        data = self._f['global_tallies'].value
+        self._global_tallies = np.column_stack((data['sum'], data['sum_sq']))
 
         # Flag indicating if Tallies are present
         self._tallies_present = self._get_int(path='tallies/tallies_present')[0]
@@ -499,15 +486,9 @@ class StatePoint(object):
                 num_tot_bins = tally.num_bins
 
                 # Extract Tally data from the file
-                if self._hdf5:
-                    data = self._f['{0}{1}/results'.format(base, tally_key)].value
-                    sum = data['sum']
-                    sum_sq = data['sum_sq']
-
-                else:
-                    results = np.array(self._get_double(2*num_tot_bins))
-                    sum = results[0::2]
-                    sum_sq = results[1::2]
+                data = self._f['{0}{1}/results'.format(base, tally_key)].value
+                sum = data['sum']
+                sum_sq = data['sum_sq']
 
                 # Define a routine to convert 0 to 1
                 def nonzero(val):
@@ -547,8 +528,7 @@ class StatePoint(object):
         self._source = np.empty(self._n_particles, dtype=SourceSite)
 
         # For HDF5 state points, copy entire bank
-        if self._hdf5:
-            source_sites = self._f['source_bank'].value
+        source_sites = self._f['source_bank'].value
 
         # Initialize SourceSite object for each particle
         for i in range(self._n_particles):
@@ -556,13 +536,7 @@ class StatePoint(object):
             site = SourceSite()
 
             # Read position, angle, and energy
-            if self._hdf5:
-                site._weight, site._xyz, site._uvw, site._E = source_sites[i]
-            else:
-                site._weight = self._get_double()[0]
-                site._xyz = self._get_double(3)
-                site._uvw = self._get_double(3)
-                site._E = self._get_double()[0]
+            site._weight, site._xyz, site._uvw, site._E = source_sites[i]
 
             # Store the source site in the NumPy array
             self._source[i] = site
@@ -798,37 +772,19 @@ class StatePoint(object):
                     self._f.read(n*size)))
 
     def _get_int(self, n=1, path=None):
-        if self._hdf5:
-            return [int(v) for v in self._f[path].value]
-        else:
-            return [int(v) for v in self._get_data(n, 'i', 4)]
+        return [int(v) for v in self._f[path].value]
 
     def _get_long(self, n=1, path=None):
-        if self._hdf5:
-            return [long(v) for v in self._f[path].value]
-        else:
-            return [long(v) for v in self._get_data(n, 'q', 8)]
+        return [long(v) for v in self._f[path].value]
 
     def _get_float(self, n=1, path=None):
-        if self._hdf5:
-            return [float(v) for v in self._f[path].value]
-        else:
-            return [float(v) for v in self._get_data(n, 'f', 4)]
+        return [float(v) for v in self._f[path].value]
 
     def _get_double(self, n=1, path=None):
-        if self._hdf5:
-            return [float(v) for v in self._f[path].value]
-        else:
-            return [float(v) for v in self._get_data(n, 'd', 8)]
+        return [float(v) for v in self._f[path].value]
 
     def _get_double_array(self, n=1, path=None):
-        if self._hdf5:
-            return self._f[path].value
-        else:
-            return self._get_data(n, 'd', 8)
+        return self._f[path].value
 
     def _get_string(self, n=1, path=None):
-        if self._hdf5:
-            return str(self._f[path].value)
-        else:
-            return str(self._get_data(n, 's', 1)[0])
+        return str(self._f[path].value)
diff --git a/src/finalize.F90 b/src/finalize.F90
index aa11f47690..b795cdb4f2 100644
--- a/src/finalize.F90
+++ b/src/finalize.F90
@@ -9,9 +9,7 @@ module finalize
   use message_passing
 #endif
 
-#ifdef HDF5
   use hdf5_interface,  only: h5tclose_f, h5close_f, hdf5_err
-#endif
 
   implicit none
 
@@ -51,14 +49,12 @@ contains
     ! Deallocate arrays
     call free_memory()
 
-#ifdef HDF5
     ! Release compound datatypes
     call h5tclose_f(hdf5_tallyresult_t, hdf5_err)
     call h5tclose_f(hdf5_bank_t, hdf5_err)
 
     ! Close FORTRAN interface.
     call h5close_f(hdf5_err)
-#endif
 
 #ifdef MPI
     ! Free all MPI types
diff --git a/src/global.F90 b/src/global.F90
index 564fcda843..ae2f5bb270 100644
--- a/src/global.F90
+++ b/src/global.F90
@@ -16,9 +16,7 @@ module global
   use trigger_header,   only: KTrigger
   use timer_header,     only: Timer
 
-#ifdef HDF5
   use hdf5_interface,  only: HID_T
-#endif
 #ifdef MPIF08
   use mpi_f08
 #endif
@@ -270,12 +268,10 @@ module global
   ! ============================================================================
   ! HDF5 VARIABLES
 
-#ifdef HDF5
   integer(HID_T) :: hdf5_output_file   ! identifier for output file
   integer(HID_T) :: hdf5_tallyresult_t ! Compound type for TallyResult
   integer(HID_T) :: hdf5_bank_t        ! Compound type for Bank
   integer(HID_T) :: hdf5_integer8_t    ! type for integer(8)
-#endif
 
   ! ============================================================================
   ! MISCELLANEOUS VARIABLES
diff --git a/src/hdf5_interface.F90 b/src/hdf5_interface.F90
index 34b72196ee..e7ba39b646 100644
--- a/src/hdf5_interface.F90
+++ b/src/hdf5_interface.F90
@@ -1,7 +1,5 @@
 module hdf5_interface
 
-#ifdef HDF5
-
   use hdf5
   use h5lt
   use, intrinsic :: ISO_C_BINDING
@@ -1811,6 +1809,4 @@ contains
 
 # endif
 
-#endif
-
 end module hdf5_interface
diff --git a/src/hdf5_summary.F90 b/src/hdf5_summary.F90
index 375ab74601..a9dab46f50 100644
--- a/src/hdf5_summary.F90
+++ b/src/hdf5_summary.F90
@@ -1,7 +1,5 @@
 module hdf5_summary
 
-#ifdef HDF5
-
   use ace_header,      only: Reaction, UrrData, Nuclide
   use constants
   use endf,            only: reaction_name
@@ -875,6 +873,4 @@ contains
 
   end subroutine hdf5_write_timing
 
-#endif
-
 end module hdf5_summary
diff --git a/src/initialize.F90 b/src/initialize.F90
index b944b6677b..22521b24da 100644
--- a/src/initialize.F90
+++ b/src/initialize.F90
@@ -15,9 +15,8 @@ module initialize
   use input_xml,        only: read_input_xml, read_cross_sections_xml,         &
                               cells_in_univ_dict, read_plots_xml
   use material_header,  only: Material
-  use output,           only: title, header, write_summary, print_version,     &
-                              print_usage, write_xs_summary, print_plot,       &
-                              write_message
+  use output,           only: title, header, print_version, write_message,     &
+                              print_usage, write_xs_summary, print_plot
   use output_interface
   use random_lcg,       only: initialize_prng
   use state_point,      only: load_state_point
@@ -33,10 +32,8 @@ module initialize
   use omp_lib
 #endif
 
-#ifdef HDF5
   use hdf5_interface
   use hdf5_summary,     only: hdf5_write_summary
-#endif
 
   implicit none
 
@@ -60,10 +57,8 @@ contains
     call initialize_mpi()
 #endif
 
-#ifdef HDF5
     ! Initialize HDF5 interface
     call hdf5_initialize()
-#endif
 
     ! Read command line arguments
     call read_command_line()
@@ -155,11 +150,7 @@ contains
         call print_plot()
       else
         ! Write summary information
-#ifdef HDF5
         if (output_summary) call hdf5_write_summary()
-#else
-        if (output_summary) call write_summary()
-#endif
 
         ! Write cross section information
         if (output_xs) call write_xs_summary()
@@ -275,8 +266,6 @@ contains
   end subroutine initialize_mpi
 #endif
 
-#ifdef HDF5
-
 !===============================================================================
 ! HDF5_INITIALIZE
 !===============================================================================
@@ -319,8 +308,6 @@ contains
 
   end subroutine hdf5_initialize
 
-#endif
-
 !===============================================================================
 ! READ_COMMAND_LINE reads all parameters from the command line
 !===============================================================================
diff --git a/src/output.F90 b/src/output.F90
index d1d4ec72aa..2ddbf6499d 100644
--- a/src/output.F90
+++ b/src/output.F90
@@ -1203,98 +1203,6 @@ contains
 
   end subroutine print_sab_table
 
-!===============================================================================
-! WRITE_SUMMARY displays summary information about the problem about to be run
-! after reading all input files
-!===============================================================================
-
-  subroutine write_summary()
-
-    integer                 :: i      ! loop index
-    character(MAX_FILE_LEN) :: path   ! path of summary file
-    type(Material),    pointer :: m => null()
-    type(TallyObject), pointer :: t => null()
-
-    ! Create filename for log file
-    path = trim(path_output) // "summary.out"
-
-    ! Open log file for writing
-    open(UNIT=UNIT_SUMMARY, FILE=path, STATUS='replace', ACTION='write')
-
-    call header("OpenMC Monte Carlo Code", unit=UNIT_SUMMARY, level=1)
-    write(UNIT=UNIT_SUMMARY, FMT=*) &
-         "Copyright:     2011-2015 Massachusetts Institute of Technology"
-    write(UNIT=UNIT_SUMMARY, FMT='(1X,A,7X,2(I1,"."),I1)') &
-         "Version:", VERSION_MAJOR, VERSION_MINOR, VERSION_RELEASE
-#ifdef GIT_SHA1
-    write(UNIT=UNIT_SUMMARY, FMT='(1X,"Git SHA1:",6X,A)') GIT_SHA1
-#endif
-    write(UNIT=UNIT_SUMMARY, FMT='(1X,"Date/Time:",5X,A)') &
-         time_stamp()
-
-    ! Write information on number of processors
-#ifdef MPI
-    write(UNIT=UNIT_SUMMARY, FMT='(1X,"MPI Processes:",1X,A)') &
-         trim(to_str(n_procs))
-#endif
-
-    ! Display problem summary
-    call header("PROBLEM SUMMARY", unit=UNIT_SUMMARY)
-    select case(run_mode)
-    case (MODE_EIGENVALUE)
-      write(UNIT_SUMMARY,100) 'Problem type:', 'k eigenvalue'
-      write(UNIT_SUMMARY,101) 'Number of Batches:', n_batches
-      write(UNIT_SUMMARY,101) 'Number of Inactive Batches:', n_inactive
-      write(UNIT_SUMMARY,101) 'Generations per Batch:', gen_per_batch
-    case (MODE_FIXEDSOURCE)
-      write(UNIT_SUMMARY,100) 'Problem type:', 'fixed source'
-    end select
-    write(UNIT_SUMMARY,101) 'Number of Particles:', n_particles
-
-    ! Display geometry summary
-    call header("GEOMETRY SUMMARY", unit=UNIT_SUMMARY)
-    write(UNIT_SUMMARY,101) 'Number of Cells:', n_cells
-    write(UNIT_SUMMARY,101) 'Number of Surfaces:', n_surfaces
-    write(UNIT_SUMMARY,101) 'Number of Materials:', n_materials
-
-    ! print summary of all geometry
-    call print_geometry()
-
-    ! print summary of materials
-    call header("MATERIAL SUMMARY", unit=UNIT_SUMMARY)
-    do i = 1, n_materials
-      m => materials(i)
-      call print_material(m, unit=UNIT_SUMMARY)
-    end do
-
-    ! print summary of tallies
-    if (n_tallies > 0) then
-      call header("TALLY SUMMARY", unit=UNIT_SUMMARY)
-      do i = 1, n_tallies
-        t=> tallies(i)
-        call print_tally(t, unit=UNIT_SUMMARY)
-      end do
-    end if
-
-    ! print summary of variance reduction
-    call header("VARIANCE REDUCTION", unit=UNIT_SUMMARY)
-    if (survival_biasing) then
-      write(UNIT_SUMMARY,100) "Survival Biasing:", "on"
-    else
-      write(UNIT_SUMMARY,100) "Survival Biasing:", "off"
-    end if
-    write(UNIT_SUMMARY,100) "Weight Cutoff:", trim(to_str(weight_cutoff))
-    write(UNIT_SUMMARY,100) "Survival weight:", trim(to_str(weight_survive))
-
-    ! Close summary file
-    close(UNIT_SUMMARY)
-
-    ! Format descriptor for columns
-100 format (1X,A,T35,A)
-101 format (1X,A,T35,I11)
-
-  end subroutine write_summary
-
 !===============================================================================
 ! WRITE_XS_SUMMARY writes information about each nuclide and S(a,b) table to a
 ! file called cross_sections.out. This file shows the list of reactions as well
diff --git a/src/output_interface.F90 b/src/output_interface.F90
index 05fcd0010b..f56a4b3399 100644
--- a/src/output_interface.F90
+++ b/src/output_interface.F90
@@ -5,12 +5,9 @@ module output_interface
   use global
   use tally_header,  only: TallyResult
 
-#ifdef HDF5
   use hdf5_interface
-#else
 #ifdef MPI
   use mpiio_interface
-#endif
 #endif
 
   implicit none
@@ -19,17 +16,8 @@ module output_interface
   type, public :: BinaryOutput
     private
     ! Compilation specific data
-#ifdef HDF5
     integer(HID_T) :: hdf5_fh
     integer(HID_T) :: hdf5_grp
-#else
-    integer        :: unit_fh
-#ifdef MPIF08
-    type(MPI_File) :: mpi_fh
-#else
-    integer        :: mpi_fh
-#endif
-#endif
     logical :: serial ! Serial I/O when using MPI/PHDF5
   contains
     generic, public :: write_data =>  write_double, &
@@ -87,11 +75,9 @@ module output_interface
     procedure, public :: read_tally_result => read_tally_result
     procedure, public :: write_source_bank => write_source_bank
     procedure, public :: read_source_bank => read_source_bank
-#ifdef HDF5
     procedure, public :: write_attribute_string => write_attribute_string
     procedure, public :: open_group => open_group
     procedure, public :: close_group => close_group
-#endif
   end type BinaryOutput
 
 contains
@@ -113,26 +99,14 @@ contains
       self % serial = .true.
     end if
 
-#ifdef HDF5
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_file_create(filename, self % hdf5_fh)
     else
       call hdf5_file_create_parallel(filename, self % hdf5_fh)
     endif
-# else
-    call hdf5_file_create(filename, self % hdf5_fh)
-# endif
-#elif MPI
-    if (self % serial) then
-      open(NEWUNIT=self % unit_fh, FILE=filename, ACTION="write", &
-           STATUS='replace', ACCESS='stream')
-    else
-      call mpi_create_file(filename, self % mpi_fh)
-    end if
 #else
-    open(NEWUNIT=self % unit_fh, FILE=filename, ACTION="write", &
-         STATUS='replace', ACCESS='stream')
+    call hdf5_file_create(filename, self % hdf5_fh)
 #endif
 
   end subroutine file_create
@@ -155,38 +129,14 @@ contains
       self % serial = .true.
     end if
 
-#ifdef HDF5
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_file_open(filename, self % hdf5_fh, mode)
     else
       call hdf5_file_open_parallel(filename, self % hdf5_fh, mode)
     endif
-# else
-    call hdf5_file_open(filename, self % hdf5_fh, mode)
-# endif
-#elif MPI
-    if (self % serial) then
-      ! Check for read/write mode to open, default is read only
-      if (mode == 'w') then
-        open(NEWUNIT=self % unit_fh, FILE=filename, ACTION='write', &
-             STATUS='old', ACCESS='stream', POSITION='append')
-      else
-        open(NEWUNIT=self % unit_fh, FILE=filename, ACTION='read', &
-             STATUS='old', ACCESS='stream')
-      end if
-    else
-      call mpi_open_file(filename, self % mpi_fh, mode)
-    end if
 #else
-    ! Check for read/write mode to open, default is read only
-    if (mode == 'w') then
-      open(NEWUNIT=self % unit_fh, FILE=filename, ACTION='write', &
-           STATUS='old', ACCESS='stream', POSITION='append')
-    else
-      open(NEWUNIT=self % unit_fh, FILE=filename, ACTION='read', &
-           STATUS='old', ACCESS='stream')
-    end if
+    call hdf5_file_open(filename, self % hdf5_fh, mode)
 #endif
 
   end subroutine file_open
@@ -199,21 +149,7 @@ contains
 
     class(BinaryOutput) :: self
 
-#ifdef HDF5
-# ifdef MPI
     call hdf5_file_close(self % hdf5_fh)
-# else
-    call hdf5_file_close(self % hdf5_fh)
-# endif
-#elif MPI
-    if (self % serial) then
-      close(UNIT=self % unit_fh)
-    else
-      call mpi_close_file(self % mpi_fh)
-    end if
-#else
-    close(UNIT=self % unit_fh)
-#endif
 
   end subroutine file_close
 
@@ -221,7 +157,6 @@ contains
 ! OPEN_GROUP call hdf5 routine to open a group within binary output context
 !===============================================================================
 
-#ifdef HDF5
   subroutine open_group(self, group)
 
     character(*), intent(in) :: group ! HDF5 group name
@@ -230,13 +165,11 @@ contains
     call hdf5_open_group(self % hdf5_fh, group, self % hdf5_grp)
 
   end subroutine open_group
-#endif
 
 !===============================================================================
 ! CLOSE_GROUP call hdf5 routine to close a group within binary output context
 !===============================================================================
 
-#ifdef HDF5
   subroutine close_group(self)
 
     class(BinaryOutput) :: self
@@ -244,7 +177,6 @@ contains
     call hdf5_close_group(self % hdf5_grp)
 
   end subroutine close_group
-#endif
 
 !===============================================================================
 ! WRITE_DOUBLE writes double precision scalar data
@@ -277,33 +209,23 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_double(self % hdf5_grp, name_, buffer)
     else
       call hdf5_write_double_parallel(self % hdf5_grp, name_, buffer, collect_)
     end if
-# else
+#else
     call hdf5_write_double(self % hdf5_grp, name_, buffer)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer
-    else
-      call mpi_write_double(self % mpi_fh, buffer, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer
-#endif
 
   end subroutine write_double
 
@@ -338,33 +260,23 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_double(self % hdf5_grp, name_, buffer)
     else
       call hdf5_read_double_parallel(self % hdf5_grp, name_, buffer, collect_)
     end if
-# else
+#else
     call hdf5_read_double(self % hdf5_grp, name_, buffer)
-# endif
+#endif
     ! Check if HDf5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer
-    else
-      call mpi_read_double(self % mpi_fh, buffer, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer
-#endif
 
   end subroutine read_double
 
@@ -400,34 +312,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_double_1Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_write_double_1Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_write_double_1Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer(1:length)
-    else
-      call mpi_write_double_1Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer(1:length)
-#endif
 
   end subroutine write_double_1Darray
 
@@ -463,34 +365,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_double_1Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_read_double_1Darray_parallel(self % hdf5_grp, name_, buffer, &
            length, collect_)
     end if
-# else
+#else
     call hdf5_read_double_1Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer(1:length)
-    else
-      call mpi_read_double_1Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer(1:length)
-#endif
 
   end subroutine read_double_1Darray
 
@@ -526,34 +418,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_double_2Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_write_double_2Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_write_double_2Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer(1:length(1),1:length(2))
-    else
-      call mpi_write_double_2Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer(1:length(1),1:length(2))
-#endif
 
   end subroutine write_double_2Darray
 
@@ -589,34 +471,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_double_2Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_read_double_2Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_read_double_2Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer(1:length(1),1:length(2))
-    else
-      call mpi_read_double_2Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer(1:length(1),1:length(2))
-#endif
 
   end subroutine read_double_2Darray
 
@@ -652,34 +524,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_double_3Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_write_double_3Darray_parallel(self % hdf5_grp, name_, buffer, &
            length, collect_)
     end if
-# else
+#else
     call hdf5_write_double_3Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3))
-    else
-      call mpi_write_double_3Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3))
-#endif
 
   end subroutine write_double_3Darray
 
@@ -715,34 +577,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_double_3Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_read_double_3Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_read_double_3Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3))
-    else
-      call mpi_read_double_3Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3))
-#endif
 
   end subroutine read_double_3Darray
 
@@ -779,37 +631,25 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_double_4Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_write_double_4Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     ! Write the data in serial
     call hdf5_write_double_4Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3), &
-                         1:length(4))
-    else
-      call mpi_write_double_4Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3), &
-                       1:length(4))
-#endif
 
   end subroutine write_double_4Darray
 
@@ -846,36 +686,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_double_4Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_read_double_4Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_read_double_4Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3), &
-                        1:length(4))
-    else
-      call mpi_read_double_4Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3), &
-                      1:length(4))
-#endif
 
   end subroutine read_double_4Darray
 
@@ -910,33 +738,23 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_integer(self % hdf5_grp, name_, buffer)
     else
       call hdf5_write_integer_parallel(self % hdf5_grp, name_, buffer, collect_)
     end if
-# else
+#else
     call hdf5_write_integer(self % hdf5_grp, name_, buffer)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer
-    else
-      call mpi_write_integer(self % mpi_fh, buffer, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer
-#endif
 
   end subroutine write_integer
 
@@ -971,33 +789,23 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_integer(self % hdf5_grp, name_, buffer)
     else
       call hdf5_read_integer_parallel(self % hdf5_grp, name_, buffer, collect_)
     end if
-# else
+#else
     call hdf5_read_integer(self % hdf5_grp, name_, buffer)
-# endif
+#endif
     ! Check if HDf5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer
-    else
-      call mpi_read_integer(self % mpi_fh, buffer, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer
-#endif
 
   end subroutine read_integer
 
@@ -1033,34 +841,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_integer_1Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_write_integer_1Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_write_integer_1Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer(1:length)
-    else
-      call mpi_write_integer_1Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer(1:length)
-#endif
 
   end subroutine write_integer_1Darray
 
@@ -1096,35 +894,25 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_integer_1Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_read_integer_1Darray_parallel(self % hdf5_grp, name_, buffer, &
            length, collect_)
     end if
-# else
+#else
     ! Read the data in serial
     call hdf5_read_integer_1Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer(1:length)
-    else
-      call mpi_read_integer_1Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer(1:length)
-#endif
 
   end subroutine read_integer_1Darray
 
@@ -1160,34 +948,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_integer_2Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_write_integer_2Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_write_integer_2Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer(1:length(1),1:length(2))
-    else
-      call mpi_write_integer_2Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer(1:length(1),1:length(2))
-#endif
 
   end subroutine write_integer_2Darray
 
@@ -1223,34 +1001,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_integer_2Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_read_integer_2Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_read_integer_2Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer(1:length(1),1:length(2))
-    else
-      call mpi_read_integer_2Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer(1:length(1),1:length(2))
-#endif
 
   end subroutine read_integer_2Darray
 
@@ -1286,34 +1054,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_integer_3Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_write_integer_3Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_write_integer_3Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3))
-    else
-      call mpi_write_integer_3Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3))
-#endif
 
   end subroutine write_integer_3Darray
 
@@ -1349,34 +1107,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_integer_3Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_read_integer_3Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_read_integer_3Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3))
-    else
-      call mpi_read_integer_3Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3))
-#endif
 
   end subroutine read_integer_3Darray
 
@@ -1413,36 +1161,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_integer_4Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_write_integer_4Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_write_integer_4Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3), &
-                         1:length(4))
-    else
-      call mpi_write_integer_4Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3), &
-                       1:length(4))
-#endif
 
   end subroutine write_integer_4Darray
 
@@ -1479,36 +1215,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_integer_4Darray(self % hdf5_grp, name_, buffer, length)
     else
       call hdf5_read_integer_4Darray_parallel(self % hdf5_grp, name_, buffer, length, &
            collect_)
     end if
-# else
+#else
     call hdf5_read_integer_4Darray(self % hdf5_grp, name_, buffer, length)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3), &
-                        1:length(4))
-    else
-      call mpi_read_integer_4Darray(self % mpi_fh, buffer, length, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer(1:length(1),1:length(2),1:length(3), &
-                      1:length(4))
-#endif
 
   end subroutine read_integer_4Darray
 
@@ -1543,34 +1267,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_long(self % hdf5_grp, name_, buffer, hdf5_integer8_t)
     else
       call hdf5_write_long_parallel(self % hdf5_grp, name_, buffer, &
            hdf5_integer8_t, collect_)
     end if
-# else
+#else
     call hdf5_write_long(self % hdf5_grp, name_, buffer, hdf5_integer8_t)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer
-    else
-      call mpi_write_long(self % mpi_fh, buffer, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer
-#endif
 
   end subroutine write_long
 
@@ -1605,34 +1319,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_long(self % hdf5_grp, name_, buffer, hdf5_integer8_t)
     else
       call hdf5_read_long_parallel(self % hdf5_grp, name_, buffer, &
            hdf5_integer8_t, collect_)
     end if
-# else
+#else
     call hdf5_read_long(self % hdf5_grp, name_, buffer, hdf5_integer8_t)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer
-    else
-      call mpi_read_long(self % mpi_fh, buffer, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer
-#endif
 
   end subroutine read_long
 
@@ -1671,34 +1375,24 @@ contains
       collect_ = .true.
     end if
 
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_write_string(self % hdf5_grp, name_, buffer, n)
     else
       call hdf5_write_string_parallel(self % hdf5_grp, name_, buffer, n, collect_)
     end if
-# else
+#else
     ! Write the data
     call hdf5_write_string(self % hdf5_grp, name_, buffer, n)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      write(self % unit_fh) buffer
-    else
-      call mpi_write_string(self % mpi_fh, buffer, n, collect_)
-    end if
-#else
-    write(self % unit_fh) buffer
-#endif
 
   end subroutine write_string
 
@@ -1737,34 +1431,23 @@ contains
       collect_ = .true.
     end if
 
-
-#ifdef HDF5
     ! Check if HDF5 group should be created/opened
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
     else
       self % hdf5_grp = self % hdf5_fh
     endif
-# ifdef MPI
+#ifdef MPI
     if (self % serial) then
       call hdf5_read_string(self % hdf5_grp, name_, buffer, n)
     else
       call hdf5_read_string_parallel(self % hdf5_grp, name_, buffer, n, collect_)
     end if
-# else
+#else
     call hdf5_read_string(self % hdf5_grp, name_, buffer, n)
-# endif
+#endif
     ! Check if HDF5 group should be closed
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
-#elif MPI
-    if (self % serial) then
-      read(self % unit_fh) buffer
-    else
-      call mpi_read_string(self % mpi_fh, buffer, n, collect_)
-    end if
-#else
-    read(self % unit_fh) buffer
-#endif
 
   end subroutine read_string
 
@@ -1772,7 +1455,6 @@ contains
 ! WRITE_ATTRIBUTE_STRING
 !===============================================================================
 
-#ifdef HDF5
   subroutine write_attribute_string(self, var, attr_type, attr_str, group)
 
     character(*), intent(in)           :: var       ! variable name for attr
@@ -1795,7 +1477,6 @@ contains
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
 
   end subroutine write_attribute_string
-#endif
 
 !===============================================================================
 ! WRITE_TALLY_RESULT writes an OpenMC TallyResult type
@@ -1812,10 +1493,6 @@ contains
     character(len=MAX_WORD_LEN) :: name_  ! HDF5 dataset name
     character(len=MAX_WORD_LEN) :: group_ ! HDF5 group name
 
-#ifndef HDF5
-    integer :: j,k ! iteration counters
-#endif
-
     ! Set name
     name_ = trim(name)
 
@@ -1824,8 +1501,6 @@ contains
       group_ = trim(group)
     end if
 
-#ifdef HDF5
-
     ! Open up sub-group if present
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
@@ -1854,18 +1529,6 @@ contains
       call hdf5_close_group(self % hdf5_grp)
     end if
 
-#else
-
-    ! Write out tally buffer
-    do k = 1, n2
-      do j = 1, n1
-        write(self % unit_fh) buffer(j,k) % sum
-        write(self % unit_fh) buffer(j,k) % sum_sq
-      end do
-    end do
-
-#endif
-
   end subroutine write_tally_result
 
 !===============================================================================
@@ -1883,12 +1546,6 @@ contains
     character(len=MAX_WORD_LEN) :: name_  ! HDF5 dataset name
     character(len=MAX_WORD_LEN) :: group_ ! HDF5 group name
 
-#ifndef HDF5
-# ifndef MPI
-    integer :: j,k ! iteration counters
-# endif
-#endif
-
     ! Set name
     name_ = trim(name)
 
@@ -1897,8 +1554,6 @@ contains
       group_ = trim(group)
     end if
 
-#ifdef HDF5
-
     ! Open up sub-group if present
     if (present(group)) then
       call hdf5_open_group(self % hdf5_fh, group_, self % hdf5_grp)
@@ -1917,24 +1572,6 @@ contains
     call h5dclose_f(dset, hdf5_err)
     if (present(group)) call hdf5_close_group(self % hdf5_grp)
 
-# elif MPI
-
-    ! Write out tally buffer
-    call MPI_FILE_READ(self % mpi_fh, buffer, n1*n2, MPI_TALLYRESULT, &
-         MPI_STATUS_IGNORE, mpiio_err)
-
-#else
-
-    ! Read tally result
-    do k = 1, n2
-      do j = 1, n1
-        read(self % unit_fh) buffer(j,k) % sum
-        read(self % unit_fh) buffer(j,k) % sum_sq
-      end do
-    end do
-
-#endif
-
   end subroutine read_tally_result
 
 !===============================================================================
@@ -1946,21 +1583,9 @@ contains
     class(BinaryOutput) :: self
 
 #ifdef MPI
-# ifndef HDF5
-    integer(MPI_OFFSET_KIND) :: offset           ! offset of data
-    integer                  :: size_bank        ! size of bank to write
-#ifdef MPIF08
-    type(MPI_Datatype)       :: datatype
-#else
-    integer                  :: datatype
-#endif
-# endif
-# ifdef HDF5
-    integer(8)               :: offset(1)        ! source data offset
-# endif
+    integer(8) :: offset(1) ! source data offset
 #endif
 
-#ifdef HDF5
 #ifdef MPI
 
     ! Set size of total dataspace for all procs and rank
@@ -2005,7 +1630,7 @@ contains
     call h5dclose_f(dset, hdf5_err)
     call h5pclose_f(plist, hdf5_err)
 
-# else
+#else
 
     ! Set size
     dims1(1) = work
@@ -2028,31 +1653,6 @@ contains
     call h5dclose_f(dset, hdf5_err)
     call h5sclose_f(dspace, hdf5_err)
 
-# endif
-
-#elif MPI
-
-    ! Get current offset for master
-    if (master) call MPI_FILE_GET_POSITION(self % mpi_fh, offset, mpiio_err)
-
-    ! Determine offset on master process and broadcast to all processors
-    call MPI_TYPE_MATCH_SIZE(MPI_TYPECLASS_INTEGER, MPI_OFFSET_KIND, &
-         datatype, mpi_err)
-    call MPI_BCAST(offset, 1, datatype, 0, MPI_COMM_WORLD, mpi_err)
-
-    ! Set the proper offset for source data on this processor
-    call MPI_TYPE_SIZE(MPI_BANK, size_bank, mpi_err)
-    offset = offset + size_bank*work_index(rank)
-
-    ! Write all source sites
-    call MPI_FILE_WRITE_AT(self % mpi_fh, offset, source_bank(1), int(work), &
-         MPI_BANK, MPI_STATUS_IGNORE, mpiio_err)
-
-#else
-
-    ! Write out source sites
-    write(self % unit_fh) source_bank
-
 #endif
 
   end subroutine write_source_bank
@@ -2066,17 +1666,10 @@ contains
     class(BinaryOutput) :: self
 
 #ifdef MPI
-# ifndef HDF5
-    integer(MPI_OFFSET_KIND) :: offset           ! offset of data
-    integer                  :: size_bank        ! size of bank to read
-# endif
-# ifdef HDF5
-    integer(8)               :: offset(1)        ! offset of data
-# endif
+    integer(8) :: offset(1) ! offset of data
 #endif
 
-#ifdef HDF5
-# ifdef MPI
+#ifdef MPI
 
     ! Set size of total dataspace for all procs and rank
     dims1(1) = n_particles
@@ -2114,7 +1707,7 @@ contains
     call h5dclose_f(dset, hdf5_err)
     call h5pclose_f(plist, hdf5_err)
 
-# else
+#else
 
     ! Open dataset
     call h5dopen_f(self % hdf5_fh, "source_bank", dset, hdf5_err)
@@ -2128,36 +1721,6 @@ contains
     ! Close all ids
     call h5dclose_f(dset, hdf5_err)
 
-# endif
-
-#elif MPI
-
-    ! Go to the end of the file to set file pointer
-    offset = 0
-    call MPI_FILE_SEEK(self % mpi_fh, offset, MPI_SEEK_END, &
-         mpiio_err)
-
-    ! Get current offset (will be at EOF)
-    call MPI_FILE_GET_POSITION(self % mpi_fh, offset, mpiio_err)
-
-    ! Get the size of the source bank on all procs
-    call MPI_TYPE_SIZE(MPI_BANK, size_bank, mpi_err)
-
-    ! Calculate offset where the source bank will begin
-    offset = offset - n_particles*size_bank
-
-    ! Set the proper offset for source data on this processor
-    offset = offset + size_bank*work_index(rank)
-
-    ! Write all source sites
-    call MPI_FILE_READ_AT(self % mpi_fh, offset, source_bank(1), int(work), &
-         MPI_BANK, MPI_STATUS_IGNORE, mpiio_err)
-
-#else
-
-    ! Write out source sites
-    read(self % unit_fh) source_bank
-
 #endif
 
   end subroutine read_source_bank
diff --git a/src/particle_restart_write.F90 b/src/particle_restart_write.F90
index f138a67403..48b4af661e 100644
--- a/src/particle_restart_write.F90
+++ b/src/particle_restart_write.F90
@@ -32,11 +32,7 @@ contains
     ! Set up file name
     filename = trim(path_output) // 'particle_' // trim(to_str(current_batch)) &
          // '_' // trim(to_str(p % id))
-#ifdef HDF5
     filename = trim(filename) // '.h5'
-#else
-    filename = trim(filename) // '.binary'
-#endif
 
 !$omp critical (WriteParticleRestart)
     ! Create file
diff --git a/src/source.F90 b/src/source.F90
index e824829154..4b0de58b5a 100644
--- a/src/source.F90
+++ b/src/source.F90
@@ -79,11 +79,7 @@ contains
     ! Write out initial source
     if (write_initial_source) then
       call write_message('Writing out initial source...', 1)
-#ifdef HDF5
       filename = trim(path_output) // 'initial_source.h5'
-#else
-      filename = trim(path_output) // 'initial_source.binary'
-#endif
       call sp % file_create(filename, serial = .false.)
       call sp % write_source_bank()
       call sp % file_close()
diff --git a/src/state_point.F90 b/src/state_point.F90
index 6b983231f6..790fd58c57 100644
--- a/src/state_point.F90
+++ b/src/state_point.F90
@@ -55,11 +55,7 @@ contains
          & zero_padded(current_batch, count_digits(n_max_batches))
 
     ! Append appropriate extension
-#ifdef HDF5
     filename = trim(filename) // '.h5'
-#else
-    filename = trim(filename) // '.binary'
-#endif
 
     ! Write message
     call write_message("Creating state point " // trim(filename) // "...", 1)
@@ -118,10 +114,8 @@ contains
 
         ! Write out CMFD info
         if (cmfd_on) then
-#ifdef HDF5
           call sp % open_group("cmfd")
           call sp % close_group()
-#endif
           call sp % write_data(1, "cmfd_on")
           call sp % write_data(cmfd % indices, "indices", length=4, group="cmfd")
           call sp % write_data(cmfd % k_cmfd, "k_cmfd", length=current_batch, &
@@ -143,10 +137,8 @@ contains
         end if
       end if
 
-#ifdef HDF5
       call sp % open_group("tallies")
       call sp % close_group()
-#endif
 
       ! Write number of meshes
       call sp % write_data(n_meshes, "n_meshes", group="tallies/meshes")
@@ -414,11 +406,7 @@ contains
         filename = trim(path_output) // 'source.' // &
              & zero_padded(current_batch, count_digits(n_max_batches))
 
-#ifdef HDF5
         filename = trim(filename) // '.h5'
-#else
-        filename = trim(filename) // '.binary'
-#endif
 
         ! Write message for new file creation
         call write_message("Creating source file " // trim(filename) // "...", &
@@ -434,12 +422,8 @@ contains
 
         ! Set filename for state point
         filename = trim(path_output) // 'statepoint.' // &
-             & zero_padded(current_batch, count_digits(n_max_batches))
-#ifdef HDF5
+             zero_padded(current_batch, count_digits(n_max_batches))
         filename = trim(filename) // '.h5'
-#else
-        filename = trim(filename) // '.binary'
-#endif
 
         ! Reopen statepoint file in parallel
         call sp % file_open(filename, 'w', serial = .false.)
@@ -456,14 +440,9 @@ contains
 
     ! Also check to write source separately in overwritten file
     if (source_latest) then
-
       ! Set filename
       filename = trim(path_output) // 'source'
-#ifdef HDF5
       filename = trim(filename) // '.h5'
-#else
-      filename = trim(filename) // '.binary'
-#endif
 
       ! Write message for new file creation
       call write_message("Creating source file " // trim(filename) // "...", 1)
diff --git a/src/track_output.F90 b/src/track_output.F90
index 6ab514cdb8..d3716e9b05 100644
--- a/src/track_output.F90
+++ b/src/track_output.F90
@@ -95,15 +95,9 @@ contains
     integer, allocatable :: n_coords(:)
     integer :: n_particle_tracks
 
-#ifdef HDF5
     fname = trim(path_output) // 'track_' // trim(to_str(current_batch)) &
          // '_' // trim(to_str(current_gen)) // '_' // trim(to_str(p % id)) &
          // '.h5'
-#else
-    fname = trim(path_output) // 'track_' // trim(to_str(current_batch)) &
-         // '_' // trim(to_str(current_gen)) // '_' // trim(to_str(p % id)) &
-         // '.binary'
-#endif
 
     ! Determine total number of particles and number of coordinates for each
     n_particle_tracks = size(tracks)