NumericalExchange.f90

Go to the documentation of this file.

module numericalexchangemodule
 
  use kindmodule, only: dp, i4b
  use basemodelmodule, only: basemodeltype
  use baseexchangemodule, only: baseexchangetype, addbaseexchangetolist
  use numericalmodelmodule, only: numericalmodeltype
  use listmodule, only: listtype
  use matrixbasemodule
 
  implicit none
 
  private
  public :: numericalexchangetype, &
            addnumericalexchangetolist, getnumericalexchangefromlist
 
  type, extends(baseexchangetype) :: numericalexchangetype
  contains
 
    procedure :: exg_df
    procedure :: exg_ac
    procedure :: exg_mc
    procedure :: exg_ar
    !procedure :: exg_rp (not needed yet; base exg_rp does nothing)
    procedure :: exg_cf
    procedure :: exg_fc
    procedure :: exg_cc
    procedure :: exg_cq
    procedure :: exg_bd
    procedure :: exg_ot
    procedure :: exg_da
    procedure :: get_iasym
  end type numericalexchangetype
 
contains
 
  !> @brief Define the exchange
  subroutine exg_df(this)
    class(numericalexchangetype) :: this
  end subroutine exg_df
 
  !> @brief If an implicit exchange then add connections to sparse
  subroutine exg_ac(this, sparse)
    use sparsemodule, only: sparsematrix
    class(numericalexchangetype) :: this
    type(sparsematrix), intent(inout) :: sparse
  end subroutine exg_ac
 
  !> @brief Map the connections in the global matrix
  subroutine exg_mc(this, matrix_sln)
    class(numericalexchangetype) :: this
    class(matrixbasetype), pointer :: matrix_sln
  end subroutine exg_mc
 
  !> @brief Allocate and read
  subroutine exg_ar(this)
    class(numericalexchangetype) :: this
  end subroutine exg_ar
 
  !> @brief Calculate conductance, and for explicit exchanges, set the
  !! conductance in the boundary package
  subroutine exg_cf(this, kiter)
    class(numericalexchangetype) :: this
    integer(I4B), intent(in) :: kiter
  end subroutine exg_cf
 
  !> @brief Fill the matrix
  subroutine exg_fc(this, kiter, matrix_sln, rhs_sln, inwtflag)
    class(numericalexchangetype) :: this
    integer(I4B), intent(in) :: kiter
    class(matrixbasetype), pointer :: matrix_sln
    real(DP), dimension(:), intent(inout) :: rhs_sln
    integer(I4B), optional, intent(in) :: inwtflag
  end subroutine exg_fc
 
  !> @brief Additional convergence check
  subroutine exg_cc(this, icnvg)
    class(numericalexchangetype) :: this
    integer(I4B), intent(inout) :: icnvg
  end subroutine exg_cc
 
  !> @brief Calculate flow
  subroutine exg_cq(this, icnvg, isuppress_output, isolnid)
    class(numericalexchangetype) :: this
    integer(I4B), intent(inout) :: icnvg
    integer(I4B), intent(in) :: isuppress_output
    integer(I4B), intent(in) :: isolnid
  end subroutine exg_cq
 
  !> @brief Exchange budget
  subroutine exg_bd(this, icnvg, isuppress_output, isolnid)
    class(numericalexchangetype) :: this
    integer(I4B), intent(inout) :: icnvg
    integer(I4B), intent(in) :: isuppress_output
    integer(I4B), intent(in) :: isolnid
  end subroutine exg_bd
 
  !> @brief Output
  subroutine exg_ot(this)
    class(numericalexchangetype) :: this
  end subroutine exg_ot
 
  !> @brief Deallocate memory
  subroutine exg_da(this)
    class(numericalexchangetype) :: this
  end subroutine exg_da
 
  function get_iasym(this) result(iasym)
    class(numericalexchangetype) :: this
    integer(I4B) :: iasym
    iasym = 0
  end function get_iasym
 
  function castasnumericalexchangeclass(obj) result(res)
    implicit none
    class(*), pointer, intent(inout) :: obj
    class(numericalexchangetype), pointer :: res
 
    res => null()
    if (.not. associated(obj)) return
 
    select type (obj)
    class is (numericalexchangetype)
      res => obj
    end select
  end function castasnumericalexchangeclass
 
  !> @brief Add numerical exchange to a list
  subroutine addnumericalexchangetolist(list, exchange)
    implicit none
    type(listtype), intent(inout) :: list
    class(numericalexchangetype), pointer, intent(in) :: exchange
    class(*), pointer :: obj
 
    obj => exchange
    call list%Add(obj)
  end subroutine addnumericalexchangetolist
 
  !> @brief Retrieve a specific numerical exchange from a list
  function getnumericalexchangefromlist(list, idx) result(res)
    implicit none
    type(listtype), intent(inout) :: list
    integer(I4B), intent(in) :: idx
    class(numericalexchangetype), pointer :: res
    class(*), pointer :: obj
 
    obj => list%GetItem(idx)
    res => castasnumericalexchangeclass(obj)
  end function getnumericalexchangefromlist
 
end module numericalexchangemodule