krylov.f90

Go to the documentation of this file.

! Copyright (c) 2020-2023, The Neko Authors
! All rights reserved.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
!   * Redistributions of source code must retain the above copyright
!     notice, this list of conditions and the following disclaimer.
!
!   * Redistributions in binary form must reproduce the above
!     copyright notice, this list of conditions and the following
!     disclaimer in the documentation and/or other materials provided
!     with the distribution.
!
!   * Neither the name of the authors nor the names of its
!     contributors may be used to endorse or promote products derived
!     from this software without specific prior written permission.
!
! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
! COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
! BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! POSSIBILITY OF SUCH DAMAGE.
!
module krylov
  use gather_scatter, only : gs_t, gs_op_add
  use ax_product, only : ax_t
  use num_types, only : rp, c_rp
  use precon, only : pc_t
  use coefs, only : coef_t
  use mesh, only : mesh_t
  use field, only : field_t
  use utils, only : neko_error, neko_warning
  use scalar_bc_projector, only : scalar_bc_projector_t
  use vector_bc_projector, only : vector_bc_projector_t
  use identity, only : ident_t
  use device_identity, only : device_ident_t
  use neko_config, only : neko_bcknd_device
  use logger, only : neko_log, log_size
  implicit none
  private
 
  integer, public, parameter :: ksp_max_iter = 1e3 
  real(kind=rp), public, parameter :: ksp_abs_tol = 1d-9 
  real(kind=rp), public, parameter :: ksp_rel_tol = 1d-9 
 
  type, public :: ksp_monitor_t
     character(len=18) :: name = ""
     integer :: iter
     real(kind=rp) :: res_start
     real(kind=rp) :: res_final
     logical :: converged = .false.
   contains
     procedure, pass(this) :: print_header => krylov_monitor_print_header
     procedure, pass(this) :: print_result => krylov_monitor_print_result
  end type ksp_monitor_t
 
  type, public, abstract :: ksp_t
     class(pc_t), pointer :: m => null() 
     real(kind=rp) :: rel_tol 
     real(kind=rp) :: abs_tol 
     integer :: max_iter
     class(pc_t), allocatable :: m_ident
     logical :: monitor
   contains
     procedure(ksp_init_intrf), deferred, pass(this) :: init
     procedure, pass(this) :: ksp_init => krylov_init
     procedure, pass(this) :: ksp_free => krylov_free
     procedure, pass(this) :: set_pc => krylov_set_pc
     procedure(ksp_method), pass(this), deferred :: solve
     procedure(ksp_method_coupled), pass(this), deferred :: solve_coupled
     procedure, pass(this) :: monitor_start => krylov_monitor_start
     procedure, pass(this) :: monitor_stop => krylov_monitor_stop
     procedure, pass(this) :: monitor_iter => krylov_monitor_iter
     procedure, pass(this) :: is_converged => krylov_is_converged
     procedure(ksp_t_free), pass(this), deferred :: free
  end type ksp_t
 
  abstract interface
     subroutine ksp_init_intrf(this, n, max_iter, M, rel_tol, abs_tol, monitor)
       import :: pc_t, ksp_t, rp
       implicit none
       class(ksp_t), target, intent(inout) :: this
       integer, intent(in) :: max_iter
       class(pc_t), optional, intent(in), target :: M
       integer, intent(in) :: n
       real(kind=rp), optional, intent(in) :: rel_tol
       real(kind=rp), optional, intent(in) :: abs_tol
       logical, optional, intent(in) :: monitor
     end subroutine ksp_init_intrf
  end interface
 
  abstract interface
     function ksp_method(this, Ax, x, f, n, coef, bc_projector, gs_h, niter) &
          result(ksp_results)
       import :: scalar_bc_projector_t
       import :: field_t
       import :: ksp_t
       import :: coef_t
       import :: gs_t
       import :: ax_t
       import :: ksp_monitor_t
       import rp
       implicit none
       class(ksp_t), intent(inout) :: this
       class(ax_t), intent(in) :: ax
       type(field_t), intent(inout) :: x
       integer, intent(in) :: n
       real(kind=rp), dimension(n), intent(in) :: f
       type(coef_t), intent(inout) :: coef
       class(scalar_bc_projector_t), intent(inout) :: bc_projector
       type(gs_t), intent(inout) :: gs_h
       integer, optional, intent(in) :: niter
       type(ksp_monitor_t) :: ksp_results
     end function ksp_method
  end interface
 
  abstract interface
     function ksp_method_coupled(this, Ax, x, y, z, fx, fy, fz, &
          n, coef, bc_projector, gs_h, niter) result(ksp_results)
       import :: vector_bc_projector_t
       import :: field_t
       import :: ksp_t
       import :: coef_t
       import :: gs_t
       import :: ax_t
       import :: ksp_monitor_t
       import rp
       implicit none
       class(ksp_t), intent(inout) :: this
       class(ax_t), intent(in) :: ax
       type(field_t), intent(inout) :: x
       type(field_t), intent(inout) :: y
       type(field_t), intent(inout) :: z
       integer, intent(in) :: n
       real(kind=rp), dimension(n), intent(in) :: fx
       real(kind=rp), dimension(n), intent(in) :: fy
       real(kind=rp), dimension(n), intent(in) :: fz
       type(coef_t), intent(inout) :: coef
       class(vector_bc_projector_t), intent(inout) :: bc_projector
       type(gs_t), intent(inout) :: gs_h
       integer, optional, intent(in) :: niter
       type(ksp_monitor_t), dimension(3) :: ksp_results
     end function ksp_method_coupled
  end interface
 
  abstract interface
     subroutine ksp_t_free(this)
       import :: ksp_t
       class(ksp_t), intent(inout) :: this
     end subroutine ksp_t_free
  end interface
 
  interface
 
     module subroutine krylov_solver_factory(object, n, type_name, &
          max_iter, abstol, m, monitor)
       class(ksp_t), allocatable, intent(inout) :: object
       integer, intent(in), value :: n
       character(len=*), intent(in) :: type_name
       integer, intent(in) :: max_iter
       real(kind=rp), optional :: abstol
       class(pc_t), optional, intent(in), target :: m
       logical, optional, intent(in) :: monitor
     end subroutine krylov_solver_factory
 
  end interface
 
  interface
 
     module subroutine krylov_solver_allocator(object, type_name)
       class(ksp_t), allocatable, intent(inout) :: object
       character(len=*), intent(in) :: type_name
     end subroutine krylov_solver_allocator
  end interface
 
  !
  ! Machinery for injecting user-defined types
  !
 
  abstract interface
     subroutine krylov_allocate(obj)
       import ksp_t
       class(ksp_t), allocatable, intent(inout) :: obj
     end subroutine krylov_allocate
  end interface
 
  interface
 
     module subroutine register_krylov(type_name, allocator)
       character(len=*), intent(in) :: type_name
       procedure(krylov_allocate), pointer, intent(in) :: allocator
     end subroutine register_krylov
  end interface
 
  type krylov_allocator_entry
     character(len=20) :: type_name
     procedure(krylov_allocate), pointer, nopass :: allocator
  end type krylov_allocator_entry
 
  type(krylov_allocator_entry), allocatable :: krylov_registry(:)
 
  integer :: krylov_registry_size = 0
 
  public :: krylov_solver_factory, krylov_solver_allocator, register_krylov, &
       krylov_allocate
contains
 
  subroutine krylov_init(this, max_iter, rel_tol, abs_tol, M, monitor)
    class(ksp_t), target, intent(inout) :: this
    integer, intent(in) :: max_iter
    real(kind=rp), optional, intent(in) :: rel_tol
    real(kind=rp), optional, intent(in) :: abs_tol
    class(pc_t), optional, target, intent(in) :: m
    logical, optional, intent(in) :: monitor
 
    call krylov_free(this)
 
    if (present(rel_tol)) then
       this%rel_tol = rel_tol
    else
       this%rel_tol = ksp_rel_tol
    end if
 
    if (present(abs_tol)) then
       this%abs_tol = abs_tol
    else
       this%abs_tol = ksp_abs_tol
    end if
 
    this%max_iter = max_iter
 
    if (present(m)) then
       this%M => m
    else
       if (.not. associated(this%M)) then
          if (neko_bcknd_device .eq. 1) then
             allocate(device_ident_t::this%M_ident)
          else
             allocate(ident_t::this%M_ident)
          end if
          this%M => this%M_ident
       end if
    end if
 
    if (present(monitor)) then
       this%monitor = monitor
    else
       this%monitor = .false.
    end if
 
  end subroutine krylov_init
 
  subroutine krylov_free(this)
    class(ksp_t), intent(inout) :: this
 
 
  end subroutine krylov_free
 
  subroutine krylov_set_pc(this, M)
    class(ksp_t), intent(inout) :: this
    class(pc_t), target, intent(in) :: M
 
    if (associated(this%M)) then
       select type (pc => this%M)
       type is (ident_t)
       type is (device_ident_t)
       class default
          call neko_error('Preconditioner already defined')
       end select
    end if
 
    this%M => m
 
  end subroutine krylov_set_pc
 
  subroutine krylov_monitor_start(this, name)
    class(ksp_t), intent(in) :: this
    character(len=*) :: name
    character(len=LOG_SIZE) :: log_buf
 
    if (this%monitor) then
       write(log_buf, '(A)') 'Krylov monitor (' // trim(name) // ')'
       call neko_log%section(trim(log_buf))
       call neko_log%newline()
       call neko_log%begin()
       write(log_buf, '(A)') ' Iter.          Residual'
       call neko_log%message(log_buf)
       write(log_buf, '(A)') '-------------------------'
       call neko_log%message(log_buf)
    end if
  end subroutine krylov_monitor_start
 
  subroutine krylov_monitor_stop(this)
    class(ksp_t), intent(in) :: this
 
    if (this%monitor) then
       call neko_log%end()
       call neko_log%end_section()
       call neko_log%newline()
    end if
  end subroutine krylov_monitor_stop
 
 
  subroutine krylov_monitor_iter(this, iter, rnorm)
    class(ksp_t), intent(in) :: this
    integer, intent(in) :: iter
    real(kind=rp), intent(in) :: rnorm
    character(len=LOG_SIZE) :: log_buf
 
    if (this%monitor) then
       write(log_buf, '(I6,E18.9)') iter, rnorm
       call neko_log%message(log_buf)
    end if
 
  end subroutine krylov_monitor_iter
 
  pure function krylov_is_converged(this, iter, residual) result(converged)
    class(ksp_t), intent(in) :: this
    integer, intent(in) :: iter
    real(kind=rp), intent(in) :: residual
    logical :: converged
 
    converged = .true.
    if (iter .ge. this%max_iter) converged = .false.
    if (residual .gt. this%abs_tol) converged = .false.
 
  end function krylov_is_converged
 
  subroutine krylov_monitor_print_header(this)
    class(ksp_monitor_t), intent(in) :: this
    character(len=LOG_SIZE) :: log_buf
 
    write(log_buf, '(A10,2x,A3,(A5,13x),1x,A6,3x,A15,3x,A15)') &
         'KSP solver', ' | ', 'Field:', 'Iters:', &
         'Start residual:', 'Final residual:'
    call neko_log%message(log_buf)
 
  end subroutine krylov_monitor_print_header
 
  subroutine krylov_monitor_print_result(this, step)
    class(ksp_monitor_t), intent(in) :: this
    integer, intent(in) :: step
    character(len=LOG_SIZE) :: log_buf
    character(len=12) :: step_str
    character(len=:), allocatable :: output_format
 
    if (this%name .eq. "") call neko_error('Krylov solver name is not set')
 
    ! Define the output format
    output_format = '(A12,A3,A18,1x,I6,3x,E15.9,3x,E15.9)'
    write(step_str, '(I12)') step
    step_str = adjustl(step_str)
 
    write(log_buf, output_format) &
         step_str, ' | ' , adjustl(this%name), this%iter, &
         this%res_start, this%res_final
    call neko_log%message(log_buf)
 
  end subroutine krylov_monitor_print_result
 
end module krylov