inp_decode.F

Go to the documentation of this file.

#include "cppdefs.h"
      MODULE inp_decode_mod
!
!git $Id$
!================================================== Hernan G. Arango ===
!  Copyright (c) 2002-2025 The ROMS Group                              !
!    Licensed under a MIT/X style license                              !
!    See License_ROMS.md                                               !
!=======================================================================
!                                                                      !
!  This module contains several routines to process and decode ROMS    !
!  unique namelist KeyWord parameters from input script files:         !
!                                                                      !
!  decode_line    Decodes line of text from input script files for a   !
!                   particular KeyWord.                                !
!                                                                      !
!  find_file      Checks if provide input filename exits.              !
!                                                                      !
!  load_i         Processes and loads an integer parameter variable.   !
!                                                                      !
!  load_i         Processes and loads a logical parameter variable.    !
!                                                                      !
!  load_r         Processes and loads a single or double precision     !
!                   floating-point (real) parameter variable.          !
!                                                                      !
!  load_lbc       Processes and loads lateral boundary conditions      !
!                   logical switches into derived type structure,      !
!                   TYPE(T_LBC).                                       !
!                                                                      !
!  load_s1d       Processes and loads I/O parameters into 1D derived   !
!                   type structure, TYPE(T_IO).                        !
!                                                                      !
!  load_s2d       Processes and loads I/O parameters into 2D derived   !
!                   type structure, TYPE(T_IO).                        !
!                                                                      !
#ifdef SOLVE3D
!  load_tadv      Processes and loads tracers horizontal and vertical  !
!                   advection switches into derived type structure,    !
!                   TYPE(T_ADV).                                       !
#endif
!                                                                      !
!=======================================================================
!
      USE mod_kinds
      USE mod_param
      USE mod_parallel
      USE mod_iounits
      USE mod_ncparam
      USE mod_netcdf
      USE mod_scalars
!
      USE strings_mod, ONLY : founderror
      USE strings_mod, ONLY : uppercase
!
      implicit none
!
      INTERFACE load_i
        MODULE PROCEDURE load_0d_i       ! scalar integer
        MODULE PROCEDURE load_1d_i       ! 1D integer array
        MODULE PROCEDURE load_2d_i       ! 2D integer array
        MODULE PROCEDURE load_3d_i       ! 3D integer array
      END INTERFACE load_i
 
      INTERFACE load_l
        MODULE PROCEDURE load_0d_l       ! scalar logical
        MODULE PROCEDURE load_1d_l       ! 1D logical array
        MODULE PROCEDURE load_2d_l       ! 2D logical array
        MODULE PROCEDURE load_3d_l       ! 3D logical array
      END INTERFACE load_l
 
      INTERFACE load_r
#ifdef SINGLE_PRECISION
        MODULE PROCEDURE load_0d_dp      ! scalar real(dp)
        MODULE PROCEDURE load_1d_dp      ! 1D real(dp) array
        MODULE PROCEDURE load_2d_dp      ! 2D real(dp) array
        MODULE PROCEDURE load_3d_dp      ! 3D real(dp) array
#endif
        MODULE PROCEDURE load_0d_r8      ! scalar real(r8)
        MODULE PROCEDURE load_1d_r8      ! 1D real(r8) array
        MODULE PROCEDURE load_2d_r8      ! 2D real(r8) array
        MODULE PROCEDURE load_3d_r8      ! 3D real(r8) array
      END INTERFACE load_r
 
      INTERFACE load_s1d
        MODULE PROCEDURE load_s1d1       ! 1D structrure, S(:)
        MODULE PROCEDURE load_s1d2       ! 2D structrure, S(Ie,:)
      END INTERFACE load_s1d
!
!  Module dimension parameters.
!
      integer, parameter :: ncval = 200  ! size of Cval character vector
      integer, parameter :: nrval = 100  ! size of Rval real vector
!
      CONTAINS
!
      FUNCTION decode_line (line_text, KeyWord, Nval, Cval, Rval)
!
!***********************************************************************
!                                                                      !
!  This function decodes lines of text from input script files. It is  !
!  to evaluate ROMS unique namelist parameters.                        !
!                                                                      !
!  Arguments:                                                          !
!                                                                      !
!    line_text      Input scripts lines as text (string)               !
!    KeyWord        Input parameter keyword (string)                   !
!    Nval           Number of values processed (integer)               !
!    Cval           Input values as characters (string array)          !
!    Rval           Input values as mumbers (real array)               !
!                                                                      !
!***********************************************************************
!
! Imported variable declarations.
!
      character (len=*), intent(in) :: line_text
 
      character (len=*), intent(inout) :: keyword
 
      integer, intent(inout) :: nval
 
      character (len=*), intent(inout) :: cval(:)
 
      real(dp), intent(inout) :: rval(:)
!
! Local variable declarations
!
      logical :: isstring, kextract, decode, nested
      integer :: iblank, icomm, icont, ipipe, kstr, kend, linp
      integer :: lend, lens, lstr, lval, nmul, schar
      integer :: copies, i, ic, ie, is, j, status
 
      integer, dimension(20) :: imul
 
      integer :: decode_line
 
      character (len=256) :: vstring, inpline, line, string
!
!------------------------------------------------------------------------
!  Decode input line.
!------------------------------------------------------------------------
!
!  Initialize. Use CHAR(32) for blank space.
!
      line=char(32)
      inpline=char(32)
      vstring=char(32)
      string=char(32)
!!    Lstr=LEN(line)
!!    DO i=1,Lstr
!!      line(i:i)=CHAR(32)
!!      inpline(i:i)=CHAR(32)
!!      Vstring(i:i)=CHAR(32)
!!      string(i:i)=CHAR(32)
!!    END DO
!
!  Check input line and remove illegal characters.  Replace control
!  ASCII characters CHAR(0) to CHAR(31) with a blank space, CHAR(32).
!
!  Char  Dec  Key  Control Action
!  ----------------------------------------------------------------------
!  NUL   0    ^@   Null character
!  SOH   1    ^A   Start of heading, = console interrupt
!  STX   2    ^B   Start of text, maintenance mode on HP console
!  ETX   3    ^C   End of text
!  EOT   4    ^D   End of transmission, not the same as ETB
!  ENQ   5    ^E   Enquiry, goes with ACK; old HP flow control
!  ACK   6    ^F   Acknowledge, clears ENQ logon hand
!  BEL   7    ^G   Bell, rings the bell...
!  BS    8    ^H   Backspace, works on HP terminals/computers
!  HT    9    ^I   Horizontal tab, move to next tab stop
!  LF    10   ^J   Line Feed
!  VT    11   ^K   Vertical tab
!  FF    12   ^L   Form Feed, page eject
!  CR    13   ^M   Carriage Return
!  SO    14   ^N   Shift Out, alternate character set
!  SI    15   ^O   Shift In, resume defaultn character set
!  DLE   16   ^P   Data link escape
!  DC1   17   ^Q   XON, with XOFF to pause listings; ":okay to send".
!  DC2   18   ^R   Device control 2, block-mode flow control
!  DC3   19   ^S   XOFF, with XON is TERM=18 flow control
!  DC4   20   ^T   Device control 4
!  NAK   21   ^U   Negative acknowledge
!  SYN   22   ^V   Synchronous idle
!  ETB   23   ^W   End transmission block, not the same as EOT
!  CAN   24   ^X   Cancel line, MPE echoes !!!
!  EM    25   ^Y   End of medium, Control-Y interrupt
!  SUB   26   ^Z   Substitute
!  ESC   27   ^[   Escape, next character is not echoed
!  FS    28   ^\   File separator
!  GS    29   ^]   Group separator
!  RS    30   ^^   Record separator, block-mode terminator
!  US    31   ^_   Unit separator
!
!  SP    32        Space
!  !     33        Exclamation mark
!  #     35        Number sign, hash, or pound sign
!  *     42        Asterisk (star, multiply)
!  +     43        Plus
!  -     45        Hyphen, dash, minus
!  .     46        Period
!  0     48        Zero
!  1     49        One
!  2     50        Two
!  3     51        Three
!  4     52        Four
!  5     53        Five
!  6     54        Six
!  7     55        Seven
!  8     56        Eight
!  9     57        Nine
!  :     58        colon sign
!  =     61        Equals sign
!  \     92        Reverse slant (Backslash)
!  |    124        Vertical line
!
      inpline=trim(adjustl(line_text))
      linp=len_trim(inpline)
      DO i=1,len_trim(inpline)
        j=ichar(inpline(i:i))
        IF (j.lt.32) THEN
          inpline(i:i)=char(32)                           ! blank space
        END IF
      END DO
      inpline=trim(inpline)
!
!  Get length of "line". Remove comment after the KEYWORD, if any.
!  Then, remove leading and trailing blanks.
!
      IF ((linp.gt.0).and.(inpline(1:1).ne.char(33))) THEN
        icomm=index(inpline,char(33),back=.false.)
        IF (icomm.gt.0) linp=icomm-1
        line=trim(adjustl(inpline(1:linp)))
        linp=len_trim(line)
      ELSE
        line=trim(adjustl(inpline))
        linp=len_trim(line)
      END IF
!
!  If not a blank or comment line [char(33)=!], decode and extract input
!  values.  Find equal sign [char(61)].
!
      status=-1
      nested=.false.
      IF ((linp.gt.0).and.(line(1:1).ne.char(33))) THEN
        status=1
        kstr=1
        kend=index(line,char(61),back=.false.)-1
        lstr=index(line,char(61),back=.true.)+1
!
! Determine if KEYWORD is followed by double equal sign (==) indicating
! nested parameter.
!
        IF ((lstr-kend).eq.3) nested=.true.
!
! Extract KEYWORD, trim leading and trailing blanks.
!
        kextract=.false.
        IF (kend.gt.0) THEN
          lend=linp
          keyword=line(kstr:kend)
          nval=0
          kextract=.true.
        ELSE
          lstr=1
          lend=linp
          kextract=.true.
        END IF
!
! Extract parameter values string.  Remove continuation symbol
! [char(92)=\] or multi-line value [char(124)=|], if any.  Trim
! leading trailing blanks.
!
        IF (kextract) THEN
          icont=index(line,char(92 ),back=.false.)
          ipipe=index(line,char(124),back=.false.)
          IF (icont.gt.0) lend=icont-1
          IF (ipipe.gt.0) lend=ipipe-1
          vstring=adjustl(line(lstr:lend))
          lval=len_trim(vstring)
!
! The TITLE KEYWORD is a special one since it can include strings,
! numbers, spaces, and continuation symbol.
!
          isstring=.false.
          IF (trim(keyword).eq.'TITLE') THEN
            nval=nval+1
            cval(nval)=vstring(1:lval)
            isstring=.true.
          ELSE
!
! Check if there is a multiplication symbol [char(42)=*] in the variable
! string indicating repetition of input values.
!
            nmul=0
            DO i=1,lval
              IF (vstring(i:i).eq.char(42)) THEN
                nmul=nmul+1
                imul(nmul)=i
              END IF
            END DO
            ic=1
!
! Check for blank spaces [char(32)=' '] between entries and decode.
!
            is=1
            ie=lval
            iblank=0
            decode=.false.
            DO i=1,lval
              IF (vstring(i:i).eq.char(32)) THEN
                IF (vstring(i+1:i+1).ne.char(32)) decode=.true.
                iblank=i
              ELSE
                ie=i
              ENDIF
              IF (decode.or.(i.eq.lval)) THEN
                nval=nval+1
!
! Processing numeric values.  Check starting character to determine
! if numeric or character values. It is possible to have both when
! processing repetitions via the multiplication symbol.
!
                schar=ichar(vstring(is:is))
                IF (((48.le.schar).and.(schar.le.57)).or.               &
     &              (schar.eq.43).or.(schar.eq.45)) THEN
                  IF ((nmul.gt.0).and.                                  &
     &                (is.lt.imul(ic)).and.(imul(ic).lt.ie)) THEN
                    READ (vstring(is:imul(ic)-1),*) copies
                    schar=ichar(vstring(imul(ic)+1:imul(ic)+1))
                    IF ((43.le.schar).and.(schar.le.57)) THEN
                      READ (vstring(imul(ic)+1:ie),*) rval(nval)
                      DO j=1,copies-1
                        rval(nval+j)=rval(nval)
                      END DO
                    ELSE
                      string=vstring(imul(ic)+1:ie)
                      lens=len_trim(string)
                      cval(nval)=string(1:lens)
                      DO j=1,copies-1
                        cval(nval+j)=cval(nval)
                      END DO
                    END IF
                    nval=nval+copies-1
                    ic=ic+1
                  ELSE
                    string=vstring(is:ie)
                    lens=len_trim(string)
                    READ (string(1:lens),*) rval(nval)
                  END IF
                ELSE
!
! Processing character values (logicals and strings).
!
                  IF ((nmul.gt.0).and.                                  &
     &                (is.lt.imul(ic)).and.(imul(ic).lt.ie)) THEN
                    READ (vstring(is:imul(ic)-1),*) copies
                    cval(nval)=vstring(imul(ic)+1:ie)
                    DO j=1,copies-1
                      cval(nval+j)=cval(nval)
                    END DO
                    nval=nval+copies-1
                    ic=ic+1
                  ELSE
                    string=vstring(is:ie)
                    cval(nval)=trim(adjustl(string))
                  END IF
                  isstring=.true.
                END IF
                is=iblank+1
                ie=lval
                decode=.false.
              END IF
            END DO
          END IF
        END IF
        status=nval
      END IF
      decode_line=status
!
      RETURN
      END FUNCTION decode_line
!
      FUNCTION find_file (ng, out, fname, KeyWord) RESULT (foundit)
!
!***********************************************************************
!                                                                      !
!  This function checks if provided input file exits.                  !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     ng         Nested grid number                                    !
!     out        Standard output unit                                  !
!     fname      Filename (path and name)                              !
!     KeyWord    Keyword associated with file name (string,OPTIONAL)   !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     foundit    The value of the result is TRUE/FALSE if the file     !
!                  was found or not                                    !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer, intent(in) :: ng, out
!
      character (len=*), intent(in) :: fname
      character (len=*), intent(in) :: keyword
!
!  Local variable declarations.
!
      logical :: foundit, isurl
!
      integer :: lstr, ncid
!
      character (len=*), parameter :: myfile =                          &
     &  __FILE__//", find_file"
!
      sourcefile=myfile
!
!-----------------------------------------------------------------------
!  Check if the file exit.
!-----------------------------------------------------------------------
!
      foundit=.false.
!
!  Check for empty file name string.
!
      lstr=len_trim(fname)
      IF (lstr.eq.0) THEN
        IF (master) THEN
          WRITE (stdout,10) trim(keyword)
 10       FORMAT (/,' FIND_FILE - empty file name string ',             &
     &            'for standard input script KeyWord: ',a)
        END IF
        exit_flag=5
        IF (founderror(exit_flag, noerror, __line__, myfile)) RETURN
      END IF
!
!  Check if provided file is a URL.  This implies the file is a NetCDF
!  file on Data Access Protocol (DAP) server (like OPeNDAP).
!
      isurl=.false.
      IF (index(trim(fname),'http:').ne.0) THEN
        isurl=.true.
      END IF
!
!  Use F90 intrinsic function for non URL files.
!
      IF (.not.isurl) THEN
        INQUIRE (file=trim(fname), exist=foundit)
!
!  Use NetCDF library (version 4.1.1 or higher) to check URL NetCDF
!  files.
!
      ELSE
        CALL netcdf_open (ng, inlm, fname, 0, ncid)
        IF (exit_flag.eq.noerror) THEN
          foundit=.true.
          CALL netcdf_close (ng, inlm, ncid, fname, .false.)
        END IF
      END IF
!
!  Report if not found.
!
      IF (.not.foundit) THEN
        IF (master) WRITE (out,20) ng, trim(fname)
 20     FORMAT (/,' FIND_FILE - Grid ',i2.2,                           &
     &          ', cannot find input file: ',a)
        exit_flag=5
      END IF
!
      RETURN
      END FUNCTION find_file
!
      FUNCTION load_0d_i (Ninp, Vinp, Nout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model scalar integer         !
!  variable.                                                           !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Nout       Size of output integer variable dimension (not used)  !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output scalar integer variable                        !
!     Nval       Number of output values processed                     !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, nout
      real(dp), intent(in) :: vinp(:)
!
      integer, intent(out) :: vout
!
!  Local variable declarations.
!
      integer :: ic
      integer :: nval
!
!-----------------------------------------------------------------------
!  Load scalar integer variable with input value.
!-----------------------------------------------------------------------
!
      ic=1
      vout=int(vinp(ic))
      nval=ic
 
      RETURN
      END FUNCTION load_0d_i
!
      FUNCTION load_1d_i (Ninp, Vinp, Nout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 1D integer array.      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Nout       Size of output integer variable dimension             !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 1D integer variable                            !
!     Nval       Number of output values processed                     !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, nout
      real(dp), intent(in) :: vinp(:)
!
      integer, intent(out) :: vout(:)
!
!  Local variable declarations.
!
      integer :: nstr, i, ic
      integer :: nval
!
!-----------------------------------------------------------------------
!  Load 1D integer variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
          vout(i)=int(vinp(i))
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
            vout(i)=int(vinp(ninp))
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
          vout(i)=int(vinp(i))
        END DO
      END IF
      nval=ic
 
      RETURN
      END FUNCTION load_1d_i
!
      FUNCTION load_2d_i (Ninp, Vinp, Iout, Jout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 2D integer array.      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Iout       Size of output integer variable first  I-dimension    !
!     Jout       Size of output integer variable second J-dimension    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 2D integer variable                            !
!     Nval       Number of output values processed                     !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, iout, jout
      real(dp), intent(in) :: vinp(:)
!
      integer, intent(out) :: vout(:,:)
!
!  Local variable declarations.
!
      integer :: nstr, i, ic
      integer :: nout, nval
!
      integer, dimension(Iout*Jout) :: vwrk
!
!-----------------------------------------------------------------------
!  Load 2D integer variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the 2D array.
!
      ic=0
      nout=iout*jout
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
          vwrk(i)=int(vinp(i))
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
            vwrk(i)=int(vinp(ninp))
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
          vwrk(i)=int(vinp(i))
        END DO
      END IF
      vout=reshape(vwrk,(/iout,jout/))
      nval=ic
!
      RETURN
      END FUNCTION load_2d_i
!
      FUNCTION load_3d_i (Ninp, Vinp, Iout, Jout, Kout, Vout)           &
     &                    result(nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 3D integer array.      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Iout       Size of output integer variable first  I-dimension    !
!     Jout       Size of output integer variable second J-dimension    !
!     Kout       Size of output integer variable third  K-dimension    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 3D integer variable                            !
!     Nval       Number of output values processed                     !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, iout, jout, kout
      real(dp), intent(in) :: vinp(:)
!
      integer, intent(out) :: vout(:,:,:)
!
!  Local variable declarations.
!
      integer :: nstr, i, ic
      integer :: nout, nval
!
      integer, dimension(Iout*Jout*Kout) :: vwrk
!
!-----------------------------------------------------------------------
!  Load 3D integer variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the 3D array.
!
      ic=0
      nout=iout*jout*kout
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
          vwrk(i)=int(vinp(i))
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
            vwrk(i)=int(vinp(ninp))
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
          vwrk(i)=int(vinp(i))
        END DO
      END IF
      vout=reshape(vwrk,(/iout,jout,kout/))
      nval=ic
!
      RETURN
      END FUNCTION load_3d_i
!
      FUNCTION load_0d_l (Ninp, Vinp, Nout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model scalar logical         !
!  variable.                                                           !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (character 1D array)                     !
!     Nout       Size of output logical variable dimension (not used)  !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output scalar logical variable                        !
!     Nval       Number of output values processed                     !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer, intent(in) :: ninp, nout
      character (len=*), intent(in) :: vinp(:)
!
      logical, intent(out) :: vout
!
!  Local variable declarations.
!
      integer :: ic
      integer :: nval
!
!-----------------------------------------------------------------------
!  Load scalar logical variable with input value.
!-----------------------------------------------------------------------
!
      ic=1
      IF ((vinp(ic)(1:1).eq.'T').or.                                    &
     &    (vinp(ic)(1:1).eq.'t')) THEN
        vout=.true.
      ELSE
        vout=.false.
      END IF
      nval=ic
!
      RETURN
      END FUNCTION load_0d_l
!
      FUNCTION load_1d_l (Ninp, Vinp, Nout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 1D logical array.      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (character 1D array)                     !
!     Nout       Size of output logical variable dimension             !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 1D logical variable                            !
!     Nval       Number of output values processed                     !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer, intent(in) :: ninp, nout
      character (len=*), intent(in) :: vinp(:)
!
      logical, intent(out) :: vout(:)
!
!  Local variable declarations.
!
      logical :: lastvalue
 
      integer :: nstr, i, ic
      integer :: nval
!
!-----------------------------------------------------------------------
!  Load logical variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      lastvalue=.false.
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
          IF ((vinp(i)(1:1).eq.'T').or.                                 &
     &        (vinp(i)(1:1).eq.'t')) THEN
            vout(i)=.true.
          ELSE
            vout(i)=.false.
          END IF
          lastvalue=vout(i)
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
            vout(i)=lastvalue
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
          IF ((vinp(i)(1:1).eq.'T').or.                                 &
     &        (vinp(i)(1:1).eq.'t')) THEN
            vout(i)=.true.
          ELSE
            vout(i)=.false.
          END IF
        END DO
      END IF
      nval=ic
!
      RETURN
      END FUNCTION load_1d_l
!
      FUNCTION load_2d_l (Ninp, Vinp, Iout, Jout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 2D logical array.      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (character 1D array)                     !
!     Iout       Size of output logical variable first  I-dimension    !
!     Jout       Size of output logical variable second J-dimension    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 2D logical variable                            !
!     Nval       Number of output values processed                     !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer, intent(in) :: ninp, iout, jout
      character (len=*), intent(in) :: vinp(:)
!
      logical, intent(out) :: vout(:,:)
!
!  Local variable declarations.
!
      logical :: lastvalue
!
      logical, dimension(Iout*Jout) :: vwrk
!
      integer :: nstr, i, ic
      integer :: nout, nval
!
!-----------------------------------------------------------------------
!  Load 2D logical variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      nout=iout*jout
      lastvalue=.false.
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
          IF ((vinp(i)(1:1).eq.'T').or.                                 &
     &        (vinp(i)(1:1).eq.'t')) THEN
            vwrk(i)=.true.
          ELSE
            vwrk(i)=.false.
          END IF
          lastvalue=vwrk(i)
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
            vwrk(i)=lastvalue
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
          IF ((vinp(i)(1:1).eq.'T').or.                                 &
     &        (vinp(i)(1:1).eq.'t')) THEN
            vwrk(i)=.true.
          ELSE
            vwrk(i)=.false.
          END IF
        END DO
      END IF
      vout=reshape(vwrk,(/iout,jout/))
      nval=ic
!
      RETURN
      END FUNCTION load_2d_l
!
      FUNCTION load_3d_l (Ninp, Vinp, Iout, Jout, Kout, Vout)           &
     &                   result(nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 3D logical array.      !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (character 1D array)                     !
!     Iout       Size of output logical variable first  I-dimension    !
!     Jout       Size of output logical variable second J-dimension    !
!     Kout       Size of output logical variable third  K-dimension    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 3D logical variable                            !
!     Nval       Number of output values processed                     !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer, intent(in) :: ninp, iout, jout, kout
      character (len=*), intent(in) :: vinp(:)
!
      logical, intent(out) :: vout(:,:,:)
!
!  Local variable declarations.
!
      logical :: lastvalue
!
      logical, dimension(Iout*Jout*Kout) :: vwrk
!
      integer :: nstr, i, ic
      integer :: nout, nval
!
!-----------------------------------------------------------------------
!  Load 3D logical variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      nout=iout*jout*kout
      lastvalue=.false.
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
          IF ((vinp(i)(1:1).eq.'T').or.                                 &
     &        (vinp(i)(1:1).eq.'t')) THEN
            vwrk(i)=.true.
          ELSE
            vwrk(i)=.false.
          END IF
          lastvalue=vwrk(i)
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
            vwrk(i)=lastvalue
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
          IF ((vinp(i)(1:1).eq.'T').or.                                 &
     &        (vinp(i)(1:1).eq.'t')) THEN
            vwrk(i)=.true.
          ELSE
            vwrk(i)=.false.
          END IF
        END DO
      END IF
      vout=reshape(vwrk,(/iout,jout,kout/))
      nval=ic
!
      RETURN
      END FUNCTION load_3d_l
 
#ifdef SINGLE_PRECISION
!
      FUNCTION load_0d_dp (Ninp, Vinp, Nout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model scalar double          !
!  precision variable when numerical kernel is in single precision.    !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Nout       Size of output integer variable dimension (not used)  !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output scalar variable (real, KIND=dp)                !
!     Nval       Number of output values processed                     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, nout
      real(dp), intent(in) :: vinp(:)
!
      real(dp), intent(out) :: vout
!
!  Local variable declarations.
!
      integer :: ic
      integer :: nval
!
!-----------------------------------------------------------------------
!  Load scalar floating-point variable with input value.
!-----------------------------------------------------------------------
!
      ic=1
      vout=vinp(ic)
      nval=ic
!
      RETURN
      END FUNCTION load_0d_dp
!
      FUNCTION load_1d_dp (Ninp, Vinp, Nout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 1D double precision    !
!  array when numerical kernel is in single precision.                 !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Nout       Size of output integer variable dimension             !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 1D variable (real, KIND=dp)                    !
!     Nval       Number of output values processed                     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, nout
      real(dp), intent(in) :: vinp(:)
!
      real(dp), intent(out) :: vout(:)
!
!  Local variable declarations.
!
      integer :: nstr, i, ic
      integer :: nval
!
!-----------------------------------------------------------------------
!  Load 1D floating-point variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
          vout(i)=vinp(i)
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
            vout(i)=vinp(ninp)
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
          vout(i)=vinp(i)
        END DO
      END IF
      nval=ic
!
      RETURN
      END FUNCTION load_1d_dp
!
      FUNCTION load_2d_dp (Ninp, Vinp, Iout, Jout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 2D double precision    !
!  array when numerical kernel is in single precision.                 !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Iout       Size of output integer variable first  I-dimension    !
!     Jout       Size of output integer variable second J-dimension    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 2D variable (real, KIND=dp)                    !
!     Nval       Number of output values processed                     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, iout, jout
      real(dp), intent(in) :: vinp(:)
!
      real(dp), intent(out) :: vout(:,:)
!
!  Local variable declarations.
!
      integer :: nstr, i, ic
      integer :: nout, nval
!
      real(dp), dimension(Iout*Jout) :: vwrk
!
!-----------------------------------------------------------------------
!  Load 2D floating-point variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      nout=iout*jout
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
          vwrk(i)=vinp(i)
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
            vwrk(i)=vinp(ninp)
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
          vwrk(i)=vinp(i)
        END DO
      END IF
      vout=reshape(vwrk,(/iout,jout/))
      nval=ic
!
      RETURN
      END FUNCTION load_2d_dp
!
      FUNCTION load_3d_dp (Ninp, Vinp, Iout, Jout, Kout, Vout)          &
     &                     result(nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 3D double precision    !
!  array when numerical kernel is in single precision.                 !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Iout       Size of output integer variable first  I-dimension    !
!     Jout       Size of output integer variable second J-dimension    !
!     Kout       Size of output integer variable third  K-dimension    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 3D variable (real, KIND=dp)                    !
!     Nval       Number of output values processed                     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, iout, jout, kout
      real(dp), intent(in) :: vinp(:)
!
      real(dp), intent(out) :: vout(:,:,:)
!
!  Local variable declarations.
!
      integer :: nstr, i, ic
      integer :: nout, nval
!
      real(dp), dimension(Iout*Jout*Kout) :: vwrk
!
!-----------------------------------------------------------------------
!  Load 3D floating-point variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      nout=iout*jout*kout
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
          vwrk(i)=vinp(i)
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
            vwrk(i)=vinp(ninp)
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
          vwrk(i)=vinp(i)
        END DO
      END IF
      vout=reshape(vwrk,(/iout,jout,kout/))
      nval=ic
!
      RETURN
      END FUNCTION load_3d_dp
#endif
!
      FUNCTION load_0d_r8 (Ninp, Vinp, Nout, Vout) RESULT (Nval)
!
!=======================================================================
!                                                                      !
!  It loads input values into a requested model scalar floating-point  !
!  variable (KIND=r8).                                                 !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Nout       Size of output integer variable dimension (not used)  !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output scalar variable (real, KIND=r8)                !
!     Nval       Number of output values processed                     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, nout
      real(dp), intent(in) :: vinp(:)
!
      real(r8), intent(out) :: vout
!
!  Local variable declarations.
!
      integer :: ic
      integer :: nval
!
!-----------------------------------------------------------------------
!  Load scalar floating-point variable with input value.
!-----------------------------------------------------------------------
!
      ic=1
#ifdef SINGLE_PRECISION
      vout=real(vinp(ic),r8)
#else
      vout=vinp(ic)
#endif
      nval=ic
!
      RETURN
      END FUNCTION load_0d_r8
!
      FUNCTION load_1d_r8 (Ninp, Vinp, Nout, Vout) RESULT (Nval)
!
!=======================================================================
!                                                                      !
!  It loads input values into a requested model 1D floating-point      !
!  array (KIND=r8).                                                    !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Nout       Size of output integer variable dimension             !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 1D variable (real, KIND=r8)                    !
!     Nval       Number of output values processed                     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, nout
      real(dp), intent(in) :: vinp(:)
!
      real(r8), intent(out) :: vout(:)
!
!  Local variable declarations.
!
      integer :: nstr, i, ic
      integer :: nval
!
!-----------------------------------------------------------------------
!  Load 1D floating-point variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
#ifdef SINGLE_PRECISION
          vout(i)=real(vinp(i),r8)
#else
          vout(i)=vinp(i)
#endif
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
#ifdef SINGLE_PRECISION
            vout(i)=real(vinp(ninp),r8)
#else
            vout(i)=vinp(ninp)
#endif
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
#ifdef SINGLE_PRECISION
          vout(i)=real(vinp(i),r8)
#else
          vout(i)=vinp(i)
#endif
        END DO
      END IF
      nval=ic
!
      RETURN
      END FUNCTION load_1d_r8
!
      FUNCTION load_2d_r8 (Ninp, Vinp, Iout, Jout, Vout) RESULT (Nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 2D floating-point      !
!  array (KIND=r8).                                                    !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Iout       Size of output integer variable first  I-dimension    !
!     Jout       Size of output integer variable second J-dimension    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 2D variable (real, KIND=r8)                    !
!     Nval       Number of output values processed                     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, iout, jout
      real(dp), intent(in) :: vinp(:)
!
      real(r8), intent(out) :: vout(:,:)
!
!  Local variable declarations.
!
      integer :: nstr, i, ic
      integer :: nout, nval
!
      real(r8), dimension(Iout*Jout) :: vwrk
!
!-----------------------------------------------------------------------
!  Load 2D floating-point variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      nout=iout*jout
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
#ifdef SINGLE_PRECISION
          vwrk(i)=real(vinp(i),r8)
#else
          vwrk(i)=vinp(i)
#endif
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
#ifdef SINGLE_PRECISION
            vwrk(i)=real(vinp(ninp),r8)
#else
            vwrk(i)=vinp(ninp)
#endif
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
#ifdef SINGLE_PRECISION
          vwrk(i)=real(vinp(i),r8)
#else
          vwrk(i)=vinp(i)
#endif
        END DO
      END IF
      vout=reshape(vwrk,(/iout,jout/))
      nval=ic
!
      RETURN
      END FUNCTION load_2d_r8
!
      FUNCTION load_3d_r8 (Ninp, Vinp, Iout, Jout, Kout, Vout)          &
     &                     result(nval)
!
!***********************************************************************
!                                                                      !
!  It loads input values into a requested model 3D floating-point      !
!  array (KIND=r8).                                                    !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Number of input elements to process in Vinp (integer) !
!     Vinp       Input values (1D real(dp) array)                      !
!     Iout       Size of output integer variable first  I-dimension    !
!     Jout       Size of output integer variable second J-dimension    !
!     Kout       Size of output integer variable third  K-dimension    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     Vout       Output 3D variable (real, KIND=r8)                    !
!     Nval       Number of output values processed                     !
!                                                                      !
!=======================================================================
!
!  Imported variable declarations.
!
      integer,  intent(in) :: ninp, iout, jout, kout
      real(dp), intent(in) :: vinp(:)
!
      real(r8), intent(out) :: vout(:,:,:)
!
!  Local variable declarations.
!
      integer :: nstr, i, ic
      integer :: nout, nval
!
      real(r8), dimension(Iout*Jout*Kout) :: vwrk
!
!-----------------------------------------------------------------------
!  Load 3D floating-point variable with input values.
!-----------------------------------------------------------------------
!
!  If not all values are provided for variable, assume the last value
!  for the rest of the array.
!
      ic=0
      nout=iout*jout*kout
      IF (ninp.le.nout) THEN
        DO i=1,ninp
          ic=ic+1
#ifdef SINGLE_PRECISION
          vwrk(i)=real(vinp(i),r8)
#else
          vwrk(i)=vinp(i)
#endif
        END DO
        IF (nout.gt.ninp) THEN
          nstr=ninp+1
          DO i=nstr,nout
            ic=ic+1
#ifdef SINGLE_PRECISION
            vwrk(i)=real(vinp(ninp),r8)
#else
            vwrk(i)=vinp(ninp)
#endif
          END DO
        END IF
      ELSE
        DO i=1,nout
          ic=ic+1
#ifdef SINGLE_PRECISION
          vwrk(i)=real(vinp(i),r8)
#else
          vwrk(i)=vinp(i)
#endif
        END DO
      END IF
      vout=reshape(vwrk,(/iout,jout,kout/))
      nval=ic
!
      RETURN
      END FUNCTION load_3d_r8
!
      FUNCTION load_lbc (Ninp, Vinp, line, nline, ifield, igrid,        &
     &                   iTrcStr, iTrcEnd, svname, S)
!
!***********************************************************************
!                                                                      !
!  This function sets lateral boundary conditions logical switches     !
!  according to input string keywords.                                 !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Size of input variable (integer)                      !
!     Vinp       Input values (string)                                 !
!     line       Current input line (string)                           !
!     nline      Multi-line counter (integer)                          !
!     ifield     Lateral boundary variable index (integer)             !
!     igrid      Nested grid counter (integer)                         !
!     iTrcStr    Starting tracer index to process (integer)            !
!     iTrcEnd    Ending   tracer index to process (integer)            !
!     svname     State variable name (string)                          !
!     S          Derived type structure, TYPE(T_LBC)                   !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     nline      Updated multi-line counter (integer)                  !
!     igrid      Updated nested grid counter (integer)                 !
!     S          Updated derived type structure, TYPE(T_LBC)           !
!     load_lbc   Number of output values processed.                    !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer, intent(in) :: ninp, ifield, itrcstr, itrcend
      integer, intent(inout) :: igrid, nline
 
      character (len=256), intent(in) :: line
      character (len=256), intent(in) :: vinp(ninp)
      character (len=*  ), intent(in) :: svname
 
      TYPE(t_lbc), intent(inout) :: s(4,nlbcvar,ngrids)
!
!  Local variable declarations.
!
      integer :: icont, i, ib, ic
      integer :: load_lbc
 
      character (len=10) :: bstring(4), string
!
!-----------------------------------------------------------------------
!  Set lateral boundary conditions switches in structure.
!-----------------------------------------------------------------------
!
!  Check current line for the continuation symbol [char(92)=\].
!
      icont=index(trim(line),char(92) ,back=.false.)
!
!  Extract lateral boundary condition keywords from Vinp. Notice that
!  additional array elements are added to Vinp during continuation
!  lines.
!
      i=nline*4
      bstring(1)=trim(vinp(i+1))
      bstring(2)=trim(vinp(i+2))
      bstring(3)=trim(vinp(i+3))
      bstring(4)=trim(vinp(i+4))
!
!  Advance or reset entry lines counter.
!
      IF (icont.gt.0) THEN
        nline=nline+1
      ELSE
        nline=0
      END IF
!
!  Set switches for each boundary segment.
!
      ic=1
      IF ((0.lt.ifield).and.(ifield.le.nlbcvar)) THEN
        DO ib=1,4
          string=uppercase(bstring(ib))
          SELECT CASE (trim(string))
            CASE ('CHA')
              s(ib,ifield,igrid)%Chapman_implicit = .true.
            CASE ('CHE')
              s(ib,ifield,igrid)%Chapman_explicit = .true.
            CASE ('CLA')
              s(ib,ifield,igrid)%clamped = .true.
              s(ib,ifield,igrid)%acquire = .true.
            CASE ('CLO')
              s(ib,ifield,igrid)%closed = .true.
            CASE ('FLA')
              s(ib,ifield,igrid)%Flather = .true.
              s(ib,ifield,igrid)%acquire = .true.
              s(ib,isfsur,igrid)%acquire = .true.
            CASE ('GRA')
              s(ib,ifield,igrid)%gradient = .true.
            CASE ('MIX')
              s(ib,ifield,igrid)%mixed   = .true.
              s(ib,ifield,igrid)%acquire = .true.
            CASE ('NES')
              s(ib,ifield,igrid)%nested = .true.
            CASE ('PER')
              s(ib,ifield,igrid)%periodic = .true.
              IF ((ib.eq.ieast).or.(ib.eq.iwest)) THEN
                ewperiodic(igrid)=.true.
              ELSE IF ((ib.eq.inorth).or.(ib.eq.isouth)) THEN
                nsperiodic(igrid)=.true.
              END IF
            CASE ('RAD')
              s(ib,ifield,igrid)%radiation = .true.
            CASE ('RADNUD')
              s(ib,ifield,igrid)%radiation = .true.
              s(ib,ifield,igrid)%nudging = .true.
              s(ib,ifield,igrid)%acquire = .true.
            CASE ('RED')
              s(ib,ifield,igrid)%reduced = .true.
#if defined FSOBC_REDUCED
              s(ib,isfsur,igrid)%acquire = .true.
#endif
            CASE ('SHC')
              s(ib,ifield,igrid)%Shchepetkin = .true.
              s(ib,ifield,igrid)%acquire = .true.
              s(ib,isfsur,igrid)%acquire = .true.
            CASE DEFAULT
              IF (master) THEN
                WRITE (stdout,10) trim(vinp(ib)), trim(line)
              END IF
              exit_flag=2
              RETURN
          END SELECT
        END DO
 
#ifdef SOLVE3D
!
!  If processing tracers and last standard input entry (Icont=0), set
!  unspecified tracer values to the last tracer entry.
!
        IF ((itrcstr.gt.0).and.(itrcend.gt.0)) THEN
          IF ((icont.eq.0).and.(ifield.lt.istvar(itrcend))) THEN
            DO i=ifield+1,istvar(itrcend)
              DO ib=1,4
                s(ib,i,igrid)%clamped   = s(ib,ifield,igrid)%clamped
                s(ib,i,igrid)%closed    = s(ib,ifield,igrid)%closed
                s(ib,i,igrid)%gradient  = s(ib,ifield,igrid)%gradient
                s(ib,i,igrid)%nested    = s(ib,ifield,igrid)%nested
                s(ib,i,igrid)%periodic  = s(ib,ifield,igrid)%periodic
                s(ib,i,igrid)%radiation = s(ib,ifield,igrid)%radiation
                s(ib,i,igrid)%nudging   = s(ib,ifield,igrid)%nudging
                s(ib,i,igrid)%acquire   = s(ib,ifield,igrid)%acquire
              END DO
              ic=ic+1
            END DO
          END IF
        END IF
#endif
      END IF
!
!  If appropriate, increase or reset nested grid counter.
!
      IF ((icont.gt.0).and.(ngrids.gt.1)) THEN
        IF ((itrcstr.gt.0).and.(itrcend.gt.0)) THEN
          IF ((ifield.eq.istvar(itrcend)).or.(ic.gt.1)) THEN
            igrid=igrid+min(1,icont)
          END IF
        ELSE
          igrid=igrid+min(1,icont)
        END IF
        IF (igrid.gt.ngrids) THEN
          IF (master) THEN
            WRITE (stdout,20) trim(line)
          END IF
          exit_flag=2
          RETURN
        END IF
      ELSE
        igrid=1
      END IF
      load_lbc=ic
 
 10   FORMAT (/,' LOAD_LBC - illegal lateral boundary condition ',      &
     &        'keyword: ',a,/,12x,a)
 20   FORMAT (/,' LOAD_LBC - incorrect continuation symbol in line:',/, &
     &        12x,a,/,12x,'number of nested grid values exceeded.')
!
      RETURN
      END FUNCTION load_lbc
!
      FUNCTION load_s1d1 (Nval, Fname, Fdim, line, label, igrid,        &
     &                    Mgrids, Nfiles, io_type, S)
!
!***********************************************************************
!                                                                      !
!  This function loads input values into requested 1D structure        !
!  S(Mgrids) containing information about I/O files.                   !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Nval        Number of values processed (integer)                 !
!     Fname       File name(s) processed (string array)                !
!     Fdim        File name(s) dimension in calling program (integer)  !
!     line        Current input line (string)                          !
!     label       I/O structure label (string)                         !
!     igrid       Nested grid counter (integer)                        !
!     Mgrids      Number of nested grids (integer)                     !
!     Nfiles      Number of files per grid (integer array)             !
!     io_type     File I/O type (integer)                              !
!     S(Mgrids)   Derived type structure array, TYPE(T_IO)             !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     igrid       Updated nested grid counter.                         !
!     S(Mgrids)   Updated derived type structure array, TYPE(T_IO).    !
!     load_s1d_1  Number of output values processed.                   !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer, intent(in)    :: mgrids, nval, fdim, io_type
      integer, intent(inout) :: igrid
      integer, intent(inout) :: nfiles(mgrids)
 
      character (len=*),   intent(in) :: line
      character (len=256), intent(in) :: fname(fdim)
      character (len=*),   intent(inout) :: label
 
      TYPE(t_io), intent(inout) :: s(mgrids)
!
!  Local variable declarations.
!
      logical :: load, persist
 
      integer :: icont, ipipe, i, is, j, lstr, my_mgrids, ng
      integer :: load_s1d1
 
      character (len=1 ), parameter :: blank = ' '
!
!-----------------------------------------------------------------------
!  Count files for all grids and activate load switch.
!-----------------------------------------------------------------------
!
!  Check current line for the continuation symbol [char(92)=\] or pipe
!  symbol [char(124)=|]. The continuation symbol is used to separate
!  string values for different grid, whereas the pipe symbol is used
!  to separate multi-string values for split input files. User may
!  split the records for a particular input field into several files.
!
      icont=index(trim(line),char(92) ,back=.false.)
      ipipe=index(trim(line),char(124),back=.false.)
      IF ((icont.eq.0).and.(ipipe.eq.0)) THEN
        load=.true.                           ! last input string
      ELSE
        load=.false.                          ! process next string
      END IF
!
!  Accumulate number of multi-files per each grid.
!
      nfiles(igrid)=nfiles(igrid)+1
!
!  Set grid counter.
!
      IF (.not.load) THEN
        igrid=igrid+min(1,icont)
      END IF
      IF (igrid.gt.mgrids) THEN
        IF (master) THEN
          WRITE (stdout,10) trim(line)
        END IF
        exit_flag=2
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Load I/O information into structure.
!-----------------------------------------------------------------------
!
      IF (load) THEN
!
!  If nesting and the number of file name entries is less than Mgrids,
!  persist the last values provided.  This is the case when not enough
!  entries are provided by "==" plural symbol after the KEYWORD.
!
        IF (igrid.lt.mgrids) THEN
          DO i=igrid+1,mgrids
            nfiles(i)=nfiles(igrid)
          END DO
          my_mgrids=igrid
          persist=.true.
        ELSE
          my_mgrids=mgrids
          persist=.false.
        END IF
!
!  Allocate various fields in structure, if not continuation or pipe
!  symbol is found which indicates end of input data.
!
        IF (label(1:3).eq.'FLT') THEN
#ifdef FLOAT_BIOLOGY
          is=-10
#else
          is=-6
#endif
        ELSE
          is=1
        END IF
!
        DO ng=1,mgrids
          allocate ( s(ng)%Nrec(nfiles(ng)) )
          allocate ( s(ng)%time_min(nfiles(ng)) )
          allocate ( s(ng)%time_max(nfiles(ng)) )
          allocate ( s(ng)%Vid(is:nv) )
          allocate ( s(ng)%Tid(mt) )
#if defined PIO_LIB && defined DISTRIBUTE
          allocate ( s(ng)%pioVar(is:nv) )
          allocate ( s(ng)%pioTrc(mt) )
#endif
          allocate ( s(ng)%files(nfiles(ng)) )
        END DO
!
!  Intialize strings to blank to facilitate processing.
!
        DO ng=1,mgrids
          lstr=len(s(ng)%name)
          DO i=1,lstr
            s(ng)%head(i:i)=blank
            s(ng)%base(i:i)=blank
            s(ng)%name(i:i)=blank
          END DO
          DO j=1,nfiles(ng)
            DO i=1,lstr
              s(ng)%files(j)(i:i)=blank
            END DO
          END DO
        END DO
!
!  Initialize and load fields into structure.
!
        i=0
        DO ng=1,my_mgrids
          s(ng)%IOtype=io_type                 ! file IO type
          s(ng)%Nfiles=nfiles(ng)              ! number of multi-files
          s(ng)%Fcount=1                       ! multi-file counter
          s(ng)%load=1                         ! filename load counter
          s(ng)%Rindex=0                       ! time index
          s(ng)%ncid=-1                        ! closed NetCDF state
          s(ng)%Vid=-1                         ! NetCDF variables IDs
          s(ng)%Tid=-1                         ! NetCDF tracers IDs
#if defined PIO_LIB && defined DISTRIBUTE
          s(ng)%pioFile%fh=-1                  ! closed file handler
          DO j=1,nv
            s(ng)%pioVar(j)%vd%varID=-1        ! variables IDs
            s(ng)%pioVar(j)%dkind=-1           ! variables data kind
            s(ng)%pioVar(j)%gtype=0            ! variables C-grid type
          END DO
          DO j=1,mt
            s(ng)%pioTrc(j)%vd%varID=-1        ! tracers IDs
            s(ng)%pioTrc(j)%dkind=-1           ! tracers data kind
            s(ng)%pioTrc(j)%gtype=0            ! tracers C-grid type
          END DO
#endif
          DO j=1,nfiles(ng)
            i=i+1
            s(ng)%files(j)=trim(fname(i))      ! load multi-files
            s(ng)%Nrec(j)=0                    ! record counter
            s(ng)%time_min(j)=0.0_dp           ! starting time
            s(ng)%time_max(j)=0.0_dp           ! ending time
          END DO
          s(ng)%label=trim(label)              ! structure label
          s(ng)%name=trim(s(ng)%files(1))      ! load first file
          lstr=len_trim(s(ng)%name)
          s(ng)%head=s(ng)%name(1:lstr-3)      ! do not include ".nc"
          s(ng)%base=s(ng)%name(1:lstr-3)      ! do not include ".nc"
          nfiles(ng)=0                         ! clean file counter
        END DO
!
!  If appropriate, persist last value(s).
!
        IF (persist) THEN
          DO ng=igrid+1,mgrids
            s(ng)%IOtype=io_type
            s(ng)%Nfiles=s(igrid)%Nfiles
            s(ng)%Fcount=1
            s(ng)%load=1
            s(ng)%Rindex=0
            s(ng)%ncid=-1
            s(ng)%Vid=-1
            s(ng)%Tid=-1
#if defined PIO_LIB && defined DISTRIBUTE
            s(ng)%pioFile%fh=-1
            DO j=is,nv
              s(ng)%pioVar(j)%vd%varID=-1
              s(ng)%pioVar(j)%dkind=-1
              s(ng)%pioVar(j)%gtype=0
            END DO
            DO j=1,mt
              s(ng)%pioTrc(j)%vd%varID=-1
              s(ng)%pioTrc(j)%dkind=-1
              s(ng)%pioTrc(j)%gtype=0
            END DO
#endif
            DO j=1,s(igrid)%Nfiles
              s(ng)%files(j)=s(igrid)%files(j)
              s(ng)%Nrec(j)=0
              s(ng)%time_min(j)=0.0_dp
              s(ng)%time_max(j)=0.0_dp
            END DO
            s(ng)%label=trim(label)
            s(ng)%name=s(igrid)%name
            s(ng)%base=s(igrid)%base
            nfiles(ng)=0
          END DO
        END IF
!
!  Reset counters and clean label.
!
        igrid=1
        DO ng=1,mgrids
          nfiles(ng)=0
        END DO
        DO i=1,len(label)
          label(i:i)=blank
        END DO
      END IF
      load_s1d1=nval
 
 10   FORMAT (/,' LOAD_S1D1 - incorrect continuation symbol in line:',  &
     &        /,14x,a,/,11x,'number of nested grid values exceeded.')
!
      RETURN
      END FUNCTION load_s1d1
!
      FUNCTION load_s1d2 (Nval, Fname, Fdim, line, label, igrid,        &
     &                    Mgrids, Nfiles, idim, Ie, io_type, S)
!
!***********************************************************************
!                                                                      !
!  This function loads input values into requested 2D structure        !
!  S(Ie,:) elemement containing information about I/O files.           !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Nval         Number of values processed (integer)                !
!     Fname        File name(s) processed (string array)               !
!     Fdim         File name(s) dimension in calling program (integer) !
!     line         Current input line (string)                         !
!     label        I/O structure label (string)                        !
!     igrid        Nested grid counter (integer)                       !
!     Mgrids       Number of nested grids (integer)                    !
!     Nfiles       Number of files per grid (integer array)            !
!     idim         Size of structure inner dimension (integer)         !
!     Ie           Inner dimension element to process (integer)        !
!     io_type      File I/O type (integer)                             !
!     S(Ie,Mgrids) Derived type structure array, TYPE(T_IO)            !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     igrid        Updated nested grid counter.                        !
!     S(Ie,Mgrids) Updated derived type structure array, TYPE(T_IO).   !
!     load_s1d_2   Number of output values processed.                  !
!                                                                      !
!***********************************************************************
!
      USE mod_param
      USE mod_parallel
      USE mod_iounits
      USE mod_ncparam
      USE mod_scalars
!
!  Imported variable declarations.
!
      integer, intent(in)    :: mgrids, nval, fdim, ie, idim, io_type
      integer, intent(inout) :: igrid
      integer, intent(inout) :: nfiles(mgrids)
 
      character (len=*),   intent(in) :: line
      character (len=256), intent(in) :: fname(fdim)
      character (len=*),   intent(inout) :: label
 
      TYPE(t_io), intent(inout) :: s(idim,mgrids)
!
!  Local variable declarations.
!
      logical :: load, persist
 
      integer :: icont, ipipe, i, is, j, lstr, my_mgrids, ng
      integer :: load_s1d2
 
      character (len=1 ), parameter :: blank = ' '
!
!-----------------------------------------------------------------------
!  Count files for all grids and activate load switch.
!-----------------------------------------------------------------------
!
!  Check current line for the continuation symbol [char(92)=\] or pipe
!  symbol [char(124)=|]. The continuation symbol is used to separate
!  string values for different grid, whereas the pipe symbol is used
!  to separate multi-string values for split input files. User may
!  split the records for a particular input field into several files.
!
      icont=index(trim(line),char(92) ,back=.false.)
      ipipe=index(trim(line),char(124),back=.false.)
      IF ((icont.eq.0).and.(ipipe.eq.0)) THEN
        load=.true.                           ! last input string
      ELSE
        load=.false.                          ! process next string
      END IF
!
!  Accumulate number of multi-files per each grid.
!
      nfiles(igrid)=nfiles(igrid)+1
!
!  Set grid counter.
!
      IF (.not.load) THEN
        igrid=igrid+min(1,icont)
      END IF
      IF (igrid.gt.mgrids) THEN
        IF (master) THEN
          WRITE (stdout,10) trim(line)
        END IF
        exit_flag=2
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Load I/O information into structure.
!-----------------------------------------------------------------------
!
      IF (load) THEN
!
!  If nesting and the number of file name entries is less than Mgrids,
!  persist the last values provided.  This is the case when not enough
!  entries are provided by "==" plural symbol after the KEYWORD.
!
        IF (igrid.lt.mgrids) THEN
          DO i=igrid+1,mgrids
            nfiles(i)=nfiles(igrid)
          END DO
          my_mgrids=igrid
          persist=.true.
        ELSE
          my_mgrids=mgrids
          persist=.false.
        END IF
!
!  Allocate various fields in structure, if not continuation or pipe
!  symbol is found which indicates end of input data.
!
        DO ng=1,mgrids
          allocate ( s(ie,ng)%Nrec(nfiles(ng)) )
          allocate ( s(ie,ng)%time_min(nfiles(ng)) )
          allocate ( s(ie,ng)%time_max(nfiles(ng)) )
          allocate ( s(ie,ng)%Vid(nv) )
          allocate ( s(ie,ng)%Tid(mt) )
#if defined PIO_LIB && defined DISTRIBUTE
          allocate ( s(ie,ng)%pioVar(nv) )
          allocate ( s(ie,ng)%pioTrc(mt) )
#endif
          allocate ( s(ie,ng)%files(nfiles(ng)) )
        END DO
!
!  Intialize strings to blank to facilitate processing.
!
        DO ng=1,mgrids
          lstr=len(s(ie,ng)%name)
          DO i=1,lstr
            s(ie,ng)%head(i:i)=blank
            s(ie,ng)%base(i:i)=blank
            s(ie,ng)%name(i:i)=blank
          END DO
          DO j=1,nfiles(ng)
            DO i=1,lstr
              s(ie,ng)%files(j)(i:i)=blank
            END DO
          END DO
        END DO
!
!  Initialize and load fields into structure.
!
        i=0
        DO ng=1,my_mgrids
          s(ie,ng)%IOtype=io_type               ! file IO type
          s(ie,ng)%Nfiles=nfiles(ng)            ! number of multi-files
          s(ie,ng)%Fcount=1                     ! multi-file counter
          s(ie,ng)%load=1                       ! filename load counter
          s(ie,ng)%Rindex=0                     ! time index
          s(ie,ng)%ncid=-1                      ! closed NetCDF state
          s(ie,ng)%Vid=-1                       ! NetCDF variables IDs
          s(ie,ng)%Tid=-1                       ! NetCDF tracers IDs
#if defined PIO_LIB && defined DISTRIBUTE
          s(ie,ng)%pioFile%fh=-1                ! closed file handler
          DO j=1,nv
            s(ie,ng)%pioVar(j)%vd%varID=-1      ! variables IDs
            s(ie,ng)%pioVar(j)%dkind=-1         ! variables data kind
            s(ie,ng)%pioVar(j)%gtype=0          ! variables C-grid type
          END DO
          DO j=1,mt
            s(ie,ng)%pioTrc(j)%vd%varID=-1      ! tracers IDs
            s(ie,ng)%pioTrc(j)%dkind=-1         ! tracers data kind
            s(ie,ng)%pioTrc(j)%gtype=0          ! tracers C-grid type
          END DO
#endif
          DO j=1,nfiles(ng)
            i=i+1
            s(ie,ng)%files(j)=trim(fname(i))    ! load multi-files
            s(ie,ng)%Nrec(j)=0                  ! record counter
            s(ie,ng)%time_min(j)=0.0_dp         ! starting time
            s(ie,ng)%time_max(j)=0.0_dp         ! ending time
          END DO
          s(ie,ng)%label=trim(label)            ! structure label
          s(ie,ng)%name=trim(s(ie,ng)%files(1)) ! load first file
          lstr=len_trim(s(ie,ng)%name)
          s(ie,ng)%head=s(ie,ng)%name(1:lstr-3) ! do not include ".nc"
          s(ie,ng)%base=s(ie,ng)%name(1:lstr-3) ! do not include ".nc"
          nfiles(ng)=0                          ! clean file counter
        END DO
!
!  If appropriate, persist last value(s).
!
        IF (persist) THEN
          DO ng=igrid+1,mgrids
            s(ie,ng)%IOtype=io_type
            s(ie,ng)%Nfiles=s(ie,igrid)%Nfiles
            s(ie,ng)%Fcount=1
            s(ie,ng)%load=1
            s(ie,ng)%Rindex=0
            s(ie,ng)%ncid=-1
            s(ie,ng)%Vid=-1
            s(ie,ng)%Tid=-1
#if defined PIO_LIB && defined DISTRIBUTE
            s(ie,ng)%pioFile%fh=-1
            DO j=1,nv
              s(ie,ng)%pioVar(j)%vd%varID=-1
              s(ie,ng)%pioVar(j)%dkind=-1
              s(ie,ng)%pioVar(j)%gtype=0
            END DO
            DO j=1,mt
              s(ie,ng)%pioTrc(j)%vd%varID=-1
              s(ie,ng)%pioTrc(j)%dkind=-1
              s(ie,ng)%pioTrc(j)%gtype=0
            END DO
#endif
            DO j=1,s(ie,igrid)%Nfiles
              s(ie,ng)%files(j)=s(ie,igrid)%files(j)
              s(ie,ng)%Nrec(j)=0
              s(ie,ng)%time_min(j)=0.0_dp
              s(ie,ng)%time_max(j)=0.0_dp
            END DO
            s(ie,ng)%label=trim(label)
            s(ie,ng)%name=s(ie,igrid)%name
            s(ie,ng)%base=s(ie,igrid)%base
            nfiles(ng)=0
          END DO
        END IF
!
!  Reset counters and clean label.
!
        igrid=1
        DO ng=1,mgrids
          nfiles(ng)=0
        END DO
        DO i=1,len(label)
          label(i:i)=blank
        END DO
      END IF
      load_s1d2=nval
 
 10   FORMAT (/,' LOAD_S1D2 - incorrect continuation symbol in line:',  &
     &        /,14x,a,/,11x,'number of nested grid values exceeded.')
!
      RETURN
      END FUNCTION load_s1d2
!
      FUNCTION load_s2d (Nval, Fname, Fdim, line, label, ifile, igrid,  &
     &                   Mgrids, Nfiles, Ncount, idim, io_type, S)
!
!***********************************************************************
!                                                                      !
!  This function loads input values into requested 2D structure        !
!  containing information about input forcing files. Notice that       !
!  Mgrids is passed for flexibility in coupling algorithms.            !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Nval       Number of values processed (integer)                  !
!     Fname      File name(s) processed (string array)                 !
!     Fdim       File name(s) dimension in calling program (integer)   !
!     line       Current input line (string)                           !
!     label      I/O structure label (string)                          !
!     ifile      File structure counter (integer)                      !
!     igrid      Nested grid counter (integer)                         !
!     Mgrids     Number of nested grids (integer)                      !
!     Nfiles     Number of input files per grid (integer vector)       !
!     Ncount     Number of files per grid counter (integer array)      !
!     idim       Size of structure inner dimension (integer)           !
!     io_type    File I/O type (integer)                               !
!     S          Derived type structure, TYPE(T_IO)                    !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     ifile      Updated file counter.                                 !
!     igrid      Updated nested grid counter.                          !
!     S          Updated derived type structure, TYPE(T_IO).           !
!     load_s2d   Number of output values processed.                    !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer, intent(in)    :: mgrids, nval, fdim, idim, io_type
      integer, intent(in)    :: nfiles(mgrids)
      integer, intent(inout) :: ifile, igrid
      integer, intent(inout) :: ncount(idim,mgrids)
!
      character (len=*),   intent(in) :: line
      character (len=256), intent(in) :: fname(fdim)
      character (len=*),   intent(inout) :: label
!
      TYPE(t_io), intent(inout) :: s(idim,mgrids)
!
!  Local variable declarations.
!
      logical :: load, persist
!
      integer :: icont, ipipe, i, is, j, k, lstr, my_mgrids, ng
      integer :: load_s2d
!
      character (len=1 ), parameter :: blank = ' '
!
!-----------------------------------------------------------------------
!  Count files for all grids and activate load switch.
!-----------------------------------------------------------------------
!
!  Check current line for the continuation symbol [char(92)=\] or pipe
!  symbol [char(124)=|]. The continuation symbol is used to separate
!  string values for different grid, whereas the pipe symbol is used
!  to separate multi-string values for split input files. User may
!  split the records for a particular input field into several files.
!
      icont=index(trim(line),char(92) ,back=.false.)
      ipipe=index(trim(line),char(124),back=.false.)
      IF ((icont.eq.0).and.(ipipe.eq.0)) THEN
        load=.true.                           ! last input string
      ELSE
        load=.false.                          ! process next string
      END IF
!
!  Accumulate number of multi-files per each grid.
!
      ncount(ifile,igrid)=ncount(ifile,igrid)+1
!
!  Set counters for next processing file, if any.  The continuation
!  symbol in the input "line" is used to advance the counters.
!
      IF (.not.load) THEN
        IF ((ifile.lt.nfiles(igrid)).or.(ipipe.ne.0)) THEN
          ifile=ifile+min(1,icont)
        ELSE
          ifile=1
          igrid=igrid+min(1,icont)
        END IF
      END IF
      IF (ifile.gt.idim) THEN
        IF (master) THEN
          WRITE (stdout,10) trim(line)
        END IF
        exit_flag=2
        RETURN
      END IF
      IF (igrid.gt.mgrids) THEN
        IF (master) THEN
          WRITE (stdout,20) trim(line)
        END IF
        exit_flag=2
        RETURN
      END IF
!
!-----------------------------------------------------------------------
!  Load I/O information into structure.
!-----------------------------------------------------------------------
!
      IF (load) THEN
!
!  If nesting and the number of file name entries is less than Mgrids,
!  persist the last values provided.  This is the case when not enough
!  entries are provided by "==" plural symbol after the KEYWORD.
!
        IF (igrid.lt.mgrids) THEN
          DO j=igrid+1,mgrids
            DO i=1,idim
              ncount(i,j)=ncount(i,igrid)
            END DO
          END DO
          my_mgrids=igrid
          persist=.true.
        ELSE
          my_mgrids=mgrids
          persist=.false.
        END IF
!
!  Allocate various fields in structure, if not continuation or pipe
!  symbol is found which indicates end of input data.
!
        DO ng=1,mgrids
          DO i=1,idim
            allocate ( s(i,ng)%Nrec(ncount(i,ng)) )
            allocate ( s(i,ng)%time_min(ncount(i,ng)) )
            allocate ( s(i,ng)%time_max(ncount(i,ng)) )
            allocate ( s(i,ng)%Vid(nv) )
            allocate ( s(i,ng)%Tid(mt) )
#if defined PIO_LIB && defined DISTRIBUTE
            allocate ( s(i,ng)%pioVar(nv) )
            allocate ( s(i,ng)%pioTrc(mt) )
#endif
            allocate ( s(i,ng)%files(ncount(i,ng)) )
          END DO
        END DO
!
!  Intialize strings to blank to facilitate processing.
!
        DO ng=1,mgrids
          DO i=1,idim
            lstr=len(s(i,ng)%name)
            DO j=1,lstr
              s(i,ng)%head(j:j)=blank
              s(i,ng)%base(j:j)=blank
              s(i,ng)%name(j:j)=blank
            END DO
            DO k=1,ncount(i,ng)
              DO j=1,lstr
                s(i,ng)%files(k)(j:j)=blank
              END DO
            END DO
          END DO
        END DO
!
!  Initialize and load fields into structure.
!
        k=0
        DO ng=1,my_mgrids
          DO i=1,nfiles(ng)
            s(i,ng)%IOtype=io_type              ! file IO type
            s(i,ng)%Nfiles=ncount(i,ng)         ! number of multi-files
            s(i,ng)%Fcount=1                    ! multi-file counter
            s(i,ng)%load=1                      ! filename load counter
            s(i,ng)%Rindex=0                    ! time index
            s(i,ng)%ncid=-1                     ! closed NetCDF state
            s(i,ng)%Vid=-1                      ! NetCDF variables IDs
            s(i,ng)%Tid=-1                      ! NetCDF tracers IDs
#if defined PIO_LIB && defined DISTRIBUTE
            s(i,ng)%pioFile%fh=-1               ! closed file handler
            DO j=1,nv
              s(i,ng)%pioVar(j)%vd%varID=-1     ! variables IDs
              s(i,ng)%pioVar(j)%dkind=-1        ! variables data kind
              s(i,ng)%pioVar(j)%gtype=0         ! variables C-grid type
            END DO
            DO j=1,mt
              s(i,ng)%pioTrc(j)%vd%varID=-1     ! tracers IDs
              s(i,ng)%pioTrc(j)%dkind=-1        ! tracers data kind
              s(i,ng)%pioTrc(j)%gtype=0         ! tracers C-grid type
            END DO
#endif
            DO j=1,ncount(i,ng)
              k=k+1
              s(i,ng)%files(j)=trim(fname(k))   ! load multi-files
              s(i,ng)%Nrec(j)=0                 ! record counter
              s(i,ng)%time_min(j)=0.0_dp        ! starting time
              s(i,ng)%time_max(j)=0.0_dp        ! ending time
            END DO
            s(i,ng)%label=trim(label)           ! structure label
            s(i,ng)%name=trim(s(i,ng)%files(1)) ! load first file
            lstr=len_trim(s(i,ng)%name)
            s(i,ng)%head=s(i,ng)%name(1:lstr-3) ! do not include ".nc"
            s(i,ng)%base=s(i,ng)%name(1:lstr-3) ! do not include ".nc"
          END DO
        END DO
!
!  If appropriate, persist last value(s).
!
        IF (persist) THEN
          DO ng=igrid+1,mgrids
            DO i=1,nfiles(ng)
              s(i,ng)%IOtype=io_type
              s(i,ng)%Nfiles=s(i,igrid)%Nfiles
              s(i,ng)%Fcount=1
              s(i,ng)%load=1
              s(i,ng)%Rindex=0
              s(i,ng)%ncid=-1
              s(i,ng)%Vid=-1
              s(i,ng)%Tid=-1
#if defined PIO_LIB && defined DISTRIBUTE
              s(i,ng)%pioFile%fh=-1
              DO j=1,nv
                s(i,ng)%pioVar(j)%vd%varID=-1
                s(i,ng)%pioVar(j)%dkind=-1
                s(i,ng)%pioVar(j)%gtype=0
              END DO
              DO j=1,mt
                s(i,ng)%pioTrc(j)%vd%varID=-1
                s(i,ng)%pioTrc(j)%dkind=-1
                s(i,ng)%pioTrc(j)%gtype=0
              END DO
#endif
              DO j=1,s(i,igrid)%Nfiles
                s(i,ng)%files(j)=s(i,igrid)%files(j)
                s(i,ng)%Nrec(j)=0
                s(i,ng)%time_min(j)=0.0_dp
                s(i,ng)%time_max(j)=0.0_dp
              END DO
              s(i,ng)%label=trim(label)
              s(i,ng)%head=s(i,igrid)%head
              s(i,ng)%base=s(i,igrid)%base
              s(i,ng)%name=s(i,igrid)%name
              ncount(i,ng)=0
            END DO
          END DO
        END IF
!
!  Reset counters and clean label.
!
        igrid=1
        ifile=1
        DO ng=1,mgrids
          DO i=1,idim
            ncount(i,ng)=0
          END DO
        END DO
        DO i=1,len(label)
          label(i:i)=blank
        END DO
      END IF
      load_s2d=nval
 
 10   FORMAT (/,' LOAD_S2D - incorrect continuation symbol in line:',/, &
     &        12x,a,/,12x,'inner dimension of structure exceeded.')
 20   FORMAT (/,' LOAD_S2D - incorrect continuation symbol in line:',/, &
     &        12x,a,/,12x,'number of nested grid values exceeded.')
!
      RETURN
      END FUNCTION load_s2d
!
#ifdef SOLVE3D
      FUNCTION load_tadv (Ninp, Vinp, line, nline, itrc, igrid,         &
     &                    itracer, iTrcStr, iTrcEnd, svname, S)
!
!***********************************************************************
!                                                                      !
!  This function sets tracers advection logical switches according to  !
!  input string keywords.                                              !
!                                                                      !
!  On Input:                                                           !
!                                                                      !
!     Ninp       Size of input variable (integer)                      !
!     Vinp       Input values (string)                                 !
!     line       Current input line (string)                           !
!     nline      Multi-line counter (integer)                          !
!     itrc       Tracer array index (integer)                          !
!     itracer    Calling routine tracer counter (integer)              !
!     igrid      Nested grid counter (integer)                         !
!     iTrcStr    Starting tracer index to process (integer)            !
!     iTrcEnd    Ending   tracer index to process (integer)            !
!     svname     State variable name (string)                          !
!     S          Derived type structure, TYPE(T_ADV)                   !
!                                                                      !
!  On Output:                                                          !
!                                                                      !
!     nline      Updated multi-line counter (integer)                  !
!     itracer    Updated calling routine tracer counter (integer)      !
!     igrid      Updated nested grid counter (integer)                 !
!     S          Updated derived type structure, TYPE(T_LBC)           !
!     load_tadv  Number of output values processed.                    !
!                                                                      !
!***********************************************************************
!
!  Imported variable declarations.
!
      integer, intent(in) :: ninp, itrc, itrcstr, itrcend
      integer, intent(inout) :: igrid, itracer, nline
 
      character (len=256), intent(in) :: line
      character (len=256), intent(in) :: vinp(ninp)
      character (len=*  ), intent(in) :: svname
 
      TYPE(t_adv), intent(inout) :: s(maxval(nt),ngrids)
!
!  Local variable declarations.
!
      integer :: icont, i, ic
      integer :: load_tadv
 
      character (len=10) :: astring, string
!
!-----------------------------------------------------------------------
!  Set tracers advection switches in structure.
!-----------------------------------------------------------------------
!
!  Check current line for the continuation symbol [char(92)=\].
!
      icont=index(trim(line),char(92) ,back=.false.)
!
!  Extract tracer advection scheme keywords from Vinp. Notice that
!  additional array elements are added to Vinp during continuation
!  lines.
!
      i=nline
      astring=trim(vinp(i+1))
!
!  Advance or reset entry lines counter.
!
      IF (icont.gt.0) THEN
        nline=nline+1
      ELSE
        nline=0
      END IF
!
!  Set advection switches for each tracer.
!
      ic=1
      IF ((0.lt.itrc).and.(itrc.le.itrcend)) THEN
        string=uppercase(astring)
        SELECT CASE (trim(string))
          CASE ('A4', 'AKIMA4')
            s(itrc,igrid) % AKIMA4 = .true.
          CASE ('C2', 'CENTERED2')
            s(itrc,igrid) % CENTERED2 = .true.
          CASE ('C4', 'CENTERED4')
            s(itrc,igrid) % CENTERED4 = .true.
          CASE ('HS', 'HSIMT')
            s(itrc,igrid) % HSIMT = .true.
          CASE ('MP', 'MPDATA')
            s(itrc,igrid) % MPDATA = .true.
          CASE ('SP', 'SPLINES')
            s(itrc,igrid) % SPLINES = .true.
          CASE ('SU', 'SU3', 'SPLIT_U3')
            s(itrc,igrid) % SPLIT_U3 = .true.
          CASE ('U3', 'UPSTREAM3')
            s(itrc,igrid) % UPSTREAM3 = .true.
          CASE DEFAULT
            IF (master) THEN
              WRITE (stdout,10) trim(astring)
            END IF
            exit_flag=2
            RETURN
        END SELECT
!
!  If processing tracers and last standard input entry (Icont=0), set
!  unspecified tracer values to the last tracer entry.
!
        IF ((itrcstr.gt.0).and.(itrcend.gt.0)) THEN
          IF ((icont.eq.0).and.(itracer.lt.itrcend)) THEN
            DO i=itrc+1,itrcend
              s(i,igrid) % AKIMA4    = s(itrc,igrid) % AKIMA4
              s(i,igrid) % CENTERED2 = s(itrc,igrid) % CENTERED2
              s(i,igrid) % CENTERED4 = s(itrc,igrid) % CENTERED4
              s(i,igrid) % HSIMT     = s(itrc,igrid) % HSIMT
              s(i,igrid) % MPDATA    = s(itrc,igrid) % MPDATA
              s(i,igrid) % SPLINES   = s(itrc,igrid) % SPLINES
              s(i,igrid) % SPLIT_U3  = s(itrc,igrid) % SPLIT_U3
              s(i,igrid) % UPSTREAM3 = s(itrc,igrid) % UPSTREAM3
            END DO
            ic=ic+1
          END IF
        END IF
      END IF
!
!  If appropriate, reset tracer grid counter.  It is done to process
!  other keywords using this function.
!
      IF ((itrc.eq.itrcend).or.(ic.gt.1)) THEN
        itracer=0
      END IF
!
!  If appropriate, increase or reset nested grid counter.
!
      IF ((icont.gt.0).and.(ngrids.gt.1)) THEN
        IF ((itrcstr.gt.0).and.(itrcend.gt.0)) THEN
          IF ((itrc.eq.itrcend).or.(ic.gt.1)) THEN
            igrid=igrid+min(1,icont)
          END IF
        ELSE
          igrid=igrid+min(1,icont)
        END IF
        IF (igrid.gt.ngrids) THEN
          IF (master) THEN
            WRITE (stdout,20) trim(line)
          END IF
          exit_flag=2
          RETURN
        END IF
      ELSE
        igrid=1
      END IF
      load_tadv=ic
 
 10   FORMAT (/,' LOAD_TADV - illegal tracer advection scheme ',        &
     &        'keyword: ',a,/,13x,'Correct standard input file.',/)
 20   FORMAT (/,' LOAD_TADV - incorrect continuation symbol in line:',  &
     &        /,13x,a,/,13x,'number of nested grid values exceeded.')
!
      RETURN
      END FUNCTION load_tadv
#endif
!
      END MODULE inp_decode_mod