inputloadtypemodule Module Reference

This module contains the InputLoadTypeModule. More...

Data Types
type	subpackagelisttype
	type representing package subpackage list More...
type	staticpkgloadtype
	Static loader type. More...
type	staticpkgloadbasetype
	Base abstract type for static input loader. More...
type	dynamicpkgloadtype
	Dynamic loader type. More...
type	dynamicpkgloadbasetype
	Base abstract type for dynamic input loader. More...
interface	load_if
	load interfaces for source static and dynamic types More...
interface	period_load_if
type	modeldynamicpkgstype
	type for storing a dynamic package load list More...

Functions/Subroutines
subroutine	subpkg_create (this, component_type, component_name)
	initialize a SubPackageListType object More...
subroutine	subpkg_add (this, pkgtype, component_type, subcomponent_type, filename)
	append one subpackage file instance to the list More...
subroutine	subpkg_names (this, parent_sctype, parent_scname, parent_mempath, modelfname)
	Assign subpackage names and mempaths for IDM-integrated subpackages. More...
character(len=lenvarname) function	build_subpkg_prefix (component_type, component_name, parent_sctype, parent_scname, modelfname)
	Build the subpackage name prefix for the given parent package. More...
subroutine	deduplicate_pkgtypes (pkgtypes, subptypes, nsubptypes)
	Deduplicate pkgtypes into unique entries with counts (run-length encoding). More...
subroutine	subpkg_destroy (this)
	destroy a SubPackageListType object More...
subroutine	static_init (this, mf6_input, component_name, component_input_name, input_name)
	initialize static package loader More...
subroutine	create_subpkg_list (this)
	create the subpackage list More...
subroutine	static_destroy (this)
subroutine	dynamic_init (this, mf6_input, component_name, component_input_name, input_name, iperblock, iout)
	initialize dynamic package loader More...
subroutine	dynamic_df (this)
	dynamic package loader define More...
subroutine	dynamic_ad (this)
	dynamic package loader advance More...
subroutine	dynamic_destroy (this)
	dynamic package loader destroy More...
subroutine	dynamicpkgs_init (this, modeltype, modelname, modelfname, nc_fname, ncid, iout)
	model dynamic packages init More...
subroutine	dynamicpkgs_add (this, dynamic_pkg)
	add package to model dynamic packages list More...
class(dynamicpkgloadbasetype) function, pointer	dynamicpkgs_get (this, idx)
	retrieve package from model dynamic packages list More...
subroutine	dynamicpkgs_rp (this)
	read and prepare model dynamic packages More...
subroutine	dynamicpkgs_df (this)
	define model dynamic packages More...
subroutine	dynamicpkgs_ad (this)
	advance model dynamic packages More...
integer(i4b) function	dynamicpkgs_size (this)
	get size of model dynamic packages list More...
subroutine	dynamicpkgs_destroy (this)
	destroy model dynamic packages object More...
subroutine, public	adddynamicmodeltolist (list, model_dynamic)
	add model dynamic packages object to list More...
class(modeldynamicpkgstype) function, pointer, public	getdynamicmodelfromlist (list, idx)
	get model dynamic packages object from list More...

Variables
type(listtype), public	model_inputs

Detailed Description

This module defines types that support generic IDM static and dynamic input loading.

Function/Subroutine Documentation

adddynamicmodeltolist()

subroutine, public inputloadtypemodule::adddynamicmodeltolist	(	type(listtype), intent(inout)	list,
		class(modeldynamicpkgstype), intent(inout), pointer	model_dynamic
	)

Parameters

[in,out]

list

package list

Definition at line 725 of file InputLoadType.f90.

    type(ListType), intent(inout) :: list !< package list
    class(ModelDynamicPkgsType), pointer, intent(inout) :: model_dynamic
    class(*), pointer :: obj
    obj => model_dynamic
    call list%Add(obj)

Here is the caller graph for this function:

build_subpkg_prefix()

character(len=lenvarname) function inputloadtypemodule::build_subpkg_prefix	(	character(len=*), intent(in)	component_type,
		character(len=*), intent(in)	component_name,
		character(len=*), intent(in)	parent_sctype,
		character(len=*), intent(in)	parent_scname,
		character(len=*), intent(in)	modelfname
	)

For single-instance parents (e.g. NPF), prefix is '<TYPE>-'. For multi-instance parents (e.g. WEL), prefix includes the instance number: '<TYPE><N>-' (e.g. 'WEL1-'). EXG packages return ''.

Definition at line 275 of file InputLoadType.f90.

    use memoryhelpermodule, only: create_mem_path
    use memorymanagermodule, only: mem_setptr
    use simvariablesmodule, only: idm_context
    use characterstringmodule, only: characterstringtype
    use modelpackageinputmodule, only: multi_package_type
    use idmdfnselectormodule, only: idm_multi_package, idm_integrated
    use sourcecommonmodule, only: idm_pkg_instance_name
    character(len=*), intent(in) :: component_type
    character(len=*), intent(in) :: component_name
    character(len=*), intent(in) :: parent_sctype
    character(len=*), intent(in) :: parent_scname
    character(len=*), intent(in) :: modelfname
    character(len=LENVARNAME) :: subpkg_prefix
    type(CharacterStringType), dimension(:), contiguous, pointer :: pnames, ftypes
    character(len=LENVARNAME) :: parent_type, parent_ftype, parent_name
    character(len=LENMEMPATH) :: model_mempath
    integer(I4B) :: parent_inst, n
    logical(LGP) :: multi
 
    subpkg_prefix = ''
 
    ! EXG (exchange) packages have no model NAM file and don't need a prefix
    if (component_type == 'EXG') return
 
    ! resolve definition names to the namefile packages block type name
    select case (parent_sctype)
    case ('EVTA', 'RCHA', 'SPCA', 'RIVG', 'CHDG', 'WELG', 'DRNG', 'GHBG')
      parent_type = parent_sctype(1:3)
    case default
      parent_type = parent_sctype
    end select
 
    ! build the filetype string used to match FTYPE in the NAM packages block
    parent_ftype = trim(parent_type)//'6'
 
    ! determine if multi-package type
    if (idm_integrated(component_type, parent_type)) then
      multi = idm_multi_package(component_type, parent_type)
    else
      multi = multi_package_type(component_type, parent_type, parent_ftype)
    end if
 
    if (multi) then
      ! identify instance number of this package type in the namefile packages
      ! block and use to set subpackage prefix
      model_mempath = create_mem_path(component_name, 'NAM', idm_context)
      call mem_setptr(pnames, 'PNAME', model_mempath)
      call mem_setptr(ftypes, 'FTYPE', model_mempath)
 
      parent_inst = 0
      do n = 1, size(pnames)
        if (ftypes(n) == parent_ftype) then
          parent_inst = parent_inst + 1
          parent_name = pnames(n)
          if (parent_name == '') &
            parent_name = idm_pkg_instance_name(parent_type, parent_inst)
          if (parent_name == parent_scname) then
            write (subpkg_prefix, '(a,i0,a)') trim(parent_type), parent_inst, '-'
            exit
          end if
        end if
      end do
 
      if (subpkg_prefix == '') then
        errmsg = &
          'Internal IDM error: subpackage load cannot identify &
          &package "'//trim(parent_scname)//'" in model name file &
          &packages block.'
        call store_error(errmsg)
        call store_error_filename(modelfname)
      end if
    else
      ! single-instance parent: prefix is '<TYPE>-', e.g. 'NPF-'
      write (subpkg_prefix, '(2a)') trim(parent_type), '-'
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

create_subpkg_list()

subroutine inputloadtypemodule::create_subpkg_list ( class(staticpkgloadtype), intent(inout)  this )

private

Definition at line 431 of file InputLoadType.f90.

    use idmdfnselectormodule, only: idm_subpackages, idm_integrated
    use memorymanagermodule, only: mem_setptr, get_isize
    use arrayhandlersmodule, only: expandarray
    use characterstringmodule, only: characterstringtype
    class(StaticPkgLoadType), intent(inout) :: this
    character(len=16), dimension(:), pointer :: subpkgs
    type(CharacterStringType), dimension(:), pointer, &
      contiguous :: fnames
    character(len=LINELENGTH) :: tag, fname, pkgtype
    character(len=LENFTYPE) :: c_type, sc_type
    character(len=16) :: subpkg
    integer(I4B) :: idx, n, m, isize
 
    ! set pointer to package (idm integrated) subpackage list
    subpkgs => idm_subpackages(this%mf6_input%component_type, &
                               this%mf6_input%subcomponent_type)
 
    ! check each subpackage type this package supports
    do n = 1, size(subpkgs)
      ! check for input matching this supported subpackage
      subpkg = subpkgs(n)
      idx = index(subpkg, '-')
 
      if (idx > 0) then
        ! split string in component/subcomponent types
        c_type = subpkg(1:idx - 1)
        sc_type = subpkg(idx + 1:len_trim(subpkg))
 
        if (idm_integrated(c_type, sc_type)) then
          ! construct FILEIN filename tag
          pkgtype = trim(sc_type)//'6'
          tag = trim(pkgtype)//'_FILENAME'
          call get_isize(tag, this%mf6_input%mempath, isize)
          if (isize > 0) then
            ! add all input files of this type to subpackage type list
            call mem_setptr(fnames, tag, this%mf6_input%mempath)
            do m = 1, size(fnames)
              fname = fnames(m)
              call this%subpkg_list%add(pkgtype, c_type, sc_type, fname)
            end do
          end if
        else
          errmsg = 'Identified subpackage is not IDM integrated. Remove dfn &
                   &subpackage tagline for package "'//trim(subpkg)//'".'
          call store_error(errmsg)
          call store_error_filename(this%input_name)
        end if
      end if
    end do
 
    ! create subpackage names and use to store mempaths in memory manager
    call this%subpkg_list%set_names(this%mf6_input%subcomponent_type, &
                                    this%mf6_input%subcomponent_name, &
                                    this%mf6_input%mempath, &
                                    this%component_input_name)

Here is the call graph for this function:

deduplicate_pkgtypes()

subroutine inputloadtypemodule::deduplicate_pkgtypes	(	character(len=lencomponentname), dimension(:), intent(in)	pkgtypes,
		character(len=linelength), dimension(:), intent(out), allocatable	subptypes,
		integer(i4b), dimension(:), intent(out), allocatable	nsubptypes
	)

INVARIANT: pkgtypes entries for the same type must be contiguous.

Definition at line 359 of file InputLoadType.f90.

    use arrayhandlersmodule, only: expandarray
    character(len=LENCOMPONENTNAME), intent(in) :: pkgtypes(:)
    character(len=LINELENGTH), allocatable, intent(out) :: subptypes(:)
    integer(I4B), allocatable, intent(out) :: nsubptypes(:)
    character(len=LENCOMPONENTNAME) :: prev
    integer(I4B) :: n, ntype
 
    allocate (subptypes(0))
    allocate (nsubptypes(0))
    prev = ''
    ntype = 0
    do n = 1, size(pkgtypes)
      if (pkgtypes(n) /= prev) then
        ntype = ntype + 1
        prev = pkgtypes(n)
        call expandarray(subptypes)
        call expandarray(nsubptypes)
        subptypes(ntype) = prev
        nsubptypes(ntype) = 1
      else
        nsubptypes(ntype) = nsubptypes(ntype) + 1
      end if
    end do

Here is the caller graph for this function:

dynamic_ad()

subroutine inputloadtypemodule::dynamic_ad ( class(dynamicpkgloadtype), intent(inout)  this )

private

Definition at line 578 of file InputLoadType.f90.

    class(DynamicPkgLoadType), intent(inout) :: this
    ! override in derived type

dynamic_destroy()

subroutine inputloadtypemodule::dynamic_destroy ( class(dynamicpkgloadtype), intent(inout)  this )

private

Definition at line 586 of file InputLoadType.f90.

    use memorymanagermodule, only: mem_deallocate
    use memorymanagerextmodule, only: memorystore_remove
    use simvariablesmodule, only: idm_context
    class(DynamicPkgLoadType), intent(inout) :: this
 
    ! clean up netcdf variables structure
    if (associated(this%nc_vars)) then
      call this%nc_vars%destroy()
      deallocate (this%nc_vars)
      nullify (this%nc_vars)
    end if
 
    ! deallocate package static and dynamic input context
    call memorystore_remove(this%mf6_input%component_name, &
                            this%mf6_input%subcomponent_name, &
                            idm_context)

Here is the call graph for this function:

dynamic_df()

subroutine inputloadtypemodule::dynamic_df

(

class(dynamicpkgloadtype), intent(inout)

this

)

Definition at line 570 of file InputLoadType.f90.

    class(DynamicPkgLoadType), intent(inout) :: this
    ! override in derived type

dynamic_init()

subroutine inputloadtypemodule::dynamic_init ( class(dynamicpkgloadtype), intent(inout)  this, type(modflowinputtype), intent(in)  mf6_input, character(len=*), intent(in)  component_name, character(len=*), intent(in)  component_input_name, character(len=*), intent(in)  input_name, integer(i4b), intent(in)  iperblock, integer(i4b), intent(in)  iout  )

private

Any managed memory pointed to from model/package context must be allocated when dynamic loader is initialized.

Definition at line 505 of file InputLoadType.f90.

    use simvariablesmodule, only: errmsg
    use inputdefinitionmodule, only: inputparamdefinitiontype
    use loadcontextmodule, only: is_keystring_period
    class(DynamicPkgLoadType), intent(inout) :: this
    type(ModflowInputType), intent(in) :: mf6_input
    character(len=*), intent(in) :: component_name
    character(len=*), intent(in) :: component_input_name
    character(len=*), intent(in) :: input_name
    integer(I4B), intent(in) :: iperblock
    integer(I4B), intent(in) :: iout
    type(InputParamDefinitionType), pointer :: idt
    integer(I4B) :: iparam
 
    this%mf6_input = mf6_input
    this%component_name = component_name
    this%component_input_name = component_input_name
    this%input_name = input_name
    this%readasarrays = .false.
    this%readarraygrid = .false.
    this%has_keystring = .false.
    this%iperblock = iperblock
    this%nparam = 0
    this%iout = iout
    nullify (idt)
 
    ! throw error and exit if not found
    if (this%iperblock == 0) then
      write (errmsg, '(a,a)') &
        'Programming error. (IDM) PERIOD block not found in '&
        &'dynamic package input block dfns: ', &
        trim(mf6_input%subcomponent_name)
      call store_error(errmsg)
      call store_error_filename(this%input_name)
    end if
 
    ! set readasarrays and readarraygrid
    if (mf6_input%block_dfns(iperblock)%aggregate) then
      ! no-op
    else
      do iparam = 1, size(mf6_input%param_dfns)
        idt => mf6_input%param_dfns(iparam)
        if (idt%blockname == 'OPTIONS') then
          select case (idt%tagname)
          case ('READASARRAYS')
            this%readasarrays = .true.
          case ('READARRAYGRID')
            this%readarraygrid = .true.
          case default
            ! no-op
          end select
        end if
      end do
    end if
 
    ! detect keystring packages
    if (mf6_input%block_dfns(iperblock)%aggregate) then
      if (is_keystring_period(mf6_input)) this%has_keystring = .true.
    end if

Here is the call graph for this function:

dynamicpkgs_ad()

subroutine inputloadtypemodule::dynamicpkgs_ad ( class(modeldynamicpkgstype), intent(inout)  this )

private

Definition at line 686 of file InputLoadType.f90.

    class(ModelDynamicPkgsType), intent(inout) :: this
    class(DynamicPkgLoadBaseType), pointer :: dynamic_pkg
    integer(I4B) :: n
    do n = 1, this%pkglist%Count()
      dynamic_pkg => this%get(n)
      call dynamic_pkg%ad()
    end do

dynamicpkgs_add()

subroutine inputloadtypemodule::dynamicpkgs_add ( class(modeldynamicpkgstype), intent(inout)  this, class(dynamicpkgloadbasetype), intent(inout), pointer  dynamic_pkg  )

private

Definition at line 628 of file InputLoadType.f90.

    class(ModelDynamicPkgsType), intent(inout) :: this
    class(DynamicPkgLoadBaseType), pointer, intent(inout) :: dynamic_pkg
    class(*), pointer :: obj
    obj => dynamic_pkg
    call this%pkglist%add(obj)

dynamicpkgs_destroy()

subroutine inputloadtypemodule::dynamicpkgs_destroy ( class(modeldynamicpkgstype), intent(inout)  this )

private

Definition at line 708 of file InputLoadType.f90.

    class(ModelDynamicPkgsType), intent(inout) :: this
    class(DynamicPkgLoadBaseType), pointer :: dynamic_pkg
    integer(I4B) :: n
    ! destroy dynamic loaders
    do n = 1, this%pkglist%Count()
      dynamic_pkg => this%get(n)
      call dynamic_pkg%destroy()
      deallocate (dynamic_pkg)
      nullify (dynamic_pkg)
    end do
    call this%pkglist%Clear()

dynamicpkgs_df()

subroutine inputloadtypemodule::dynamicpkgs_df

(

class(modeldynamicpkgstype), intent(inout)

this

)

Definition at line 673 of file InputLoadType.f90.

    class(ModelDynamicPkgsType), intent(inout) :: this
    class(DynamicPkgLoadBaseType), pointer :: dynamic_pkg
    integer(I4B) :: n
    do n = 1, this%pkglist%Count()
      dynamic_pkg => this%get(n)
      call dynamic_pkg%df()
    end do

dynamicpkgs_get()

class(dynamicpkgloadbasetype) function, pointer inputloadtypemodule::dynamicpkgs_get ( class(modeldynamicpkgstype), intent(inout)  this, integer(i4b), intent(in)  idx  )

private

Definition at line 639 of file InputLoadType.f90.

    class(ModelDynamicPkgsType), intent(inout) :: this
    integer(I4B), intent(in) :: idx
    class(DynamicPkgLoadBaseType), pointer :: res
    class(*), pointer :: obj
    nullify (res)
    obj => this%pkglist%GetItem(idx)
    if (associated(obj)) then
      select type (obj)
      class is (dynamicpkgloadbasetype)
        res => obj
      end select
    end if

dynamicpkgs_init()

subroutine inputloadtypemodule::dynamicpkgs_init	(	class(modeldynamicpkgstype), intent(inout)	this,
		character(len=*), intent(in)	modeltype,
		character(len=*), intent(in)	modelname,
		character(len=*), intent(in)	modelfname,
		character(len=*), intent(in)	nc_fname,
		integer(i4b), intent(in)	ncid,
		integer(i4b), intent(in)	iout
	)

Definition at line 608 of file InputLoadType.f90.

    class(ModelDynamicPkgsType), intent(inout) :: this
    character(len=*), intent(in) :: modeltype
    character(len=*), intent(in) :: modelname
    character(len=*), intent(in) :: modelfname
    character(len=*), intent(in) :: nc_fname
    integer(I4B), intent(in) :: ncid
    integer(I4B), intent(in) :: iout
    this%modeltype = modeltype
    this%modelname = modelname
    this%modelfname = modelfname
    this%nc_fname = nc_fname
    this%ncid = ncid
    this%iout = iout

dynamicpkgs_rp()

subroutine inputloadtypemodule::dynamicpkgs_rp ( class(modeldynamicpkgstype), intent(inout)  this )

private

Definition at line 657 of file InputLoadType.f90.

    use idmloggermodule, only: idm_log_period_header, idm_log_period_close
    class(ModelDynamicPkgsType), intent(inout) :: this
    class(DynamicPkgLoadBaseType), pointer :: dynamic_pkg
    integer(I4B) :: n
    call idm_log_period_header(this%modelname, this%iout)
    do n = 1, this%pkglist%Count()
      dynamic_pkg => this%get(n)
      call dynamic_pkg%rp()
    end do
    call idm_log_period_close(this%iout)

Here is the call graph for this function:

dynamicpkgs_size()

integer(i4b) function inputloadtypemodule::dynamicpkgs_size ( class(modeldynamicpkgstype), intent(inout)  this )

private

Definition at line 699 of file InputLoadType.f90.

    class(ModelDynamicPkgsType), intent(inout) :: this
    integer(I4B) :: size
    size = this%pkglist%Count()

getdynamicmodelfromlist()

class(modeldynamicpkgstype) function, pointer, public inputloadtypemodule::getdynamicmodelfromlist	(	type(listtype), intent(inout)	list,
		integer(i4b), intent(in)	idx
	)

Parameters

[in,out]	list	spd list
[in]	idx	package number

Definition at line 736 of file InputLoadType.f90.

    type(ListType), intent(inout) :: list !< spd list
    integer(I4B), intent(in) :: idx !< package number
    class(ModelDynamicPkgsType), pointer :: res
    class(*), pointer :: obj
    ! initialize res
    nullify (res)
    ! get the object from the list
    obj => list%GetItem(idx)
    if (associated(obj)) then
      select type (obj)
      class is (modeldynamicpkgstype)
        res => obj
      end select
    end if

Here is the caller graph for this function:

static_destroy()

subroutine inputloadtypemodule::static_destroy

(

class(staticpkgloadtype), intent(inout)

this

)

Definition at line 489 of file InputLoadType.f90.

    class(StaticPkgLoadType), intent(inout) :: this
    call this%subpkg_list%destroy()
    if (associated(this%nc_vars)) then
      call this%nc_vars%destroy()
      deallocate (this%nc_vars)
      nullify (this%nc_vars)
    end if

static_init()

subroutine inputloadtypemodule::static_init ( class(staticpkgloadtype), intent(inout)  this, type(modflowinputtype), intent(in)  mf6_input, character(len=*), intent(in)  component_name, character(len=*), intent(in)  component_input_name, character(len=*), intent(in)  input_name  )

private

Definition at line 400 of file InputLoadType.f90.

    class(StaticPkgLoadType), intent(inout) :: this
    type(ModflowInputType), intent(in) :: mf6_input
    character(len=*), intent(in) :: component_name
    character(len=*), intent(in) :: component_input_name
    character(len=*), intent(in) :: input_name
    integer(I4B) :: iblock
 
    this%mf6_input = mf6_input
    this%component_name = component_name
    this%component_input_name = component_input_name
    this%input_name = input_name
    this%iperblock = 0
 
    ! create subpackage list
    call this%subpkg_list%create(this%mf6_input%component_type, &
                                 this%mf6_input%component_name)
 
    ! identify period block definition
    do iblock = 1, size(mf6_input%block_dfns)
      if (mf6_input%block_dfns(iblock)%blockname == 'PERIOD') then
        this%iperblock = iblock
        exit
      end if
    end do

subpkg_add()

subroutine inputloadtypemodule::subpkg_add ( class(subpackagelisttype)  this, character(len=*), intent(in)  pkgtype, character(len=*), intent(in)  component_type, character(len=*), intent(in)  subcomponent_type, character(len=*), intent(in)  filename  )

private

Definition at line 178 of file InputLoadType.f90.

    use arrayhandlersmodule, only: expandarray
    class(SubPackageListType) :: this
    character(len=*), intent(in) :: pkgtype
    character(len=*), intent(in) :: component_type
    character(len=*), intent(in) :: subcomponent_type
    character(len=*), intent(in) :: filename
 
    ! reallocate
    call expandarray(this%pkgtypes)
    call expandarray(this%component_types)
    call expandarray(this%subcomponent_types)
    call expandarray(this%subcomponent_names)
    call expandarray(this%filenames)
 
    ! add new package instance
    this%pnum = this%pnum + 1
    this%pkgtypes(this%pnum) = pkgtype
    this%component_types(this%pnum) = component_type
    this%subcomponent_types(this%pnum) = subcomponent_type
    this%subcomponent_names(this%pnum) = ''
    this%filenames(this%pnum) = filename

subpkg_create()

subroutine inputloadtypemodule::subpkg_create ( class(subpackagelisttype)  this, character(len=*), intent(in)  component_type, character(len=*), intent(in)  component_name  )

private

Definition at line 158 of file InputLoadType.f90.

    class(SubPackageListType) :: this
    character(len=*), intent(in) :: component_type
    character(len=*), intent(in) :: component_name
 
    ! initialize
    this%pnum = 0
    this%component_type = component_type
    this%component_name = component_name
 
    ! allocate arrays
    allocate (this%pkgtypes(0))
    allocate (this%component_types(0))
    allocate (this%subcomponent_types(0))
    allocate (this%subcomponent_names(0))
    allocate (this%filenames(0))

subpkg_destroy()

subroutine inputloadtypemodule::subpkg_destroy

(

class(subpackagelisttype)

this

)

Definition at line 387 of file InputLoadType.f90.

    class(SubPackageListType) :: this
    ! deallocate arrays
    deallocate (this%pkgtypes)
    deallocate (this%component_types)
    deallocate (this%subcomponent_types)
    deallocate (this%subcomponent_names)
    deallocate (this%filenames)

subpkg_names()

subroutine inputloadtypemodule::subpkg_names	(	class(subpackagelisttype)	this,
		character(len=*), intent(in)	parent_sctype,
		character(len=*), intent(in)	parent_scname,
		character(len=*), intent(in)	parent_mempath,
		character(len=*), intent(in)	modelfname
	)

Definition at line 205 of file InputLoadType.f90.

    use memoryhelpermodule, only: create_mem_path
    use memorymanagermodule, only: mem_allocate
    use simvariablesmodule, only: idm_context
    use characterstringmodule, only: characterstringtype
    use sourcecommonmodule, only: idm_utl_type
    class(SubPackageListType) :: this
    character(len=*), intent(in) :: parent_sctype
    character(len=*), intent(in) :: parent_scname
    character(len=*), intent(in) :: parent_mempath
    character(len=*), intent(in) :: modelfname
    character(len=LINELENGTH), dimension(:), allocatable :: subptypes
    integer(I4B), dimension(:), allocatable :: nsubptypes
    type(CharacterStringType), dimension(:), pointer, contiguous :: mempaths
    character(len=LINELENGTH), pointer :: input_fname
    character(len=LENVARNAME) :: mempath_key
    character(len=LENVARNAME) :: subpkg_prefix
    character(len=LENMEMPATH) :: mempath
    integer(I4B) :: subpkg_inst, n, m
 
    ! nothing to do if no subpackages were added
    if (size(this%pkgtypes) == 0) return
 
    ! UTL packages do not themselves have subpackages
    if (idm_utl_type(this%component_type, parent_sctype)) return
 
    ! build subpkg_prefix from the parent package identity
    subpkg_prefix = build_subpkg_prefix(this%component_type, &
                                        this%component_name, parent_sctype, &
                                        parent_scname, modelfname)
 
    ! deduplicate pkgtypes into unique list with per-type counts
    call deduplicate_pkgtypes(this%pkgtypes, subptypes, nsubptypes)
 
    ! allocate mempath arrays for each subpackage type, create and
    ! store the memory paths for package side access.
    do n = 1, size(subptypes)
      subpkg_inst = 0
      mempath_key = trim(subptypes(n))//'_MEMPATH'
      call mem_allocate(mempaths, lenmempath, nsubptypes(n), &
                        mempath_key, parent_mempath)
      do m = 1, size(this%pkgtypes)
        if (this%pkgtypes(m) == subptypes(n)) then
          subpkg_inst = subpkg_inst + 1
          ! set the subpackage name
          write (this%subcomponent_names(m), '(a,i0)') &
            trim(subpkg_prefix)//trim(this%subcomponent_types(m)), subpkg_inst
          ! create and set mempath
          mempath = create_mem_path(this%component_name, &
                                    this%subcomponent_names(m), &
                                    idm_context)
          mempaths(subpkg_inst) = mempath
          ! create and set INPUT_FNAME string in each new memory path.
          call mem_allocate(input_fname, linelength, 'INPUT_FNAME', mempath)
          input_fname = trim(this%filenames(m))
        end if
      end do
    end do
 
    deallocate (subptypes)
    deallocate (nsubptypes)

Here is the call graph for this function:

Variable Documentation

model_inputs

type(listtype), public inputloadtypemodule::model_inputs

Definition at line 152 of file InputLoadType.f90.

  type(ListType) :: model_inputs