optimizer.f90

Go to the documentation of this file.

 
 
module optimizer
  use json_module, only: json_file
  use simulation_m, only: simulation_t
  use problem, only: problem_t
  use design, only: design_t
  use num_types, only: rp
  use logger, only: neko_log, log_size
  use profiler, only: profiler_start_region, profiler_end_region
  use mpi_f08, only: mpi_wtime, mpi_allreduce, mpi_max, mpi_bcast, &
       mpi_logical, mpi_barrier
  use utils, only: neko_error, filename_path, filename_suffix, read_duration, &
       mkdir
  use csv_file, only: csv_file_t
  use vector, only: vector_t
  use json_utils, only: json_get_or_default
  use comm, only: pe_rank, mpi_real_precision, neko_comm
  use continuation_scheduler, only: nekotop_continuation
  use math, only: neko_eps
  use, intrinsic :: iso_fortran_env, only : error_unit, output_unit
 
  implicit none
  private
 
  type, abstract, public :: optimizer_t
 
     character(len=64), private :: optimizer_type = ''
     integer, private :: max_iterations = 0
     integer, private :: current_iteration = 0
     real(kind=rp), private :: stop_design_change = neko_eps
     real(kind=rp), public :: max_design_change = 0.0_rp
     real(kind=rp), public :: norm2_design_change = 0.0_rp
 
     ! ----------------------------------------------------------------------- !
     ! Restart related members
 
     ! Internal initialization flag to ensure correct ordering.
     logical, private :: initialized = .false.
 
     character(len=256), private :: restart_file = ''
 
     ! Checkpoint related information
     character(len=256), private :: checkpoint_path = './checkpoints/'
     character(len=256), private :: checkpoint_base = 'optimizer_checkpoint'
     character(len=256), private :: checkpoint_format = 'hdf5'
     integer, private :: checkpoint_interval = -1
     logical, private :: checkpoint_overwrite = .false.
 
     ! Variables for the runtime-based stopping criteria
     real(kind=rp), private :: max_runtime = -1.0_rp
     real(kind=rp), private :: start_time = 0.0_rp
     real(kind=rp), private :: average_time = 0.0_rp
     real(kind=rp), private :: step_count = 0.0_rp
 
     ! Logging state
     logical, private :: log_initialized = .false.
     logical, private :: log_include_constraints = .true.
     integer, private :: log_extra_size = 0
     type(csv_file_t), private :: log_file
     type(vector_t), private :: log_data
 
   contains
 
     !  ---------------------------------------------------------------------- !
     ! Deferred procedures for specific optimizers
 
     procedure(optimizer_init_from_json), pass(this), public, deferred :: &
          init_from_json
     procedure(optimizer_free), pass(this), public, deferred :: free
 
     procedure(optimizer_initialize), pass(this), public, deferred :: initialize
     procedure(optimizer_step), pass(this), public, deferred :: step
     procedure(optimizer_validate), pass(this), public, deferred :: validate
 
     procedure(optimizer_write), pass(this), public, deferred :: write
     procedure(optimizer_save_checkpoint_components), pass(this), deferred :: &
          save_checkpoint_components
     procedure(optimizer_load_checkpoint_components), pass(this), deferred :: &
          load_checkpoint_components
 
     procedure, pass(this) :: save_checkpoint => optimizer_save_checkpoint
     procedure, pass(this) :: load_checkpoint => optimizer_load_checkpoint
 
     ! ----------------------------------------------------------------------- !
     ! Public procedures
 
     procedure, pass(this), public :: run => optimizer_run
 
     ! ----------------------------------------------------------------------- !
     ! Private procedures
 
     procedure, pass(this) :: init_base => optimizer_init_base
     procedure, pass(this) :: free_base => optimizer_free_base
     procedure, pass(this) :: read_base_settings => optimizer_read_base_settings
     procedure, pass(this) :: get_iteration => optimizer_get_iteration
     procedure, pass(this) :: print_status => optimizer_print_status
     procedure, pass(this) :: out_of_time => optimizer_out_of_time
     procedure, pass(this) :: init_log => optimizer_init_log
     procedure, pass(this) :: write_log => optimizer_write_log
  end type optimizer_t
 
  ! -------------------------------------------------------------------------- !
  ! Interface for the optimizer module.
 
  abstract interface
 
     subroutine optimizer_init_from_json(this, parameters, problem, design, &
          simulation)
       import optimizer_t, json_file, simulation_t, problem_t, design_t, rp
       class(optimizer_t), intent(inout) :: this
       type(json_file), intent(inout) :: parameters
       class(problem_t), intent(inout) :: problem
       class(design_t), intent(in) :: design
       type(simulation_t), optional, intent(in) :: simulation
     end subroutine optimizer_init_from_json
 
     subroutine optimizer_initialize(this, problem, design, simulation)
       import optimizer_t, simulation_t, problem_t, design_t
       class(optimizer_t), intent(inout) :: this
       class(problem_t), intent(inout) :: problem
       class(design_t), intent(inout) :: design
       type(simulation_t), optional, intent(inout) :: simulation
     end subroutine optimizer_initialize
 
     subroutine optimizer_free(this)
       import optimizer_t
       class(optimizer_t), intent(inout) :: this
     end subroutine optimizer_free
 
     logical function optimizer_step(this, iter, problem, design, simulation)
       import optimizer_t, simulation_t, problem_t, design_t
       class(optimizer_t), intent(inout) :: this
       integer, intent(in) :: iter
       class(problem_t), intent(inout) :: problem
       class(design_t), intent(inout) :: design
       type(simulation_t), optional, intent(inout) :: simulation
     end function optimizer_step
 
     subroutine optimizer_validate(this, problem, design)
       import optimizer_t, problem_t, design_t
       class(optimizer_t), intent(inout) :: this
       class(problem_t), intent(in) :: problem
       class(design_t), intent(in) :: design
     end subroutine optimizer_validate
 
     subroutine optimizer_write(this, iter, problem)
       import optimizer_t, simulation_t, problem_t, design_t
       class(optimizer_t), intent(inout) :: this
       integer, intent(in) :: iter
       class(problem_t), intent(inout) :: problem
     end subroutine optimizer_write
 
     subroutine optimizer_save_checkpoint_components(this, filename, overwrite)
       import optimizer_t
       class(optimizer_t), intent(inout) :: this
       character(len=*), intent(in) :: filename
       logical, intent(in), optional :: overwrite
     end subroutine optimizer_save_checkpoint_components
 
     subroutine optimizer_load_checkpoint_components(this, filename)
       import optimizer_t
       class(optimizer_t), intent(inout) :: this
       character(len=*), intent(in) :: filename
     end subroutine optimizer_load_checkpoint_components
 
  end interface
 
  ! -------------------------------------------------------------------------- !
  ! Interfaces for the factory functions
 
  interface optimizer_factory
     module subroutine optimizer_factory(object, parameters, problem, design, &
          simulation)
       class(optimizer_t), allocatable, intent(inout) :: object
       type(json_file), intent(inout) :: parameters
       class(problem_t), intent(inout) :: problem
       class(design_t), intent(in) :: design
       type(simulation_t), optional, intent(in) :: simulation
     end subroutine optimizer_factory
  end interface optimizer_factory
 
  ! -------------------------------------------------------------------------- !
  ! IO routines for HDF5 checkpoints
 
  interface
 
     module subroutine optimizer_save_checkpoint_hdf5(object, filename, &
          overwrite)
       class(optimizer_t), intent(inout) :: object
       character(len=*), intent(in) :: filename
       logical, intent(in), optional :: overwrite
     end subroutine optimizer_save_checkpoint_hdf5
 
     module subroutine optimizer_load_checkpoint_hdf5(object, filename)
       class(optimizer_t), intent(inout) :: object
       character(len=*), intent(in) :: filename
     end subroutine optimizer_load_checkpoint_hdf5
  end interface
 
  public :: optimizer_factory
 
contains
 
  ! -------------------------------------------------------------------------- !
  ! Base initializer and free routines
 
  subroutine optimizer_init_base(this, optimizer_type, max_iterations, &
       max_runtime, stop_design_change, restart_file, checkpoint_path, &
       checkpoint_base, checkpoint_format, checkpoint_interval, &
       checkpoint_overwrite)
    class(optimizer_t), intent(inout) :: this
    character(len=*), intent(in) :: optimizer_type
    integer, intent(in) :: max_iterations
    real(kind=rp), intent(in), optional :: max_runtime
    real(kind=rp), intent(in), optional :: stop_design_change
    character(len=*), intent(in), optional :: restart_file
    character(len=*), intent(in), optional :: checkpoint_path
    character(len=*), intent(in), optional :: checkpoint_base
    character(len=*), intent(in), optional :: checkpoint_format
    integer, intent(in), optional :: checkpoint_interval
    logical, intent(in), optional :: checkpoint_overwrite
    character(len=LOG_SIZE) :: msg
    character(len=256) :: file_name
    logical :: exists
 
    ! Initialize internals
    this%start_time = mpi_wtime()
    this%initialized = .true.
 
    ! Mandatory settings
    this%optimizer_type = optimizer_type
    this%max_iterations = max_iterations
 
    ! Optional settings
    if (present(max_runtime)) this%max_runtime = max_runtime
    if (present(stop_design_change)) this%stop_design_change = stop_design_change
    if (present(restart_file)) this%restart_file = restart_file
    if (present(checkpoint_path)) this%checkpoint_path = checkpoint_path
    if (present(checkpoint_base)) this%checkpoint_base = checkpoint_base
    if (present(checkpoint_format)) this%checkpoint_format = checkpoint_format
    if (present(checkpoint_interval)) then
       this%checkpoint_interval = checkpoint_interval
    end if
    if (present(checkpoint_overwrite)) then
       this%checkpoint_overwrite = checkpoint_overwrite
    end if
 
    if (this%max_runtime .gt. 0.0_rp) then
       write(msg, '(A,F0.0,A)') 'Optimizer will stop after: ', &
            this%max_runtime, ' seconds.'
       call neko_log%message(msg)
 
       ! Look up the runtime checkpoint file if no restart file is specified
       if (len_trim(this%restart_file) .eq. 0) then
          exists = .false.
          file_name = checkpoint_filename(this, &
               basename = "optimizer_rt_checkpoint")
          if (pe_rank .eq. 0) inquire(file = file_name, exist = exists)
          call mpi_bcast(exists, 1, mpi_logical, 0, neko_comm)
          if (exists) this%restart_file = file_name
       end if
    end if
 
  end subroutine optimizer_init_base
 
  subroutine optimizer_free_base(this)
    class(optimizer_t), intent(inout) :: this
 
    this%optimizer_type = ''
    this%max_iterations = 0
    this%max_runtime = -1.0_rp
    this%stop_design_change = -1.0_rp
    this%max_design_change = 0.0_rp
    this%restart_file = ''
    this%checkpoint_path = './checkpoints/'
    this%checkpoint_base = 'optimizer_checkpoint'
    this%checkpoint_format = 'hdf5'
    this%checkpoint_interval = -1
    this%checkpoint_overwrite = .false.
 
    this%start_time = 0.0_rp
    this%current_iteration = 0
    call this%log_data%free()
    this%log_initialized = .false.
    this%log_extra_size = 0
    this%log_include_constraints = .true.
 
    ! Most files have no "free" method, must be done manually here
    this%log_file%header = ''
    this%log_file%header_is_written = .false.
    call this%log_file%set_overwrite(.false.)
 
    this%initialized = .false.
 
  end subroutine optimizer_free_base
 
  subroutine optimizer_read_base_settings(this, solver_params)
    class(optimizer_t), intent(inout) :: this
    type(json_file), intent(inout) :: solver_params
    integer :: read_int
    logical :: read_logical
    character(len=:), allocatable :: read_str
 
    if (this%initialized) then
       call neko_error('optimizer: Base settings already initialized.')
    end if
 
    call json_get_or_default(solver_params, 'max_runtime', read_str, "")
    call read_duration(read_str, this%max_runtime)
    call json_get_or_default(solver_params, 'stop_design_change', &
         this%stop_design_change, neko_eps)
 
    call json_get_or_default(solver_params, 'restart_file', read_str, &
         this%restart_file)
    this%restart_file = read_str
 
    call json_get_or_default(solver_params, 'checkpoint.path', read_str, &
         this%checkpoint_path)
    this%checkpoint_path = read_str
    call json_get_or_default(solver_params, 'checkpoint.base', read_str, &
         this%checkpoint_base)
    this%checkpoint_base = read_str
    call json_get_or_default(solver_params, 'checkpoint.format', read_str, &
         this%checkpoint_format)
    this%checkpoint_format = read_str
    call json_get_or_default(solver_params, 'checkpoint.interval', read_int, &
         this%checkpoint_interval)
    this%checkpoint_interval = read_int
    call json_get_or_default(solver_params, 'checkpoint.overwrite', &
         read_logical, this%checkpoint_overwrite)
    this%checkpoint_overwrite = read_logical
 
  end subroutine optimizer_read_base_settings
 
  ! -------------------------------------------------------------------------- !
  ! Optimization loop routine
 
  subroutine optimizer_run(this, problem, design, simulation)
    class(optimizer_t), intent(inout) :: this
    class(problem_t), intent(inout) :: problem
    class(design_t), intent(inout) :: design
    type(simulation_t), optional, intent(inout) :: simulation
    real(kind=rp) :: iteration_time
    logical :: converged
    integer :: stop_flag
 
    ! Initialize variables
    stop_flag = 1
    converged = .false.
 
    if (len_trim(this%restart_file) .gt. 0) then
       call this%load_checkpoint(design, this%restart_file)
    end if
 
    ! compute potential internals for for a potential restart
    if (this%current_iteration .ne. 0) then
       call design%set_output_counter(this%current_iteration - 1)
       if (present(simulation)) then
          call simulation%set_output_counter(this%current_iteration - 1)
       end if
    end if
 
    ! On a restart, restore the continuation parameters of the checkpointed
    ! iteration, so that the problem is re-evaluated with the same values as
    ! in the original run. A fresh start has nothing to restore, and update(0)
    ! would index the parameter values at 0.
    if (this%current_iteration .gt. 0) then
       call nekotop_continuation%update(this%current_iteration)
    end if
 
    ! Prepare the problem state before starting the optimization
    if (present(simulation)) then
       call simulation%set_design_iteration(this%current_iteration)
    end if
    call this%initialize(problem, design, simulation)
 
    ! Log the initial state of the problem.
    if (this%current_iteration .eq. 0) then
       call this%write(this%current_iteration, problem)
    end if
 
    ! Save the current design state.
    call design%write(this%current_iteration)
 
    call neko_log%section('Optimization Loop')
 
    do while (this%current_iteration .lt. this%max_iterations)
       this%current_iteration = this%current_iteration + 1
       if (pe_rank .eq. 0) then
          write(*,*) 'Starting iteration ', this%current_iteration
       end if
 
       call profiler_start_region('Optimizer iteration')
       iteration_time = mpi_wtime()
 
       ! Update the parameters in continuation scheduler
       call nekotop_continuation%update(this%current_iteration)
 
       if (present(simulation)) then
          call simulation%set_design_iteration(this%current_iteration)
       end if
       converged = this%step(this%current_iteration, problem, design, &
            simulation)
 
       iteration_time = mpi_wtime() - iteration_time
       call profiler_end_region('Optimizer iteration')
 
       ! Log the progress and outputs
       call this%write(this%current_iteration, problem)
       call design%write(this%current_iteration)
 
       ! Save checkpoint if enabled
       if (this%checkpoint_interval .gt. 0 .and. &
            mod(this%current_iteration, this%checkpoint_interval) == 0) then
          call this%save_checkpoint(design)
       end if
 
       ! --------------------------------------------------------------------- !
       ! Check stopping criteria
 
       if (converged) then
          stop_flag = 0
          exit
       else if (this%current_iteration .ge. this%max_iterations) then
          stop_flag = 1
          exit
       else if (this%max_design_change .lt. this%stop_design_change) then
          stop_flag = 2
          exit
       else if (this%out_of_time(iteration_time)) then
          block
            character(len=256) :: filename
            filename = checkpoint_filename(this, &
                 basename = "optimizer_rt_checkpoint")
            call this%save_checkpoint(design, .true., filename)
          end block
          stop_flag = 3
          exit
       end if
    end do
 
    ! Check that the final design is valid
    call this%validate(problem, design)
    call this%print_status(stop_flag, this%current_iteration)
 
    call neko_log%end_section()
 
  end subroutine optimizer_run
 
  ! ========================================================================== !
  ! Helper routines
 
  pure function optimizer_get_iteration(this) result(iteration)
    class(optimizer_t), intent(in) :: this
    integer :: iteration
 
    iteration = this%current_iteration
  end function optimizer_get_iteration
 
  subroutine optimizer_print_status(this, stop_flag, iteration)
    class(optimizer_t), intent(in) :: this
    integer, intent(in) :: stop_flag
    integer, intent(in) :: iteration
    character(len=LOG_SIZE) :: msg
 
    select case (stop_flag)
    case (0)
       write(msg, '(A,I0,A)') 'Optimizer converged successfully after ', &
            iteration, ' iterations.'
       call neko_log%message(msg)
    case (1)
       write(msg, '(A,I0,A)') 'Optimizer did not converge in ', &
            this%max_iterations, ' iterations.'
       call neko_log%warning(msg)
    case (2)
       write(msg, '(A,A,F8.2,A)') 'Optimizer stopped, design change ', &
            'below threshold of: ', this%stop_design_change, '.'
       call neko_log%warning(msg)
    case (3)
       if (pe_rank .eq. 0) then
          write(error_unit, '(A)') &
               '*** Error: Optimizer stopped due to runtime limit. ***'
       end if
 
    case default
       write(msg, '(A)') 'Optimizer stopped for an unknown reason.'
       call neko_error(msg)
    end select
  end subroutine optimizer_print_status
 
  function optimizer_out_of_time(this, step_time) result(out_of_time)
    class(optimizer_t), intent(inout) :: this
    real(kind=rp), intent(in) :: step_time
    logical :: out_of_time
    real(kind=rp) :: elapsed, step, old_avg_weight
 
    out_of_time = .false.
    if (this%max_runtime .lt. 0.0_rp) then
       return
    end if
 
    call mpi_allreduce(step_time, step, 1, mpi_real_precision, mpi_max, &
         neko_comm)
 
    this%step_count = this%step_count + 1.0_rp
    old_avg_weight = (this%step_count - 1.0_rp) / this%step_count
 
    ! Estimate Cumulative Average iteration step
    this%average_time = step / this%step_count + &
         this%average_time * old_avg_weight
 
    ! Determine if next iteration would exceed max runtime
    elapsed = mpi_wtime() - this%start_time
    out_of_time = (elapsed + this%average_time) .gt. 0.99_rp * this%max_runtime
 
  end function optimizer_out_of_time
 
  ! ========================================================================== !
  ! Logging helpers
 
  subroutine optimizer_init_log(this, problem, extra_headers, &
       include_constraints, filename)
    class(optimizer_t), intent(inout) :: this
    class(problem_t), intent(in) :: problem
    character(len=*), intent(in), optional :: extra_headers(:)
    logical, intent(in), optional :: include_constraints
    character(len=*), intent(in), optional :: filename
 
    character(len=4096) :: header
    integer :: total_size, base_size, i, n_cont
    character(len=256) :: log_name
 
    if (present(include_constraints)) then
       this%log_include_constraints = include_constraints
    end if
 
    n_cont = nekotop_continuation%get_n_params()
    base_size = problem%get_log_size(this%log_include_constraints)
    this%log_extra_size = 0
    if (present(extra_headers)) this%log_extra_size = size(extra_headers)
 
    total_size = 1 + base_size + this%log_extra_size + 2 + n_cont
    call this%log_data%init(total_size)
 
    if (present(filename)) then
       log_name = trim(filename)
    else
       log_name = 'optimization_data.csv'
    end if
 
    call this%log_file%init(trim(log_name))
 
    header = 'iter, ' // &
         trim(problem%get_log_header(this%log_include_constraints))
    if (present(extra_headers)) then
       do i = 1, size(extra_headers)
          if (trim(extra_headers(i)) .eq. '') then
             call neko_error('some headers are empty')
          end if
          header = trim(header) // ', ' // trim(extra_headers(i))
       end do
    end if
 
    header = trim(header) // ', max_design_change, norm2_design_change'
 
    ! continuation parameters
    do i = 1, n_cont
       header = trim(header) // ', ' // &
            trim(nekotop_continuation%get_param_name(i))
    end do
    call this%log_file%set_header(trim(header))
 
    this%log_initialized = .true.
  end subroutine optimizer_init_log
 
  subroutine optimizer_write_log(this, iter, problem, extra_values)
    class(optimizer_t), intent(inout) :: this
    integer, intent(in) :: iter
    class(problem_t), intent(in) :: problem
    real(kind=rp), intent(in), optional :: extra_values(:)
    integer :: base_size, offset, n_cont, i
 
    if (.not. this%log_initialized) return
 
    ! Iteration 0 starts a new log; later iterations append to the existing
    ! log without writing its header again.
    if (this%current_iteration .eq. 0) then
       call this%log_file%set_overwrite(.true.)
       this%log_file%header_is_written = .false.
    else
       call this%log_file%set_overwrite(.false.)
       this%log_file%header_is_written = .true.
    end if
 
    ! Number of continuation parameters
    n_cont = nekotop_continuation%get_n_params()
 
    base_size = problem%get_log_size(this%log_include_constraints)
    this%log_data%x(1) = real(iter, kind=rp)
 
    call problem%get_log_values( &
         this%log_data%x(2:1 + base_size), &
         this%log_include_constraints)
 
    offset = 2 + base_size
    if (present(extra_values)) then
       if (this%log_extra_size .eq. 0) then
          call neko_error('got extra values but no headers')
       end if
       this%log_data%x(offset:offset + size(extra_values) - 1) = extra_values
    end if
 
    ! Save maximum design change
    offset = offset + this%log_extra_size
    this%log_data%x(offset:offset + 1 - 1) = this%max_design_change
    this%log_data%x(offset + 1:offset + 2 - 1) = this%norm2_design_change
 
    ! Continuation parameter values, starting at the first slot after the
    ! design change entries
    offset = offset + 2
    do i = 1, n_cont
       this%log_data%x(offset + i - 1) = &
            nekotop_continuation%params(i)%target
    end do
 
    call this%log_file%write(this%log_data)
 
  end subroutine optimizer_write_log
 
  ! ========================================================================== !
  ! IO Functions
 
  function checkpoint_filename(this, path, basename, format, iteration) &
       result(file_full)
    class(optimizer_t), intent(in) :: this
    character(len=*), intent(in), optional :: path
    character(len=*), intent(in), optional :: basename
    character(len=*), intent(in), optional :: format
    integer, intent(in), optional :: iteration
    character(len=256) :: file_full
    character(len=:), allocatable :: file_format
    character(len=256) :: file_path, file_base, file_ext
 
    ! Default, read from the optimizer's stored checkpoint settings
    file_path = trim(this%checkpoint_path)
    file_base = trim(this%checkpoint_base)
    file_format = trim(this%checkpoint_format)
 
    ! Override with any provided arguments
    if (present(path)) file_path = trim(path)
    if (present(basename)) file_base = trim(basename)
    if (present(format)) file_format = trim(format)
 
    ! Ensure the path ends with a '/'
    if (len_trim(file_path) .eq. 0) then
       file_path = './'
    else if (file_path(len_trim(file_path):len_trim(file_path)) .ne. '/') then
       file_path = trim(file_path) // '/'
    end if
 
    select case (trim(file_format))
    case ('h5', 'hdf5', 'hf5', 'hdf')
       file_ext = 'h5'
    case default
       call neko_error('optimizer: Unsupported checkpoint format: "' // &
            trim(file_format) // '"')
    end select
 
    ! Construct the full filename based on overwrite flag
    if (present(iteration)) then
       write(file_full, '(3A,I5.5,2A)') trim(file_path), &
            trim(file_base), "_", iteration, ".", trim(file_ext)
    else
       write(file_full, '(4A)') &
            trim(file_path), trim(file_base), ".", trim(file_ext)
    end if
 
  end function checkpoint_filename
 
  subroutine optimizer_save_checkpoint(this, design, overwrite, filename, &
       path, basename, format, iteration)
    class(optimizer_t), intent(inout) :: this
    class(design_t), intent(inout) :: design
    logical, intent(in), optional :: overwrite
    character(len=*), intent(in), optional :: filename
    character(len=*), intent(in), optional :: path
    character(len=*), intent(in), optional :: basename
    character(len=*), intent(in), optional :: format
    integer, intent(in), optional :: iteration
    character(len=256) :: file_full, file_path
    character(len=12) :: suffix
    logical :: exists, overwrite_flag
 
    call neko_log%section('Optimizer save checkpoint')
    call profiler_start_region('Optimizer save checkpoint')
 
    ! Ensure support for external iterators.
    if (present(iteration)) this%current_iteration = iteration
    if (.not. present(overwrite)) then
       overwrite_flag = this%checkpoint_overwrite
    else
       overwrite_flag = overwrite
    end if
 
    ! Create the fill filename and extract relevant components
    if (present(filename) .and. (present(path) .or. present(basename) .or. &
         present(format) .or. present(iteration))) then
       call neko_error('optimizer: Cannot specify both filename and ' // &
            'path/basename/format for checkpoint loading.')
    else if (present(filename)) then
       file_full = trim(filename)
    else
       file_full = checkpoint_filename(this, path, basename, format, &
            this%current_iteration)
    end if
 
    ! Throw an error if the file already exists
    if (pe_rank .eq. 0) then
       inquire(file = file_full, exist = exists)
       if (exists .and. .not. overwrite_flag) then
          call neko_error('optimizer: Checkpoint file "' // &
               trim(file_full) // '" already exists and overwrite is false.')
       end if
    end if
 
    ! Extract the path and suffix from the full filename.
    call filename_path(trim(file_full), file_path)
    call filename_suffix(trim(file_full), suffix)
 
    ! Create the path if it does not exist
    exists = .false.
    if (pe_rank .eq. 0) inquire(file=file_path, exist=exists)
    call mpi_bcast(exists, 1, mpi_logical, 0, neko_comm)
    if (.not. exists) then
       if (pe_rank .eq. 0) call mkdir(trim(file_path))
       call mpi_barrier(neko_comm)
    end if
 
    call neko_log%message('Save general optimizer components')
    select case (trim(suffix))
    case ('h5', 'hdf5', 'hf5')
       call optimizer_save_checkpoint_hdf5(this, file_full, overwrite_flag)
    case default
       call neko_error('optimizer: Unsupported checkpoint format: "' // &
            trim(suffix) // '"')
    end select
 
    call neko_log%message('Saving components of ' // this%optimizer_type)
    call this%save_checkpoint_components(file_full, overwrite_flag)
 
    call neko_log%message('Save design checkpoint')
    call design%save_checkpoint(file_full, overwrite_flag)
 
    call profiler_end_region('Optimizer save checkpoint')
    call neko_log%end_section()
 
  end subroutine optimizer_save_checkpoint
 
  subroutine optimizer_load_checkpoint(this, design, filename, &
       path, basename, format, iteration)
    class(optimizer_t), intent(inout) :: this
    class(design_t), intent(inout) :: design
    character(len=*), intent(in), optional :: filename
    character(len=*), intent(in), optional :: path
    character(len=*), intent(in), optional :: basename
    character(len=*), intent(in), optional :: format
    integer, intent(in), optional :: iteration
    character(len=256) :: file_full
    character(len=12) :: suffix
 
    call neko_log%section('Optimizer loading checkpoint')
    call profiler_start_region('Optimizer load checkpoint')
 
    ! Check that the provided inputs are a valid combination.
    if (present(filename) .and. (present(path) .or. present(basename) .or. &
         present(format) .or. present(iteration))) then
       call neko_error('optimizer: Cannot specify both filename and ' // &
            'path/basename/format for checkpoint loading.')
    else if (present(filename)) then
       file_full = trim(filename)
    else
       file_full = checkpoint_filename(this, path, basename, format, iteration)
    end if
 
    if (pe_rank .eq. 0) then
       block
         logical :: exists
         character(len=256) :: msg
         inquire(file = file_full, exist = exists)
         if (.not. exists) then
            write(msg, '(3A)') 'optimizer: Checkpoint file "', trim(file_full), &
                 '" does not exist.'
            call neko_error(msg)
         end if
       end block
    end if
    call mpi_barrier(neko_comm)
 
    ! Get the file extension
    call filename_suffix(trim(file_full), suffix)
    select case (trim(suffix))
    case ('h5', 'hdf5', 'hf5')
       call optimizer_load_checkpoint_hdf5(this, trim(file_full))
    case default
       call neko_error('optimizer: Unsupported checkpoint format: "' // &
            trim(suffix) // '"')
    end select
 
    call this%load_checkpoint_components(trim(file_full))
    call design%load_checkpoint(trim(file_full))
 
    ! Set the current iteration to the loaded iteration
    if (pe_rank .eq. 0) then
       write(*,*) 'Restarted simulation from checkpoint.'
       write(*,*) '    Checkpoint file: "', trim(file_full), '"'
       write(*,*) '    Iteration      : ', this%current_iteration
    end if
 
    call profiler_end_region('Optimizer load checkpoint')
    call neko_log%end_section()
 
  end subroutine optimizer_load_checkpoint
 
  ! ========================================================================== !
  ! Dummy implementations for module procedures
 
#if !HAVE_HDF5
  module subroutine optimizer_save_checkpoint_hdf5(object, filename, &
       overwrite)
    class(optimizer_t), intent(inout) :: object
    character(len=*), intent(in) :: filename
    logical, intent(in), optional :: overwrite
    call neko_error('optimizer: HDF5 support not enabled rebuild with ' // &
         'HAVE_HDF5')
  end subroutine optimizer_save_checkpoint_hdf5
 
  module subroutine optimizer_load_checkpoint_hdf5(object, filename)
    class(optimizer_t), intent(inout) :: object
    character(len=*), intent(in) :: filename
    call neko_error('optimizer: HDF5 support not enabled rebuild with ' // &
         'HAVE_HDF5')
  end subroutine optimizer_load_checkpoint_hdf5
#endif
 
end module optimizer