checkpoint_linear.f90

 
!
 
submodule(simulation_checkpoint) checkpoint_linear
  use simulation, only: simulation_step, simulation_restart
  use file, only: file_t, file_free
  use time_step_controller, only: time_step_controller_t
 
contains
 
  module subroutine checkpoint_save_linear(this, neko_case)
    class(simulation_checkpoint_t), intent(inout) :: this
    class(case_t), intent(inout) :: neko_case
    integer :: index, tstep, counter
    real(kind=rp) :: time
 
    time = neko_case%time%t
    tstep = neko_case%time%tstep
 
    ! We save to disc only every n_saves_memory time steps
    index = modulo(tstep, this%n_saves_memory)
 
    ! Sample the checkpoint if needed
    if (index .eq. 0 .or. tstep .le. this%first_valid_timestep) then
       this%loaded_checkpoint = tstep
 
       counter = determine_counter(tstep, this%n_saves_memory, &
            this%first_valid_timestep)
 
       call this%chkp_output%set_counter(counter)
       call this%chkp_output%sample(time)
       this%n_saves_disc = this%n_saves_disc + 1
    end if
 
    call this%save_data(index + 1)
  end subroutine checkpoint_save_linear
 
  module subroutine checkpoint_restore_linear(this, neko_case, tstep)
    class(simulation_checkpoint_t), intent(inout) :: this
    class(case_t), target, intent(inout) :: neko_case
    integer, intent(in) :: tstep
    type(time_step_controller_t) :: dt_controller
    real(kind=dp) :: loop_start
    integer :: k, previous_save, next_save, local_idx, counter
    type(field_t), pointer :: u, v, w, p, s
 
    loop_start = mpi_wtime()
 
    u => neko_case%fluid%u
    v => neko_case%fluid%v
    w => neko_case%fluid%w
    p => neko_case%fluid%p
    s => null()
 
    ! Determine the nearest save states on both sides
    previous_save = tstep - modulo(tstep, this%n_saves_memory)
    next_save = previous_save + this%n_saves_memory
 
    ! Before the first valid state we always load from disc and we do not step
    ! forward in time.
    if (tstep .lt. this%first_valid_timestep) then
       previous_save = tstep
       next_save = previous_save + 1
    else if (previous_save .lt. this%first_valid_timestep) then
       previous_save = this%first_valid_timestep
    end if
 
    ! Load a new batch of checkpoints if needed
    if (this%loaded_checkpoint .ne. previous_save) then
 
       ! Restart the simulation form the checkpoint file
       counter = determine_counter(previous_save, this%n_saves_memory, &
            this%first_valid_timestep)
       call this%chkp_output%set_counter(counter)
       call this%chkp_output%file_%read(neko_case%chkp)
       call simulation_restart(neko_case, neko_case%chkp)
 
       ! Initialize the time step controller and set the time step
       call dt_controller%init(neko_case%params)
       neko_case%time%tstep = previous_save
       this%loaded_checkpoint = neko_case%time%tstep
 
       ! Step through the simulation and store field states in memory
       do k = previous_save, min(next_save - 1, this%n_timesteps)
 
          ! Do not run simulation step on the first iteration
          if (k .ne. previous_save) then
             if (neko_case%time%t .ge. neko_case%time%end_time) exit
             call simulation_step(neko_case, dt_controller, loop_start)
          end if
 
          ! Save the restored state in memory
          local_idx = modulo(k, this%n_saves_memory) + 1
          call this%save_data(local_idx)
       end do
    end if
 
    ! Restore the required time step from memory
    local_idx = modulo(tstep, this%n_saves_memory) + 1
    call this%load_data(local_idx)
  end subroutine checkpoint_restore_linear
 
  pure function determine_counter(tstep, n_memory, first) result(counter)
    integer, intent(in) :: tstep, n_memory, first
    integer :: counter
 
    if (tstep .le. first) then
       counter = tstep
    else
       counter = first + tstep / n_memory
    end if
 
  end function determine_counter
 
end submodule checkpoint_linear