sll_m_time_propagator_pic_vm_3d3v_disgradE.F90

Go to the documentation of this file.

 
module sll_m_time_propagator_pic_vm_3d3v_disgrade
  !+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include "sll_assert.h"
#include "sll_memory.h"
#include "sll_working_precision.h"
 
  use sll_m_control_variate, only: &
       sll_t_control_variates
 
  use sll_m_time_propagator_base, only: &
       sll_c_time_propagator_base
 
  use sll_m_time_propagator_pic_vm_3d3v_helper, only: &
       sll_t_time_propagator_pic_vm_3d3v_helper
 
  use sll_m_time_propagator_pic_vm_3d3v_cl_helper, only:&
       sll_t_time_propagator_pic_vm_3d3v_cl_helper
 
  use sll_m_particle_mesh_coupling_base_3d, only: &
       sll_c_particle_mesh_coupling_3d
 
  use sll_m_maxwell_3d_base, only: &
       sll_c_maxwell_3d_base
 
  use sll_m_particle_group_base, only: &
       sll_c_particle_group_base, &
       sll_t_particle_array
 
  use sll_m_filter_base_3d, only: &
       sll_c_filter_base_3d
 
  implicit none
 
  public :: &
       sll_t_time_propagator_pic_vm_3d3v_disgrade
 
  private
  !+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
  type, extends(sll_c_time_propagator_base) :: sll_t_time_propagator_pic_vm_3d3v_disgrade
 
     type(sll_t_time_propagator_pic_vm_3d3v_helper) :: helper
     logical    :: electrostatic = .false. 
 
   contains
     procedure :: lie_splitting => lie_splitting_pic_vm_3d3v
     procedure :: lie_splitting_back => lie_splitting_back_pic_vm_3d3v
     procedure :: strang_splitting => strang_splitting_pic_vm_3d3v
 
     procedure :: init => initialize_pic_vm_3d3v
     procedure :: init_from_file => initialize_file_pic_vm_3d3v
     procedure :: free => delete_pic_vm_3d3v
 
  end type sll_t_time_propagator_pic_vm_3d3v_disgrade
 
contains
 
 
  subroutine strang_splitting_pic_vm_3d3v(self,dt, number_steps)
    class(sll_t_time_propagator_pic_vm_3d3v_disgrade), intent(inout) :: self
    sll_real64,                                     intent(in)    :: dt   
    sll_int32,                                      intent(in)    :: number_steps 
    !local variables
    sll_int32 :: i_step
    if(self%electrostatic) then
       do i_step = 1, number_steps
          call self%helper%advect_x( dt*0.5_f64 )
          call self%helper%advect_vb( dt*0.5_f64 )
          call self%helper%advect_e( dt )
          call self%helper%advect_vb( dt*0.5_f64 )
          call self%helper%advect_x( dt*0.5_f64 )
       end do
    else
       do i_step = 1, number_steps
          call self%helper%advect_eb( dt*0.5_f64 )
          call self%helper%advect_x( dt*0.5_f64 )
          call self%helper%advect_vb( dt*0.5_f64 )
          call self%helper%advect_e( dt )
          call self%helper%advect_vb( dt*0.5_f64 )
          call self%helper%advect_x( dt*0.5_f64 )
          call self%helper%advect_eb( dt*0.5_f64 )
       end do
    end if
 
  end subroutine strang_splitting_pic_vm_3d3v
 
 
  subroutine lie_splitting_pic_vm_3d3v(self,dt, number_steps)
    class(sll_t_time_propagator_pic_vm_3d3v_disgrade), intent(inout) :: self
    sll_real64,                                     intent(in)    :: dt   
    sll_int32,                                      intent(in)    :: number_steps 
    !local variables
    sll_int32 :: i_step
 
    if(self%electrostatic) then
       do i_step = 1,number_steps
          call self%helper%advect_x( dt )
          call self%helper%advect_vb( dt )
          call self%helper%advect_e( dt )
       end do
    else
       do i_step = 1,number_steps
          call self%helper%advect_x( dt )
          call self%helper%advect_vb( dt )
          call self%helper%advect_eb( dt )
          call self%helper%advect_e( dt )
       end do
    end if
 
  end subroutine lie_splitting_pic_vm_3d3v
 
 
  subroutine lie_splitting_back_pic_vm_3d3v(self,dt, number_steps)
    class(sll_t_time_propagator_pic_vm_3d3v_disgrade), intent(inout) :: self
    sll_real64,                                     intent(in)    :: dt   
    sll_int32,                                      intent(in)    :: number_steps 
    !local variables
    sll_int32 :: i_step
 
    if(self%electrostatic) then
       do i_step = 1,number_steps
          call self%helper%advect_e( dt )
          call self%helper%advect_vb( dt )
          call self%helper%advect_x( dt )
       end do
    else
       do i_step = 1,number_steps
          call self%helper%advect_e( dt )
          call self%helper%advect_vb( dt )
          call self%helper%advect_x( dt )
          call self%helper%advect_eb( dt )
       end do
    end if
 
  end subroutine lie_splitting_back_pic_vm_3d3v
 
 
  !---------------------------------------------------------------------------!
  subroutine initialize_pic_vm_3d3v(&
       self, &
       maxwell_solver, &
       particle_mesh_coupling, &
       particle_group, &
       phi_dofs, &
       efield_dofs, &
       bfield_dofs, &
       x_min, &
       Lx, &
       filter, &
       boundary_particles, &
       solver_tolerance, &
       betar, &
       force_sign, &
       electrostatic, &
       rhob, &
       control_variate, &
       jmean) 
    class(sll_t_time_propagator_pic_vm_3d3v_disgrade), intent( out ) :: self
    class(sll_c_maxwell_3d_base), target,          intent( in ) :: maxwell_solver
    class(sll_c_particle_mesh_coupling_3d), target,   intent(in)  :: particle_mesh_coupling
    class(sll_t_particle_array), target,           intent( in ) :: particle_group
    sll_real64, target,                            intent( in ) :: phi_dofs(:) 
    sll_real64, target,                            intent( in ) :: efield_dofs(:) 
    sll_real64, target,                            intent( in ) :: bfield_dofs(:) 
    sll_real64,                                    intent( in ) :: x_min(3) 
    sll_real64,                                    intent( in ) :: lx(3) 
    class(sll_c_filter_base_3d), target :: filter
    sll_int32, optional,                           intent( in ) :: boundary_particles 
    sll_real64, optional,                          intent( in ) :: solver_tolerance 
    sll_real64, optional, intent(in) :: betar(2) 
    sll_real64, optional, intent(in) :: force_sign 
    logical, optional,                             intent( in ) :: electrostatic
    sll_real64, optional, target,                  intent( in ) :: rhob(:) 
    class(sll_t_control_variates), optional, target, intent(in) :: control_variate
    logical, optional, intent(in) :: jmean
    !local variables
    sll_real64 :: solver_tolerance_set
    sll_real64 :: betar_set(2), force_sign_set
    sll_int32 :: boundary_particles_set
    logical :: jmean_set
 
    if( present(boundary_particles) )then
       boundary_particles_set = boundary_particles
    else
       boundary_particles_set = 100
    end if
 
    if (present(solver_tolerance) )  then
       solver_tolerance_set = solver_tolerance
    else
       solver_tolerance_set = 1d-12
    end if
 
    if (present(betar) )  then
       betar_set = betar
    else
       betar_set = 1d0
    end if
 
    if( present(force_sign) )then
       force_sign_set = force_sign
    else
       force_sign_set = 1._f64
    end if
 
    if( present(electrostatic) )then
       self%electrostatic = electrostatic
    end if
 
    if (present(jmean)) then
       jmean_set = jmean
    else
       jmean_set = .false.
    end if
 
    if( present( control_variate) ) then
       call self%helper%init(maxwell_solver, &
            particle_mesh_coupling, &
            particle_group, &
            phi_dofs, &
            efield_dofs, &
            bfield_dofs, &
            x_min, &
            lx, &
            filter, &
            boundary_particles=boundary_particles_set, &
            solver_tolerance=solver_tolerance_set, &
            betar=betar_set, &
            force_sign=force_sign_set, &
            control_variate = control_variate,&
            jmean=jmean_set)
    else
       call self%helper%init(maxwell_solver, &
            particle_mesh_coupling, &
            particle_group, &
            phi_dofs, &
            efield_dofs, &
            bfield_dofs, &
            x_min, &
            lx, &
            filter, &
            boundary_particles=boundary_particles_set, &
            solver_tolerance=solver_tolerance_set, &
            betar=betar_set, &
            force_sign=force_sign_set, &
            jmean=jmean_set)
    end if
 
  end subroutine initialize_pic_vm_3d3v
 
 
  subroutine initialize_file_pic_vm_3d3v(&
       self, &
       maxwell_solver, &
       particle_mesh_coupling, &
       particle_group, &
       phi_dofs, &
       efield_dofs, &
       bfield_dofs, &
       x_min, &
       Lx, &
       filter, &
       filename, &
       boundary_particles, &
       betar, &
       force_sign, &
       electrostatic, &
       rhob, &
       control_variate,&
       jmean) 
    class(sll_t_time_propagator_pic_vm_3d3v_disgrade), intent( out ) :: self
    class(sll_c_maxwell_3d_base), target,          intent( in ) :: maxwell_solver
    class(sll_c_particle_mesh_coupling_3d), target, intent(in) :: particle_mesh_coupling
    class(sll_t_particle_array), target,           intent( in ) :: particle_group
    sll_real64, target,                            intent( in ) :: phi_dofs(:) 
    sll_real64, target,                            intent( in ) :: efield_dofs(:) 
    sll_real64, target,                            intent( in ) :: bfield_dofs(:) 
    sll_real64,                                    intent( in ) :: x_min(3) 
    sll_real64,                                    intent( in ) :: lx(3) 
    class(sll_c_filter_base_3d), target :: filter
    character(len=*),                              intent( in ) :: filename
    sll_int32, optional,                           intent( in ) :: boundary_particles 
    sll_real64, optional,                          intent( in ) :: betar(2) 
    sll_real64, optional, intent(in) :: force_sign 
    logical, optional,                             intent( in ) :: electrostatic
    sll_real64, optional, target,                  intent( in ) :: rhob(:) 
    class(sll_t_control_variates), optional, target, intent(in) :: control_variate
    logical, optional, intent(in) :: jmean
    !local variables
    sll_real64 :: betar_set(2), force_sign_set
    sll_int32 :: boundary_particles_set
    logical :: jmean_set
 
    if( present(boundary_particles) )then
       boundary_particles_set = boundary_particles
    else
       boundary_particles_set = 100
    end if
 
    if( present(force_sign) )then
       force_sign_set = force_sign
    else
       force_sign_set = 1._f64
    end if
 
    if( present(electrostatic) )then
       self%electrostatic = electrostatic
    end if
 
    if( present(betar) )then
       betar_set = betar
    else
       betar_set = 1d0
    end if
 
    if (present(jmean)) then
       jmean_set = jmean
    else
       jmean_set = .false.
    end if
 
    if( present( control_variate) ) then
       call self%helper%init_from_file(  maxwell_solver, &
            particle_mesh_coupling, &
            particle_group, &
            phi_dofs, &
            efield_dofs, &
            bfield_dofs, &
            x_min, &
            lx, &
            filename, &
            filter, &
            boundary_particles = boundary_particles_set, &
            betar=betar_set, &
            force_sign=force_sign_set, &
            rhob = rhob, &
            control_variate = control_variate, &
            jmean=jmean_set)
    else
       call self%helper%init_from_file(  maxwell_solver, &
            particle_mesh_coupling, &
            particle_group, &
            phi_dofs, &
            efield_dofs, &
            bfield_dofs, &
            x_min, &
            lx, &
            filename, &
            filter, &
            boundary_particles = boundary_particles_set, &
            betar=betar_set, &
            force_sign=force_sign_set, &
            rhob = rhob, &
            jmean=jmean_set)
    end if
 
  end subroutine initialize_file_pic_vm_3d3v
 
 
  subroutine delete_pic_vm_3d3v(self)
    class(sll_t_time_propagator_pic_vm_3d3v_disgrade), intent( inout ) :: self
    call self%helper%free()
 
  end subroutine delete_pic_vm_3d3v
 
 
end module sll_m_time_propagator_pic_vm_3d3v_disgrade