loadcontextmodule Module Reference

This module contains the LoadContextModule. More...

Data Types
type	readstatevartype
	Pointer type for read state variable. More...
interface	setptr
type	loadcontexttype
	derived type for boundary package input context More...

Enumerations
enum	{ load_undef = 0 , list = 1 , layerarray = 2 , gridarray = 3 }
enum	{   context_undef = 0 , root = 1 , sim = 2 , model = 3 ,   modelpkg = 4 , stresspkg = 5 , exchange = 6 }

Functions/Subroutines
subroutine	init (this, mf6_input, blockname, named_bound)
	init loader context object More...
subroutine	allocate_scalars (this)
	allocate scalars More...
subroutine	allocate_arrays (this)
	allocate arrays More...
subroutine	allocate_param (this, idt)
	allocate a package dynamic input parameter More...
subroutine	tags (this, params, nparam, input_name, create)
	get in scope package params More...
logical(lgp) function	in_scope (this, mf6_input, blockname, tagname)
	establish if input parameter is in scope for package load More...
subroutine	set_params (this)
	set set of in scope parameters for package More...
character(len=lenvarname) function	rsv_alloc (this, mf6varname)
	allocate a read state variable More...
subroutine	destroy (this)
	destroy input context object More...
character(len=lenvarname) function, public	rsv_name (mf6varname)
	create read state variable name More...
subroutine	allocate_charstr1d (strlen, nrow, varname, mempath)
	allocate character string type array More...
subroutine	allocate_int1d (nrow, varname, mempath)
	allocate int1d More...
subroutine	allocate_int2d (ncol, nrow, varname, mempath)
	allocate int2d More...
subroutine	allocate_dbl1d (nrow, varname, mempath)
	allocate dbl1d More...
subroutine	allocate_dbl2d (ncol, nrow, varname, mempath)
	allocate dbl2d More...
subroutine	setval (intptr, varname, mempath)
	allocate intptr and update from input contextset intptr to varname More...
subroutine	setptr_int (intptr, varname, mempath)
	set intptr to varname More...
subroutine	setptr_charstr1d (charstr1d, varname, mempath, strlen)
	set charstr1d pointer to varname More...
subroutine	setptr_auxvar (auxvar, mempath)
	set auxvar pointer More...

Detailed Description

This module creates a load context for IDM generic loaders (ListLoadType, LayerArrayLoadType, GridArrayLoadType) that supports consistent package side access. It also determines in scope parameters for the generic dynamic loaders and all structarray based static loads.

Enumeration Type Documentation

anonymous enum

anonymous enum

private

Enumerator
load_undef	undefined load type
list	list (structarray) based load
layerarray	readasarrays load
gridarray	readarraygrid load

Definition at line 27 of file LoadContext.f90.

anonymous enum

anonymous enum

private

Enumerator
context_undef	undefined context type
root	root context type
sim	sim context type
model	model context type
modelpkg	model package context type
stresspkg	model stress package context type
exchange	exchange context type

Definition at line 34 of file LoadContext.f90.

Function/Subroutine Documentation

allocate_arrays()

subroutine loadcontextmodule::allocate_arrays

(

class(loadcontexttype)

this

)

call this routine after input parameters have been allocated, e.g. after load_params() with create has been called for array based loaders or after all mem_create_vector() calls have been made for list based load.

Definition at line 238 of file LoadContext.f90.

    use memorymanagermodule, only: mem_allocate, mem_setptr, get_isize
    class(LoadContextType) :: this
    integer(I4B), dimension(:, :), pointer, contiguous :: cellid
    integer(I4B), dimension(:), pointer, contiguous :: nodeulist
 
    if (this%ctxtype == stresspkg .and. &
        this%blockname == 'PERIOD') then
      ! allocate cellid if this is not list input
      if (this%readarray) then
        call mem_allocate(cellid, 0, 0, 'CELLID', this%mf6_input%mempath)
      end if
 
      ! allocate nodeulist
      if (this%loadtype /= gridarray) then
        call mem_allocate(nodeulist, 0, 'NODEULIST', this%mf6_input%mempath)
      end if
 
      ! set pointers to arrays
      call setptr(this%auxname_cst, 'AUXILIARY', &
                  this%mf6_input%mempath, lenauxname)
      call setptr(this%boundname_cst, 'BOUNDNAME', &
                  this%mf6_input%mempath, lenboundname)
      call setptr(this%auxvar, this%mf6_input%mempath)
 
    else if (this%ctxtype == exchange) then
      ! set pointers to arrays
      call setptr(this%auxname_cst, 'AUXILIARY', &
                  this%mf6_input%mempath, lenauxname)
      call setptr(this%boundname_cst, 'BOUNDNAME', &
                  this%mf6_input%mempath, lenboundname)
      call setptr(this%auxvar, this%mf6_input%mempath)
    end if

Here is the call graph for this function:

allocate_charstr1d()

subroutine loadcontextmodule::allocate_charstr1d	(	integer(i4b), intent(in)	strlen,
		integer(i4b), intent(in)	nrow,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	mempath
	)

Parameters

[in]	strlen	string number of characters
[in]	nrow	integer array number of rows
[in]	varname	variable name
[in]	mempath	variable mempath

Definition at line 608 of file LoadContext.f90.

    use memorymanagermodule, only: mem_allocate
    integer(I4B), intent(in) :: strlen !< string number of characters
    integer(I4B), intent(in) :: nrow !< integer array number of rows
    character(len=*), intent(in) :: varname !< variable name
    character(len=*), intent(in) :: mempath !< variable mempath
    type(CharacterStringType), dimension(:), pointer, &
      contiguous :: charstr1d
    integer(I4B) :: n
    call mem_allocate(charstr1d, strlen, nrow, varname, mempath)
    do n = 1, nrow
      charstr1d(n) = ''
    end do

Here is the caller graph for this function:

allocate_dbl1d()

subroutine loadcontextmodule::allocate_dbl1d	(	integer(i4b), intent(in)	nrow,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	mempath
	)

Parameters

[in]	nrow	integer array number of rows
[in]	varname	variable name
[in]	mempath	variable mempath

Definition at line 658 of file LoadContext.f90.

    use memorymanagermodule, only: mem_allocate
    integer(I4B), intent(in) :: nrow !< integer array number of rows
    character(len=*), intent(in) :: varname !< variable name
    character(len=*), intent(in) :: mempath !< variable mempath
    real(DP), dimension(:), pointer, contiguous :: dbl1d
    integer(I4B) :: n
    call mem_allocate(dbl1d, nrow, varname, mempath)
    do n = 1, nrow
      dbl1d(n) = dzero
    end do

Here is the caller graph for this function:

allocate_dbl2d()

subroutine loadcontextmodule::allocate_dbl2d	(	integer(i4b), intent(in)	ncol,
		integer(i4b), intent(in)	nrow,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	mempath
	)

Parameters

[in]	ncol	integer array number of cols
[in]	nrow	integer array number of rows
[in]	varname	variable name
[in]	mempath	variable mempath

Definition at line 673 of file LoadContext.f90.

    use memorymanagermodule, only: mem_allocate
    integer(I4B), intent(in) :: ncol !< integer array number of cols
    integer(I4B), intent(in) :: nrow !< integer array number of rows
    character(len=*), intent(in) :: varname !< variable name
    character(len=*), intent(in) :: mempath !< variable mempath
    real(DP), dimension(:, :), pointer, contiguous :: dbl2d
    integer(I4B) :: n, m
    call mem_allocate(dbl2d, ncol, nrow, varname, mempath)
    do m = 1, nrow
      do n = 1, ncol
        dbl2d(n, m) = dzero
      end do
    end do

Here is the caller graph for this function:

allocate_int1d()

subroutine loadcontextmodule::allocate_int1d	(	integer(i4b), intent(in)	nrow,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	mempath
	)

Parameters

[in]	nrow	integer array number of rows
[in]	varname	variable name
[in]	mempath	variable mempath

Definition at line 625 of file LoadContext.f90.

    use memorymanagermodule, only: mem_allocate
    integer(I4B), intent(in) :: nrow !< integer array number of rows
    character(len=*), intent(in) :: varname !< variable name
    character(len=*), intent(in) :: mempath !< variable mempath
    integer(I4B), dimension(:), pointer, contiguous :: int1d
    integer(I4B) :: n
    call mem_allocate(int1d, nrow, varname, mempath)
    do n = 1, nrow
      int1d(n) = izero
    end do

Here is the caller graph for this function:

allocate_int2d()

subroutine loadcontextmodule::allocate_int2d	(	integer(i4b), intent(in)	ncol,
		integer(i4b), intent(in)	nrow,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	mempath
	)

Parameters

[in]	ncol	integer array number of cols
[in]	nrow	integer array number of rows
[in]	varname	variable name
[in]	mempath	variable mempath

Definition at line 640 of file LoadContext.f90.

    use memorymanagermodule, only: mem_allocate
    integer(I4B), intent(in) :: ncol !< integer array number of cols
    integer(I4B), intent(in) :: nrow !< integer array number of rows
    character(len=*), intent(in) :: varname !< variable name
    character(len=*), intent(in) :: mempath !< variable mempath
    integer(I4B), dimension(:, :), pointer, contiguous :: int2d
    integer(I4B) :: n, m
    call mem_allocate(int2d, ncol, nrow, varname, mempath)
    do m = 1, nrow
      do n = 1, ncol
        int2d(n, m) = izero
      end do
    end do

Here is the caller graph for this function:

allocate_param()

subroutine loadcontextmodule::allocate_param	(	class(loadcontexttype)	this,
		type(inputparamdefinitiontype), pointer	idt
	)

Definition at line 275 of file LoadContext.f90.

    use inputdefinitionmodule, only: inputparamdefinitiontype
    class(LoadContextType) :: this
    type(InputParamDefinitionType), pointer :: idt
    integer(I4B) :: dimsize
 
    ! initialize
    dimsize = 0
 
    if (this%readarray) then
      select case (idt%shape)
      case ('NCPL', 'NAUX NCPL')
        dimsize = this%ncpl
      case ('NODES', 'NAUX NODES')
        dimsize = this%maxbound
      case default
      end select
    end if
 
    select case (idt%datatype)
    case ('INTEGER')
      if (this%loadtype == list) then
        call allocate_int1d(this%maxbound, idt%mf6varname, &
                            this%mf6_input%mempath)
      end if
    case ('DOUBLE')
      if (this%loadtype == list) then
        call allocate_dbl1d(this%maxbound, idt%mf6varname, &
                            this%mf6_input%mempath)
      end if
    case ('STRING')
      if (this%loadtype == list) then
        call allocate_charstr1d(lenboundname, this%maxbound, idt%mf6varname, &
                                this%mf6_input%mempath)
      end if
    case ('INTEGER1D')
      if (this%loadtype == list) then
        if (idt%shape == 'NCELLDIM') then
          call allocate_int2d(size(this%mshape), this%maxbound, &
                              idt%mf6varname, this%mf6_input%mempath)
        end if
      else if (this%readarray) then
        call allocate_int1d(dimsize, idt%mf6varname, &
                            this%mf6_input%mempath)
      end if
    case ('DOUBLE1D')
      if (idt%shape == 'NAUX') then
        call allocate_dbl2d(this%naux, this%maxbound, &
                            idt%mf6varname, this%mf6_input%mempath)
      else if (this%readarray) then
        call allocate_dbl1d(dimsize, idt%mf6varname, &
                            this%mf6_input%mempath)
      end if
    case ('DOUBLE2D')
      if (this%readarray) then
        call allocate_dbl2d(this%naux, dimsize, idt%mf6varname, &
                            this%mf6_input%mempath)
      end if
    case default
    end select

Here is the call graph for this function:

allocate_scalars()

subroutine loadcontextmodule::allocate_scalars

(

class(loadcontexttype)

this

)

Definition at line 193 of file LoadContext.f90.

    use memorymanagermodule, only: mem_setptr
    class(LoadContextType) :: this
 
    if (this%ctxtype == exchange .or. &
        this%ctxtype == modelpkg .or. &
        this%ctxtype == stresspkg) then
 
      call setptr(this%nbound, 'NBOUND', this%mf6_input%mempath)
      call setval(this%naux, 'NAUX', this%mf6_input%mempath)
      call setval(this%ncpl, 'NCPL', this%mf6_input%mempath)
      call setval(this%nodes, 'NODES', this%mf6_input%mempath)
      call setval(this%maxbound, this%named_bound, this%mf6_input%mempath)
      call setval(this%boundnames, 'BOUNDNAMES', this%mf6_input%mempath)
      call setval(this%iprpak, 'IPRPAK', this%mf6_input%mempath)
 
      ! reset nbound
      this%nbound = 0
    end if
 
    if (this%ctxtype == stresspkg .and. &
        this%blockname == 'PERIOD') then
      call mem_setptr(this%mshape, 'MODEL_SHAPE', &
                      this%mf6_input%component_mempath)
 
      if (this%ncpl == 0) then
        if (size(this%mshape) == 2) then
          this%ncpl = this%mshape(2)
        else if (size(this%mshape) == 3) then
          this%ncpl = this%mshape(2) * this%mshape(3)
        end if
      end if
 
      if (this%nodes == 0) this%nodes = product(this%mshape)
    end if

Here is the call graph for this function:

destroy()

subroutine loadcontextmodule::destroy

(

class(loadcontexttype)

this

)

Definition at line 562 of file LoadContext.f90.

    class(LoadContextType) :: this
 
    if (this%ctxtype == exchange .or. &
        this%ctxtype == stresspkg) then
      ! deallocate local
      deallocate (this%naux)
      deallocate (this%ncpl)
      deallocate (this%nodes)
      deallocate (this%maxbound)
      deallocate (this%boundnames)
      deallocate (this%iprpak)
    end if
 
    ! nullify
    nullify (this%naux)
    nullify (this%nbound)
    nullify (this%ncpl)
    nullify (this%nodes)
    nullify (this%maxbound)
    nullify (this%boundnames)
    nullify (this%iprpak)
    nullify (this%auxname_cst)
    nullify (this%boundname_cst)
    nullify (this%auxvar)
    nullify (this%mshape)

in_scope()

logical(lgp) function loadcontextmodule::in_scope	(	class(loadcontexttype)	this,
		type(modflowinputtype), intent(in)	mf6_input,
		character(len=*), intent(in)	blockname,
		character(len=*), intent(in)	tagname
	)

Definition at line 392 of file LoadContext.f90.

    use memorymanagermodule, only: get_isize, mem_setptr
    use definitionselectmodule, only: get_param_definition_type, idt_datatype
    class(LoadContextType) :: this
    type(ModflowInputType), intent(in) :: mf6_input
    character(len=*), intent(in) :: blockname
    character(len=*), intent(in) :: tagname
    logical(LGP) :: in_scope
    type(InputParamDefinitionType), pointer :: idt
    character(len=LENVARNAME) :: checkname
    character(len=LINELENGTH) :: datatype
    integer(I4B) :: isize, checksize
    integer(I4B), pointer :: intptr
 
    idt => &
      get_param_definition_type(mf6_input%param_dfns, &
                                mf6_input%component_type, &
                                mf6_input%subcomponent_type, &
                                blockname, tagname, '')
    if (idt%required) then
      in_scope = .true.
      return
    else
      in_scope = .false.
      datatype = idt_datatype(idt)
      if (datatype == 'KEYSTRING' .or. &
          datatype == 'RECARRAY' .or. &
          datatype == 'RECORD') return
    end if
 
    ! initialize
    checkname = ''
    checksize = 0
 
    if (tagname == 'AUXVAR' .or. &
        tagname == 'AUX') then
      checkname = 'NAUX'
    else if (tagname == 'BOUNDNAME') then
      checkname = 'BOUNDNAMES'
    else if (tagname == 'I'//trim(mf6_input%subcomponent_type(1:3))) then
      if (this%loadtype == layerarray) in_scope = .true.
    else
      select case (mf6_input%subcomponent_type)
      case ('EVT')
        if (tagname == 'PXDP' .or. tagname == 'PETM') then
          checkname = 'NSEG'
          checksize = 1
        else if (tagname == 'PETM0') then
          checkname = 'SURFRATESPEC'
        end if
      case ('MVR', 'MVT', 'MVE')
        if (tagname == 'MNAME' .or. &
            tagname == 'MNAME1' .or. &
            tagname == 'MNAME2') then
          checkname = 'MODELNAMES'
        end if
      case ('NAM')
        in_scope = .true.
      case ('SSM')
        if (tagname == 'MIXED') in_scope = .true.
      case default
        errmsg = 'LoadContext in_scope needs new check for: '// &
                 trim(idt%tagname)
        call store_error(errmsg, .true.)
      end select
    end if
 
    ! apply checks
    if (.not. in_scope) then
      call get_isize(checkname, mf6_input%mempath, isize)
      if (isize > 0) then
        call mem_setptr(intptr, checkname, mf6_input%mempath)
        if (intptr > checksize) in_scope = .true.
      end if
    end if

Here is the call graph for this function:

init()

subroutine loadcontextmodule::init ( class(loadcontexttype)  this, type(modflowinputtype), intent(in)  mf6_input, character(len=*), intent(in), optional  blockname, character(len=*), intent(in), optional  named_bound  )

private

Definition at line 99 of file LoadContext.f90.

    use inputoutputmodule, only: upcase
    use modelpackageinputsmodule, only: supported_model
    class(LoadContextType) :: this
    type(ModflowInputType), intent(in) :: mf6_input
    character(len=*), optional, intent(in) :: blockname
    character(len=*), optional, intent(in) :: named_bound
    type(InputParamDefinitionType), pointer :: idt
    integer(I4B) :: n
 
    this%mf6_input = mf6_input
    this%readarray = .false.
    this%loadtype = load_undef
    this%ctxtype = context_undef
 
    select case (mf6_input%load_scope)
    case ('ROOT')
      this%ctxtype = root
    case ('SIM')
      if (mf6_input%subcomponent_type == 'NAM') then
        this%ctxtype = model
      else if (mf6_input%subcomponent_type == 'TDIS' .or. &
               mf6_input%subcomponent_type == 'HPC') then
        this%ctxtype = sim
      else if (mf6_input%component_type == 'EXG') then
        this%ctxtype = exchange
      end if
    case ('MODEL')
      if (mf6_input%subcomponent_type == 'OC' .or. &
          mf6_input%subcomponent_type == 'STO') then
        this%ctxtype = modelpkg
      else
        this%ctxtype = stresspkg
      end if
    case default
    end select
 
    if (this%ctxtype == context_undef) then
      errmsg = 'LoadContext unidentified context for mempath: '// &
               trim(mf6_input%mempath)
      call store_error(errmsg, .true.)
    end if
 
    if (present(blockname)) then
      this%blockname = blockname
      call upcase(this%blockname)
    else
      this%blockname = 'PERIOD'
    end if
 
    if (present(named_bound)) then
      this%named_bound = named_bound
      call upcase(this%named_bound)
    else
      this%named_bound = 'MAXBOUND'
    end if
 
    ! determine if list based load
    do n = 1, size(mf6_input%block_dfns)
      if (mf6_input%block_dfns(n)%blockname == this%blockname) then
        if (mf6_input%block_dfns(n)%aggregate) then
          this%loadtype = list
        end if
      end if
    end do
 
    ! determine if array based load
    if (this%loadtype == load_undef) then
      do n = 1, size(mf6_input%param_dfns)
        idt => mf6_input%param_dfns(n)
        if (idt%blockname == 'OPTIONS') then
          select case (idt%tagname)
          case ('READASARRAYS')
            this%loadtype = layerarray
            this%readarray = .true.
          case ('READARRAYGRID')
            this%loadtype = gridarray
            this%readarray = .true.
          case default
            ! no-op
          end select
        end if
      end do
    end if
 
    ! set in scope params for load
    call this%set_params()
 
    ! allocate load context scalars
    call this%allocate_scalars()

Here is the call graph for this function:

rsv_alloc()

character(len=lenvarname) function loadcontextmodule::rsv_alloc	(	class(loadcontexttype)	this,
		character(len=*), intent(in)	mf6varname
	)

Create and set a read state variable, e.g. 'INRECHARGE', which are updated per iper load as follows: -1: unset, not in use 0: not read in most recent period block 1: numeric input read in most recent period block 2: time series input read in most recent period block

Definition at line 548 of file LoadContext.f90.

    use constantsmodule, only: lenvarname
    use memorymanagermodule, only: mem_setptr, mem_allocate
    class(LoadContextType) :: this
    character(len=*), intent(in) :: mf6varname
    character(len=LENVARNAME) :: varname
    integer(I4B), pointer :: intvar
    varname = rsv_name(mf6varname)
    call mem_allocate(intvar, varname, this%mf6_input%mempath)
    intvar = -1

Here is the call graph for this function:

rsv_name()

character(len=lenvarname) function, public loadcontextmodule::rsv_name

(

character(len=*), intent(in)

mf6varname

)

Definition at line 592 of file LoadContext.f90.

    use constantsmodule, only: lenvarname
    character(len=*), intent(in) :: mf6varname
    character(len=LENVARNAME) :: varname
    integer(I4B) :: ilen
    character(len=2) :: prefix = 'IN'
    ilen = len_trim(mf6varname)
    if (ilen > (lenvarname - len(prefix))) then
      varname = prefix//mf6varname(1:(lenvarname - len(prefix)))
    else
      varname = prefix//trim(mf6varname)
    end if

Here is the caller graph for this function:

set_params()

subroutine loadcontextmodule::set_params

(

class(loadcontexttype)

this

)

Definition at line 471 of file LoadContext.f90.

    use arrayhandlersmodule, only: expandarray
    use definitionselectmodule, only: get_param_definition_type, &
                                      get_aggregate_definition_type, &
                                      idt_parse_rectype
    class(LoadContextType) :: this
    type(InputParamDefinitionType), pointer :: idt, aidt
    character(len=LINELENGTH), dimension(:), allocatable :: tags
    character(len=LINELENGTH), dimension(:), allocatable :: cols
    integer(I4B) :: keepcnt, iparam, nparam
    logical(LGP) :: keep
 
    ! initialize
    keepcnt = 0
 
    if (this%loadtype == list) then
      ! get aggregate param definition for period block
      aidt => &
        get_aggregate_definition_type(this%mf6_input%aggregate_dfns, &
                                      this%mf6_input%component_type, &
                                      this%mf6_input%subcomponent_type, &
                                      this%blockname)
      ! split recarray definition
      call idt_parse_rectype(aidt, cols, nparam)
    else
      nparam = size(this%mf6_input%param_dfns)
    end if
 
    ! allocate dfn input params
    do iparam = 1, nparam
      if (this%loadtype == list) then
        idt => get_param_definition_type(this%mf6_input%param_dfns, &
                                         this%mf6_input%component_type, &
                                         this%mf6_input%subcomponent_type, &
                                         this%blockname, cols(iparam), '')
      else
        idt => this%mf6_input%param_dfns(iparam)
      end if
 
      if (idt%blockname /= this%blockname) then
        keep = .false.
      else
        keep = this%in_scope(this%mf6_input, this%blockname, idt%tagname)
      end if
 
      if (keep) then
        keepcnt = keepcnt + 1
        call expandarray(tags)
        tags(keepcnt) = trim(idt%tagname)
      end if
    end do
 
    ! update nparam
    nparam = keepcnt
 
    ! allocate filtcols
    allocate (this%params(nparam))
 
    ! set filtcols
    do iparam = 1, nparam
      this%params(iparam) = trim(tags(iparam))
    end do
 
    ! cleanup
    if (allocated(tags)) deallocate (tags)

Here is the call graph for this function:

setptr_auxvar()

subroutine loadcontextmodule::setptr_auxvar	(	real(dp), dimension(:, :), intent(inout), pointer, contiguous	auxvar,
		character(len=*), intent(in)	mempath
	)

Definition at line 742 of file LoadContext.f90.

    use memorymanagermodule, only: mem_allocate, mem_setptr, get_isize
    real(DP), dimension(:, :), pointer, &
      contiguous, intent(inout) :: auxvar
    character(len=*), intent(in) :: mempath
    integer(I4B) :: isize
    call get_isize('AUXVAR', mempath, isize)
    if (isize > -1) then
      call mem_setptr(auxvar, 'AUXVAR', mempath)
    else
      call mem_allocate(auxvar, 0, 0, 'AUXVAR', mempath)
    end if

setptr_charstr1d()

subroutine loadcontextmodule::setptr_charstr1d	(	type(characterstringtype), dimension(:), intent(inout), pointer, contiguous	charstr1d,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	mempath,
		integer(i4b), intent(in)	strlen
	)

Definition at line 723 of file LoadContext.f90.

    use memorymanagermodule, only: mem_allocate, mem_setptr, get_isize
    type(CharacterStringType), dimension(:), pointer, &
      contiguous, intent(inout) :: charstr1d
    character(len=*), intent(in) :: varname
    character(len=*), intent(in) :: mempath
    integer(I4B), intent(in) :: strlen
    integer(I4B) :: isize
    call get_isize(varname, mempath, isize)
    if (isize > -1) then
      call mem_setptr(charstr1d, varname, mempath)
    else
      call mem_allocate(charstr1d, strlen, 0, varname, mempath)
    end if

setptr_int()

subroutine loadcontextmodule::setptr_int	(	integer(i4b), intent(inout), pointer	intptr,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	mempath
	)

Definition at line 706 of file LoadContext.f90.

    use memorymanagermodule, only: mem_allocate, mem_setptr, get_isize
    integer(I4B), pointer, intent(inout) :: intptr
    character(len=*), intent(in) :: varname
    character(len=*), intent(in) :: mempath
    integer(I4B) :: isize
    call get_isize(varname, mempath, isize)
    if (isize > -1) then
      call mem_setptr(intptr, varname, mempath)
    else
      call mem_allocate(intptr, varname, mempath)
      intptr = 0
    end if

setval()

subroutine loadcontextmodule::setval	(	integer(i4b), intent(inout), pointer	intptr,
		character(len=*), intent(in)	varname,
		character(len=*), intent(in)	mempath
	)

Definition at line 692 of file LoadContext.f90.

    use memorymanagerextmodule, only: mem_set_value
    integer(I4B), pointer, intent(inout) :: intptr
    character(len=*), intent(in) :: varname
    character(len=*), intent(in) :: mempath
    logical(LGP) :: found
    allocate (intptr)
    intptr = 0
    call mem_set_value(intptr, varname, mempath, found)

Here is the caller graph for this function:

tags()

subroutine loadcontextmodule::tags	(	class(loadcontexttype)	this,
		character(len=linelength), dimension(:), intent(inout), allocatable	params,
		integer(i4b), intent(inout)	nparam,
		character(len=*), intent(in)	input_name,
		logical(lgp), intent(in), optional	create
	)

set input array to tagnames of in scope params, optionally allocate the parameters based on datatype.

Definition at line 343 of file LoadContext.f90.

    use devfeaturemodule, only: dev_feature
    use simvariablesmodule, only: iout
    use definitionselectmodule, only: get_param_definition_type
    class(LoadContextType) :: this
    character(len=LINELENGTH), dimension(:), allocatable, &
      intent(inout) :: params
    integer(I4B), intent(inout) :: nparam
    character(len=*), intent(in) :: input_name
    logical(LGP), optional, intent(in) :: create
    type(InputParamDefinitionType), pointer :: idt
    character(len=LINELENGTH) :: dev_msg
    logical(LGP) :: allocate_params
    integer(I4B) :: n
 
    ! initialize allocate_params
    allocate_params = .false.
 
    ! override default if provided
    if (present(create)) then
      allocate_params = create
    end if
 
    if (allocated(params)) deallocate (params)
    nparam = size(this%params)
    allocate (params(nparam))
    do n = 1, nparam
      idt => &
        get_param_definition_type(this%mf6_input%param_dfns, &
                                  this%mf6_input%component_type, &
                                  this%mf6_input%subcomponent_type, &
                                  this%blockname, this%params(n), '')
 
      ! check if input param is prerelease
      if (idt%prerelease) then
        dev_msg = 'Input tag "'//trim(idt%tagname)// &
          &'" read from file "'//trim(input_name)// &
          &'" is still under development. Install the &
          &nightly build or compile from source with IDEVELOPMODE = 1.'
        call dev_feature(dev_msg, iout)
      end if
 
      params(n) = this%params(n)
      if (allocate_params) call this%allocate_param(idt)
    end do

Here is the call graph for this function: