olfgwfexchangemodule Module Reference

This module contains the OlfGwfExchangeModule Module. More...

Data Types
type	olfgwfexchangetype

Functions/Subroutines
subroutine, public	olfgwf_cr (filename, name, id, m1_id, m2_id, input_mempath)
	@ brief Create OLF GWF exchange More...
subroutine	olf_gwf_df (this)
	@ brief Define OLF GWF exchange More...
subroutine	source_options (this, iout)
	@ brief Source options More...
subroutine	source_dimensions (this, iout)
	Source dimension from input context. More...
subroutine	source_data (this, iout)
	Source exchange data from input context. More...

Detailed Description

This module contains a lightweight OLF-GWF exchange class which is primarily based on the underlying and generic SWF-GWF code for connecting

Function/Subroutine Documentation

olf_gwf_df()

subroutine olfgwfexchangemodule::olf_gwf_df ( class(olfgwfexchangetype)  this )

private

Parameters

this	SwfGwfExchangeType

Definition at line 65 of file exg-olfgwf.f90.

    !  modules
    !  dummy
    class(OlfGwfExchangeType) :: this !<  SwfGwfExchangeType
    !  local
 
    !  log the exchange
    write (iout, '(/a,a)') ' Creating exchange: ', this%name
    !
    !  Ensure models are in same solution
    if (associated(this%swfmodel) .and. associated(this%gwfmodel)) then
      if (this%swfmodel%idsoln /= this%gwfmodel%idsoln) then
        call store_error('Two models are connected in a SWF-GWF '// &
                         'exchange but they are in different solutions. '// &
                         'Models must be in same solution: '// &
                         trim(this%swfmodel%name)//' '// &
                         trim(this%gwfmodel%name))
        call store_error_filename(this%filename)
      end if
    end if
 
    !  source options
    call this%source_options(iout)
 
    !  source dimensions
    call this%source_dimensions(iout)
 
    !  allocate arrays
    call this%allocate_arrays()
 
    !  source exchange data
    call this%source_data(iout)
 
    !  Store obs
    ! call this%swf_gwf_df_obs()
    ! if (associated(this%swfmodel1)) then
    !   call this%obs%obs_df(iout, this%name, 'SWF-GWF', this%swfmodel1%dis)
    ! end if
 
    ! !  validate
    ! call this%validate_exchange()
 

Here is the call graph for this function:

olfgwf_cr()

subroutine, public olfgwfexchangemodule::olfgwf_cr	(	character(len=*), intent(in)	filename,
		character(len=*)	name,
		integer(i4b), intent(in)	id,
		integer(i4b), intent(in)	m1_id,
		integer(i4b), intent(in)	m2_id,
		character(len=*), intent(in)	input_mempath
	)

High level wrapper over the SWF-GWF exchange, which is generic in that it can be used to couple either a CHF or OLF surface water model to a GWF model.

Parameters

[in]	filename	filename for reading
	name	exchange name
[in]	id	id for the exchange
[in]	m1_id	id for model 1
[in]	m2_id	id for model 2

Definition at line 40 of file exg-olfgwf.f90.

    ! modules
    ! dummy
    character(len=*), intent(in) :: filename !< filename for reading
    character(len=*) :: name !< exchange name
    integer(I4B), intent(in) :: id !< id for the exchange
    integer(I4B), intent(in) :: m1_id !< id for model 1
    integer(I4B), intent(in) :: m2_id !< id for model 2
    character(len=*), intent(in) :: input_mempath
    ! local
    type(OlfGwfExchangeType), pointer :: exchange
    class(BaseExchangeType), pointer :: baseexchange
 
    ! Create a new exchange and add it to the baseexchangelist container
    allocate (exchange)
    baseexchange => exchange
    call addbaseexchangetolist(baseexchangelist, baseexchange)
 
    call exchange%initialize(filename, name, 'OLF', id, m1_id, m2_id, &
                             input_mempath)
 

Here is the call graph for this function:

Here is the caller graph for this function:

source_data()

subroutine olfgwfexchangemodule::source_data	(	class(olfgwfexchangetype)	this,
		integer(i4b), intent(in)	iout
	)

Parameters

	this	instance of exchange object
[in]	iout	the output file unit

Definition at line 191 of file exg-olfgwf.f90.

    !  modules
    use memorymanagermodule, only: mem_setptr
    use memorymanagerextmodule, only: memorystore_release
    !  dummy
    class(OlfGwfExchangeType) :: this !< instance of exchange object
    integer(I4B), intent(in) :: iout !< the output file unit
    !  local
    integer(I4B), dimension(:, :), contiguous, pointer :: cellidm1
    integer(I4B), dimension(:, :), contiguous, pointer :: cellidm2
    real(DP), dimension(:), contiguous, pointer :: bedleak
    real(DP), dimension(:), contiguous, pointer :: cfact
    character(len=20) :: cellstr1, cellstr2
    integer(I4B) :: nerr
    integer(I4B) :: iexg, nodeswf, nodegwf
    !  format
    character(len=*), parameter :: fmtexglabel = "(1x, 3a10, 50(a16))"
    character(len=*), parameter :: fmtexgdata = &
                                   "(5x, a, 1x, a ,50(1pg16.6))"
 
    call mem_setptr(cellidm1, 'CELLIDM1', this%input_mempath)
    call mem_setptr(cellidm2, 'CELLIDM2', this%input_mempath)
    call mem_setptr(bedleak, 'BEDLEAK', this%input_mempath)
    call mem_setptr(cfact, 'CFACT', this%input_mempath)
 
    write (iout, '(1x,a)') 'PROCESSING EXCHANGEDATA'
 
    if (this%ipr_input /= 0) then
      write (iout, fmtexglabel) 'NODEM1', 'NODEM2', 'BEDLEAK', 'CFACT'
    end if
 
    do iexg = 1, this%nexg
 
      if (associated(this%model1)) then
        !  Determine user node number
        nodeswf = this%noder(this%model1, cellidm1(:, iexg), iout)
        this%nodeswf(iexg) = nodeswf
      else
        this%nodeswf(iexg) = -1
      end if
 
      if (associated(this%model2)) then
        !  Determine user node number
        nodegwf = this%noder(this%model2, cellidm2(:, iexg), iout)
        this%nodegwf(iexg) = nodegwf
      else
        this%nodegwf(iexg) = -1
      end if
 
      !  Read rest of input line
      this%bedleak(iexg) = bedleak(iexg)
      this%cfact(iexg) = cfact(iexg)
 
      !  Write the data to listing file if requested
      if (this%ipr_input /= 0) then
        cellstr1 = this%cellstr(this%model1, cellidm1(:, iexg), iout)
        cellstr2 = this%cellstr(this%model2, cellidm2(:, iexg), iout)
        write (iout, fmtexgdata) trim(cellstr1), trim(cellstr2), &
          this%bedleak(iexg), this%cfact(iexg)
      end if
 
      !  Check to see if nodeswf is outside of active domain
      if (associated(this%model1)) then
        if (nodeswf <= 0) then
          cellstr1 = this%cellstr(this%model1, cellidm1(:, iexg), iout)
          write (errmsg, *) &
            trim(adjustl(this%model1%name))// &
            ' Cell is outside active grid domain ('// &
            trim(adjustl(cellstr1))//').'
          call store_error(errmsg)
        end if
      end if
 
      !  Check to see if nodegwf is outside of active domain
      if (associated(this%model2)) then
        if (nodegwf <= 0) then
          cellstr2 = this%cellstr(this%model2, cellidm2(:, iexg), iout)
          write (errmsg, *) &
            trim(adjustl(this%model2%name))// &
            ' Cell is outside active grid domain ('// &
            trim(adjustl(cellstr2))//').'
          call store_error(errmsg)
        end if
      end if
    end do
 
    write (iout, '(1x,a)') 'END OF EXCHANGEDATA'
 
    !  Stop if errors
    nerr = count_errors()
    if (nerr > 0) then
      call store_error('Errors encountered in exchange input file.')
      call store_error_filename(this%filename)
    end if
 
    call memorystore_release('CELLIDM1', this%input_mempath)
    call memorystore_release('CELLIDM2', this%input_mempath)
    call memorystore_release('BEDLEAK', this%input_mempath)
    call memorystore_release('CFACT', this%input_mempath)
 

Here is the call graph for this function:

source_dimensions()

subroutine olfgwfexchangemodule::source_dimensions	(	class(olfgwfexchangetype)	this,
		integer(i4b), intent(in)	iout
	)

Parameters

	this	instance of exchange object
[in]	iout	for logging

Definition at line 166 of file exg-olfgwf.f90.

    !  modules
    use memorymanagerextmodule, only: mem_set_value
    use exgolfgwfinputmodule, only: exgolfgwfparamfoundtype
    !  dummy
    class(OlfGwfExchangeType) :: this !< instance of exchange object
    integer(I4B), intent(in) :: iout !< for logging
    !  local
    type(ExgOlfgwfParamFoundType) :: found
 
    !  update defaults with idm sourced values
    call mem_set_value(this%nexg, 'NEXG', this%input_mempath, found%nexg)
 
    write (iout, '(1x,a)') 'PROCESSING EXCHANGE DIMENSIONS'
 
    if (found%nexg) then
      write (iout, '(4x,a,i0)') 'NEXG = ', this%nexg
    end if
 
    write (iout, '(1x,a)') 'END OF EXCHANGE DIMENSIONS'
 

source_options()

subroutine olfgwfexchangemodule::source_options ( class(olfgwfexchangetype)  this, integer(i4b), intent(in)  iout  )

private

Parameters

this	GwfExchangeType

Definition at line 111 of file exg-olfgwf.f90.

    !  modules
    use constantsmodule, only: lenvarname, dem6
    use inputoutputmodule, only: getunit, openfile
    use memorymanagerextmodule, only: mem_set_value
    use characterstringmodule, only: characterstringtype
    use exgolfgwfinputmodule, only: exgolfgwfparamfoundtype
    use sourcecommonmodule, only: filein_fname
    !  dummy
    class(OlfGwfExchangeType) :: this !<  GwfExchangeType
    integer(I4B), intent(in) :: iout
    !  local
    type(ExgOlfgwfParamFoundType) :: found
 
    !  update defaults with idm sourced values
    call mem_set_value(this%ipr_input, 'IPR_INPUT', &
                       this%input_mempath, found%ipr_input)
    call mem_set_value(this%ipr_flow, 'IPR_FLOW', &
                       this%input_mempath, found%ipr_flow)
    call mem_set_value(this%ifixedcond, 'IFIXEDCOND', &
                       this%input_mempath, found%ifixedcond)
 
    write (iout, '(1x,a)') 'Processing OLF-GWF exchange options'
 
    if (found%ipr_input) then
      write (iout, '(4x,a)') &
        'The list of exchanges will be printed.'
    end if
 
    if (found%ipr_flow) then
      write (iout, '(4x,a)') &
        'Exchange flows will be printed to list files.'
    end if
 
    if (found%ifixedcond) then
      write (iout, '(4x,a)') &
        'Conductance is fixed as product of BEDLEAK and CFACT.'
    end if
 
    !  enforce 0 or 1 OBS6_FILENAME entries in option block
    ! if (.not. this%is_datacopy) then
    !   if (filein_fname(this%obs%inputFilename, 'OBS6_FILENAME', &
    !                    this%input_mempath, this%filename)) then
    !     this%obs%active = .true.
    !     this%obs%inUnitObs = GetUnit()
    !     call openfile(this%obs%inUnitObs, iout, this%obs%inputFilename, 'OBS')
    !   end if
    ! end if
 
    write (iout, '(1x,a)') 'End of OLF-GWF exchange options'
 

Here is the call graph for this function: