ParameterLists.f90

!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!
!                              Copyright (C) 2012                              !
!                   The Regents of the University of Michigan                  !
!              MPACT Development Group and Prof. Thomas J. Downar              !
!                             All rights reserved.                             !
!                                                                              !
! Copyright is reserved to the University of Michigan for purposes of          !
! controlled dissemination, commercialization through formal licensing, or     !
! other disposition. The University of Michigan nor any of their employees,    !
! makes any warranty, express or implied, or assumes any liability or          !
! responsibility for the accuracy, completeness, or usefulness of any          !
! information, apparatus, product, or process disclosed, or represents that    !
! its use would not infringe privately owned rights. Reference herein to any   !
! specific commercial products, process, or service by trade name, trademark,  !
! manufacturer, or otherwise, does not necessarily constitute or imply its     !
! endorsement, recommendation, or favoring by the University of Michigan.      !
!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!
!> @brief This module defines a parameter type object.
!>
!> The purpose of this object is to facilitate encapsulation of an arbitrary
!> number of parameters that may have varying types of values into one object
!> which can be more easily passed around between different code.
!>
!> The object is self-referential which means it can contain objects of the
!> same type as itself. This allows for nested lists of parameters. A parameter
!> is defined by a name, a datatype, an optional description, and a value.
!> The value attribute is polymorphic so that it can be a single integer
!> or an array of double precision reals or a list of other parameters.
!>
!> This module only makes public the base parameter type and it's assignment
!> operation and the exception handler for the module. The base parameter
!> type includes methods for initialization to a specific type, editing the
!> contents of parameter, clearing the contents of a parameter, getting or
!> setting values of existing parameters (or subparameters) and the ability to
!> add or delete parameters nested within other parameters.
!>
!> The parameters are searched and matched using the name attribute and the
!> matching is not case sensitive.
!>
!> The supported extended parameter types accept the following types of values:
!>  - a list of parameters
!>  - scalar logicals
!>  - @ref Strings::StringType "StringTypes"
!>  - scalar 32-bit integers
!>  - scalar 64-bit integers
!>  - scalar single precision reals
!>  - scalar double precision reals
!>  - 1-D arrays of logicals
!>  - 1-D arrays of 32-bit integers
!>  - 1-D arrays of 64-bit integers
!>  - 1-D arrays of single precision reals
!>  - 1-D arrays of double precision reals
!>  - 1-D arrays of "StringTypes"
!>  - 2-D arrays of 32-bit integers
!>  - 2-D arrays of 64-bit integers
!>  - 2-D arrays of single precision reals
!>  - 2-D arrays of double precision reals
!>  - 2-D arrays of "StringTypes"
!>  - 3-D arrays of 32-bit integers
!>  - 3-D arrays of 64-bit integers
!>  - 3-D arrays of single precision reals
!>  - 3-D arrays of double precision reals
!>
!> @par Module Dependencies
!>  - @ref IntrType "IntrType": @copybrief IntrType
!>  - @ref Strings "Strings": @copybrief Strings
!>  - @ref ExceptionHandler "ExceptionHandler": @copybrief ExceptionHandler
!>  - @ref IO_Strings "IO_Strings": @copybrief IO_Strings
!>  - @ref UnitTest "UnitTest": @copybrief UnitTest
!>
!> @par EXAMPLE
!> @code
!> PROGRAM
!>
!>   IMPLICIT NONE
!>
!>
!> END PROGRAM
!> @endcode
!>
!> @author Brendan Kochunas and Dan Jabaay and Benjamin Collins
!>   @date 07/26/2012
!> @par Revisions:
!>   (08/14/2012) - Dan Jabaay
!>   - Expanded functionality to scalar, one, two, and three dimensional arrays
!>     of the parameter types listed above.
!>   (03/07/2013) - Benjamin Collins
!>   - Added has function to return if the parameter list has a given parameter
!>   (10/22/2013) - Dan Jabaay
!>   - Added the %verify subroutine for validating two parameter lists and then
!>     checking that all of the values in the parameter list are equal.
!>   (05/18/2016) - Dan Jabaay
!>   - Added the %getString subroutine that returns any parameter as a string
!>     of the same dimension.  (e.g. will return a 1-D array of reals as a 1-D
!>     array of strings.)
!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++!
MODULE ParameterLists
#include "UnitTest.h"
  USE ISO_FORTRAN_ENV
  USE UnitTest
  USE IntrType
  USE Strings
  USE ExceptionHandler
  USE IO_Strings
  USE FileType_XML
#ifdef HAVE_ForTeuchos
  USE ForTeuchos_ParameterList
#endif

  IMPLICIT NONE
  PRIVATE !Default private for module contents
!
! List of Public items
  PUBLIC :: eParams
  PUBLIC :: ParamType
  PUBLIC :: ASSIGNMENT(=)
  PUBLIC :: OPERATOR(==)

  PUBLIC :: char_to_int_array
  PUBLIC :: char_to_double_array
  PUBLIC :: char_to_string_array

  !> The module name
  CHARACTER(LEN=*),PARAMETER :: modName='PARAMETERLISTS'
  INTEGER(SIK),PARAMETER :: MAX_1D_LEN=10

  !> Exception handler for the module
  TYPE(ExceptionHandlerType),SAVE :: eParams

  !> @brief Derived type for a parameter object
  !>
  !> This is an object which encapsulates a polymorphic value which so that the
  !> parameter value can be any number of things e.g.  a real scalar, an integer
  !> array, a logical, a string, etc.
  !>
  !> This type should not have an @c init operation as it logically does not
  !> make any sense. For all extended types the @c edit and @c clear methods
  !> should be overwritten.
  TYPE :: ParamType
    !> @brief The name of the parameter
    !>
    !> Set through input arguments
    TYPE(StringType) :: name
    !> @brief The data type for the parameter
    !>
    !> Set internally.
    TYPE(StringType) :: dataType
    !> An optional description for the parameter
    TYPE(StringType) :: description
    !> @brief The parameter value
    !>
    !> This is only allocated for variables of TYPE(ParamType) for any
    !> extended type it is the additional attribute that should be
    !> accessed.
    CLASS(ParamType),POINTER :: pdat => NULL()
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::init_ParamType_List
      !> @copydoc ParameterLists::init_ParamType_List
      PROCEDURE,PASS,PRIVATE :: initParamList => init_ParamType_List
      !> @copybrief ParameterLists::init_ParamType_SSK
      !> @copydoc ParameterLists::init_ParamType_SSK
      PROCEDURE,PASS,PRIVATE :: initSSK => init_ParamType_SSK
      !> @copybrief ParameterLists::init_ParamType_SDK
      !> @copydoc ParameterLists::init_ParamType_SDK
      PROCEDURE,PASS,PRIVATE :: initSDK => init_ParamType_SDK
      !> @copybrief ParameterLists::init_ParamType_SNK
      !> @copydoc ParameterLists::init_ParamType_SNK
      PROCEDURE,PASS,PRIVATE :: initSNK => init_ParamType_SNK
      !> @copybrief ParameterLists::init_ParamType_SLK
      !> @copydoc ParameterLists::init_ParamType_SLK
      PROCEDURE,PASS,PRIVATE :: initSLK => init_ParamType_SLK
      !> @copybrief ParameterLists::init_ParamType_SBK
      !> @copydoc ParameterLists::init_ParamType_SBK
      PROCEDURE,PASS,PRIVATE :: initSBK => init_ParamType_SBK
      !> @copybrief ParameterLists::init_ParamType_STR
      !> @copydoc ParameterLists::init_ParamType_STR
      PROCEDURE,PASS,PRIVATE :: initSTR => init_ParamType_STR
      !> @copybrief ParameterLists::init_ParamType_CHAR
      !> @copydoc ParameterLists::init_ParamType_CHAR
      PROCEDURE,PASS,PRIVATE :: initCHAR => init_ParamType_CHAR
      !> @copybrief ParameterLists::init_ParamType_SSK_a1
      !> @copydoc ParameterLists::init_ParamType_SSK_a1
      PROCEDURE,PASS,PRIVATE :: initSSKa1 => init_ParamType_SSK_a1
      !> @copybrief ParameterLists::init_ParamType_SDK_a1
      !> @copydoc ParameterLists::init_ParamType_SDK_a1
      PROCEDURE,PASS,PRIVATE :: initSDKa1 => init_ParamType_SDK_a1
      !> @copybrief ParameterLists::init_ParamType_SNK_a1
      !> @copydoc ParameterLists::init_ParamType_SNK_a1
      PROCEDURE,PASS,PRIVATE :: initSNKa1 => init_ParamType_SNK_a1
      !> @copybrief ParameterLists::init_ParamType_SLK_a1
      !> @copydoc ParameterLists::init_ParamType_SLK_a1
      PROCEDURE,PASS,PRIVATE :: initSLKa1 => init_ParamType_SLK_a1
      !> @copybrief ParameterLists::init_ParamType_SBK_a1
      !> @copydoc ParameterLists::init_ParamType_SBK_a1
      PROCEDURE,PASS,PRIVATE :: initSBKa1 => init_ParamType_SBK_a1
      !> @copybrief ParameterLists::init_ParamType_STR_a1
      !> @copydoc ParameterLists::init_ParamType_STR_a1
      PROCEDURE,PASS,PRIVATE :: initSTRa1 => init_ParamType_STR_a1
      !> @copybrief ParameterLists::init_ParamType_SSK_a2
      !> @copydoc ParameterLists::init_ParamType_SSK_a2
      PROCEDURE,PASS,PRIVATE :: initSSKa2 => init_ParamType_SSK_a2
      !> @copybrief ParameterLists::init_ParamType_SDK_a2
      !> @copydoc ParameterLists::init_ParamType_SDK_a2
      PROCEDURE,PASS,PRIVATE :: initSDKa2 => init_ParamType_SDK_a2
      !> @copybrief ParameterLists::init_ParamType_SNK_a2
      !> @copydoc ParameterLists::init_ParamType_SNK_a2
      PROCEDURE,PASS,PRIVATE :: initSNKa2 => init_ParamType_SNK_a2
      !> @copybrief ParameterLists::init_ParamType_SLK_a2
      !> @copydoc ParameterLists::init_ParamType_SLK_a2
      PROCEDURE,PASS,PRIVATE :: initSLKa2 => init_ParamType_SLK_a2
      !> @copybrief ParameterLists::init_ParamType_STR_a2
      !> @copydoc ParameterLists::init_ParamType_STR_a2
      PROCEDURE,PASS,PRIVATE :: initSTRa2 => init_ParamType_STR_a2
      !> @copybrief ParameterLists::init_ParamType_SSK_a3
      !> @copydoc ParameterLists::init_ParamType_SSK_a3
      PROCEDURE,PASS,PRIVATE :: initSSKa3 => init_ParamType_SSK_a3
      !> @copybrief ParameterLists::init_ParamType_SDK_a3
      !> @copydoc ParameterLists::init_ParamType_SDK_a3
      PROCEDURE,PASS,PRIVATE :: initSDKa3 => init_ParamType_SDK_a3
      !> @copybrief ParameterLists::init_ParamType_SNK_a3
      !> @copydoc ParameterLists::init_ParamType_SNK_a3
      PROCEDURE,PASS,PRIVATE :: initSNKa3 => init_ParamType_SNK_a3
      !> @copybrief ParameterLists::init_ParamType_SLK_a3
      !> @copydoc ParameterLists::init_ParamType_SLK_a3
      PROCEDURE,PASS,PRIVATE :: initSLKa3 => init_ParamType_SLK_a3
      !> Generic type bound interface for all @c init operations
      GENERIC :: init => initParamList,initSSK,initSDK,initSNK,initSLK, &
                 initSBK,initSTR,initCHAR,initSSKa1,initSDKa1,initSNKa1, &
                 initSLKa1,initSBKa1,initSTRa1,initSSKa2,initSDKa2,initSNKa2, &
                 initSLKa2,initSTRa2,initSSKa3,initSDKa3,initSNKa3,initSLKa3
      PROCEDURE,PASS :: initFromXML
      !> @copybrief ParameterLists::set_ParamType_List
      !> @copydoc ParameterLists::set_ParamType_List
      PROCEDURE,PASS,PRIVATE :: setParamList => set_ParamType_List
      !> @copybrief ParameterLists::set_ParamType_SSK
      !> @copydoc ParameterLists::set_ParamType_SSK
      PROCEDURE,PASS,PRIVATE :: setSSK => set_ParamType_SSK
      !> @copybrief ParameterLists::set_ParamType_SDK
      !> @copydoc ParameterLists::set_ParamType_SDK
      PROCEDURE,PASS,PRIVATE :: setSDK => set_ParamType_SDK
      !> @copybrief ParameterLists::set_ParamType_SNK
      !> @copydoc ParameterLists::set_ParamType_SNK
      PROCEDURE,PASS,PRIVATE :: setSNK => set_ParamType_SNK
      !> @copybrief ParameterLists::set_ParamType_SLK
      !> @copydoc ParameterLists::set_ParamType_SLK
      PROCEDURE,PASS,PRIVATE :: setSLK => set_ParamType_SLK
      !> @copybrief ParameterLists::set_ParamType_SBK
      !> @copydoc ParameterLists::set_ParamType_SBK
      PROCEDURE,PASS,PRIVATE :: setSBK => set_ParamType_SBK
      !> @copybrief ParameterLists::set_ParamType_STR
      !> @copydoc ParameterLists::set_ParamType_STR
      PROCEDURE,PASS,PRIVATE :: setSTR => set_ParamType_STR
      !> @copybrief ParameterLists::set_ParamType_CHAR
      !> @copydoc ParameterLists::set_ParamType_CHAR
      PROCEDURE,PASS,PRIVATE :: setCHAR => set_ParamType_CHAR
      !> @copybrief ParameterLists::set_ParamType_SSK_a1
      !> @copydoc ParameterLists::set_ParamType_SSK_a1
      PROCEDURE,PASS,PRIVATE :: setSSKa1 => set_ParamType_SSK_a1
      !> @copybrief ParameterLists::set_ParamType_SDK_a1
      !> @copydoc ParameterLists::set_ParamType_SDK_a1
      PROCEDURE,PASS,PRIVATE :: setSDKa1 => set_ParamType_SDK_a1
      !> @copybrief ParameterLists::set_ParamType_SNK_a1
      !> @copydoc ParameterLists::set_ParamType_SNK_a1
      PROCEDURE,PASS,PRIVATE :: setSNKa1 => set_ParamType_SNK_a1
      !> @copybrief ParameterLists::set_ParamType_SLK_a1
      !> @copydoc ParameterLists::set_ParamType_SLK_a1
      PROCEDURE,PASS,PRIVATE :: setSLKa1 => set_ParamType_SLK_a1
      !> @copybrief ParameterLists::set_ParamType_SBK_a1
      !> @copydoc ParameterLists::set_ParamType_SBK_a1
      PROCEDURE,PASS,PRIVATE :: setSBKa1 => set_ParamType_SBK_a1
      !> @copybrief ParameterLists::set_ParamType_STR_a1
      !> @copydoc ParameterLists::set_ParamType_STR_a1
      PROCEDURE,PASS,PRIVATE :: setSTRa1 => set_ParamType_STR_a1
      !> @copybrief ParameterLists::set_ParamType_SSK_a2
      !> @copydoc ParameterLists::set_ParamType_SSK_a2
      PROCEDURE,PASS,PRIVATE :: setSSKa2 => set_ParamType_SSK_a2
      !> @copybrief ParameterLists::set_ParamType_SDK_a2
      !> @copydoc ParameterLists::set_ParamType_SDK_a2
      PROCEDURE,PASS,PRIVATE :: setSDKa2 => set_ParamType_SDK_a2
      !> @copybrief ParameterLists::set_ParamType_SNK_a2
      !> @copydoc ParameterLists::set_ParamType_SNK_a2
      PROCEDURE,PASS,PRIVATE :: setSNKa2 => set_ParamType_SNK_a2
      !> @copybrief ParameterLists::set_ParamType_SLK_a2
      !> @copydoc ParameterLists::set_ParamType_SLK_a2
      PROCEDURE,PASS,PRIVATE :: setSLKa2 => set_ParamType_SLK_a2
      !> @copybrief ParameterLists::set_ParamType_STR_a2
      !> @copydoc ParameterLists::set_ParamType_STR_a2
      PROCEDURE,PASS,PRIVATE :: setSTRa2 => set_ParamType_STR_a2
      !> @copybrief ParameterLists::set_ParamType_SSK_a3
      !> @copydoc ParameterLists::set_ParamType_SSK_a3
      PROCEDURE,PASS,PRIVATE :: setSSKa3 => set_ParamType_SSK_a3
      !> @copybrief ParameterLists::set_ParamType_SDK_a3
      !> @copydoc ParameterLists::set_ParamType_SDK_a3
      PROCEDURE,PASS,PRIVATE :: setSDKa3 => set_ParamType_SDK_a3
      !> @copybrief ParameterLists::set_ParamType_SNK_a3
      !> @copydoc ParameterLists::set_ParamType_SNK_a3
      PROCEDURE,PASS,PRIVATE :: setSNKa3 => set_ParamType_SNK_a3
      !> @copybrief ParameterLists::set_ParamType_SLK_a3
      !> @copydoc ParameterLists::set_ParamType_SLK_a3
      PROCEDURE,PASS,PRIVATE :: setSLKa3 => set_ParamType_SLK_a3
      !> Generic type bound interface for all @c set operations
      GENERIC :: set => setParamList,setSSK,setSDK,setSNK,setSLK, &
                 setSBK,setSTR,setCHAR,setSSKa1,setSDKa1,setSNKa1, &
                 setSLKa1,setSBKa1,setSTRa1,setSSKa2,setSDKa2,setSNKa2, &
                 setSLKa2,setSTRa2,setSSKa3,setSDKa3,setSNKa3,setSLKa3
      !> @copybrief ParameterLists::get_ParamType
      !> @copydoc ParameterLists::get_ParamType
      PROCEDURE,PASS,PRIVATE :: getParam => get_ParamType
      !> @copybrief ParameterLists::get_ParamType_List
      !> @copydoc ParameterLists::get_ParamType_List
      PROCEDURE,PASS,PRIVATE :: getParamList => get_ParamType_List
      !> @copybrief ParameterLists::get_ParamType_SSK
      !> @copydoc ParameterLists::get_ParamType_SSK
      PROCEDURE,PASS,PRIVATE :: getSSK => get_ParamType_SSK
      !> @copybrief ParameterLists::get_ParamType_SDK
      !> @copydoc ParameterLists::get_ParamType_SDK
      PROCEDURE,PASS,PRIVATE :: getSDK => get_ParamType_SDK
      !> @copybrief ParameterLists::get_ParamType_SNK
      !> @copydoc ParameterLists::get_ParamType_SNK
      PROCEDURE,PASS,PRIVATE :: getSNK => get_ParamType_SNK
      !> @copybrief ParameterLists::get_ParamType_SLK
      !> @copydoc ParameterLists::get_ParamType_SLK
      PROCEDURE,PASS,PRIVATE :: getSLK => get_ParamType_SLK
      !> @copybrief ParameterLists::get_ParamType_SBK
      !> @copydoc ParameterLists::get_ParamType_SBK
      PROCEDURE,PASS,PRIVATE :: getSBK => get_ParamType_SBK
      !> @copybrief ParameterLists::get_ParamType_STR
      !> @copydoc ParameterLists::get_ParamType_STR
      PROCEDURE,PASS,PRIVATE :: getSTR => get_ParamType_STR
      !> @copybrief ParameterLists::get_ParamType_CHAR
      !> @copydoc ParameterLists::get_ParamType_CHAR
      PROCEDURE,PASS,PRIVATE :: getCHAR => get_ParamType_CHAR
      !> @copybrief ParameterLists::get_ParamType_SSK_a1
      !> @copydoc ParameterLists::get_ParamType_SSK_a1
      PROCEDURE,PASS,PRIVATE :: getSSKa1 => get_ParamType_SSK_a1
      !> @copybrief ParameterLists::get_ParamType_SDK_a1
      !> @copydoc ParameterLists::get_ParamType_SDK_a1
      PROCEDURE,PASS,PRIVATE :: getSDKa1 => get_ParamType_SDK_a1
      !> @copybrief ParameterLists::get_ParamType_SNK_a1
      !> @copydoc ParameterLists::get_ParamType_SNK_a1
      PROCEDURE,PASS,PRIVATE :: getSNKa1 => get_ParamType_SNK_a1
      !> @copybrief ParameterLists::get_ParamType_SLK_a1
      !> @copydoc ParameterLists::get_ParamType_SLK_a1
      PROCEDURE,PASS,PRIVATE :: getSLKa1 => get_ParamType_SLK_a1
      !> @copybrief ParameterLists::get_ParamType_SBK_a1
      !> @copydoc ParameterLists::get_ParamType_SBK_a1
      PROCEDURE,PASS,PRIVATE :: getSBKa1 => get_ParamType_SBK_a1
      !> @copybrief ParameterLists::get_ParamType_STR_a1
      !> @copydoc ParameterLists::get_ParamType_STR_a1
      PROCEDURE,PASS,PRIVATE :: getSTRa1 => get_ParamType_STR_a1
      !> @copybrief ParameterLists::get_ParamType_SSK_a2
      !> @copydoc ParameterLists::get_ParamType_SSK_a2
      PROCEDURE,PASS,PRIVATE :: getSSKa2 => get_ParamType_SSK_a2
      !> @copybrief ParameterLists::get_ParamType_SDK_a2
      !> @copydoc ParameterLists::get_ParamType_SDK_a2
      PROCEDURE,PASS,PRIVATE :: getSDKa2 => get_ParamType_SDK_a2
      !> @copybrief ParameterLists::get_ParamType_SNK_a2
      !> @copydoc ParameterLists::get_ParamType_SNK_a2
      PROCEDURE,PASS,PRIVATE :: getSNKa2 => get_ParamType_SNK_a2
      !> @copybrief ParameterLists::get_ParamType_SLK_a2
      !> @copydoc ParameterLists::get_ParamType_SLK_a2
      PROCEDURE,PASS,PRIVATE :: getSLKa2 => get_ParamType_SLK_a2
      !> @copybrief ParameterLists::get_ParamType_STR_a2
      !> @copydoc ParameterLists::get_ParamType_STR_a2
      PROCEDURE,PASS,PRIVATE :: getSTRa2 => get_ParamType_STR_a2
      !> @copybrief ParameterLists::get_ParamType_SSK_a3
      !> @copydoc ParameterLists::get_ParamType_SSK_a3
      PROCEDURE,PASS,PRIVATE :: getSSKa3 => get_ParamType_SSK_a3
      !> @copybrief ParameterLists::get_ParamType_SDK_a3
      !> @copydoc ParameterLists::get_ParamType_SDK_a3
      PROCEDURE,PASS,PRIVATE :: getSDKa3 => get_ParamType_SDK_a3
      !> @copybrief ParameterLists::get_ParamType_SNK_a3
      !> @copydoc ParameterLists::get_ParamType_SNK_a3
      PROCEDURE,PASS,PRIVATE :: getSNKa3 => get_ParamType_SNK_a3
      !> @copybrief ParameterLists::get_ParamType_SLK_a3
      !> @copydoc ParameterLists::get_ParamType_SLK_a3
      PROCEDURE,PASS,PRIVATE :: getSLKa3 => get_ParamType_SLK_a3
      !> Generic type bound interface for all @c get operations
      GENERIC :: get => getParam,getParamList,getSSK,getSDK,getSNK, &
                 getSLK,getSBK,getSTR,getCHAR,getSSKa1,getSDKa1,getSNKa1, &
                 getSBKa1,getSLKa1,getSTRa1,getSSKa2,getSDKa2,getSNKa2, &
                 getSLKa2,getSTRa2,getSSKa3,getSDKa3,getSNKa3,getSLKa3
      !> @copybrief ParameterLists::add_ParamType
      !> @copydoc ParameterLists::add_ParamType
      PROCEDURE,PASS,PRIVATE :: addParam => add_ParamType
      !> @copybrief ParameterLists::add_ParamType_List
      !> @copydoc ParameterLists::add_ParamType_List
      PROCEDURE,PASS,PRIVATE :: addList => add_ParamType_List
      !> @copybrief ParameterLists::add_ParamType_SSK
      !> @copydoc ParameterLists::add_ParamType_SSK
      PROCEDURE,PASS,PRIVATE :: addSSK => add_ParamType_SSK
      !> @copybrief ParameterLists::add_ParamType_SDK
      !> @copydoc ParameterLists::add_ParamType_SDK
      PROCEDURE,PASS,PRIVATE :: addSDK => add_ParamType_SDK
      !> @copybrief ParameterLists::add_ParamType_SNK
      !> @copydoc ParameterLists::add_ParamType_SNK
      PROCEDURE,PASS,PRIVATE :: addSNK => add_ParamType_SNK
      !> @copybrief ParameterLists::add_ParamType_SLK
      !> @copydoc ParameterLists::add_ParamType_SLK
      PROCEDURE,PASS,PRIVATE :: addSLK => add_ParamType_SLK
      !> @copybrief ParameterLists::add_ParamType_SBK
      !> @copydoc ParameterLists::add_ParamType_SBK
      PROCEDURE,PASS,PRIVATE :: addSBK => add_ParamType_SBK
      !> @copybrief ParameterLists::add_ParamType_STR
      !> @copydoc ParameterLists::add_ParamType_STR
      PROCEDURE,PASS,PRIVATE :: addSTR => add_ParamType_STR
      !> @copybrief ParameterLists::add_ParamType_CHAR
      !> @copydoc ParameterLists::add_ParamType_CHAR
      PROCEDURE,PASS,PRIVATE :: addCHAR => add_ParamType_CHAR
      !> @copybrief ParameterLists::add_ParamType_SSK_a1
      !> @copydoc ParameterLists::add_ParamType_SSK_a1
      PROCEDURE,PASS,PRIVATE :: addSSKa1 => add_ParamType_SSK_a1
      !> @copybrief ParameterLists::add_ParamType_SDK_a1
      !> @copydoc ParameterLists::add_ParamType_SDK_a1
      PROCEDURE,PASS,PRIVATE :: addSDKa1 => add_ParamType_SDK_a1
      !> @copybrief ParameterLists::add_ParamType_SNK_a1
      !> @copydoc ParameterLists::add_ParamType_SNK_a1
      PROCEDURE,PASS,PRIVATE :: addSNKa1 => add_ParamType_SNK_a1
      !> @copybrief ParameterLists::add_ParamType_SLK_a1
      !> @copydoc ParameterLists::add_ParamType_SLK_a1
      PROCEDURE,PASS,PRIVATE :: addSLKa1 => add_ParamType_SLK_a1
      !> @copybrief ParameterLists::add_ParamType_SBK_a1
      !> @copydoc ParameterLists::add_ParamType_SBK_a1
      PROCEDURE,PASS,PRIVATE :: addSBKa1 => add_ParamType_SBK_a1
      !> @copybrief ParameterLists::add_ParamType_STR_a1
      !> @copydoc ParameterLists::add_ParamType_STR_a1
      PROCEDURE,PASS,PRIVATE :: addSTRa1 => add_ParamType_STR_a1
      !> @copybrief ParameterLists::add_ParamType_SSK_a2
      !> @copydoc ParameterLists::add_ParamType_SSK_a2
      PROCEDURE,PASS,PRIVATE :: addSSKa2 => add_ParamType_SSK_a2
      !> @copybrief ParameterLists::add_ParamType_SDK_a2
      !> @copydoc ParameterLists::add_ParamType_SDK_a2
      PROCEDURE,PASS,PRIVATE :: addSDKa2 => add_ParamType_SDK_a2
      !> @copybrief ParameterLists::add_ParamType_SNK_a2
      !> @copydoc ParameterLists::add_ParamType_SNK_a2
      PROCEDURE,PASS,PRIVATE :: addSNKa2 => add_ParamType_SNK_a2
      !> @copybrief ParameterLists::add_ParamType_SLK_a2
      !> @copydoc ParameterLists::add_ParamType_SLK_a2
      PROCEDURE,PASS,PRIVATE :: addSLKa2 => add_ParamType_SLK_a2
      !> @copybrief ParameterLists::add_ParamType_STR_a2
      !> @copydoc ParameterLists::add_ParamType_STR_a2
      PROCEDURE,PASS,PRIVATE :: addSTRa2 => add_ParamType_STR_a2
      !> @copybrief ParameterLists::add_ParamType_SSK_a3
      !> @copydoc ParameterLists::add_ParamType_SSK_a3
      PROCEDURE,PASS,PRIVATE :: addSSKa3 => add_ParamType_SSK_a3
      !> @copybrief ParameterLists::add_ParamType_SDK_a3
      !> @copydoc ParameterLists::add_ParamType_SDK_a3
      PROCEDURE,PASS,PRIVATE :: addSDKa3 => add_ParamType_SDK_a3
      !> @copybrief ParameterLists::add_ParamType_SNK_a3
      !> @copydoc ParameterLists::add_ParamType_SNK_a3
      PROCEDURE,PASS,PRIVATE :: addSNKa3 => add_ParamType_SNK_a3
      !> @copybrief ParameterLists::add_ParamType_SLK_a3
      !> @copydoc ParameterLists::add_ParamType_SLK_a3
      PROCEDURE,PASS,PRIVATE :: addSLKa3 => add_ParamType_SLK_a3
      !> Generic type bound interface for all @c add operations
      GENERIC :: add => addParam,addList,addSSK,addSDK, &
         addSNK,addSLK,addSBK,addSTR,addCHAR,addSSKa1,addSDKa1, &
         addSNKa1,addSLKa1,addSBKa1,addSTRa1,addSSKa2,addSDKa2, &
         addSNKa2,addSLKa2,addSTRa2,addSSKa3,addSDKa3,addSNKa3,addSLKa3
      !> @copybrief ParameterLists::remove_ParamType
      !> @copydoc ParameterLists::remove_ParamType
      PROCEDURE,PASS :: remove => remove_ParamType
      !> @copybrief ParameterLists::getString_ParamType_scalar
      !> @copydoc ParameterLists::getString_scalar_ParamType_scalar
      PROCEDURE,PASS,PRIVATE :: getString_scalar => getString_ParamType_scalar
      !> @copybrief ParameterLists::getString_ParamType_a1
      !> @copydoc ParameterLists::getString_ParamType_a1
      PROCEDURE,PASS,PRIVATE :: getString_a1 => getString_ParamType_a1
      !> @copybrief ParameterLists::getString_ParamType_a2
      !> @copydoc ParameterLists::getString_ParamType_a2
      PROCEDURE,PASS,PRIVATE :: getString_a2 => getString_ParamType_a2
      !> @copybrief ParameterLists::getString_ParamType_a3
      !> @copydoc ParameterLists::getString_ParamType_a3
      PROCEDURE,PASS,PRIVATE :: getString_a3 => getString_ParamType_a3
      !> Generic type bound interface for all @c getString operations
      GENERIC :: getString => getString_scalar,getString_a1,getString_a2,getString_a3
      !> @copybrief ParameterLists::has_ParamType
      !> @copydoc ParameterLists::has_ParamType
      PROCEDURE,PASS :: has => has_ParamType
      !> @copybrief ParameterLists::getNextParam_ParamType
      !> @copydoc ParameterLists::getNextParam_ParamType
      PROCEDURE,PASS :: getNextParam => getNextParam_ParamType
      !> @copybrief ParameterLists::getSubParam_List
      !> @copydoc ParameterLists::getSubParam_List
      PROCEDURE,PASS :: getSubPL => getSubParam_List
      !> @copybrief ParameterLists::getSubParams
      !> @copydoc ParameterLists::getSubParams
      PROCEDURE,PASS :: getSubParams => getSubParams
      !> @copybrief ParameterLists::validate_ParamType
      !> @copydoc ParameterLists::validate_ParamType
      PROCEDURE,PASS :: validate => validate_ParamType
      !> @copybrief ParameterLists::verify_ParamType
      !> @copydoc ParameterLists::verify_ParamType
      PROCEDURE,PASS :: verify => verify_ParamType
      !> @copybrief ParameterLists::edit_ParamType
      !> @copydoc ParameterLists::edit_ParamType
      PROCEDURE,PASS :: edit => edit_ParamType
      !> @copybrief ParameterLists::editToXML_ParamType
      !> @copydoc ParameterLists::editToXML_ParamType
      PROCEDURE,PASS :: editToXML => editToXML_ParamType
      !> @copybrief ParameterLists::clear_ParamType
      !> @copydoc ParameterLists::clear_ParamType
      PROCEDURE,PASS :: clear => clear_ParamType
#ifdef HAVE_ForTeuchos
      PROCEDURE,PASS :: toTeuchosPlist
#endif
  PROCEDURE :: procXMLTree
  ENDTYPE ParamType

  !> @brief Extended type of a ParamType for defining a list of parameters
  TYPE,EXTENDS(ParamType) :: ParamType_List
    !> The list of parameters
    TYPE(ParamType),ALLOCATABLE :: pList(:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_List
      !> @copydoc ParameterLists::edit_ParamType_List
      PROCEDURE,PASS :: edit => edit_ParamType_List
      !> @copybrief ParameterLists::clear_ParamType_List
      !> @copydoc ParameterLists::clear_ParamType_List
      PROCEDURE,PASS :: clear => clear_ParamType_List
  ENDTYPE ParamType_List

  !> @brief Extended type of a ParamType for defining a parameter that
  !> is a single precision real scalar
  TYPE,EXTENDS(ParamType) :: ParamType_SSK
    !> The value of the parameter
    REAL(SSK) :: val=0.0_SSK
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SSK
      !> @copydoc ParameterLists::edit_ParamType_SSK
      PROCEDURE,PASS :: edit => edit_ParamType_SSK
      !> @copybrief ParameterLists::clear_ParamType_SSK
      !> @copydoc ParameterLists::clear_ParamType_SSK
      PROCEDURE,PASS :: clear => clear_ParamType_SSK
  ENDTYPE ParamType_SSK

  !> @brief Extended type of a ParamType for defining a parameter that
  !> is a double precision real scalar
  TYPE,EXTENDS(ParamType) :: ParamType_SDK
    !> The value of the parameter
    REAL(SDK) :: val=0.0_SDK
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SDK
      !> @copydoc ParameterLists::edit_ParamType_SDK
      PROCEDURE,PASS :: edit => edit_ParamType_SDK
      !> @copybrief ParameterLists::clear_ParamType_SDK
      !> @copydoc ParameterLists::clear_ParamType_SDK
      PROCEDURE,PASS :: clear => clear_ParamType_SDK
  ENDTYPE ParamType_SDK

  !> @brief Extended type of a ParamType for defining a parameter that
  !> is a 32-bit integer scalar
  TYPE,EXTENDS(ParamType) :: ParamType_SNK
    !> The value of the parameter
    INTEGER(SNK) :: val=0_SNK
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SNK
      !> @copydoc ParameterLists::edit_ParamType_SNK
      PROCEDURE,PASS :: edit => edit_ParamType_SNK
      !> @copybrief ParameterLists::clear_ParamType_SNK
      !> @copydoc ParameterLists::clear_ParamType_SNK
      PROCEDURE,PASS :: clear => clear_ParamType_SNK
  ENDTYPE ParamType_SNK

  !> @brief Extended type of a ParamType for defining a parameter that
  !> is a 64-bit integer scalar
  TYPE,EXTENDS(ParamType) :: ParamType_SLK
    !> The value of the parameter
    INTEGER(SLK) :: val=0_SLK
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SLK
      !> @copydoc ParameterLists::edit_ParamType_SLK
      PROCEDURE,PASS :: edit => edit_ParamType_SLK
      !> @copybrief ParameterLists::clear_ParamType_SLK
      !> @copydoc ParameterLists::clear_ParamType_SLK
      PROCEDURE,PASS :: clear => clear_ParamType_SLK
  ENDTYPE ParamType_SLK

  !> @brief Extended type of a ParamType for defining a parameter that
  !> is a logical scalar
  TYPE,EXTENDS(ParamType) :: ParamType_SBK
    !> The value of the parameter
    LOGICAL(SBK) :: val=.FALSE.
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SBK
      !> @copydoc ParameterLists::edit_ParamType_SBK
      PROCEDURE,PASS :: edit => edit_ParamType_SBK
      !> @copybrief ParameterLists::clear_ParamType_SBK
      !> @copydoc ParameterLists::clear_ParamType_SBK
      PROCEDURE,PASS :: clear => clear_ParamType_SBK
  ENDTYPE ParamType_SBK

  !> @brief Extended type of a ParamType for defining a parameter that
  !> is a string derived type
  TYPE,EXTENDS(ParamType) :: ParamType_STR
    !> The value of the parameter
    TYPE(StringType) :: val
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_STR
      !> @copydoc ParameterLists::edit_ParamType_STR
      PROCEDURE,PASS :: edit => edit_ParamType_STR
      !> @copybrief ParameterLists::clear_ParamType_STR
      !> @copydoc ParameterLists::clear_ParamType_STR
      PROCEDURE,PASS :: clear => clear_ParamType_STR
  ENDTYPE ParamType_STR
!----------------------------------------------------------------------
!     One-Dimensional Arrays
!----------------------------------------------------------------------
  !> @brief Extended type of a ParamType for defining a one dimensional
  !> array parameter of single precision reals
  TYPE,EXTENDS(ParamType) :: ParamType_SSK_a1
    !> The value of the parameter
    REAL(SSK),ALLOCATABLE :: val(:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SSK_a1
      !> @copydoc ParameterLists::edit_ParamType_SSK_a1
      PROCEDURE,PASS :: edit => edit_ParamType_SSK_a1
      !> @copybrief ParameterLists::clear_ParamType_SSK_a1
      !> @copydoc ParameterLists::clear_ParamType_SSK_a1
      PROCEDURE,PASS :: clear => clear_ParamType_SSK_a1
  ENDTYPE ParamType_SSK_a1

  !> @brief Extended type of a ParamType for defining a one dimensional
  !> array parameter of double precision reals
  TYPE,EXTENDS(ParamType) :: ParamType_SDK_a1
    !> The value of the parameter
    REAL(SDK),ALLOCATABLE :: val(:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SDK_a1
      !> @copydoc ParameterLists::edit_ParamType_SDK_a1
      PROCEDURE,PASS :: edit => edit_ParamType_SDK_a1
      !> @copybrief ParameterLists::clear_ParamType_SDK_a1
      !> @copydoc ParameterLists::clear_ParamType_SDK_a1
      PROCEDURE,PASS :: clear => clear_ParamType_SDK_a1
  ENDTYPE ParamType_SDK_a1

  !> @brief Extended type of a ParamType for defining a one dimensional
  !> array parameter of 32-bit integers
  TYPE,EXTENDS(ParamType) :: ParamType_SNK_a1
    !> The value of the parameter
    INTEGER(SNK),ALLOCATABLE :: val(:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SNK_a1
      !> @copydoc ParameterLists::edit_ParamType_SNK_a1
      PROCEDURE,PASS :: edit => edit_ParamType_SNK_a1
      !> @copybrief ParameterLists::clear_ParamType_SNK_a1
      !> @copydoc ParameterLists::clear_ParamType_SNK_a1
      PROCEDURE,PASS :: clear => clear_ParamType_SNK_a1
  ENDTYPE ParamType_SNK_a1

  !> @brief Extended type of a ParamType for defining a one dimensional
  !> array parameter of 64-bit integers
  TYPE,EXTENDS(ParamType) :: ParamType_SLK_a1
    !> The value of the parameter
    INTEGER(SLK),ALLOCATABLE :: val(:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SLK_a1
      !> @copydoc ParameterLists::edit_ParamType_SLK_a1
      PROCEDURE,PASS :: edit => edit_ParamType_SLK_a1
      !> @copybrief ParameterLists::clear_ParamType_SLK_a1
      !> @copydoc ParameterLists::clear_ParamType_SLK_a1
      PROCEDURE,PASS :: clear => clear_ParamType_SLK_a1
  ENDTYPE ParamType_SLK_a1

  !> @brief Extended type of a ParamType for defining a one dimensional
  !> array parameter of single precision reals
  TYPE,EXTENDS(ParamType) :: ParamType_SBK_a1
    !> The value of the parameter
    LOGICAL(SBK),ALLOCATABLE :: val(:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SBK_a1
      !> @copydoc ParameterLists::edit_ParamType_SBK_a1
      PROCEDURE,PASS :: edit => edit_ParamType_SBK_a1
      !> @copybrief ParameterLists::clear_ParamType_SBK_a1
      !> @copydoc ParameterLists::clear_ParamType_SBK_a1
      PROCEDURE,PASS :: clear => clear_ParamType_SBK_a1
  ENDTYPE ParamType_SBK_a1

  !> @brief Extended type of a ParamType for defining a one dimensional
  !> array parameter that is a string derived type
  TYPE,EXTENDS(ParamType) :: ParamType_STR_a1
    !> The value of the parameter
    TYPE(StringType),ALLOCATABLE :: val(:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_STR_a1
      !> @copydoc ParameterLists::edit_ParamType_STR_a1
      PROCEDURE,PASS :: edit => edit_ParamType_STR_a1
      !> @copybrief ParameterLists::clear_ParamType_STR_a1
      !> @copydoc ParameterLists::clear_ParamType_STR_a1
      PROCEDURE,PASS :: clear => clear_ParamType_STR_a1
  ENDTYPE ParamType_STR_a1

!----------------------------------------------------------------------
!     Two-Dimensional Arrays
!----------------------------------------------------------------------
  !> @brief Extended type of a ParamType for defining a two dimensional
  !> array parameter of single precision reals
  TYPE,EXTENDS(ParamType) :: ParamType_SSK_a2
    !> The value of the parameter
    REAL(SSK),ALLOCATABLE :: val(:,:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SSK_a2
      !> @copydoc ParameterLists::edit_ParamType_SSK_a2
      PROCEDURE,PASS :: edit => edit_ParamType_SSK_a2
      !> @copybrief ParameterLists::clear_ParamType_SSK_a2
      !> @copydoc ParameterLists::clear_ParamType_SSK_a2
      PROCEDURE,PASS :: clear => clear_ParamType_SSK_a2
  ENDTYPE ParamType_SSK_a2

  !> @brief Extended type of a ParamType for defining a two dimensional
  !> array parameter of double precision reals
  TYPE,EXTENDS(ParamType) :: ParamType_SDK_a2
    !> The value of the parameter
    REAL(SDK),ALLOCATABLE :: val(:,:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SDK_a2
      !> @copydoc ParameterLists::edit_ParamType_SDK_a2
      PROCEDURE,PASS :: edit => edit_ParamType_SDK_a2
      !> @copybrief ParameterLists::clear_ParamType_SDK_a2
      !> @copydoc ParameterLists::clear_ParamType_SDK_a2
      PROCEDURE,PASS :: clear => clear_ParamType_SDK_a2
  ENDTYPE ParamType_SDK_a2

  !> @brief Extended type of a ParamType for defining a two dimensional
  !> array parameter of 32-bit integers
  TYPE,EXTENDS(ParamType) :: ParamType_SNK_a2
    !> The value of the parameter
    INTEGER(SNK),ALLOCATABLE :: val(:,:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SNK_a2
      !> @copydoc ParameterLists::edit_ParamType_SNK_a2
      PROCEDURE,PASS :: edit => edit_ParamType_SNK_a2
      !> @copybrief ParameterLists::clear_ParamType_SNK_a2
      !> @copydoc ParameterLists::clear_ParamType_SNK_a2
      PROCEDURE,PASS :: clear => clear_ParamType_SNK_a2
  ENDTYPE ParamType_SNK_a2

  !> @brief Extended type of a ParamType for defining a two dimensional
  !> array parameter of 64-bit integers
  TYPE,EXTENDS(ParamType) :: ParamType_SLK_a2
    !> The value of the parameter
    INTEGER(SLK),ALLOCATABLE :: val(:,:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SLK_a2
      !> @copydoc ParameterLists::edit_ParamType_SLK_a2
      PROCEDURE,PASS :: edit => edit_ParamType_SLK_a2
      !> @copybrief ParameterLists::clear_ParamType_SLK_a2
      !> @copydoc ParameterLists::clear_ParamType_SLK_a2
      PROCEDURE,PASS :: clear => clear_ParamType_SLK_a2
  ENDTYPE ParamType_SLK_a2

  !> @brief Extended type of a ParamType for defining a two dimensional
  !> array parameter that is a string derived type
  TYPE,EXTENDS(ParamType) :: ParamType_STR_a2
    !> The value of the parameter
    TYPE(StringType),ALLOCATABLE :: val(:,:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_STR_a2
      !> @copydoc ParameterLists::edit_ParamType_STR_a2
      PROCEDURE,PASS :: edit => edit_ParamType_STR_a2
      !> @copybrief ParameterLists::clear_ParamType_STR_a2
      !> @copydoc ParameterLists::clear_ParamType_STR_a2
      PROCEDURE,PASS :: clear => clear_ParamType_STR_a2
  ENDTYPE ParamType_STR_a2
!----------------------------------------------------------------------
!     Three-Dimensional Arrays
!----------------------------------------------------------------------
  !> @brief Extended type of a ParamType for defining a three dimensional
  !> array parameter of single precision reals
  TYPE,EXTENDS(ParamType) :: ParamType_SSK_a3
    !> The value of the parameter
    REAL(SSK),ALLOCATABLE :: val(:,:,:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SSK_a3
      !> @copydoc ParameterLists::edit_ParamType_SSK_a3
      PROCEDURE,PASS :: edit => edit_ParamType_SSK_a3
      !> @copybrief ParameterLists::clear_ParamType_SSK_a3
      !> @copydoc ParameterLists::clear_ParamType_SSK_a3
      PROCEDURE,PASS :: clear => clear_ParamType_SSK_a3
  ENDTYPE ParamType_SSK_a3

  !> @brief Extended type of a ParamType for defining a three dimensional
  !> array parameter of double precision reals
  TYPE,EXTENDS(ParamType) :: ParamType_SDK_a3
    !> The value of the parameter
    REAL(SDK),ALLOCATABLE :: val(:,:,:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SDK_a3
      !> @copydoc ParameterLists::edit_ParamType_SDK_a3
      PROCEDURE,PASS :: edit => edit_ParamType_SDK_a3
      !> @copybrief ParameterLists::clear_ParamType_SDK_a3
      !> @copydoc ParameterLists::clear_ParamType_SDK_a3
      PROCEDURE,PASS :: clear => clear_ParamType_SDK_a3
  ENDTYPE ParamType_SDK_a3

  !> @brief Extended type of a ParamType for defining a three dimensional
  !> array parameter of 32-bit integers
  TYPE,EXTENDS(ParamType) :: ParamType_SNK_a3
    !> The value of the parameter
    INTEGER(SNK),ALLOCATABLE :: val(:,:,:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SNK_a3
      !> @copydoc ParameterLists::edit_ParamType_SNK_a3
      PROCEDURE,PASS :: edit => edit_ParamType_SNK_a3
      !> @copybrief ParameterLists::clear_ParamType_SNK_a3
      !> @copydoc ParameterLists::clear_ParamType_SNK_a3
      PROCEDURE,PASS :: clear => clear_ParamType_SNK_a3
  ENDTYPE ParamType_SNK_a3

  !> @brief Extended type of a ParamType for defining a three dimensional
  !> array parameter of 64-bit integers
  TYPE,EXTENDS(ParamType) :: ParamType_SLK_a3
    !> The value of the parameter
    INTEGER(SLK),ALLOCATABLE :: val(:,:,:)
!
!List of type bound procedures
    CONTAINS
      !> @copybrief ParameterLists::edit_ParamType_SLK_a3
      !> @copydoc ParameterLists::edit_ParamType_SLK_a3
      PROCEDURE,PASS :: edit => edit_ParamType_SLK_a3
      !> @copybrief ParameterLists::clear_ParamType_SLK_a3
      !> @copydoc ParameterLists::clear_ParamType_SLK_a3
      PROCEDURE,PASS :: clear => clear_ParamType_SLK_a3
  ENDTYPE ParamType_SLK_a3
!
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  !> Generic interface adds a procedure to overload the intrinsic assignment
  !> operator with the given procedure
  INTERFACE ASSIGNMENT(=)
    !> @copybrief ParameterLists::assign_ParamType
    !> @copydoc ParameterLists::assign_ParamType
    MODULE PROCEDURE assign_ParamType
  ENDINTERFACE

  INTERFACE OPERATOR(==)
    !> @copybrief ParameterLists::isEqual_ParamType
    !> @copydoc ParameterLists::isEqual_ParamType
    MODULE PROCEDURE isEqual_ParamType
  ENDINTERFACE
!
!===============================================================================
  CONTAINS
#ifdef HAVE_ForTeuchos
    RECURSIVE SUBROUTINE toTeuchosPlist(this, that, n)
      CLASS(ParamType),INTENT(IN) :: this
      TYPE(ForTeuchos_ParameterList_ID),INTENT(IN) :: that
      INTEGER(SNK),INTENT(IN),OPTIONAL :: n
      !
      CLASS(ParamType), POINTER :: itr
      Type(ParamType) :: nextParam
      TYPE(ForTeuchos_ParameterList_ID) :: new
      INTEGER(C_INT) :: ierr
      INTEGER(SNK) :: level
      TYPE(StringType) :: path
      INTEGER :: t

      nullify(itr)

      level = 0
      IF(PRESENT(n)) THEN
        level = n
      ENDIF

      IF(level > 10) THEN
        WRITE(*,*)"Too much recursion. Giving up"
        return
      ENDIF

      path = ''
      CALL this%getSubParams(path, itr)

      DO WHILE(ASSOCIATED(itr))
        SELECT TYPE(itr)
          TYPE IS(ParamType_List)
            ! This node is its own parameter list
            new = ForTeuchos_PL_sublist(that, CHAR(itr%name), 0, &
              "Imported from MPACT PList", ierr)
            nextParam = itr
            WRITE(*,*)associated(nextParam%pdat)
            CALL toTeuchosPlist(nextParam, new, level+1)
          TYPE IS(ParamType_SBK)
            CALL ForTeuchos_PL_set_bool(that, CHAR(itr%name), itr%val,&
              CHAR(itr%description), ierr)
          TYPE IS(ParamType_SDK)
            CALL ForTeuchos_PL_set_double(that, CHAR(itr%name), itr%val,&
              CHAR(itr%description), ierr)
          TYPE IS(ParamType_SNK)
            CALL ForTeuchos_PL_set_int(that, CHAR(itr%name), itr%val,&
              CHAR(itr%description), ierr)
          TYPE IS(ParamType_STR)
            CALL ForTeuchos_PL_set_string(that, CHAR(itr%name), CHAR(itr%val),&
              CHAR(itr%description), ierr)
          CLASS DEFAULT
            CALL eParams%raiseError(&
              "Unsupported PARAMETER TYPE for Teuchos conversion.")
        ENDSELECT
        CALL this%getSubParams(path, itr)
      ENDDO
    ENDSUBROUTINE
#endif
!
!-------------------------------------------------------------------------------
!> @brief Defines the assignment operation two @c ParamType objects.
!> @param thisParam the ParamType object to be assigned
!> @param param the ParamType object to assign
!>
!> This routine clears the @c thisParam which must be a declared as a
!> <TT>TYPE(ParamType)</TT> in the client code. @c param may be anything. As
!> new extended types of the @c ParamType are defined in this module this
!> will need to be updated with a new <TT>TYPE IS()</TT> block. This should
!> be the only routine that knows about all the extended types of @c ParamType.
!>
    RECURSIVE SUBROUTINE assign_ParamType(thisParam,param)
      CHARACTER(LEN=*),PARAMETER :: myName='assign_ParamType'
      CLASS(ParamType),INTENT(INOUT) :: thisParam
      CLASS(ParamType),INTENT(IN) :: param

      SELECTTYPE(thisParam)
        TYPE IS(ParamType)
          IF(ASSOCIATED(thisParam%pdat)) CALL thisParam%clear()
          SELECTTYPE(p=>param)
            TYPE IS(ParamType)
              !Assign the parameter value using a recursive call
              IF(ASSOCIATED(p%pdat)) CALL assign_ParamType(thisParam,p%pdat)
            TYPE IS(ParamType_SSK)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_SDK)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_SNK)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_SLK)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_SBK)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_STR)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_SSK_a1)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_SDK_a1)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_SNK_a1)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_SLK_a1)
              CALL thisParam%init(CHAR(p%name),p%val, &
                CHAR(p%description))
            TYPE IS(ParamType_SBK_a1)
              CALL thisParam%init(CHAR(p%name),p%val, &