sll_m_ode_integrator_base.F90

Go to the documentation of this file.

!------------------------------------------------------------------------------
! SELALIB
!------------------------------------------------------------------------------
! MODULE:   sll_m_ode_integrator_base
!
! DESCRIPTION:
!------------------------------------------------------------------------------
module sll_m_ode_integrator_base
!+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
   use sll_m_working_precision, only: &
      f64
 
   use sll_m_vector_space_base, only: &
      sll_c_vector_space
 
   implicit none
 
   public :: &
      sll_c_ode, &
      sll_c_ode_integrator
 
   private
!+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
   integer, parameter :: wp = f64
 
   !----------------------------------------------------------------------------
   ! Abstract type: sll_c_ode
   !----------------------------------------------------------------------------
   type, abstract :: sll_c_ode
   contains
      procedure(i_rhs), deferred :: rhs
!    procedure                    :: solve !< solve an implicit problem
   end type sll_c_ode
 
   !----------------------------------------------------------------------------
   ! Abstract type: sll_c_ode_integrator
   !----------------------------------------------------------------------------
   type, abstract :: sll_c_ode_integrator
 
      class(sll_c_ode), pointer :: ode => null()
 
      class(sll_c_vector_space), allocatable :: work(:)
 
   contains
      procedure(i_init), deferred :: init
      procedure(i_step), deferred :: step
      procedure(i_clean), deferred :: clean
 
   end type sll_c_ode_integrator
 
   !----------------------------------------------------------------------------
   ! Abstract interface: i_rhs
   !----------------------------------------------------------------------------
   abstract interface
      subroutine i_rhs(self, t, y, ydot)
         import sll_c_ode, sll_c_vector_space, wp
         class(sll_c_ode), intent(inout) :: self
         real(wp), intent(in) :: t
         class(sll_c_vector_space), intent(in) :: y
         class(sll_c_vector_space), intent(inout) :: ydot
      end subroutine i_rhs
   end interface
 
   !----------------------------------------------------------------------------
   ! Abstract interface: i_init
   !----------------------------------------------------------------------------
   abstract interface
      subroutine i_init(self, ode, t0, y0)
         import sll_c_ode_integrator, sll_c_ode, sll_c_vector_space, wp
         class(sll_c_ode_integrator), intent(out) :: self
         class(sll_c_ode), pointer, intent(in) :: ode
         real(wp), intent(in) :: t0
         class(sll_c_vector_space), intent(inout) :: y0
      end subroutine i_init
   end interface
 
   !----------------------------------------------------------------------------
   ! Abstract interface: i_step
   !----------------------------------------------------------------------------
   abstract interface
      subroutine i_step(self, t, y, h, ynew)
         import sll_c_ode_integrator, sll_c_ode, sll_c_vector_space, wp
         class(sll_c_ode_integrator), intent(inout) :: self
         real(wp), intent(in) :: t
         class(sll_c_vector_space), intent(in) :: y
         real(wp), intent(in) :: h
         class(sll_c_vector_space), intent(inout) :: ynew
      end subroutine i_step
   end interface
 
   !----------------------------------------------------------------------------
   ! Abstract interface: i_clean
   !----------------------------------------------------------------------------
   abstract interface
      subroutine i_clean(self)
         import sll_c_ode_integrator
         class(sll_c_ode_integrator), intent(inout) :: self
      end subroutine i_clean
   end interface
 
!==============================================================================
!contains
!==============================================================================
 
!  subroutine solve( self, t, y, ynew, b, sigma )
!    class( sll_c_ode ), intent( inout ) :: self
!    real(wp)          , intent( in    ) :: t
!  end subroutine solve
 
end module sll_m_ode_integrator_base