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
    logical :: save_disc
 
    ! We save to disc only every n_saves_memory time steps
    save_disc = modulo(neko_case%time%tstep, this%n_saves_memory) .eq. 0
 
    ! Sample the checkpoint if needed
    if (save_disc .or. neko_case%time%tstep .le. this%first_valid_timestep) then
 
       call this%chkp_output%set_counter(neko_case%time%tstep)
       call this%chkp_output%sample(neko_case%time%t)
       this%n_saves_disc = this%n_saves_disc + 1
    end if
  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 :: j, k, previous_save, next_save
    integer :: i_scalars
    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
       call this%chkp_output%set_counter(previous_save)
       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
 
          local_idx = modulo(k, this%n_saves_memory) + 1
          call field_copy(this%p_list(local_idx), p)
          call field_copy(this%u_list(local_idx), u)
          call field_copy(this%v_list(local_idx), v)
          call field_copy(this%w_list(local_idx), w)
          do i_scalars = 1, this%n_scalars
             j = (local_idx - 1) * this%n_scalars + i_scalars
             s => neko_case%scalars%scalar_fields(i_scalars)%s
             call field_copy(this%s_list(j), s)
          end do
 
       end do
    end if
 
    local_idx = modulo(tstep, this%n_saves_memory) + 1
    call field_copy(p, this%p_list(local_idx))
    call field_copy(u, this%u_list(local_idx))
    call field_copy(v, this%v_list(local_idx))
    call field_copy(w, this%w_list(local_idx))
    do i_scalars = 1, this%n_scalars
       j = (local_idx - 1) * this%n_scalars + i_scalars
       s => neko_case%scalars%scalar_fields(i_scalars)%s
       call field_copy(s, this%s_list(j))
    end do
 
 
  end subroutine checkpoint_restore_linear
 
end submodule checkpoint_linear