idmloadmodule Module Reference

This module contains the IdmLoadModule. More...

Functions/Subroutines
subroutine, public	idm_df ()
	advance package dynamic data for period steps More...
subroutine, public	idm_rp ()
	load package dynamic data for period More...
subroutine, public	idm_ad ()
	advance package dynamic data for period steps More...
subroutine, public	idm_da (iout)
	idm deallocate routine More...
recursive subroutine	input_load (component_type, subcomponent_type, modelname, pkgname, pkgtype, filename, modelfname, nc_vars, iout)
	load an integrated model package from supported source More...
subroutine	load_model_pkgs (model_pkg_inputs, iout)
	load integrated model package files More...
subroutine, public	load_models (iout)
	load model namfiles and model package files More...
subroutine, public	load_exchanges (iout)
	load exchange files More...
subroutine, public	simnam_load (paramlog)
	MODFLOW 6 mfsim.nam input load routine. More...
subroutine, public	simtdis_load ()
	MODFLOW 6 tdis input load routine. More...
class(modeldynamicpkgstype) function, pointer	dynamic_models (modeltype, modelname, modelfname, nc_fname, ncid, iout)
	retrieve list of model dynamic loaders More...
subroutine	dynamic_da (iout)
	deallocate all model dynamic loader collections More...
integer(i4b) function	input_param_log ()
	return sim input context PRINT_INPUT value More...
subroutine	simnam_load_dim ()
	load simulation summary info to input context More...
subroutine	allocate_simnam_int (input_mempath, idt)
	set sim nam input context default integer value More...
subroutine	allocate_simnam_param (input_mempath, idt)
	MODFLOW 6 mfsim.nam parameter allocate and set. More...
subroutine	simnam_allocate ()
	MODFLOW 6 mfsim.nam input context parameter allocation. More...

Detailed Description

This module contains routines for managing static and dynamic input loading for supported sources.

Function/Subroutine Documentation

allocate_simnam_int()

subroutine idmloadmodule::allocate_simnam_int	(	character(len=lenmempath), intent(in)	input_mempath,
		type(inputparamdefinitiontype), intent(in), pointer	idt
	)

Definition at line 569 of file IdmLoad.f90.

    use memorymanagermodule, only: mem_allocate
    use simvariablesmodule, only: isimcontinue, isimcheck, simfile
    character(len=LENMEMPATH), intent(in) :: input_mempath
    type(InputParamDefinitionType), pointer, intent(in) :: idt
    integer(I4B), pointer :: intvar
 
    ! allocate and set default
    call mem_allocate(intvar, idt%mf6varname, input_mempath)
 
    select case (idt%mf6varname)
    case ('CONTINUE')
      intvar = isimcontinue
    case ('NOCHECK')
      intvar = isimcheck
    case ('MAXERRORS')
      intvar = 1000 !< MessageType max_message
    case ('MXITER')
      intvar = 1
    case ('PRINT_INPUT')
      intvar = 0
    case default
      write (errmsg, '(a,a)') &
        'Idm SIMNAM Load default value setting '&
        &'is unhandled for this variable: ', &
        trim(idt%mf6varname)
      call store_error(errmsg)
      call store_error_filename(simfile)
    end select

Here is the call graph for this function:

Here is the caller graph for this function:

allocate_simnam_param()

subroutine idmloadmodule::allocate_simnam_param	(	character(len=lenmempath), intent(in)	input_mempath,
		type(inputparamdefinitiontype), intent(in), pointer	idt
	)

Definition at line 602 of file IdmLoad.f90.

    use simvariablesmodule, only: simfile
    use memorymanagermodule, only: mem_allocate
    use characterstringmodule, only: characterstringtype
    use definitionselectmodule, only: idt_datatype
    character(len=LENMEMPATH), intent(in) :: input_mempath
    type(InputParamDefinitionType), pointer, intent(in) :: idt
    character(len=LINELENGTH), pointer :: cstr
    type(CharacterStringType), dimension(:), &
      pointer, contiguous :: acharstr1d
 
    select case (idt_datatype(idt))
    case ('KEYWORD', 'INTEGER')
      if (idt%in_record) then
        ! no-op
      else
        ! allocate and set default
        call allocate_simnam_int(input_mempath, idt)
      end if
    case ('STRING')
      ! did this param originate from sim namfile RECARRAY type
      if (idt%in_record) then
        ! allocate 0 size CharacterStringType array
        call mem_allocate(acharstr1d, linelength, 0, idt%mf6varname, &
                          input_mempath)
      else
        ! allocate empty string
        call mem_allocate(cstr, linelength, idt%mf6varname, input_mempath)
        cstr = ''
      end if
    case ('RECORD')
      ! no-op
    case default
      write (errmsg, '(a,a)') &
        'IdmLoad allocate simnam param unhandled datatype: ', &
        trim(idt%datatype)
      call store_error(errmsg)
      call store_error_filename(simfile)
    end select

Here is the call graph for this function:

Here is the caller graph for this function:

dynamic_da()

subroutine idmloadmodule::dynamic_da

(

integer(i4b), intent(in)

iout

)

Definition at line 500 of file IdmLoad.f90.

    use inputloadtypemodule, only: getdynamicmodelfromlist
    use sourceloadmodule, only: nc_close
    integer(I4B), intent(in) :: iout
    class(ModelDynamicPkgsType), pointer :: model_dynamic_input
    integer(I4B) :: n
    do n = 1, model_inputs%Count()
      model_dynamic_input => getdynamicmodelfromlist(model_inputs, n)
      call nc_close(model_dynamic_input%ncid, model_dynamic_input%nc_fname)
      call model_dynamic_input%destroy()
      deallocate (model_dynamic_input)
      nullify (model_dynamic_input)
    end do
    call model_inputs%Clear()

Here is the call graph for this function:

Here is the caller graph for this function:

dynamic_models()

class(modeldynamicpkgstype) function, pointer idmloadmodule::dynamic_models	(	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 464 of file IdmLoad.f90.

    use inputloadtypemodule, only: adddynamicmodeltolist, getdynamicmodelfromlist
    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
    class(ModelDynamicPkgsType), pointer :: model_dynamic_input
    class(ModelDynamicPkgsType), pointer :: temp
    integer(I4B) :: id
 
    ! initialize
    nullify (model_dynamic_input)
 
    ! assign model loader object if found
    do id = 1, model_inputs%Count()
      temp => getdynamicmodelfromlist(model_inputs, id)
      if (temp%modelname == modelname) then
        model_dynamic_input => temp
        exit
      end if
    end do
 
    ! create if not found
    if (.not. associated(model_dynamic_input)) then
      allocate (model_dynamic_input)
      call model_dynamic_input%init(modeltype, modelname, modelfname, &
                                    nc_fname, ncid, iout)
      call adddynamicmodeltolist(model_inputs, model_dynamic_input)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

idm_ad()

subroutine, public idmloadmodule::idm_ad

Definition at line 61 of file IdmLoad.f90.

    use inputloadtypemodule, only: getdynamicmodelfromlist
    class(ModelDynamicPkgsType), pointer :: model_dynamic_input
    integer(I4B) :: n
    do n = 1, model_inputs%Count()
      model_dynamic_input => getdynamicmodelfromlist(model_inputs, n)
      call model_dynamic_input%ad()
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

idm_da()

subroutine, public idmloadmodule::idm_da

(

integer(i4b), intent(in)

iout

)

Definition at line 73 of file IdmLoad.f90.

    use simvariablesmodule, only: idm_context
    use memorymanagermodule, only: mem_setptr
    use memoryhelpermodule, only: create_mem_path, split_mem_path
    use memorymanagerextmodule, only: memorystore_remove
    use characterstringmodule, only: characterstringtype
    integer(I4B), intent(in) :: iout
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: mempaths
    character(len=LENCOMPONENTNAME) :: exg_comp, exg_subcomp
    character(len=LENMEMPATH) :: input_mempath, mempath
    integer(I4B) :: n
 
    ! deallocate dynamic loaders
    call dynamic_da(iout)
 
    ! deallocate EXG mempaths
    input_mempath = create_mem_path('SIM', 'NAM', idm_context)
    call mem_setptr(mempaths, 'EXGMEMPATHS', input_mempath)
    do n = 1, size(mempaths)
      mempath = mempaths(n)
      if (mempath /= '') then
        call split_mem_path(mempath, exg_comp, exg_subcomp)
        call memorystore_remove(exg_comp, exg_subcomp, idm_context)
      end if
    end do
 
    ! deallocate input context SIM paths
    call memorystore_remove('UTL', 'HPC', idm_context)
    call memorystore_remove('SIM', 'TDIS', idm_context)
    call memorystore_remove('SIM', 'NAM', idm_context)
    call memorystore_remove(component='SIM', context=idm_context)

Here is the call graph for this function:

Here is the caller graph for this function:

idm_df()

subroutine, public idmloadmodule::idm_df

Definition at line 37 of file IdmLoad.f90.

    use inputloadtypemodule, only: getdynamicmodelfromlist
    class(ModelDynamicPkgsType), pointer :: model_dynamic_input
    integer(I4B) :: n
    do n = 1, model_inputs%Count()
      model_dynamic_input => getdynamicmodelfromlist(model_inputs, n)
      call model_dynamic_input%df()
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

idm_rp()

subroutine, public idmloadmodule::idm_rp

Definition at line 49 of file IdmLoad.f90.

    use inputloadtypemodule, only: getdynamicmodelfromlist
    class(ModelDynamicPkgsType), pointer :: model_dynamic_input
    integer(I4B) :: n
    do n = 1, model_inputs%Count()
      model_dynamic_input => getdynamicmodelfromlist(model_inputs, n)
      call model_dynamic_input%rp()
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

input_load()

recursive subroutine idmloadmodule::input_load	(	character(len=*), intent(in)	component_type,
		character(len=*), intent(in)	subcomponent_type,
		character(len=*), intent(in)	modelname,
		character(len=*), intent(in)	pkgname,
		character(len=*), intent(in)	pkgtype,
		character(len=*), intent(in)	filename,
		character(len=*), intent(in)	modelfname,
		type(ncfilevarstype), intent(in), pointer	nc_vars,
		integer(i4b), intent(in)	iout
	)

Definition at line 109 of file IdmLoad.f90.

    use modelpackageinputsmodule, only: modelpackageinputstype
    use ncfilevarsmodule, only: ncfilevarstype
    use sourceloadmodule, only: create_input_loader
    character(len=*), intent(in) :: component_type
    character(len=*), intent(in) :: subcomponent_type
    character(len=*), intent(in) :: pkgname
    character(len=*), intent(in) :: pkgtype
    character(len=*), intent(in) :: filename
    character(len=*), intent(in) :: modelname
    character(len=*), intent(in) :: modelfname
    type(NCFileVarsType), pointer, intent(in) :: nc_vars
    integer(I4B), intent(in) :: iout
    class(StaticPkgLoadBaseType), pointer :: static_loader
    class(DynamicPkgLoadBaseType), pointer :: dynamic_loader
    class(ModelDynamicPkgsType), pointer :: dynamic_model
    integer(I4B) :: n
 
    ! create model package loader
    static_loader => &
      create_input_loader(component_type, subcomponent_type, modelname, pkgname, &
                          pkgtype, filename, modelfname, nc_vars)
 
    ! load static input and set dynamic loader
    dynamic_loader => static_loader%load(iout)
 
    ! set pointer to model dynamic packages list
    dynamic_model => &
      dynamic_models(static_loader%mf6_input%component_type, modelname, &
                     static_loader%component_input_name, nc_vars%nc_fname, &
                     nc_vars%ncid, iout)
 
    if (associated(dynamic_loader)) then
      ! add dynamic pkg loader to list
      call dynamic_model%add(dynamic_loader)
    end if
 
    ! create subpackage list
    call static_loader%create_subpkg_list()
 
    ! load idm integrated subpackages
    do n = 1, static_loader%subpkg_list%pnum
      ! load subpackage
      call input_load(static_loader%subpkg_list%component_types(n), &
                      static_loader%subpkg_list%subcomponent_types(n), &
                      static_loader%mf6_input%component_name, &
                      static_loader%subpkg_list%subcomponent_types(n), &
                      static_loader%subpkg_list%pkgtypes(n), &
                      static_loader%subpkg_list%filenames(n), &
                      modelfname, nc_vars, iout)
    end do
 
    ! cleanup
    call static_loader%destroy()
    deallocate (static_loader)

Here is the call graph for this function:

Here is the caller graph for this function:

input_param_log()

integer(i4b) function idmloadmodule::input_param_log

Definition at line 518 of file IdmLoad.f90.

    use memoryhelpermodule, only: create_mem_path
    use memorymanagermodule, only: mem_setptr
    use simvariablesmodule, only: idm_context
    character(len=LENMEMPATH) :: simnam_mempath
    integer(I4B) :: paramlog
    integer(I4B), pointer :: p
    ! read and set input value of PRINT_INPUT
    simnam_mempath = create_mem_path('SIM', 'NAM', idm_context)
    call mem_setptr(p, 'PRINT_INPUT', simnam_mempath)
    paramlog = p

Here is the call graph for this function:

Here is the caller graph for this function:

load_exchanges()

subroutine, public idmloadmodule::load_exchanges

(

integer(i4b), intent(in)

iout

)

Definition at line 284 of file IdmLoad.f90.

    use memoryhelpermodule, only: create_mem_path
    use memorymanagermodule, only: mem_setptr, mem_allocate, &
                                   mem_deallocate, get_isize
    use characterstringmodule, only: characterstringtype
    use simvariablesmodule, only: idm_context, simfile
    use distributedsimmodule, only: distributedsimtype, get_dsim
    use sourcecommonmodule, only: idm_subcomponent_type, ifind_charstr, &
                                  inlen_check
    use sourceloadmodule, only: create_input_loader, remote_model_ndim
    integer(I4B), intent(in) :: iout
    type(DistributedSimType), pointer :: ds
    integer(I4B), dimension(:), pointer :: model_loadmask
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: etypes !< exg types
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: efiles !< exg file names
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: emnames_a !< model a names
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: emnames_b !< model b names
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: emempaths !< exg mempaths
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: mtypes !< model types
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: mfnames !< model file names
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: mnames !< model names
    character(len=LENMEMPATH) :: input_mempath, mempath
    integer(I4B), pointer :: exgid, ncelldim
    character(len=LINELENGTH) :: exgtype, efname, mfname
    character(len=LENMODELNAME) :: mname1, mname2, mname
    character(len=LENCOMPONENTNAME) :: sc_type, sc_name, mtype
    class(StaticPkgLoadBaseType), pointer :: static_loader
    class(DynamicPkgLoadBaseType), pointer :: dynamic_loader
    integer(I4B) :: n, m1_idx, m2_idx, irem, isize
 
    ! get model mask
    ds => get_dsim()
    model_loadmask => ds%get_load_mask()
 
    ! set input memory path
    input_mempath = create_mem_path('SIM', 'NAM', idm_context)
 
    ! set pointers to input context exg and model attribute arrays
    call mem_setptr(etypes, 'EXGTYPE', input_mempath)
    call mem_setptr(efiles, 'EXGFILE', input_mempath)
    call mem_setptr(emnames_a, 'EXGMNAMEA', input_mempath)
    call mem_setptr(emnames_b, 'EXGMNAMEB', input_mempath)
    call mem_setptr(mtypes, 'MTYPE', input_mempath)
    call mem_setptr(mfnames, 'MFNAME', input_mempath)
    call mem_setptr(mnames, 'MNAME', input_mempath)
 
    ! allocate mempaths array for exchanges
    call mem_allocate(emempaths, lenmempath, size(etypes), 'EXGMEMPATHS', &
                      input_mempath)
 
    ! load exchanges for local models
    do n = 1, size(etypes)
      ! attributes for this exchange
      exgtype = etypes(n)
      efname = efiles(n)
      call inlen_check(emnames_a(n), mname1, lenmodelname, 'MODELNAME')
      call inlen_check(emnames_b(n), mname2, lenmodelname, 'MODELNAME')
 
      ! initialize mempath as no path
      emempaths(n) = ''
      irem = 0
 
      ! set indexes for exchange model names
      m1_idx = ifind_charstr(mnames, mname1)
      m2_idx = ifind_charstr(mnames, mname2)
 
      if (m1_idx <= 0 .or. m2_idx <= 0) then
        errmsg = 'Exchange has invalid (unrecognized) model name(s):'
        if (m1_idx <= 0) errmsg = trim(errmsg)//' '//trim(mname1)
        if (m2_idx <= 0) errmsg = trim(errmsg)//' '//trim(mname2)
        call store_error(errmsg)
      end if
 
      ! terminate if errors were detected
      if (count_errors() > 0) then
        call store_error_filename(simfile)
      end if
 
      ! load the exchange input if either model local
      if (model_loadmask(m1_idx) > 0 .or. model_loadmask(m2_idx) > 0) then
        ! set index if either model is remote
        if (model_loadmask(m1_idx) == 0) then
          irem = m1_idx
        else if (model_loadmask(m2_idx) == 0) then
          irem = m2_idx
        end if
 
        ! allocate and set remote model NCELLDIM
        if (irem > 0) then
          mtype = mtypes(irem)
          mfname = mfnames(irem)
          mname = mnames(irem)
          mempath = create_mem_path(component=mname, context=idm_context)
          call get_isize('NCELLDIM', mempath, isize)
          if (isize < 0) then
            call mem_allocate(ncelldim, 'NCELLDIM', mempath)
            ncelldim = remote_model_ndim(mtype, mfname)
          else
            call mem_setptr(ncelldim, 'NCELLDIM', mempath)
          end if
        else
          nullify (ncelldim)
        end if
 
        ! set subcomponent strings
        sc_type = trim(idm_subcomponent_type('EXG', exgtype))
        write (sc_name, '(a,i0)') trim(sc_type)//'_', n
 
        ! create and set exchange mempath
        mempath = create_mem_path('EXG', sc_name, idm_context)
        emempaths(n) = mempath
 
        ! allocate and set exgid
        call mem_allocate(exgid, 'EXGID', mempath)
        exgid = n
 
        ! create exchange loader
        static_loader => create_input_loader('EXG', sc_type, 'EXG', sc_name, &
                                             exgtype, efname, simfile)
        ! load static input
        dynamic_loader => static_loader%load(iout)
 
        if (associated(dynamic_loader)) then
          errmsg = 'IDM unimplemented. Dynamic Exchanges not supported.'
          call store_error(errmsg)
          call store_error_filename(efname)
        else
          call static_loader%destroy()
          deallocate (static_loader)
        end if
      end if
    end do
 
    ! clean up temporary NCELLDIM for remote models
    do n = 1, size(mnames)
      if (model_loadmask(n) == 0) then
        mname = mnames(n)
        mempath = create_mem_path(component=mname, context=idm_context)
        call get_isize('NCELLDIM', mempath, isize)
        if (isize > 0) then
          call mem_setptr(ncelldim, 'NCELLDIM', mempath)
          call mem_deallocate(ncelldim)
        end if
      end if
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

load_model_pkgs()

subroutine idmloadmodule::load_model_pkgs	(	type(modelpackageinputstype), intent(inout)	model_pkg_inputs,
		integer(i4b), intent(in)	iout
	)

Definition at line 170 of file IdmLoad.f90.

    use modelpackageinputsmodule, only: modelpackageinputstype
    use ncfilevarsmodule, only: ncfilevarstype
    use sourceloadmodule, only: open_source_file, netcdf_context
    use idmdfnselectormodule, only: idm_integrated
    type(ModelPackageInputsType), intent(inout) :: model_pkg_inputs
    integer(i4B), intent(in) :: iout
    type(NCFileVarsType), pointer :: nc_vars
    integer(I4B) :: itype, ipkg
 
    nc_vars => netcdf_context(model_pkg_inputs%modeltype, &
                              model_pkg_inputs%component_type, &
                              model_pkg_inputs%modelname, &
                              model_pkg_inputs%modelfname, iout)
    ! load package instances by type
    do itype = 1, size(model_pkg_inputs%pkglist)
      ! load package instances
      do ipkg = 1, model_pkg_inputs%pkglist(itype)%pnum
        if (idm_integrated(model_pkg_inputs%component_type, &
                           model_pkg_inputs%pkglist(itype)%subcomponent_type)) &
          then
          ! only load if model pkg can read from input context
          call input_load(model_pkg_inputs%component_type, &
                          model_pkg_inputs%pkglist(itype)%subcomponent_type, &
                          model_pkg_inputs%modelname, &
                          model_pkg_inputs%pkglist(itype)%pkgnames(ipkg), &
                          model_pkg_inputs%pkglist(itype)%pkgtype, &
                          model_pkg_inputs%pkglist(itype)%filenames(ipkg), &
                          model_pkg_inputs%modelfname, nc_vars, iout)
        else
          ! open input file for package parser
          model_pkg_inputs%pkglist(itype)%inunits(ipkg) = &
            open_source_file(model_pkg_inputs%pkglist(itype)%pkgtype, &
                             model_pkg_inputs%pkglist(itype)%filenames(ipkg), &
                             model_pkg_inputs%modelfname, iout)
        end if
      end do
    end do
 
    ! cleanup
    call nc_vars%destroy()
    deallocate (nc_vars)
    nullify (nc_vars)

Here is the call graph for this function:

Here is the caller graph for this function:

load_models()

subroutine, public idmloadmodule::load_models

(

integer(i4b), intent(in)

iout

)

Definition at line 217 of file IdmLoad.f90.

    use memoryhelpermodule, only: create_mem_path
    use memorymanagermodule, only: mem_setptr
    use characterstringmodule, only: characterstringtype
    use distributedsimmodule, only: distributedsimtype, get_dsim
    use simvariablesmodule, only: idm_context, simfile
    use modelpackageinputsmodule, only: modelpackageinputstype
    use sourcecommonmodule, only: idm_component_type, inlen_check
    use sourceloadmodule, only: load_modelnam
    integer(I4B), intent(in) :: iout
    type(DistributedSimType), pointer :: ds
    integer(I4B), dimension(:), pointer :: model_loadmask
    character(len=LENMEMPATH) :: input_mempath
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: mtypes !< model types
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: mfnames !< model file names
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: mnames !< model names
    character(len=LINELENGTH) :: mtype, mfname
    character(len=LENMODELNAME) :: mname
    type(ModelPackageInputsType), allocatable :: model_pkg_inputs
    integer(I4B) :: n
 
    ! get model mask
    ds => get_dsim()
    model_loadmask => ds%get_load_mask()
 
    ! set input memory path
    input_mempath = create_mem_path('SIM', 'NAM', idm_context)
 
    ! set pointers to input context model attribute arrays
    call mem_setptr(mtypes, 'MTYPE', input_mempath)
    call mem_setptr(mfnames, 'MFNAME', input_mempath)
    call mem_setptr(mnames, 'MNAME', input_mempath)
 
    do n = 1, size(mtypes)
      ! attributes for this model
      mtype = mtypes(n)
      mfname = mfnames(n)
      call inlen_check(mnames(n), mname, lenmodelname, 'MODELNAME')
 
      ! terminate if errors were detected
      if (count_errors() > 0) then
        call store_error_filename(simfile)
      end if
 
      ! load specified model inputs
      if (model_loadmask(n) > 0) then
        ! load model nam file
        call load_modelnam(mtype, mfname, mname, iout)
        ! create description of model packages
        allocate (model_pkg_inputs)
        call model_pkg_inputs%init(mtype, mfname, mname, iout)
        ! load packages
        call load_model_pkgs(model_pkg_inputs, iout)
        ! publish pkg info to input context
        call model_pkg_inputs%memload()
        ! cleanup
        call model_pkg_inputs%destroy()
        deallocate (model_pkg_inputs)
      end if
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

simnam_allocate()

subroutine idmloadmodule::simnam_allocate

Definition at line 645 of file IdmLoad.f90.

    use memoryhelpermodule, only: create_mem_path
    use memorymanagermodule, only: get_isize, mem_allocate
    use simvariablesmodule, only: idm_context
    use characterstringmodule, only: characterstringtype
    character(len=LENMEMPATH) :: input_mempath
    type(ModflowInputType) :: mf6_input
    type(InputParamDefinitionType), pointer :: idt
    integer(I4B) :: iparam, isize
 
    ! set memory path
    input_mempath = create_mem_path('SIM', 'NAM', idm_context)
    ! create description of input
    mf6_input = getmodflowinput('NAM6', 'SIM', 'NAM', 'SIM', 'NAM')
 
    ! allocate sim namfile parameters if not in input context
    do iparam = 1, size(mf6_input%param_dfns)
      ! assign param definition pointer
      idt => mf6_input%param_dfns(iparam)
      ! check if variable is already allocated
      call get_isize(idt%mf6varname, input_mempath, isize)
      if (isize < 0) then
        ! allocate and set parameter
        call allocate_simnam_param(input_mempath, idt)
      end if
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

simnam_load()

subroutine, public idmloadmodule::simnam_load

(

integer(i4b), intent(inout)

paramlog

)

Definition at line 441 of file IdmLoad.f90.

    use sourceloadmodule, only: load_simnam
    integer(I4B), intent(inout) :: paramlog
    ! load sim nam file
    call load_simnam()
    ! allocate any unallocated simnam params
    call simnam_allocate()
    ! read and set input parameter logging keyword
    paramlog = input_param_log()
    ! memload summary info
    call simnam_load_dim()

Here is the call graph for this function:

Here is the caller graph for this function:

simnam_load_dim()

subroutine idmloadmodule::simnam_load_dim

Definition at line 533 of file IdmLoad.f90.

    use memoryhelpermodule, only: create_mem_path
    use memorymanagermodule, only: mem_allocate, mem_setptr
    use simvariablesmodule, only: idm_context
    use characterstringmodule, only: characterstringtype
    character(len=LENMEMPATH) :: sim_mempath, simnam_mempath
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: mtypes !< model types
    type(CharacterStringType), dimension(:), contiguous, &
      pointer :: etypes !< model types
    integer(I4B), pointer :: nummodels
    integer(I4B), pointer :: numexchanges
 
    ! initialize
    nullify (nummodels)
    nullify (numexchanges)
 
    ! set memory paths
    sim_mempath = create_mem_path(component='SIM', context=idm_context)
    simnam_mempath = create_mem_path('SIM', 'NAM', idm_context)
 
    ! set pointers to loaded simnam arrays
    call mem_setptr(mtypes, 'MTYPE', simnam_mempath)
    call mem_setptr(etypes, 'EXGTYPE', simnam_mempath)
 
    ! allocate variables
    call mem_allocate(nummodels, 'NUMMODELS', sim_mempath)
    call mem_allocate(numexchanges, 'NUMEXCHANGES', sim_mempath)
 
    ! set values
    nummodels = size(mtypes)
    numexchanges = size(etypes)

Here is the call graph for this function:

Here is the caller graph for this function:

simtdis_load()

subroutine, public idmloadmodule::simtdis_load

Definition at line 456 of file IdmLoad.f90.

    use sourceloadmodule, only: load_simtdis
    ! load sim tdis file
    call load_simtdis()

Here is the call graph for this function:

Here is the caller graph for this function: