tsp.f90

Go to the documentation of this file.

!> @brief This module contains the base transport model type
!!
!! This module contains the base class for transport models.
!!
!<
 
module transportmodelmodule
  use kindmodule, only: dp, i4b
  use constantsmodule, only: lenftype, linelength, dzero, lenpakloc, &
                             lenmempath, lenvarname
  use simvariablesmodule, only: errmsg
  use numericalmodelmodule, only: numericalmodeltype
  use bndmodule, only: bndtype, getbndfromlist
  use tspicmodule, only: tspictype
  use tspfmimodule, only: tspfmitype
  use tspadvmodule, only: tspadvtype
  use tspssmmodule, only: tspssmtype
  use tspmvtmodule, only: tspmvttype
  use tspocmodule, only: tspoctype
  use tspobsmodule, only: tspobstype
  use budgetmodule, only: budgettype
  use matrixbasemodule
 
  implicit none
 
  private
 
  public :: transportmodeltype
 
  type, extends(numericalmodeltype) :: transportmodeltype
 
    ! Generalized transport package types common to either GWT or GWE
    type(tspadvtype), pointer :: adv => null() !< advection package
    type(tspfmitype), pointer :: fmi => null() !< flow model interface
    type(tspictype), pointer :: ic => null() !< initial conditions package
    type(tspmvttype), pointer :: mvt => null() !< mover transport package
    type(tspobstype), pointer :: obs => null() !< observation package
    type(tspoctype), pointer :: oc => null() !< output control package
    type(tspssmtype), pointer :: ssm => null() !< source sink mixing package
    type(budgettype), pointer :: budget => null() !< budget object
    integer(I4B), pointer :: infmi => null() ! unit number FMI
    integer(I4B), pointer :: inadv => null() !< unit number ADV
    integer(I4B), pointer :: inic => null() !< unit number IC
    integer(I4B), pointer :: inmvt => null() !< unit number MVT
    integer(I4B), pointer :: inoc => null() !< unit number OC
    integer(I4B), pointer :: inobs => null() !< unit number OBS
 
    integer(I4B), pointer :: inssm => null() !< unit number SSM
    real(dp), pointer :: eqnsclfac => null() !< constant factor by which all terms in the model's governing equation are scaled (divided) for formulation and solution
    ! Labels that will be defined
    character(len=LENVARNAME) :: tsptype = '' !< "solute" or "heat"
    character(len=LENVARNAME) :: depvartype = '' !< "concentration" or "temperature"
    character(len=LENVARNAME) :: depvarunit = '' !< "mass" or "energy"
    character(len=LENVARNAME) :: depvarunitabbrev = '' !< "M" or "E"
 
  contains
 
    ! -- public
    procedure, public :: tsp_cr
    procedure, public :: tsp_df
    procedure, public :: tsp_da
    procedure, public :: tsp_ac
    procedure, public :: tsp_mc
    procedure, public :: tsp_ar
    procedure, public :: tsp_rp
    procedure, public :: tsp_ad
    procedure, public :: tsp_fc
    procedure, public :: tsp_cc
    procedure, public :: tsp_cq
    procedure, public :: tsp_bd
    procedure, public :: model_ot => tsp_ot
    procedure, public :: tsp_ot_flow
    procedure, public :: tsp_ot_dv
    procedure, public :: allocate_tsp_scalars
    procedure, public :: set_tsp_labels
    procedure, public :: ftype_check
    ! -- private
    procedure, private :: tsp_ot_obs
    procedure, private :: tsp_ot_flowja
    procedure, private :: tsp_ot_bdsummary
    procedure, private :: create_tsp_packages
    procedure, private :: log_namfile_options
 
  end type transportmodeltype
 
contains
 
  !> @brief Create a new generalized transport model object
  !!
  !! Create a new transport model that will be further refined into GWT or GWE
  !<
  subroutine tsp_cr(this, filename, id, modelname, macronym, indis)
    ! -- modules
    use memoryhelpermodule, only: create_mem_path
    use memorymanagerextmodule, only: mem_set_value
    use simvariablesmodule, only: idm_context
    use gwfnaminputmodule, only: gwfnamparamfoundtype
    use budgetmodule, only: budget_cr
    ! -- dummy
    class(transportmodeltype) :: this
    character(len=*), intent(in) :: filename
    integer(I4B), intent(in) :: id
    integer(I4B), intent(inout) :: indis
    character(len=*), intent(in) :: modelname
    character(len=*), intent(in) :: macronym
    ! -- local
    character(len=LENMEMPATH) :: input_mempath
    character(len=LINELENGTH) :: lst_fname
    type(gwfnamparamfoundtype) :: found
    !
    ! -- Assign values
    this%filename = filename
    this%name = modelname
    this%id = id
    this%macronym = macronym
    !
    ! -- set input model namfile memory path
    input_mempath = create_mem_path(modelname, 'NAM', idm_context)
    !
    ! -- copy option params from input context
    call mem_set_value(lst_fname, 'LIST', input_mempath, found%list)
    call mem_set_value(this%iprpak, 'PRINT_INPUT', input_mempath, &
                       found%print_input)
    call mem_set_value(this%iprflow, 'PRINT_FLOWS', input_mempath, &
                       found%print_flows)
    call mem_set_value(this%ipakcb, 'SAVE_FLOWS', input_mempath, found%save_flows)
    !
    ! -- create the list file
    call this%create_lstfile(lst_fname, filename, found%list, &
                             'TRANSPORT MODEL ('//trim(macronym)//')')
    !
    ! -- activate save_flows if found
    if (found%save_flows) then
      this%ipakcb = -1
    end if
    !
    ! -- log set options
    if (this%iout > 0) then
      call this%log_namfile_options(found)
    end if
    !
    ! -- Create utility objects
    call budget_cr(this%budget, this%name)
    !
    ! -- create model packages
    call this%create_tsp_packages(indis)
  end subroutine tsp_cr
 
  !> @brief Generalized transport model define model
  !!
  !! This subroutine extended by either GWT or GWE.  This routine calls the
  !! define (df) routines for each attached package and sets variables and
  !! pointers.
  !<
  subroutine tsp_df(this)
    ! -- dummy
    class(transportmodeltype) :: this
  end subroutine tsp_df
 
  !> @brief Generalized transport model add connections
  !!
  !! This subroutine extended by either GWT or GWE.  This routine adds the
  !! internal connections of this model to the sparse matrix
  !<
  subroutine tsp_ac(this, sparse)
    ! -- modules
    use sparsemodule, only: sparsematrix
    ! -- dummy
    class(transportmodeltype) :: this
    type(sparsematrix), intent(inout) :: sparse
  end subroutine tsp_ac
 
  !> @brief Generalized transport model map coefficients
  !!
  !! This subroutine extended by either GWT or GWE.  This routine maps the
  !! positions of this models connections in the numerical solution coefficient
  !! matrix.
  !<
  subroutine tsp_mc(this, matrix_sln)
    ! -- dummy
    class(transportmodeltype) :: this
    class(matrixbasetype), pointer :: matrix_sln !< global system matrix
  end subroutine tsp_mc
 
  !> @brief Generalized transport model allocate and read
  !!
  !! This subroutine extended by either GWT or GWE.  This routine calls
  !! the allocate and reads (ar) routines of attached packages and allocates
  !! memory for arrays required by the model object.
  !<
  subroutine tsp_ar(this)
    ! -- dummy
    class(transportmodeltype) :: this
  end subroutine tsp_ar
 
  !> @brief Generalized transport model read and prepare
  !!
  !! This subroutine extended by either GWT or GWE.  This routine calls
  !! the read and prepare (rp) routines of attached packages.
  !<
  subroutine tsp_rp(this)
    ! -- dummy
    class(transportmodeltype) :: this
  end subroutine tsp_rp
 
  !> @brief Generalized transport model time step advance
  !!
  !! This subroutine extended by either GWT or GWE.  This routine calls
  !! the advance time step (ad) routines of attached packages.
  !<
  subroutine tsp_ad(this)
    ! -- dummy
    class(transportmodeltype) :: this
  end subroutine tsp_ad
 
  !> @brief Generalized transport model fill coefficients
  !!
  !! This subroutine extended by either GWT or GWE.  This routine calls
  !! the fill coefficients (fc) routines of attached packages.
  !<
  subroutine tsp_fc(this, kiter, matrix_sln, inwtflag)
    ! -- dummy
    class(transportmodeltype) :: this
    integer(I4B), intent(in) :: kiter
    class(matrixbasetype), pointer :: matrix_sln
    integer(I4B), intent(in) :: inwtflag
  end subroutine tsp_fc
 
  !> @brief Generalized transport model final convergence check
  !!
  !! This subroutine extended by either GWT or GWE.  This routine calls
  !! the convergence check (cc) routines of attached packages.
  !<
  subroutine tsp_cc(this, innertot, kiter, iend, icnvgmod, cpak, ipak, dpak)
    ! -- dummy
    class(transportmodeltype) :: this
    integer(I4B), intent(in) :: innertot
    integer(I4B), intent(in) :: kiter
    integer(I4B), intent(in) :: iend
    integer(I4B), intent(in) :: icnvgmod
    character(len=LENPAKLOC), intent(inout) :: cpak
    integer(I4B), intent(inout) :: ipak
    real(DP), intent(inout) :: dpak
  end subroutine tsp_cc
 
  !> @brief Generalized transport model calculate flows
  !!
  !! This subroutine extended by either GWT or GWE.  This routine calculates
  !! intercell flows (flowja)
  !<
  subroutine tsp_cq(this, icnvg, isuppress_output)
    ! -- dummy
    class(transportmodeltype) :: this
    integer(I4B), intent(in) :: icnvg
    integer(I4B), intent(in) :: isuppress_output
  end subroutine tsp_cq
 
  !> @brief Generalized transport model budget
  !!
  !! This subroutine extended by either GWT or GWE. This routine calculates
  !! package contributions to model budget
  !<
  subroutine tsp_bd(this, icnvg, isuppress_output)
    ! -- dummy
    class(transportmodeltype) :: this
    integer(I4B), intent(in) :: icnvg
    integer(I4B), intent(in) :: isuppress_output
  end subroutine tsp_bd
 
  !> @brief Generalized transport model output routine
  !!
  !! Generalized transport model output
  !<
  subroutine tsp_ot(this)
    ! -- modules
    use tdismodule, only: kstp, kper, tdis_ot, endofperiod
    ! -- dummy
    class(transportmodeltype) :: this
    ! -- local
    integer(I4B) :: idvsave
    integer(I4B) :: idvprint
    integer(I4B) :: icbcfl
    integer(I4B) :: icbcun
    integer(I4B) :: ibudfl
    integer(I4B) :: ipflag
    ! -- formats
    character(len=*), parameter :: fmtnocnvg = &
      "(1X,/9X,'****FAILED TO MEET SOLVER CONVERGENCE CRITERIA IN TIME STEP ', &
      &I0,' OF STRESS PERIOD ',I0,'****')"
    !
    ! -- Set write and print flags
    idvsave = 0
    idvprint = 0
    icbcfl = 0
    ibudfl = 0
    if (this%oc%oc_save(trim(this%depvartype))) idvsave = 1
    if (this%oc%oc_print(trim(this%depvartype))) idvprint = 1
    if (this%oc%oc_save('BUDGET')) icbcfl = 1
    if (this%oc%oc_print('BUDGET')) ibudfl = 1
    icbcun = this%oc%oc_save_unit('BUDGET')
    !
    ! -- Override ibudfl and idvprint flags for nonconvergence
    !    and end of period
    ibudfl = this%oc%set_print_flag('BUDGET', this%icnvg, endofperiod)
    idvprint = this%oc%set_print_flag(trim(this%depvartype), &
                                      this%icnvg, endofperiod)
    !
    ! -- Calculate and save observations
    call this%tsp_ot_obs()
    !
    ! -- Save and print flows
    call this%tsp_ot_flow(icbcfl, ibudfl, icbcun)
    !
    ! -- Save and print dependent variables
    call this%tsp_ot_dv(idvsave, idvprint, ipflag)
    !
    ! -- Print budget summaries
    call this%tsp_ot_bdsummary(ibudfl, ipflag)
    !
    ! -- Timing Output; if any dependent variables or budgets
    !    are printed, then ipflag is set to 1.
    if (ipflag == 1) call tdis_ot(this%iout)
    !
    ! -- Write non-convergence message
    if (this%icnvg == 0) then
      write (this%iout, fmtnocnvg) kstp, kper
    end if
  end subroutine tsp_ot
 
  !> @brief Generalized transport model output routine
  !!
  !! Calculate and save observations
  !<
  subroutine tsp_ot_obs(this)
    class(transportmodeltype) :: this
    class(bndtype), pointer :: packobj
    integer(I4B) :: ip
    ! -- Calculate and save observations
    call this%obs%obs_bd()
    call this%obs%obs_ot()
    !
    ! -- Calculate and save package obserations
    do ip = 1, this%bndlist%Count()
      packobj => getbndfromlist(this%bndlist, ip)
      call packobj%bnd_bd_obs()
      call packobj%bnd_ot_obs()
    end do
    !
  end subroutine tsp_ot_obs
 
  !> @brief Generalized transport model output routine
  !!
  !! Save and print flows
  !<
  subroutine tsp_ot_flow(this, icbcfl, ibudfl, icbcun)
    ! -- dummy
    class(transportmodeltype) :: this
    integer(I4B), intent(in) :: icbcfl
    integer(I4B), intent(in) :: ibudfl
    integer(I4B), intent(in) :: icbcun
    ! -- local
    class(bndtype), pointer :: packobj
    integer(I4B) :: ip
    !
    ! -- Save TSP flows
    call this%tsp_ot_flowja(this%nja, this%flowja, icbcfl, icbcun)
    if (this%infmi > 0) call this%fmi%fmi_ot_flow(icbcfl, icbcun)
    if (this%inssm > 0) then
      call this%ssm%ssm_ot_flow(icbcfl=icbcfl, ibudfl=0, icbcun=icbcun)
    end if
    !
    do ip = 1, this%bndlist%Count()
      packobj => getbndfromlist(this%bndlist, ip)
      call packobj%bnd_ot_model_flows(icbcfl=icbcfl, ibudfl=0, icbcun=icbcun)
    end do
    !
    ! -- Save advanced package flows
    do ip = 1, this%bndlist%Count()
      packobj => getbndfromlist(this%bndlist, ip)
      call packobj%bnd_ot_package_flows(icbcfl=icbcfl, ibudfl=0)
    end do
    if (this%inmvt > 0) then
      call this%mvt%mvt_ot_saveflow(icbcfl, ibudfl)
    end if
    !
    ! -- Print Model (GWT or GWE) flows
    !    no need to print flowja
    !    no need to print mst
    !    no need to print fmi
    if (this%inssm > 0) then
      call this%ssm%ssm_ot_flow(icbcfl=icbcfl, ibudfl=ibudfl, icbcun=0)
    end if
    do ip = 1, this%bndlist%Count()
      packobj => getbndfromlist(this%bndlist, ip)
      call packobj%bnd_ot_model_flows(icbcfl=icbcfl, ibudfl=ibudfl, icbcun=0)
    end do
    !
    ! -- Print advanced package flows
    do ip = 1, this%bndlist%Count()
      packobj => getbndfromlist(this%bndlist, ip)
      call packobj%bnd_ot_package_flows(icbcfl=0, ibudfl=ibudfl)
    end do
    !
    if (this%inmvt > 0) then
      call this%mvt%mvt_ot_printflow(icbcfl, ibudfl)
    end if
    !
  end subroutine tsp_ot_flow
 
  !> @brief Generalized transport model output routine
  !!
  !! Write intercell flows for the transport model
  !<
  subroutine tsp_ot_flowja(this, nja, flowja, icbcfl, icbcun)
    ! -- dummy
    class(transportmodeltype) :: this
    integer(I4B), intent(in) :: nja
    real(DP), dimension(nja), intent(in) :: flowja
    integer(I4B), intent(in) :: icbcfl
    integer(I4B), intent(in) :: icbcun
    ! -- local
    integer(I4B) :: ibinun
    ! -- formats
    !
    ! -- Set unit number for binary output
    if (this%ipakcb < 0) then
      ibinun = icbcun
    elseif (this%ipakcb == 0) then
      ibinun = 0
    else
      ibinun = this%ipakcb
    end if
    if (icbcfl == 0) ibinun = 0
    !
    ! -- Write the face flows if requested
    if (ibinun /= 0) then
      call this%dis%record_connection_array(flowja, ibinun, this%iout)
    end if
  end subroutine tsp_ot_flowja
 
  !> @brief Generalized transport model output routine
  !!
  !! Loop through attached packages saving and printing dependent variables
  !<
  subroutine tsp_ot_dv(this, idvsave, idvprint, ipflag)
    class(transportmodeltype) :: this
    integer(I4B), intent(in) :: idvsave
    integer(I4B), intent(in) :: idvprint
    integer(I4B), intent(inout) :: ipflag
    class(bndtype), pointer :: packobj
    integer(I4B) :: ip
    !
    ! -- Print advanced package dependent variables
    do ip = 1, this%bndlist%Count()
      packobj => getbndfromlist(this%bndlist, ip)
      call packobj%bnd_ot_dv(idvsave, idvprint)
    end do
    !
    ! -- Save head and print head
    call this%oc%oc_ot(ipflag)
  end subroutine tsp_ot_dv
 
  !> @brief Generalized transport model output budget summary
  !!
  !! Loop through attached packages and write budget summaries
  !<
  subroutine tsp_ot_bdsummary(this, ibudfl, ipflag)
    use tdismodule, only: kstp, kper, totim, delt
    class(transportmodeltype) :: this
    integer(I4B), intent(in) :: ibudfl
    integer(I4B), intent(inout) :: ipflag
    class(bndtype), pointer :: packobj
    integer(I4B) :: ip
    !
    ! -- Package budget summary
    do ip = 1, this%bndlist%Count()
      packobj => getbndfromlist(this%bndlist, ip)
      call packobj%bnd_ot_bdsummary(kstp, kper, this%iout, ibudfl)
    end do
    !
    ! -- Mover budget summary
    if (this%inmvt > 0) then
      call this%mvt%mvt_ot_bdsummary(ibudfl)
    end if
    !
    ! -- Model budget summary
    call this%budget%finalize_step(delt)
    if (ibudfl /= 0) then
      ipflag = 1
      call this%budget%budget_ot(kstp, kper, this%iout)
    end if
    !
    ! -- Write to budget csv
    call this%budget%writecsv(totim)
  end subroutine tsp_ot_bdsummary
 
  !> @brief Allocate scalar variables for transport model
  !!
  !!  Method to allocate memory for non-allocatable members.
  !<
  subroutine allocate_tsp_scalars(this, modelname)
    ! -- modules
    use memorymanagermodule, only: mem_allocate
    ! -- dummy
    class(transportmodeltype) :: this
    character(len=*), intent(in) :: modelname
    !
    ! -- allocate members from (grand)parent class
    call this%NumericalModelType%allocate_scalars(modelname)
    !
    ! -- allocate members that are part of model class
    call mem_allocate(this%inic, 'INIC', this%memoryPath)
    call mem_allocate(this%infmi, 'INFMI', this%memoryPath)
    call mem_allocate(this%inmvt, 'INMVT', this%memoryPath)
    call mem_allocate(this%inadv, 'INADV', this%memoryPath)
    call mem_allocate(this%inssm, 'INSSM', this%memoryPath)
    call mem_allocate(this%inoc, 'INOC ', this%memoryPath)
    call mem_allocate(this%inobs, 'INOBS', this%memoryPath)
    call mem_allocate(this%eqnsclfac, 'EQNSCLFAC', this%memoryPath)
    !
    this%inic = 0
    this%infmi = 0
    this%inmvt = 0
    this%inadv = 0
    this%inssm = 0
    this%inoc = 0
    this%inobs = 0
    this%eqnsclfac = dzero
  end subroutine allocate_tsp_scalars
 
  !> @brief Define the labels corresponding to the flavor of
  !! transport model
  !!
  !! Set variable names according to type of transport model
  !<
  subroutine set_tsp_labels(this, tsptype, depvartype, depvarunit, &
                            depvarunitabbrev)
    class(transportmodeltype) :: this
    character(len=*), intent(in), pointer :: tsptype !< type of model, default is GWT (alternative is GWE)
    character(len=*), intent(in) :: depvartype !< dependent variable type, default is "CONCENTRATION"
    character(len=*), intent(in) :: depvarunit !< units of dependent variable for writing to list file
    character(len=*), intent(in) :: depvarunitabbrev !< abbreviation of associated units
    !
    ! -- Set the model type
    this%tsptype = tsptype
    !
    ! -- Set the type of dependent variable being solved for
    this%depvartype = depvartype
    !
    ! -- Set the units associated with the dependent variable
    this%depvarunit = depvarunit
    !
    ! -- Set the units abbreviation
    this%depvarunitabbrev = depvarunitabbrev
  end subroutine set_tsp_labels
 
  !> @brief Deallocate memory
  !!
  !! Deallocate memory at conclusion of model run
  !<
  subroutine tsp_da(this)
    ! -- modules
    use memorymanagermodule, only: mem_deallocate
    ! -- dummy
    class(transportmodeltype) :: this
    ! -- local
    !
    ! -- Scalars
    call mem_deallocate(this%inic)
    call mem_deallocate(this%infmi)
    call mem_deallocate(this%inadv)
    call mem_deallocate(this%inssm)
    call mem_deallocate(this%inmvt)
    call mem_deallocate(this%inoc)
    call mem_deallocate(this%inobs)
    call mem_deallocate(this%eqnsclfac)
  end subroutine tsp_da
 
  !> @brief Generalized transport model routine
  !!
  !! Check to make sure required input files have been specified
  !<
  subroutine ftype_check(this, indis, inmst)
    ! -- modules
    use constantsmodule, only: linelength
    use simmodule, only: store_error, count_errors, store_error_filename
    ! -- dummy
    class(transportmodeltype) :: this
    integer(I4B), intent(in) :: indis
    integer(I4B), intent(in) :: inmst !< representative of both inmst and inest depending on model type
    ! -- local
    character(len=LINELENGTH) :: errmsg
    !
    ! -- Check for IC6, DIS(u), and MST. Stop if not present.
    if (this%inic == 0) then
      write (errmsg, '(a)') &
        'Initial conditions (IC6) package not specified.'
      call store_error(errmsg)
    end if
    if (indis == 0) then
      write (errmsg, '(a)') &
        'Discretization (DIS6 or DISU6) package not specified.'
      call store_error(errmsg)
    end if
    if (inmst == 0) then
      write (errmsg, '(a)') 'Mass storage and transfer (MST6) &
        &package not specified.'
      call store_error(errmsg)
    end if
    !
    if (count_errors() > 0) then
      write (errmsg, '(a)') 'Required package(s) not specified.'
      call store_error(errmsg)
      call store_error_filename(this%filename)
    end if
  end subroutine ftype_check
 
  !> @brief Write model name file options to list file
  !<
  subroutine log_namfile_options(this, found)
    ! -- modules
    use gwfnaminputmodule, only: gwfnamparamfoundtype
    ! -- dummy
    class(transportmodeltype) :: this
    type(gwfnamparamfoundtype), intent(in) :: found
    !
    write (this%iout, '(1x,a)') 'NAMEFILE OPTIONS:'
    !
    if (found%newton) then
      write (this%iout, '(4x,a)') &
        'NEWTON-RAPHSON method enabled for the model.'
      if (found%under_relaxation) then
        write (this%iout, '(4x,a,a)') &
          'NEWTON-RAPHSON UNDER-RELAXATION based on the bottom ', &
          'elevation of the model will be applied to the model.'
      end if
    end if
    !
    if (found%print_input) then
      write (this%iout, '(4x,a)') 'STRESS PACKAGE INPUT WILL BE PRINTED '// &
        'FOR ALL MODEL STRESS PACKAGES'
    end if
    !
    if (found%print_flows) then
      write (this%iout, '(4x,a)') 'PACKAGE FLOWS WILL BE PRINTED '// &
        'FOR ALL MODEL PACKAGES'
    end if
    !
    if (found%save_flows) then
      write (this%iout, '(4x,a)') &
        'FLOWS WILL BE SAVED TO BUDGET FILE SPECIFIED IN OUTPUT CONTROL'
    end if
    !
    write (this%iout, '(1x,a)') 'END NAMEFILE OPTIONS:'
  end subroutine log_namfile_options
 
  !> @brief Source package info and begin to process
  !<
  subroutine create_tsp_packages(this, indis)
    ! -- modules
    use constantsmodule, only: linelength, lenpackagename
    use characterstringmodule, only: characterstringtype
    use memorymanagermodule, only: mem_setptr
    use memoryhelpermodule, only: create_mem_path
    use simvariablesmodule, only: idm_context
    use dismodule, only: dis_cr
    use disvmodule, only: disv_cr
    use disumodule, only: disu_cr
    use tspicmodule, only: ic_cr
    use tspfmimodule, only: fmi_cr
    use tspadvmodule, only: adv_cr
    use tspssmmodule, only: ssm_cr
    use tspmvtmodule, only: mvt_cr
    use tspocmodule, only: oc_cr
    use tspobsmodule, only: tsp_obs_cr
    ! -- dummy
    class(transportmodeltype) :: this
    integer(I4B), intent(inout) :: indis ! DIS enabled flag
    ! -- local
    type(characterstringtype), dimension(:), contiguous, &
      pointer :: pkgtypes => null()
    type(characterstringtype), dimension(:), contiguous, &
      pointer :: pkgnames => null()
    type(characterstringtype), dimension(:), contiguous, &
      pointer :: mempaths => null()
    integer(I4B), dimension(:), contiguous, &
      pointer :: inunits => null()
    character(len=LENMEMPATH) :: model_mempath
    character(len=LENFTYPE) :: pkgtype
    character(len=LENPACKAGENAME) :: pkgname
    character(len=LENMEMPATH) :: mempath
    integer(I4B), pointer :: inunit
    integer(I4B) :: n
    character(len=LENMEMPATH) :: mempathic = ''
    !
    ! -- Initialize
    indis = 0
    !
    ! -- Set input memory paths, input/model and input/model/namfile
    model_mempath = create_mem_path(component=this%name, context=idm_context)
    !
    ! -- Set pointers to model path package info
    call mem_setptr(pkgtypes, 'PKGTYPES', model_mempath)
    call mem_setptr(pkgnames, 'PKGNAMES', model_mempath)
    call mem_setptr(mempaths, 'MEMPATHS', model_mempath)
    call mem_setptr(inunits, 'INUNITS', model_mempath)
    !
    do n = 1, size(pkgtypes)
      !
      ! -- Attributes for this input package
      pkgtype = pkgtypes(n)
      pkgname = pkgnames(n)
      mempath = mempaths(n)
      inunit => inunits(n)
      !
      ! -- Create dis package as it is a prerequisite for other packages
      select case (pkgtype)
      case ('DIS6')
        indis = 1
        call dis_cr(this%dis, this%name, mempath, indis, this%iout)
      case ('DISV6')
        indis = 1
        call disv_cr(this%dis, this%name, mempath, indis, this%iout)
      case ('DISU6')
        indis = 1
        call disu_cr(this%dis, this%name, mempath, indis, this%iout)
      case ('IC6')
        this%inic = 1
        mempathic = mempath
      case ('FMI6')
        this%infmi = inunit
      case ('MVT6', 'MVE6')
        this%inmvt = inunit
      case ('ADV6')
        this%inadv = inunit
      case ('SSM6')
        this%inssm = inunit
      case ('OC6')
        this%inoc = inunit
      case ('OBS6')
        this%inobs = inunit
        !case default
        ! TODO
      end select
    end do
    !
    ! -- Create packages that are tied directly to model
    call ic_cr(this%ic, this%name, mempathic, this%inic, this%iout, this%dis, &
               this%depvartype)
    call fmi_cr(this%fmi, this%name, this%infmi, this%iout, this%eqnsclfac, &
                this%depvartype)
    call adv_cr(this%adv, this%name, this%inadv, this%iout, this%fmi, &
                this%eqnsclfac)
    call ssm_cr(this%ssm, this%name, this%inssm, this%iout, this%fmi, &
                this%eqnsclfac, this%depvartype)
    call mvt_cr(this%mvt, this%name, this%inmvt, this%iout, this%fmi, &
                this%eqnsclfac, this%depvartype)
    call oc_cr(this%oc, this%name, this%inoc, this%iout)
    call tsp_obs_cr(this%obs, this%inobs, this%depvartype)
  end subroutine create_tsp_packages
 
end module transportmodelmodule