sll_m_preconditioner_poisson_fft.F90

Go to the documentation of this file.

 
 
module sll_m_preconditioner_poisson_fft
  !+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include "sll_assert.h"
#include "sll_memory.h"
#include "sll_working_precision.h"
 
  use sll_m_linear_solver_abstract, only : &
       sll_t_linear_solver_abstract
 
  use sll_m_poisson_3d_fem_fft, only : &
       sll_t_poisson_3d_fem_fft
 
  implicit none
 
  public :: &
       sll_t_preconditioner_poisson_fft
 
  private
  !+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
  type, extends(sll_t_linear_solver_abstract) :: sll_t_preconditioner_poisson_fft
     type(sll_t_poisson_3d_fem_fft) :: poisson_solver
     sll_real64, allocatable :: jacobi_precond(:)
 
     sll_int32 :: n_dofs
     
   contains
 
     procedure :: create => create_poisson_fft
     procedure :: free => free_poisson_fft
     procedure :: solve_real => solve_poisson_fft
     procedure :: set_verbose => set_verbose_poisson_fft
     procedure :: print_info => print_info_poisson_fft
     procedure :: read_from_file => read_from_file_poisson_fft
 
  end type sll_t_preconditioner_poisson_fft
 
contains
 
  subroutine create_poisson_fft( self, n_dofs, degree, delta_x, jacobi_in )
    class(sll_t_preconditioner_poisson_fft), intent( inout ) :: self
    sll_int32, intent( in ) :: n_dofs(3)     
    sll_int32, intent( in ) :: degree(3)     
    sll_real64, intent( in ) :: delta_x(3)   
    sll_real64, intent( in ) :: jacobi_in(:)
 
    call self%poisson_solver%init( n_dofs, degree, delta_x  )
 
    allocate( self%jacobi_precond( product(n_dofs)) )
    self%jacobi_precond = jacobi_in
    self%n_dofs = product(n_dofs)
    
  end subroutine create_poisson_fft
 
  subroutine free_poisson_fft( self )
    class(sll_t_preconditioner_poisson_fft), intent( inout ) :: self
 
    call self%poisson_solver%free()
    
  end subroutine free_poisson_fft
 
  subroutine solve_poisson_fft(self,  rhs, unknown )
    class(sll_t_preconditioner_poisson_fft), intent( inout ) :: self
    sll_real64, intent(in   ) :: rhs(:) 
    sll_real64, intent(  out) :: unknown(:) 
 
    sll_real64, allocatable :: tmp(:)
 
    allocate( tmp(self%n_dofs) )
    unknown = self%jacobi_precond*rhs
   ! tmp = unknown
    call self%poisson_solver%compute_phi_from_rho( unknown, tmp )
    unknown = self%jacobi_precond*tmp
   
    
  end subroutine solve_poisson_fft
 
  subroutine read_from_file_poisson_fft(self, filename)
    class(sll_t_preconditioner_poisson_fft), intent( inout ) :: self
    character(len=*), intent( in ) :: filename
    
  end subroutine read_from_file_poisson_fft
 
  subroutine set_verbose_poisson_fft(self, verbose)
    class(sll_t_preconditioner_poisson_fft), intent( inout ) :: self
    logical, intent( in ) :: verbose
 
    self%verbose = verbose
  end subroutine set_verbose_poisson_fft
 
  subroutine print_info_poisson_fft(self)
    class(sll_t_preconditioner_poisson_fft), intent( in ) :: self
 
  end subroutine print_info_poisson_fft
 
  
end module sll_m_preconditioner_poisson_fft