sll_m_maxwell_1d_base.F90

Go to the documentation of this file.

 
module sll_m_maxwell_1d_base
  !+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include "sll_working_precision.h"
 
  use sll_m_utilities, only: &
       sll_s_int2string
 
  implicit none
 
  public :: &
       sll_i_function_1d_real64, &
       sll_c_maxwell_1d_base, &
       sll_s_plot_two_fields_1d
 
  private
  !+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
  type, abstract :: sll_c_maxwell_1d_base
     sll_real64 :: lx          
     sll_int32  :: n_cells     
     sll_int32  :: n_dofs0      
     sll_int32  :: n_dofs1     
     sll_real64 :: delta_x     
     sll_int32  :: s_deg_0     
     sll_int32  :: s_deg_1     
     sll_real64 :: mass_solver_tolerance = 1d-12 
     sll_real64 :: poisson_solver_tolerance = 1d-12 
     logical :: strong_ampere = .false. 
 
     sll_real64 :: solver_tolerance = 1d-12 
 
   contains
     procedure(compute_field1_from_field2), deferred :: &
          compute_e_from_b
     procedure(compute_field1_from_field2), deferred :: &
          compute_b_from_e
     procedure(signature_compute_field_from_field), deferred :: &
          compute_e_from_rho
     procedure(signature_compute_field_from_field), deferred :: &
          compute_rho_from_e
     procedure(signature_compute_e_from_j_1d), deferred :: &
          compute_e_from_j
     procedure(signature_compute_phi_from_field), deferred :: &
           compute_phi_from_rho
       procedure(signature_compute_phi_from_field), deferred :: &
          compute_phi_from_j
     !procedure(signature_solve), deferred :: &
     !     solve !< Solve Amperes law and Faraday equation
     procedure(update_dofs_function), deferred :: &
          compute_rhs_from_function
     procedure(update_dofs_function), deferred :: &
          l2projection
     procedure(norm_squared), deferred :: &
          l2norm_squared
     procedure(signature_inner_product), deferred :: &
          inner_product
     procedure(empty), deferred :: &
          free
     procedure(signature_mass), deferred :: &
          multiply_mass
     procedure(signature_mass), deferred :: &
          invert_mass
     procedure(multiply_derivative), deferred :: &
          multiply_g
     procedure(multiply_derivative), deferred :: &
          multiply_gt
     procedure :: compute_curl_part
 
     procedure :: transform_dofs
 
  end type sll_c_maxwell_1d_base
 
  !---------------------------------------------------------------------------!
  abstract interface
     subroutine empty(self) 
       import sll_c_maxwell_1d_base
       class( sll_c_maxwell_1d_base)                    :: self
 
     end subroutine empty
  end interface
 
  !---------------------------------------------------------------------------!
  abstract interface
     function norm_squared(self, coefs_dofs, degree) result( r )
       use sll_m_working_precision
       import sll_c_maxwell_1d_base
       class( sll_c_maxwell_1d_base)                    :: self
       sll_real64                                     :: coefs_dofs(:) 
       sll_int32                                      :: degree 
       sll_real64                                     :: r
     end function norm_squared
  end interface
 
 
  !---------------------------------------------------------------------------!
  abstract interface
     subroutine signature_mass(self, in, out, degree)
       use sll_m_working_precision
       import sll_c_maxwell_1d_base
       class( sll_c_maxwell_1d_base), intent(inout)   :: self
       sll_real64, intent(in)                         :: in(:) 
       sll_real64, intent(out)                        :: out(:) 
       sll_int32, intent(in)                          :: degree 
     end subroutine signature_mass
  end interface
 
 
 
 
  !---------------------------------------------------------------------------!
  abstract interface
     function signature_inner_product(self, coefs1_dofs, coefs2_dofs, degree, degree2) result( r )
       use sll_m_working_precision
       import sll_c_maxwell_1d_base
       class( sll_c_maxwell_1d_base)                    :: self
       sll_real64                                     :: coefs1_dofs(:) 
       sll_real64                                     :: coefs2_dofs(:) 
       sll_int32                                      :: degree 
       sll_int32, optional                            :: degree2 
       sll_real64                                     :: r
     end function signature_inner_product
  end interface
 
  !---------------------------------------------------------------------------!
  abstract interface
 
     function sll_i_function_1d_real64(x)
       use sll_m_working_precision ! can't pass a header file because the
       ! preprocessor prevents double inclusion.
       ! It is very rare.
       sll_real64             :: sll_i_function_1d_real64
       sll_real64, intent(in) :: x
     end function sll_i_function_1d_real64
  end interface
  !---------------------------------------------------------------------------!
  abstract interface
     subroutine update_dofs_function(self, func, degree, coefs_dofs)
       use sll_m_working_precision
       import sll_c_maxwell_1d_base
       import sll_i_function_1d_real64
       class( sll_c_maxwell_1d_base)    :: self
       procedure(sll_i_function_1d_real64)  :: func
       sll_int32, intent(in)          :: degree 
       sll_real64, intent(out)        :: coefs_dofs(:) 
     end subroutine update_dofs_function
  end interface
 
  !---------------------------------------------------------------------------!
  abstract interface 
     subroutine compute_field1_from_field2(self, delta_t, field_in, field_out)
       use sll_m_working_precision
       import sll_c_maxwell_1d_base     
       class(sll_c_maxwell_1d_base) :: self
       sll_real64, intent(in)     :: delta_t
       sll_real64, intent(in)     :: field_in(:)
       sll_real64, intent(inout)  :: field_out(:)
     end subroutine compute_field1_from_field2
  end interface
 
  !---------------------------------------------------------------------------!
  abstract interface 
     subroutine signature_compute_field_from_field(self, field_in, field_out)
       use sll_m_working_precision
       import sll_c_maxwell_1d_base     
       class(sll_c_maxwell_1d_base) :: self
       sll_real64, intent(in)     :: field_in(:)
       sll_real64, intent(out)  :: field_out(:)
     end subroutine signature_compute_field_from_field
  end interface
 
  !---------------------------------------------------------------------------!  
  abstract interface
     subroutine signature_compute_e_from_j_1d(self, current, component, E)
       use sll_m_working_precision
       import sll_c_maxwell_1d_base
       class(sll_c_maxwell_1d_base)             :: self
       sll_real64,dimension(:),intent(in)    :: current
       sll_int32, intent(in)                 :: component
       sll_real64,dimension(:),intent(inout) :: e
     end subroutine signature_compute_e_from_j_1d
  end interface
 
  !---------------------------------------------------------------------------!
  abstract interface 
     subroutine signature_compute_phi_from_field(self, in, phi, efield)
     use sll_m_working_precision
     import sll_c_maxwell_1d_base     
     class(sll_c_maxwell_1d_base) :: self
     sll_real64, intent(in)   :: in(:)
     sll_real64, intent(out)  :: phi(:)
     sll_real64, intent(out)  :: efield(:)
   end subroutine signature_compute_phi_from_field
  end interface
 
  !---------------------------------------------------------------------------!
  abstract interface 
     subroutine multiply_derivative(self, in, out)
       use sll_m_working_precision
       import sll_c_maxwell_1d_base     
       class(sll_c_maxwell_1d_base), intent(in) :: self
       sll_real64, intent(in)   :: in(:)
       sll_real64, intent(out)  :: out(:)
     end subroutine multiply_derivative
  end interface
 
 
contains
  subroutine sll_s_plot_two_fields_1d(fname, n1, f1, f2, iplot, time )
    character(len=*),             intent(in) :: fname
    sll_int32,                    intent(in) :: n1    
    sll_real64, dimension(n1),    intent(in) :: f1    
    sll_real64, dimension(n1),    intent(in) :: f2    
    sll_int32,                    intent(in) :: iplot 
    sll_real64,                   intent(in) :: time  
 
    integer          :: i
    character(len=4) :: cplot
 
    call sll_s_int2string(iplot, cplot)
 
    !write domains
    open( 80, file = fname//cplot//".dat" )
    do i=1,n1
       write(80,*) i, sngl(f1(i)), sngl(f2(i))
    end do
    close(80)
 
!!$    open( 90, file = fname//'plots.gnu', position="append" )
!!$    if ( iplot == 1 ) then
!!$       rewind(90)
!!$       !write(90,*)"set xr[-0.1:1.1]"
!!$       !write(90,*)"set yr[-0.1:1.1]"
!!$       !write(90,*)"set zr[-1.1:1.1]"
!!$       !write(90,*)"set cbrange[-1:1]"
!!$       !write(90,*)"set pm3d"
!!$       !write(90,*)"set surf"
!!$       write(90,*)"set term x11"
!!$    end if
!!$    write(90,*)"set title 'Time = ",time,"'"
!!$    write(90,"(a)",advance='no')"plot '"//fname//cplot//".dat' w lines"
!!$    write(90,"(a)")",'"//fname//cplot//".dat' u 1:3 w lines"
!!$    write(90,*)"pause -1"
!!$    close(90)
 
  end subroutine sll_s_plot_two_fields_1d
 
  subroutine transform_dofs(self, in, out, degree)
     class(sll_c_maxwell_1d_base), intent(inout) :: self
     sll_int32, intent(in) :: degree 
     sll_real64, intent(in) :: in(:)  
     sll_real64, intent(out) :: out(:)  
     ! local variables
 
     out = in
     
   end subroutine transform_dofs
 
   subroutine compute_curl_part( self, delta_t, efield, bfield, betar )
     class(sll_c_maxwell_1d_base) :: self
     sll_real64, intent(in)     :: delta_t   
     sll_real64, intent(inout)  :: efield(:)  
     sll_real64, intent(inout)  :: bfield(:)  
     sll_real64, optional       :: betar      
     !local variables
     sll_real64 :: factor
     
     if( present(betar) ) then
        factor = betar
     else
        factor = 1._f64
     end if
 
     
     call self%compute_B_from_E( &
          delta_t, efield, bfield )
    
     call self%compute_E_from_B(&
          delta_t, bfield*factor , efield )
     
   end subroutine compute_curl_part
 
end module sll_m_maxwell_1d_base