GwfInterfaceModel.f90

Go to the documentation of this file.

module gwfinterfacemodelmodule
  use kindmodule, only: i4b, dp
  use constantsmodule, only: dzero
  use memorymanagermodule, only: mem_allocate
  use memoryhelpermodule, only: create_mem_path
  use numericalmodelmodule, only: numericalmodeltype
  use gwfmodule, only: gwfmodeltype, castasgwfmodel
  use xt3dmodule, only: xt3d_cr
  use gwfbuymodule, only: buy_cr
  use gridconnectionmodule
  use basedismodule
  use disumodule
  use gwfnpfmodule
  use gwfnpfoptionsmodule
  use gwfbuyinputdatamodule
  use gwfocmodule
  implicit none
  private
 
  !> The GWF Interface Model is a utility to calculate the solution's
  !! exchange coefficients from the interface between a GWF model and
  !! its GWF neighbors. The interface model itself will not be part
  !! of the solution, it is not being solved.
  !! Patching (a part of the) discretizations of two GWF models in a
  !! general way, e.g. DIS+DIS with refinement, requires the resulting
  !< discretization to be of type DISU.
  type, public, extends(gwfmodeltype) :: gwfinterfacemodeltype
    class(gridconnectiontype), pointer :: gridconnection => null() !< The grid connection class will provide the interface grid
    class(gwfmodeltype), private, pointer :: owner => null() !< the real GWF model for which the exchange coefficients
                                                             !! are calculated with this interface model
  contains
    procedure, pass(this) :: gwfifm_cr
    procedure :: model_df => gwfifm_df
    procedure :: model_ar => gwfifm_ar
    procedure :: model_da => gwfifm_da
 
    ! private
    procedure, private, pass(this) :: setnpfoptions
    procedure, private, pass(this) :: setbuydata
  end type
 
contains
 
  !> @brief set up the interface model, analogously to what
  !< happens in gwf_cr
  subroutine gwfifm_cr(this, name, iout, gridConn)
    class(gwfinterfacemodeltype) :: this !< the GWF interface model
    character(len=*), intent(in) :: name !< the interface model's name
    integer(I4B), intent(in) :: iout !< the output unit
    class(gridconnectiontype), pointer, intent(in) :: gridConn !< the grid connection for creating a DISU
    ! local
    class(*), pointer :: modPtr
 
    this%memoryPath = create_mem_path(name)
    call this%allocate_scalars(name)
 
    this%iout = iout
 
    this%gridConnection => gridconn
    modptr => this%gridConnection%model
    this%owner => castasgwfmodel(modptr)
 
    this%innpf = huge(1_i4b)
    this%inewton = this%owner%inewton
    this%inewtonur = this%owner%inewtonur
 
    if (this%owner%inbuy > 0) then
      this%inbuy = huge(1_i4b)
    end if
 
    ! create discretization and packages
    call disu_cr(this%dis, this%name, '', -1, this%iout)
    call npf_cr(this%npf, this%name, '', -this%innpf, this%iout)
    call xt3d_cr(this%xt3d, this%name, -this%innpf, this%iout)
    call buy_cr(this%buy, this%name, this%inbuy, this%iout)
 
  end subroutine gwfifm_cr
 
  !> @brief Define, mostly DISU and the NPF package
  !< for this interface model
  subroutine gwfifm_df(this)
    class(gwfinterfacemodeltype) :: this !< the GWF interface model
    ! local
    type(gwfnpfoptionstype) :: npfOptions
    type(gwfbuyinputdatatype) :: buyData
    class(*), pointer :: disPtr
 
    this%moffset = 0
 
    ! define DISU
    disptr => this%dis
    call this%gridConnection%getDiscretization(castasdisutype(disptr))
 
    ! define NPF package
    call npfoptions%construct()
    call this%setNpfOptions(npfoptions)
    call this%npf%npf_df(this%dis, this%xt3d, 0, 0, npfoptions)
    call npfoptions%destroy()
 
    ! define BUY package
    if (this%inbuy > 0) then
      call buydata%construct(this%owner%buy%nrhospecies)
      call this%setBuyData(buydata)
      call this%buy%buy_df(this%dis, buydata)
      call buydata%destruct()
    end if
 
    this%neq = this%dis%nodes
    this%nja = this%dis%nja
    this%ia => this%dis%con%ia
    this%ja => this%dis%con%ja
 
    call this%allocate_arrays()
 
  end subroutine gwfifm_df
 
  !> @brief allocate and read the packages
  !<
  subroutine gwfifm_ar(this)
    class(gwfinterfacemodeltype) :: this !< the GWF interface model
 
    call this%npf%npf_ar(this%ic, this%vsc, this%ibound, this%x)
    if (this%inbuy > 0) call this%buy%buy_ar(this%npf, this%ibound)
 
  end subroutine gwfifm_ar
 
  !> @brief Clean up
  !<
  subroutine gwfifm_da(this)
    use memorymanagermodule, only: mem_deallocate
    class(gwfinterfacemodeltype) :: this !< the GWF interface model
 
    ! -- Internal flow packages deallocate
    call this%dis%dis_da()
    call this%npf%npf_da()
    call this%xt3d%xt3d_da()
    call this%buy%buy_da()
    !
    ! -- Internal package objects
    deallocate (this%dis)
    deallocate (this%npf)
    deallocate (this%xt3d)
    !
    ! -- Scalars
    call mem_deallocate(this%inic)
    call mem_deallocate(this%inoc)
    call mem_deallocate(this%inobs)
    call mem_deallocate(this%innpf)
    call mem_deallocate(this%inbuy)
    call mem_deallocate(this%invsc)
    call mem_deallocate(this%insto)
    call mem_deallocate(this%incsub)
    call mem_deallocate(this%inmvr)
    call mem_deallocate(this%inhfb)
    call mem_deallocate(this%ingnc)
    call mem_deallocate(this%iss)
    call mem_deallocate(this%inewtonur)
    !
    ! -- NumericalModelType
    call this%NumericalModelType%model_da()
 
  end subroutine
 
  !> @brief Copy NPF options from the model owning
  !! the interface to the data structure
  !<
  subroutine setnpfoptions(this, npfOptions)
    class(gwfinterfacemodeltype) :: this !< the GWF interface model
    type(gwfnpfoptionstype) :: npfOptions !< the options data to be filled
 
    ! for now, assuming full homogeneity, so just take
    ! the options from the owning model's npf package
    npfoptions%icellavg = this%owner%npf%icellavg
    npfoptions%ithickstrt = this%owner%npf%ithickstrt
    npfoptions%iperched = this%owner%npf%iperched
    npfoptions%ivarcv = this%owner%npf%ivarcv
    npfoptions%idewatcv = this%owner%npf%idewatcv
    npfoptions%irewet = this%owner%npf%irewet
    npfoptions%wetfct = this%owner%npf%wetfct
    npfoptions%iwetit = this%owner%npf%iwetit
    npfoptions%ihdwet = this%owner%npf%ihdwet
 
  end subroutine setnpfoptions
 
  !> @brief Sets the BUY input data from the models that
  !! make up this interface. We adopt everything from the
  !! owning model, but during validation it should be
  !< checked that the models are compatible.
  subroutine setbuydata(this, buyData)
    class(gwfinterfacemodeltype) :: this !< the interface model
    type(gwfbuyinputdatatype) :: buyData !< the data for the buoyancy package
    ! local
    integer(I4B) :: i
 
    buydata%denseref = this%owner%buy%denseref
    buydata%iform = this%owner%buy%iform
    buydata%nrhospecies = this%owner%buy%nrhospecies
 
    do i = 1, buydata%nrhospecies
      buydata%drhodc(i) = this%owner%buy%drhodc(i)
      buydata%crhoref(i) = this%owner%buy%crhoref(i)
      buydata%cmodelname(i) = this%owner%buy%cmodelname(i)
      buydata%cauxspeciesname(i) = this%owner%buy%cauxspeciesname(i)
    end do
 
  end subroutine setbuydata
 
end module gwfinterfacemodelmodule