Line data    Source code

       1              : !--------------------------------------------------------------------------------
       2              : ! Copyright (c) 2024 Peter Grünberg Institut, Forschungszentrum Jülich, Germany
       3              : ! This file is part of FLEUR and available as free software under the conditions
       4              : ! of the MIT license as expressed in the LICENSE file in more detail.
       5              : !--------------------------------------------------------------------------------
       6              : 
       7              : module m_types_solver
       8              :    use m_types_mat
       9              :    use m_judfT
      10              :    implicit none
      11              :    private
      12              :    ! This is the data-type all eigenvalue solvers supported by FLEUR should implement
      13              :    type, abstract:: t_solver
      14              :       character(len=10):: name = "none"
      15              :       logical :: available
      16              :       logical :: parallel
      17              :       logical :: serial
      18              :       logical :: generalized
      19              :       logical :: standard
      20              :       logical :: single_precision
      21              :       logical :: transform
      22              :       logical :: GPU
      23              :       logical :: use_sp = .false.
      24              :    contains
      25              :       procedure        :: solve_std  !solver for standard eigenvalue problem
      26              :       procedure        :: solve_std_dp  !solver for standard eigenvalue problem (double precision)
      27              :       procedure        :: solve_std_sp  !solver for standard eigenvalue problem (single precision)
      28              :       procedure        :: solve_gev  !solver for generalized eigenvalue problem
      29              :       procedure        :: to_std     !transform the H of the generalized problem to a std problem
      30              :       procedure        :: backtrans  !transform the Eigenvalue back to the generalized problem
      31              :    end type
      32              : 
      33              :    !Simple solver that only stops
      34              :    type, extends(t_solver):: t_solver_stop
      35              :    contains
      36              :       procedure        :: solve_gev => solve_stop  !solver for generalized eigenvalue problem
      37              :    end type
      38              : 
      39              :    public:: t_solver, t_solver_stop, get_solver_stop
      40              : 
      41              : contains
      42          104 :    function get_solver_stop() result(solver)
      43              :       type(t_solver_stop), pointer::solver
      44          104 :       allocate (solver)
      45          104 :       solver%name = "stop"
      46          104 :       solver%available = .true.
      47          104 :       solver%parallel = .true.
      48          104 :       solver%serial = .true.
      49          104 :       solver%generalized = .true.
      50          104 :       solver%standard = .false.
      51          104 :       solver%single_precision = .false.
      52          104 :       solver%transform = .false.
      53          104 :       solver%GPU = .true.
      54              :       solver%use_sp = .false.
      55              : 
      56          104 :    end function
      57              : 
      58            0 :    subroutine solve_stop(self, hmat, smat, ne, eig, zmat, ikpt)
      59              :       implicit none
      60              :       class(t_solver_stop)       :: self
      61              :       class(t_mat), intent(INOUT)  :: hmat, smat
      62              :       integer, intent(INOUT)       :: ne
      63              :       class(t_mat), allocatable, intent(OUT)    :: zmat
      64              :       real, intent(OUT)           :: eig(:)
      65              :       integer, intent(IN)         :: ikpt
      66              : 
      67            0 :       call judft_error("FLEUR stopped as -diag stop was choosen")
      68            0 :    end subroutine
      69              : 
      70            0 :    subroutine solve_std(self, hmat, ne, eig, zmat)
      71              :       implicit none
      72              :       class(t_solver)            :: self
      73              :       class(t_mat), intent(INOUT)  :: hmat
      74              :       integer, intent(INOUT)       :: ne
      75              :       class(t_mat), allocatable, intent(OUT)    :: zmat
      76              :       real, intent(OUT)           :: eig(:)
      77              : 
      78            0 :       if (self%use_sp) then
      79            0 :          call self%solve_std_sp(hmat, ne, eig, zmat)
      80              :       else
      81            0 :          call self%solve_std_dp(hmat, ne, eig, zmat)
      82              :       end if
      83            0 :    end subroutine
      84              : 
      85            0 :    subroutine solve_gev(self, hmat, smat, ne, eig, zmat, ikpt)
      86              :       implicit none
      87              :       class(t_solver)                    :: self
      88              :       class(t_mat), intent(INOUT)          :: hmat, smat
      89              :       integer, intent(INOUT)               :: ne
      90              :       class(t_mat), allocatable, intent(OUT):: zmat
      91              :       real, intent(OUT)                    :: eig(:)
      92              :       integer, intent(IN)                  :: ikpt
      93              : 
      94            0 :       call judft_bug("Not implemented", calledby="solve_std")
      95            0 :    end subroutine
      96            0 :    subroutine solve_std_sp(self, hmat, ne, eig, zmat)
      97              :       implicit none
      98              :       class(t_solver)                     :: self
      99              :       class(t_mat), intent(INOUT)          :: hmat
     100              :       integer, intent(INOUT)               :: ne
     101              :       class(t_mat), allocatable, intent(OUT):: zmat
     102              :       real, intent(OUT)                    :: eig(:)
     103              : 
     104            0 :       call judft_bug("Not implemented", calledby="solve_std_sp")
     105            0 :    end subroutine
     106            0 :    subroutine solve_std_dp(self, hmat, ne, eig, zmat)
     107              :       implicit none
     108              :       class(t_solver)                     :: self
     109              :       class(t_mat), intent(INOUT)          :: hmat
     110              :       integer, intent(INOUT)               :: ne
     111              :       class(t_mat), allocatable, intent(OUT):: zmat
     112              :       real, intent(OUT)                    :: eig(:)
     113              : 
     114            0 :       call judft_bug("Not implemented", calledby="solve_std_dp")
     115            0 :    end subroutine
     116            0 :    subroutine to_std(self, hmat, smat)
     117              :       implicit none
     118              :       class(t_solver)                     :: self
     119              :       class(t_mat), intent(INOUT)          :: hmat, smat
     120              : 
     121            0 :       call judft_bug("Not implemented", calledby="to_std")
     122            0 :    end subroutine
     123            0 :    subroutine backtrans(self, smat, zmat)
     124              :       implicit none
     125              :       class(t_solver)                     :: self
     126              :       class(t_mat), intent(INOUT)         :: smat
     127              :       class(t_mat), intent(INOUT)         :: zmat
     128              : 
     129            0 :       call judft_bug("Not implemented", calledby="backtrans")
     130            0 :    end subroutine
     131              : 
     132          104 : end module m_types_solver