sll_m_pic_poisson_base.F90

Go to the documentation of this file.

 
module sll_m_pic_poisson_base
 
#include "sll_working_precision.h"
 
  use sll_m_poisson_2d_base, only : &
       sll_i_function_of_position
 
  implicit none
 
  public :: sll_c_pic_poisson
 
  private
 
  type, abstract :: sll_c_pic_poisson
     sll_int32              :: dim 
     sll_int32              :: no_weights = 1 
     
   contains
     procedure(add_single), deferred            :: add_charge_single
     procedure                                  :: add_charge_vector
     procedure(eval_component_single), deferred :: evaluate_field_single
     procedure                                  :: evaluate_field_vector
     procedure(eval_single), deferred           :: evaluate_rho_single
     procedure                                  :: evaluate_rho_vector
     procedure(eval_single), deferred           :: evaluate_phi_single
     procedure                                  :: evaluate_phi_vector
     procedure(empty), deferred                 :: reset
     procedure(empty), deferred                 :: solve
     procedure                                  :: solve_phi
     procedure                                  :: solve_fields
     procedure(compute_energy), deferred        :: compute_field_energy
     procedure(linear_combination), deferred    :: add_analytic_charge
     procedure(update_dofs_function), deferred  :: set_analytic_charge
 
     procedure(empty), deferred                 :: free
 
 
     generic :: add_charge => add_charge_single, add_charge_vector
     generic :: evaluate_field => evaluate_field_single, evaluate_field_vector
     generic :: evaluate_rho => evaluate_rho_single, evaluate_rho_vector
     generic :: evaluate_phi => evaluate_phi_single, evaluate_phi_vector 
 
  end type sll_c_pic_poisson
 
  
  !---------------------------------------------------------------------------!
  abstract interface
     subroutine add_single(self, position, marker_charge) 
       use sll_m_working_precision
       import sll_c_pic_poisson
       class(sll_c_pic_poisson), intent( inout ) :: self 
       sll_real64,                intent( in )    :: position(self%dim) 
       sll_real64,                intent( in )    :: marker_charge 
     end subroutine add_single
  end interface
 
  !---------------------------------------------------------------------------!
  abstract interface
     subroutine eval_single(self, position, func_value)
       use sll_m_working_precision
       import sll_c_pic_poisson
       class(sll_c_pic_poisson), intent( inout ) :: self 
       sll_real64,                intent( in )    :: position(self%dim) 
       sll_real64,                intent( out)    :: func_value 
     end subroutine eval_single
  end interface
 
  !---------------------------------------------------------------------------!
  abstract interface
     subroutine eval_component_single(self, position, components, func_value)
       use sll_m_working_precision
       import sll_c_pic_poisson
       class(sll_c_pic_poisson), intent( inout ) :: self 
       sll_real64,                intent( in )    :: position(self%dim) 
       sll_int32,                 intent( in )    :: components(:) 
       sll_real64,                intent( out)    :: func_value(:) 
     end subroutine eval_component_single
  end interface
 
 
  !---------------------------------------------------------------------------!
  abstract interface
     subroutine empty(self)
       import sll_c_pic_poisson
       class(sll_c_pic_poisson), intent( inout ) :: self
     end subroutine empty
  end interface
 
 
  !---------------------------------------------------------------------------!
  abstract interface
     function compute_energy(self, component) result(energy)
       use sll_m_working_precision
       import sll_c_pic_poisson
       class(sll_c_pic_poisson), intent( in ) :: self 
       sll_int32,                 intent( in ) :: component 
       sll_real64 :: energy 
     end function compute_energy
  end interface
  
 
  !---------------------------------------------------------------------------!
  abstract interface
     subroutine update_dofs_function(self, func)
       use sll_m_working_precision
       import sll_c_pic_poisson
       import sll_i_function_of_position
       class( sll_c_pic_poisson ),       intent( inout )    :: self
       procedure(sll_i_function_of_position)                :: func
     end subroutine update_dofs_function
  end interface
 
  !---------------------------------------------------------------------------!
  abstract interface
     subroutine linear_combination(self, factor_present, factor_analytic)
       use sll_m_working_precision
       import sll_c_pic_poisson
       class( sll_c_pic_poisson ), intent( inout ) :: self
       sll_real64,                 intent( in )    :: factor_present 
       sll_real64,                 intent( in )    :: factor_analytic 
 
     end subroutine linear_combination
  end interface
 
contains
 
    !---------------------------------------------------------------------------!
    
  subroutine add_charge_vector(self,n_part, position, marker_charge) 
    class(sll_c_pic_poisson), intent( inout ) :: self 
    sll_int32,                 intent( in )    :: n_part 
    sll_real64,                intent( in )    :: position(self%dim, n_part) 
    sll_real64,                intent( in )    :: marker_charge(n_part) 
 
    !local variables
    sll_int32  :: i_part
 
    do i_part = 1, n_part
       call self%add_charge_single( position(:,i_part), marker_charge(i_part))
    end do
 
  end subroutine add_charge_vector
 
 
  !---------------------------------------------------------------------------!
  
  subroutine evaluate_rho_vector(self, position, n_part, func_value)
    class(sll_c_pic_poisson), intent( inout ) :: self 
    sll_real64,                intent( in )    :: position(:, :) 
    sll_int32,                 intent( in )    :: n_part 
    sll_real64,                intent( out)    :: func_value(n_part) 
 
    !local variables
    sll_int32 :: i_part
 
    do i_part = 1, n_part
       call self%evaluate_rho_single&
            (position(:, i_part), func_value(i_part))
    end do
    
 
  end subroutine evaluate_rho_vector
 
  !---------------------------------------------------------------------------!
  
  subroutine evaluate_phi_vector(self, position, n_part, func_value)
    class(sll_c_pic_poisson), intent( inout ) :: self 
    sll_real64,                intent( in )    :: position(:,:) 
    sll_int32,                 intent( in )    :: n_part 
    sll_real64,                intent( out)    :: func_value(n_part) 
 
    !local variables
    sll_int32 :: i_part
 
    do i_part = 1, n_part
       call self%evaluate_phi_single&
            (position(:, i_part), func_value(i_part))
    end do
    
 
  end subroutine evaluate_phi_vector
 
  
  !---------------------------------------------------------------------------!
  subroutine evaluate_field_vector(self, position, n_part, components,func_value)
    class(sll_c_pic_poisson), intent( inout ) :: self 
    sll_real64,                intent( in )    :: position(:,:) 
    sll_int32,                 intent( in )    :: n_part 
    sll_int32,                 intent( in )    :: components(:) 
    sll_real64,                intent( out)    :: func_value(:,:) 
    
    !local variables
    sll_int32 :: i_part
 
    do i_part = 1, n_part
       call self%evaluate_field_single&
            (position(:, i_part), components, func_value(:,i_part))
    end do
    
 
  end subroutine evaluate_field_vector
 
  subroutine solve_phi( self )    
    class(sll_c_pic_poisson), intent( inout ) :: self 
  
    call self%solve()
 
  end subroutine solve_phi
 
  subroutine solve_fields( self )    
    class(sll_c_pic_poisson), intent( inout ) :: self 
  
    call self%solve()
 
  end subroutine solve_fields
 
end module sll_m_pic_poisson_base