inp_decode_mod::load_l Interface Reference

Public Member Functions
integer function	load_0d_l (ninp, vinp, nout, vout)
integer function	load_1d_l (ninp, vinp, nout, vout)
integer function	load_2d_l (ninp, vinp, iout, jout, vout)
integer function	load_3d_l (ninp, vinp, iout, jout, kout, vout)

Detailed Description

Definition at line 64 of file inp_decode.F.

Member Function/Subroutine Documentation

load_0d_l()

integer function inp_decode_mod::load_l::load_0d_l	(	integer, intent(in)	ninp,
		character (len=*), dimension(:), intent(in)	vinp,
		integer, intent(in)	nout,
		logical, intent(out)	vout )

Definition at line 717 of file inp_decode.F.

!
!***********************************************************************
!                                                                      !
!  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

load_1d_l()

integer function inp_decode_mod::load_l::load_1d_l	(	integer, intent(in)	ninp,
		character (len=*), dimension(:), intent(in)	vinp,
		integer, intent(in)	nout,
		logical, dimension(:), intent(out)	vout )

Definition at line 765 of file inp_decode.F.

!
!***********************************************************************
!                                                                      !
!  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

References mod_param::nstr.

load_2d_l()

integer function inp_decode_mod::load_l::load_2d_l	(	integer, intent(in)	ninp,
		character (len=*), dimension(:), intent(in)	vinp,
		integer, intent(in)	iout,
		integer, intent(in)	jout,
		logical, dimension(:,:), intent(out)	vout )

Definition at line 841 of file inp_decode.F.

!
!***********************************************************************
!                                                                      !
!  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

References mod_param::nstr.

load_3d_l()

integer function inp_decode_mod::load_l::load_3d_l	(	integer, intent(in)	ninp,
		character (len=*), dimension(:), intent(in)	vinp,
		integer, intent(in)	iout,
		integer, intent(in)	jout,
		integer, intent(in)	kout,
		logical, dimension(:,:,:), intent(out)	vout )

Definition at line 922 of file inp_decode.F.

!
!***********************************************************************
!                                                                      !
!  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

References mod_param::nstr.

---

The documentation for this interface was generated from the following file:

• ROMS/Utility/inp_decode.F